Add support for adjoint testing

This is an attempt to support adjoint testing without redoing each adjoint
run twice and providing more stability and less fragility.  A new helper
function has been added to the AMRClaw test python module.  Hopefully this
will also work in GeoClaw.

Author: mandli

examples/acoustics_1d_adjoint/adjoint/test_acoustics_1d_adjoint.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python
 """
 Test for the adjoint problem for 1D acoustics
 """
@@ -10,14 +11,14 @@
 def test_acoustics_1d_adjoint(tmp_path: Path, save: bool):
     """Acoustics 1D adjoint test"""
 
-    ctr = test.AMRClawTestRunner(tmp_path)
-    ctr.set_data()
-    ctr.write_data()
-    ctr.build_executable()
-    ctr.run_code()
+    runner = test.AMRClawTestRunner(tmp_path, test_path=Path(__file__).parent)
+    runner.set_data()
+    runner.write_data()
+    runner.build_executable()
+    runner.run_code()
 
-    ctr.check_gauge(gauge_id=0)
-    ctr.check_gauge(gauge_id=1)
+    runner.check_gauge(gauge_id=0)
+    runner.check_gauge(gauge_id=1)
 
 
 if __name__ == "__main__":

examples/acoustics_1d_adjoint/test_acoustics_1d_adjoint_forward.py

@@ -1,43 +1,35 @@
+#!/usr/bin/env python
 """
 Regression tests for 1D acoustics with adjoint flagging.
 """
 
 from pathlib import Path
-import os
 import pytest
 
 import clawpack.amrclaw.test as test
 
-# import adjoint.test_acoustics_1d_adjoint
-
 def test_acoustics_1d_adjoint_forward(tmp_path: Path, save: bool):
     """Test for a 1D acoustics adjoint-flagging forward problem test case"""
-
-    ctr = test.AMRClawTestRunner(tmp_path, test_path=__file__)
 
-    # Run adjoint problem
-    adjoint_output = ctr.temp_path / "_adjoint_output"
-    
-    if not adjoint_output.exists():
-        os.makedirs(adjoint_output)
-    adjoint_ctr = test.AMRClawTestRunner(adjoint_output, 
-                                         test_path=ctr.test_path / "adjoint")
-    adjoint_ctr.set_data(setrun_path=adjoint_ctr.test_path / "setrun.py")
-    adjoint_ctr.write_data()
-    adjoint_ctr.build_executable()
-    adjoint_ctr.run_code()
-
-    # Write problem data
-    ctr.set_data()
-    ctr.rundata.adjointdata.adjoint_outdir = adjoint_output
-    ctr.write_data()
-
-    ctr.build_executable()
-    ctr.run_code()
-    
-    ctr.check_gauge(gauge_id=0)
-    ctr.check_gauge(gauge_id=1)
-
+    example_path = Path(__file__).parent
+    adjoint_path = example_path / "adjoint"
+    adjoint_output = tmp_path / "_adjoint_output"
+
+    test.run_example_for_test(
+        test.AMRClawTestRunner,
+        adjoint_output,
+        adjoint_path,
+    )
+
+    runner = test.run_example_for_test(
+        test.AMRClawTestRunner,
+        tmp_path,
+        example_path,
+        configure=lambda r: setattr(r.rundata.adjointdata, "adjoint_outdir", adjoint_output),
+    )
+
+    runner.check_gauge(0, save=save)
+    runner.check_gauge(1, save=save)
 
 if __name__ == "__main__":
     pytest.main([__file__])

examples/acoustics_2d_adjoint/adjoint/test_acoustics_2d_adjoint.py

@@ -1,47 +1,37 @@
+#!/usr/bin/env python
 """
 Test for the adjoint problem for 2D acoustics
 """
 
-import sys
-import unittest
+from pathlib import Path
+import pytest
 
 import clawpack.amrclaw.test as test
-import clawpack.amrclaw.data as data
 
-class Acoustics2DAdjointTest(test.AMRClawRegressionTest):
+def configure_2d_adjoint(runner):
+    clawdata = runner.rundata.clawdata
+    gaugedata = runner.rundata.gaugedata
 
-    def runTest(self, save=False):
+    clawdata.num_output_times = 30
+    clawdata.tfinal = 3.0
 
-        # Write out data files
-        self.load_rundata()
+    gaugedata.gauges = [
+        [1, 1.0, 1.0, 0.0, 10.0],
+        [2, 3.5, 0.5, 0.0, 10.0],
+    ]
 
-        self.rundata.clawdata.num_output_times = 30
-        self.rundata.clawdata.tfinal = 3.0
+def test_acoustics_2d_adjoint(tmp_path: Path, save: bool):
+    adjoint_path = Path(__file__).parent
 
-        self.rundata.gaugedata.gauges = []
-        self.rundata.gaugedata.gauges.append([1, 1.0, 1.0, 0., 10.])
-        self.rundata.gaugedata.gauges.append([2, 3.5, 0.5, 0., 10.])
+    runner = test.run_example_for_test(
+        test.AMRClawTestRunner,
+        tmp_path,
+        adjoint_path,
+        configure_runner=configure_2d_adjoint,
+    )
 
-        self.write_rundata_objects()
+    runner.check_gauge(gauge_id=1, save=save)
+    runner.check_gauge(gauge_id=2, save=save)
 
-        self.run_code()
-
-        # Perform Tests
-        self.check_gauges(save=save, gauge_id=1)
-        self.check_gauges(save=save, gauge_id=2)
-
-        self.success = True
-
-
-if __name__=="__main__":
-    if len(sys.argv) > 1:
-        if bool(sys.argv[1]):
-            # Fake the setup and save out output
-            test = Acoustics2DAdjointTest()
-            try:
-                test.setUp()
-                test.runTest(save=True)
-            finally:
-                test.tearDown()
-            sys.exit(0)
-    unittest.main()
+if __name__ == "__main__":
+    pytest.main([__file__])

examples/acoustics_2d_adjoint/test_acoustics_2d_adjoint_forward.py

@@ -1,80 +1,72 @@
+#!/usr/bin/env python
 """
 Regression tests for 2D acoustics with adjoint flagging.
 """
 
 from pathlib import Path
-import sys
-import shutil
-import unittest
+import pytest
 
 import clawpack.amrclaw.test as test
 
-from adjoint.test_acoustics_2d_adjoint import Acoustics2DAdjointTest 
+def configure_2d_adjoint(runner):
+    clawdata = runner.rundata.clawdata
+    gaugedata = runner.rundata.gaugedata
 
-class Acoustics2DAdjointForwardTest(test.AMRClawRegressionTest):
-    r"""Basic test for a 2D acoustics adjoint-flagging forward problem test case"""
+    clawdata.num_output_times = 30
+    clawdata.tfinal = 3.0
 
+    gaugedata.gauges = [
+        [1, 1.0, 1.0, 0.0, 10.0],
+        [2, 3.5, 0.5, 0.0, 10.0],
+    ]
 
-    def runTest(self, save=False):
-        
-        # Run adjoint problem
-        try:
-            adjoint_run = Acoustics2DAdjointTest()    
-            adjoint_run.setUp()
-            adjoint_run.runTest()
-            
-            # Copy output to local directory
-            adjoint_output = Path(self.temp_path) / "_adjoint_output"
+def configure_2d_forward(adjoint_output: Path):
+    def _configure(runner):
+        clawdata = runner.rundata.clawdata
+        gaugedata = runner.rundata.gaugedata
+        amrdata = runner.rundata.amrdata
 
-            if Path(adjoint_output).exists():
-                shutil.rmtree(adjoint_output)
-            shutil.copytree(adjoint_run.temp_path, adjoint_output)
-        finally:
-            adjoint_run.tearDown()
-
-        # Write out data files
-        self.load_rundata()
-
-        self.rundata.clawdata.num_output_times = 1
-        self.rundata.clawdata.tfinal = 3.0
+        clawdata.num_output_times = 1
+        clawdata.tfinal = 3.0
 
         # Test gauges
-        self.rundata.gaugedata.gauges = []
-        self.rundata.gaugedata.gauges.append([1, 1.0, 1.0, 0., 1e9])
-        self.rundata.gaugedata.gauges.append([2, 3.5, 0.5, 0., 1e9])
+        gaugedata.gauges = []
+        gaugedata.gauges.append([1, 1.0, 1.0, 0., 1e9])
+        gaugedata.gauges.append([2, 3.5, 0.5, 0., 1e9])
 
         # AMR parameters
-        self.rundata.amrdata.amr_levels_max = 2
-        self.rundata.amrdata.refinement_ratios_x = [2]
-        self.rundata.amrdata.refinement_ratios_y = [2]
-        self.rundata.amrdata.refinement_ratios_t = [2]
-        self.rundata.amrdata.flag_richardson_tol = 1e-5
-        self.rundata.amrdata.flag2refine_tol = 0.02
-
-        # Look for adjoint data
-        self.rundata.adjointdata.adjoint_outdir = adjoint_output.resolve()
-
-        self.write_rundata_objects()
-
-        # Run code
-        self.run_code()
-
-        # Perform tests
-        self.check_gauges(save=save, gauge_id=1)
-        self.check_gauges(save=save, gauge_id=2)
-
-        self.success = True
-
-
-if __name__=="__main__":
-    if len(sys.argv) > 1:
-        if bool(sys.argv[1]):
-            # Fake the setup and save out output
-            test = Acoustics2DAdjointForwardTest()
-            try:
-                test.setUp()
-                test.runTest(save=True)
-            finally:
-                test.tearDown()
-            sys.exit(0)
-    unittest.main()
+        amrdata.amr_levels_max = 2
+        amrdata.refinement_ratios_x = [2]
+        amrdata.refinement_ratios_y = [2]
+        amrdata.refinement_ratios_t = [2]
+        amrdata.flag_richardson_tol = 1e-5
+        amrdata.flag2refine_tol = 0.02
+
+        runner.rundata.adjointdata.adjoint_outdir = adjoint_output
+
+    return _configure
+
+def test_acoustics_2d_adjoint_forward(tmp_path: Path, save: bool):
+    example_path = Path(__file__).parent
+    adjoint_path = example_path / "adjoint"
+    adjoint_output = tmp_path / "_adjoint_output"
+
+    test.run_example_for_test(
+        test.AMRClawTestRunner,
+        adjoint_output,
+        adjoint_path,
+        configure_runner=configure_2d_adjoint,
+    )
+
+    runner = test.run_example_for_test(
+        test.AMRClawTestRunner,
+        tmp_path,
+        example_path,
+        configure_runner=configure_2d_forward(adjoint_output),
+    )
+
+    runner.check_gauge(gauge_id=1, save=save)
+    runner.check_gauge(gauge_id=2, save=save)
+
+if __name__ == "__main__":
+    pytest.main([__file__])

src/python/amrclaw/test.py

@@ -22,3 +22,47 @@ class AMRClawTestRunner(test.ClawpackTestRunner):
     def __init__(self, path: Path, test_path: Optional[Path]=None):
         super(AMRClawTestRunner, self).__init__(path, test_path=test_path)
         self.executable_name = 'xamr'
+
+
+# Useful for running tests that need more than one example to be run, e.g. an
+# adjoint test that needs to run the forward problem first.
+def run_example_for_test(
+    runner_cls,
+    output_path: Path,
+    test_path: Path,
+    *,
+    setrun_path: Path | None = None,
+    configure_runner=None,
+    build_kwargs: dict | None = None,
+):
+    """
+    Build and run one example in a specified output directory.
+
+    Parameters
+    ----------
+    runner_cls
+        Runner class, e.g. AMRClawTestRunner.
+    output_path
+        Temporary directory for data files, executable, and output.
+    test_path
+        Path to the example directory.
+    setrun_path
+        Optional explicit path to setrun.py.
+    configure
+        Optional callback taking the runner after set_data() and before
+        write_data().
+    build_kwargs
+        Optional keyword arguments passed to build_executable().
+    """
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    runner = runner_cls(output_path, test_path=test_path)
+    runner.set_data(setrun_path=setrun_path)
+
+    if configure_runner is not None:
+        configure_runner(runner)
+
+    runner.write_data()
+    runner.build_executable(**(build_kwargs or {}))
+    runner.run_code()
+    return runner