htpolynet 2.11.2__tar.gz → 2.11.3__tar.gz

{htpolynet-2.11.2 → htpolynet-2.11.3}/CHANGELOG.md

@@ -7,6 +7,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.11.3] - 2026-09-23
+
+### Fixed
+
+- **A ring cure handed its last batch of rings to postcure unrelaxed.**  Every batch
+  but the last is relaxed twice: once by the per-iteration relax as soon as its bonds
+  exist, and again by the *next* iteration's closure ladder, which is eight
+  minimizations and 16 ps at 600 K against the relax's one minimization and 4 ps at
+  300 K.  The final batch only ever gets the first, and then goes straight into a
+  500 K anneal.
+
+  htpolynet-study measured it on three 2.11.1 builds, all of which had ended on a
+  ring-forming iteration and had therefore been relaxed.  Bond energy entering the
+  anneal tracked how many rings that last iteration formed -- 1, 1 and 4 rings for
+  18849, 26113 and 35959 kJ/mol, against 13619 +/- 226 for a route that enters already
+  relaxed.  An inventory of one such structure found five bonds beyond 2.0 A: one
+  triazine's three ring bonds at 2.24 A, and two monomers whose own backbones the
+  ladder had stretched to 2.34 and 3.20 A while pulling their arms toward different
+  rings.  Eleven of twenty builds died in the anneal.
+
+  The cure now runs a minimization and a short 300 K NVT once on exit, mirroring what
+  the postcure repair stage already did for the route that never saw this.  It is
+  unconditional -- the cure has four ways to end and which of them leaves strain behind
+  is not worth reasoning about per exit -- and configurable as `ring_cure.settle`.
+
+  Confirmed paired, same eight velocity seeds against the same two structures on the
+  same hardware: two anneals exploded without the settle and none with it.  The two
+  came from different source structures, one of which had never failed in production,
+  so the effect is not particular to a pathological build, and nothing exploded during
+  the settle itself -- the minimization absorbs the strain rather than the failure
+  moving earlier.  Eight seeds is a small sample and that comparison alone would be
+  weak; it is corroboration of the bond energies above, not the case on its own.
+
 ## [2.11.2] - 2026-09-23
 
 ### Fixed

{htpolynet-2.11.2 → htpolynet-2.11.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: htpolynet
-Version: 2.11.2
+Version: 2.11.3
 Summary: Automated MD System Builder for Amorphous Network Polymers
 Project-URL: Source, https://github.com/cameronabrams/htpolynet
 Project-URL: Documentation, https://htpolynet.readthedocs.io/

{htpolynet-2.11.2 → htpolynet-2.11.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "htpolynet"
-version = "2.11.2"
+version = "2.11.3"
 authors = [
   { name="Cameron F Abrams", email="cfa22@drexel.edu" },
 ]

{htpolynet-2.11.2 → htpolynet-2.11.3}/src/htpolynet/core/runtime.py

@@ -718,6 +718,12 @@ class Runtime:
             rc.state.iter += 1
             pfs.go_proj()
             rc.state.to_yaml(statefile)
+        # the last batch of rings never sees another closure ladder, so it reaches
+        # postcure carrying whatever the ladder left in it
+        pfs.go_to(pfs.Dirs.systems_iter(rc.state.iter))
+        TC.grab_files()
+        rc.settle(TC, gromacs_dict=gromacs_dict)
+        pfs.go_proj()
         self._report_molecule_charges('after ring cure')
         my_logger(f'Ring cure ends: {rc.state.rings} ring(s), conversion '
                   f'{rc.state.conversion:.3f}', logger.info)

{htpolynet-2.11.2 → htpolynet-2.11.3}/src/htpolynet/cure/ringcontroller.py

@@ -96,6 +96,8 @@ class RingController:
         'same_residue': False,
         'relax': [{'ensemble': 'min'},
                   {'ensemble': 'nvt', 'temperature': 300, 'nsteps': 2000}],
+        'settle': [{'ensemble': 'min'},
+                   {'ensemble': 'nvt', 'temperature': 300, 'nsteps': 2500}],
         'closure': {'nstages': 8, 'target': 0.15, 'kb': 300000.0, 'max_accept': 0.30,
                     'equilibration': [{'ensemble': 'min'},
                                       {'ensemble': 'nvt', 'temperature': 600, 'nsteps': 1000}]},
@@ -341,6 +343,45 @@ class RingController:
                          gromacs_dict or {})
         logger.info(f'Iteration {self.state.iter}: new ring bonds relaxed')
 
+    def settle(self, TC, gromacs_dict=None):
+        """Relaxes the network one last time before the cure hands it on.
+
+        Every batch of rings but the last is relaxed twice: once by :meth:`relax` as
+        soon as its bonds exist, and again -- much harder -- by the next iteration's
+        closure ladder, which is eight minimizations and 16 ps at 600 K against relax's
+        one minimization and 4 ps at 300 K.  The final batch only ever gets the first,
+        and whatever the cure ends on goes straight into postcure.
+
+        Measured by htpolynet-study on three 2.11.1 builds, all of which ended on a
+        ring-forming iteration, so all of which had been relaxed: bond energy entering
+        the anneal tracked how many rings that last iteration formed -- 1, 1 and 4 rings
+        for 18849, 26113 and 35959 kJ/mol, against 13619 +/- 226 for a route that enters
+        already relaxed.  An inventory of one such structure found five bonds beyond
+        2.0 A: one triazine's three ring bonds at 2.24 A, and two monomers whose own
+        backbones the ladder had stretched to 2.34 and 3.20 A while pulling their two
+        arms toward different rings.  Nothing after the restraints come off relieves
+        either, and the strain then has to be absorbed by a 500 K anneal, which is where
+        11 of 20 builds died.
+
+        Unconditional on purpose.  The cure has four ways to end -- target reached,
+        iterations exhausted, radius exhausted, every ring declined -- and which of them
+        leaves strain behind is not worth reasoning about per exit when the remedy is
+        this cheap.
+
+        Args:
+            TC (TopoCoord): the system
+            gromacs_dict (dict): gromacs directives
+        """
+        stages = self.dicts['settle']
+        if not stages:
+            return False
+        TC.write_top(f'ringsettle-{self.state.iter}.top')
+        TC.write_gro(f'ringsettle-{self.state.iter}.gro')
+        self._run_stages(TC, f'ringsettle-{self.state.iter}', stages, gromacs_dict or {})
+        logger.info(f'Ring cure settled after {self.state.rings} ring(s); the network is '
+                    f'relaxed before postcure rather than at 500 K')
+        return True
+
     def _run_stages(self, TC, deffnm, stages, gromacs_dict):
         """Runs one equilibration sequence, as the cure's ladders do."""
         for stage in stages:

{htpolynet-2.11.2 → htpolynet-2.11.3}/src/htpolynet/schema/base.yaml

@@ -842,6 +842,20 @@ attributes:
           Allow two groups of one residue in a ring, which for a dicyanate is both
           arms into one triazine.
         default: false
+      - name: settle
+        type: list
+        text: >
+          Equilibration run once at the end of the cure, before postcure.  Every
+          batch of rings but the last is relaxed again by the next iteration's
+          closure ladder; the last one is not, and reaches postcure still carrying
+          the strain the ladder left -- stretched ring bonds, and monomers whose
+          backbones were pulled while their arms went to different rings.  An empty
+          list skips it.
+        default:
+          - ensemble: min
+          - ensemble: nvt
+            temperature: 300
+            nsteps: 2500
       - name: closure
         type: dict
         text: >

{htpolynet-2.11.2 → htpolynet-2.11.3}/tests/unit/test_ringcontroller.py

@@ -357,3 +357,22 @@ class TestATripleThatFailedIsNotTriedAgainWhileAnythingElseIsLeft(unittest.TestC
         _, out_c = c.accept(bdf, work, chosen)
         self.assertEqual(len(out_c), 1)
         self.assertEqual(c.declined, set())
+
+
+class TestSettlingTheNetworkOnExit(unittest.TestCase):
+    """Every batch of rings but the last is relaxed twice -- once by `relax`, then much
+    harder by the next iteration's closure ladder.  The last batch only gets the first,
+    and goes to a 500 K anneal carrying whatever the ladder left in it."""
+
+    def test_it_is_on_by_default(self):
+        c = RingController({})
+        self.assertEqual([s['ensemble'] for s in c.dicts['settle']], ['min', 'nvt'])
+
+    def test_an_empty_list_skips_it(self):
+        # and does not touch the system, so a caller that disables it pays nothing
+        c = RingController({'settle': []})
+        self.assertFalse(c.settle(None))
+
+    def test_a_caller_can_replace_the_stages(self):
+        c = RingController({'settle': [{'ensemble': 'npt', 'temperature': 400}]})
+        self.assertEqual(c.dicts['settle'], [{'ensemble': 'npt', 'temperature': 400}])