htpolynet 2.11.0__tar.gz → 2.11.2__tar.gz

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

@@ -7,6 +7,74 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.11.2] - 2026-09-23
+
+### Fixed
+
+- **A ring cure near its target kept re-proposing the triples it had just declined.**
+  Declining a ring that the closure ladder could not pull shut leaves its three groups
+  unreacted, which is the point -- but the next search then offered the same groups,
+  ran the same eight-stage ladder, and declined them again.  htpolynet-study measured
+  the cost on a 2.11.1 build: at conversion 0.97 with 24 groups left, nine iterations
+  running produced 77 declines and not one ring, at about 67 s each.
+
+  A declined combination is now passed over while any untried ring is within the search
+  radius.  It is a preference and not a prohibition: that cure escaped on iteration 41
+  and finished at 0.971, because the relaxation between iterations moves the groups, so
+  a triple that failed once can still close later.  When the memory is the only thing
+  left keeping an iteration idle, the search lifts it and offers those rings again
+  rather than stand still.
+
+## [2.11.1] - 2026-09-22
+
+### Fixed
+
+- **A cyclotrimerization's charges were computed on a ring that was never closed.**  The
+  trimer template reached antechamber with its three ring bonds recorded but still about
+  2.2 A long: the closure ladder cannot beat the reactants' own C#N, whose sp parameters
+  hold each group linear, and no force constant wins that.  Charges come from the
+  geometry, so the semiempirical step charged three separate cyanates rather than a
+  triazine, leaving **every ring carbon about 0.21 e low** with the deficit smeared over
+  the rest of the molecule.
+
+  Nothing caught it.  The atom types were right, because antechamber perceives those from
+  the connectivity, which was right; the molecules were neutral, because the error sums
+  to zero; and the system's own ring bonds relaxed to 1.347 A after the splice, because
+  the bonded parameters were fine.  It surfaced only when htpolynet-study ran a campaign
+  with `bcc` charges and half their builds died in a 500 K anneal -- the release smoke
+  test had used `gas` charges, which are computed from the topology and could not have
+  seen it.
+
+  A product whose reaction closes a ring is now relaxed against its own connectivity
+  before it is parameterized, and refused if the ring is still open afterward.
+  Measured on a methyl cyanate trimer, ring-carbon charge: **+0.699 before, +0.909
+  after, against +0.909** for the same molecule built independently from SMILES.
+  htpolynet-study measured the same 0.21 e deficit on a bisphenol A dicyanate trimer.
+
+  Two things fell out of the investigation that are worth knowing:
+  - **Correcting the bond orders does not fix it.**  An addition bond leaves the cyanate
+    carbon pentavalent -- it keeps its C#N, gains the ring bond, and still carries its
+    ester oxygen -- and that is now repaired too, since RDKit cannot read a molecule with
+    an impossible valence.  But repairing the orders alone produced charges identical to
+    the broken ones, because the semiempirical step reads coordinates, not bond orders.
+  - **antechamber's output geometry is its input geometry.**  It is not evidence about
+    what the charge calculation did or did not relax, and it should not be read as such.
+
+- **A ring the closure ladder could not pull shut is now declined rather than bonded
+  long.**  Late in a cure the matrix is rigid enough that a ring sometimes stops well
+  short -- one batch at conversion 0.95 ended 0.327 nm apart against a target of 0.150 --
+  and forming the bond anyway leaves it long for good: two ring bonds survived relaxation
+  and a 500 K anneal still 2.6 A apart, strained but stable, a defect the network then
+  carries permanently.  Declining costs almost nothing, since the groups stay unreacted
+  and are offered again next iteration once the neighbourhood has moved.  The limit is
+  `ring_cure: closure: max_accept`, default 0.30 nm; 0 restores the old behavior.  Only
+  visible now because the charge fix let a build reach conversion 0.95 for the first
+  time.
+
+- `Topology.rebalance_mol2_bond_orders` reduces a multiple bond when an addition would
+  otherwise leave an atom over-valent, preferring a bond that is over-valent at both ends
+  because reducing it repairs two atoms at once.
+
 ## [2.11.0] - 2026-09-22
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: htpolynet
-Version: 2.11.0
+Version: 2.11.2
 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.0 → htpolynet-2.11.2}/ROADMAP.md

@@ -199,6 +199,24 @@ Coverage as of the last measurement: **38.8%** overall.
 
 ## Cure and repair
 
+- **A ring cure that stalls near its target has no exit but `max_iterations`.**
+  Reported by htpolynet-study 2026-09-23 from a 2.11.1 build: at conversion 0.97
+  with 24 groups left, nine iterations running (32-40) produced 77 declines and no
+  ring, about 67 s apiece.  2.11.1 now skips a triple it has already failed to
+  close, which removes most of that cost, but a cure with nothing closable left
+  still runs to `max_iterations` rather than stopping.
+
+  The obvious fix -- stop after N consecutive iterations that close nothing -- was
+  deliberately not taken, and the reason is worth keeping.  That build escaped on
+  iteration 41 and finished at 0.971, and it was the one of four that survived the
+  study's postcure anneal.  Any N below 9 would have ended it early.  A stall is
+  not evidence that a cure is finished: the inter-iteration relaxation keeps moving
+  the groups, so the escape is real and can be a long time coming.
+
+  If this is revisited, the test should be something that distinguishes "nothing is
+  closable" from "nothing closed this time" -- the trend in the ladder's final
+  distances across the stalled run, say, rather than a count of iterations.
+
 - **Filtering candidate crosslinks against disallowed topologies, and what that means
   for cyanate esters.**  Raised by Cameron 2026-09-21, who asked the right question:
   can "physically disallowable" even be defined for these systems?  Partly.  Three
@@ -265,6 +283,12 @@ Coverage as of the last measurement: **38.8%** overall.
     component, the test would reject every cycle-closing bond and no system could gel
     (ours carry a cycle rank of ~430 on ~938 junctions).  Now noted in the code at
     both sites that read it, so it does not get "fixed".
+  - **Stronger than "could not gel": above 75% conversion an acyclic network does not
+    exist.**  From the cycle-rank identity below, a forest (rank 0) requires
+    4chi/3 - 1 = -(u+C)/n < 0, that is **chi < 3/4**.  Our builds run to chi 0.97-0.99,
+    so cycle-closing bonds are *forced* there, not merely tolerated -- a test that
+    rejected them could not reach its own target conversion, never mind gel.
+    htpolynet-study, 2026-09-22, checked here.
 
   **Class 3, soft: strained cycles, and the threshold problem.**  For cyanate esters
   this class is where a filter does *harm* if switched on -- see the end-group
@@ -292,7 +316,10 @@ Coverage as of the last measurement: **38.8%** overall.
     and the docs and the code comment must say why.**  htpolynet-study, 2026-09-21,
     from the library: Fang & Shimp's end-group arithmetic caps acyclic dendritic
     growth at **75%** cyanate conversion, a mild ring-chain model at **90%**, and only
-    severe macrocyclization reaches **98%**.  Real cure reaches 98-99%, and Guenthner
+    severe macrocyclization reaches **98%**.  That 75% is not only an end-group
+    argument: counting edges and vertices on the monomer-junction graph gives
+    chi < 3/4 for any acyclic network, with no chemistry in the derivation at all
+    (see the retraction below).  Two independent routes to the same ceiling.  Real cure reaches 98-99%, and Guenthner
     2014 treats the point as settled.  **A 98% polycyanurate network cannot be
     macrocycle-free.**  Filtering short cycles out of this chemistry would therefore
     remove the very structures that let it cure at all.
@@ -301,18 +328,34 @@ Coverage as of the last measurement: **38.8%** overall.
     are negligible.  That justification inverts for cyanate esters.  Put this in a
     comment where the filter is defined, because the filter will otherwise look
     under-used and someone will helpfully turn it on.
-  - **If anything, we make too few.**  Two independent measures: cycle rank per
-    monomer **0.303 against Fang's 0.485**, and a gel-point delay of **+6.3% against
-    Lin's +21%** cyclization term.  So the interesting question for cyanate esters is
-    not how to suppress cycles but why htpolynet produces fewer than the chemistry
-    demands -- plausibly the 0.5 nm search radius and junctions seeded at t=0.  That
-    is a separate investigation, and the three-body reaction changes its terms, since
-    junctions would then emerge where ends meet.
+  - **If anything, we make too few** -- on the gel-point evidence, which is now the
+    only evidence.  A gel-point delay of **+6.3% against Lin's +21%** cyclization
+    term.  So the interesting question for cyanate esters is not how to suppress
+    cycles but why htpolynet produces fewer than the chemistry demands -- plausibly
+    the 0.5 nm search radius and junctions seeded at t=0.  That is a separate
+    investigation, and the three-body reaction changes its terms, since junctions
+    would then emerge where ends meet.
+  - **RETRACTED 2026-09-22: the cycle-rank half of that claim ("0.303 against Fang's
+    0.485") was never a measurement.**  On the monomer-junction graph, with
+    `same_residue: false` forbidding both arms of one monomer in one junction, the
+    edge count is fixed by the conversion: E = 3N and N = 2n*chi/3, so
+    cycle rank = E - V + C = n(4chi/3 - 1) + u + C, with u the monomers having no
+    reacted arm.  Nothing about cyclization is left free.  Raised by htpolynet-study
+    and checked here against an unrelated network -- 150 bisphenol A dicyanates at
+    chi 0.610 -- where the identity reproduces the measured rank of 2 with a residual
+    of zero to six decimals.  Fang's 0.485 also cannot be a graph cycle rank at all:
+    4chi/3 - 1 = 0.485 requires chi = 1.11.  Two different quantities were being
+    compared.  Do not reinstate the comparison; if a cyclization metric is wanted,
+    it has to be one with structural freedom left in it once chi is fixed -- the
+    cycle *spectrum* (how many cycles of each length) rather than the rank.  The
+    freedom in the rank is exactly u + C, which for a well-cured network is about 1:
+    htpolynet-study measured rank 107 against a floor of 106.1 at n = 360, chi 0.971.
+    A metric whose entire range is one unit cannot separate two networks.
   - The 28-rings are near-unstrained in GAFF (span -0.07 A, C-O-C angle -0.46 deg
     against non-ring bridges), but that only says the force field tolerates them.
     Their absolute frequency is still set by our search radius and seeded junctions,
-    so **1.4% must never be quoted as a physical cyclization rate**; the comparison
-    against Fang above is the meaningful one.
+    so **1.4% must never be quoted as a physical cyclization rate**; the gel-point
+    comparison above is the meaningful one, the cycle-rank one having been retracted.
   - **Do not validate the filter on Tg in this system -- it is underpowered, and
     that is bounded, not guessed.**  Between-bridge spread in ring density is 0.67
     percentage points of bridges, and dTg/dconversion averages 5.6 K per percentage
@@ -1738,15 +1781,16 @@ Coverage as of the last measurement: **38.8%** overall.
   structure-property story.
 
 
-- **A ring-closing ladder stops around 0.22 nm, not at its 0.15 nm target.**
-  The closure restraints pull three cyanate groups together before any ring bond
-  exists, and they consistently stall at ~0.225 nm regardless of how far apart
-  they started -- in the isolated trimer template too, so it is not crowding by
-  the surrounding system.  The cause is that the groups still carry their
-  sp-hybridized C#N parameters while being pulled, and a linear triple bond
-  resists closing the angle a triazine needs; no force constant fixes that.  It
-  is benign today: the bonds are formed at that length, the template splice
-  replaces the types, and the relax step brings them to 1.35 A, which every
-  build has confirmed.  The warning threshold (twice the target) has never
-  fired.  If it ever does, the fix is to attenuate the C#N bonded parameters
-  along the closure ladder rather than to pull harder.
+- **Every template is parameterized with its new bonds still about 2.2 A long, and
+  whether that matters outside ring closures is unverified.**  htpolynet records a
+  reaction's bonds and only relaxes the geometry after parameterization, so antechamber
+  always sees a product whose new bonds are stretched -- a styrene dimer as much as a
+  triazine.  For ring closures this was measured to be badly wrong (0.21 e per ring
+  carbon; see the CHANGELOG for 2.11.1) and is now fixed by relaxing those templates
+  first.  For an ordinary one-bond condensation nobody has checked.  The honest test is
+  not the output mol2, because antechamber echoes its input coordinates into it: it is
+  to parameterize a dimer template both as built and after relaxing it, and compare the
+  charges near the new bond.  If they differ materially, the same relaxation should be
+  applied to every product, which would move the charges of every template htpolynet has
+  ever built -- so it wants measuring before it is done, and a deliberate decision about
+  reproducibility against published results.

{htpolynet-2.11.0 → htpolynet-2.11.2}/docs/source/htpolynetpackage.rst

@@ -202,6 +202,11 @@ htpolynet.geometry
    :undoc-members:
    :show-inheritance:
 
+.. automodule:: htpolynet.geometry.templategeom
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
 htpolynet.repair
 ----------------
 

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

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

{htpolynet-2.11.0 → htpolynet-2.11.2}/src/htpolynet/core/molecule.py

@@ -18,11 +18,13 @@ from ..core.bondtemplate import BondTemplate, BondTemplateList, ReactionBond, Re
 from ..core.topocoord import TopoCoord
 from ..cure.chain import ChainManager
 from ..cure.reaction import (Reaction, ReactionList, consumes_sacrificial_h, reaction_stage,
-                             spanning_and_closing_bonds)
+                             spanning_and_closing_bonds, is_ring_closing)
 from ..external.ambertools import GAFFParameterize
 from ..external.command import run
 from ..external.gromacs import mdp_modify,gro_from_trr
 from ..geometry.matrix4 import Matrix4
+from ..geometry.templategeom import (check_ring_closed,
+                                     relax_geometry as relax_template_geometry)
 from ..geometry.placement import min_distance, place_group, rotate_about_axis
 from ..io.gro import GRX_ATTRIBUTES
 
@@ -510,6 +512,15 @@ class Molecule:
             #     logger.debug(f'Using override input molecules/inputs/{self.name}.{isf} as a generator')
             #     pfs.checkout(f'molecules/inputs/{self.name}.{isf}')
             # else:
+            # A ring closure leaves the template's coordinates describing its reactants
+            # rather than its product: the closure ladder cannot beat the reactants' own
+            # sp parameters, so the ring bonds are recorded but still ~0.22 nm long.
+            # Charges are computed from the geometry, so this has to be put right before
+            # antechamber sees it -- see geometry.templategeom.
+            if is_ring_closing(R):
+                self.TopoCoord.Topology.rebalance_mol2_bond_orders()
+                relax_template_geometry(self.TopoCoord, name=self.name)
+                check_ring_closed(self.TopoCoord, self.name)
             self.TopoCoord.write_mol2(filename=f'{self.name}.mol2', molname=self.name)
             if not do_parameterization:
                 self.TopoCoord.write_gro(f'{self.name}.gro', grotitle=self.name)

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

@@ -701,7 +701,12 @@ class Runtime:
                 rc.state.iter += 1
                 continue
             bdf = triple_bonds_dataframe(chosen, sites, R.product, order=R.bonds[0].get('order', 1))
-            rc.close_rings(TC, bdf, gromacs_dict=gromacs_dict)
+            work = rc.close_rings(TC, bdf, gromacs_dict=gromacs_dict)
+            # a ring the ladder could not pull shut would be bonded long and stay that way
+            bdf, chosen = rc.accept(bdf, work, chosen)
+            if not chosen:
+                rc.state.iter += 1
+                continue
             rc.form_rings(TC, bdf, sites, chosen, template, template_resids,
                           name_translations=name_translations, atom_names=arm)
             rc.relax(TC, gromacs_dict=gromacs_dict)

{htpolynet-2.11.0 → htpolynet-2.11.2}/src/htpolynet/core/topocoord.py

@@ -1307,6 +1307,11 @@ class TopoCoord:
         # htpolynet-study 2026-09-21: that is the sole reason no cured cyanate-ester
         # network in 96 cells contains an intramolecular 14-ring, while carrying a
         # cycle rank of ~430 on ~938 junctions.  Do not "fix" the staleness.
+        # Nor is gelling the whole of it: counting edges and vertices on the
+        # monomer-junction graph, an acyclic network requires a conversion below
+        # 3/4, so above that every further bond MUST close a cycle.  A cure that
+        # refused cycle-closing bonds could not reach the conversions this
+        # chemistry is run at (0.97-0.99) at all.
         assert i_resNum!=j_resNum,f'shortcircuit test error {i}-{j} both in residue {i_resNum}?'
         i_neighbors=self.Topology.bondlist.partners_of(i)
         j_neighbors=self.Topology.bondlist.partners_of(j)

{htpolynet-2.11.0 → htpolynet-2.11.2}/src/htpolynet/core/topology.py

@@ -209,6 +209,23 @@ def select_topology_type_option(options, typename='dihedraltypes', rule='stiffes
         return sorted_options[0]
     return []
 
+
+def _element_of(name, gafftype):
+    """Best guess at an atom's element from its GAFF type, falling back to its name.
+
+    GAFF types are lowercase element-led (``ca``, ``nb``, ``os``, ``hc``), with the
+    two-letter halogens the only ambiguity worth handling.
+    """
+    for src in (str(gafftype), str(name)):
+        t = src.strip().upper()
+        if not t:
+            continue
+        if t[:2] in ('CL', 'BR'):
+            return t[:2]
+        if t[0].isalpha():
+            return t[0]
+    return ''
+
 class Topology:
     """ Class for handling gromacs topology data
     """
@@ -649,6 +666,66 @@ class Topology:
             to_drop.append(d[(d.ai == ai) & (d.aj == aj)].index.values[0])
         self.D['bonds'] = self.D['bonds'].drop(to_drop)
 
+    def rebalance_mol2_bond_orders(self, atoms=None):
+        """Restores valence after an addition bond, by reducing a multiple bond.
+
+        A condensation reaction removes a hydrogen from each atom it bonds, so valence
+        takes care of itself.  An addition removes nothing: ``add_bonds`` records the new
+        mol2 bond at order 1 and leaves every existing bond alone, so an atom that already
+        carried a multiple bond ends up over-valent.  A cyclotrimerization does exactly
+        this -- the cyanate carbon keeps its C#N, gains the ring bond, and still carries
+        its ester oxygen, for a valence of five.
+
+        The mol2 bond orders are what antechamber perceives the molecule from, so an
+        impossible valence there is not cosmetic.  Reducing the shared triple bond fixes
+        both of its atoms at once, which is why a bond over-valent at BOTH ends is chosen
+        first.
+
+        Args:
+            atoms (iterable): restrict the repair to these atom numbers, normally the ones
+                a reaction just bonded; None considers every atom
+
+        Returns:
+            int: how many bond orders were reduced
+        """
+        mb = self.D.get('mol2_bonds')
+        if mb is None or mb.empty:
+            return 0
+        at = self.D['atoms']
+        element = {int(r.nr): _element_of(r.atom, r.type) for r in at.itertuples()}
+        limit = {'H': 1, 'C': 4, 'N': 3, 'O': 2, 'F': 1, 'CL': 1, 'BR': 1, 'I': 1}
+        order_of = {'1': 1.0, '2': 2.0, '3': 3.0, 'ar': 1.5, 'am': 1.0}
+        watch = None if atoms is None else {int(a) for a in atoms}
+        reduced = 0
+        for _ in range(4 * mb.shape[0]):     # each pass reduces one order; bounded
+            val = {}
+            for r in mb.itertuples():
+                o = order_of.get(str(r.order), 1.0)
+                val[int(r.ai)] = val.get(int(r.ai), 0.0) + o
+                val[int(r.aj)] = val.get(int(r.aj), 0.0) + o
+            over = {a: v - limit[element[a]] for a, v in val.items()
+                    if element.get(a) in limit and v > limit[element[a]] + 0.01
+                    and (watch is None or a in watch)}
+            if not over:
+                break
+            # a bond over-valent at both ends repairs two atoms at once
+            cand = [(i, r) for i, r in enumerate(mb.itertuples())
+                    if order_of.get(str(r.order), 1.0) >= 2.0
+                    and (int(r.ai) in over or int(r.aj) in over)]
+            if not cand:
+                break
+            cand.sort(key=lambda x: (-(int(x[1].ai) in over) - (int(x[1].aj) in over),
+                                     -order_of.get(str(x[1].order), 1.0)))
+            i, row = cand[0]
+            newo = int(order_of[str(row.order)] - 1)
+            mb.iat[i, mb.columns.get_loc('order')] = str(newo)
+            logger.debug(f'valence repair: bond {row.ai}-{row.aj} order '
+                         f'{row.order} -> {newo}')
+            reduced += 1
+        if reduced:
+            logger.info(f'Reduced {reduced} bond order(s) to keep valence after an addition')
+        return reduced
+
     def add_bonds(self, pairs=[]):
         """Adds bonds indicated in list pairs to the topology.
 

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

@@ -33,6 +33,21 @@ from ..repair.topology_surgery import neutralize_touched_fragments
 logger = logging.getLogger(__name__)
 
 
+def _triple_key(donors):
+    """A ring's identity, in terms that survive from one iteration to the next.
+
+    A triple is held as row numbers into the site table, and that table is rebuilt
+    every iteration and shrinks as groups react, so those numbers name a different
+    ring next time.  The three donor atoms do not move: one per group, unique to it,
+    and fixed for the life of the system.
+
+    The two ring orientations deliberately share a key.  :func:`candidate_triples`
+    scores both and keeps the better one, so the orientation that was declined is the
+    better one, and the other would have farther to go.
+    """
+    return frozenset(int(d) for d in donors)
+
+
 class RingCureState:
     """How far a ring cure has got, and enough to resume it."""
 
@@ -81,7 +96,7 @@ class RingController:
         'same_residue': False,
         'relax': [{'ensemble': 'min'},
                   {'ensemble': 'nvt', 'temperature': 300, 'nsteps': 2000}],
-        'closure': {'nstages': 8, 'target': 0.15, 'kb': 300000.0,
+        'closure': {'nstages': 8, 'target': 0.15, 'kb': 300000.0, 'max_accept': 0.30,
                     'equilibration': [{'ensemble': 'min'},
                                       {'ensemble': 'nvt', 'temperature': 600, 'nsteps': 1000}]},
     }
@@ -93,6 +108,7 @@ class RingController:
         self.dicts = d
         self.state = state or RingCureState()
         self.rings_df = None
+        self.declined = set()
 
     # ---- what the loop decides, all of it testable without MD ----
 
@@ -172,16 +188,49 @@ class RingController:
             cands = candidate_triples(sites, positions, self.radius, box,
                                       same_molecule=self.dicts['same_molecule'],
                                       same_residue=self.dicts['same_residue'])
-            chosen = select_disjoint(cands, max_triples=self.dicts['max_rings_per_iteration'])
+            allowed = self._drop_declined(cands, sites)
+            chosen = select_disjoint(allowed, max_triples=self.dicts['max_rings_per_iteration'])
+            passed = len(cands) - len(allowed)
             logger.info(f'Iteration {self.state.iter}: {len(sites)} unreacted group(s), '
-                        f'{len(cands)} candidate ring(s) within {self.radius:.3f} nm, '
-                        f'{len(chosen)} accepted')
+                        f'{len(cands)} candidate ring(s) within {self.radius:.3f} nm'
+                        + (f' ({passed} passed over as already failed)' if passed else '')
+                        + f', {len(chosen)} accepted')
             if len(chosen) >= floor or self.radius >= self.dicts['max_radius']:
+                if not chosen and cands and self.declined:
+                    # the memory is now the only thing keeping this iteration idle, and
+                    # the groups have moved since they were declined; try them again
+                    logger.info(f'Iteration {self.state.iter}: every ring in reach has '
+                                f'failed before; forgetting {len(self.declined)} of them '
+                                f'and offering them again')
+                    self.declined.clear()
+                    chosen = select_disjoint(cands,
+                                             max_triples=self.dicts['max_rings_per_iteration'])
                 return sites, chosen
             self.state.radius_index += 1
             logger.info(f'Radius increased to {self.radius:.3f} nm '
                         f'({len(chosen)}/{floor} ring(s) so far)')
 
+    def _drop_declined(self, cands, sites):
+        """Passes over the triples this cure has already failed to pull shut.
+
+        A declined ring leaves its three groups unreacted by design, and the next search
+        offers them again -- so a rigid endgame proposes the same triples, runs the same
+        closure ladder, and declines them again.  Measured at conversion 0.97 with 24
+        groups left: nine iterations running, 77 declines, about 67 s apiece, before one
+        triple finally closed and the cure finished at 0.971.
+
+        A preference, not a prohibition, because the geometry between one decline and the
+        next search is not identical -- the inter-iteration relaxation moves the groups,
+        which is how that cure escaped.  Skipping a triple saves a ladder that would
+        almost certainly fail; refusing it outright would have ended that cure three
+        iterations early.  :meth:`search` therefore lifts the whole memory rather than
+        come back empty-handed.
+        """
+        if not self.declined:
+            return cands
+        return [c for c in cands
+                if _triple_key(sites.at[a, 'donor'] for a in c[1]) not in self.declined]
+
     def record(self, chosen):
         """Counts the rings formed and the groups they consumed."""
         self.state.rings += len(chosen)
@@ -229,11 +278,53 @@ class RingController:
         TC.add_length_attribute(work, attr_name='final_distance')
         worst = work['final_distance'].max()
         logger.info(f'Rings closed to at most {worst:.3f} nm (target {c["target"]:.3f})')
-        if worst > 2.0 * c['target']:
-            logger.warning(f'A ring-closing pair is still {worst:.3f} nm apart; its bond will be '
-                           f'formed long and relaxed, which may strain the network')
         return work
 
+    def accept(self, bdf, work, chosen):
+        """Drops any ring the closure ladder could not actually pull shut.
+
+        Late in a cure the matrix is rigid enough that a ring sometimes stops well short
+        -- one batch at conversion 0.95 ended 0.327 nm apart against a target of 0.150.
+        Forming the bond anyway leaves it long: two ring bonds survived relaxation and a
+        500 K anneal still 2.6 A apart, strained but stable, which is a defect the
+        network then carries for good.
+
+        Declining costs almost nothing.  The groups stay unreacted and are offered again
+        next iteration, by which time the neighbourhood has moved; only if they can never
+        close does the cure lose them, which is the right outcome.
+
+        The combination itself is recorded for :meth:`_drop_declined`, which prefers not
+        to spend another ladder on it while any untried ring is in reach.  That is what
+        a rigid endgame otherwise does: nine iterations running, 77 declines, the same
+        few triples every time.
+
+        Args:
+            bdf (pandas.DataFrame): this iteration's bonds, three rows per ring
+            work (pandas.DataFrame): the same pairs with their final distances
+            chosen (list): the rings the search accepted
+
+        Returns:
+            tuple: (bdf, chosen) keeping only the rings that closed
+        """
+        limit = self.dicts['closure']['max_accept']
+        if not limit:
+            return bdf, chosen
+        worst = work['final_distance'].to_numpy().reshape(-1, 3).max(axis=1)
+        keep = [n for n in range(len(chosen)) if worst[n] <= limit]
+        if len(keep) == len(chosen):
+            return bdf, chosen
+        for n in range(len(chosen)):
+            if n not in keep:
+                self.declined.add(_triple_key(bdf[bdf['triple'] == n]['ai']))
+                logger.info(f'Iteration {self.state.iter}: declining a ring still '
+                            f'{worst[n]:.3f} nm from closing (limit {limit:.3f} nm); its '
+                            f'groups stay unreacted, and this combination waits until '
+                            f'nothing untried is in reach')
+        renumber = {old: new for new, old in enumerate(keep)}
+        bdf = bdf[bdf['triple'].isin(keep)].copy()
+        bdf['triple'] = [renumber[t] for t in bdf['triple']]
+        return bdf.reset_index(drop=True), [chosen[n] for n in keep]
+
     def relax(self, TC, gromacs_dict=None):
         """Eases a freshly closed ring's bonds in before anything else runs.