Seperate write and read geometry object tests

reframe_tests/tests/base_tests.py

@@ -161,9 +161,11 @@ class GprMaxBaseTest(RunOnlyRegressionTest):
         if self.test_dependency is None:
             return None
 
-        # Always filter by the model parameter, but allow child classes
+        # Always filter by the model parameter (unless the test
+        # dependency only runs a single model), but allow child classes
         # (or mixins) to override how models are filtered.
-        kwargs.setdefault("model", self.model)
+        if len(self.test_dependency.model.values) > 1:
+            kwargs.setdefault("model", self.model)
 
         variant_nums = self.test_dependency.get_variant_nums(**kwargs)
 

reframe_tests/tests/mixins.py

@@ -1,10 +1,12 @@
 from pathlib import Path
+from shutil import copyfile
 from typing import Optional
 
+import reframe.utility.sanity as sn
 import reframe.utility.typecheck as typ
 from numpy import prod
 from reframe import RegressionMixin
-from reframe.core.builtins import parameter, required, run_after, variable
+from reframe.core.builtins import parameter, run_after, variable
 from typing_extensions import TYPE_CHECKING
 
 from reframe_tests.tests.base_tests import GprMaxBaseTest
@@ -31,7 +33,11 @@ class ReceiverMixin(GprMaxMixin):
 
     @run_after("setup", always_last=True)
     def add_receiver_regression_checks(self):
-        reference_file = self.build_reference_filepath(self.output_file)
+        test_dependency = self.get_test_dependency()
+        if test_dependency is not None:
+            reference_file = self.build_reference_filepath(test_dependency.output_file)
+        else:
+            reference_file = self.build_reference_filepath(self.output_file)
 
         if self.number_of_receivers > 0:
             for i in range(self.number_of_receivers):
@@ -88,16 +94,7 @@ class GeometryOnlyMixin(GprMaxMixin):
         self.executable_opts += ["--geometry-only"]
 
 
-class GeometryObjectMixin(GprMaxMixin):
-    """Add regression tests for geometry objects.
-
-    Attributes:
-        geometry_objects (list[str]): List of geometry objects to run
-            regression checks on.
-    """
-
-    geometry_objects = variable(typ.List[str], value=[])
-
+class GeometryObjectMixinBase(GprMaxMixin):
     def build_geometry_object_filepath(self, geometry_object: str) -> Path:
         """Build filepath to the specified geometry object.
 
@@ -114,6 +111,63 @@ class GeometryObjectMixin(GprMaxMixin):
         """
         return Path(f"{geometry_object}_materials").with_suffix(".txt")
 
+
+class GeometryObjectsReadMixin(GeometryObjectMixinBase):
+    geometry_objects_read = variable(typ.Dict[str, str], value={})
+
+    @run_after("setup")
+    def copy_geometry_objects_from_test_dependency(self):
+        self.skip_if(
+            len(self.geometry_objects_read) < 0,
+            f"Must provide a list of geometry objects being read by the test.",
+        )
+
+        test_dependency = self.get_test_dependency()
+
+        self.skip_if(
+            test_dependency is None,
+            f"GeometryObjectsReadMixin must be used with a test dependency.",
+        )
+
+        for geometry_object_input, geometry_object_output in self.geometry_objects_read.items():
+            geometry_object_input_file = self.build_geometry_object_filepath(geometry_object_input)
+            geometry_object_input_file = Path(test_dependency.stagedir, geometry_object_input_file)
+
+            materials_input_file = self.build_materials_filepath(geometry_object_input)
+            materials_input_file = Path(test_dependency.stagedir, materials_input_file)
+
+            self.skip_if(
+                not sn.path_isfile(geometry_object_input_file),
+                f"Test dependency did not create geometry object file.",
+            )
+
+            self.skip_if(
+                not sn.path_isfile(materials_input_file),
+                f"Test dependency did not create geometry object materials file.",
+            )
+
+            geometry_object_output_file = self.build_geometry_object_filepath(
+                geometry_object_output
+            )
+            geometry_object_output_file = Path(self.stagedir, geometry_object_output_file)
+
+            materials_output_file = self.build_materials_filepath(geometry_object_output)
+            materials_output_file = Path(self.stagedir, materials_output_file)
+
+            copyfile(geometry_object_input_file, geometry_object_output_file)
+            copyfile(materials_input_file, materials_output_file)
+
+
+class GeometryObjectsWriteMixin(GeometryObjectMixinBase):
+    """Add regression tests for geometry objects.
+
+    Attributes:
+        geometry_objects_write (list[str]): List of geometry objects to
+            run regression checks on.
+    """
+
+    geometry_objects_write = variable(typ.List[str], value=[])
+
     @run_after("setup")
     def add_geometry_object_regression_checks(self):
         """Add a regression check for each geometry object.
@@ -121,11 +175,11 @@ class GeometryObjectMixin(GprMaxMixin):
         The test will be skipped if no geometry objects have been specified.
         """
         self.skip_if(
-            len(self.geometry_objects) < 0,
-            f"Must provide a list of geometry objects.",
+            len(self.geometry_objects_write) < 0,
+            f"Must provide a list of geometry objects being written by the test.",
         )
 
-        for geometry_object in self.geometry_objects:
+        for geometry_object in self.geometry_objects_write:
             # Add materials regression check first as if this fails,
             # checking the .h5 file will almost definitely fail.
             materials_file = self.build_materials_filepath(geometry_object)
@@ -138,7 +192,9 @@ class GeometryObjectMixin(GprMaxMixin):
             self.regression_checks.append(materials_regression_check)
 
             geometry_object_file = self.build_geometry_object_filepath(geometry_object)
-            reference_file = self.build_reference_filepath(geometry_object)
+            reference_file = self.build_reference_filepath(
+                geometry_object, suffix=geometry_object_file.suffix
+            )
             regression_check = GeometryObjectRegressionCheck(geometry_object_file, reference_file)
             self.regression_checks.append(regression_check)
 

reframe_tests/tests/src/geometry_object_tests/geometry_object_read_full_volume.in

@@ -0,0 +1,11 @@
+#title: Hertzian dipole in free-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.08 0.08 0.08
+
+#geometry_objects_read: 0 0 0 full_volume_read.h5 full_volume_read_materials.txt

reframe_tests/tests/src/geometry_object_tests/geometry_object_read_write_partial_volume.in

@@ -0,0 +1,12 @@
+#title: Hertzian dipole in free-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.08 0.08 0.08
+
+#geometry_objects_read: 0.05 0.05 0.05 partial_volume_read.h5 partial_volume_read_materials.txt
+#geometry_objects_write: 0.05 0.05 0.05 0.09 0.09 0.09 partial_volume

reframe_tests/tests/src/geometry_object_tests/geometry_object_write.in

@@ -6,6 +6,8 @@
 #waveform: gaussiandot 1 1e9 myWave
 #hertzian_dipole: z 0.050 0.050 0.050 myWave
 
+#rx: 0.08 0.08 0.08
+
 #material: 4.9 0 1 0 myWater
 #material: 2 0 1.4 0 unusedMaterial
 #material: 3 0 2 0 boxMaterial

reframe_tests/tests/standard_tests.py

@@ -1,6 +1,7 @@
 from reframe_tests.tests.base_tests import GprMaxBaseTest
 from reframe_tests.tests.mixins import (
-    GeometryObjectMixin,
+    GeometryObjectsReadMixin,
+    GeometryObjectsWriteMixin,
     GeometryOnlyMixin,
     GeometryViewMixin,
     ReceiverMixin,
@@ -20,7 +21,17 @@ class GprMaxGeometryViewTest(GeometryViewMixin, GeometryOnlyMixin, GprMaxBaseTes
     pass
 
 
-class GprMaxGeometryObjectTest(GeometryObjectMixin, GeometryOnlyMixin, GprMaxBaseTest):
+class GprMaxGeometryObjectsWriteTest(GeometryObjectsWriteMixin, GprMaxBaseTest):
+    pass
+
+
+class GprMaxGeometryObjectsReadTest(GeometryObjectsReadMixin, GprMaxBaseTest):
+    pass
+
+
+class GprMaxGeometryObjectsReadWriteTest(
+    GeometryObjectsReadMixin, GeometryObjectsWriteMixin, GprMaxBaseTest
+):
     pass
 
 

reframe_tests/tests/test_geometry_objects.py

@@ -1,16 +1,20 @@
 import reframe as rfm
 from reframe.core.builtins import parameter
 
-from reframe_tests.tests.mixins import MpiMixin
-from reframe_tests.tests.standard_tests import GprMaxGeometryObjectTest
+from reframe_tests.tests.mixins import GeometryOnlyMixin, MpiMixin, ReceiverMixin
+from reframe_tests.tests.standard_tests import (
+    GprMaxGeometryObjectsReadTest,
+    GprMaxGeometryObjectsReadWriteTest,
+    GprMaxGeometryObjectsWriteTest,
+)
 
 
 @rfm.simple_test
-class TestGeometryObject(GprMaxGeometryObjectTest):
+class TestGeometryObject(ReceiverMixin, GprMaxGeometryObjectsWriteTest):
     tags = {"test", "serial", "geometry only", "geometry object"}
     sourcesdir = "src/geometry_object_tests"
     model = parameter(["geometry_object_write"])
-    geometry_objects = ["partial_volume", "full_volume"]
+    geometry_objects_write = ["partial_volume", "full_volume"]
 
 
 @rfm.simple_test
@@ -18,3 +22,37 @@ class TestGeometryObjectMPI(MpiMixin, TestGeometryObject):
     tags = {"test", "mpi", "geometry only", "geometry object"}
     mpi_layout = parameter([[2, 2, 2], [4, 4, 1]])
     test_dependency = TestGeometryObject
+
+
+@rfm.simple_test
+class TestGeometryObjectReadFullVolume(ReceiverMixin, GprMaxGeometryObjectsReadTest):
+    tags = {"test", "serial", "geometry only", "geometry object"}
+    sourcesdir = "src/geometry_object_tests"
+    model = parameter(["geometry_object_read_full_volume"])
+    geometry_objects_read = {"full_volume": "full_volume_read"}
+    geometry_objects_write = ["full_volume"]
+    test_dependency = TestGeometryObject
+
+
+@rfm.simple_test
+class TestGeometryObjectReadFullVolumeMPI(MpiMixin, TestGeometryObjectReadFullVolume):
+    tags = {"test", "mpi", "geometry only", "geometry object"}
+    mpi_layout = parameter([[2, 2, 2], [4, 4, 1]])
+    test_dependency = TestGeometryObject
+
+
+@rfm.simple_test
+class TestGeometryObjectReadWrite(GeometryOnlyMixin, GprMaxGeometryObjectsReadWriteTest):
+    tags = {"test", "serial", "geometry only", "geometry object"}
+    sourcesdir = "src/geometry_object_tests"
+    model = parameter(["geometry_object_read_write_partial_volume"])
+    geometry_objects_read = {"partial_volume": "partial_volume_read"}
+    geometry_objects_write = ["partial_volume"]
+    test_dependency = TestGeometryObject
+
+
+@rfm.simple_test
+class TestGeometryObjectReadWriteMPI(MpiMixin, TestGeometryObjectReadWrite):
+    tags = {"test", "mpi", "geometry only", "geometry object"}
+    mpi_layout = parameter([[2, 2, 2], [4, 4, 1]])
+    test_dependency = TestGeometryObject