def test_geiger_3d_partial():
f_1 = np.array([[0.5, 0, 0], [0.5, 1, 0], [0.5, 1, 1], [0.5, 0, 1]]).T
f_2 = np.array([[0, 0.5, 0], [1, 0.5, 0], [1, 0.5, 1], [0, 0.5, 1]]).T
f_3 = np.array([[0, 0, 0.5], [1, 0, 0.5], [1, 1, 0.5], [0, 1, 0.5]]).T
f_4 = np.array([[0.5, 0.5, 0.75], [1.0, 0.5, 0.75], [1.0, 1.0, 0.75],
[0.5, 1.0, 0.75]]).T
f_5 = np.array([[0.75, 0.5, 0.5], [0.75, 1.0, 0.5], [0.75, 1.0, 1.0],
[0.75, 0.5, 1.0]]).T
domain = {'xmin': 0, 'xmax': 1, 'ymin': 0, 'ymax': 1, 'zmin': 0, 'zmax': 1}
kwargs = {
'mesh_size_frac': .4,
'mesh_size_bound': 1,
'mesh_size_min': .2,
'return_expected': True
}
meshing.simplex_grid([f_1, f_2, f_3, f_4, f_5], domain, **kwargs)
def test_T_intersection_one_boundary_one_inside(**kwargs):
p1 = np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]]).T
p2 = np.array([[0.2, 0.5, 0], [1, 0.5, 0], [0.5, 0.5, 1.]]).T
domain = {'xmin':-1, 'xmax': 2, 'ymin': -2, 'ymax': 2, 'zmin': -1,
'zmax':2}
grids = meshing.simplex_grid([p1, p2], domain)
def dfm_3d_from_csv(file_name,
tol=1e-4,
elliptic_fractures=False,
**mesh_kwargs):
"""
Create the grid bucket from a set of 3d fractures stored in a csv file and
domain. In the csv file, we assume the following structure
- first line describes the domain as a rectangle with
X_MIN, Y_MIN, Z_MIN, X_MAX, Y_MAX, Z_MAX
- the other lines descibe the N fractures as a list of points
P0_X, P0_Y, P0_Z, ...,PN_X, PN_Y, PN_Z
Parameters:
file_name: name of the file
tol: (optional) tolerance for the methods
mesh_kwargs: kwargs for the gridding, see meshing.simplex_grid
Return:
gb: the grid bucket
"""
if elliptic_fractures:
frac_list, network, domain = elliptic_network_3d_from_csv(file_name)
else:
frac_list, network, domain = network_3d_from_csv(file_name)
gb = meshing.simplex_grid(domain=domain, network=network, **mesh_kwargs)
return gb, domain
def dfm_3d_from_fab(file_name,
tol=1e-4,
domain=None,
return_domain=False,
**mesh_kwargs):
"""
Create the grid bucket from a set of 3d fractures stored in a fab file and
domain.
Parameters:
file_name: name of the file
tol: (optional) tolerance for the methods
domain: (optional) the domain, otherwise a bounding box is considered
mesh_kwargs: kwargs for the gridding, see meshing.simplex_grid
Return:
gb: the grid bucket
"""
network = network_3d_from_fab(file_name, return_all=False, tol=tol)
# Define the domain as bounding-box if not defined
if domain is None:
domain = network.bounding_box()
gb = meshing.simplex_grid(domain=domain, network=network, **mesh_kwargs)
if return_domain:
return gb, domain
else:
return gb
def test_two_intersecting_fractures(**kwargs):
"""
Two fractures intersecting along a line.
The example also sets different characteristic mesh lengths on the boundary
and at the fractures.
"""
f_1 = np.array([[-1, 1, 1, -1], [0, 0, 0, 0], [-1, -1, 1, 1]])
f_2 = np.array([[0, 0, 0, 0], [-1, 1, 1, -1], [-.7, -.7, .8, .8]])
domain = {
"xmin": -2,
"xmax": 2,
"ymin": -2,
"ymax": 2,
"zmin": -2,
"zmax": 2
}
kwargs = {"mesh_size_frac": .5, "mesh_size_bound": 1, "mesh_size_min": .2}
grids = meshing.simplex_grid([f_1, f_2], domain, **kwargs)
if kwargs.get("return_expected", False):
return grids, [1, 2, 1, 0]
else:
return grids
def test_geiger_3d_partial():
f_1 = np.array([[0.5, 0, 0], [0.5, 1, 0], [0.5, 1, 1], [0.5, 0, 1]]).T
f_2 = np.array([[0, 0.5, 0], [1, 0.5, 0], [1, 0.5, 1], [0, 0.5, 1]]).T
f_3 = np.array([[0, 0, 0.5], [1, 0, 0.5], [1, 1, 0.5], [0, 1, 0.5]]).T
f_4 = np.array([[0.5, 0.5, 0.75], [1.0, 0.5, 0.75], [1.0, 1.0, 0.75],
[0.5, 1.0, 0.75]]).T
f_5 = np.array([[0.75, 0.5, 0.5], [0.75, 1.0, 0.5], [0.75, 1.0, 1.0],
[0.75, 0.5, 1.0]]).T
domain = {"xmin": 0, "xmax": 1, "ymin": 0, "ymax": 1, "zmin": 0, "zmax": 1}
kwargs = {
"mesh_size_frac": .4,
"mesh_size_bound": 1,
"mesh_size_min": .2,
"return_expected": True,
}
meshing.simplex_grid([f_1, f_2, f_3, f_4, f_5], domain, **kwargs)
def test_three_intersecting_fractures(**kwargs):
"""
Three fractures intersecting, with intersecting intersections (point)
"""
f_1 = np.array([[-1, 1, 1, -1], [0, 0, 0, 0], [-1, -1, 1, 1]])
f_2 = np.array([[0, 0, 0, 0], [-1, 1, 1, -1], [-.7, -.7, .8, .8]])
f_3 = np.array([[-1, 1, 1, -1], [-1, -1, 1, 1], [0, 0, 0, 0]])
# Add some parameters for grid size
domain = {
"xmin": -2,
"xmax": 2,
"ymin": -2,
"ymax": 2,
"zmin": -2,
"zmax": 2
}
kwargs = {"mesh_size_frac": .5, "mesh_size_bound": 1, "mesh_size_min": .2}
grids = meshing.simplex_grid([f_1, f_2, f_3], domain, **kwargs)
if kwargs.get("return_expected", False):
return grids, [1, 3, 6, 1]
else:
return grids
def test_one_fracture_intersected_by_two(**kwargs):
"""
One fracture, intersected by two other (but no point intersections)
"""
f_1 = np.array([[-1, 1, 1, -1], [0, 0, 0, 0], [-1, -1, 1, 1]])
f_2 = np.array([[0, 0, 0, 0], [-1, 1, 1, -1], [-.7, -.7, .8, .8]])
f_3 = f_2 + np.array([0.5, 0, 0]).reshape((-1, 1))
# Add some parameters for grid size
domain = {
"xmin": -2,
"xmax": 2,
"ymin": -2,
"ymax": 2,
"zmin": -2,
"zmax": 2
}
kwargs = {"mesh_size_frac": .4, "mesh_size_bound": 1, "mesh_size_min": .2}
grids = meshing.simplex_grid([f_1, f_2, f_3], domain, **kwargs)
if kwargs.get("return_expected", False):
return grids, [1, 3, 2, 0]
else:
return grids
def __init__(self, *args, **kwargs):
f = np.array([[1, 1, 4], [3, 4, 1], [2, 2, 4]])
box = {'xmin': 0, 'ymin': 0, 'zmin': 0,
'xmax': 5, 'ymax': 5, 'zmax': 5}
self.gb3d = meshing.simplex_grid([f], box, h_min= 5, h_ideal=5)
unittest.TestCase.__init__(self, *args, **kwargs)
def test_T_intersection_both_outside_plane(**kwargs):
p1 = np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]]).T
p2 = np.array([[0.5, 0.5, 1], [0.5, -0.5, 0], [0.5, 1.9, 0.]]).T
domain = {'xmin':-1, 'xmax': 2, 'ymin': -2, 'ymax': 2, 'zmin': -1,
'zmax':2}
grids = meshing.simplex_grid([p1, p2], domain)
def setup_2d_1d(nx, simplex_grid=False):
frac1 = np.array([[0.2, 0.8], [0.5, 0.5]])
frac2 = np.array([[0.5, 0.5], [0.8, 0.2]])
fracs = [frac1, frac2]
if not simplex_grid:
gb = meshing.cart_grid(fracs, nx, physdims=[1, 1])
else:
mesh_kwargs = {}
mesh_size = .3
mesh_kwargs['mesh_size'] = {'mode': 'constant',
'value': mesh_size, 'bound_value': 1 * mesh_size}
domain = {'xmin': 0, 'ymin': 0, 'xmax': 1, 'ymax': 1}
gb = meshing.simplex_grid(fracs, domain, **mesh_kwargs)
gb.compute_geometry()
gb.assign_node_ordering()
gb.add_node_props(['param'])
for g, d in gb:
kxx = np.ones(g.num_cells)
perm = tensor.SecondOrder(3, kxx)
a = 0.01 / np.max(nx)
a = np.power(a, gb.dim_max() - g.dim)
param = Parameters(g)
param.set_tensor('flow', perm)
param.set_aperture(a)
if g.dim == 2:
bound_faces = g.get_boundary_faces()
bound = bc.BoundaryCondition(g, bound_faces.ravel('F'),
['dir'] * bound_faces.size)
bc_val = g.face_centers[1]
param.set_bc('flow', bound)
param.set_bc_val('flow', bc_val)
d['param'] = param
return gb
def test_issue_58_3():
domain = {'xmin': -2, 'xmax': 2, 'ymin': -2, 'ymax': 2,
'zmin': -2, 'zmax': 2}
mesh_size = {'mode': 'constant', 'value': .4, 'bound_value': 1}
kwargs = {'mesh_size': mesh_size, 'return_expected': True}
f_1 = np.array([[0, 1, 1, 0], [0, 0, 1, 1], [0, 0, 0, 0]])
f_2 = np.array([[0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 1, 1]])
grids = meshing.simplex_grid([f_1, f_2], domain,**kwargs)
def dfm_2d_from_csv(f_name,
mesh_kwargs,
domain=None,
return_domain=False,
tol=1e-8,
polyline=False,
**kwargs):
"""
Create the grid bucket from a set of fractures stored in a csv file and a
domain. In the csv file, we assume the following structure:
FID, START_X, START_Y, END_X, END_Y
Where FID is the fracture id, START_X and START_Y are the abscissa and
coordinate of the starting point, and END_X and END_Y are the abscissa and
coordinate of the ending point.
Note: the delimiter can be different.
Parameters:
f_name: the file name in CSV format
mesh_kwargs: list of additional arguments for the meshing
domain: rectangular domain, if not given the bounding-box is computed
kwargs: list of argument for the numpy function genfromtxt
Returns:
gb: grid bucket associated to the configuration.
domain: if the domain is not given as input parameter, the bounding box
is returned.
"""
pts, edges = lines_from_csv(f_name, tol=tol, polyline=polyline, **kwargs)
f_set = np.array([pts[:, e] for e in edges.T])
# Define the domain as bounding-box if not defined
if domain is None:
overlap = kwargs.get("domain_overlap", 0)
domain = cg.bounding_box(pts, overlap)
if kwargs.get("assign_fracture_id", False):
mesh_kwargs["fracture_id"] = np.arange(edges.shape[1])
if return_domain:
return meshing.simplex_grid(f_set, domain, **mesh_kwargs), domain
else:
return meshing.simplex_grid(f_set, domain, **mesh_kwargs)
def setup(self, num_fracs=1, remove_tags=False):
domain = {
"xmin": 0,
"xmax": 1,
"ymin": 0,
"ymax": 1,
"zmin": 0,
"zmax": 1
}
if num_fracs == 0:
fl = None
elif num_fracs == 1:
fl = [
Fracture(
np.array([[0, 1, 1, 0], [0.5, 0.5, 0.5, 0.5], [0, 0, 1,
1]]))
]
elif num_fracs == 2:
fl = [
Fracture(
np.array([[0, 1, 1, 0], [0.5, 0.5, 0.5, 0.5], [0, 0, 1,
1]])),
Fracture(
np.array([[0.5, 0.5, 0.5, 0.5], [0, 1, 1, 0], [0, 0, 1,
1]])),
]
elif num_fracs == 3:
fl = [
Fracture(
np.array([[0, 1, 1, 0], [0.5, 0.5, 0.5, 0.5], [0, 0, 1,
1]])),
Fracture(
np.array([[0.5, 0.5, 0.5, 0.5], [0, 1, 1, 0], [0, 0, 1,
1]])),
Fracture(
np.array([[0, 1, 1, 0], [0, 0, 1, 1], [0.5, 0.5, 0.5,
0.5]])),
]
gb = meshing.simplex_grid(fracs=fl,
domain=domain,
h_min=0.5,
h_ideal=0.5,
verbose=0)
# if remove_tags:
# internal_flag = FaceTag.FRACTURE
# [g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb]
self.set_params(gb)
return gb
def test_one_fracture_touches_boundary_and_corner(**kwargs):
f_1 = np.array([[-2, 2, 2, -2], [-2, 1, 1, -2], [-2, -2, 2, 2]])
kwargs, domain = kwarguments_and_domain()
grids = meshing.simplex_grid([f_1], domain, **kwargs)
if kwargs.get("return_expected", False):
return grids, [1, 2, 0, 0]
else:
return grids
def setup_3d(nx, simplex_grid=False):
f1 = np.array([[0.2, 0.2, 0.8, 0.8], [0.2, 0.8, 0.8, 0.2],
[0.5, 0.5, 0.5, 0.5]])
f2 = np.array([[0.2, 0.8, 0.8, 0.2], [0.5, 0.5, 0.5, 0.5],
[0.2, 0.2, 0.8, 0.8]])
f3 = np.array([[0.5, 0.5, 0.5, 0.5], [0.2, 0.8, 0.8, 0.2],
[0.2, 0.2, 0.8, 0.8]])
fracs = [f1, f2, f3]
if not simplex_grid:
gb = meshing.cart_grid(fracs, nx, physdims=[1, 1, 1])
else:
mesh_kwargs = {}
mesh_size = .3
mesh_kwargs['mesh_size'] = {
'mode': 'constant',
'value': mesh_size,
'bound_value': 2 * mesh_size
}
domain = {'xmin': 0, 'ymin': 0, 'xmax': 1, 'ymax': 1}
gb = meshing.simplex_grid(fracs, domain, **mesh_kwargs)
internal_flag = FaceTag.FRACTURE
[g.remove_face_tag_if_tag(FaceTag.BOUNDARY, internal_flag) for g, _ in gb]
gb.add_node_props(['param'])
for g, d in gb:
a = 0.01 / np.max(nx)
a = np.power(a, gb.dim_max() - g.dim)
param = Parameters(g)
param.set_aperture(a)
# BoundaryCondition
left = g.face_centers[0] < 1e-6
top = g.face_centers[2] > 1 - 1e-6
dir_faces = np.argwhere(left)
bc_cond = bc.BoundaryCondition(g, dir_faces, ['dir'] * dir_faces.size)
bc_val = np.zeros(g.num_faces)
bc_val[dir_faces] = 3
bc_val[top] = 2.4
param.set_bc('flow', bc_cond)
param.set_bc_val('flow', bc_val)
# Source and sink
src = np.zeros(g.num_cells)
src[0] = np.pi
src[-1] = -np.pi
param.set_source('flow', src)
d['param'] = param
gb.add_edge_prop('kn')
for e, d in gb.edges_props():
g = gb.sorted_nodes_of_edge(e)[0]
d['kn'] = 1 / gb.node_prop(g, 'param').get_aperture()
return gb
def test_two_fractures_touching_one_boundary(**kwargs):
f_1 = np.array([[-1, 2, 2, -1], [0, 0, 0, 0], [-1, -1, 1, 1]])
f_2 = np.array([[-1, -1, 2, 2], [-1, 1, 1, -1], [0, 0, 0, 0]])
kwargs, domain = kwarguments_and_domain()
grids = meshing.simplex_grid([f_1, f_2], domain, **kwargs)
if kwargs.get("return_expected", False):
return grids, [1, 2, 1, 0]
else:
return grids
return grids
def setup_3d(nx, simplex_grid=False):
f1 = np.array([[0.2, 0.2, 0.8, 0.8], [0.2, 0.8, 0.8, 0.2],
[0.5, 0.5, 0.5, 0.5]])
f2 = np.array([[0.2, 0.8, 0.8, 0.2], [0.5, 0.5, 0.5, 0.5],
[0.2, 0.2, 0.8, 0.8]])
f3 = np.array([[0.5, 0.5, 0.5, 0.5], [0.2, 0.8, 0.8, 0.2],
[0.2, 0.2, 0.8, 0.8]])
fracs = [f1, f2, f3]
if not simplex_grid:
gb = meshing.cart_grid(fracs, nx, physdims=[1, 1, 1])
else:
mesh_kwargs = {}
mesh_size = .3
mesh_kwargs = {
"mesh_size_frac": mesh_size,
"mesh_size_bound": 2 * mesh_size,
"mesh_size_min": mesh_size / 20,
}
domain = {"xmin": 0, "ymin": 0, "xmax": 1, "ymax": 1}
gb = meshing.simplex_grid(fracs, domain, **mesh_kwargs)
gb.add_node_props(["param"])
for g, d in gb:
a = 0.01 / np.max(nx)
a = np.power(a, gb.dim_max() - g.dim)
param = Parameters(g)
param.set_aperture(a)
# BoundaryCondition
left = g.face_centers[0] < 1e-6
top = g.face_centers[2] > 1 - 1e-6
dir_faces = np.argwhere(left)
bc_cond = bc.BoundaryCondition(g, dir_faces, ["dir"] * dir_faces.size)
bc_val = np.zeros(g.num_faces)
bc_val[dir_faces] = 3
bc_val[top] = 2.4
param.set_bc("flow", bc_cond)
param.set_bc_val("flow", bc_val)
# Source and sink
src = np.zeros(g.num_cells)
src[0] = np.pi
src[-1] = -np.pi
param.set_source("flow", src)
d["param"] = param
gb.add_edge_props("kn")
for e, d in gb.edges():
g = gb.nodes_of_edge(e)[0]
mg = d["mortar_grid"]
check_P = mg.low_to_mortar_avg()
d["kn"] = 1 / (check_P * gb.node_props(g, "param").get_aperture())
return gb
def test_T_intersection_within_plane(**kwargs):
p1 = np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]]).T
p2 = np.array([[0.5, 0.5, 1], [0.5, 0.5, 0], [0.5, .9, 0.]]).T
domain = {'xmin':-1, 'xmax': 2, 'ymin': -2, 'ymax': 2, 'zmin': -1,
'zmax':2}
# This test, when used with certain versions of gmsh (<2.15?) gives a
# a mismatch between 2d cells and 3d faces on fracture surfaces. The bug
# can be located in the .msh-file. To function as a test, we disband the
# test of cell-face relations.
grids = meshing.simplex_grid([p1, p2], domain,
ensure_matching_face_cell=False)
def define_grid():
"""
Make cartesian grids and a bucket. One horizontal and one vertical 1d
fracture in a 2d matrix domain.
"""
h_max = 0.018
mesh_size_min = h_max / 3
domain = {
"xmin": 0.2,
"xmax": 0.8,
"ymin": 0.25,
"ymax": 0.75,
"zmin": 0.5,
"zmax": 0.7,
}
f_1 = np.array([[0.2, 0.8, 0.8, 0.2], [0.5, 0.5, 0.5, 0.5], [0.5, 0.5, 0.7, 0.7]])
f_2 = np.array([[0.5, 0.5, 0.5, 0.5], [0.3, 0.7, 0.7, 0.3], [0.5, 0.5, 0.7, 0.7]])
f_3 = np.array(
[[0.7, 0.7, 0.7, 0.7], [0.25, 0.75, 0.75, 0.25], [0.5, 0.5, 0.7, 0.7]]
)
f_4 = np.array(
[[0.3, 0.3, 0.3, 0.3], [0.25, 0.75, 0.75, 0.25], [0.5, 0.5, 0.7, 0.7]]
)
c_1 = np.array([0.35, 0.6, 0.6])
c_5 = np.array([0.35, 0.4, 0.6])
c_2 = np.array([0.65, 0.38, 0.65])
c_3 = np.array([0.65, 0.62, 0.65])
c_4 = np.array([0.5, 0.5, 0.6])
ma_1, mi_1, a_1, s_1, d_1 = 0.15, 0.08, -5 / 9, -5 / 9, np.pi / 2
ma_5, mi_5, a_5, s_5, d_5 = 0.15, 0.08, 5 / 9, 5 / 9, np.pi / 2
ma_2, mi_2, a_2, s_2, d_2 = 0.12, 0.07, -np.pi / 4, 0, 0
ma_3, mi_3, a_3, s_3, d_3 = 0.12, 0.07, np.pi / 4, 0, 0
ma_4, mi_4, a_4, s_4, d_4 = 0.08, 0.08, 0, 0, 0
fracs = [
f_1,
f_2,
f_3,
f_4,
EllipticFracture(c_1, ma_1, mi_1, a_1, s_1, d_1),
EllipticFracture(c_2, ma_2, mi_2, a_2, s_2, d_2),
EllipticFracture(c_3, ma_3, mi_3, a_3, s_3, d_3),
EllipticFracture(c_4, ma_4, mi_4, a_4, s_4, d_4),
EllipticFracture(c_5, ma_5, mi_5, a_5, s_5, d_5),
]
gb = meshing.simplex_grid(
fracs, domain, mesh_size_frac=h_max, mesh_size_min=mesh_size_min
)
gb.compute_geometry()
gb.assign_node_ordering()
return gb
def test_one_fracture_touching_three_boundaries(**kwargs):
"""
Three fractures intersecting, with intersecting intersections (point)
"""
f_1 = np.array([[-2, 2, 2, -2], [0, 0, 0, 0], [-1, -1, 2, 2]])
kwargs, domain = kwarguments_and_domain()
grids = meshing.simplex_grid([f_1], domain, **kwargs)
if kwargs.get("return_expected", False):
return grids, [1, 1, 0, 0]
else:
return grids
def test_issue_58_1():
domain = {
"xmin": -2,
"xmax": 2,
"ymin": -2,
"ymax": 2,
"zmin": -2,
"zmax": 2
}
kwargs = {"mesh_size_frac": .4, "mesh_size_bound": 1, "mesh_size_min": .2}
f_1 = np.array([[0, 1, 1, 0], [0, 0, 1, 1], [0, 0, 0, 0]])
f_2 = np.array([[0, 1, 1, 0], [0, .5, .5, 0], [0, 0, 1, 1]])
grids = meshing.simplex_grid([f_1, f_2], domain, **kwargs)
def test_issue_58_1():
domain = {
'xmin': -2,
'xmax': 2,
'ymin': -2,
'ymax': 2,
'zmin': -2,
'zmax': 2
}
kwargs = {'mesh_size_frac': .4, 'mesh_size_bound': 1, 'mesh_size_min': .2}
f_1 = np.array([[0, 1, 1, 0], [0, 0, 1, 1], [0, 0, 0, 0]])
f_2 = np.array([[0, 1, 1, 0], [0, .5, .5, 0], [0, 0, 1, 1]])
grids = meshing.simplex_grid([f_1, f_2], domain, **kwargs)
def test_T_intersection_one_boundary_one_outside(**kwargs):
p1 = np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]]).T
p2 = np.array([[-0.2, 0.5, 0], [1, 0.5, 0], [0.5, 0.5, 1.]]).T
domain = {
"xmin": -1,
"xmax": 2,
"ymin": -2,
"ymax": 2,
"zmin": -1,
"zmax": 2
}
grids = meshing.simplex_grid([p1, p2], domain)
def test_split_into_octants(**kwargs):
f_1 = np.array([[-1, 1, 1, -1], [0, 0, 0, 0], [-1, -1, 1, 1]])
f_2 = np.array([[-1, -1, 1, 1], [-1, 1, 1, -1], [0, 0, 0, 0]])
f_3 = np.array([[0, 0, 0, 0], [-1, 1, 1, -1], [-1, -1, 1, 1]])
domain = {'xmin': -2, 'xmax': 2, 'ymin': -2, 'ymax': 2, 'zmin': -2, 'zmax':
2}
grids = meshing.simplex_grid([f_1, f_2, f_3], domain, **kwargs)
if kwargs.get('return_expected', False):
return grids, [1, 3, 6, 1]
else:
return grids
return grids
def test_two_fractures_L_intersection(**kwargs):
"""
Two fractures sharing a segment in an L-intersection.
"""
f_1 = np.array([[0, 1, 1, 0], [0, 0, 1, 1], [0, 0, 0, 0]])
f_2 = np.array([[0, 0, 0, 0], [0, 1, 1, 0], [0, 0, 1, 1]])
domain = {'xmin': -2, 'xmax': 2, 'ymin': -2, 'ymax': 2, 'zmin': -2, 'zmax':
2}
grids = meshing.simplex_grid([f_1, f_2], domain, **kwargs)
if kwargs.get('return_expected', False):
return grids, [1, 2, 1, 0]
else:
return grids
def test_two_fractures_L_intersection_one_displaced(**kwargs):
"""
Two fractures sharing what is a part of segments for both.
"""
f_1 = np.array([[0, 1, 1, 0], [0, 0, 1, 1], [0, 0, 0, 0]])
f_2 = np.array([[0, 0, 0, 0], [0.5, 1.5, 1.5, 0.5], [0, 0, 1, 1]])
domain = {'xmin': -2, 'xmax': 2, 'ymin': -2, 'ymax': 2, 'zmin': -2, 'zmax':
2}
grids = meshing.simplex_grid([f_2, f_1], domain, **kwargs)
if kwargs.get('return_expected', False):
return grids, [1, 2, 1, 0]
else:
return grids
def test_issue_54():
domain = {
"xmin": -1,
"xmax": 1,
"ymin": 0,
"ymax": 1,
"zmin": 0,
"zmax": 1
}
f_1 = np.array([[.5, .5, .5, .5], [.4, .5, .5, .4], [0.2, 0.2, .8, .8]])
f_2 = np.array([[0, .8, .8, 0], [.5, .5, .5, .5], [0.2, 0.2, .8, .8]])
grids = meshing.simplex_grid([f_1, f_2],
domain,
ensure_matching_face_cell=False)
def test_single_isolated_fracture(**kwargs):
"""
A single fracture completely immersed in a boundary grid.
"""
f_1 = np.array([[-1, 1, 1, -1], [0, 0, 0, 0], [-1, -1, 1, 1]])
domain = {'xmin': -2, 'xmax': 2, 'ymin': -2, 'ymax': 2, 'zmin': -2, 'zmax':
2}
grids = meshing.simplex_grid([f_1], domain, **kwargs)
if kwargs.get('return_expected', False):
expected = [1, 1, 0, 0]
return grids, expected
else:
return grids
def test_two_fractures_L_intersection_part_of_segment(**kwargs):
"""
Two fractures sharing what is a full segment for one, an part of a segment
for the other.
"""
f_1 = np.array([[0, 1, 1, 0], [0, 0, 1, 1], [0, 0, 0, 0]])
f_2 = np.array([[0, 0, 0, 0], [0.3, 0.7, 0.7, 0.3], [0, 0, 1, 1]])
domain = {'xmin': -2, 'xmax': 2, 'ymin': -2, 'ymax': 2, 'zmin': -2, 'zmax':
2}
grids = meshing.simplex_grid([f_1, f_2], domain, **kwargs)
if kwargs.get('return_expected', False):
return grids, [1, 2, 1, 0]
else:
return grids
