Esempio n. 1
0
def get_admissible_projectors(dae_auto):
    'get admissible projectors for the autonomous dae system'

    adm_projs, _, _, _ = admissible_projectors(dae_auto.matrix_e.todense(),
                                               dae_auto.matrix_a.todense())
    print "\nadmissible projectors:"
    print "\nadm_projs = {}".format(adm_projs)
    print "\nQ0 = {}".format(adm_projs[0])

    return adm_projs
Esempio n. 2
0
    def get_decoupled_system(self, auto_dae_automaton):
        'get decoupled system from an dae automaton'

        assert isinstance(auto_dae_automaton, AutonomousDaeAutomation)

        matrix_e = auto_dae_automaton.matrix_e.todense()
        matrix_a = auto_dae_automaton.matrix_a.todense()
        matrix_c = auto_dae_automaton.matrix_c.todense()

        n = matrix_a.shape[0]
        In = np.eye(n, dtype=float)

        adm_projs, E_list, A_list, _ = admissible_projectors(
            matrix_e, matrix_a)

        if adm_projs == 'error':
            print "\nerror: dae system has index larger than 3"
            self.status = 'error'
        else:
            assert isinstance(
                adm_projs, list), 'error: not a list of admissible projectors'
            ind = len(adm_projs)

            if ind == 1:

                decoupled_sys = AutonomousDecoupledIndexOne()
                Q0 = adm_projs[0]
                P0 = In - Q0
                A0 = A_list[0]
                E1_inv = np.linalg.inv(E_list[1])
                E1_inv_A0 = np.dot(E1_inv, A0)

                N1 = np.dot(P0, E1_inv_A0)  # ode part
                N2 = np.dot(Q0, E1_inv_A0)  # alg part

                decoupled_sys.set_dynamics(N1, N2, matrix_c)
                decoupled_sys.set_projectors(adm_projs)
                self.decoupled_sys = decoupled_sys
                self.status = 'success'

            elif ind == 2:

                decoupled_sys = AutonomousDecoupledIndexTwo()
                Q0 = adm_projs[0]
                Q1 = adm_projs[1]
                P0 = In - Q0
                P1 = In - Q1

                P0_P1 = np.dot(P0, P1)
                A2 = A_list[2]
                E2_inv = np.linalg.inv(E_list[2])
                E2_inv_A2 = np.dot(E2_inv, A2)

                N1 = np.dot(P0_P1, E2_inv_A2)  # ode part
                N2 = np.dot(P0, np.dot(Q1, E2_inv_A2))  # alg1 part

                # alg2 part
                Q0_P1 = np.dot(Q0, P1)
                N3 = np.dot(Q0_P1, E2_inv_A2)
                L3 = np.dot(Q0, Q1)

                decoupled_sys.set_dynamics(N1, N2, N3, L3, matrix_c)
                decoupled_sys.set_projectors(adm_projs)
                self.decoupled_sys = decoupled_sys
                self.status = 'success'

            elif ind == 3:

                decoupled_sys = AutonomousDecoupledIndexThree()
                Q0 = adm_projs[0]
                Q1 = adm_projs[1]
                Q2 = adm_projs[2]
                P0 = In - Q0
                P1 = In - Q1
                P2 = In - Q2
                A0 = matrix_a

                P0_P1_P2 = np.dot(P0, np.dot(P1, P2))
                A3 = A_list[3]
                E3_inv = np.linalg.inv(E_list[3])
                E3_inv_A3 = np.dot(E3_inv, A3)

                # ode part
                N1 = np.dot(P0_P1_P2, E3_inv_A3)

                # alg1 part
                P0_P1_Q2 = np.dot(P0, np.dot(P1, Q2))
                N2 = np.dot(P0_P1_Q2, E3_inv_A3)

                # alg2 part
                P0_Q1_P2 = np.dot(P0, np.dot(Q1, P2))
                N3 = np.dot(P0_Q1_P2, E3_inv_A3)
                L3 = np.dot(P0, np.dot(Q1, Q2))

                # alg3 part
                Q0_P1_P2 = np.dot(Q0, np.dot(P1, P2))
                N4 = np.dot(Q0_P1_P2, E3_inv_A3)
                L4 = np.dot(Q0, Q1)
                Z4 = np.dot(Q0, np.dot(P1, Q2))

                decoupled_sys.set_dynamics(N1, N2, N3, L3, N4, L4, Z4,
                                           matrix_c)
                decoupled_sys.set_projectors(adm_projs)
                self.decoupled_sys = decoupled_sys
                self.status = 'success'

        # print decoupling result
        print "\ndecoupling status = {}".format(self.status)
        if self.status == 'success':
            if ind == 1:
                print "\nsystem is index 1"
                print "\ndecoupled dae_auto: N1 = {}".format(decoupled_sys.N1)
                print "\nnorm of N1 = {}".format(
                    np.linalg.norm(decoupled_sys.N1))
                print "\ndecoupled dae_auto: N2 = {}".format(decoupled_sys.N2)
                print "\nnorm of N2 = {}".format(
                    np.linalg.norm(decoupled_sys.N2))

            if ind == 2:
                print "\nsystem is index 2"
                print "\ndecoupled dae_auto: N1 = {}".format(decoupled_sys.N1)
                print "\nnorm of N1 = {}".format(
                    np.linalg.norm(decoupled_sys.N1))
                print "\ndecoupled dae_auto: N2 = {}".format(decoupled_sys.N2)
                print "\nnorm of N2 = {}".format(
                    np.linalg.norm(decoupled_sys.N2))
                print "\ndecoupled dae_auto: N3 = {}".format(decoupled_sys.N3)
                print "\nnorm of N3 = {}".format(
                    np.linalg.norm(decoupled_sys.N3))
                print "\ndecoupled dae_auto: L3 = {}".format(decoupled_sys.L3)
                print "\nnorm of L3 = {}".format(
                    np.linalg.norm(decoupled_sys.L3))

            if ind == 3:
                print "\nsystem is index 3"
                print "\ndecoupled dae_auto: N1 = {}".format(decoupled_sys.N1)
                print "\nnorm of N1 = {}".format(
                    np.linalg.norm(decoupled_sys.N1))
                print "\ndecoupled dae_auto: N2 = {}".format(decoupled_sys.N2)
                print "\nnorm of N2 = {}".format(
                    np.linalg.norm(decoupled_sys.N2))
                print "\ndecoupled dae_auto: N3 = {}".format(decoupled_sys.N3)
                print "\nnorm of N3 = {}".format(
                    np.linalg.norm(decoupled_sys.N3))
                print "\ndecoupled dae_auto: L3 = {}".format(decoupled_sys.L3)
                print "\nnorm of L3 = {}".format(
                    np.linalg.norm(decoupled_sys.L3))
                print "\ndecoupled dae_auto: N4 = {}".format(decoupled_sys.N4)
                print "\nnorm of N4 = {}".format(
                    np.linalg.norm(decoupled_sys.N4))
                print "\ndecoupled dae_auto: L4 = {}".format(decoupled_sys.L4)
                print "\nnorm of L4 = {}".format(
                    np.linalg.norm(decoupled_sys.L4))
                print "\ndecoupled dae_auto: Z4 = {}".format(decoupled_sys.Z4)
                print "\nnorm of Z4 = {}".format(
                    np.linalg.norm(decoupled_sys.Z4))

        return self.decoupled_sys, self.status
Esempio n. 3
0
    def get_decoupled_system(self, dae_automaton):
        'get decoupled system from an dae automaton'

        assert isinstance(dae_automaton, DaeAutomation)

        matrix_e = dae_automaton.matrix_e.todense()
        matrix_a = dae_automaton.matrix_a.todense()
        matrix_b = dae_automaton.matrix_b.todense()
        print "\nmatrix_b = {}".format(matrix_b)
        matrix_c = dae_automaton.matrix_c.todense()
        print "\nmatrix_c = {}".format(matrix_c)

        n = matrix_a.shape[0]
        In = np.eye(n, dtype=float)

        adm_projs, E_list, A_list, _ = admissible_projectors(
            matrix_e, matrix_a)

        if adm_projs == 'error':
            print "\nerror: dae system has index larger than 3"
            self.status = 'error'
        else:
            assert isinstance(
                adm_projs, list), 'error: not a list of admissible projectors'
            ind = len(adm_projs)

            if ind == 1:

                decoupled_sys = DecoupledIndexOne()
                Q0 = adm_projs[0]
                P0 = In - Q0
                E1_inv = np.linalg.inv(E_list[1])
                A0 = A_list[0]
                E1_inv_A0 = np.dot(E1_inv, A0)
                E1_inv_B = np.dot(E1_inv, matrix_b)
                # ode part
                N1 = np.dot(P0, E1_inv_A0)
                M1 = np.dot(P0, E1_inv_B)

                # alg part
                N2 = np.dot(Q0, E1_inv_A0)
                M2 = np.dot(Q0, E1_inv_B)

                decoupled_sys.set_dynamics(N1, M1, N2, M2, matrix_c)
                decoupled_sys.set_projectors(adm_projs)

                self.decoupled_sys = decoupled_sys
                self.status = 'success'

            elif ind == 2:

                decoupled_sys = DecoupledIndexTwo()
                Q0 = adm_projs[0]
                Q1 = adm_projs[1]
                P0 = In - Q0
                P1 = In - Q1

                P0_P1 = np.dot(P0, P1)
                E2_inv = np.linalg.inv(E_list[2])
                A2 = A_list[2]
                E2_inv_A2 = np.dot(E2_inv, A2)
                E2_inv_B = np.dot(E2_inv, matrix_b)

                # ode part
                N1 = np.dot(P0_P1, E2_inv_A2)
                M1 = np.dot(P0_P1, E2_inv_B)

                # alg1 part
                N2 = np.dot(P0, np.dot(Q1, E2_inv_A2))
                M2 = np.dot(P0, np.dot(Q1, E2_inv_B))

                # alg2 part
                Q0_P1 = np.dot(Q0, P1)
                N3 = np.dot(Q0_P1, E2_inv_A2)
                M3 = np.dot(Q0_P1, E2_inv_B)
                L3 = np.dot(Q0, Q1)

                decoupled_sys.set_dynamics(N1, M1, N2, M2, N3, M3, L3,
                                           matrix_c)

                decoupled_sys.set_projectors(adm_projs)
                self.decoupled_sys = decoupled_sys
                self.status = 'success'

            elif ind == 3:

                decoupled_sys = DecoupledIndexThree()
                Q0 = adm_projs[0]
                Q1 = adm_projs[1]
                Q2 = adm_projs[2]
                P0 = In - Q0
                P1 = In - Q1
                P2 = In - Q2

                P0_P1_P2 = np.dot(P0, np.dot(P1, P2))
                A3 = A_list[3]
                E3_inv = np.linalg.inv(E_list[3])
                E3_inv_A3 = np.dot(E3_inv, A3)
                E3_inv_B = np.dot(E3_inv, matrix_b)
                # ode part
                N1 = np.dot(P0_P1_P2, E3_inv_A3)
                M1 = np.dot(P0_P1_P2, E3_inv_B)

                # alg1 part
                P0_P1_Q2 = np.dot(P0, np.dot(P1, Q2))
                N2 = np.dot(P0_P1_Q2, E3_inv_A3)
                M2 = np.dot(P0_P1_Q2, E3_inv_B)

                # alg2 part
                P0_Q1_P2 = np.dot(P0, np.dot(Q1, P2))
                N3 = np.dot(P0_Q1_P2, E3_inv_A3)
                M3 = np.dot(P0_Q1_P2, E3_inv_B)
                L3 = np.dot(P0, np.dot(Q1, Q2))

                # alg3 part
                Q0_P1_P2 = np.dot(Q0, np.dot(P1, P2))
                N4 = np.dot(Q0_P1_P2, E3_inv_A3)
                M4 = np.dot(Q0_P1_P2, E3_inv_B)
                L4 = np.dot(Q0, Q1)
                Z4 = np.dot(Q0, np.dot(P1, Q2))

                decoupled_sys.set_dynamics(N1, M1, N2, M2, N3, M3, L3, N4, M4,
                                           L4, Z4, matrix_c)
                decoupled_sys.set_projectors(adm_projs)
                self.decoupled_sys = decoupled_sys
                self.status = 'success'

        return self.decoupled_sys, self.status