htpolynet 2.10.1__tar.gz → 2.10.2__tar.gz

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

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.10.2] - 2026-09-17
+
+### Fixed
+
+- **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
+  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.
+
+  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.
+
 ## [2.10.1] - 2026-09-16
 
 ### Fixed

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: htpolynet
-Version: 2.10.1
+Version: 2.10.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.10.1 → htpolynet-2.10.2}/ROADMAP.md

@@ -950,6 +950,16 @@ Coverage as of the last measurement: **38.8%** overall.
   for any operand that lacks the table, rather than concatenating a partial
   table. Bond orders would then need the same single-bond assumption.
 
+  **It has appeared (2026-09-17).** Example 2's stereoisomer copies `GMAS-*`
+  have 78 bonds in their topology but only 24 in their `.mol2`, in the
+  2026-09-14 sweep's files too. It shows up only when a cache is *reused*:
+  `bond_source_check` then logs "Gromacs/Mol2 bond inconsistency detected"
+  once per copy. Sweeps always start from an empty cache, so they never see
+  it. `generate_stereoisomers` deep-copies the parent's TopoCoord and writes
+  only a `.gro`; where the 24-bond `.mol2` comes from is not yet traced. What
+  a reused cache does with the wrong table (ring detection, system `.mol2`
+  output) is also unknown. No cyanate-ester molecule has stereoisomer copies.
+
 - **Two gaps left after the percolation check moved to cure sites
   (2026-09-15).**  First, a system that crosslinks through a *multi-residue*
   molecule -- example 2's GMA (two methacrylate HIE units), example 5's

{htpolynet-2.10.1 → htpolynet-2.10.2}/pyproject.toml

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

{htpolynet-2.10.1 → htpolynet-2.10.2}/src/htpolynet/core/molecule.py

@@ -51,6 +51,46 @@ def _yield_bonds_as_df(R: Reaction, TC: TopoCoord, resid_mapper) -> pd.DataFrame
                      'order': bondrec['order'], 'reactantName': R.product})
     return pd.DataFrame(rows)
 
+_TRANSROT_STEP_DEG_ = 10.0
+"""Angular step of the turn scan in Molecule.transrot."""
+
+_TRANSROT_WARN_NM_ = 0.10
+"""Closest approach, in nm, below which a template's starting geometry is reported as crowded.
+
+Contacts of 1.2-1.5 A between the new piece and the rest are routine before
+minimization; below 1 A they have been seen to stop sqm converging (a TMB ring
+methyl H 0.82 A from a triazine N).
+"""
+
+
+def _rotate_about_axis(xyz, point, axis, theta):
+    """Rotates points by theta about the line through point along unit vector axis (Rodrigues).
+
+    Args:
+        xyz (numpy.ndarray): (n, 3) positions
+        point (numpy.ndarray): a point on the axis
+        axis (numpy.ndarray): unit vector along the axis
+        theta (float): angle in radians
+
+    Returns:
+        numpy.ndarray: rotated (n, 3) positions
+    """
+    if theta == 0.0:
+        return xyz.copy()
+    k = axis / np.linalg.norm(axis)
+    K = np.array([[0, -k[2], k[1]], [k[2], 0, -k[0]], [-k[1], k[0], 0]])
+    R = np.eye(3) + np.sin(theta) * K + (1.0 - np.cos(theta)) * (K @ K)
+    return (xyz - point) @ R.T + point
+
+
+def _min_distance(a, b):
+    """Smallest distance between any point of a and any point of b; inf if either is empty."""
+    if len(a) == 0 or len(b) == 0:
+        return np.inf
+    diff = a[:, np.newaxis, :] - b[np.newaxis, :, :]
+    return float(np.sqrt((diff * diff).sum(axis=2)).min())
+
+
 class Molecule:
     def __init__(self, name='', generator:Reaction=None, origin:str=None):
         self.name = name
@@ -830,7 +870,16 @@ class Molecule:
         Rj = TC.get_R(from_idx)
         logger.debug(f'Ri {at_idx} {Ri} {type(Ri)} {Ri.dtype}')
         logger.debug(f'Rj {from_idx} {Rj} {type(Rj)} {Rj.dtype}')
-        overall_maximum = (-1.e9, -1, -1)
+        # The two sacrificial H's are made to coincide, which puts at_idx, the H's
+        # and from_idx on one line.  The moving piece can still turn freely about
+        # that line, and that freedom is what clears a crowded site: a third
+        # tetramethyl bisphenol on a triazine lands its ortho methyl inside the
+        # ring at the unrotated placement.  So each H pairing is tried at a
+        # range of turns, and the one farthest from the residues that stay put
+        # wins.  (Measuring against all of TC would include the moving piece's
+        # own pre-move positions.)
+        fixed = C[~C['resNum'].isin(bresids)]
+        overall_maximum = (-1.e9, -1, -1, 0.0)
         coord_trials = {}
         for myH, myHnm in myHpartners.items():  # keys are globalIdx's, values are names
             coord_trials[myH] = {}
@@ -838,17 +887,13 @@ class Molecule:
             logger.debug(f'  Rh {myH} {Rh} {Rh.dtype}')
             Rih = Ri - Rh
             Rih *= 1.0 / np.linalg.norm(Rih)
+            fixed_xyz = fixed.loc[fixed['globalIdx'] != myH, ['posX', 'posY', 'posZ']].to_numpy(dtype=float)
             for otH, otHnm in otHpartners.items():
                 logger.debug(f'{self.name}: Considering {myH} {otH}')
-                coord_trials[myH][otH] = deepcopy(BTC)
-                # logger.debug(f'\n{coord_trials[myH][otH].Coordinates.A.to_string()}')
-                Rk = coord_trials[myH][otH].get_R(otH)
-                logger.debug(f'{self.name}:    otH {otH} Rk {Rk} {Rk.dtype}')
+                aligned = deepcopy(BTC)
+                Rk = aligned.get_R(otH)
                 Rkj = Rk - Rj
                 Rkj *= 1.0 / np.linalg.norm(Rkj)
-                logger.debug(f'Rkj {Rkj} {Rkj.dtype} Rih {Rih} {Rih.dtype}')
-                #Rhk=Rh-Rk
-                #rhk=np.linalg.norm(Rhk)
                 cp = np.cross(Rkj,Rih)
                 c = np.dot(Rkj,Rih)
                 v = np.array([[0,-cp[2],cp[1]],[cp[2],0,-cp[0]],[-cp[1],cp[0],0]])
@@ -856,19 +901,31 @@ class Molecule:
                 I = np.array([[1.,0.,0.],[0.,1.,0.],[0.,0.,1.]])
                 # R is the rotation matrix that will rotate donb to align with accb
                 R = I + v + v2 / (1. + c)
-                # logger.debug(f'{self.name}: R:\n{R}')
-                # rotate translate all donor atoms!
-                coord_trials[myH][otH].rotate(R)
-                Rk = coord_trials[myH][otH].get_R(otH)
+                aligned.rotate(R)
+                Rk = aligned.get_R(otH)
                 # overlap the two H atoms by translation
-                Rik = Rh - Rk
-                coord_trials[myH][otH].translate(Rik)
-                minD = TC.minimum_distance(coord_trials[myH][otH], self_excludes=[myH], other_excludes=[otH])
-                logger.debug(f'{self.name}: minD {minD}')
+                aligned.translate(Rh - Rk)
+                A = aligned.Coordinates.A
+                moving_mask = (A['globalIdx'] != otH).to_numpy()
+                xyz = A[['posX', 'posY', 'posZ']].to_numpy(dtype=float)
+                best = None
+                for theta in np.deg2rad(np.arange(0.0, 360.0, _TRANSROT_STEP_DEG_)):
+                    trial = _rotate_about_axis(xyz, Rh, Rih, theta)
+                    minD = _min_distance(trial[moving_mask], fixed_xyz)
+                    if best is None or minD > best[0]:
+                        best = (minD, theta, trial)
+                minD, theta, trial = best
+                A[['posX', 'posY', 'posZ']] = trial
+                coord_trials[myH][otH] = aligned
+                logger.debug(f'{self.name}: {myH}/{otH} best turn {np.rad2deg(theta):.0f} deg, minD {minD}')
                 if minD > overall_maximum[0]:
-                    overall_maximum = (minD, myH, otH)
+                    overall_maximum = (minD, myH, otH, theta)
         logger.debug(f'{self.name}: overall_maximum {overall_maximum}')
-        minD, myH, otH = overall_maximum
+        minD, myH, otH, _ = overall_maximum
+        if minD < _TRANSROT_WARN_NM_:
+            logger.warning(f'{self.name}: the best placement found for the new bond still leaves two atoms '
+                           f'{minD*10:.2f} A apart; a semi-empirical charge method (bcc, abcg2) may fail to converge '
+                           f'on this starting geometry')
         BTC = coord_trials[myH][otH]
         TC.overwrite_coords(BTC)
         TC.swap_atom_names(myH, list(myHighestH.keys())[0])

htpolynet-2.10.2/tests/unit/test_transrot_turn_scan.py

@@ -0,0 +1,66 @@
+"""
+
+.. module:: test_transrot_turn_scan
+   :synopsis: template placement turns the incoming piece to clear crowded sites
+
+.. moduleauthor: Cameron F. Abrams, <cfa22@drexel.edu>
+
+"""
+import numpy as np
+import pytest
+
+from htpolynet.core.molecule import _min_distance, _rotate_about_axis
+
+
+class TestRotateAboutAxis:
+    def test_quarter_turn_about_z(self):
+        got = _rotate_about_axis(np.array([[1.0, 0.0, 0.0]]), np.zeros(3), np.array([0.0, 0.0, 1.0]), np.pi / 2)
+        assert np.allclose(got, [[0.0, 1.0, 0.0]])
+
+    def test_points_on_the_axis_stay_put(self):
+        pts = np.array([[1.0, 2.0, 3.0], [1.0, 2.0, 5.0]])
+        got = _rotate_about_axis(pts, np.array([1.0, 2.0, 0.0]), np.array([0.0, 0.0, 2.0]), 1.234)
+        assert np.allclose(got, pts)
+
+    def test_axis_through_an_offset_point(self):
+        got = _rotate_about_axis(np.array([[2.0, 0.0, 0.0]]), np.array([1.0, 0.0, 0.0]), np.array([0.0, 0.0, 1.0]), np.pi)
+        assert np.allclose(got, [[0.0, 0.0, 0.0]])
+
+    def test_distances_are_preserved(self):
+        rng = np.random.default_rng(1)
+        pts = rng.normal(size=(6, 3))
+        got = _rotate_about_axis(pts, rng.normal(size=3), rng.normal(size=3), 0.7)
+        d0 = np.linalg.norm(pts[:, None] - pts[None], axis=2)
+        d1 = np.linalg.norm(got[:, None] - got[None], axis=2)
+        assert np.allclose(d0, d1)
+
+    def test_zero_turn_is_a_copy(self):
+        pts = np.ones((2, 3))
+        got = _rotate_about_axis(pts, np.zeros(3), np.array([1.0, 0.0, 0.0]), 0.0)
+        got[0, 0] = 9.0
+        assert pts[0, 0] == 1.0
+
+
+class TestMinDistance:
+    def test_closest_pair(self):
+        a = np.array([[0.0, 0.0, 0.0], [5.0, 0.0, 0.0]])
+        b = np.array([[0.0, 3.0, 0.0], [5.0, 0.5, 0.0]])
+        assert _min_distance(a, b) == pytest.approx(0.5)
+
+    def test_empty_is_infinite(self):
+        assert _min_distance(np.empty((0, 3)), np.zeros((1, 3))) == np.inf
+
+
+class TestTurnScanClearsAClash:
+    def test_the_best_turn_moves_a_substituent_off_an_occupied_site(self):
+        # one arm of a piece bonded along the z axis; a fixed atom sits where the arm points at 0 deg
+        piece = np.array([[0.15, 0.0, 0.35]])
+        fixed = np.array([[0.15, 0.0, 0.36]])
+        scores = []
+        for theta in np.deg2rad(np.arange(0, 360, 10)):
+            scores.append((_min_distance(_rotate_about_axis(piece, np.zeros(3), np.array([0, 0, 1.0]), theta), fixed),
+                           theta))
+        best = max(scores)
+        assert scores[0][0] < 0.02
+        assert best[0] > 0.25
+        assert np.isclose(best[1], np.pi)