calphy 2.3.0__tar.gz → 2.3.1__tar.gz

{calphy-2.3.0 → calphy-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calphy
-Version: 2.3.0
+Version: 2.3.1
 Summary: free energy calculation for python
 Author: Yury Lysogorskiy, Ralf Drautz
 Author-email: Sarath Menon <sarath.menon@ruhr-uni-bochum.de>

{calphy-2.3.0 → calphy-2.3.1}/calphy/__init__.py

@@ -28,7 +28,7 @@ from calphy.solid import Solid
 from calphy.alchemy import Alchemy
 from calphy.routines import MeltingTemp
 
-__version__ = "2.3.0"
+__version__ = "2.3.1"
 
 def addtest(a,b):
     return a+b

{calphy-2.3.0 → calphy-2.3.1}/calphy/alchemy.py

@@ -175,7 +175,7 @@ class Alchemy(cph.Phase):
         """Coupling-mode integration: ramp ONLY the last component 0->1
         (forward) and 1->0 (backward) over the fixed base.
         W = int <U_last>_lam dlam;  dF = (W_f + W_b)/2 per iteration."""
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
         conf = os.path.join(self.simfolder, "conf.equilibration.data")
         # style only before read_data (pair_coeff needs the box)
         ns = self.calc._pair_style_with_options
@@ -253,7 +253,7 @@ class Alchemy(cph.Phase):
         Fix lattice option is not implemented at present.
         At the end of the run, the averaged box dimensions are calculated.
         """
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         if self.calc.alchemy_coupling:
             # equilibrate on the BASE system (lam = 0): full base, ramped
@@ -345,7 +345,7 @@ class Alchemy(cph.Phase):
         initial, final = self._end_states()
 
         # create lammps object
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         # Adiabatic switching parameters.
         lmp.command("variable        li       equal   1.0")

{calphy-2.3.0 → calphy-2.3.1}/calphy/dcci.py

@@ -345,7 +345,8 @@ class DynamicCCI:
         """
         def equilibrate(phase):
             self.logger.info("Equilibrating the %s cell at %.2f K, %.2f bar" % (phase, self.t0, self.p_start))
-            self.jobs[phase].run_averaging()
+            with self.jobs[phase]:
+                self.jobs[phase].run_averaging()
             self.logger.info("%s cell: %.4f A^3/atom" % (phase, self.jobs[phase].volatom))
 
         self._for_cells(equilibrate)

{calphy-2.3.0 → calphy-2.3.1}/calphy/helpers.py

@@ -24,6 +24,7 @@ sarath.menon@ruhr-uni-bochum.de
 """
 
 import os
+import sys
 import shutil
 import warnings
 import logging
@@ -96,7 +97,7 @@ def create_object(calc, directory):
             cmdargs=calc.md.cmdargs,
             directory=directory,
         )
-        return emit_init_commands(lmp, calc)
+        return _emit_init_commands_or_close(lmp, calc)
 
     binary = resolve_lammps_executable(calc.lammps_executable)
     mpi_command = (
@@ -113,7 +114,20 @@ def create_object(calc, directory):
         directory=directory,
         dry_run=False,
     )
-    return emit_init_commands(lmp, calc)
+    return _emit_init_commands_or_close(lmp, calc)
+
+
+def _emit_init_commands_or_close(lmp, calc):
+    """Run :func:`emit_init_commands`, closing ``lmp`` if it raises.
+
+    The caller only gets hold of the runner once :func:`create_object`
+    returns, so a failure here would otherwise leave the session (in library
+    mode, the executor behind it) open."""
+    try:
+        return emit_init_commands(lmp, calc)
+    except BaseException:
+        lmp.__exit__(*sys.exc_info())
+        raise
 
 
 def emit_init_commands(lmp, calc):

{calphy-2.3.0 → calphy-2.3.1}/calphy/input.py

@@ -58,7 +58,7 @@ from calphy.structures import (
     make_lattice,
 )
 
-__version__ = "2.3.0"
+__version__ = "2.3.1"
 
 
 def _check_equal(val):

{calphy-2.3.0 → calphy-2.3.1}/calphy/library_runner.py

@@ -37,6 +37,7 @@ imported lazily inside :class:`LibraryRunner` -- importing this module (or any
 other part of calphy) never requires it.
 """
 import os
+import sys
 import logging
 
 from calphy.runner import BaseRunner, _normalize_cmdargs
@@ -81,7 +82,13 @@ class LibraryRunner(BaseRunner):
         self.lmp = LammpsLibrary(
             cores=cores, working_directory=directory, cmdargs=cmdargs
         )
-        self._activate_mliap()
+        # the executor is live from here on; nobody else holds a reference to
+        # this runner yet, so close it ourselves if the rest of setup fails
+        try:
+            self._activate_mliap()
+        except BaseException:
+            self.__exit__(*sys.exc_info())
+            raise
 
     def _activate_mliap(self):
         """Register the mliappy coupling in the live session when available.

{calphy-2.3.0 → calphy-2.3.1}/calphy/liquid.py

@@ -162,7 +162,7 @@ class Liquid(cph.Phase):
         At the end of the run, the averaged box dimensions are calculated.
         """
         # create lammps object
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         lmp = ph.set_pair_style(lmp, self.calc)
 
@@ -237,7 +237,7 @@ class Liquid(cph.Phase):
         Run the integration routine where the initial and final systems are connected using
         the lambda parameter. See algorithm 4 in publication.
         """
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         # Adiabatic switching parameters.
         lmp.command("variable        li       equal   1.0")

{calphy-2.3.0 → calphy-2.3.1}/calphy/phase.py

@@ -554,6 +554,11 @@ class Phase:
         aborted with a MeltedError.  Detection can be turned off by setting
         ``tolerance.solid_fraction: 0``.
         """
+        # Disabled (solid_fraction <= 0): the comparison below can never fire, so do not run the
+        # structure analysis at all. It is not free, and pyscal3 can segfault in find.neighbors on
+        # some LAMMPS triclinic dumps, killing a run over a check that could not have stopped it.
+        if self.calc.tolerance.solid_fraction <= 0:
+            return
         solids = ph.find_solid_fraction(os.path.join(self.simfolder, filename))
         if solids / self.natoms < self.calc.tolerance.solid_fraction:
             self.lammps_close(lmp=lmp)
@@ -569,7 +574,11 @@ class Phase:
 
         If the solid fraction in ``filename`` exceeds
         ``tolerance.liquid_fraction`` the run is aborted with a SolidifiedError.
+        Disabled (``liquid_fraction >= 1``), the analysis is skipped, as in
+        ``check_if_melted``.
         """
+        if self.calc.tolerance.liquid_fraction >= 1:
+            return
         solids = ph.find_solid_fraction(os.path.join(self.simfolder, filename))
         if solids / self.natoms > self.calc.tolerance.liquid_fraction:
             self.lammps_close(lmp=lmp)
@@ -1497,7 +1506,7 @@ class Phase:
             iteration, t0, tf, li, lf, pi, pf,
         )
 
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         lmp.command("echo              log")
         lmp.command("variable          li equal %f" % li)
@@ -1705,7 +1714,7 @@ class Phase:
             iteration, tf, t0, lf, li, pf, pi,
         )
 
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         lmp.command("echo              log")
         lmp.command("variable          li equal %f" % li)
@@ -1983,7 +1992,7 @@ class Phase:
         )
 
         # ── Build the LAMMPS object and load the equilibrated configuration ──
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         lmp.command("echo              log")
         lmp = ph.set_pair_style(lmp, self.calc)
@@ -2173,7 +2182,7 @@ class Phase:
         p0 = self.calc._pressure
 
         # create lammps object
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         lmp.command("echo              log")
         lmp.command("variable          li equal %f" % li)
@@ -2323,7 +2332,7 @@ class Phase:
         pf = self.calc._pressure_stop
 
         # create lammps object
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         lmp.command("echo              log")
         lmp.command("variable          li equal %f" % li)
@@ -2482,5 +2491,25 @@ class Phase:
         with open(os.path.join(self.simfolder, "metadata.yaml"), "w") as fout:
             yaml.safe_dump(metadata, fout)
 
+    def _open_lammps(self):
+        """Create a stage's LAMMPS session and remember it, so that a
+        surrounding ``with job:`` can close it if the stage raises."""
+        self._lmp = ph.create_object(self.calc, self.simfolder)
+        return self._lmp
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        """Close the session opened by the last stage, exception or not.
+
+        On success the stage has already closed it itself; closing again is a
+        no-op.  The exception is never suppressed.
+        """
+        lmp, self._lmp = getattr(self, "_lmp", None), None
+        if lmp is not None:
+            lmp.__exit__(exc_type, exc, tb)
+        return False
+
     def lammps_close(self, lmp):
         lmp.close()

{calphy-2.3.0 → calphy-2.3.1}/calphy/routines.py

@@ -271,7 +271,8 @@ class MeltingTemp:
         self.logger.info("Starting solid reversible scaling run")
         for i in range(self.soljob.calc.n_iterations):
             try:
-                self.soljob.reversible_scaling(iteration=(i + 1))
+                with self.soljob:
+                    self.soljob.reversible_scaling(iteration=(i + 1))
             except MeltedError:
                 self.logger.info("Solid system melted during reversible scaling run")
                 return 2
@@ -290,7 +291,8 @@ class MeltingTemp:
         self.logger.info("Starting liquid reversible scaling calculation")
         for i in range(self.lqdjob.calc.n_iterations):
             try:
-                self.lqdjob.reversible_scaling(iteration=(i + 1))
+                with self.lqdjob:
+                    self.lqdjob.reversible_scaling(iteration=(i + 1))
             except SolidifiedError:
                 self.logger.info("Liquid froze during reversible scaling calculation")
                 return 3
@@ -527,14 +529,16 @@ def routine_fe(job):
     Perform an FE calculation routine
     """
     ts = time.time()
-    job.run_averaging()
+    with job:
+        job.run_averaging()
     te = time.time() - ts
     job.logger.info("Averaging routine finished in %f s" % te)
 
     # now run integration loops
     for i in range(job.calc.n_iterations):
         ts = time.time()
-        job.run_integration(iteration=(i + 1))
+        with job:
+            job.run_integration(iteration=(i + 1))
         te = time.time() - ts
         job.logger.info("Integration cycle %d finished in %f s" % (i + 1, te))
 
@@ -556,14 +560,16 @@ def routine_ts(job):
     # in the single-phase region.  Disabled by default (mode='none').
     if job.calc.phase_transition_detection.mode != "none":
         ts = time.time()
-        job.scan_temperature_range()
+        with job:
+            job.scan_temperature_range()
         te = time.time() - ts
         job.logger.info("Pre-flight temperature-range scan finished in %f s" % te)
 
     # now do rev scale steps
     for i in range(job.calc.n_iterations):
         ts = time.time()
-        job.reversible_scaling(iteration=(i + 1))
+        with job:
+            job.reversible_scaling(iteration=(i + 1))
         te = time.time() - ts
         job.logger.info("TS integration cycle %d finished in %f s" % (i + 1, te))
 
@@ -581,7 +587,8 @@ def routine_tscale(job):
     # now do rev scale steps
     for i in range(job.calc.n_iterations):
         ts = time.time()
-        job.temperature_scaling(iteration=(i + 1))
+        with job:
+            job.temperature_scaling(iteration=(i + 1))
         te = time.time() - ts
         job.logger.info("Temperature scaling cycle %d finished in %f s" % (i + 1, te))
 
@@ -599,7 +606,8 @@ def routine_pscale(job):
     # now do rev scale steps
     for i in range(job.calc.n_iterations):
         ts = time.time()
-        job.pressure_scaling(iteration=(i + 1))
+        with job:
+            job.pressure_scaling(iteration=(i + 1))
         te = time.time() - ts
         job.logger.info("Pressure scaling cycle %d finished in %f s" % (i + 1, te))
 
@@ -613,14 +621,16 @@ def routine_alchemy(job):
     Perform an FE calculation routine
     """
     ts = time.time()
-    job.run_averaging()
+    with job:
+        job.run_averaging()
     te = time.time() - ts
     job.logger.info("Averaging routine finished in %f s" % te)
 
     # now run integration loops
     for i in range(job.calc.n_iterations):
         ts = time.time()
-        job.run_integration(iteration=(i + 1))
+        with job:
+            job.run_integration(iteration=(i + 1))
         te = time.time() - ts
         job.logger.info("Alchemy integration cycle %d finished in %f s" % (i + 1, te))
 
@@ -742,14 +752,16 @@ def routine_composition_scaling(job):
 
     # now start cycle
     ts = time.time()
-    job.run_averaging()
+    with job:
+        job.run_averaging()
     te = time.time() - ts
     job.logger.info("Averaging routine finished in %f s" % te)
 
     # now run integration loops
     for i in range(job.calc.n_iterations):
         ts = time.time()
-        job.run_integration(iteration=(i + 1))
+        with job:
+            job.run_integration(iteration=(i + 1))
         te = time.time() - ts
         job.logger.info("Alchemy integration cycle %d finished in %f s" % (i + 1, te))
 

{calphy-2.3.0 → calphy-2.3.1}/calphy/runner.py

@@ -366,6 +366,34 @@ class BaseRunner:
         """End the session and release backend resources."""
         raise NotImplementedError
 
+    def __enter__(self):
+        """Enter a runner scope; the runner itself is the ``as`` target."""
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        """Close the session on the way out, exception or not.
+
+        This is what makes a stage's LAMMPS session -- and, in library mode,
+        the executorlib executor behind it -- go away deterministically even
+        when an exception escapes the driver.  The driver's exception is never
+        suppressed.
+
+        If :meth:`close` itself fails *while an exception is propagating*, the
+        close error is logged and swallowed rather than replacing the original
+        one: the interesting failure is the physics error that got us here, not
+        the fallout of shutting a half-dead session down.
+        """
+        try:
+            self.close()
+        except Exception:
+            if exc_type is None:
+                raise
+            logger.exception(
+                "closing the LAMMPS session failed while handling %s; the "
+                "original exception is propagating", exc_type.__name__,
+            )
+        return False
+
     def rotate_logs(self, stage_name):
         """Collect the LAMMPS log output produced since the last rotation into
         ``<stage_name>.log.lammps`` in the sim folder."""

{calphy-2.3.0 → calphy-2.3.1}/calphy/solid.py

@@ -91,20 +91,32 @@ class Solid(cph.Phase):
         lmp = ph.compute_msd(lmp, self.calc)
 
         if ph.check_if_any_is_none(self.calc.spring_constants):
-            # similar averaging routine
-            laststd = 0.00
+            # k only has to be close: the Frenkel-Ladd free energy does not depend
+            # on its exact value. Stop once k changes by less than
+            # tolerance.spring_constant (relative) between cycles, and fall back
+            # to the last estimate rather than iterating without end.
+            k_last = np.zeros(self.calc.n_elements)
             for i in range(self.calc.md.n_cycles):
                 lmp.command("run              %d" % int(self.calc.md.n_small_steps))
                 lmp.sync()  # flush before analyse_spring_constants reads msd.dat
                 k_mean, k_std = self.analyse_spring_constants(lmp)
                 self.logger.info(
-                    "At count %d mean k is %f std is %f" % (i + 1, k_mean[0], k_std[0])
+                    "At count %d mean k is %s" % (i + 1, " ".join("%f" % k for k in k_mean))
                 )
-                if np.abs(laststd - k_std[0]) < self.calc.tolerance.spring_constant:
-                    # now reevaluate spring constants
-                    self.assign_spring_constants(k_mean)
+                k_now = np.array(k_mean)
+                # nan for elements without a usable MSD; those are left out here
+                change = np.abs(k_now - k_last) / k_now
+                k_last = k_now
+                finite = np.isfinite(change)
+                if not np.any(finite) or np.max(change[finite]) < self.calc.tolerance.spring_constant:
                     break
-                laststd = k_std[0]
+            else:
+                self.logger.warning(
+                    "Spring constants not converged to a relative change of %f "
+                    "after %d cycles; using the last estimate"
+                    % (self.calc.tolerance.spring_constant, self.calc.md.n_cycles)
+                )
+            self.assign_spring_constants(k_mean)
 
         else:
             if not (len(self.calc.spring_constants) == self.calc.n_elements):
@@ -137,17 +149,21 @@ class Solid(cph.Phase):
         k_std = []
         for i in range(self.calc.n_elements):
             quant = msd[:, i + 1][-ncount + 1 :]
-            mean_quant = np.round(np.mean(quant), decimals=2)
-            std_quant = np.round(np.std(quant), decimals=2)
-            if mean_quant == 0:
+            mean_quant = np.mean(quant)
+            std_quant = np.std(quant)
+            if not (np.isfinite(mean_quant) and mean_quant > 0):
+                # e.g. an element with no atoms. nan is replaced by another
+                # element's k in validate_spring_constants, which raises if no
+                # element has a usable value. Never substitute a fixed MSD: it
+                # gives a k that is wrong by orders of magnitude at low T.
                 self.logger.warning(
-                    "MSD for element index %d averaged to ~0; spring-constant "
-                    "estimation is unreliable. Consider increasing equilibration "
-                    "time or providing spring_constants explicitly." % i
+                    "MSD for element index %d is %s; cannot estimate its spring "
+                    "constant. Provide spring_constants explicitly if this "
+                    "element has atoms." % (i, mean_quant)
                 )
-                mean_quant = 1.00
-            mean_quant = 3 * kb * self.calc._temperature / mean_quant
-            k_mean.append(mean_quant)
+                k_mean.append(np.nan)
+            else:
+                k_mean.append(3 * kb * self.calc._temperature / mean_quant)
             k_std.append(std_quant)
         return k_mean, k_std
 
@@ -192,7 +208,7 @@ class Solid(cph.Phase):
         At the end of the run, the averaged box dimensions are calculated.
         """
 
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         # set up potential
         lmp = ph.set_pair_style(lmp, self.calc)
@@ -268,7 +284,7 @@ class Solid(cph.Phase):
         Run the integration routine where the initial and final systems are connected using
         the lambda parameter. See algorithm 4 in publication.
         """
-        lmp = ph.create_object(self.calc, self.simfolder)
+        lmp = self._open_lammps()
 
         # set up potential
         lmp = ph.set_pair_style(lmp, self.calc)

{calphy-2.3.0 → calphy-2.3.1}/calphy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calphy
-Version: 2.3.0
+Version: 2.3.1
 Summary: free energy calculation for python
 Author: Yury Lysogorskiy, Ralf Drautz
 Author-email: Sarath Menon <sarath.menon@ruhr-uni-bochum.de>

{calphy-2.3.0 → calphy-2.3.1}/calphy.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ tests/test_dcci_input.py
 tests/test_dcci_integrator.py
 tests/test_dcci_lammps_e2e.py
 tests/test_dcci_lammps_semantics.py
+tests/test_disabled_phase_checks.py
 tests/test_dissipation_check.py
 tests/test_element_ordering.py
 tests/test_ex07.py
@@ -66,5 +67,6 @@ tests/test_runner.py
 tests/test_scheduler.py
 tests/test_seed.py
 tests/test_solid_methods.py
+tests/test_spring_constants.py
 tests/test_structures.py
 tests/test_sweep_barostat_targets.py

{calphy-2.3.0 → calphy-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "calphy"
-version = "2.3.0"
+version = "2.3.1"
 description = "free energy calculation for python"
 readme = "README.md"
 license = "LicenseRef-ASL-1.0"

calphy-2.3.1/tests/test_disabled_phase_checks.py

@@ -0,0 +1,46 @@
+"""A disabled phase-stability check must not run the structure analysis.
+
+`tolerance.solid_fraction: 0` (or `liquid_fraction: 1`) makes the comparison in
+check_if_melted / check_if_solidfied impossible to trigger, but the solid fraction
+was still computed with pyscal3 -- which segfaults in find.neighbors on some LAMMPS
+triclinic dumps (Mg2Si antifluorite, 60-degree primitive cell), killing the run.
+"""
+from types import SimpleNamespace
+
+import pytest
+
+import calphy.phase as phase_mod
+from calphy.phase import Phase
+
+
+def _fake(solid_fraction=0.0, liquid_fraction=1.0):
+    tol = SimpleNamespace(solid_fraction=solid_fraction, liquid_fraction=liquid_fraction)
+    return SimpleNamespace(calc=SimpleNamespace(tolerance=tol), simfolder="/nonexistent", natoms=10)
+
+
+def _explode(_):
+    raise AssertionError("find_solid_fraction must not be called when the check is disabled")
+
+
+def test_disabled_melt_check_skips_structure_analysis(monkeypatch):
+    monkeypatch.setattr(phase_mod.ph, "find_solid_fraction", _explode)
+    Phase.check_if_melted(_fake(solid_fraction=0.0), lmp=None, filename="traj.temp.dat")
+
+
+def test_disabled_solidification_check_skips_structure_analysis(monkeypatch):
+    monkeypatch.setattr(phase_mod.ph, "find_solid_fraction", _explode)
+    Phase.check_if_solidfied(_fake(liquid_fraction=1.0), lmp=None, filename="traj.temp.dat")
+
+
+def test_enabled_melt_check_still_runs(monkeypatch):
+    called = []
+    monkeypatch.setattr(phase_mod.ph, "find_solid_fraction", lambda f: called.append(f) or 10)
+    Phase.check_if_melted(_fake(solid_fraction=0.7), lmp=None, filename="traj.temp.dat")
+    assert called == ["/nonexistent/traj.temp.dat"]
+
+
+def test_enabled_solidification_check_still_runs(monkeypatch):
+    called = []
+    monkeypatch.setattr(phase_mod.ph, "find_solid_fraction", lambda f: called.append(f) or 0)
+    Phase.check_if_solidfied(_fake(liquid_fraction=0.05), lmp=None, filename="traj.temp.dat")
+    assert called == ["/nonexistent/traj.temp.dat"]

{calphy-2.3.0 → calphy-2.3.1}/tests/test_integration_lammps.py

@@ -296,11 +296,11 @@ def _check_free_energy(scenario, rundir):
         "%s free energy delta %.2e eV/atom exceeds tol %.2e "
         "(new=%.6f base=%.6f)" % (scenario, delta, tol, fe_new, fe_base)
     )
-    # Spring constant is informational only: calphy rounds the mean MSD to 2
-    # decimals and does not pin the RNG seed, so k = 3 kB T / MSD is bistable
-    # run-to-run (e.g. B1 flips between ~1.85 and ~2.15) in the OLD code too.
-    # The free energy is insensitive to the exact k (Frenkel-Ladd), so we assert
-    # on fe only and just report the spring delta.
+    # Spring constant is informational only: the baselines were made when calphy
+    # rounded the mean MSD to 2 decimals, which made k = 3 kB T / MSD bistable
+    # run-to-run (e.g. B1 flipped between ~1.85 and ~2.15), and the RNG seed is
+    # not pinned. The free energy is insensitive to the exact k (Frenkel-Ladd),
+    # so we assert on fe only and just report the spring delta.
     k_new = new.get("average", {}).get("spring_constant")
     k_base = base.get("average", {}).get("spring_constant")
     kinfo = ""

{calphy-2.3.0 → calphy-2.3.1}/tests/test_library_runner.py

@@ -254,6 +254,47 @@ def test_create_object_library_mode(tmp_path, fake_pylammpsmpi, make_calc):
     assert len(lmp.logical_commands) == 4
 
 
+@pytest.fixture
+def recorded_libraries(fake_pylammpsmpi, monkeypatch):
+    """Every FakeLammpsLibrary created, so a test can check it got closed."""
+    created = []
+
+    class Recording(FakeLammpsLibrary):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            created.append(self)
+
+    monkeypatch.setattr(fake_pylammpsmpi, "LammpsLibrary", Recording)
+    return created
+
+
+def test_failed_mliap_activation_closes_the_session(
+    tmp_path, recorded_libraries, fake_lammps_mliap, monkeypatch
+):
+    def boom(self):
+        raise RuntimeError("activation failed")
+
+    monkeypatch.setattr(_FakeConcurrent, "activate_mliappy", boom)
+    with pytest.raises(RuntimeError, match="activation failed"):
+        make_runner(tmp_path)
+    assert [lib.closed for lib in recorded_libraries] == [True]
+
+
+def test_create_object_closes_the_session_if_init_commands_fail(
+    tmp_path, recorded_libraries, make_calc, monkeypatch
+):
+    import calphy.helpers as ph
+
+    def boom(lmp, calc):
+        raise ValueError("bad init command")
+
+    monkeypatch.setattr(ph, "emit_init_commands", boom)
+    calc = make_calc("B1", execution_mode="library")
+    with pytest.raises(ValueError, match="bad init command"):
+        ph.create_object(calc, str(tmp_path))
+    assert [lib.closed for lib in recorded_libraries] == [True]
+
+
 def test_execution_mode_validation(make_calc):
     with pytest.raises(Exception, match="execution_mode"):
         make_calc("B1", execution_mode="banana")

{calphy-2.3.0 → calphy-2.3.1}/tests/test_runner.py

@@ -633,3 +633,76 @@ def test_imports_without_pylammpsmpi():
                           text=True, cwd=REPO_ROOT)
     assert proc.returncode == 0, proc.stdout + proc.stderr
     assert "OK" in proc.stdout
+
+
+# --------------------------------------------------------------------------- #
+# BaseRunner as a context manager
+# --------------------------------------------------------------------------- #
+class _RecordingRunner(R.BaseRunner):
+    """Minimal BaseRunner subclass that records close() calls."""
+
+    def __init__(self, directory=".", close_error=None):
+        super().__init__(directory)
+        self.closes = 0
+        self.close_error = close_error
+
+    def close(self):
+        self.closes += 1
+        if self.close_error is not None:
+            raise self.close_error
+
+
+def test_context_manager_yields_the_runner_and_closes():
+    runner = _RecordingRunner()
+    with runner as lmp:
+        assert lmp is runner
+        assert runner.closes == 0
+    assert runner.closes == 1
+
+
+def test_context_manager_closes_on_exception_and_does_not_suppress():
+    runner = _RecordingRunner()
+    with pytest.raises(ValueError, match="physics"):
+        with runner:
+            raise ValueError("physics went wrong")
+    assert runner.closes == 1
+
+
+def test_close_failure_propagates_when_no_exception_is_in_flight():
+    runner = _RecordingRunner(close_error=RuntimeError("close failed"))
+    with pytest.raises(RuntimeError, match="close failed"):
+        with runner:
+            pass
+
+
+def test_close_failure_does_not_mask_the_original_exception():
+    """A dead LAMMPS worker can make close() fail; the physics error must win."""
+    runner = _RecordingRunner(close_error=RuntimeError("worker already dead"))
+    with pytest.raises(ValueError, match="physics"):
+        with runner:
+            raise ValueError("physics went wrong")
+    assert runner.closes == 1
+
+
+def test_phase_context_closes_the_session_of_a_failed_stage(monkeypatch):
+    """``with job: job.stage()`` closes the session the stage opened if it raises."""
+    import calphy.phase as cph
+
+    runner = _RecordingRunner()
+    monkeypatch.setattr(cph.ph, "create_object", lambda calc, simfolder: runner)
+    job = cph.Phase.__new__(cph.Phase)
+    job.calc, job.simfolder = None, "."
+
+    def stage():
+        job._open_lammps()
+        raise ValueError("physics went wrong")
+
+    with pytest.raises(ValueError, match="physics"):
+        with job:
+            stage()
+    assert runner.closes == 1
+
+    # a context with no stage in it is a no-op
+    with job:
+        pass
+    assert runner.closes == 1

calphy-2.3.1/tests/test_spring_constants.py

@@ -0,0 +1,131 @@
+"""Spring-constant estimate from the MSD in Solid.
+
+A small MSD (low T, heavy or stiff elements) used to be rounded to 0 Ų and
+replaced by 1 Ų, giving a k that was orders of magnitude too soft. These tests
+feed a synthetic msd.dat through the estimate and the convergence loop.
+"""
+import logging
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from calphy.integrators import kb
+from calphy.solid import Solid
+
+
+class FakeLmp:
+    """Serves msd.dat as `rows` more samples per run command."""
+
+    def __init__(self, columns, rows):
+        self.columns = [np.asarray(c, dtype=float) for c in columns]
+        self.rows = rows
+        self.nruns = 0
+
+    def command(self, cmd):
+        if cmd.startswith("run"):
+            self.nruns += 1
+
+    def sync(self):
+        pass
+
+    def read_timeseries(self, name):
+        assert name == "msd.dat"
+        n = self.nruns * self.rows
+        steps = np.arange(n, dtype=float)
+        return np.column_stack([steps] + [c[:n] for c in self.columns])
+
+
+def make_solid(elements, temperature, spring_constants=None, n_cycles=20,
+               tolerance=0.1):
+    job = Solid.__new__(Solid)
+    job.logger = logging.getLogger("test_spring_constants")
+    job.calc = SimpleNamespace(
+        element=elements,
+        n_elements=len(elements),
+        _temperature=temperature,
+        _qtb=False,
+        spring_constants=spring_constants,
+        n_equilibration_steps=25000,
+        md=SimpleNamespace(
+            n_every_steps=10,
+            n_repeat_steps=10,
+            n_small_steps=10000,
+            n_cycles=n_cycles,
+            thermostat_damping=[0.1, 0.1],
+        ),
+        tolerance=SimpleNamespace(spring_constant=tolerance),
+    )
+    return job
+
+
+def noisy_msd(mean, n, rel_noise=0.05, seed=0):
+    rng = np.random.default_rng(seed)
+    return mean * (1 + rel_noise * rng.standard_normal(n))
+
+
+def test_small_msd_gives_stiff_spring():
+    # bcc W at 100 K: MSD ~0.004 Ų must give k = 3kT/0.004 ~ 6.46, not 3kT/1
+    job = make_solid(["W"], 100.0)
+    lmp = FakeLmp([np.full(300, 0.004)], rows=100)
+    lmp.nruns = 3
+    k_mean, _ = job.analyse_spring_constants(lmp)
+    assert k_mean[0] == pytest.approx(3 * kb * 100.0 / 0.004)
+    assert k_mean[0] == pytest.approx(6.46, abs=0.01)
+
+
+def test_msd_is_not_rounded():
+    # 0.0149 and 0.0051 both rounded to 0.01 before
+    job = make_solid(["A", "B"], 300.0)
+    lmp = FakeLmp([np.full(300, 0.0149), np.full(300, 0.0051)], rows=100)
+    lmp.nruns = 3
+    k_mean, _ = job.analyse_spring_constants(lmp)
+    assert k_mean[0] == pytest.approx(3 * kb * 300.0 / 0.0149)
+    assert k_mean[1] == pytest.approx(3 * kb * 300.0 / 0.0051)
+
+
+def test_zero_msd_single_element_raises():
+    job = make_solid(["W"], 100.0)
+    lmp = FakeLmp([np.zeros(300)], rows=100)
+    with pytest.raises(ValueError):
+        job.run_spring_constant_convergence(lmp)
+    # no usable estimate at all: stop on the first cycle instead of looping
+    assert lmp.nruns == 1
+
+
+def test_zero_msd_empty_element_takes_other_k():
+    # an element with no atoms has MSD 0; it gets the other element's k
+    job = make_solid(["Cu", "Zr"], 100.0)
+    lmp = FakeLmp([noisy_msd(0.004, 2000), np.zeros(2000)], rows=100)
+    job.run_spring_constant_convergence(lmp)
+    assert np.isfinite(job.k).all()
+    assert job.k[0] == pytest.approx(6.46, rel=0.05)
+    assert job.k[1] == job.k[0]
+
+
+def test_user_spring_constant_overrides_estimate():
+    job = make_solid(["Cu", "Zr"], 100.0, spring_constants=[None, 2.0])
+    lmp = FakeLmp([noisy_msd(0.004, 2000), np.zeros(2000)], rows=100)
+    job.run_spring_constant_convergence(lmp)
+    assert job.k[0] == pytest.approx(6.46, rel=0.05)
+    assert job.k[1] == 2.0
+
+
+def test_convergence_stops_after_two_cycles():
+    # a stationary MSD converges as soon as two estimates can be compared
+    job = make_solid(["W"], 100.0)
+    lmp = FakeLmp([noisy_msd(0.004, 2000)], rows=100)
+    job.run_spring_constant_convergence(lmp)
+    assert lmp.nruns == 2
+    assert job.k[0] == pytest.approx(6.46, rel=0.05)
+
+
+def test_convergence_is_bounded_by_n_cycles():
+    # an MSD that keeps drifting never meets the tolerance: use the last
+    # estimate after n_cycles instead of iterating further or failing
+    job = make_solid(["W"], 100.0, n_cycles=5)
+    drifting = np.repeat(0.004 * 1.5 ** np.arange(5), 100)
+    lmp = FakeLmp([drifting], rows=100)
+    job.run_spring_constant_convergence(lmp)
+    assert lmp.nruns == 5
+    assert np.isfinite(job.k[0])