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