示例#1
0
    def test_projection_on_lag1st(self):
        weights = []

        # convenience wrapper for non array input -> constant function
        weight = core.project_on_base(self.funcs[0], self.initial_functions[1])
        self.assertAlmostEqual(weight, 1.5*self.funcs[0](self.nodes[1]))

        # linear function -> should be fitted exactly
        weights.append(core.project_on_base(self.funcs[1], self.initial_functions))
        self.assertTrue(np.allclose(weights[-1], self.funcs[1](self.nodes)))

        # quadratic function -> should be fitted somehow close
        weights.append(core.project_on_base(self.funcs[2], self.initial_functions))
        self.assertTrue(np.allclose(weights[-1], self.funcs[2](self.nodes), atol=.5))

        # trig function -> will be crappy
        weights.append(core.project_on_base(self.funcs[3], self.initial_functions))

        if show_plots:
            # since test function are lagrange1st order, plotting the results is fairly easy
            for idx, w in enumerate(weights):
                pw = pg.plot(title="Weights {0}".format(idx))
                pw.plot(x=self.z_values, y=self.real_values[idx+1], pen="r")
                pw.plot(x=self.nodes, y=w, pen="b")
                app.exec_()
示例#2
0
    def test_it(self):
        actuation_type = 'robin'
        bound_cond_type = 'robin'
        param = [2., 1.5, -3., -1., -.5]
        adjoint_param = ef.get_adjoint_rad_evp_param(param)
        a2, a1, a0, alpha, beta = param

        l = 1.
        spatial_disc = 10
        dz = sim.Domain(bounds=(0, l), num=spatial_disc)

        T = 1.
        temporal_disc = 1e2
        dt = sim.Domain(bounds=(0, T), num=temporal_disc)
        n = 10

        eig_freq, eig_val = ef.compute_rad_robin_eigenfrequencies(param, l, n)

        init_eig_funcs = np.array([ef.SecondOrderRobinEigenfunction(om, param, dz.bounds) for om in eig_freq])
        init_adjoint_eig_funcs = np.array([ef.SecondOrderRobinEigenfunction(om, adjoint_param, dz.bounds)
                                           for om in eig_freq])

        # normalize eigenfunctions and adjoint eigenfunctions
        adjoint_and_eig_funcs = [cr.normalize_function(init_eig_funcs[i], init_adjoint_eig_funcs[i]) for i in range(n)]
        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])

        # register eigenfunctions
        register_base("eig_funcs", eig_funcs, overwrite=True)
        register_base("adjoint_eig_funcs", adjoint_eig_funcs, overwrite=True)

        # derive initial field variable x(z,0) and weights
        start_state = cr.Function(lambda z: 0., domain=(0, l))
        initial_weights = cr.project_on_base(start_state, adjoint_eig_funcs)

        # init trajectory
        u = tr.RadTrajectory(l, T, param, bound_cond_type, actuation_type)

        # determine (A,B) with weak-formulation (pyinduct)
        rad_pde = ut.get_parabolic_robin_weak_form("eig_funcs", "adjoint_eig_funcs", u, param, dz.bounds)
        cf = sim.parse_weak_formulation(rad_pde)
        ss_weak = cf.convert_to_state_space()

        # determine (A,B) with modal-transfomation
        A = np.diag(np.real_if_close(eig_val))
        B = a2*np.array([adjoint_eig_funcs[i](l) for i in xrange(len(eig_freq))])
        ss_modal = sim.StateSpace("eig_funcs", A, B)

        # check if ss_modal.(A,B) is close to ss_weak.(A,B)
        self.assertTrue(np.allclose(np.sort(np.linalg.eigvals(ss_weak.A)), np.sort(np.linalg.eigvals(ss_modal.A)),
                                    rtol=1e-05, atol=0.))
        self.assertTrue(np.allclose(np.array([i[0] for i in ss_weak.B]), ss_modal.B))

        # display results
        if show_plots:
            t, q = sim.simulate_state_space(ss_modal, u, initial_weights, dt)
            eval_d = ut.evaluate_approximation("eig_funcs", q, t, dz, spat_order=1)
            win1 = vis.PgAnimatedPlot([eval_d], title="Test")
            win2 = vis.PgSurfacePlot(eval_d[0])
            app.exec_()
示例#3
0
    def test_it(self):
        actuation_type = 'dirichlet'
        bound_cond_type = 'dirichlet'
        param = [1., -2., -1., None, None]
        adjoint_param = ef.get_adjoint_rad_evp_param(param)
        a2, a1, a0, _, _ = param

        l = 1.
        spatial_disc = 10
        dz = sim.Domain(bounds=(0, l), num=spatial_disc)

        T = 1.
        temporal_disc = 1e2
        dt = sim.Domain(bounds=(0, T), num=temporal_disc)

        omega = np.array([(i+1)*np.pi/l for i in xrange(spatial_disc)])
        eig_values = a0 - a2*omega**2 - a1**2/4./a2
        norm_fak = np.ones(omega.shape)*np.sqrt(2)
        eig_funcs = np.array([ef.SecondOrderDirichletEigenfunction(omega[i], param, dz.bounds, norm_fak[i])
                              for i in range(spatial_disc)])
        register_base("eig_funcs", eig_funcs, overwrite=True)
        adjoint_eig_funcs = np.array([ef.SecondOrderDirichletEigenfunction(omega[i],
                                                                           adjoint_param,
                                                                           dz.bounds,
                                                                           norm_fak[i]) for i in range(spatial_disc)])
        register_base("adjoint_eig_funcs", adjoint_eig_funcs, overwrite=True)

        # derive initial field variable x(z,0) and weights
        start_state = cr.Function(lambda z: 0., domain=(0, l))
        initial_weights = cr.project_on_base(start_state, adjoint_eig_funcs)

        # init trajectory
        u = tr.RadTrajectory(l, T, param, bound_cond_type, actuation_type)

        # determine (A,B) with weak-formulation (pyinduct)

        # derive sate-space system
        rad_pde = ut.get_parabolic_dirichlet_weak_form("eig_funcs", "adjoint_eig_funcs", u, param, dz.bounds)
        cf = sim.parse_weak_formulation(rad_pde)
        ss_weak = cf.convert_to_state_space()

        # determine (A,B) with modal-transfomation
        A = np.diag(eig_values)
        B = -a2*np.array([adjoint_eig_funcs[i].derive()(l) for i in xrange(spatial_disc)])
        ss_modal = sim.StateSpace("eig_funcs", A, B)

        # TODO: resolve the big tolerance (rtol=3e-01) between ss_modal.A and ss_weak.A
        # check if ss_modal.(A,B) is close to ss_weak.(A,B)
        self.assertTrue(np.allclose(np.sort(np.linalg.eigvals(ss_weak.A)), np.sort(np.linalg.eigvals(ss_modal.A)),
                                    rtol=3e-1, atol=0.))
        self.assertTrue(np.allclose(np.array([i[0] for i in ss_weak.B]), ss_modal.B))

        # display results
        if show_plots:
            t, q = sim.simulate_state_space(ss_modal, u, initial_weights, dt)
            eval_d = ut.evaluate_approximation("eig_funcs", q, t, dz, spat_order=1)
            win2 = vis.PgSurfacePlot(eval_d)
            app.exec_()
示例#4
0
    def test_fem(self):
        """
        use best documented fem case to test all steps in simulation process
        """

        # enter string with mass equations
        nodes, ini_funcs = pyinduct.shapefunctions.cure_interval(pyinduct.shapefunctions.LagrangeSecondOrder,
                                                                 self.dz.bounds, node_count=10)
        register_base("init_funcs", ini_funcs, overwrite=True)
        int1 = ph.IntegralTerm(
            ph.Product(ph.TemporalDerivedFieldVariable("init_funcs", 2),
                       ph.TestFunction("init_funcs")), self.dz.bounds, scale=self.params.sigma*self.params.tau**2)
        s1 = ph.ScalarTerm(
            ph.Product(ph.TemporalDerivedFieldVariable("init_funcs", 2, location=0),
                       ph.TestFunction("init_funcs", location=0)), scale=self.params.m)
        int2 = ph.IntegralTerm(
            ph.Product(ph.SpatialDerivedFieldVariable("init_funcs", 1),
                       ph.TestFunction("init_funcs", order=1)), self.dz.bounds, scale=self.params.sigma)
        s2 = ph.ScalarTerm(
            ph.Product(ph.Input(self.u), ph.TestFunction("init_funcs", location=1)), -self.params.sigma)

        # derive sate-space system
        string_pde = sim.WeakFormulation([int1, s1, int2, s2], name="fem_test")
        self.cf = sim.parse_weak_formulation(string_pde)
        ss = self.cf.convert_to_state_space()

        # generate initial conditions for weights
        q0 = np.array([cr.project_on_base(self.ic[idx], ini_funcs) for idx in range(2)]).flatten()

        # simulate
        t, q = sim.simulate_state_space(ss, self.cf.input_function, q0, self.dt)

        # calculate result data
        eval_data = []
        for der_idx in range(2):
            eval_data.append(
                ut.evaluate_approximation("init_funcs", q[:, der_idx * ini_funcs.size:(der_idx + 1) * ini_funcs.size],
                                          t, self.dz))
            eval_data[-1].name = "{0}{1}".format(self.cf.name, "_"+"".join(["d" for x in range(der_idx)])
                                                               + "t" if der_idx > 0 else "")

        # display results
        if show_plots:
            win = vis.PgAnimatedPlot(eval_data[:2], title="fem approx and derivative")
            win2 = vis.PgSurfacePlot(eval_data[0])
            app.exec_()

        # test for correct transition
        self.assertTrue(np.isclose(eval_data[0].output_data[-1, 0], self.y_end, atol=1e-3))

        # TODO dump in pyinduct/tests/ressources
        file_path = os.sep.join(["resources", "test_data.res"])
        if not os.path.isdir("resources"):
            os.makedirs("resources")
        with open(file_path, "w") as f:
            f.write(dumps(eval_data))
示例#5
0
    def setUp(self):
        # real function
        self.z_values = np.linspace(0, 1, 1000)
        self.real_func = core.Function(lambda x: x)
        self.real_func_handle = np.vectorize(self.real_func)

        # approximation by lag1st
        self.nodes, self.src_test_funcs = shapefunctions.cure_interval(shapefunctions.LagrangeFirstOrder, (0, 1),
                                                                       node_count=2)
        register_base("test_funcs", self.src_test_funcs, overwrite=True)
        self.src_weights = core.project_on_base(self.real_func, self.src_test_funcs)
        self.assertTrue(np.allclose(self.src_weights, [0, 1]))  # just to be sure
        self.src_approx_handle = core.back_project_from_base(self.src_weights, self.src_test_funcs)

        # approximation by sin(w*x)
        def trig_factory(freq):
            def func(x):
                return np.sin(freq*x)
            return func
        self.trig_test_funcs = np.array([core.Function(trig_factory(w), domain=(0, 1)) for w in range(1, 3)])
示例#6
0
    def test_it(self):
        # original system parameters
        a2 = 1.5;
        a1 = 2.5;
        a0 = 28;
        alpha = -2;
        beta = -3
        param = [a2, a1, a0, alpha, beta]
        adjoint_param = ef.get_adjoint_rad_evp_param(param)

        # target system parameters (controller parameters)
        a1_t = -5;
        a0_t = -25;
        alpha_t = 3;
        beta_t = 2
        # a1_t = a1; a0_t = a0; alpha_t = alpha; beta_t = beta
        param_t = [a2, a1_t, a0_t, alpha_t, beta_t]

        # original intermediate ("_i") and traget intermediate ("_ti") system parameters
        _, _, a0_i, alpha_i, beta_i = ef.transform2intermediate(param)
        _, _, a0_ti, alpha_ti, beta_ti = ef.transform2intermediate(param_t)

        # system/simulation parameters
        actuation_type = 'robin'
        bound_cond_type = 'robin'
        self.l = 1.
        spatial_disc = 10
        dz = sim.Domain(bounds=(0, self.l), num=spatial_disc)

        T = 1.
        temporal_disc = 1e2
        dt = sim.Domain(bounds=(0, T), num=temporal_disc)
        n = 10

        # create (not normalized) eigenfunctions
        eig_freq, eig_val = ef.compute_rad_robin_eigenfrequencies(param, self.l, n)
        init_eig_funcs = np.array([ef.SecondOrderRobinEigenfunction(om, param, dz.bounds) for om in eig_freq])
        init_adjoint_eig_funcs = np.array([ef.SecondOrderRobinEigenfunction(om, adjoint_param, dz.bounds)
                                           for om in eig_freq])

        # normalize eigenfunctions and adjoint eigenfunctions
        adjoint_and_eig_funcs = [cr.normalize_function(init_eig_funcs[i], init_adjoint_eig_funcs[i]) for i in range(n)]
        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, dz.bounds).scale(eig_funcs[i](0))
                                for i in range(n)])

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

        # derive initial field variable x(z,0) and weights
        start_state = cr.Function(lambda z: 0., domain=(0, self.l))
        initial_weights = cr.project_on_base(start_state, adjoint_eig_funcs)

        # controller initialization
        x_at_l = ph.FieldVariable("eig_funcs", location=self.l)
        xd_at_l = ph.SpatialDerivedFieldVariable("eig_funcs", 1, location=self.l)
        x_t_at_l = ph.FieldVariable("eig_funcs_t", weight_label="eig_funcs", location=self.l)
        xd_t_at_l = ph.SpatialDerivedFieldVariable("eig_funcs_t", 1, weight_label="eig_funcs", location=self.l)
        combined_transform = lambda z: np.exp((a1_t - a1) / 2 / a2 * z)
        int_kernel_zz = lambda z: alpha_ti - alpha_i + (a0_i - a0_ti) / 2 / a2 * z
        controller = ct.Controller(
            ct.ControlLaw([ph.ScalarTerm(x_at_l, (beta_i - beta_ti - int_kernel_zz(self.l))),
                           ph.ScalarTerm(x_t_at_l, -beta_ti * combined_transform(self.l)),
                           ph.ScalarTerm(x_at_l, beta_ti),
                           ph.ScalarTerm(xd_t_at_l, -combined_transform(self.l)),
                           ph.ScalarTerm(x_t_at_l, -a1_t / 2 / a2 * combined_transform(self.l)),
                           ph.ScalarTerm(xd_at_l, 1),
                           ph.ScalarTerm(x_at_l, a1 / 2 / a2 + int_kernel_zz(self.l))
                           ]))

        # init trajectory
        traj = tr.RadTrajectory(self.l, T, param_t, bound_cond_type, actuation_type)
        traj.scale = combined_transform(self.l)

        # input with feedback
        control_law = sim.SimulationInputSum([traj, controller])
        # control_law = sim.simInputSum([traj])

        # determine (A,B) with modal-transformation
        A = np.diag(np.real(eig_val))
        B = a2 * np.array([adjoint_eig_funcs[i](self.l) for i in range(len(eig_freq))])
        ss_modal = sim.StateSpace("eig_funcs", A, B, input_handle=control_law)

        # simulate
        t, q = sim.simulate_state_space(ss_modal, initial_weights, dt)

        eval_d = sim.evaluate_approximation("eig_funcs", q, t, dz)
        x_0t = eval_d.output_data[:, 0]
        yc, tc = tr.gevrey_tanh(T, 1)
        x_0t_desired = np.interp(t, tc, yc[0, :])
        self.assertLess(np.average((x_0t - x_0t_desired) ** 2), 1e-4)

        # display results
        if show_plots:
            win1 = vis.PgAnimatedPlot([eval_d], title="Test")
            win2 = vis.PgSurfacePlot(eval_d)
            app.exec_()
示例#7
0
    def test_it(self):
        # original system parameters
        a2 = 1
        a1 = 0  # attention: only a2 = 1., a1 =0 supported in this test case
        a0 = 0
        param = [a2, a1, a0, None, None]

        # target system parameters (controller parameters)
        a1_t = 0
        a0_t = 0  # attention: only a2 = 1., a1 =0 and a0 =0 supported in this test case
        param_t = [a2, a1_t, a0_t, None, None]

        # system/simulation parameters
        actuation_type = 'dirichlet'
        bound_cond_type = 'dirichlet'

        l = 1.
        spatial_disc = 10
        dz = sim.Domain(bounds=(0, l), num=spatial_disc)

        T = 1.
        temporal_disc = 1e2
        dt = sim.Domain(bounds=(0, T), num=temporal_disc)

        n = 10

        # 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, dz.bounds, norm_fac[i])
                                for i in range(n)])
        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, dz.bounds, norm_fac_t[i])
                                  for i in range(n)])
        register_base("eig_funcs_t", eig_funcs_t, overwrite=True)

        # derive initial field variable x(z,0) and weights
        start_state = cr.Function(lambda z: 0., domain=(0, l))
        initial_weights = cr.project_on_base(start_state, eig_funcs)

        # init trajectory / input of target system
        traj = tr.RadTrajectory(l, T, param_t, bound_cond_type, actuation_type)

        # 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)]))

        # input with feedback
        control_law = sim.SimulationInputSum([traj, controller])

        # determine (A,B) with modal-transfomation
        A = np.diag(eig_values)
        B = -a2 * np.array([eig_funcs[i].derive()(l) for i in range(n)])
        ss = sim.StateSpace("eig_funcs", A, B, input_handle=control_law)

        # simulate
        t, q = sim.simulate_state_space(ss, initial_weights, dt)

        eval_d = sim.evaluate_approximation("eig_funcs", q, t, dz)
        x_0t = eval_d.output_data[:, 0]
        yc, tc = tr.gevrey_tanh(T, 1)
        x_0t_desired = np.interp(t, tc, yc[0, :])
        self.assertLess(np.average((x_0t - x_0t_desired) ** 2), 0.5)

        # display results
        if show_plots:
            eval_d = sim.evaluate_approximation("eig_funcs", q, t, dz)
            win2 = vis.PgSurfacePlot(eval_d)
            app.exec_()
示例#8
0
# 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
start_state = cr.Function(lambda z: init_profile)
initial_weights = cr.project_on_base(start_state, eig_funcs)

# init trajectory
traj = tr.RadTrajectory(l, T, param_t, bound_cond_type, actuation_type)

# input with feedback
control_law = sim.SimulationInputSum([traj, controller])

# determine (A,B) with modal-transfomation
A = np.diag(eig_values)
B = -a2 * np.array([eig_funcs[i].derive()(l) for i in xrange(n)])
ss = sim.StateSpace("eig_funcs", A, B)

# evaluate desired output data
z_d = np.linspace(0, l, len(spatial_domain))
y_d, t_d = tr.gevrey_tanh(T, 80)
示例#9
0
# 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
start_state = cr.Function(lambda z: init_profile)
initial_weights = cr.project_on_base(start_state, eig_funcs)

# init trajectory
traj = tr.RadTrajectory(l, T, param_t, bound_cond_type, actuation_type)

# input with feedback
control_law = sim.SimulationInputSum([traj, controller])

# determine (A,B) with modal-transfomation
A = np.diag(eig_values)
B = -a2 * np.array([eig_funcs[i].derive()(l) for i in range(n)])
ss = sim.StateSpace("eig_funcs", A, B, input_handle=control_law)

# evaluate desired output data
z_d = np.linspace(0, l, len(spatial_domain))
y_d, t_d = tr.gevrey_tanh(T, 80)
示例#10
0
    def test_it(self):
        # original system parameters
        a2 = 1.5
        a1 = 2.5
        a0 = 28
        alpha = -2
        beta = -3
        param = [a2, a1, a0, alpha, beta]
        adjoint_param = ef.get_adjoint_rad_evp_param(param)

        # target system parameters (controller parameters)
        a1_t = -5
        a0_t = -25
        alpha_t = 3
        beta_t = 2
        # a1_t = a1; a0_t = a0; alpha_t = alpha; beta_t = beta
        param_t = [a2, a1_t, a0_t, alpha_t, beta_t]

        # original intermediate ("_i") and traget intermediate ("_ti") system parameters
        _, _, a0_i, alpha_i, beta_i = ef.transform2intermediate(param)
        _, _, a0_ti, alpha_ti, beta_ti = ef.transform2intermediate(param_t)

        # system/simulation parameters
        actuation_type = 'robin'
        bound_cond_type = 'robin'
        self.l = 1.
        spatial_disc = 10
        dz = sim.Domain(bounds=(0, self.l), num=spatial_disc)

        T = 1.
        temporal_disc = 1e2
        dt = sim.Domain(bounds=(0, T), num=temporal_disc)
        n = 10

        # create (not normalized) eigenfunctions
        eig_freq, eig_val = ef.compute_rad_robin_eigenfrequencies(
            param, self.l, n)
        init_eig_funcs = np.array([
            ef.SecondOrderRobinEigenfunction(om, param, dz.bounds)
            for om in eig_freq
        ])
        init_adjoint_eig_funcs = np.array([
            ef.SecondOrderRobinEigenfunction(om, adjoint_param, dz.bounds)
            for om in eig_freq
        ])

        # normalize eigenfunctions and adjoint eigenfunctions
        adjoint_and_eig_funcs = [
            cr.normalize_function(init_eig_funcs[i], init_adjoint_eig_funcs[i])
            for i in range(n)
        ]
        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,
                                             dz.bounds).scale(eig_funcs[i](0))
            for i in range(n)
        ])

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

        # derive initial field variable x(z,0) and weights
        start_state = cr.Function(lambda z: 0., domain=(0, self.l))
        initial_weights = cr.project_on_base(start_state, adjoint_eig_funcs)

        # controller initialization
        x_at_l = ph.FieldVariable("eig_funcs", location=self.l)
        xd_at_l = ph.SpatialDerivedFieldVariable("eig_funcs",
                                                 1,
                                                 location=self.l)
        x_t_at_l = ph.FieldVariable("eig_funcs_t",
                                    weight_label="eig_funcs",
                                    location=self.l)
        xd_t_at_l = ph.SpatialDerivedFieldVariable("eig_funcs_t",
                                                   1,
                                                   weight_label="eig_funcs",
                                                   location=self.l)
        combined_transform = lambda z: np.exp((a1_t - a1) / 2 / a2 * z)
        int_kernel_zz = lambda z: alpha_ti - alpha_i + (a0_i - a0_ti
                                                        ) / 2 / a2 * z
        controller = ct.Controller(
            ct.ControlLaw([
                ph.ScalarTerm(x_at_l,
                              (beta_i - beta_ti - int_kernel_zz(self.l))),
                ph.ScalarTerm(x_t_at_l, -beta_ti * combined_transform(self.l)),
                ph.ScalarTerm(x_at_l, beta_ti),
                ph.ScalarTerm(xd_t_at_l, -combined_transform(self.l)),
                ph.ScalarTerm(x_t_at_l,
                              -a1_t / 2 / a2 * combined_transform(self.l)),
                ph.ScalarTerm(xd_at_l, 1),
                ph.ScalarTerm(x_at_l, a1 / 2 / a2 + int_kernel_zz(self.l))
            ]))

        # init trajectory
        traj = tr.RadTrajectory(self.l, T, param_t, bound_cond_type,
                                actuation_type)
        traj.scale = combined_transform(self.l)

        # input with feedback
        control_law = sim.SimulationInputSum([traj, controller])
        # control_law = sim.simInputSum([traj])

        # determine (A,B) with modal-transformation
        A = np.diag(np.real(eig_val))
        B = a2 * np.array(
            [adjoint_eig_funcs[i](self.l) for i in range(len(eig_freq))])
        ss_modal = sim.StateSpace("eig_funcs", A, B, input_handle=control_law)

        # simulate
        t, q = sim.simulate_state_space(ss_modal, initial_weights, dt)

        eval_d = sim.evaluate_approximation("eig_funcs", q, t, dz)
        x_0t = eval_d.output_data[:, 0]
        yc, tc = tr.gevrey_tanh(T, 1)
        x_0t_desired = np.interp(t, tc, yc[0, :])
        self.assertLess(np.average((x_0t - x_0t_desired)**2), 1e-4)

        # display results
        if show_plots:
            win1 = vis.PgAnimatedPlot([eval_d], title="Test")
            win2 = vis.PgSurfacePlot(eval_d)
            app.exec_()
示例#11
0
    def test_it(self):
        # original system parameters
        a2 = 1
        a1 = 0  # attention: only a2 = 1., a1 =0 supported in this test case
        a0 = 0
        param = [a2, a1, a0, None, None]

        # target system parameters (controller parameters)
        a1_t = 0
        a0_t = 0  # attention: only a2 = 1., a1 =0 and a0 =0 supported in this test case
        param_t = [a2, a1_t, a0_t, None, None]

        # system/simulation parameters
        actuation_type = 'dirichlet'
        bound_cond_type = 'dirichlet'

        l = 1.
        spatial_disc = 10
        dz = sim.Domain(bounds=(0, l), num=spatial_disc)

        T = 1.
        temporal_disc = 1e2
        dt = sim.Domain(bounds=(0, T), num=temporal_disc)

        n = 10

        # 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, dz.bounds,
                                                 norm_fac[i]) for i in range(n)
        ])
        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,
                                                 dz.bounds, norm_fac_t[i])
            for i in range(n)
        ])
        register_base("eig_funcs_t", eig_funcs_t, overwrite=True)

        # derive initial field variable x(z,0) and weights
        start_state = cr.Function(lambda z: 0., domain=(0, l))
        initial_weights = cr.project_on_base(start_state, eig_funcs)

        # init trajectory / input of target system
        traj = tr.RadTrajectory(l, T, param_t, bound_cond_type, actuation_type)

        # 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)]))

        # input with feedback
        control_law = sim.SimulationInputSum([traj, controller])

        # determine (A,B) with modal-transfomation
        A = np.diag(eig_values)
        B = -a2 * np.array([eig_funcs[i].derive()(l) for i in range(n)])
        ss = sim.StateSpace("eig_funcs", A, B, input_handle=control_law)

        # simulate
        t, q = sim.simulate_state_space(ss, initial_weights, dt)

        eval_d = sim.evaluate_approximation("eig_funcs", q, t, dz)
        x_0t = eval_d.output_data[:, 0]
        yc, tc = tr.gevrey_tanh(T, 1)
        x_0t_desired = np.interp(t, tc, yc[0, :])
        self.assertLess(np.average((x_0t - x_0t_desired)**2), 0.5)

        # display results
        if show_plots:
            eval_d = sim.evaluate_approximation("eig_funcs", q, t, dz)
            win2 = vis.PgSurfacePlot(eval_d)
            app.exec_()
示例#12
0
    def test_it(self):
        actuation_type = 'dirichlet'
        bound_cond_type = 'dirichlet'
        param = [1., -2., -1., None, None]
        adjoint_param = ef.get_adjoint_rad_evp_param(param)
        a2, a1, a0, _, _ = param

        l = 1.
        spatial_disc = 10
        dz = sim.Domain(bounds=(0, l), num=spatial_disc)

        T = 1.
        temporal_disc = 1e2
        dt = sim.Domain(bounds=(0, T), num=temporal_disc)

        omega = np.array([(i + 1) * np.pi / l for i in range(spatial_disc)])
        eig_values = a0 - a2 * omega**2 - a1**2 / 4. / a2
        norm_fak = np.ones(omega.shape) * np.sqrt(2)
        eig_funcs = np.array([
            ef.SecondOrderDirichletEigenfunction(omega[i], param, dz.bounds,
                                                 norm_fak[i])
            for i in range(spatial_disc)
        ])
        register_base("eig_funcs", eig_funcs, overwrite=True)
        adjoint_eig_funcs = np.array([
            ef.SecondOrderDirichletEigenfunction(omega[i], adjoint_param,
                                                 dz.bounds, norm_fak[i])
            for i in range(spatial_disc)
        ])
        register_base("adjoint_eig_funcs", adjoint_eig_funcs, overwrite=True)

        # derive initial field variable x(z,0) and weights
        start_state = cr.Function(lambda z: 0., domain=(0, l))
        initial_weights = cr.project_on_base(start_state, adjoint_eig_funcs)

        # init trajectory
        u = tr.RadTrajectory(l, T, param, bound_cond_type, actuation_type)

        # determine (A,B) with weak-formulation (pyinduct)

        # derive sate-space system
        rad_pde = ut.get_parabolic_dirichlet_weak_form("eig_funcs",
                                                       "adjoint_eig_funcs", u,
                                                       param, dz.bounds)
        cf = sim.parse_weak_formulation(rad_pde)
        ss_weak = cf.convert_to_state_space()

        # determine (A,B) with modal-transfomation
        A = np.diag(eig_values)
        B = -a2 * np.array(
            [adjoint_eig_funcs[i].derive()(l) for i in range(spatial_disc)])
        ss_modal = sim.StateSpace("eig_funcs", A, B, input_handle=u)

        # TODO: resolve the big tolerance (rtol=3e-01) between ss_modal.A and ss_weak.A
        # check if ss_modal.(A,B) is close to ss_weak.(A,B)
        self.assertTrue(
            np.allclose(np.sort(np.linalg.eigvals(ss_weak.A[1])),
                        np.sort(np.linalg.eigvals(ss_modal.A[1])),
                        rtol=3e-1,
                        atol=0.))
        self.assertTrue(
            np.allclose(np.array([i[0] for i in ss_weak.B[1]]), ss_modal.B[1]))

        # display results
        if show_plots:
            t, q = sim.simulate_state_space(ss_modal, initial_weights, dt)
            eval_d = sim.evaluate_approximation("eig_funcs",
                                                q,
                                                t,
                                                dz,
                                                spat_order=1)
            win2 = vis.PgSurfacePlot(eval_d)
            app.exec_()
示例#13
0
    def test_fem(self):
        """
        use best documented fem case to test all steps in simulation process
        """

        # enter string with mass equations
        # nodes, ini_funcs = sf.cure_interval(sf.LagrangeFirstOrder,
        nodes, ini_funcs = sf.cure_interval(sf.LagrangeSecondOrder,
                                            self.dz.bounds,
                                            node_count=11)
        register_base("init_funcs", ini_funcs, overwrite=True)
        int1 = ph.IntegralTerm(ph.Product(
            ph.TemporalDerivedFieldVariable("init_funcs", 2),
            ph.TestFunction("init_funcs")),
                               self.dz.bounds,
                               scale=self.params.sigma * self.params.tau**2)
        s1 = ph.ScalarTerm(ph.Product(
            ph.TemporalDerivedFieldVariable("init_funcs", 2, location=0),
            ph.TestFunction("init_funcs", location=0)),
                           scale=self.params.m)
        int2 = ph.IntegralTerm(ph.Product(
            ph.SpatialDerivedFieldVariable("init_funcs", 1),
            ph.TestFunction("init_funcs", order=1)),
                               self.dz.bounds,
                               scale=self.params.sigma)
        s2 = ph.ScalarTerm(
            ph.Product(ph.Input(self.u),
                       ph.TestFunction("init_funcs", location=1)),
            -self.params.sigma)

        # derive sate-space system
        string_pde = sim.WeakFormulation([int1, s1, int2, s2], name="fem_test")
        self.cf = sim.parse_weak_formulation(string_pde)
        ss = self.cf.convert_to_state_space()

        # generate initial conditions for weights
        q0 = np.array([
            cr.project_on_base(self.ic[idx], ini_funcs) for idx in range(2)
        ]).flatten()

        # simulate
        t, q = sim.simulate_state_space(ss, q0, self.dt)

        # calculate result data
        eval_data = []
        for der_idx in range(2):
            eval_data.append(
                sim.evaluate_approximation(
                    "init_funcs",
                    q[:,
                      der_idx * ini_funcs.size:(der_idx + 1) * ini_funcs.size],
                    t, self.dz))
            eval_data[-1].name = "{0}{1}".format(
                self.cf.name, "_" + "".join(["d" for x in range(der_idx)]) +
                "t" if der_idx > 0 else "")

        # display results
        if show_plots:
            win = vis.PgAnimatedPlot(eval_data[:2],
                                     title="fem approx and derivative")
            win2 = vis.PgSurfacePlot(eval_data[0])
            app.exec_()

        # test for correct transition
        self.assertTrue(
            np.isclose(eval_data[0].output_data[-1, 0], self.y_end, atol=1e-3))

        # save some test data for later use
        root_dir = os.getcwd()
        if root_dir.split(os.sep)[-1] == "tests":
            res_dir = os.sep.join([os.getcwd(), "resources"])
        else:
            res_dir = os.sep.join([os.getcwd(), "tests", "resources"])

        if not os.path.isdir(res_dir):
            os.makedirs(res_dir)

        file_path = os.sep.join([res_dir, "test_data.res"])
        with open(file_path, "w+b") as f:
            dump(eval_data, f)
示例#14
0
    def test_it(self):
        actuation_type = 'robin'
        bound_cond_type = 'robin'
        param = [2., 1.5, -3., -1., -.5]
        adjoint_param = ef.get_adjoint_rad_evp_param(param)
        a2, a1, a0, alpha, beta = param

        l = 1.
        spatial_disc = 10
        dz = sim.Domain(bounds=(0, l), num=spatial_disc)

        T = 1.
        temporal_disc = 1e2
        dt = sim.Domain(bounds=(0, T), num=temporal_disc)
        n = 10

        eig_freq, eig_val = ef.compute_rad_robin_eigenfrequencies(param, l, n)

        init_eig_funcs = np.array([
            ef.SecondOrderRobinEigenfunction(om, param, dz.bounds)
            for om in eig_freq
        ])
        init_adjoint_eig_funcs = np.array([
            ef.SecondOrderRobinEigenfunction(om, adjoint_param, dz.bounds)
            for om in eig_freq
        ])

        # normalize eigenfunctions and adjoint eigenfunctions
        adjoint_and_eig_funcs = [
            cr.normalize_function(init_eig_funcs[i], init_adjoint_eig_funcs[i])
            for i in range(n)
        ]
        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])

        # register eigenfunctions
        register_base("eig_funcs", eig_funcs, overwrite=True)
        register_base("adjoint_eig_funcs", adjoint_eig_funcs, overwrite=True)

        # derive initial field variable x(z,0) and weights
        start_state = cr.Function(lambda z: 0., domain=(0, l))
        initial_weights = cr.project_on_base(start_state, adjoint_eig_funcs)

        # init trajectory
        u = tr.RadTrajectory(l, T, param, bound_cond_type, actuation_type)

        # determine (A,B) with weak-formulation (pyinduct)
        rad_pde = ut.get_parabolic_robin_weak_form("eig_funcs",
                                                   "adjoint_eig_funcs", u,
                                                   param, dz.bounds)
        cf = sim.parse_weak_formulation(rad_pde)
        ss_weak = cf.convert_to_state_space()

        # determine (A,B) with modal-transfomation
        A = np.diag(np.real_if_close(eig_val))
        B = a2 * np.array(
            [adjoint_eig_funcs[i](l) for i in range(len(eig_freq))])
        ss_modal = sim.StateSpace("eig_funcs", A, B, input_handle=u)

        # check if ss_modal.(A,B) is close to ss_weak.(A,B)
        self.assertTrue(
            np.allclose(np.sort(np.linalg.eigvals(ss_weak.A[1])),
                        np.sort(np.linalg.eigvals(ss_modal.A[1])),
                        rtol=1e-05,
                        atol=0.))
        self.assertTrue(
            np.allclose(np.array([i[0] for i in ss_weak.B[1]]), ss_modal.B[1]))

        # display results
        if show_plots:
            t, q = sim.simulate_state_space(ss_modal, initial_weights, dt)
            eval_d = sim.evaluate_approximation("eig_funcs",
                                                q,
                                                t,
                                                dz,
                                                spat_order=1)
            win1 = vis.PgAnimatedPlot([eval_d], title="Test")
            win2 = vis.PgSurfacePlot(eval_d)
            app.exec_()