htpolynet 2.10.2__tar.gz → 2.11.0__tar.gz

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

@@ -7,6 +7,178 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.11.0] - 2026-09-22
+
+### Added
+
+- **A three-body cure reaction: cyclotrimerization** (see `ROADMAP.md`).  A
+  `reactions` entry whose bonds close a ring among three reactants, plus a
+  `ring_cure` configuration block, now build a network by the real cyanate-ester
+  chemistry -- three -O-C#N groups closing one triazine -- instead of the
+  pre-formed-triazine surrogate that needs postcure repair.  CURE is untouched
+  and remains the default; a configuration without a ring-closing reaction
+  behaves exactly as before.
+
+  Verified end to end twice.  On 90 methyl cyanates, which can only trimerize:
+  19 triazines, 63% conversion, every ring six-membered with three aromatic
+  carbons and three aromatic nitrogens, bonds averaging 1.351 A (a triazine's
+  is 1.34) and planar to 0.065 A, the 33 unreacted groups keeping their C#N at
+  1.153 A, and all 52 molecules neutral.  Then on 100 ethylene dicyanates,
+  which gel: 50 triazines, 75% conversion, ring bonds averaging 1.347 A, 55
+  monomers reacted through both arms and 40 through one, no chemically
+  impossible bond, and the largest of the 8 remaining molecules holding 1068 of
+  1200 atoms -- a percolating network.
+
+  Then at scale, on 150 bisphenol A dicyanates -- the real monomer, 35 atoms
+  rather than 12, with a rigid aromatic backbone and its two arms about 0.9 nm
+  apart: 61 triazines at 61% conversion, every unit six-membered with three
+  aromatic nitrogens and three ring carbons still carrying their ester oxygen,
+  ring bonds averaging 1.347 A, no bond anywhere longer than 2.5 A, 54 monomers
+  reacted through both arms and 75 through one, all 150 molecules neutral, and
+  the largest of the 30 remaining components holding 1295 of 5250 atoms.
+
+  A monomer with more than one reactive site needs two things beyond the
+  single-site case, both of which the difunctional build exposed:
+  - **Only the reacting site's share of a residue is spliced.**  A dicyanate can
+    join two rings, and the trimer template shows one arm reacted, so splicing
+    the whole residue reset the other ring's arm -- 36 bonds between an aromatic
+    nitrogen and an unreacted cyanate carbon in the first attempt.  Each atom is
+    assigned to whichever site is nearer through the residue's own bonds.
+  - **The template's atom names are translated for a residue that rings through
+    its other site.**  That exchange moves every atom of the arm, hydrogens
+    included, so it is derived as an automorphism of the monomer's bond graph
+    rather than read off `symmetry_equivalent_atoms`, which names only the
+    reactive atoms.  The sets are still consulted for which sites exist.
+
+  A ring-closing reaction is also exempt from symmetry expansion, which permutes
+  each reactive atom independently: for three dicyanates that produced 64
+  reactions, most of them mixing the two arms of one site, and a template for
+  each.
+  - A reaction's residue-offset arithmetic now works for any number of
+    reactants.  It was written for exactly two, so a bond between the first and
+    third reactant of a three-reactant reaction resolved to the wrong residue.
+  - `reaction.is_ring_closing` recognizes a reaction whose bonds close a cycle
+    among its reactants, which a cyclotrimerization does (1-2, 2-3, 3-1) even
+    though its new bonds alone form no cycle -- the ring closes through bonds
+    each reactant already had.
+  - The pairwise bond search now skips such a reaction with a warning naming
+    it, rather than treating its bonds as three unrelated pairwise candidates
+    and forming them in separate iterations, which would not build a ring.
+  - A reaction bond can declare `sacrificial_h: false`, for an addition where
+    nothing is lost.  Every reaction htpolynet had before is a condensation
+    that deletes one hydrogen from each of the bond's atoms, which stays the
+    default; cyclotrimerization forms three bonds and deletes no atom.
+  - `reaction.spanning_and_closing_bonds` separates the bonds that assemble a
+    product from the bond that closes its ring.  A template build positions
+    each incoming piece as it bonds it, which a closing bond cannot do: the
+    residues it joins are already placed, so it is skipped there and its
+    geometry handled separately.
+  - `Runtime.do_ring_cure` runs it as a workflow stage, with restart state
+    beside the cure's.  `do_cure` now returns early when every cure reaction
+    closes a ring: the pairwise search skips those, so it would otherwise
+    iterate to its limit forming nothing.  (The `CURE` block is present even
+    when a configuration omits it, since the schema supplies its defaults.)
+  - `cure.ringcontroller` runs the loop: search, pull every chosen ring shut,
+    form its bonds, splice the trimer template over its three residues, settle
+    the charge, and count what was consumed.  Conversion is counted in reactive **groups**, three per
+    ring, which is what this chemistry reports -- the pre-formed-triazine route
+    has to infer it from a bond count instead.  The search widens until an
+    iteration yields `min_rings_per_iteration` rings, as the pairwise cure's
+    does for bonds.  Its state round-trips to YAML for restart, carrying the
+    widened radius with it.
+  - `cure.triplesearch` finds the triangles of reactive groups one ring-closing
+    reaction can join.  The pairwise search cannot: it asks which A atom is near
+    which B atom, while a cyclotrimerization needs three groups mutually close,
+    and two well-chosen groups can still leave the third far off.  Candidates
+    are scored as whole triangles by their total new-bond length, both ring
+    orientations are tried, each group may join only one triple, and a group is
+    identified by residue *and* atom names -- a bisphenol dicyanate carries two,
+    which is what makes it a crosslinker.  Two groups of one residue, or of one
+    molecule, are excluded by default.  On a 720-molecule box (1440 groups) at
+    a 0.5 nm radius it finds 358 candidates in half a second and packs 148
+    triples from them.
+  - A reaction bond that consumes no hydrogen is positioned by
+    `Molecule.place_for_addition` rather than `transrot`, which aligns two
+    reactants on the hydrogens they are about to lose and so cannot place an
+    addition at all: in a cyclotrimerization neither the cyanate carbon nor its
+    nitrogen carries one.  The new placement puts the incoming piece a bond
+    length away, in the direction and at the turn that leave the most room,
+    using one shared copy of that geometry in `geometry.placement`.
+  - `Molecule.close_ring_geometry` pulls a ring shut before its bonds exist,
+    by restraining every pair of the ring and stepping the restraints down to a
+    bond length under minimization.  The merged reactants' topology is already
+    valid for MD, and a type-6 restraint needs no atom types, so this needs
+    nothing parameterized.
+  - `Topology.set_restraint_parameters` prescribes a restraint's length and
+    stiffness outright.  `attenuate_bond_parameters` cannot serve here: it
+    reads each bond's reference values from the row it overwrites, which is
+    stable for a real bond, whose reference comes from its atom types, but
+    compounds on a restraint carrying explicit parameters -- an eight-stage
+    ladder ended 400 times too weak to pull anything.
+  - `core.productsplice.map_product_from_template` makes the residues of one
+    reaction event match a product template exactly -- atom types, charges, and
+    every bond, angle, dihedral and 1-4 pair among them, replacing the
+    instance's parameters where they exist and adding them where they do not.
+    This is what a ring closure needs and what the per-bond splice cannot do:
+    among the interactions a triazine closure changes are ones wholly inside a
+    residue (a cyanate C#N becoming a ring bond), which contain no new bond and
+    so are never revisited by `map_from_templates`.  It takes the residue
+    correspondence from its caller rather than inferring it from local context,
+    refuses a residue map that does not explain the bonds it was given, and
+    refuses by default to run before those bonds exist.
+
+### Fixed
+
+- **A ring cure now widens its search radius when an iteration is short of
+  rings, not only when it finds none.**  The pairwise cure has always grown its
+  radius within an iteration until it has `min_bonds_per_iteration` bonds; the
+  ring loop instead widened only after an iteration that found nothing at all.
+  A floppy monomer never noticed, but a rigid one keeps trickling one or two
+  rings at the starting radius, so the radius never grew: 150 bisphenol A
+  dicyanates stopped at conversion 0.40 after eight iterations, having asked for
+  0.60 and never once widened.  With the same rule the pairwise cure uses --
+  counted in rings, and clamped against the rings still needed to reach the
+  target -- the same system reaches 0.61 in eight iterations.  The floor is
+  `ring_cure: min_rings_per_iteration`, default 4.
+
+- **A GPU build died at its first minimization when the configuration set
+  `ntomp`.**  GROMACS refuses OpenMP threads together with a GPU unless it is
+  also told how many ranks to run: "Please specify the number of thread-MPI
+  ranks as well (option -ntmpi)."  Nothing supplied one, so every such build
+  failed about a minute in, after parameterization had already been paid for.
+  htpolynet now passes `-ntmpi 1` when a configuration asks for a GPU, sets
+  `ntomp`, and gives no rank count of its own.  A rank count in the
+  configuration (`ntmpi`, `nt` or `npme`) is left as it is, and so is an MPI
+  `mdrun`, which takes its ranks from `mpirun` or `srun` and rejects
+  `-ntmpi`.  Reported by htpolynet-study from a 9-task GPU build where every
+  task failed.
+
+- **`ntmpi` passed as a keyword argument to `grompp_and_mdrun` was dropped**,
+  because the passthrough list spelled it `ntpmi`.  Configurations were
+  unaffected: `mdrun_options` is copied whole.
+
+## [2.10.3] - 2026-09-17
+
+### Fixed
+
+- **The CPU and CUDA container images shipped different AmberTools.**  The
+  CUDA images, `:cuda-v2.10.0` through `:cuda-v2.10.2`, had AmberTools 24.8,
+  while the CPU images had 26.0. Nobody chose that: conda-forge can't install
+  AmberTools 26 alongside CUDA GROMACS, and the unpinned Dockerfile line fell
+  back silently. So the same configuration was parameterized by different
+  AmberTools releases depending on which image ran it. Both images now
+  install AmberTools in their own conda environment, pinned to one version
+  (26.0, set by the `AMBERTOOLS_VERSION` build argument). A future conflict
+  now fails the build instead of quietly downgrading.
+
+- **A cached parameterization is no longer reused across AmberTools
+  versions.**  The cache record now includes the AmberTools version, and a
+  run on a different version re-parameterizes instead of reusing the entry.
+  Records written before this, and runs that can't tell their version, still
+  match. A cache filled with a CUDA image up to v2.10.2 (AmberTools 24.8)
+  has no version in its records, so it would still be reused by a newer
+  image. Refill it if the charges must come from one AmberTools release.
+
 ## [2.10.2] - 2026-09-17
 
 ### Fixed
@@ -14,23 +186,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Templates for crowded monomers could start with atoms on top of each
   other, and AM1-BCC/ABCG2 charges then failed.**  When htpolynet built a
   linked-product template, it attached the incoming molecule along the new
-  bond but never turned it about that bond. Its clash check also compared the
-  moved piece with its own pre-move position. With tetramethylbisphenol F
-  (TMB), whose methyls flank each reacting oxygen, every triazine template
+  bond but never turned it about that bond. Its clash check also compared
+  the moved piece with its own pre-move position. With tetramethylbisphenol
+  F (TMB), whose methyls flank each reacting oxygen, every triazine template
   started with a methyl hydrogen 0.65-1.26 A from a ring atom. On one triply
-  substituted template, AmberTools 26's sqm then failed to converge ("Cannot
-  properly run sqm"), which stopped parameterization.
+  substituted template, sqm (AmberTools 24.8, as shipped in the `:cuda`
+  image) then failed to converge ("Cannot properly run sqm"), which stopped
+  parameterization.
 
   The placement now scans turns about the new bond, in 10 degree steps, and
   keeps the one farthest from the residues that stay put. Every TMB template
   now starts at 1.50 A or more. The six triply substituted TMB templates
-  were run with ABCG2 on AmberTools 26: five, including the geometry that
-  failed before, completed, and the sixth converged its SCF and was still
-  optimizing when this was written. On these crowded molecules the
-  optimization is slow, 40 minutes to 2.6 hours each, run three at a time. Charges and atom types of all 123
-  templates in the shipped examples, which use gas charges, are unchanged. A
-  template that still starts with a contact under 1 A is now logged as a
-  warning.
+  were run with ABCG2 on that same AmberTools 24.8: five, including the
+  geometry that failed before, completed, and the sixth converged its SCF
+  and was still optimizing when this was written. On these crowded molecules
+  the optimization is slow, 40 minutes to 2.6 hours each, run three at a
+  time. Charges and atom types of all 123 templates in the shipped examples,
+  which use gas charges, are unchanged. A template that still starts with a
+  contact under 1 A is now logged as a warning.
 
 ## [2.10.1] - 2026-09-16
 

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

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