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)
