Exemplo n.º 1
0
    def project_onto(self, mesh, proj_type="Fekete"):
        """
        Projects 'self' onto the 'mesh' using the 'proj_type' projection.

        proj_type == "Fekete"/"L2"/"H1"
        """
        if mesh == self._mesh:
            return self
        if proj_type == "Fekete":
            return Function(self, mesh)
        elif proj_type in ["L2", "H1"]:
            from hermes1d.h1d_wrapper.h1d_wrapper import \
                    (assemble_projection_matrix_rhs, Mesh, FESolution)
            from hermes1d.hermes_common.matrix import CSCMatrix, AVector
            pts, orders = mesh.get_mesh_data()
            m = Mesh(pts, orders)
            n_dof = m.assign_dofs()
            A = CSCMatrix(n_dof)
            rhs = AVector(n_dof)
            assemble_projection_matrix_rhs(m,
                                           A,
                                           rhs,
                                           self,
                                           projection_type=proj_type)
            coeffs = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
            return FESolution(m, coeffs).to_discrete_function()
        else:
            raise ValueError("Unknown projection type")
Exemplo n.º 2
0
    def project_onto(self, mesh, proj_type="Fekete"):
        """
        Projects 'self' onto the 'mesh' using the 'proj_type' projection.

        proj_type == "Fekete"/"L2"/"H1"
        """
        if mesh == self._mesh:
            return self
        if proj_type == "Fekete":
            return Function(self, mesh)
        elif proj_type in ["L2", "H1"]:
            from hermes1d.h1d_wrapper.h1d_wrapper import \
                    (assemble_projection_matrix_rhs, Mesh, FESolution)
            from hermes1d.hermes_common.matrix import CSCMatrix, AVector
            pts, orders = mesh.get_mesh_data()
            m = Mesh(pts, orders)
            n_dof = m.assign_dofs()
            A = CSCMatrix(n_dof)
            rhs = AVector(n_dof)
            assemble_projection_matrix_rhs(m, A, rhs, self,
                    projection_type=proj_type)
            coeffs = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
            return FESolution(m, coeffs).to_discrete_function()
        else:
            raise ValueError("Unknown projection type")
Exemplo n.º 3
0
 def calculate_FE_coeffs(self):
     if self._fe_sol is None:
         from hermes1d.h1d_wrapper.h1d_wrapper import \
                 (assemble_projection_matrix_rhs, Mesh, FESolution)
         from hermes1d.hermes_common.matrix import CSCMatrix, AVector
         pts, orders = self._mesh.get_mesh_data()
         m = Mesh(pts, orders)
         n_dof = m.assign_dofs()
         A = CSCMatrix(n_dof)
         rhs = AVector(n_dof)
         assemble_projection_matrix_rhs(m, A, rhs, self,
                 projection_type="L2")
         coeffs = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
         self._fe_sol = FESolution(m, coeffs)
Exemplo n.º 4
0
 def calculate_FE_coeffs(self):
     if self._fe_sol is None:
         from hermes1d.h1d_wrapper.h1d_wrapper import \
                 (assemble_projection_matrix_rhs, Mesh, FESolution)
         from hermes_common._hermes_common import CooMatrix
         pts, orders = self._mesh.get_mesh_data()
         m = Mesh(pts, orders)
         n_dof = m.assign_dofs()
         A = CooMatrix(n_dof)
         rhs = empty(n_dof)
         assemble_projection_matrix_rhs(m, A, rhs, self,
                 projection_type="L2")
         coeffs = solve(A.to_scipy_coo().todense(), rhs)
         self._fe_sol = FESolution(m, coeffs)
Exemplo n.º 5
0
def test_l2_h1_proj_run():
    """
    Test that the projections run.

    It doesn't test if it's correct.
    """
    pts = arange(0, 2 * pi, 1)
    orders = [3] * (len(pts) - 1)
    m = Mesh(pts, orders)
    n_dof = m.assign_dofs()
    A = CSCMatrix(n_dof)
    rhs = AVector(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f_sin, projection_type="L2")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_l2 = FESolution(m, x).to_discrete_function()
    A = CSCMatrix(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f_sin, projection_type="H1")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_h1 = FESolution(m, x).to_discrete_function()
    sol_l2.plot(False)
    sol_h1.plot(False)
Exemplo n.º 6
0
def test_l2_h1_proj_run():
    """
    Test that the projections run.

    It doesn't test if it's correct.
    """
    pts = arange(0, 2*pi, 1)
    orders = [3]*(len(pts)-1)
    m = Mesh(pts, orders)
    n_dof = m.assign_dofs()
    A = CSCMatrix(n_dof)
    rhs = AVector(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f_sin, projection_type="L2")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_l2 = FESolution(m, x).to_discrete_function()
    A = CSCMatrix(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f_sin, projection_type="H1")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_h1 = FESolution(m, x).to_discrete_function()
    sol_l2.plot(False)
    sol_h1.plot(False)
Exemplo n.º 7
0
def test_l2_h1_proj3():
    """
    Tests conversion to FE basis.
    """
    pts = arange(0, 2 * pi, 0.1)
    orders = [2] * (len(pts) - 1)
    m = Mesh(pts, orders)

    f = Function(lambda x: sin(x), Mesh1D(pts, orders))

    n_dof = m.assign_dofs()
    A = CSCMatrix(n_dof)
    rhs = AVector(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f, projection_type="L2")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_l2 = FESolution(m, x).to_discrete_function()
    A = CSCMatrix(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f, projection_type="H1")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_h1 = FESolution(m, x).to_discrete_function()
    assert sol_l2 == f
    assert sol_h1 == f
Exemplo n.º 8
0
def test_l2_h1_proj3():
    """
    Tests conversion to FE basis.
    """
    pts = arange(0, 2*pi, 0.1)
    orders = [2]*(len(pts)-1)
    m = Mesh(pts, orders)

    f = Function(lambda x: sin(x), Mesh1D(pts, orders))

    n_dof = m.assign_dofs()
    A = CSCMatrix(n_dof)
    rhs = AVector(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f, projection_type="L2")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_l2 = FESolution(m, x).to_discrete_function()
    A = CSCMatrix(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f, projection_type="H1")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_h1 = FESolution(m, x).to_discrete_function()
    assert sol_l2 == f
    assert sol_h1 == f
Exemplo n.º 9
0
def test_l2_h1_proj2():
    """
    Tests the correctness of the projections.
    """
    pts = arange(0, 2 * pi, 3)
    orders = [4] * (len(pts) - 1)
    m = Mesh(pts, orders)

    pts = array(list(arange(0, pts[-1], 0.1)) + [pts[-1]])
    orders = [6] * (len(pts) - 1)
    f_exact = Function(lambda x: sin(x), Mesh1D(pts, orders))

    n_dof = m.assign_dofs()
    A = CSCMatrix(n_dof)
    rhs = AVector(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f_sin, projection_type="L2")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_l2 = FESolution(m, x).to_discrete_function()
    A = CSCMatrix(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f_sin, projection_type="H1")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_h1 = FESolution(m, x).to_discrete_function()
    assert (sol_l2 - f_exact).l2_norm() < 0.002
    assert (sol_h1 - f_exact).l2_norm() < 0.002
Exemplo n.º 10
0
def test_l2_h1_proj2():
    """
    Tests the correctness of the projections.
    """
    pts = arange(0, 2*pi, 3)
    orders = [4]*(len(pts)-1)
    m = Mesh(pts, orders)

    pts = array(list(arange(0, pts[-1], 0.1)) + [pts[-1]])
    orders = [6]*(len(pts)-1)
    f_exact = Function(lambda x: sin(x), Mesh1D(pts, orders))

    n_dof = m.assign_dofs()
    A = CSCMatrix(n_dof)
    rhs = AVector(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f_sin, projection_type="L2")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_l2 = FESolution(m, x).to_discrete_function()
    A = CSCMatrix(n_dof)
    assemble_projection_matrix_rhs(m, A, rhs, f_sin, projection_type="H1")
    x = solve(A.to_scipy_csc().todense(), rhs.to_numpy())
    sol_h1 = FESolution(m, x).to_discrete_function()
    assert (sol_l2 - f_exact).l2_norm() < 0.002
    assert (sol_h1 - f_exact).l2_norm() < 0.002