def gb_coarse_fine_cell_mapping( gb: pp.GridBucket, gb_ref: pp.GridBucket, tol=1e-8 ): """ Wrapper for coarse_fine_cell_mapping to construct mapping for grids in GridBucket. Parameters ---------- gb : pp.GridBucket Coarse grid bucket gb_ref : pp.GridBucket Refined grid bucket tol : float, Optional Tolerance for point_in_poly* -methods Returns ------- mapping : list of tuples with entries (pp.GridBucket, pp.GridBucket, sps.csc_matrix) The first entry is the coarse grid. The second entry is the refined grid. The third entry is the mapping from coarse to fine cells """ grids = gb.get_grids() grids_ref = gb_ref.get_grids() assert len(grids) == len(grids_ref), "Weakly check that GridBuckets refer to same domains" assert np.array_equal(np.append(*gb.bounding_box()), np.append(*gb_ref.bounding_box())), \ "Weakly check that GridBuckets refer to same domains" # This method assumes a consistent node ordering between grids. At least assign one. gb.assign_node_ordering(overwrite_existing=False) gb_ref.assign_node_ordering(overwrite_existing=False) n_grids = len(grids) # mappings = [None]*n_grids mappings = {'gb': gb, 'gb_ref': gb_ref} for i in np.arange(n_grids): g, g_ref = grids[i], grids_ref[i] node_num, node_num_ref = gb._nodes[g]['node_number'], gb_ref._nodes[g_ref]['node_number'] assert node_num == node_num_ref, "Weakly check that grids refer to same domain." mapping = coarse_fine_cell_mapping(g, g_ref, tol=tol) mappings[(g, g_ref)] = {'node_number': node_num, 'data': gb.node_props(g), 'data_ref': gb_ref.node_props(g_ref)} return mappings
def gb_coarse_fine_cell_mapping( gb: pp.GridBucket, gb_ref: pp.GridBucket, tol=1e-8 ) -> None: """ Wrapper for coarse_fine_cell_mapping to construct mapping for grids in GridBucket. Adds a node_prop to each grid in gb. The key is 'coarse_fine_cell_mapping', and is the mapping generated by 'coarse_fine_cell_mapping(...)'. Note: No node prop is added to the reference grids in gb_ref. Parameters ---------- gb : pp.GridBucket Coarse grid bucket gb_ref : pp.GridBucket Refined grid bucket tol : float, Optional Tolerance for point_in_poly* -methods """ grids = gb.get_grids() grids_ref = gb_ref.get_grids() assert len(grids) == len( grids_ref ), "Weakly check that GridBuckets refer to same domains" assert np.allclose( np.append(*gb.bounding_box()), np.append(*gb_ref.bounding_box()) ), "Weakly check that GridBuckets refer to same domains" # This method assumes a consistent node ordering between grids. # At least assign one. gb.assign_node_ordering(overwrite_existing=False) gb_ref.assign_node_ordering(overwrite_existing=False) # Add node prop on the coarse grid to map from coarse to fine cells. gb.add_node_props(keys="coarse_fine_cell_mapping") for i in np.arange(len(grids)): g, g_ref = grids[i], grids_ref[i] node_num = gb.node_props(g, "node_number") node_num_ref = gb_ref.node_props(g_ref, "node_number") assert node_num == node_num_ref, "Weakly check that grids refer to same domain." # Compute the mapping for this grid-pair, # and assign the result to the node of the coarse gb mapping = coarse_fine_cell_mapping(g, g_ref, point_in_poly_tol=tol) gb.set_node_prop(g, key="coarse_fine_cell_mapping", val=mapping)
def gb(self, gb: pp.GridBucket): """ Set a grid bucket to the class """ self._gb = gb if gb is None: return pp.contact_conditions.set_projections(self.gb) self.gb.add_node_props( keys=["name"]) # Add 'name' as node prop to all grids. # Set the bounding box self.bounding_box = gb.bounding_box(as_dict=True) # Set Nd grid name self.gb.set_node_prop(self._nd_grid(), key="name", val=self.params.intact_name) # Set fracture grid names if self.params.n_frac > 0: fracture_grids = self.gb.get_grids(lambda g: g.dim == self.Nd - 1) assert ( len(fracture_grids) == self.params.n_frac ), "There should be equal number of Nd-1 fractures as shearzone names" # We assume that order of fractures on grid creation (self.create_grid) # is preserved. for i, sz_name in enumerate(self.params.shearzone_names): self.gb.set_node_prop(fracture_grids[i], key="name", val=sz_name)
def _tag_ivar_well_cells(_, gb: pp.GridBucket) -> None: """ Tag well cells with unitary values, positive for injection cells and negative for production cells. """ box = gb.bounding_box(as_dict=True) nd = gb.dim_max() for g, d in gb: tags = np.zeros(g.num_cells) if g.dim < nd: point = np.array([[(box["xmin"] + box["xmax"]) / 2], [box["ymax"]], [0],]) distances = pp.distances.point_pointset(point, g.cell_centers) indexes = np.argsort(distances) if d["node_number"] == 1: tags[indexes[-1]] = 1 # injection elif d["node_number"] == 3: tags[indexes[-1]] = -1 # production # write_well_cell_to_csv(g, indexes[-1], self) g.tags["well_cells"] = tags pp.set_state(d, {"well": tags.copy()})
def nd_injection_cell_center(params: FlowParameters, gb: pp.GridBucket) -> None: """ Tag the center cell of the nd-grid with 1 (injection) Parameters ---------- params : FlowParameters gb : pp.GridBucket """ # Get the center of the domain. box = gb.bounding_box() pts = (box[1] + box[0]) / 2 # center of domain pts = np.atleast_2d(pts).T # Get the Nd-grid nd_grid = gb.grids_of_dimension(gb.dim_max())[0] # Tag highest dim grid with 1 in the cell closest to the grid center _tag_injection_cell(gb, nd_grid, pts, params.length_scale)
def gb_refinement( gb: pp.GridBucket, gb_ref: pp.GridBucket, tol: float = 1e-8, mode: str = "nested" ): """Wrapper for coarse_fine_cell_mapping to construct mapping for grids in GridBucket. Adds a node_prop to each grid in gb. The key is 'coarse_fine_cell_mapping', and is the mapping generated by 'coarse_fine_cell_mapping(...)'. Currently, only nested refinement is supported; more general cases are also possible. Note: No node prop is added to the reference grids in gb_ref. Parameters ---------- gb : pp.GridBucket Coarse grid bucket gb_ref : pp.GridBucket Refined grid bucket tol : float, Optional Tolerance for point_in_poly* -methods mode : str, Optional Refinement mode. Defaults to 'nested', corresponds to refinement by splitting. Acknowledgement: The code was contributed by Haakon Ervik. """ grids = gb.get_grids() grids_ref = gb_ref.get_grids() assert len(grids) == len( grids_ref ), "Weakly check that GridBuckets refer to same domains" assert np.allclose( np.append(*gb.bounding_box()), np.append(*gb_ref.bounding_box()) ), "Weakly check that GridBuckets refer to same domains" # This method assumes a consistent node ordering between grids. At least assign one. gb.assign_node_ordering(overwrite_existing=False) gb_ref.assign_node_ordering(overwrite_existing=False) # Add node prop on the coarse grid to map from coarse to fine cells. gb.add_node_props(keys="coarse_fine_cell_mapping") for i in np.arange(len(grids)): g, g_ref = grids[i], grids_ref[i] node_num, node_num_ref = ( gb._nodes[g]["node_number"], gb_ref._nodes[g_ref]["node_number"], ) assert node_num == node_num_ref, "Weakly check that grids refer to same domain." # Compute the mapping for this grid-pair, # and assign the result to the node of the coarse gb if mode == "nested": mapping = structured_refinement(g, g_ref, point_in_poly_tol=tol) else: raise NotImplementedError("Unknown refinement mode") gb.set_node_prop(grid=g, key="coarse_fine_cell_mapping", val=mapping)
def gb(self, gb: pp.GridBucket): """ Set a grid bucket to the class""" self._gb = gb if gb is not None: self.bounding_box = gb.bounding_box(as_dict=True)