ASEClusterRunner: tolerate ASE calculators without stress support

The runner computed atoms.get_stress() unconditionally, so a calculator
without a stress implementation crashed every job even when the ensemble
was computed with get_stress=False. Guard the stress call (like
ASEDirectCalculator already did) and omit the stress key from the output
JSON; ASEFileCalculator.read_results now treats it as optional. Adds
regression tests covering a stress-less calculator on both DirectCluster
and the file-bridge runner path.

Author: mesonepigreco

Modules/ASEClusterRunner.py

@@ -7,8 +7,9 @@
     python -m sscha.ASEClusterRunner --calc calculator.pkl \
         --input PREFIX_input.json --output PREFIX.json
 
-The output JSON contains energy [eV], forces [eV/Angstrom], stress
-[ASE Voigt (xx, yy, zz, yz, xz, xy), eV/Angstrom^3] and the computed Atoms.
+The output JSON contains energy [eV], forces [eV/Angstrom], the computed
+Atoms and, when the calculator supports it, stress [ASE Voigt
+(xx, yy, zz, yz, xz, xy), eV/Angstrom^3].
 """
 import argparse
 import pickle
@@ -36,9 +37,12 @@ def main():
     payload = {
         "energy": float(atoms.get_potential_energy()),  # eV
         "forces": atoms.get_forces(),                   # eV / Angstrom
-        "stress": atoms.get_stress(),                   # ASE Voigt, -eV/Angstrom^3
         "atoms": atoms,                                 # structure actually computed
     }
+    try:
+        payload["stress"] = atoms.get_stress()          # ASE Voigt, -eV/Angstrom^3
+    except Exception:
+        pass  # calculator without stress: call compute_ensemble with get_stress=False
     with open(args.output, "w") as handle:
         handle.write(ase.io.jsonio.encode(payload))
 

Modules/ClusterCalculators.py

@@ -187,8 +187,11 @@ def read_results(self):
         self.results = {
             "energy": payload["energy"],   # eV
             "forces": payload["forces"],   # eV / Angstrom
-            "stress": payload["stress"],   # ASE Voigt (xx,yy,zz,yz,xz,xy), -eV/Angstrom^3
         }
+        if "stress" in payload:
+            # ASE Voigt (xx,yy,zz,yz,xz,xy), -eV/Angstrom^3. Absent when the
+            # calculator does not support stress (get_stress=False).
+            self.results["stress"] = payload["stress"]
         self.structure = CC.Structure.Structure()
         self.structure.generate_from_ase_atoms(payload["atoms"])
 

tests/test_otf/test_cluster_interface.py

@@ -150,3 +150,73 @@ def __getstate__(self):
             raise TypeError("no pickle")
     with pytest.raises(TypeError):
         cluster_calcs.ASEFileCalculator(Unpicklable())
+
+
+def test_directcluster_stress_less_calculator():
+    """A calculator without stress works via DirectCluster with get_stress=False."""
+    class NoStressEMT(EMT):
+        def get_stress(self, atoms=None, voigt=True):
+            raise NotImplementedError("NoStressEMT does not support stress")
+
+    np.random.seed(0)
+    ensemble = sscha.Ensemble.Ensemble(get_gold_dyn(), 0)
+    ensemble.generate(4)
+    cluster = sscha.BaseCluster.DirectCluster(batch_size=2, job_number=1)
+    ensemble.compute_ensemble(cluster_calcs.ASEDirectCalculator(NoStressEMT()),
+                              compute_stress=False, cluster=cluster)
+
+    assert all(ensemble.force_computed)
+    assert not any(ensemble.stress_computed)
+    from ase.units import create_units
+    Ry = create_units("2006")["Ry"]
+    atoms = ensemble.structures[0].get_ase_atoms()
+    atoms.calc = NoStressEMT()
+    assert ensemble.energies[0] == pytest.approx(atoms.get_potential_energy() / Ry, rel=1e-10)
+    assert np.allclose(ensemble.forces[0], atoms.get_forces() / Ry, atol=1e-10)
+
+
+_NO_STRESS_MODULE = """
+from ase.calculators.emt import EMT
+
+
+class NoStressEMT(EMT):
+    \"\"\"EMT that refuses to compute the stress (like stress-less codes).\"\"\"
+    def get_stress(self, atoms=None, voigt=True):
+        raise NotImplementedError("NoStressEMT does not support stress")
+"""
+
+
+def test_ase_file_calculator_stress_less_roundtrip(tmp_path):
+    """The file bridge tolerates calculators without stress (get_stress=False).
+
+    The runner must not crash on a missing stress implementation: the output
+    JSON simply omits the ``stress`` key and ``read_results`` keeps working.
+    """
+    import sys as _sys
+
+    (tmp_path / "_nostress_calc.py").write_text(_NO_STRESS_MODULE)
+    _sys.path.insert(0, str(tmp_path))
+    try:
+        from _nostress_calc import NoStressEMT
+
+        calc = cluster_calcs.ASEFileCalculator(NoStressEMT())
+        calc.set_directory(str(tmp_path))
+        calc.set_label("ESP_0")
+        struct = get_gold_structure()
+        calc.write_input(struct)
+
+        # Execute the runner exactly as Cluster.get_execution_command would
+        cmd = calc.command.replace("PREFIX", os.path.join(str(tmp_path), "ESP_0"))
+        subprocess.run(cmd, shell=True, check=True, cwd=str(tmp_path))
+
+        calc.read_results()
+        assert "energy" in calc.results
+        assert "forces" in calc.results
+        assert "stress" not in calc.results
+
+        atoms = struct.get_ase_atoms()
+        atoms.calc = NoStressEMT()
+        assert calc.results["energy"] == pytest.approx(atoms.get_potential_energy(), rel=1e-10)
+        assert np.allclose(calc.results["forces"], atoms.get_forces(), atol=1e-10)
+    finally:
+        _sys.path.remove(str(tmp_path))