test: refactor shared 2D mesh helper into pytest fixture (#5342)

Author: swastim01

tests/__init__.py

@@ -25,7 +25,6 @@
 from .shared import (
     DummyDiscretisationClass,
     get_mesh_for_testing,
-    get_mesh_for_testing_2d,
     get_3d_mesh_for_testing,
     get_unit_3d_mesh_for_testing,
     get_mesh_for_testing_symbolic,

tests/conftest.py

@@ -0,0 +1,94 @@
+import pytest
+
+import pybamm
+
+
+@pytest.fixture
+def mesh_2d():
+    param = pybamm.ParameterValues(
+        values={
+            "Electrode height [m]": 1,
+            "Negative electrode thickness [m]": 0.3333333333333333,
+            "Separator thickness [m]": 0.3333333333333333,
+            "Positive electrode thickness [m]": 0.3333333333333334,
+            "Negative particle radius [m]": 0.5,
+            "Positive particle radius [m]": 0.5,
+        }
+    )
+
+    x = pybamm.SpatialVariable(
+        "x", ["negative electrode", "separator", "positive electrode"], direction="lr"
+    )
+    z = pybamm.SpatialVariable(
+        "z", ["negative electrode", "separator", "positive electrode"], direction="tb"
+    )
+    r_n = pybamm.SpatialVariable("r_n", ["negative particle"])
+    r_p = pybamm.SpatialVariable("r_p", ["positive particle"])
+
+    geometry = {
+        "negative electrode": {
+            x: {
+                "min": pybamm.Scalar(0),
+                "max": pybamm.Parameter("Negative electrode thickness [m]"),
+            },
+            z: {
+                "min": pybamm.Scalar(0),
+                "max": pybamm.Parameter("Electrode height [m]"),
+            },
+        },
+        "separator": {
+            x: {
+                "min": pybamm.Parameter("Negative electrode thickness [m]"),
+                "max": pybamm.Parameter("Separator thickness [m]")
+                + pybamm.Parameter("Negative electrode thickness [m]"),
+            },
+            z: {
+                "min": pybamm.Scalar(0),
+                "max": pybamm.Parameter("Electrode height [m]"),
+            },
+        },
+        "positive electrode": {
+            x: {
+                "min": pybamm.Parameter("Separator thickness [m]")
+                + pybamm.Parameter("Negative electrode thickness [m]"),
+                "max": pybamm.Parameter("Positive electrode thickness [m]")
+                + pybamm.Parameter("Separator thickness [m]")
+                + pybamm.Parameter("Negative electrode thickness [m]"),
+            },
+            z: {
+                "min": pybamm.Scalar(0),
+                "max": pybamm.Parameter("Electrode height [m]"),
+            },
+        },
+        "negative particle": {
+            r_n: {
+                "min": pybamm.Scalar(0),
+                "max": pybamm.Scalar(1),
+            },
+        },
+        "positive particle": {
+            r_p: {
+                "min": pybamm.Scalar(0),
+                "max": pybamm.Scalar(1),
+            },
+        },
+    }
+
+    param.process_geometry(geometry)
+
+    submesh_types = {
+        "negative electrode": pybamm.Uniform2DSubMesh,
+        "separator": pybamm.Uniform2DSubMesh,
+        "positive electrode": pybamm.Uniform2DSubMesh,
+        "negative particle": pybamm.Uniform1DSubMesh,
+        "positive particle": pybamm.Uniform1DSubMesh,
+    }
+
+    var_pts = {
+        x: 40,
+        z: 15,
+        r_n: 10,
+        r_p: 10,
+    }
+
+    return pybamm.Mesh(geometry, submesh_types, var_pts)

tests/shared.py

@@ -120,104 +120,6 @@ def get_mesh_for_testing(
     return pybamm.Mesh(geometry, submesh_types, var_pts)
 
 
-def get_mesh_for_testing_2d(
-    xpts=None,
-    rpts=10,
-    Rpts=10,
-    ypts=15,
-    zpts=15,
-):
-    param = pybamm.ParameterValues(
-        values={
-            "Electrode height [m]": 1,
-            "Negative electrode thickness [m]": 0.3333333333333333,
-            "Separator thickness [m]": 0.3333333333333333,
-            "Positive electrode thickness [m]": 0.3333333333333334,
-            "Negative particle radius [m]": 0.5,
-            "Positive particle radius [m]": 0.5,
-        }
-    )
-
-    x = pybamm.SpatialVariable(
-        "x", ["negative electrode", "separator", "positive electrode"], direction="lr"
-    )
-    z = pybamm.SpatialVariable(
-        "z", ["negative electrode", "separator", "positive electrode"], direction="tb"
-    )
-    r_n = pybamm.SpatialVariable("r_n", ["negative particle"])
-    r_p = pybamm.SpatialVariable("r_p", ["positive particle"])
-
-    geometry = {
-        "negative electrode": {
-            x: {
-                "min": pybamm.Scalar(0),
-                "max": pybamm.Parameter("Negative electrode thickness [m]"),
-            },
-            z: {
-                "min": pybamm.Scalar(0),
-                "max": pybamm.Parameter("Electrode height [m]"),
-            },
-        },
-        "separator": {
-            x: {
-                "min": pybamm.Parameter("Negative electrode thickness [m]"),
-                "max": pybamm.Parameter("Separator thickness [m]")
-                + pybamm.Parameter("Negative electrode thickness [m]"),
-            },
-            z: {
-                "min": pybamm.Scalar(0),
-                "max": pybamm.Parameter("Electrode height [m]"),
-            },
-        },
-        "positive electrode": {
-            x: {
-                "min": pybamm.Parameter("Separator thickness [m]")
-                + pybamm.Parameter("Negative electrode thickness [m]"),
-                "max": pybamm.Parameter("Positive electrode thickness [m]")
-                + pybamm.Parameter("Separator thickness [m]")
-                + pybamm.Parameter("Negative electrode thickness [m]"),
-            },
-            z: {
-                "min": pybamm.Scalar(0),
-                "max": pybamm.Parameter("Electrode height [m]"),
-            },
-        },
-        "negative particle": {
-            r_n: {
-                "min": pybamm.Scalar(0),
-                "max": pybamm.Scalar(1),
-            },
-        },
-        "positive particle": {
-            r_p: {
-                "min": pybamm.Scalar(0),
-                "max": pybamm.Scalar(1),
-            },
-        },
-    }
-    param.process_geometry(geometry)
-
-    submesh_types = {
-        "negative electrode": pybamm.Uniform2DSubMesh,
-        "separator": pybamm.Uniform2DSubMesh,
-        "positive electrode": pybamm.Uniform2DSubMesh,
-        "negative particle": pybamm.Uniform1DSubMesh,
-        "positive particle": pybamm.Uniform1DSubMesh,
-    }
-
-    if xpts is None:
-        xn_pts = 40
-    else:
-        xn_pts = xpts
-    var_pts = {
-        x: xn_pts,
-        z: zpts,
-        r_n: rpts,
-        r_p: rpts,
-    }
-    return pybamm.Mesh(geometry, submesh_types, var_pts)
-
-
 def get_unit_3d_mesh_for_testing(geom_type="pouch", **geom_params):
     if geom_type == "pouch":
         x = pybamm.SpatialVariable("x", ["current collector"])

tests/unit/test_expression_tree/test_vector_field_and_magnitude.py

@@ -1,12 +1,11 @@
 import pytest
 
 import pybamm
-from tests.shared import get_mesh_for_testing_2d
 
 
 class TestVectorFieldAndMagnitude:
-    def test_vector_field_and_magnitude(self):
-        mesh = get_mesh_for_testing_2d()
+    def test_vector_field_and_magnitude(self, mesh_2d):
+        mesh = mesh_2d
         spatial_methods = {
             "macroscale": pybamm.FiniteVolume2D(),
         }

tests/unit/test_solvers/test_processed_variable.py

@@ -5,7 +5,6 @@
 
 import pybamm
 import tests
-from tests.shared import get_mesh_for_testing_2d
 
 _hermite_args = [True, False]
 
@@ -374,9 +373,9 @@ def test_processed_variable_2D_x_r(self, hermite_interp):
             var, r, x, disc=disc, hermite_interp=hermite_interp
         )
 
-    def test_processed_variable_2D_fvm(self):
+    def test_processed_variable_2D_fvm(self, mesh_2d):
         var = pybamm.Variable("var", domain=["negative electrode"])
-        mesh = get_mesh_for_testing_2d()
+        mesh = mesh_2d
         fin_vol = pybamm.FiniteVolume2D()
         disc = pybamm.Discretisation(mesh, {"negative electrode": fin_vol})
         disc.set_variable_slices([var])

tests/unit/test_spatial_methods/test_finite_volume_2d/test_2d_finite_volume_integration.py

@@ -6,12 +6,11 @@
 import pytest
 
 import pybamm
-from tests.shared import get_mesh_for_testing_2d
 
 
 class TestFiniteVolumeIntegration:
-    def test_indefinite_integral(self):
-        mesh = get_mesh_for_testing_2d()
+    def test_indefinite_integral(self, mesh_2d):
+        mesh = mesh_2d
         spatial_methods = {"macroscale": pybamm.FiniteVolume2D()}
         disc = pybamm.Discretisation(mesh, spatial_methods)
         var = pybamm.Variable(
@@ -36,9 +35,9 @@ def test_indefinite_integral(self):
                 "negative electrode", "left"
             )
 
-    def test_definite_integral(self):
+    def test_definite_integral(self, mesh_2d):
         # create discretisation
-        mesh = get_mesh_for_testing_2d()
+        mesh = mesh_2d
         spatial_methods = {
             "negative electrode": pybamm.FiniteVolume2D(),
             "separator": pybamm.FiniteVolume2D(),
@@ -110,8 +109,8 @@ def test_definite_integral(self):
         ):
             spatial_method.definite_integral_matrix(child)
 
-    def test_area_integral(self):
-        mesh = get_mesh_for_testing_2d()
+    def test_area_integral(self, mesh_2d):
+        mesh = mesh_2d
         spatial_methods = {"macroscale": pybamm.FiniteVolume2D()}
         disc = pybamm.Discretisation(mesh, spatial_methods)
         var = pybamm.Variable(
@@ -158,9 +157,9 @@ def test_area_integral(self):
         ):
             disc.process_symbol(pybamm.Integral(var, [x, x]))
 
-    def test_boundary_integral(self):
+    def test_boundary_integral(self, mesh_2d):
         # create discretisation
-        mesh = get_mesh_for_testing_2d()
+        mesh = mesh_2d
         spatial_methods = {
             "negative electrode": pybamm.FiniteVolume2D(),
             "separator": pybamm.FiniteVolume2D(),
@@ -266,8 +265,8 @@ def test_boundary_integral(self):
         )
         np.testing.assert_allclose(result_left, 0.0, atol=1e-6)
 
-    def test_one_dimensional_integral(self):
-        mesh = get_mesh_for_testing_2d()
+    def test_one_dimensional_integral(self, mesh_2d):
+        mesh = mesh_2d
         spatial_methods = {"macroscale": pybamm.FiniteVolume2D()}
         disc = pybamm.Discretisation(mesh, spatial_methods)
         var = pybamm.Variable(

tests/unit/test_spatial_methods/test_finite_volume_2d/test_extrapolation.py

@@ -2,21 +2,20 @@
 import pytest
 
 import pybamm
-from tests.shared import get_mesh_for_testing_2d
 
 
 class TestExtrapolationFiniteVolume2D:
     @pytest.mark.parametrize("use_bcs", [True, False])
     @pytest.mark.parametrize("order", ["linear", "quadratic"])
-    def test_boundary_value_finite_volume_2d(self, use_bcs, order):
+    def test_boundary_value_finite_volume_2d(self, use_bcs, order, mesh_2d):
         if order == "quadratic" and use_bcs:
             # Not implemented
             return
         if order == "constant" and use_bcs:
             # Constant extrapolation doesn't use boundary conditions
             return
         # Create discretisation
-        mesh = get_mesh_for_testing_2d()
+        mesh = mesh_2d
         spatial_methods = {
             "macroscale": pybamm.FiniteVolume2D(
                 {
@@ -171,9 +170,9 @@ def test_boundary_value_finite_volume_2d(self, use_bcs, order):
 
     @pytest.mark.parametrize("use_bcs", [True, False])
     @pytest.mark.parametrize("order", ["linear", "quadratic"])
-    def test_boundary_gradient_finite_volume_2d(self, use_bcs, order):
+    def test_boundary_gradient_finite_volume_2d(self, use_bcs, order, mesh_2d):
         # Create discretisation
-        mesh = get_mesh_for_testing_2d()
+        mesh = mesh_2d
         spatial_methods = {
             "macroscale": pybamm.FiniteVolume2D(
                 {
@@ -323,8 +322,8 @@ def test_boundary_gradient_finite_volume_2d(self, use_bcs, order):
             "bottom-right",
         ],
     )
-    def test_cubic_not_implemented(self, use_bcs, direction):
-        mesh = get_mesh_for_testing_2d()
+    def test_cubic_not_implemented(self, use_bcs, direction, mesh_2d):
+        mesh = mesh_2d
         spatial_methods = {
             "macroscale": pybamm.FiniteVolume2D(
                 {
@@ -344,9 +343,11 @@ def test_cubic_not_implemented(self, use_bcs, direction):
             disc.process_symbol(pybamm.BoundaryValue(var, direction))
 
     @pytest.mark.parametrize("use_bcs", [True, False])
-    def test_boundary_gradient_quadratic_function_finite_volume_2d(self, use_bcs):
+    def test_boundary_gradient_quadratic_function_finite_volume_2d(
+        self, use_bcs, mesh_2d
+    ):
         # Create discretisation with quadratic gradient extrapolation
-        mesh = get_mesh_for_testing_2d()
+        mesh = mesh_2d
         spatial_methods = {
             "macroscale": pybamm.FiniteVolume2D(
                 {
@@ -455,10 +456,10 @@ def test_boundary_gradient_quadratic_function_finite_volume_2d(self, use_bcs):
                 atol=1e-5,
             )
 
-    def test_boundary_value_constant_extrapolation(self):
+    def test_boundary_value_constant_extrapolation(self, mesh_2d):
         """Test constant extrapolation for left and right boundaries."""
         # Create discretisation with constant extrapolation
-        mesh = get_mesh_for_testing_2d()
+        mesh = mesh_2d
         spatial_methods = {
             "macroscale": pybamm.FiniteVolume2D(
                 {