コード例 #1
0
    def set_grids(self, N, num_nodes_mortar, num_nodes_1d, physdims=[1, 1]):
        f1 = np.array([[0, physdims[0]], [.5, .5]])

        gb = meshing.cart_grid([f1], N, **{"physdims": physdims})
        gb.compute_geometry()
        gb.assign_node_ordering()

        for e, d in gb.edges():
            mg = d["mortar_grid"]
            new_side_grids = {
                s: refinement.remesh_1d(g, num_nodes=num_nodes_mortar)
                for s, g in mg.side_grids.items()
            }

            mortars.update_mortar_grid(mg, new_side_grids, tol=1e-4)

            # refine the 1d-physical grid
            old_g = gb.nodes_of_edge(e)[0]
            new_g = refinement.remesh_1d(old_g, num_nodes=num_nodes_1d)
            new_g.compute_geometry()

            gb.update_nodes(old_g, new_g)
            mg = d["mortar_grid"]
            mortars.update_physical_low_grid(mg, new_g, tol=1e-4)
        return gb
コード例 #2
0
    def test_mortar_grid_1d_refine_1d_grid(self):
        """ Refine the lower-dimensional grid so that it is matching with the
        higher dimensional grid.
        """

        f1 = np.array([[0, 1], [.5, .5]])

        gb = meshing.cart_grid([f1], [2, 2], **{"physdims": [1, 1]})
        gb.compute_geometry()
        meshing.create_mortar_grids(gb)
        gb.assign_node_ordering()

        for e, d in gb.edges():

            # refine the 1d-physical grid
            old_g = gb.nodes_of_edge(e)[0]
            new_g = refinement.remesh_1d(old_g, num_nodes=5)
            new_g.compute_geometry()

            gb.update_nodes({old_g: new_g})
            mg = d["mortar_grid"]
            mortars.update_physical_low_grid(mg, new_g, 1e-4)

            high_to_mortar_known = np.matrix(
                [
                    [0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
                    [0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
                    [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
                    [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
                ]
            )
            low_to_mortar_known = np.matrix(
                [
                    [0., 0., 0.5, 0.5],
                    [0.5, 0.5, 0., 0.],
                    [0., 0., 0.5, 0.5],
                    [0.5, 0.5, 0., 0.],
                ]
            )

            self.assertTrue(
                np.allclose(high_to_mortar_known, mg.high_to_mortar_int.todense())
            )

            # The ordering of the cells in the new 1d grid may be flipped on
            # some systems; therefore allow two configurations
            self.assertTrue(
                np.logical_or(
                    np.allclose(low_to_mortar_known, mg.low_to_mortar_int.todense()),
                    np.allclose(
                        low_to_mortar_known, mg.low_to_mortar_int.todense()[::-1]
                    ),
                )
            )