Merge pull request fankiat#117 from fankiat/115_refactor_test_suite

Refactor test suite
SophT-Team · Dec 6, 2022 · aeeb718 · aeeb718
2 parents a67ba30 + cc832ac
commit aeeb718
Show file tree

Hide file tree

Showing 22 changed files with 249 additions and 301 deletions.
diff --git a/tests/test_numeric/test_eulerian_grid_ops/test_poisson_solver_2d/test_fft_mpi_2d.py b/tests/test_numeric/test_eulerian_grid_ops/test_poisson_solver_2d/test_fft_mpi_2d.py
@@ -9,21 +9,22 @@
 from scipy.fft import rfftn
 
 
-@pytest.mark.mpi(group="MPI_Poisson_solver_2d", min_size=2)
-@pytest.mark.parametrize("ghost_size", [1, 2, 3])
+@pytest.mark.mpi(group="MPI_Poisson_solver_2d", min_size=4)
+@pytest.mark.parametrize("ghost_size", [1, 2])
 @pytest.mark.parametrize("precision", ["single", "double"])
 @pytest.mark.parametrize("rank_distribution", [(1, 0), (0, 1)])
-@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 2), (2, 1)])
+@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1.5, 1)])
 def test_mpi_fft_slab(ghost_size, precision, rank_distribution, aspect_ratio):
     """
     Test parallel FFT on slab distributed along x and y
     """
-    n_values = 32
+    n_values = 8
+    grid_size_y, grid_size_x = (n_values * np.array(aspect_ratio)).astype(int)
     real_t = get_real_t(precision)
     # Generate the MPI topology minimal object
     mpi_construct = MPIConstruct2D(
-        grid_size_y=n_values * aspect_ratio[0],
-        grid_size_x=n_values * aspect_ratio[1],
+        grid_size_y=grid_size_y,
+        grid_size_x=grid_size_x,
         real_t=real_t,
         rank_distribution=rank_distribution,
     )
@@ -46,9 +47,7 @@ def test_mpi_fft_slab(ghost_size, precision, rank_distribution, aspect_ratio):
 
     # Generate solution and broadcast solution from rank 0 to all ranks
     if mpi_construct.rank == 0:
-        ref_field = np.random.randn(
-            n_values * aspect_ratio[0], n_values * aspect_ratio[1]
-        ).astype(real_t)
+        ref_field = np.random.randn(grid_size_y, grid_size_x).astype(real_t)
     else:
         ref_field = None
     ref_field = mpi_construct.grid.bcast(ref_field, root=0)

diff --git a/...ric/test_eulerian_grid_ops/test_poisson_solver_2d/test_unbounded_poisson_solver_mpi_2d.py b/...ric/test_eulerian_grid_ops/test_poisson_solver_2d/test_unbounded_poisson_solver_mpi_2d.py
@@ -13,28 +13,29 @@
 )
 
 
-@pytest.mark.mpi(group="MPI_unbounded_poisson_solve_2d", min_size=2)
-@pytest.mark.parametrize("ghost_size", [1, 2, 3])
+@pytest.mark.mpi(group="MPI_unbounded_poisson_solve_2d", min_size=4)
+@pytest.mark.parametrize("ghost_size", [1, 2])
 @pytest.mark.parametrize("precision", ["single", "double"])
 @pytest.mark.parametrize("rank_distribution", [(1, 0), (0, 1)])
-@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 2), (2, 1)])
+@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1.5, 1)])
 def test_mpi_unbounded_poisson_solve_2d(
     ghost_size, precision, rank_distribution, aspect_ratio
 ):
-    n_values = 32
+    n_values = 8
+    grid_size_y, grid_size_x = (n_values * np.array(aspect_ratio)).astype(int)
     real_t = get_real_t(precision)
     # Generate the MPI topology minimal object
     mpi_construct = MPIConstruct2D(
-        grid_size_y=n_values * aspect_ratio[0],
-        grid_size_x=n_values * aspect_ratio[1],
+        grid_size_y=grid_size_y,
+        grid_size_x=grid_size_x,
         real_t=real_t,
         rank_distribution=rank_distribution,
     )
 
     # Create unbounded poisson solver
     unbounded_poisson_solver = UnboundedPoissonSolverMPI2D(
-        grid_size_y=n_values * aspect_ratio[0],
-        grid_size_x=n_values * aspect_ratio[1],
+        grid_size_y=grid_size_y,
+        grid_size_x=grid_size_x,
         real_t=real_t,
         mpi_construct=mpi_construct,
         ghost_size=ghost_size,
@@ -58,9 +59,7 @@ def test_mpi_unbounded_poisson_solve_2d(
 
     # Initialize and broadcast solution for comparison later
     if mpi_construct.rank == 0:
-        ref_rhs_field = np.random.rand(
-            n_values * aspect_ratio[0], n_values * aspect_ratio[1]
-        ).astype(real_t)
+        ref_rhs_field = np.random.rand(grid_size_y, grid_size_x).astype(real_t)
     else:
         ref_rhs_field = None
 
@@ -79,8 +78,8 @@ def test_mpi_unbounded_poisson_solve_2d(
     # assert correct
     if mpi_construct.rank == 0:
         ref_unbounded_poisson_solver = UnboundedPoissonSolverPYFFTW2D(
-            grid_size_y=n_values * aspect_ratio[0],
-            grid_size_x=n_values * aspect_ratio[1],
+            grid_size_y=grid_size_y,
+            grid_size_x=grid_size_x,
             real_t=real_t,
         )
         ref_solution_field = np.zeros_like(ref_rhs_field)

diff --git a/tests/test_numeric/test_eulerian_grid_ops/test_stencil_ops_2d/test_advection_flux_mpi_2d.py b/tests/test_numeric/test_eulerian_grid_ops/test_stencil_ops_2d/test_advection_flux_mpi_2d.py
@@ -14,20 +14,21 @@
 )
 
 
-@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=2)
-@pytest.mark.parametrize("ghost_size", [pytest.param(1, marks=pytest.mark.xfail), 2, 3])
+@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=4)
+@pytest.mark.parametrize("ghost_size", [pytest.param(1, marks=pytest.mark.xfail), 2])
 @pytest.mark.parametrize("precision", ["single", "double"])
 @pytest.mark.parametrize("rank_distribution", [(1, 0), (0, 1)])
-@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 2), (2, 1)])
+@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 1.5)])
 def test_mpi_advection_flux_conservative_eno3_2d(
     ghost_size, precision, rank_distribution, aspect_ratio
 ):
-    n_values = 32
+    n_values = 16
+    grid_size_y, grid_size_x = (n_values * np.array(aspect_ratio)).astype(int)
     real_t = get_real_t(precision)
     # Generate the MPI topology minimal object
     mpi_construct = MPIConstruct2D(
-        grid_size_y=n_values * aspect_ratio[0],
-        grid_size_x=n_values * aspect_ratio[1],
+        grid_size_y=grid_size_y,
+        grid_size_x=grid_size_x,
         real_t=real_t,
         rank_distribution=rank_distribution,
     )
@@ -55,13 +56,9 @@ def test_mpi_advection_flux_conservative_eno3_2d(
 
     # Initialize and broadcast solution for comparison later
     if mpi_construct.rank == 0:
-        ref_field = np.random.rand(
-            n_values * aspect_ratio[0], n_values * aspect_ratio[1]
-        ).astype(real_t)
+        ref_field = np.random.rand(grid_size_y, grid_size_x).astype(real_t)
         ref_velocity = np.random.rand(
-            mpi_construct.grid_dim,
-            n_values * aspect_ratio[0],
-            n_values * aspect_ratio[1],
+            mpi_construct.grid_dim, grid_size_y, grid_size_x
         ).astype(real_t)
         inv_dx = real_t(0.1)
     else:

diff --git a/...test_numeric/test_eulerian_grid_ops/test_stencil_ops_2d/test_advection_timestep_mpi_2d.py b/...test_numeric/test_eulerian_grid_ops/test_stencil_ops_2d/test_advection_timestep_mpi_2d.py
@@ -14,21 +14,22 @@
 )
 
 
-@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=2)
-@pytest.mark.parametrize("ghost_size", [pytest.param(1, marks=pytest.mark.xfail), 2, 3])
+@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=4)
+@pytest.mark.parametrize("ghost_size", [pytest.param(1, marks=pytest.mark.xfail), 2])
 @pytest.mark.parametrize("precision", ["single", "double"])
 @pytest.mark.parametrize("rank_distribution", [(1, 0), (0, 1)])
-@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 2), (2, 1)])
+@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 1.5)])
 def test_mpi_advection_timestep_eno3_euler_forward_2d(
     ghost_size, precision, rank_distribution, aspect_ratio
 ):
-    n_values = 32
+    n_values = 16
+    grid_size_y, grid_size_x = (n_values * np.array(aspect_ratio)).astype(int)
     real_t = get_real_t(precision)
 
     # Generate the MPI topology minimal object
     mpi_construct = MPIConstruct2D(
-        grid_size_y=n_values * aspect_ratio[0],
-        grid_size_x=n_values * aspect_ratio[1],
+        grid_size_y=grid_size_y,
+        grid_size_x=grid_size_x,
         real_t=real_t,
         rank_distribution=rank_distribution,
     )
@@ -56,11 +57,9 @@ def test_mpi_advection_timestep_eno3_euler_forward_2d(
 
     # Initialize and broadcast solution for comparison later
     if mpi_construct.rank == 0:
-        ref_field = np.random.rand(
-            n_values * aspect_ratio[0], n_values * aspect_ratio[1]
-        ).astype(real_t)
+        ref_field = np.random.rand(grid_size_y, grid_size_x).astype(real_t)
         ref_velocity = np.random.rand(
-            2, n_values * aspect_ratio[0], n_values * aspect_ratio[1]
+            mpi_construct.grid_dim, grid_size_y, grid_size_x
         ).astype(real_t)
         inv_dx = real_t(0.2)
         dt = real_t(0.1)
@@ -82,7 +81,7 @@ def test_mpi_advection_timestep_eno3_euler_forward_2d(
 
     local_velocity = np.zeros(
         (
-            2,
+            mpi_construct.grid_dim,
             mpi_construct.local_grid_size[0] + 2 * ghost_size,
             mpi_construct.local_grid_size[1] + 2 * ghost_size,
         )

diff --git a/...test_numeric/test_eulerian_grid_ops/test_stencil_ops_2d/test_brinkmann_penalise_mpi_2d.py b/...test_numeric/test_eulerian_grid_ops/test_stencil_ops_2d/test_brinkmann_penalise_mpi_2d.py
@@ -10,20 +10,21 @@
 )
 
 
-@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=2)
-@pytest.mark.parametrize("ghost_size", [0, 1, 2, 3])
+@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=4)
+@pytest.mark.parametrize("ghost_size", [1, 2])
 @pytest.mark.parametrize("precision", ["single", "double"])
 @pytest.mark.parametrize("rank_distribution", [(1, 0), (0, 1)])
-@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 2), (2, 1)])
+@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 1.5)])
 def test_mpi_brinkmann_penalise_scalar_field_2d(
     ghost_size, precision, rank_distribution, aspect_ratio
 ):
-    n_values = 32
+    n_values = 8
+    grid_size_y, grid_size_x = (n_values * np.array(aspect_ratio)).astype(int)
     real_t = get_real_t(precision)
     # Generate the MPI topology minimal object
     mpi_construct = MPIConstruct2D(
-        grid_size_y=n_values * aspect_ratio[0],
-        grid_size_x=n_values * aspect_ratio[1],
+        grid_size_y=grid_size_y,
+        grid_size_x=grid_size_x,
         real_t=real_t,
         rank_distribution=rank_distribution,
     )
@@ -49,15 +50,9 @@ def test_mpi_brinkmann_penalise_scalar_field_2d(
 
     # Initialize and broadcast solution for comparison later
     if mpi_construct.rank == 0:
-        ref_field = np.random.rand(
-            n_values * aspect_ratio[0], n_values * aspect_ratio[1]
-        ).astype(real_t)
-        ref_penalty_field = np.random.rand(
-            n_values * aspect_ratio[0], n_values * aspect_ratio[1]
-        ).astype(real_t)
-        ref_char_field = np.random.rand(
-            n_values * aspect_ratio[0], n_values * aspect_ratio[1]
-        ).astype(real_t)
+        ref_field = np.random.rand(grid_size_y, grid_size_x).astype(real_t)
+        ref_penalty_field = np.random.rand(grid_size_y, grid_size_x).astype(real_t)
+        ref_char_field = np.random.rand(grid_size_y, grid_size_x).astype(real_t)
         penalty_factor = real_t(0.1)
     else:
         ref_field = None
@@ -115,20 +110,21 @@ def test_mpi_brinkmann_penalise_scalar_field_2d(
         )
 
 
-@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=2)
-@pytest.mark.parametrize("ghost_size", [0, 1, 2, 3])
+@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=4)
+@pytest.mark.parametrize("ghost_size", [1, 2])
 @pytest.mark.parametrize("precision", ["single", "double"])
 @pytest.mark.parametrize("rank_distribution", [(1, 0), (0, 1)])
-@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 2), (2, 1)])
+@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 1.5)])
 def test_mpi_brinkmann_penalise_vector_field_2d(
     ghost_size, precision, rank_distribution, aspect_ratio
 ):
-    n_values = 32
+    n_values = 8
+    grid_size_y, grid_size_x = (n_values * np.array(aspect_ratio)).astype(int)
     real_t = get_real_t(precision)
     # Generate the MPI topology minimal object
     mpi_construct = MPIConstruct2D(
-        grid_size_y=n_values * aspect_ratio[0],
-        grid_size_x=n_values * aspect_ratio[1],
+        grid_size_y=grid_size_y,
+        grid_size_x=grid_size_x,
         real_t=real_t,
         rank_distribution=rank_distribution,
     )
@@ -156,18 +152,12 @@ def test_mpi_brinkmann_penalise_vector_field_2d(
     # Initialize and broadcast solution for comparison later
     if mpi_construct.rank == 0:
         ref_vector_field = np.random.rand(
-            mpi_construct.grid_dim,
-            n_values * aspect_ratio[0],
-            n_values * aspect_ratio[1],
+            mpi_construct.grid_dim, grid_size_y, grid_size_x
         ).astype(real_t)
         ref_penalty_vector_field = np.random.rand(
-            mpi_construct.grid_dim,
-            n_values * aspect_ratio[0],
-            n_values * aspect_ratio[1],
-        ).astype(real_t)
-        ref_char_field = np.random.rand(
-            n_values * aspect_ratio[0], n_values * aspect_ratio[1]
+            mpi_construct.grid_dim, grid_size_y, grid_size_x
         ).astype(real_t)
+        ref_char_field = np.random.rand(grid_size_y, grid_size_x).astype(real_t)
         penalty_factor = real_t(0.1)
     else:
         ref_vector_field = None

diff --git a/...umeric/test_eulerian_grid_ops/test_stencil_ops_2d/test_char_func_from_level_set_mpi_2d.py b/...umeric/test_eulerian_grid_ops/test_stencil_ops_2d/test_char_func_from_level_set_mpi_2d.py
@@ -10,20 +10,21 @@
 )
 
 
-@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=2)
-@pytest.mark.parametrize("ghost_size", [0, 1, 2, 3])
+@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=4)
+@pytest.mark.parametrize("ghost_size", [1, 2])
 @pytest.mark.parametrize("precision", ["single", "double"])
 @pytest.mark.parametrize("rank_distribution", [(1, 0), (0, 1)])
-@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 2), (2, 1)])
-def test_mpi_brinkmann_penalise_scalar_field_2d(
+@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 1.5)])
+def test_mpi_char_func_from_level_set_2d(
     ghost_size, precision, rank_distribution, aspect_ratio
 ):
-    n_values = 32
+    n_values = 8
+    grid_size_y, grid_size_x = (n_values * np.array(aspect_ratio)).astype(int)
     real_t = get_real_t(precision)
     # Generate the MPI topology minimal object
     mpi_construct = MPIConstruct2D(
-        grid_size_y=n_values * aspect_ratio[0],
-        grid_size_x=n_values * aspect_ratio[1],
+        grid_size_y=grid_size_y,
+        grid_size_x=grid_size_x,
         real_t=real_t,
         rank_distribution=rank_distribution,
     )
@@ -47,9 +48,7 @@ def test_mpi_brinkmann_penalise_scalar_field_2d(
 
     # Initialize and broadcast solution for comparison later
     if mpi_construct.rank == 0:
-        ref_level_set_field = np.random.rand(
-            n_values * aspect_ratio[0], n_values * aspect_ratio[1]
-        ).astype(real_t)
+        ref_level_set_field = np.random.rand(grid_size_y, grid_size_x).astype(real_t)
         blend_width = real_t(0.2)
     else:
         ref_level_set_field = None

diff --git a/tests/test_numeric/test_eulerian_grid_ops/test_stencil_ops_2d/test_diffusion_flux_mpi_2d.py b/tests/test_numeric/test_eulerian_grid_ops/test_stencil_ops_2d/test_diffusion_flux_mpi_2d.py
@@ -14,18 +14,19 @@
 )
 
 
-@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=2)
-@pytest.mark.parametrize("ghost_size", [1, 2, 3])
+@pytest.mark.mpi(group="MPI_stencil_ops_2d", min_size=4)
+@pytest.mark.parametrize("ghost_size", [1, 2])
 @pytest.mark.parametrize("precision", ["single", "double"])
 @pytest.mark.parametrize("rank_distribution", [(1, 0), (0, 1)])
-@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 2), (2, 1)])
+@pytest.mark.parametrize("aspect_ratio", [(1, 1), (1, 1.5)])
 def test_mpi_diffusion_flux_2d(ghost_size, precision, rank_distribution, aspect_ratio):
-    n_values = 32
+    n_values = 8
+    grid_size_y, grid_size_x = (n_values * np.array(aspect_ratio)).astype(int)
     real_t = get_real_t(precision)
     # Generate the MPI topology minimal object
     mpi_construct = MPIConstruct2D(
-        grid_size_y=n_values * aspect_ratio[0],
-        grid_size_x=n_values * aspect_ratio[1],
+        grid_size_y=grid_size_y,
+        grid_size_x=grid_size_x,
         real_t=real_t,
         rank_distribution=rank_distribution,
     )
@@ -51,9 +52,7 @@ def test_mpi_diffusion_flux_2d(ghost_size, precision, rank_distribution, aspect_
 
     # Initialize and broadcast solution for comparison later
     if mpi_construct.rank == 0:
-        ref_field = np.random.rand(
-            n_values * aspect_ratio[0], n_values * aspect_ratio[1]
-        ).astype(real_t)
+        ref_field = np.random.rand(grid_size_y, grid_size_x).astype(real_t)
         prefactor = real_t(0.1)
     else:
         ref_field = None