Fix restart roundtrip, grid stretching, and hypoelasticity test failures

Restart roundtrip: Phase 2 now runs only SIMULATION (skips pre_process)
since it reads grid+IC directly from p_all/p0/<mid_step>/. D/ is
preserved across phases and intermediate step files are cleaned up so
the final output matches a straight run.

Grid stretching: Enlarge patches to cover the cosh-stretched domain
(which expands beyond [0,1] to ~[0,1.39] with a=2, x_a=0.3, x_b=0.7).
Without this, cells beyond the original bounds are uninitialized.

Hypoelasticity MPI: Add dt=1e-06 matching other 3D hypoelasticity tests
(default dt=0.0005 exceeds CFL for the high speed of sound ~88).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: sbryngelson

tests/0090B316/golden.txt

@@ -5,7 +5,7 @@
 from ..      import case, common
 from ..state import ARG
 from ..run   import input
-from ..build import MFCTarget, get_target
+from ..build import MFCTarget, SIMULATION, get_target
 
 Tend = 0.25
 Nt   = 50
@@ -158,18 +158,26 @@ def run_restart(self, targets, gpus):
             if result1.returncode != 0:
                 return result1
 
-            # Delete output data but keep restart_data/
+            # Keep D/ (has steps 0 and mid_step) and p_all/ (restart data).
             dirpath = self.get_dirpath()
-            common.delete_directory(os.path.join(dirpath, "D"))
-            common.delete_directory(os.path.join(dirpath, "p_all"))
             common.delete_directory(os.path.join(dirpath, "silo_hdf5"))
 
-            # Phase 2: Restart from midpoint
-            self.params = {**orig, 'old_ic': 'T', 'old_grid': 'T',
-                           't_step_start': mid_step,
+            # Phase 2: Restart simulation from midpoint.  Only the simulation
+            # is run — it reads grid + IC directly from p_all/p0/<mid_step>/.
+            self.params = {**orig, 't_step_start': mid_step,
                            't_step_save': orig['t_step_stop'] - mid_step}
             self.create_directory()
-            return self.run(targets, gpus)
+            result2 = self.run([SIMULATION], gpus)
+
+            # Remove intermediate step files from D/ so only step 0 and
+            # t_step_stop remain, matching the straight run's output.
+            if result2.returncode == 0:
+                d_dir = os.path.join(dirpath, "D")
+                mid_tag = f"{mid_step:06d}"
+                for f in glob.glob(os.path.join(d_dir, f"*.{mid_tag}.dat")):
+                    os.remove(f)
+
+            return result2
         finally:
             self.params = orig
             self.create_directory()

tests/05D092C5/golden.txt

@@ -1213,6 +1213,7 @@ def mpi_consistency_tests():
 
         # Hypoelasticity with 2 MPI ranks
         stack.push('MPI Consistency -> 3D -> Hypoelasticity', {**base_3d,
+            'dt': 1e-06,
             'hypoelasticity': 'T', 'riemann_solver': 1, 'fd_order': 4,
             'fluid_pp(1)%gamma': 0.3, 'fluid_pp(1)%pi_inf': 7.8E+05,
             'fluid_pp(1)%G': 1.E+05,
@@ -1321,11 +1322,25 @@ def kernel_golden_tests():
             'patch_icpp(3)%z_centroid': 0.9,  'patch_icpp(3)%length_z': 0.2,
         })
 
-        # 3D grid stretching in all directions
+        # 3D grid stretching in all directions.
+        # The cosh-based stretching expands the domain beyond the original
+        # bounds (e.g., [0,1] → ~[0,1.39] with a=2, x_a=0.3, x_b=0.7).
+        # Patches must be enlarged to cover the stretched domain, otherwise
+        # cells beyond the original bounds are uninitialized (zero density),
+        # causing ICFL blowup.
         stack.push('Kernel -> 3D -> Grid Stretching', {**base_3d,
-            'stretch_x': 'T', 'a_x': 2.0, 'x_a': -0.3, 'x_b': 0.3, 'loops_x': 1,
-            'stretch_y': 'T', 'a_y': 2.0, 'y_a': -0.3, 'y_b': 0.3, 'loops_y': 1,
-            'stretch_z': 'T', 'a_z': 2.0, 'z_a': -0.3, 'z_b': 0.3, 'loops_z': 1,
+            'stretch_x': 'T', 'a_x': 2.0, 'x_a': 0.3, 'x_b': 0.7, 'loops_x': 1,
+            'stretch_y': 'T', 'a_y': 2.0, 'y_a': 0.3, 'y_b': 0.7, 'loops_y': 1,
+            'stretch_z': 'T', 'a_z': 2.0, 'z_a': 0.3, 'z_b': 0.7, 'loops_z': 1,
+            # Enlarge x/y coverage for all patches (stretched domain reaches ~1.39)
+            'patch_icpp(1)%x_centroid': 0.75, 'patch_icpp(1)%length_x': 1.5,
+            'patch_icpp(1)%y_centroid': 0.75, 'patch_icpp(1)%length_y': 1.5,
+            'patch_icpp(2)%x_centroid': 0.75, 'patch_icpp(2)%length_x': 1.5,
+            'patch_icpp(2)%y_centroid': 0.75, 'patch_icpp(2)%length_y': 1.5,
+            'patch_icpp(3)%x_centroid': 0.75, 'patch_icpp(3)%length_x': 1.5,
+            'patch_icpp(3)%y_centroid': 0.75, 'patch_icpp(3)%length_y': 1.5,
+            # Extend last z-patch to cover stretched z range
+            'patch_icpp(3)%z_centroid': 1.15,  'patch_icpp(3)%length_z': 0.7,
         })
         cases.append(define_case_d(stack, '', {}))
         stack.pop()