Esempio n. 1
0
 def test_debug_plot(self):
     if show_plots:
         self.roots = ut.find_roots(self.char_eq,
                                    self.n_roots,
                                    self.grid,
                                    rtol=self.rtol,
                                    show_plot=show_plots)
Esempio n. 2
0
 def test_rtol(self):
     roots = ut.find_roots(self.char_eq,
                           self.n_roots,
                           self.grid,
                           self.rtol,
                           show_plot=show_plots)
     self.assertGreaterEqual(np.log10(min(np.abs(np.diff(roots)))),
                             self.rtol)
Esempio n. 3
0
 def test_n_dim_func(self):
     grid = np.array([list(range(10)), list(range(10))])
     roots = ut.find_roots(self.univar_eq,
                           self.n_roots,
                           grid,
                           self.rtol,
                           show_plot=show_plots)
     print(roots)
Esempio n. 4
0
 def test_cmplx_func(self):
     grid = [np.arange(-10, 10), np.arange(-5, 5)]
     roots = ut.find_roots(self.cmplx_eq,
                           3,
                           grid,
                           -1,
                           show_plot=show_plots,
                           complex=True)
     self.assertTrue(
         np.allclose([self.cmplx_eq(root) for root in roots],
                     [0] * len(roots)))
     print(roots)
Esempio n. 5
0
 def test_n_dim_func(self):
     grid = np.array([list(range(10)), list(range(10))])
     roots = ut.find_roots(self.univar_eq, self.n_roots, grid, self.rtol,
                           show_plot=show_plots)
     print(roots)
Esempio n. 6
0
 def test_cmplx_func(self):
     grid = [np.arange(-10, 10), np.arange(-5, 5)]
     roots = ut.find_roots(self.cmplx_eq, 3, grid, -1, show_plot=show_plots, complex=True)
     self.assertTrue(np.allclose([self.cmplx_eq(root) for root in roots], [0]*len(roots)))
     print(roots)
Esempio n. 7
0
 def test_debug_plot(self):
     if show_plots:
         self.roots = ut.find_roots(self.char_eq, self.n_roots, self.grid, rtol=self.rtol,
                                    show_plot=show_plots)
Esempio n. 8
0
 def test_in_area(self):
     roots = ut.find_roots(self.char_eq, self.n_roots, self.grid, self.rtol)
     for root in roots:
         self.assertTrue(root >= 0.)
Esempio n. 9
0
 def test_rtol(self):
     roots = ut.find_roots(self.char_eq, self.n_roots, self.grid, self.rtol, show_plot=show_plots)
     self.assertGreaterEqual(np.log10(min(np.abs(np.diff(roots)))), self.rtol)
Esempio n. 10
0
 def test_enough_roots(self):
     roots = ut.find_roots(self.char_eq, self.n_roots, self.grid, self.rtol)
     self.assertEqual(len(roots), self.n_roots)
Esempio n. 11
0
 def test_in_fact_roots(self):
     roots = ut.find_roots(self.char_eq, self.n_roots, self.grid, self.rtol)
     for root in roots:
         self.assertAlmostEqual(self.char_eq(root), 0)
Esempio n. 12
0
    def test_modal(self):
        order = 8

        def char_eq(w):
            return w * (np.sin(w) + self.params.m * w * np.cos(w))

        def phi_k_factory(freq, derivative_order=0):
            def eig_func(z):
                return np.cos(freq * z) - self.params.m * freq * np.sin(freq * z)

            def eig_func_dz(z):
                return -freq * (np.sin(freq * z) + self.params.m * freq * np.cos(freq * z))

            def eig_func_ddz(z):
                return freq ** 2 * (-np.cos(freq * z) + self.params.m * freq * np.sin(freq * z))

            if derivative_order == 0:
                return eig_func
            elif derivative_order == 1:
                return eig_func_dz
            elif derivative_order == 2:
                return eig_func_ddz
            else:
                raise ValueError

        # create eigenfunctions
        eig_frequencies = ut.find_roots(char_eq, n_roots=order, grid=np.arange(0, 1e3, 2), rtol=-2)
        print("eigenfrequencies:")
        print eig_frequencies

        # create eigen function vectors
        class SWMFunctionVector(cr.ComposedFunctionVector):
            """
            String With Mass Function Vector, necessary due to manipulated scalar product
            """
            @property
            def func(self):
                return self.members["funcs"][0]

            @property
            def scalar(self):
                return self.members["scalars"][0]

        eig_vectors = []
        for n in range(order):
            eig_vectors.append(SWMFunctionVector(cr.Function(phi_k_factory(eig_frequencies[n]),
                                                             derivative_handles=[
                                                                 phi_k_factory(eig_frequencies[n], der_order)
                                                                 for der_order in range(1, 3)],
                                                             domain=self.dz.bounds,
                                                             nonzero=self.dz.bounds),
                                                 phi_k_factory(eig_frequencies[n])(0)))

        # normalize eigen vectors
        norm_eig_vectors = [cr.normalize_function(vec) for vec in eig_vectors]
        norm_eig_funcs = np.array([vec.func for vec in norm_eig_vectors])
        register_base("norm_eig_funcs", norm_eig_funcs, overwrite=True)

        norm_eig_funcs[0](1)

        # debug print eigenfunctions
        if 0:
            func_vals = []
            for vec in eig_vectors:
                func_vals.append(np.vectorize(vec.func)(self.dz))

            norm_func_vals = []
            for func in norm_eig_funcs:
                norm_func_vals.append(np.vectorize(func)(self.dz))

            clrs = ["r", "g", "b", "c", "m", "y", "k", "w"]
            for n in range(1, order + 1, len(clrs)):
                pw_phin_k = pg.plot(title="phin_k for k in [{0}, {1}]".format(n, min(n + len(clrs), order)))
                for k in range(len(clrs)):
                    if k + n > order:
                        break
                    pw_phin_k.plot(x=np.array(self.dz), y=norm_func_vals[n + k - 1], pen=clrs[k])

            app.exec_()

        # create terms of weak formulation
        terms = [ph.IntegralTerm(ph.Product(ph.FieldVariable("norm_eig_funcs", order=(2, 0)),
                                            ph.TestFunction("norm_eig_funcs")),
                                 self.dz.bounds, scale=-1),
                 ph.ScalarTerm(ph.Product(
                     ph.FieldVariable("norm_eig_funcs", order=(2, 0), location=0),
                     ph.TestFunction("norm_eig_funcs", location=0)),
                     scale=-1),
                 ph.ScalarTerm(ph.Product(ph.Input(self.u),
                                          ph.TestFunction("norm_eig_funcs", location=1))),
                 ph.ScalarTerm(
                     ph.Product(ph.FieldVariable("norm_eig_funcs", location=1),
                                ph.TestFunction("norm_eig_funcs", order=1, location=1)),
                     scale=-1),
                 ph.ScalarTerm(ph.Product(ph.FieldVariable("norm_eig_funcs", location=0),
                                          ph.TestFunction("norm_eig_funcs", order=1,
                                                          location=0))),
                 ph.IntegralTerm(ph.Product(ph.FieldVariable("norm_eig_funcs"),
                                            ph.TestFunction("norm_eig_funcs", order=2)),
                                 self.dz.bounds)]
        modal_pde = sim.WeakFormulation(terms, name="swm_lib-modal")
        eval_data = sim.simulate_system(modal_pde, self.ic, self.dt, self.dz, der_orders=(2, 0))

        # display results
        if show_plots:
            win = vis.PgAnimatedPlot(eval_data[0:2], title="modal 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))
Esempio n. 13
0
 def test_in_area(self):
     roots = ut.find_roots(self.char_eq, self.n_roots, self.grid, self.rtol)
     for root in roots:
         self.assertTrue(root >= 0.)
Esempio n. 14
0
 def test_enough_roots(self):
     roots = ut.find_roots(self.char_eq, self.n_roots, self.grid, self.rtol)
     self.assertEqual(len(roots), self.n_roots)
Esempio n. 15
0
 def test_in_fact_roots(self):
     roots = ut.find_roots(self.char_eq, self.n_roots, self.grid, self.rtol)
     for root in roots:
         self.assertAlmostEqual(self.char_eq(root), 0)
Esempio n. 16
0
    def test_modal(self):
        order = 8

        def char_eq(w):
            return w * (np.sin(w) + self.params.m * w * np.cos(w))

        def phi_k_factory(freq, derivative_order=0):
            def eig_func(z):
                return np.cos(
                    freq * z) - self.params.m * freq * np.sin(freq * z)

            def eig_func_dz(z):
                return -freq * (np.sin(freq * z) +
                                self.params.m * freq * np.cos(freq * z))

            def eig_func_ddz(z):
                return freq**2 * (-np.cos(freq * z) +
                                  self.params.m * freq * np.sin(freq * z))

            if derivative_order == 0:
                return eig_func
            elif derivative_order == 1:
                return eig_func_dz
            elif derivative_order == 2:
                return eig_func_ddz
            else:
                raise ValueError

        # create eigenfunctions
        eig_frequencies = ut.find_roots(char_eq,
                                        n_roots=order,
                                        grid=np.arange(0, 1e3, 2),
                                        rtol=-2)
        print("eigenfrequencies:")
        print(eig_frequencies)

        # create eigen function vectors
        class SWMFunctionVector(cr.ComposedFunctionVector):
            """
            String With Mass Function Vector, necessary due to manipulated scalar product
            """
            @property
            def func(self):
                return self.members["funcs"][0]

            @property
            def scalar(self):
                return self.members["scalars"][0]

        eig_vectors = []
        for n in range(order):
            eig_vectors.append(
                SWMFunctionVector(
                    cr.Function(phi_k_factory(eig_frequencies[n]),
                                derivative_handles=[
                                    phi_k_factory(eig_frequencies[n],
                                                  der_order)
                                    for der_order in range(1, 3)
                                ],
                                domain=self.dz.bounds,
                                nonzero=self.dz.bounds),
                    phi_k_factory(eig_frequencies[n])(0)))

        # normalize eigen vectors
        norm_eig_vectors = [cr.normalize_function(vec) for vec in eig_vectors]
        norm_eig_funcs = np.array([vec.func for vec in norm_eig_vectors])
        register_base("norm_eig_funcs", norm_eig_funcs, overwrite=True)

        norm_eig_funcs[0](1)

        # debug print eigenfunctions
        if 0:
            func_vals = []
            for vec in eig_vectors:
                func_vals.append(np.vectorize(vec.func)(self.dz))

            norm_func_vals = []
            for func in norm_eig_funcs:
                norm_func_vals.append(np.vectorize(func)(self.dz))

            clrs = ["r", "g", "b", "c", "m", "y", "k", "w"]
            for n in range(1, order + 1, len(clrs)):
                pw_phin_k = pg.plot(title="phin_k for k in [{0}, {1}]".format(
                    n, min(n + len(clrs), order)))
                for k in range(len(clrs)):
                    if k + n > order:
                        break
                    pw_phin_k.plot(x=np.array(self.dz),
                                   y=norm_func_vals[n + k - 1],
                                   pen=clrs[k])

            app.exec_()

        # create terms of weak formulation
        terms = [
            ph.IntegralTerm(ph.Product(
                ph.FieldVariable("norm_eig_funcs", order=(2, 0)),
                ph.TestFunction("norm_eig_funcs")),
                            self.dz.bounds,
                            scale=-1),
            ph.ScalarTerm(ph.Product(
                ph.FieldVariable("norm_eig_funcs", order=(2, 0), location=0),
                ph.TestFunction("norm_eig_funcs", location=0)),
                          scale=-1),
            ph.ScalarTerm(
                ph.Product(ph.Input(self.u),
                           ph.TestFunction("norm_eig_funcs", location=1))),
            ph.ScalarTerm(ph.Product(
                ph.FieldVariable("norm_eig_funcs", location=1),
                ph.TestFunction("norm_eig_funcs", order=1, location=1)),
                          scale=-1),
            ph.ScalarTerm(
                ph.Product(
                    ph.FieldVariable("norm_eig_funcs", location=0),
                    ph.TestFunction("norm_eig_funcs", order=1, location=0))),
            ph.IntegralTerm(
                ph.Product(ph.FieldVariable("norm_eig_funcs"),
                           ph.TestFunction("norm_eig_funcs", order=2)),
                self.dz.bounds)
        ]
        modal_pde = sim.WeakFormulation(terms, name="swm_lib-modal")
        eval_data = sim.simulate_system(modal_pde,
                                        self.ic,
                                        self.dt,
                                        self.dz,
                                        der_orders=(2, 0))

        # display results
        if show_plots:
            win = vis.PgAnimatedPlot(eval_data[0:2],
                                     title="modal 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))