예제 #1
0
    def test_temporal_derive(self):

        b_desired = 0.4
        k = 5  # = k1 + k2
        k1, k2, b = ut.split_domain(k, b_desired, self.l, mode='coprime')[0:3]
        # q
        E = tr.coefficient_recursion(self.y, self.beta * self.y, self.param)
        q = tr.temporal_derived_power_series(self.l - b, E,
                                             int(self.n_y / 2) - 1, self.n_y)
        # u
        B = tr.coefficient_recursion(self.y, self.alpha * self.y, self.param)
        xq = tr.temporal_derived_power_series(self.l,
                                              B,
                                              int(self.n_y / 2) - 1,
                                              self.n_y,
                                              spatial_der_order=0)
        d_xq = tr.temporal_derived_power_series(self.l,
                                                B,
                                                int(self.n_y / 2) - 1,
                                                self.n_y,
                                                spatial_der_order=1)
        u = d_xq + self.beta * xq
        # x(0,t)
        C = tr.coefficient_recursion(q, self.beta * q, self.param)
        D = tr.coefficient_recursion(np.zeros(u.shape), u, self.param)
        x_0t = tr.power_series(0, self.t, C)
        if show_plots:
            pw = pg.plot(title="control_input")
            pw.plot(self.t, x_0t)
            app.exec_()
예제 #2
0
    def test_temporal_derive(self):

        b_desired = 0.4
        k = 5 # = k1 + k2
        k1, k2, b = ut.split_domain(k, b_desired, self.l, mode='coprime')[0:3]
        # q
        E = tr.coefficient_recursion(self.y, self.beta*self.y, self.param)
        q = tr.temporal_derived_power_series(self.l-b, E, int(self.n_y/2)-1, self.n_y)
        # u
        B = tr.coefficient_recursion(self.y, self.alpha*self.y, self.param)
        xq = tr.temporal_derived_power_series(self.l, B, int(self.n_y/2)-1, self.n_y, spatial_der_order=0)
        d_xq = tr.temporal_derived_power_series(self.l, B, int(self.n_y/2)-1, self.n_y, spatial_der_order=1)
        u = d_xq + self.beta*xq
        # x(0,t)
        C = tr.coefficient_recursion(q, self.beta*q, self.param)
        D = tr.coefficient_recursion(np.zeros(u.shape), u, self.param)
        x_0t = tr.power_series(0, self.t, C)
        if show_plots:
            pw = pg.plot(title="control_input")
            pw.plot(self.t, x_0t)
            app.exec_()
예제 #3
0
M = np.linalg.inv(ut.get_inn_domain_transformation_matrix(k1, k2, mode="2n"))

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

# COMPUTE DESIRED FIELDVARIABLE
# THE NAMING OF THE POWER SERIES COEFFICIENTS IS BASED ON THE PUBLICATION:
#      - WANG; WOITTENNEK:BACKSTEPPING-METHODE FUER PARABOLISCHE SYSTEM MIT PUNKTFOERMIGEM INNEREN EINGRIFF
# compute input u_i of the boundary-controlled intermediate (_i) system with n_y/2 temporal derivatives
n_y = 80
y, t_x = tr.gevrey_tanh(T, n_y, 1.1, 2)
B = tr.coefficient_recursion(y, alpha_i * y, param_i)
x_i_at_l = tr.temporal_derived_power_series(l, B, int(n_y / 2) - 1, n_y, spatial_der_order=0)
dx_i_at_l = tr.temporal_derived_power_series(l, B, int(n_y / 2) - 1, n_y, spatial_der_order=1)
u_i = dx_i_at_l + beta_i * x_i_at_l

# compute coefficients C, D and E for the power series
E = tr.coefficient_recursion(y, beta_i * y, param_i)
q = tr.temporal_derived_power_series(l - b, E, int(n_y / 2) - 1, n_y)
C = tr.coefficient_recursion(q, alpha_i * q, param_i)
D = tr.coefficient_recursion(np.zeros(u_i.shape), u_i, param_i)

# compute power series for the desired in-domain intermediate (_id) fieldvariable (subdivided in x1_i & x2_i)
z_x1 = np.linspace(0, b, len(spatial_domain) * k1 / k)
x1_id_desired = tr.power_series(z_x1, t_x, C)
z_x2 = np.linspace(b, l, len(spatial_domain) * k2 / k)[1:]
x2_id_desired = tr.power_series(z_x2, t_x, C) - tr.power_series(z_x2 - b, t_x, D)
z_x = np.array(list(z_x1) + list(z_x2))
예제 #4
0
# original intermediate ("_i") and target intermediate ("_ti") system parameters
_, _, a0_i, alpha_i, beta_i = ef.transform2intermediate(param)
param_i = a2, 0, a0_i, alpha_i, beta_i
_, _, a0_ti, alpha_ti, beta_ti = ef.transform2intermediate(param_t)
param_ti = a2, 0, a0_ti, alpha_ti, beta_ti

# COMPUTE DESIRED FIELDVARIABLE
# THE NAMING OF THE POWER SERIES COEFFICIENTS IS BASED ON THE PUBLICATION:
#      - WANG; WOITTENNEK:BACKSTEPPING-METHODE FUER PARABOLISCHE SYSTEM MIT PUNKTFOERMIGEM INNEREN EINGRIFF
# compute input u_i of the boundary-controlled intermediate (_i) system with n_y/2 temporal derivatives
n_y = 80
y, t_x = tr.gevrey_tanh(T, n_y, 1.1, 2)
B = tr.coefficient_recursion(y, alpha_i * y, param_i)
x_i_at_l = tr.temporal_derived_power_series(l,
                                            B,
                                            int(n_y / 2) - 1,
                                            n_y,
                                            spatial_der_order=0)
dx_i_at_l = tr.temporal_derived_power_series(l,
                                             B,
                                             int(n_y / 2) - 1,
                                             n_y,
                                             spatial_der_order=1)
u_i = dx_i_at_l + beta_i * x_i_at_l

# compute coefficients C, D and E for the power series
E = tr.coefficient_recursion(y, beta_i * y, param_i)
q = tr.temporal_derived_power_series(l - b, E, int(n_y / 2) - 1, n_y)
C = tr.coefficient_recursion(q, alpha_i * q, param_i)
D = tr.coefficient_recursion(np.zeros(u_i.shape), u_i, param_i)