def test_storage(self): a = np.eye(2, 2) b = np.array([[0], [1]]) u = MonotonousInput() ic = np.zeros((2, 1)) ss = sim.StateSpace("test", a, b, input_handle=u) # run simulation to fill the internal storage domain = sim.Domain((0, 10), step=.1) res = sim.simulate_state_space(ss, ic, domain) # don't return entries that are not there self.assertRaises(KeyError, u.get_results, domain, "Unknown Entry") # default key is "output" ed = u.get_results(domain) ed_explicit = u.get_results(domain, result_key="output") self.assertTrue(np.array_equal(ed, ed_explicit)) # return np.ndarray as default self.assertIsInstance(ed, np.ndarray) # return EvalData if corresponding flag is set self.assertIsInstance(u.get_results(domain, as_eval_data=True), sim.EvalData)
def test_call_arguments(self): a = np.eye(2, 2) b = np.array([[0], [1]]) u = CorrectInput() ic = np.zeros((2, 1)) ss = sim.StateSpace("test", {1: a}, {1: b}, input_handle=u) # if caller provides correct kwargs no exception should be raised res = sim.simulate_state_space(ss, ic, sim.Domain((0, 1), num=10))
def test_modal(self): self.act_funcs = "eig_funcs" a2, a1, a0, alpha, beta = self.param controller = ut.get_parabolic_robin_backstepping_controller( state=self.x_i_at_l, approx_state=self.x_i_at_l, d_approx_state=self.xd_i_at_l, approx_target_state=self.x_ti_at_l, d_approx_target_state=self.xd_ti_at_l, integral_kernel_zz=self.int_kernel_zz(self.l), original_beta=self.beta_i, target_beta=self.beta_ti, trajectory=self.traj, scale=self.transform_i(-self.l)) # determine (A,B) with modal-transfomation A = np.diag(np.real(self.eig_val)) B = a2 * np.array( [self.adjoint_eig_funcs[i](self.l) for i in range(self.n)]) ss_modal = sim.StateSpace(self.act_funcs, A, B, input_handle=controller) # simulate self.t, self.q = sim.simulate_state_space( ss_modal, np.zeros((len(self.adjoint_eig_funcs))), self.dt) eval_d = sim.evaluate_approximation(self.act_funcs, self.q, self.t, self.dz) x_0t = eval_d.output_data[:, 0] yc, tc = tr.gevrey_tanh(self.T, 1) x_0t_desired = np.interp(self.t, tc, yc[0, :]) self.assertLess(np.average((x_0t - x_0t_desired)**2), 1e-2) # display results if show_plots: win1 = vis.PgAnimatedPlot([eval_d], title="Test") win2 = vis.PgSurfacePlot(eval_d) app.exec_()
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) C = tr.coefficient_recursion(np.zeros(y_d.shape), y_d, param) x_l = tr.power_series(z_d, t_d, C) evald_traj = vis.EvalData([t_d, z_d], x_l, name="x(z,t) desired") # simulate t, q = sim.simulate_state_space(ss, initial_weights, temporal_domain) # pyqtgraph visualization evald_x = sim.evaluate_approximation("eig_funcs", q, t, spatial_domain, name="x(z,t) with x(z,0)=" + str(init_profile)) win1 = vis.PgAnimatedPlot([evald_x, evald_traj], title="animation", dt=temporal_domain.step)
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_()
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_()
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_()
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_()