Revert Model to be a parameter and rename regression test files

reframe_tests/base_tests.py

@@ -6,7 +6,6 @@ from shutil import copyfile
 import reframe as rfm
 import reframe.utility.sanity as sn
 import reframe.utility.typecheck as typ
-from matplotlib.tri import TriContourSet
 from numpy import product
 from reframe.core.builtins import (
     parameter,
@@ -86,7 +85,8 @@ class GprMaxRegressionTest(rfm.RunOnlyRegressionTest):
     num_cpus_per_task = 16
     exclusive_access = True
 
-    model = variable(str)
+    model = parameter()
+    is_antenna_model = variable(bool, value=False)
     # sourcesdir = required
     extra_executable_opts = variable(typ.List[str], value=[])
     executable = "time -p python -m gprMax --log-level 25"
@@ -118,24 +118,34 @@ class GprMaxRegressionTest(rfm.RunOnlyRegressionTest):
         path_to_pyenv = os.path.join(CreatePyenvTest(part="login").stagedir, PATH_TO_PYENV)
         self.prerun_cmds.append(f"source {path_to_pyenv}")
 
-    @run_after("init")
-    def set_model(self):
-        if hasattr(self, "models") and self.models is not None:
-            self.model = self.models
-
-    @run_after("init", always_last=True)
+    @run_after("setup", always_last=True)
     def configure_test_run(self, input_file_ext: str = ".in"):
         self.input_file = f"{self.model}{input_file_ext}"
-        self.skip_if(
-            not os.path.exists(self.input_file),
-            f"Input file '{self.input_file}' not present in src directory '{self.sourcesdir}'",
-        )
         self.output_file = f"{self.model}.h5"
         self.executable_opts = [self.input_file, "-o", self.output_file]
         self.executable_opts += self.extra_executable_opts
         self.postrun_cmds = [f"python -m toolboxes.Plotting.plot_Ascan -save {self.output_file}"]
         self.keep_files = [self.input_file, self.output_file, f"{self.model}.pdf"]
 
+        if self.is_antenna_model:
+            self.postrun_cmds = [
+                f"python -m toolboxes.Plotting.plot_antenna_params -save {self.output_file}"
+            ]
+
+            antenna_t1_params = f"{self.model}_t1_params.pdf"
+            antenna_ant_params = f"{self.model}_ant_params.pdf"
+            self.keep_files += [
+                antenna_t1_params,
+                antenna_ant_params,
+            ]
+
+    @run_before("run")
+    def check_input_file_exists(self):
+        self.skip_if(
+            not os.path.exists(os.path.join(self.sourcesdir, self.input_file)),
+            f"Input file '{self.input_file}' not present in src directory '{self.sourcesdir}'",
+        )
+
     @run_before("run")
     def setup_reference_file(self):
         """Build reference file path"""
@@ -249,65 +259,68 @@ class GprMaxAPIRegressionTest(GprMaxRegressionTest):
 
 
 class GprMaxBScanRegressionTest(GprMaxRegressionTest):
-    num_models = variable(int)
+    num_models = parameter()
 
-    @run_after("init", always_last=True)
+    @run_after("setup", always_last=True)
     def configure_test_run(self):
-        self.input_file = f"{self.model}.in"
-        self.output_file = f"{self.model}_merged.h5"
-        self.executable_opts = [self.input_file, "-n", str(self.num_models)]
+        self.extra_executable_opts += ["-n", str(self.num_models)]
+        super().configure_test_run()
+
         self.postrun_cmds = [
             f"python -m toolboxes.Utilities.outputfiles_merge {self.model}",
+            f"mv {self.model}_merged.h5 {self.output_file}",
             f"python -m toolboxes.Plotting.plot_Bscan -save {self.output_file} Ez",
         ]
-        self.keep_files = [self.input_file, self.output_file, "{self.model}_merged.pdf"]
 
 
 class GprMaxTaskfarmRegressionTest(GprMaxBScanRegressionTest):
-    serial_dependency = variable(type[GprMaxRegressionTest])
+    serial_dependency: type[GprMaxRegressionTest]
     extra_executable_opts = ["-taskfarm"]
 
     num_tasks = required
 
-    @run_after("init")
-    def inject_dependencies(self):
-        """Test depends on the Python virtual environment building correctly"""
+    def _get_variant(self) -> str:
         variant = self.serial_dependency.get_variant_nums(
             model=lambda m: m == self.model, num_models=lambda n: n == self.num_models
         )
-        self.depends_on(self.serial_dependency.variant_name(variant[0]), udeps.by_env)
+        return self.serial_dependency.variant_name(variant[0])
+
+    @run_after("init")
+    def inject_dependencies(self):
+        """Test depends on the Python virtual environment building correctly"""
+        self.depends_on(self._get_variant(), udeps.by_env)
         super().inject_dependencies()
 
     @run_before("run")
     def setup_reference_file(self):
         """Add prerun command to load the built Python environment"""
-        variant = self.serial_dependency.get_variant_nums(
-            model=lambda m: m == self.model, num_models=lambda n: n == self.num_models
-        )
-        target = self.getdep(self.serial_dependency.variant_name(variant[0]))
+        target = self.getdep(self._get_variant())
         self.reference_file = os.path.join(target.stagedir, str(self.output_file))
 
 
 class GprMaxMPIRegressionTest(GprMaxRegressionTest):
+    # TODO: Make this a variable
+    serial_dependency: type[GprMaxRegressionTest]
     mpi_layout = variable(typ.List[int])
-    serial_dependency = variable(type[GprMaxRegressionTest])
 
-    @run_after("init", always_last=True)
+    @run_after("setup", always_last=True)
     def configure_test_run(self):
-        self.num_tasks = product(self.mpi_layout, dtype=int)
-        self.extra_executable_opts = ["-mpi", " ".join(self.mpi_layout)]
+        self.num_tasks = int(product(self.mpi_layout))
+        self.extra_executable_opts = ["-mpi", " ".join(map(str, self.mpi_layout))]
         super().configure_test_run()
 
+    def _get_variant(self) -> str:
+        variant = self.serial_dependency.get_variant_nums(model=lambda m: m == self.model)
+        return self.serial_dependency.variant_name(variant[0])
+
     @run_after("init")
     def inject_dependencies(self):
         """Test depends on the Python virtual environment building correctly"""
-        variant = self.serial_dependency.get_variant_nums(model=lambda m: m == self.model)
-        self.depends_on(self.serial_dependency.variant_name(variant[0]), udeps.by_env)
+        self.depends_on(self._get_variant(), udeps.by_env)
         super().inject_dependencies()
 
     @run_before("run")
     def setup_reference_file(self):
         """Add prerun command to load the built Python environment"""
-        variant = self.serial_dependency.get_variant_nums(model=lambda m: m == self.model)
-        target = self.getdep(self.serial_dependency.variant_name(variant[0]))
+        target = self.getdep(self._get_variant())
         self.reference_file = os.path.join(target.stagedir, str(self.output_file))

reframe_tests/reframe_tests.py

@@ -6,7 +6,7 @@ from base_tests import (
     GprMaxRegressionTest,
     GprMaxTaskfarmRegressionTest,
 )
-from reframe.core.builtins import parameter, run_after, skip
+from reframe.core.builtins import parameter, run_after, run_before
 
 """ReFrame tests for basic functionality
 
@@ -16,6 +16,7 @@ from reframe.core.builtins import parameter, run_after, skip
 """
 
 
+@rfm.simple_test
 class TestAscan(GprMaxRegressionTest):
     tags = {
         "test",
@@ -28,7 +29,7 @@ class TestAscan(GprMaxRegressionTest):
         "box",
         "cylinder",
     }
-    model = "cylinder_Ascan_2D"
+    model = parameter(["cylinder_Ascan_2D"])
 
 
 @rfm.simple_test
@@ -44,8 +45,8 @@ class TestBscan(GprMaxBScanRegressionTest):
         "box",
         "cylinder",
     }
-    model = "cylinder_Bscan_2D"
-    num_models = 64
+    model = parameter(["cylinder_Bscan_2D"])
+    num_models = parameter([64])
 
 
 @rfm.simple_test
@@ -61,11 +62,11 @@ class TestSingleNodeTaskfarm(GprMaxTaskfarmRegressionTest):
         "box",
         "cylinder",
     }
-    model = "cylinder_Bscan_2D"
     num_tasks = 8
     num_tasks_per_node = 8
-    num_models = 64
     serial_dependency = TestBscan
+    model = serial_dependency.model
+    num_models = serial_dependency.num_models
 
 
 @rfm.simple_test
@@ -81,59 +82,60 @@ class TestMultiNodeTaskfarm(GprMaxTaskfarmRegressionTest):
         "box",
         "cylinder",
     }
-    model = "cylinder_Bscan_2D"
     num_tasks = 32
     num_tasks_per_node = 8
-    num_models = 64
     serial_dependency = TestBscan
+    model = serial_dependency.model
+    num_models = serial_dependency.num_models
 
 
 @rfm.simple_test
 class Test2DModelXY(GprMaxRegressionTest):
     tags = {"test", "serial", "2d", "waveform", "hertzian_dipole"}
-    model = "2D_EzHxHy"
+    model = parameter(["2D_EzHxHy"])
 
 
 @rfm.simple_test
 class Test2DModelXZ(GprMaxRegressionTest):
     tags = {"test", "serial", "2d", "waveform", "hertzian_dipole"}
-    model = "2D_EyzHxHz"
+    model = parameter(["2D_EyHxHz"])
 
 
 @rfm.simple_test
 class Test2DModelYZ(GprMaxRegressionTest):
     tags = {"test", "serial", "2d", "waveform", "hertzian_dipole"}
-    model = "2D_ExzHyHz"
+    model = parameter(["2D_ExHyHz"])
 
 
 @rfm.simple_test
 class TestHertzianDipoleSource(GprMaxRegressionTest):
     tags = {"test", "serial", "hertzian_dipole", "waveform"}
-    model = "hertzian_dipole_fs"
+    model = parameter(["hertzian_dipole_fs"])
 
 
 @rfm.simple_test
 class TestMagneticDipoleSource(GprMaxRegressionTest):
     tags = {"test", "serial", "magnetic_dipole", "waveform"}
-    model = "magnetic_dipole_fs"
+    model = parameter(["magnetic_dipole_fs"])
 
 
 @rfm.simple_test
 class TestDispersiveMaterials(GprMaxRegressionTest):
     tags = {"test", "serial", "hertzian_dipole", "waveform", "material", "dispersive", "box"}
-    model = "hertizian_dipole_dispersive"
+    model = parameter(["hertzian_dipole_dispersive"])
 
 
 @rfm.simple_test
 class TestTransmissionLineSource(GprMaxRegressionTest):
     tags = {"test", "serial", "transmission_line", "waveform"}
-    model = "transmission_line_fs"
+    model = parameter(["transmission_line_fs"])
 
 
 @rfm.simple_test
 class TestEdgeGeometry(GprMaxRegressionTest):
     tags = {"test", "serial", "geometry", "edge", "transmission_line", "waveform", "antenna"}
-    model = "antenna_wire_dipole_fs"
+    model = parameter(["antenna_wire_dipole_fs"])
+    is_antenna_model = True
 
 
 @rfm.simple_test
@@ -149,11 +151,10 @@ class TestSubgrids(GprMaxAPIRegressionTest):
         "dispersive",
         "cylinder",
     }
-    model = "cylinder_fs"
+    model = parameter(["cylinder_fs"])
 
 
 @rfm.simple_test
-@skip("Takes ~1hr 30m on ARCHER2")
 class TestSubgridsWithAntennaModel(GprMaxAPIRegressionTest):
     tags = {
         "test",
@@ -166,80 +167,86 @@ class TestSubgridsWithAntennaModel(GprMaxAPIRegressionTest):
         "fractal_box",
         "add_surface_roughness",
     }
-    model = "gssi_400_over_fractal_subsurface"
+    model = parameter(["gssi_400_over_fractal_subsurface"])
+    is_antenna_model = True
+
+    @run_after("init")
+    def skip_test(self):
+        self.skip_if(self.current_system.name == "archer2", "Takes ~1hr 30m on ARCHER2")
 
 
 @rfm.simple_test
 class Test2DModelXYMpi(GprMaxMPIRegressionTest):
     tags = {"test", "mpi", "2d", "waveform", "hertzian_dipole"}
-    model = "2D_EzHxHy"
     mpi_layout = [4, 4, 1]
     serial_dependency = Test2DModelXY
+    model = serial_dependency.model
 
 
 @rfm.simple_test
 class Test2DModelXZMpi(GprMaxMPIRegressionTest):
     tags = {"test", "mpi", "2d", "waveform", "hertzian_dipole"}
-    model = "2D_EyzHxHz"
     mpi_layout = [4, 1, 4]
     serial_dependency = Test2DModelXZ
+    model = serial_dependency.model
 
 
 @rfm.simple_test
 class Test2DModelYZMpi(GprMaxMPIRegressionTest):
     tags = {"test", "mpi", "2d", "waveform", "hertzian_dipole"}
-    model = "2D_ExzHyHz"
     mpi_layout = [1, 4, 4]
     serial_dependency = Test2DModelYZ
+    model = serial_dependency.model
 
 
 @rfm.simple_test
 class TestHertzianDipoleSourceMpi(GprMaxMPIRegressionTest):
     tags = {"test", "mpi", "hertzian_dipole", "waveform"}
-    model = "hertzian_dipole_fs"
     mpi_layout = [3, 3, 3]
     serial_dependency = TestHertzianDipoleSource
+    model = serial_dependency.model
 
 
 @rfm.simple_test
 class TestMagneticDipoleSourceMpi(GprMaxMPIRegressionTest):
     tags = {"test", "mpi", "magnetic_dipole", "waveform"}
-    model = "magnetic_dipole_fs"
     mpi_layout = [3, 3, 3]
     serial_dependency = TestMagneticDipoleSource
+    model = serial_dependency.model
 
 
 @rfm.simple_test
 class TestDispersiveMaterialsMpi(GprMaxMPIRegressionTest):
     tags = {"test", "mpi", "hertzian_dipole", "waveform", "material", "dispersive", "box"}
-    model = "hertizian_dipole_dispersive"
     mpi_layout = [3, 3, 3]
     serial_dependency = TestDispersiveMaterials
+    model = serial_dependency.model
 
 
 @rfm.simple_test
 class TestTransmissionLineSourceMpi(GprMaxMPIRegressionTest):
     tags = {"test", "mpi", "transmission_line", "waveform"}
-    model = "transmission_line_fs"
     mpi_layout = [3, 3, 3]
     serial_dependency = TestTransmissionLineSource
+    model = serial_dependency.model
 
 
 @rfm.simple_test
 class TestEdgeGeometryMpi(GprMaxMPIRegressionTest):
     tags = {"test", "mpi", "geometry", "edge", "transmission_line", "waveform", "antenna"}
-    model = "antenna_wire_dipole_fs"
     mpi_layout = [3, 3, 3]
     serial_dependency = TestEdgeGeometry
+    model = serial_dependency.model
+    is_antenna_model = True
 
 
 @rfm.simple_test
 class TestBoxGeometryNoPml(GprMaxRegressionTest):
     tags = {"test", "serial", "geometery", "box"}
     sourcesdir = "src/box_geometry_tests"
-    models = parameter(["box_full_model", "box_half_model"])
+    model = parameter(["box_full_model", "box_half_model"])
 
-    @run_after("init", always_last=True)
+    @run_before("run")
     def add_gprmax_commands(self):
         self.prerun_cmds.append(f"echo '#pml_cells: 0' >> {self.input_file}")
 
@@ -248,17 +255,17 @@ class TestBoxGeometryNoPml(GprMaxRegressionTest):
 class TestBoxGeometryDefaultPml(GprMaxRegressionTest):
     tags = {"test", "serial", "geometery", "box"}
     sourcesdir = "src/box_geometry_tests"
-    models = parameter(["box_full_model", "box_half_model"])
+    model = parameter(["box_full_model", "box_half_model"])
 
 
 @rfm.simple_test
 class TestBoxGeometryNoPmlMpi(GprMaxMPIRegressionTest):
     tags = {"test", "mpi", "geometery", "box"}
-    models = TestBoxGeometryNoPml.models
     mpi_layout = [2, 2, 2]
     serial_dependency = TestBoxGeometryNoPml
+    model = serial_dependency.model
 
-    @run_after("init", always_last=True)
+    @run_before("run")
     def add_gprmax_commands(self):
         self.prerun_cmds.append(f"echo '#pml_cells: 0' >> {self.input_file}")
 
@@ -266,6 +273,6 @@ class TestBoxGeometryNoPmlMpi(GprMaxMPIRegressionTest):
 @rfm.simple_test
 class TestBoxGeometryDefaultPmlMpi(GprMaxMPIRegressionTest):
     tags = {"test", "mpi", "geometery", "box"}
-    models = TestBoxGeometryDefaultPml.models
     mpi_layout = [2, 2, 2]
     serial_dependency = TestBoxGeometryDefaultPml
+    model = serial_dependency.model

reframe_tests/src/box_geometry_tests/box_full_model.in

@@ -0,0 +1,11 @@
+#title: Hertzian dipole over a half-space
+#domain: 0.100 0.100 0.100
+#dx_dy_dz: 0.001 0.001 0.001
+#time_window: 3e-9
+
+#waveform: gaussiandot 1 1e9 myWave
+#hertzian_dipole: z 0.050 0.050 0.050 myWave
+#rx: 0.070 0.070 0.070
+
+#material: 8 0 1 0 half_space
+#box: 0 0 0 0.100 0.100 0.100 half_space

reframe_tests/src/transmission_line_fs.in

@@ -0,0 +1,7 @@
+#title: Transmission line in free-space
+#domain: 0.100 0.100 0.100
+#dx_dy_dz: 0.001 0.001 0.001
+#time_window: 3e-9
+
+#waveform: gaussian 1 1e9 mypulse
+#transmission_line: x 0.025 0.040 0.040 35 mypulse