Merge pull request #1369 from pmgbergen/name_unification

Unification of variable names throughout the code base

Author: IvarStefansson

src/porepy/applications/boundary_conditions/model_boundary_conditions.py

@@ -35,22 +35,22 @@ def bc_type_darcy_flux(self, sd: pp.Grid) -> pp.BoundaryCondition:
         # Define boundary condition on faces
         return pp.BoundaryCondition(sd, domain_sides.west + domain_sides.east, "dir")
 
-    def bc_values_pressure(self, boundary_grid: pp.BoundaryGrid) -> np.ndarray:
+    def bc_values_pressure(self, bg: pp.BoundaryGrid) -> np.ndarray:
         """Boundary condition values for Darcy flux.
 
         Dirichlet boundary conditions are defined on the west and east boundaries,
         with a constant value equal to the fluid's reference pressure (which will be 0
         by default).
 
         Parameters:
-            boundary_grid: Boundary grid for which to define boundary conditions.
+            bg: Boundary grid for which to define boundary conditions.
 
         Returns:
             Boundary condition values array.
 
         """
-        domain_sides = self.domain_boundary_sides(boundary_grid)
-        values = np.zeros(boundary_grid.num_cells)
+        domain_sides = self.domain_boundary_sides(bg)
+        values = np.zeros(bg.num_cells)
         values[domain_sides.west + domain_sides.east] = (
             self.reference_variable_values.pressure
         )
@@ -99,22 +99,22 @@ def bc_type_darcy_flux(self, sd: pp.Grid) -> pp.BoundaryCondition:
         # Define boundary condition on faces
         return pp.BoundaryCondition(sd, domain_sides.north + domain_sides.south, "dir")
 
-    def bc_values_pressure(self, boundary_grid: pp.BoundaryGrid) -> np.ndarray:
+    def bc_values_pressure(self, bg: pp.BoundaryGrid) -> np.ndarray:
         """Boundary condition values for Darcy flux.
 
         Dirichlet boundary conditions are defined on the north and south boundaries,
         with a constant value equal to the fluid's reference pressure (which will be 0
         by default).
 
         Parameters:
-            boundary_grid: Boundary grid for which to define boundary conditions.
+            bg: Boundary grid for which to define boundary conditions.
 
         Returns:
             Boundary condition values array.
 
         """
-        domain_sides = self.domain_boundary_sides(boundary_grid)
-        values = np.zeros(boundary_grid.num_cells)
+        domain_sides = self.domain_boundary_sides(bg)
+        values = np.zeros(bg.num_cells)
         values[domain_sides.north + domain_sides.south] = (
             self.reference_variable_values.pressure
         )
@@ -208,24 +208,24 @@ def bc_type_mechanics(self, sd: pp.Grid) -> pp.BoundaryConditionVectorial:
         bc.internal_to_dirichlet(sd)
         return bc
 
-    def bc_values_displacement(self, boundary_grid: pp.BoundaryGrid) -> np.ndarray:
+    def bc_values_displacement(self, bg: pp.BoundaryGrid) -> np.ndarray:
         """Boundary values for the mechanics problem as a numpy array.
 
         Values for north and south faces are set to zero unless otherwise specified
         through items u_north and u_south in the parameter dictionary passed on model
         initialization.
 
         Parameters:
-            boundary_grid: Boundary grid for which boundary values are to be returned.
+            bg: Boundary grid for which boundary values are to be returned.
 
         Returns:
             Array of boundary values, with one value for each dimension of the
                 domain, for each face in the subdomain.
 
         """
-        sides = self.domain_boundary_sides(boundary_grid)
-        values = np.zeros((self.nd, boundary_grid.num_cells))
-        if boundary_grid.dim < self.nd - 1:
+        domain_sides = self.domain_boundary_sides(bg)
+        values = np.zeros((self.nd, bg.num_cells))
+        if bg.dim < self.nd - 1:
             # No displacement is implemented on grids of co-dimension >= 2.
             return values.ravel("F")
 
@@ -236,13 +236,17 @@ def bc_values_displacement(self, boundary_grid: pp.BoundaryGrid) -> np.ndarray:
         # Wrap as array for convert_units. Thus, the passed values can be scalar or
         # list. Then tile for correct broadcasting below.
         u_n = np.tile(
-            self.params.get("u_north", np.zeros(self.nd)), (boundary_grid.num_cells, 1)
+            self.params.get("u_north", np.zeros(self.nd)), (bg.num_cells, 1)
         ).T
         u_s = np.tile(
-            self.params.get("u_south", np.zeros(self.nd)), (boundary_grid.num_cells, 1)
+            self.params.get("u_south", np.zeros(self.nd)), (bg.num_cells, 1)
         ).T
-        values[:, sides.north] = self.units.convert_units(u_n, "m")[:, sides.north]
-        values[:, sides.south] = self.units.convert_units(u_s, "m")[:, sides.south]
+        values[:, domain_sides.north] = self.units.convert_units(u_n, "m")[
+            :, domain_sides.north
+        ]
+        values[:, domain_sides.south] = self.units.convert_units(u_s, "m")[
+            :, domain_sides.south
+        ]
         return values.ravel("F")
 
 
@@ -253,7 +257,7 @@ class TimeDependentMechanicalBCsDirNorthSouth(BoundaryConditionsMechanicsDirNort
 
     """
 
-    def bc_values_displacement(self, boundary_grid: pp.BoundaryGrid) -> np.ndarray:
+    def bc_values_displacement(self, bg: pp.BoundaryGrid) -> np.ndarray:
         """Displacement values.
 
         Initial value is u_y = self.solid.fracture_gap +
@@ -265,15 +269,15 @@ def bc_values_displacement(self, boundary_grid: pp.BoundaryGrid) -> np.ndarray:
         defaulting to 0.
 
         Parameters:
-            boundary_grid: Boundary grid for which boundary values are to be returned.
+            bg: Boundary grid for which boundary values are to be returned.
 
         Returns:
             Array of boundary values, with one value for each dimension of the
                 problem, for each face in the subdomain.
 
         """
-        domain_sides = self.domain_boundary_sides(boundary_grid)
-        values = np.zeros((self.nd, boundary_grid.num_cells))
+        domain_sides = self.domain_boundary_sides(bg)
+        values = np.zeros((self.nd, bg.num_cells))
         # Add fracture width on top if there is a fracture.
         if len(self.mdg.subdomains()) > 1:
             frac_val = (
@@ -283,6 +287,6 @@ def bc_values_displacement(self, boundary_grid: pp.BoundaryGrid) -> np.ndarray:
             frac_val = 0
         values[1, domain_sides.north] = frac_val
         if self.time_manager.time > 1e-5:
-            return values.ravel("F") + super().bc_values_displacement(boundary_grid)
+            return values.ravel("F") + super().bc_values_displacement(bg)
         else:
             return values.ravel("F")

src/porepy/applications/convergence_analysis.py

@@ -119,20 +119,20 @@ def __init__(
 
         """
 
-        # Initialize setup and retrieve spatial and temporal data
-        setup: pp.PorePyModel = model_class(
+        # Initialize model and retrieve spatial and temporal data
+        model: pp.PorePyModel = model_class(
             deepcopy(model_params)
         )  # make a deep copy of dictionary
         # The typing of PorePyModel was added to support linters as much as possible.
         # But the protocols do not contain all methods provided by SolutionStrategy.
-        setup.prepare_simulation()  # type: ignore[attr-defined]
+        model.prepare_simulation()  # type: ignore[attr-defined]
 
-        # Store initial setup
-        self._init_setup = setup
-        """Initial setup containing the 'base-line' information."""
+        # Store initial model
+        self._init_model = model
+        """Initial model containing the 'base-line' information."""
 
         # We need to know whether the model is time-dependent or not
-        self._is_time_dependent: bool = setup._is_time_dependent()
+        self._is_time_dependent: bool = model._is_time_dependent()
         """Whether the model is time-dependent."""
 
         if not self._is_time_dependent and self.temporal_refinement_rate > 1:
@@ -178,20 +178,20 @@ def run_analysis(self) -> list:
         """
         convergence_results: list = []
         for level in range(self.levels):
-            setup = self.model_class(deepcopy(self.model_params[level]))
-            if not setup._is_time_dependent():
+            model = self.model_class(deepcopy(self.model_params[level]))
+            if not model._is_time_dependent():
                 # Run stationary model
-                pp.run_stationary_model(setup, deepcopy(self.model_params[level]))
+                pp.run_stationary_model(model, deepcopy(self.model_params[level]))
                 # Complement information in results
-                setattr(setup.results[-1], "cell_diameter", setup.mdg.diameter())
+                setattr(model.results[-1], "cell_diameter", model.mdg.diameter())
             else:
                 # Run time-dependent model
-                pp.run_time_dependent_model(setup)
+                pp.run_time_dependent_model(model)
                 # Complement information in results
-                setattr(setup.results[-1], "cell_diameter", setup.mdg.diameter())
-                setattr(setup.results[-1], "dt", setup.time_manager.dt)
+                setattr(model.results[-1], "cell_diameter", model.mdg.diameter())
+                setattr(model.results[-1], "dt", model.time_manager.dt)
 
-            convergence_results.append(setup.results[-1])
+            convergence_results.append(model.results[-1])
         return convergence_results
 
     def export_errors_to_txt(
@@ -377,7 +377,7 @@ def _get_list_of_meshing_arguments(self) -> list[dict[str, float]]:
 
         """
         # Retrieve initial meshing arguments
-        init_mesh_args = deepcopy(self._init_setup.meshing_arguments())
+        init_mesh_args = deepcopy(self._init_model.meshing_arguments())
 
         # Prepare factors for the spatial analysis
         factors = 1 / (self.spatial_refinement_rate ** np.arange(self.levels))
@@ -405,7 +405,7 @@ def _get_list_of_time_managers(self) -> Union[list[pp.TimeManager], None]:
             return None
 
         # Retrieve initial time manager
-        init_time_manager: pp.TimeManager = self._init_setup.time_manager
+        init_time_manager: pp.TimeManager = self._init_model.time_manager
 
         # Sanity check
         if not init_time_manager.is_constant:

src/porepy/applications/md_grids/fracture_sets.py

@@ -132,7 +132,7 @@ def benchmark_2d_case_3(size: pp.number = 1) -> list[pp.LineFracture]:
 def benchmark_2d_case_4() -> list[pp.LineFracture]:
     """Returns a fracture set that corresponds to Case 4 from the 2D flow benchmark [1].
 
-    The setup is composed of 64 fractures grouped in 13 different connected networks,
+    The geometry is composed of 64 fractures grouped in 13 different connected networks,
     ranging from isolated fractures up to tens of fractures each.
 
     References:

src/porepy/applications/md_grids/mdg_library.py

@@ -141,7 +141,7 @@ def square_with_orthogonal_fractures(
             non_matching=False,
         )
 
-        intf_map: dict[
+        interface_map: dict[
             pp.MortarGrid,
             Union[pp.MortarGrid, dict[mortar_grid.MortarSides, pp.Grid]],
         ] = {}
@@ -161,11 +161,13 @@ def square_with_orthogonal_fractures(
                 # they are the same, i.e., if the fractures are the same ones, we update
                 # the interface map.
                 if g_sec_old.frac_num == g_sec_new.frac_num:
-                    intf_map.update({intf_old: intf})
+                    interface_map.update({intf_old: intf})
 
         # Finally replace the subdomains and interfaces in the original
         # mixed-dimensional grid.
-        mdg.replace_subdomains_and_interfaces(sd_map=grid_map, intf_map=intf_map)
+        mdg.replace_subdomains_and_interfaces(
+            sd_map=grid_map, interface_map=interface_map
+        )
 
     return mdg, fracture_network