ipi 3.3.0__tar.gz → 3.3.1__tar.gz

{ipi-3.3.0 → ipi-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ipi
-Version: 3.3.0
+Version: 3.3.1
 Summary: A Python interface for ab initio path integral molecular dynamics simulations
 Home-page: http://ipi-code.org
 Author: The i-PI developers

{ipi-3.3.0 → ipi-3.3.1}/bin/i-pi

@@ -60,6 +60,10 @@ def main(fn_input, options):
     # construct simulation based on input file
     simulation = Simulation.load_from_xml(open(fn_input), request_banner=True, custom_verbosity=options.verbosity, sockets_prefix=options.sockets_prefix)
 
+    # when running as a standalone program, ends the process as soon as the
+    # soft exit cleanup is complete (see Softexit.kill)
+    softexit.hard_exit = True
+
     # run the simulation
     simulation.run()
 

ipi-3.3.1/ipi/_version.py

@@ -0,0 +1 @@
+__version__ = "3.3.1"

{ipi-3.3.0 → ipi-3.3.1}/ipi/engine/barostats.py

@@ -25,10 +25,11 @@ from ipi.utils.mathtools import (
     sinch,
     mat_taylor,
 )
+from ipi.utils.messages import warning, verbosity
 from ipi.engine.thermostats import Thermostat
 from ipi.engine.cell import Cell
 
-__all__ = ["Barostat", "BaroBZP", "BaroRGB", "BaroSCBZP", "BaroMTK"]
+__all__ = ["Barostat", "BaroSCR", "BaroBZP", "BaroRGB", "BaroSCBZP", "BaroMTK"]
 
 
 def mask_from_fix(fix):
@@ -426,6 +427,231 @@ dproperties(
 )
 
 
+class BaroSCR(Barostat):
+    """Bernetti--Bussi stochastic cell-rescaling barostat.
+
+    Mode ``stochastic-rescaling`` implements the reversible, isotropic
+    Trotter scheme with instantaneous kinetic pressure described in
+    Bernetti and Bussi, J. Chem. Phys. 153, 114107 (2020)
+    [doi:10.1063/5.0020514]. Positions and cell vectors are scaled by the
+    same factor, while momenta are scaled by its inverse.
+
+    This implementation is restricted to classical dynamics. The particle
+    thermostat remains responsible for temperature control; stochastic cell
+    rescaling does not have a separate piston or cell thermostat.
+    """
+
+    def __init__(
+        self,
+        dt=None,
+        temp=None,
+        tau=None,
+        ebaro=None,
+        thermostat=None,
+        pext=None,
+        compressibility=None,
+    ):
+        """Initializes the stochastic cell-rescaling barostat.
+
+        Args:
+            dt: Optional simulation time step.
+            temp: Optional simulation temperature.
+            tau: Pressure relaxation time.
+            ebaro: Accumulated effective-energy correction, used on restart.
+            thermostat: Must be the dummy thermostat. Kept for input
+                compatibility with other barostats.
+            pext: Optional external pressure.
+            compressibility: Estimate of the isothermal compressibility.
+        """
+
+        super(BaroSCR, self).__init__(dt, temp, tau, ebaro, thermostat)
+
+        self._compressibility = depend_value(
+            name="compressibility",
+            value=-1.0 if compressibility is None else compressibility,
+        )
+        self.prng = None
+        self._scr_state = None
+
+        if pext is not None:
+            self.pext = pext
+
+    def bind(self, beads, nm, cell, forces, bias=None, prng=None, fixdof=None, nmts=1):
+        """Binds the physical system and random-number generator."""
+
+        super(BaroSCR, self).bind(beads, nm, cell, forces, bias, prng, fixdof, nmts)
+
+        if self.tau <= 0.0:
+            raise ValueError(
+                "The stochastic cell-rescaling relaxation time must be positive."
+            )
+        if self.compressibility <= 0.0:
+            raise ValueError(
+                "The stochastic cell-rescaling compressibility must be positive."
+            )
+        if self.beads.nbeads != 1:
+            raise ValueError(
+                "Stochastic cell rescaling currently supports classical "
+                "dynamics only (nbeads=1)."
+            )
+        if type(self.thermostat) is not Thermostat:
+            raise ValueError(
+                "Stochastic cell rescaling does not use a separate cell thermostat."
+            )
+        if prng is None:
+            raise ValueError(
+                "Stochastic cell rescaling requires the simulation random-number "
+                "generator."
+            )
+
+        self.prng = prng
+        self._pot = depend_value(
+            name="pot", func=self.get_pot, dependencies=[cell._V, self._pext]
+        )
+        self._cell_jacobian = depend_value(
+            name="cell_jacobian",
+            func=self.get_cell_jacobian,
+            dependencies=[cell._V, self._temp],
+        )
+
+    def get_pot(self):
+        """Returns the external-pressure contribution to the enthalpy."""
+
+        return self.pext * self.cell.V
+
+    def get_cell_jacobian(self):
+        """Returns the Jacobian contribution for lambda = sqrt(volume)."""
+
+        return -0.5 * Constants.kb * self.temp * np.log(self.cell.V)
+
+    def get_lambda_force(self):
+        """Returns the drift force acting on lambda = sqrt(volume)."""
+
+        volume = self.cell.V
+        if not np.isfinite(volume) or volume <= 0.0:
+            raise ValueError(
+                "Stochastic cell rescaling encountered a non-positive or "
+                "non-finite volume."
+            )
+        pressure = (
+            sum(np.trace(self.stress_mts(level)) for level in range(self.nmtslevels))
+            / 3.0
+        )
+        if not np.isfinite(pressure):
+            raise ValueError(
+                "Stochastic cell rescaling encountered a non-finite internal "
+                "pressure."
+            )
+
+        lam = np.sqrt(volume)
+        return (
+            -2.0
+            * lam
+            * (self.pext - pressure - Constants.kb * self.temp / (2.0 * volume))
+        )
+
+    def prepare(self):
+        """Draws a cell move and returns its isotropic length scale."""
+
+        lambda_force = self.get_lambda_force()
+        volume = self.cell.V
+        lam = np.sqrt(volume)
+        coupling_dt = 2.0 * self.qdt
+        kbt = Constants.kb * self.temp
+        diffusion = kbt * self.compressibility / (4.0 * self.tau)
+        delta_lambda = (
+            diffusion * lambda_force * coupling_dt / kbt
+            + np.sqrt(2.0 * diffusion * coupling_dt) * self.prng.g
+        )
+        new_lambda = lam + delta_lambda
+
+        if not np.isfinite(new_lambda) or new_lambda <= 0.0:
+            raise ValueError(
+                "Stochastic cell rescaling proposed a non-positive or non-finite "
+                "sqrt(volume). Increase tau, reduce stride or the MD time step, "
+                "and check the compressibility."
+            )
+
+        delta_log_lambda = np.log1p(delta_lambda / lam)
+        scale = np.exp((2.0 / 3.0) * delta_log_lambda)
+        if scale < 0.99 or scale > 1.01:
+            warning(
+                "Stochastic cell rescaling changed a cell length by more than "
+                "1%. Consider increasing tau or reducing stride.",
+                verbosity.low,
+            )
+
+        self._scr_state = {
+            "volume": volume,
+            "lambda": lam,
+            "lambda_force": lambda_force,
+            "delta_lambda": delta_lambda,
+            "delta_log_lambda": delta_log_lambda,
+            "diffusion": diffusion,
+            "coupling_dt": coupling_dt,
+        }
+        return scale
+
+    def qcstep(self):
+        """Propagates one half of the reversible cell-rescaling map.
+
+        The standard NPT integrator calls this method twice around the free
+        ring-polymer propagation. The first call draws the stochastic cell
+        move and applies drift--rescale; the second applies rescale--drift and
+        closes the effective-energy bookkeeping.
+        """
+
+        masses = dstrip(self.nm.dynm3)[0]
+
+        if self._scr_state is None:
+            scale = self.prepare()
+            half_scale = np.sqrt(scale)
+            self._scr_state["half_scale"] = half_scale
+
+            self.nm.qnm[0, :] += dstrip(self.nm.pnm)[0] * self.qdt / masses
+            self.nm.qnm[0, :] *= half_scale
+            self.nm.pnm[0, :] *= 1.0 / half_scale
+            self.cell.h *= half_scale
+        else:
+            half_scale = self._scr_state["half_scale"]
+
+            self.nm.qnm[0, :] *= half_scale
+            self.nm.pnm[0, :] *= 1.0 / half_scale
+            self.cell.h *= half_scale
+            self.nm.qnm[0, :] += dstrip(self.nm.pnm)[0] * self.qdt / masses
+            self.finalize()
+
+    def finalize(self):
+        """Accumulates the reversible effective-energy correction."""
+
+        if self._scr_state is None:
+            raise RuntimeError(
+                "Stochastic cell-rescaling finalize called without a pending move."
+            )
+
+        state = self._scr_state
+        new_volume = self.cell.V
+        new_lambda_force = self.get_lambda_force()
+        kbt = Constants.kb * self.temp
+
+        correction = self.pext * (new_volume - state["volume"])
+        correction -= kbt * state["delta_log_lambda"]
+        correction += (
+            0.5 * state["delta_lambda"] * (state["lambda_force"] + new_lambda_force)
+        )
+        correction += (
+            state["diffusion"]
+            * state["coupling_dt"]
+            / (4.0 * kbt)
+            * (new_lambda_force**2 - state["lambda_force"] ** 2)
+        )
+        self.ebaro += correction
+        self._scr_state = None
+
+
+dproperties(BaroSCR, ["compressibility"])
+
+
 class BaroBZP(Barostat):
     """Bussi-Zykova-Parrinello barostat class.
 

{ipi-3.3.0 → ipi-3.3.1}/ipi/engine/forcefields.py

@@ -380,7 +380,7 @@ class FFSocket(ForceField):
         """Closes the socket and the thread."""
 
         super(FFSocket, self).stop()
-        if self._thread is not None:
+        if self._thread not in (None, threading.current_thread()):
             # must wait until loop has ended before closing the socket
             self._thread.join()
         self.socket.close()
@@ -481,7 +481,7 @@ class FFMPI(ForceField):
         """Stops the poll thread and tells every driver root to exit."""
 
         super().stop()
-        if self._thread is not None:
+        if self._thread not in (None, threading.current_thread()):
             # must wait until the poll loop has ended before signalling exit
             self._thread.join()
         self.interface.close()
@@ -1180,6 +1180,7 @@ class FFYaff(FFEval):
         logf = open(yafflog, "w")
         # Tell Python to close the file when the script exits
         atexit.register(logf.close)
+        softexit.register_function(logf.close)  # also with a hard exit
 
         # Redirect Yaff log to file
         log._file = codecs.getwriter(locale.getpreferredencoding())(logf)

{ipi-3.3.0 → ipi-3.3.1}/ipi/engine/initializer.py

@@ -146,30 +146,21 @@ def init_chk(filename):
        filename: A string giving the name of the checkpoint file to be read from.
 
     Returns:
-       A Beads object, Cell object and Thermostat object as read from the
+       A Beads object, Cell object and Motion object as read from the
        checkpoint file.
     """
 
-    # reads configuration from a checkpoint file
-    rfile = open(filename, "r")
-    xmlchk = xml_parse_file(rfile)  # Parses the file.
+    # Parse only the state required by the initializer.  A full checkpoint
+    # restart still uses InputSimulation.fetch(), which intentionally restores
+    # its force fields as well.
+    with open(filename, "r") as rfile:
+        xmlchk = xml_parse_file(rfile)
 
     from ipi.inputs.simulation import InputSimulation
 
     simchk = InputSimulation()
     simchk.parse(xmlchk.fields[0][1])
-    sim = simchk.fetch()
-    if len(sim.syslist) > 1:
-        warning(
-            "Restart from checkpoint with "
-            + str(len(sim.syslist))
-            + " systems will fetch data from the first system."
-        )
-    rcell = sim.syslist[0].cell
-    rbeads = sim.syslist[0].beads
-    rmotion = sim.syslist[0].motion
-
-    return (rbeads, rcell, rmotion)
+    return simchk.fetch_checkpoint_state()
 
 
 def init_beads(

{ipi-3.3.0 → ipi-3.3.1}/ipi/engine/motion/dynamics.py

@@ -341,6 +341,10 @@ class DummyIntegrator:
         dpipe(self._tdt, self.thermostat._dt)
 
         if motion.enstype == "sc" or motion.enstype == "scnpt":
+            if self.nm.mode == "eco":
+                raise ValueError(
+                    "Suzuki-Chin propagation assumes Trotter springs and cannot be used with mode='eco'."
+                )
             # coefficients to get the (baseline) trotter to sc conversion
             self.coeffsc = np.ones((self.beads.nbeads, 3 * self.beads.natoms), float)
             self.coeffsc[::2] /= -3.0

{ipi-3.3.0 → ipi-3.3.1}/ipi/engine/motion/instanton.py

@@ -233,6 +233,11 @@ class InstantonMotion(Motion):
         prng: The random number generator object which controls random number generation.
         """
 
+        if nm.mode == "eco":
+            raise ValueError(
+                "Instanton calculations assume Trotter springs and cannot be used with mode='eco'."
+            )
+
         super(InstantonMotion, self).bind(ens, beads, nm, cell, bforce, prng, omaker)
 
         # Redefine normal modes

{ipi-3.3.0 → ipi-3.3.1}/ipi/engine/motion/planetary.py

@@ -114,6 +114,11 @@ class Planetary(Motion):
         self.basebeads = beads
         self.basenm = nm
 
+        if nm.mode == "eco":
+            raise ValueError(
+                "The planetary model assumes Trotter springs and cannot be used with mode='eco'."
+            )
+
         # copies of all of the helper classes that are needed to bind the ccdyn object
         self.dbeads = beads.clone(nbeads=self.nbeads)
         self.dcell = cell.clone()

{ipi-3.3.0 → ipi-3.3.1}/ipi/engine/normalmodes.py

@@ -56,7 +56,8 @@ class NormalModes:
           between the replicas. Depends on the simulation temperature.
        omegan2: omegan**2.
        omegak: The normal mode frequencies for the free ring polymer.
-          Depends on omegan.
+          Trotter values, or economised ("eco") values fitted to reproduce
+          harmonic radii of gyration. Depends on omegan, mode and nm_freqs.
        prop_pq: An array holding the exact normal mode propagator for the
           free ring polymer, using mass scaled coordinates.
           See J. Chem. Phys. 133, 124101 (2010). Depends on the bead masses
@@ -171,6 +172,15 @@ class NormalModes:
 
         self.bosons = self.resolve_bosons()
 
+        # eco springs are only defined for closed, distinguishable paths
+        if self.mode == "eco":
+            if len(self.bosons) > 0 or len(self.open_paths) > 0:
+                raise ValueError("ECO mode cannot be used with bosons or open paths.")
+            if len(self.nm_freqs) != 1:
+                raise ValueError(
+                    "ECO mode requires one frequency, the maximum physical frequency to be reproduced."
+                )
+
         # stores a reference to the bound beads and ensemble objects
         self.ensemble = ensemble
         dpipe(motion._dt, self._dt)
@@ -263,7 +273,7 @@ class NormalModes:
             name="omegak",
             value=np.zeros(self.beads.nbeads, float),
             func=self.get_omegak,
-            dependencies=[self._omegan],
+            dependencies=[self._omegan, self._nm_freqs, self._mode],
         )
         self._omegak2 = depend_array(
             name="omegak2",
@@ -454,8 +464,28 @@ class NormalModes:
         Returns:
            A list of the normal mode frequencies for the free ring polymer.
            The first element is the centroid frequency (0.0).
+           For mode="eco", returns economised frequencies optimized to
+           reproduce the radii of gyration of harmonic oscillators with
+           frequencies up to nm_freqs[0].
         """
 
+        if self.mode == "eco":
+            if len(self.nm_freqs) != 1:
+                raise ValueError(
+                    "ECO mode requires one frequency, the maximum physical frequency to be reproduced."
+                )
+            # xmax = beta*hbar*omega_max, given that omegan = nbeads/(beta*hbar)
+            xmax = self.nm_freqs[0] * self.nbeads / self.omegan
+            # seeds the fit with the previous solution (the stale value held in
+            # the depend array), which speeds up re-fits when temperature changes
+            y0 = (
+                dstrip(self._omegak)[1 : self.nbeads // 2 + 1]
+                * self.nbeads
+                / self.omegan
+            )
+            if not np.all(y0 > 0):  # zeros before the first evaluation
+                y0 = None
+            return self.omegan * nmtransform.eco_eva(self.nbeads, xmax, y0)
         return self.omegan * nmtransform.nm_eva(self.nbeads)
 
     def get_o_omegak(self):
@@ -592,6 +622,9 @@ class NormalModes:
         if self.mode == "rpmd":
             if len(self.nm_freqs) > 0:
                 warning("nm.frequencies will be ignored for RPMD mode.", verbosity.low)
+        elif self.mode == "eco":
+            # eco changes the spring frequencies (statics), not the dynamical masses
+            pass
         elif self.mode == "manual":
             if len(self.nm_freqs) != self.nbeads - 1:
                 raise ValueError(

{ipi-3.3.0 → ipi-3.3.1}/ipi/engine/outputs.py

@@ -12,7 +12,7 @@ import os
 
 import numpy as np
 
-from ipi.utils.messages import verbosity, info, warning
+from ipi.utils.messages import verbosity, warning
 from ipi.utils.units import unit_to_user
 from ipi.utils.softexit import softexit
 from ipi.utils.depend import *
@@ -117,6 +117,7 @@ class BaseOutput(object):
         """Emergency call when i-pi must exit quickly"""
 
         self.close_stream()
+        self.out = None  # anything written later is discarded
 
     def close_stream(self):
         """Closes the output stream"""
@@ -270,9 +271,6 @@ class PropertyOutput(BaseOutput):
               are not contained in the property_dict member of properties.
         """
 
-        if softexit.triggered:
-            return  # don't write if we are about to exit!
-
         if not self.active():
             return
         self.out.write("  ")
@@ -453,8 +451,6 @@ class TrajectoryOutput(BaseOutput):
     def write(self):
         """Writes out the required trajectories."""
 
-        if softexit.triggered:
-            return  # don't write if we are about to exit!
         if not self.active():
             return
 
@@ -693,7 +689,6 @@ class CheckpointOutput:
         self.stride = stride
         self._step = depend_value(name="step", value=step)
         self.overwrite = overwrite
-        self._storing = False
         self._continued = False
 
     def bind(self, simul):
@@ -723,9 +718,7 @@ class CheckpointOutput:
         positions would have been consistent.
         """
 
-        self._storing = True
         self.status.store(self.simul)
-        self._storing = False
 
     def write(self, store=True):
         """Writes out the required trajectories.
@@ -744,13 +737,6 @@ class CheckpointOutput:
               stored before writing the checkpoint file.
         """
 
-        if self._storing:
-            info(
-                "@ CHECKPOINT: Write called while storing. Force re-storing",
-                verbosity.low,
-            )
-            self.store()
-
         if not self.active():
             return
 

{ipi-3.3.0 → ipi-3.3.1}/ipi/engine/properties.py

@@ -1319,6 +1319,16 @@ class Properties:
 
         return fq * 0.5 / self.beads.nbeads
 
+    def _require_trotter_springs(self, name):
+        """Raises when an estimator derived for Trotter ring-polymer springs
+        is requested with a different spring matrix."""
+
+        if self.nm.mode == "eco":
+            raise ValueError(
+                "The %s estimator assumes Trotter ring-polymer springs and cannot be used with mode='eco'."
+                % name
+            )
+
     def get_sckintd(self, atom=""):
         """Calculates the Suzuki-Chin thermodynamic quantum centroid virial kinetic energy estimator.
 
@@ -1327,6 +1337,7 @@ class Properties:
               for. If not, the system kinetic energy is given.
         """
 
+        self._require_trotter_springs("kinetic_tdsc")
         try:
             # iatom gives the index of the atom to be studied
             iatom = int(atom)
@@ -1470,7 +1481,9 @@ class Properties:
                 atoms not to be considered in the distinguishable estimator (e.g. bosons)
         """
         q = dstrip(self.beads.q)
+        qnm = dstrip(self.nm.qnm)
         m = dstrip(self.beads.m)
+        omegak2 = dstrip(self.nm.omegak2)
         PkT32 = 1.5 * Constants.kb * self.ensemble.temp * self.beads.nbeads
 
         atd = 0.0
@@ -1482,14 +1495,23 @@ class Properties:
             if i in skip_atom_indices:
                 continue
 
-            ktd = 0.0
-            for b in range(1, self.beads.nbeads):
-                for j in range(3 * i, 3 * (i + 1)):
-                    ktd += (q[b, j] - q[b - 1, j]) ** 2
-            for j in range(3 * i, 3 * (i + 1)):
-                ktd += (q[self.beads.nbeads - 1, j] - q[0, j]) ** 2
-
-            ktd *= -0.5 * m[i] * self.nm.omegan2 / self.beads.nbeads
+            if i in self.nm.open_paths:
+                # open-path atoms are not described by the ring-polymer normal modes;
+                # uses the cyclic bead-difference spring energy (primitive-estimator
+                # definition, including the ring-closure term)
+                dq = q[:, 3 * i : 3 * (i + 1)] - np.roll(
+                    q[:, 3 * i : 3 * (i + 1)], 1, axis=0
+                )
+                ktd = -0.5 * m[i] * self.nm.omegan2 * (dq**2).sum() / self.beads.nbeads
+            else:
+                # spring energy of atom i, computed in the normal-mode representation
+                # so that it is valid for any circulant spring matrix (Trotter or eco)
+                ktd = (
+                    -0.5
+                    * m[i]
+                    * (omegak2 @ (qnm[:, 3 * i : 3 * (i + 1)] ** 2).sum(axis=1))
+                    / self.beads.nbeads
+                )
             ktd += PkT32
             atd += ktd
             ncount += 1
@@ -1499,6 +1521,7 @@ class Properties:
     def get_sckinpr(self):
         """Calculates the quantum centroid virial kinetic energy estimator."""
 
+        self._require_trotter_springs("kinetic_prsc")
         spring = self.nm.vspring / self.beads.nbeads
         PkT32 = (
             1.5
@@ -2330,6 +2353,7 @@ class Properties:
               sign(sum(weight*ke)) )
         """
 
+        self._require_trotter_springs("isotope_thermo")
         try:
             # iatom gives the index of the atom to be studied
             iatom = int(atom)
@@ -2436,6 +2460,7 @@ class Properties:
            (spraverage, spr2average, sprexpaverage)
         """
 
+        self._require_trotter_springs("isotope_zetatd")
         try:
             # iatom gives the index of the atom to be studied
             iatom = int(atom)
@@ -2539,6 +2564,7 @@ class Properties:
         q = dstrip(self.beads.q)
         v0 = self.forces.pot
         self.dbeads.q = q
+        self.dcell.h = self.cell.h
 
         for i in range(self.beads.natoms):
             # selects only the atoms we care about
@@ -2586,6 +2612,7 @@ class Properties:
             (ti_weight, chin_weight)
         """
 
+        self._require_trotter_springs("isotope_zetatd_4th")
         try:
             # iatom gives the index of the atom to be studied
             iatom = int(atom)
@@ -2707,6 +2734,7 @@ class Properties:
            (ti_weight, chin_weight)
         """
 
+        self._require_trotter_springs("isotope_zetasc_4th")
         try:
             # iatom gives the index of the atom to be studied
             iatom = int(atom)
@@ -2738,6 +2766,7 @@ class Properties:
         f = dstrip(self.forces.f)
         v0 = self.forces.pot
         pots = self.forces.pots
+        self.dcell.h = self.cell.h
 
         for i in range(self.beads.natoms):
             # selects only the atoms we care about
@@ -2804,6 +2833,7 @@ class Properties:
         )
 
     def get_chin_correction(self):
+        self._require_trotter_springs("chin_weight")
         f = dstrip(self.forces.f)
         m3 = dstrip(self.beads.m3)
         pots = self.forces.pots
@@ -2827,6 +2857,7 @@ class Properties:
         return np.asarray([chin, chin2, chinexp])
 
     def get_ti_correction(self):
+        self._require_trotter_springs("ti_weight")
         f = dstrip(self.forces.f)
         m3 = dstrip(self.beads.m3)
         #        pots = self.forces.pots    #
@@ -2854,6 +2885,7 @@ class Properties:
               for. If not, the system kinetic energy is given.
         """
 
+        self._require_trotter_springs("ti_pot")
         try:
             # iatom gives the index of the atom to be studied
             iatom = int(atom)
@@ -3225,6 +3257,10 @@ class Trajectories:
         Args:
            alpha: m'/m the mass ratio
         """
+        if self.system.nm.mode == "eco":
+            raise ValueError(
+                "The isotope_zetatd estimator assumes Trotter ring-polymer springs and cannot be used with mode='eco'."
+            )
         try:
             # iatom gives the index of the atom to be studied
             iatom = int(atom)
@@ -3306,6 +3342,7 @@ class Trajectories:
         q = dstrip(self.system.beads.q)
         v0 = self.system.forces.pot / nb
         self.dbeads.q = q
+        self.dcell.h = self.system.cell.h
 
         for i in range(nat):
             # selects only the atoms we care about