# eigenfunctions from target intermediate system ("_ti")
eig_freq_ti = np.sqrt((a0_ti - eig_val) / a2)
eig_funcs_ti = np.array([ef.SecondOrderRobinEigenfunction(eig_freq_ti[i],
                                                          param_ti,
                                                          spatial_domain.bounds,
                                                          eig_funcs_i[i](0))
                         for i in range(n)])

# create test-functions
nodes, fem_funcs = sh.cure_interval(sh.LagrangeFirstOrder,
                                    spatial_domain.bounds,
                                    node_count=len(spatial_domain))

# register functions
re.register_base("adjoint_eig_funcs", adjoint_eig_funcs, overwrite=True)
re.register_base("eig_funcs", eig_funcs, overwrite=True)
re.register_base("eig_funcs_i", eig_funcs_i, overwrite=True)
re.register_base("eig_funcs_ti", eig_funcs_ti, overwrite=True)
re.register_base("fem_funcs", fem_funcs, overwrite=True)

# original intermediate (_i), target intermediate (_ti) and fem field variable
fem_field_variable = ph.FieldVariable("fem_funcs", location=l)
field_variable_i = ph.FieldVariable("eig_funcs_i", weight_label="eig_funcs", location=l)
d_field_variable_i = ph.SpatialDerivedFieldVariable("eig_funcs_i", 1, weight_label="eig_funcs", location=l)
field_variable_ti = ph.FieldVariable("eig_funcs_ti", weight_label="eig_funcs", location=l)
d_field_variable_ti = ph.SpatialDerivedFieldVariable("eig_funcs_ti", 1, weight_label="eig_funcs", location=l)

# intermediate (_i) and target intermediate (_ti) field variable (list of scalar terms = sum of scalar terms)
x_i_at_l = [ph.ScalarTerm(field_variable_i)]
xd_i_at_l = [ph.ScalarTerm(d_field_variable_i)]
# eigenfunctions from target intermediate system ("_ti")
eig_freq_ti = np.sqrt((a0_ti - eig_val) / a2)
eig_funcs_ti = np.array([
    ef.SecondOrderRobinEigenfunction(eig_freq_ti[i], param_ti,
                                     spatial_domain.bounds, eig_funcs_i[i](0))
    for i in range(n)
])

# create test-functions
nodes, fem_funcs = sh.cure_interval(sh.LagrangeFirstOrder,
                                    spatial_domain.bounds,
                                    node_count=len(spatial_domain))

# register functions
re.register_base("adjoint_eig_funcs", adjoint_eig_funcs, overwrite=True)
re.register_base("eig_funcs", eig_funcs, overwrite=True)
re.register_base("eig_funcs_i", eig_funcs_i, overwrite=True)
re.register_base("eig_funcs_ti", eig_funcs_ti, overwrite=True)
re.register_base("fem_funcs", fem_funcs, overwrite=True)

# original intermediate (_i), target intermediate (_ti) and fem field variable
fem_field_variable = ph.FieldVariable("fem_funcs", location=l)
field_variable_i = ph.FieldVariable("eig_funcs_i",
                                    weight_label="eig_funcs",
                                    location=l)
d_field_variable_i = ph.SpatialDerivedFieldVariable("eig_funcs_i",
                                                    1,
                                                    weight_label="eig_funcs",
                                                    location=l)
field_variable_ti = ph.FieldVariable("eig_funcs_ti",
Exemple #3
0
# system/simulation parameters
actuation_type = 'dirichlet'
bound_cond_type = 'dirichlet'
l = 1  # attention: only l=1. supported in this test case
T = 1
spatial_domain = sim.Domain(bounds=(0, l), num=30)
temporal_domain = sim.Domain(bounds=(0, T), num=1e2)
n = n_modal

# eigenvalues /-functions original system
eig_freq = np.array([(i + 1) * np.pi / l for i in xrange(n)])
eig_values = a0 - a2 * eig_freq ** 2 - a1 ** 2 / 4. / a2
norm_fac = np.ones(eig_freq.shape) * np.sqrt(2)
eig_funcs = np.asarray(
    [ef.SecondOrderDirichletEigenfunction(eig_freq[i], param, spatial_domain.bounds, norm_fac[i]) for i in range(n)])
re.register_base("eig_funcs", eig_funcs, overwrite=True)

# eigenfunctions target system
eig_freq_t = np.sqrt(-eig_values.astype(complex))
norm_fac_t = norm_fac * eig_freq / eig_freq_t
eig_funcs_t = np.asarray(
    [ef.SecondOrderDirichletEigenfunction(eig_freq_t[i], param_t, spatial_domain.bounds, norm_fac_t[i]) for i in
     range(n)])
re.register_base("eig_funcs_t", eig_funcs_t, overwrite=True)

# init controller
x_at_1 = ph.FieldVariable("eig_funcs", location=1)
xt_at_1 = ph.FieldVariable("eig_funcs_t", weight_label="eig_funcs", location=1)
controller = ct.Controller(ct.ControlLaw([ph.ScalarTerm(x_at_1, 1), ph.ScalarTerm(xt_at_1, -1)]))

# derive initial field variable x(z,0) and weights
eig_funcs = np.array([f_tuple[0] for f_tuple in adjoint_and_eig_funcs])
adjoint_eig_funcs = np.array([f_tuple[1] for f_tuple in adjoint_and_eig_funcs])

# eigenfunctions from target system ("_t")
eig_freq_t = np.sqrt(-a1_t ** 2 / 4 / a2 ** 2 + (a0_t - eig_val) / a2)
eig_funcs_t = np.array(
    [ef.SecondOrderRobinEigenfunction(eig_freq_t[i], param_t, spatial_domain.bounds).scale(eig_funcs[i](0))
     for i in range(n)])

# create fem test functions
nodes, fem_funcs = sh.cure_interval(sh.LagrangeFirstOrder,
                                    spatial_domain.bounds,
                                    node_count=len(spatial_domain))

# register eigenfunctions
re.register_base("eig_funcs", eig_funcs, overwrite=True)
re.register_base("adjoint_eig_funcs", adjoint_eig_funcs, overwrite=True)
re.register_base("eig_funcs_t", eig_funcs_t, overwrite=True)
re.register_base("fem_funcs", fem_funcs, overwrite=True)

# original () and target (_t) field variable
fem_field_variable = ph.FieldVariable("fem_funcs", location=l)
field_variable = ph.FieldVariable("eig_funcs", location=l)
d_field_variable = ph.SpatialDerivedFieldVariable("eig_funcs", 1, location=l)
field_variable_t = ph.FieldVariable("eig_funcs_t", weight_label="eig_funcs", location=l)
d_field_variable_t = ph.SpatialDerivedFieldVariable("eig_funcs_t", 1, weight_label="eig_funcs", location=l)


def transform_i(z):
    """
    intermediate (_i) transformation at z=l
# system/simulation parameters
actuation_type = 'dirichlet'
bound_cond_type = 'dirichlet'
l = 1  # attention: only l=1. supported in this test case
T = 1
spatial_domain = sim.Domain(bounds=(0, l), num=30)
temporal_domain = sim.Domain(bounds=(0, T), num=1e2)
n = n_modal

# eigenvalues /-functions original system
eig_freq = np.array([(i + 1) * np.pi / l for i in range(n)])
eig_values = a0 - a2 * eig_freq ** 2 - a1 ** 2 / 4. / a2
norm_fac = np.ones(eig_freq.shape) * np.sqrt(2)
eig_funcs = np.asarray(
    [ef.SecondOrderDirichletEigenfunction(eig_freq[i], param, spatial_domain.bounds, norm_fac[i]) for i in range(n)])
re.register_base("eig_funcs", eig_funcs, overwrite=True)

# eigenfunctions target system
eig_freq_t = np.sqrt(-eig_values.astype(complex))
norm_fac_t = norm_fac * eig_freq / eig_freq_t
eig_funcs_t = np.asarray(
    [ef.SecondOrderDirichletEigenfunction(eig_freq_t[i], param_t, spatial_domain.bounds, norm_fac_t[i]) for i in
     range(n)])
re.register_base("eig_funcs_t", eig_funcs_t, overwrite=True)

# init controller
x_at_1 = ph.FieldVariable("eig_funcs", location=1)
xt_at_1 = ph.FieldVariable("eig_funcs_t", weight_label="eig_funcs", location=1)
controller = ct.Controller(ct.ControlLaw([ph.ScalarTerm(x_at_1, 1), ph.ScalarTerm(xt_at_1, -1)]))

# derive initial field variable x(z,0) and weights
Exemple #6
0
eig_funcs = np.array([f_tuple[0] for f_tuple in adjoint_and_eig_funcs])
adjoint_eig_funcs = np.array([f_tuple[1] for f_tuple in adjoint_and_eig_funcs])

# eigenfunctions from target system ("_t")
eig_freq_t = np.sqrt(-a1_t ** 2 / 4 / a2 ** 2 + (a0_t - eig_val) / a2)
eig_funcs_t = np.array(
    [ef.SecondOrderRobinEigenfunction(eig_freq_t[i], param_t, spatial_domain.bounds).scale(eig_funcs[i](0))
     for i in range(n)])

# create fem test functions
nodes, fem_funcs = sh.cure_interval(sh.LagrangeFirstOrder,
                                    spatial_domain.bounds,
                                    node_count=len(spatial_domain))

# register eigenfunctions
re.register_base("eig_funcs", eig_funcs, overwrite=True)
re.register_base("adjoint_eig_funcs", adjoint_eig_funcs, overwrite=True)
re.register_base("eig_funcs_t", eig_funcs_t, overwrite=True)
re.register_base("fem_funcs", fem_funcs, overwrite=True)

# original () and target (_t) field variable
fem_field_variable = ph.FieldVariable("fem_funcs", location=l)
field_variable = ph.FieldVariable("eig_funcs", location=l)
d_field_variable = ph.SpatialDerivedFieldVariable("eig_funcs", 1, location=l)
field_variable_t = ph.FieldVariable("eig_funcs_t", weight_label="eig_funcs", location=l)
d_field_variable_t = ph.SpatialDerivedFieldVariable("eig_funcs_t", 1, weight_label="eig_funcs", location=l)


def transform_i(z):
    """
    intermediate (_i) transformation at z=l