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
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]
),
)
)
def create_gb(cells_2d, alpha_1d=None, alpha_mortar=None):
mesh_size = np.sqrt(2 / cells_2d)
mesh_kwargs = {
"tol": tol(),
"mesh_size_frac": mesh_size,
"mesh_size_min": mesh_size / 20,
}
mesh_kwargs = {"mesh_size_frac": mesh_size, "mesh_size_min": mesh_size / 20}
file_name = "example_1_split.csv"
gb = pp.importer.dfm_2d_from_csv(file_name, mesh_kwargs, domain())
g_map = {}
if alpha_1d is not None:
for g, d in gb:
if g.dim == 1:
num_nodes = int(g.num_nodes * alpha_1d)
g_map[g] = refinement.remesh_1d(g, num_nodes=num_nodes)
g_map[g].compute_geometry()
mg_map = {}
if alpha_mortar is not None:
for e, d in gb.edges():
mg = d["mortar_grid"]
if mg.dim == 1:
mg_map[mg] = {}
for s, g in mg.side_grids.items():
num_nodes = int(g.num_nodes * alpha_mortar)
mg_map[mg][s] = refinement.remesh_1d(g, num_nodes=num_nodes)
gb = mortars.replace_grids_in_bucket(gb, g_map, mg_map, tol())
gb.assign_node_ordering()
return gb
def test_mortar_grid_1d_equally_refine_mortar_grids(self):
f1 = np.array([[0, 1], [.5, .5]])
gb = meshing.cart_grid([f1], [2, 2], **{"physdims": [1, 1]})
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=4)
for s, g in mg.side_grids.items()
}
mortars.update_mortar_grid(mg, new_side_grids, 1e-4)
high_to_mortar_known = (
1.
/ 3.
* np.matrix(
[
[0., 0., 0., 0., 0., 0., 0., 0., 2., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 2., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 2., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 2.],
]
)
)
low_to_mortar_known = (
1.
/ 3.
* np.matrix(
[[0., 2.], [1., 1.], [2., 0.], [0., 2.], [1., 1.], [2., 0.]]
)
)
self.assertTrue(
np.allclose(high_to_mortar_known, mg.high_to_mortar_int.todense())
)
self.assertTrue(
np.allclose(low_to_mortar_known, mg.low_to_mortar_int.todense())
)
def test_mortar_grid_1d_refine_1d_grid_2(self):
""" Refine the 1D grid so that it is no longer matching the 2D grid.
"""
f1 = np.array([[0, 1], [0.5, 0.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=4)
new_g.compute_geometry()
gb.update_nodes({old_g: new_g})
mg = d["mortar_grid"]
mg.update_slave(new_g, 1e-4)
high_to_mortar_known = np.matrix([
[
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.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.0,
0.0,
0.0,
0.0,
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.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.0,
0.0,
],
])
low_to_mortar_known = (
1.0 / 3.0 * np.matrix([[0.0, 1.0, 2.0], [2.0, 1.0, 0.0],
[0.0, 1.0, 2.0], [2.0, 1.0, 0.0]]))
self.assertTrue(
np.allclose(high_to_mortar_known,
mg.master_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.slave_to_mortar_int().todense()),
np.allclose(low_to_mortar_known,
mg.slave_to_mortar_int().todense()[::-1]),
))
def test_mortar_grid_1d_unequally_refine_mortar_grids(self):
f1 = np.array([[0, 1], [0.5, 0.5]])
gb = meshing.cart_grid([f1], [2, 2], **{"physdims": [1, 1]})
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=int(s) + 3)
for s, g in mg.side_grids.items()
}
mg.update_mortar(new_side_grids, 1e-4)
high_to_mortar_known = np.matrix([
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.66666667,
0.0,
0.0,
0.0,
0.0,
0.0,
],
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.33333333,
0.33333333,
0.0,
0.0,
0.0,
0.0,
],
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.66666667,
0.0,
0.0,
0.0,
0.0,
],
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.5,
0.0,
],
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.5,
0.0,
],
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.5,
],
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.5,
],
])
low_to_mortar_known = np.matrix([
[0.0, 0.66666667],
[0.33333333, 0.33333333],
[0.66666667, 0.0],
[0.0, 0.5],
[0.0, 0.5],
[0.5, 0.0],
[0.5, 0.0],
])
self.assertTrue(
np.allclose(high_to_mortar_known,
mg.master_to_mortar_int().todense()))
self.assertTrue(
np.allclose(low_to_mortar_known,
mg.slave_to_mortar_int().todense()))
def setup(
self,
num_fracs=1,
remove_tags=False,
alpha_1d=None,
alpha_mortar=None,
alpha_2d=None,
):
domain = {"xmin": 0, "xmax": 1, "ymin": 0, "ymax": 1}
if num_fracs == 0:
p = np.zeros((2, 0))
elif num_fracs == 1:
p = [np.array([[0, 1], [0.5, 0.5]])]
# p = [np.array([[0.5, 0.5], [0, 1]])]
elif num_fracs == 2:
p = [
np.array([[0, 0.5], [0.5, 0.5]]),
np.array([[0.5, 1], [0.5, 0.5]]),
np.array([[0.5, 0.5], [0, 0.5]]),
np.array([[0.5, 0.5], [0.5, 1]]),
]
mesh_size = {"value": 0.3, "bound_value": 0.3}
gb = meshing.simplex_grid(fracs=p,
domain=domain,
mesh_size=mesh_size,
verbose=0)
# gb = meshing.cart_grid([np.array([[0.5, 0.5], [0, 1]])],np.array([10, 10]),
# physdims=np.array([1, 1]))
gmap = {}
# Refine 2D grid?
if alpha_2d is not None:
mesh_size = {
"value": 0.3 * alpha_2d,
"bound_value": 0.3 * alpha_2d
}
gbn = meshing.simplex_grid(fracs=p,
domain=domain,
mesh_size=mesh_size,
verbose=0)
go = gb.grids_of_dimension(2)[0]
gn = gbn.grids_of_dimension(2)[0]
gn.compute_geometry()
gmap[go] = gn
# Refine 1d grids
if alpha_1d is not None:
for g, d in gb:
if g.dim == 1:
if alpha_1d > 1:
num_nodes = 1 + int(alpha_1d) * g.num_cells
else:
num_nodes = 1 + int(alpha_1d * g.num_cells)
num_nodes = 1 + int(alpha_1d * g.num_cells)
gmap[g] = refinement.remesh_1d(g, num_nodes=num_nodes)
gmap[g].compute_geometry()
# Refine mortar grid
mg_map = {}
if alpha_mortar is not None:
for e, d in gb.edges():
mg = d["mortar_grid"]
if mg.dim == 1:
mg_map[mg] = {}
for s, g in mg.side_grids.items():
num_nodes = int(g.num_nodes * alpha_mortar)
mg_map[mg][s] = refinement.remesh_1d(
g, num_nodes=num_nodes)
gb = mortars.replace_grids_in_bucket(gb, gmap, mg_map, tol=1e-4)
# if remove_tags:
# internal_flag = FaceTag.FRACTURE
# [g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb]
gb.assign_node_ordering()
self.set_params(gb)
return gb
