htpolynet 2.10.0__tar.gz → 2.10.2__tar.gz

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

@@ -7,6 +7,58 @@ 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
+
+- **Asking for `pme: gpu` or `update: gpu` in `mdrun_options` stopped the
+  build at its first minimization.**  The same options go to every `mdrun`,
+  and GROMACS refuses both tasks on a GPU without a dynamical integrator.
+  For minimization stages they now become `auto`, and so does `bonded`, which
+  hasn't been checked with a minimizer.  Dynamics gets the options unchanged.
+
+- **The parameterization summary undercounted and named the wrong place.**
+  It was printed before the symmetry-, chain- and second-shell-derived
+  templates were built, so a run that reused 29 templates reported 11.  It
+  also always named `~/.htpolynet`, even when `HTPOLYNET_CACHE` pointed
+  elsewhere.  It now comes after every template exists, reports "N of M
+  reused", and names the library and cache actually searched.
+
+### Changed
+
+- **The "percolation not assessed" message says when it means "cannot
+  assess".**  It read as though the outcome were always the correct answer
+  for a linear polymer, with the multi-residue crosslinker case as an aside.
+  For example 2 that aside is the actual situation: bis-GMA crosslinks
+  through junctions a residue-level count cannot see.  Noticed by a sweep of
+  the shipped examples.
+
+
 ## [2.10.0] - 2026-09-15
 
 ### Added

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

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

@@ -199,6 +199,20 @@ Coverage as of the last measurement: **38.8%** overall.
 
 ## Cure and repair
 
+- **Chain-growth cure leaves whole chains charged.**  The v2.10.0 sweep's new
+  molecule-charge check found example 1's polystyrene warning: 7 of 49 chains
+  over 0.01 e, the largest -0.040 e on the longest (1410-atom) chain, with the
+  system total exactly 0.  htpolynet-sweep measured the same scale in the two
+  preceding sweeps (9 of 49, largest -0.022 and -0.025 e), so it predates the
+  check, which merely exposed it.  It is about 2-3e-5 e per atom, i.e. a little
+  charge per chain-growth bond, which points at the same system-wide
+  `adjust_charges` as the item below.  Small enough not to matter much per
+  atom, but it scales with chain length, so the longest chain is the worst
+  off.  The fix is the per-molecule settle below; what is not yet known is
+  whether the residual comes from the templates disagreeing with their
+  instances (a `STY~C1-C2~STY` bond in a long chain is not quite the trimer
+  template) or only from the system-wide spread.  Measure before fixing.
+
 - **Cure still settles template overcharge system-wide.**
   `map_from_templates` ends each batch of bonds with one `adjust_charges`
   over every mapped atom in the system.  When the templates are consistent
@@ -936,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
@@ -951,6 +975,17 @@ Coverage as of the last measurement: **38.8%** overall.
 
 ## Simulation defaults
 
+- **The density-convergence tolerance may be tight for example 6.**  In the
+  v2.10.0 sweep, example 6 failed the gate for the first time in four sweeps:
+  "sem 1.070 exceeds tolerance 1.000" after 6 extensions, with the last window
+  at 1112.0 kg/m^3 against 1110.5 and 1111.6 in the two sweeps that converged
+  with no extension at all.  Monomer charges were byte-identical to the
+  previous sweep, so this is run-to-run noise rather than a change -- but the
+  build went on into the cure from a box the gate had just called unsettled,
+  and said so only in a warning.  Worth deciding whether the tolerance should
+  scale with system size or window length, and whether failing it should be
+  more than a warning.
+
 - **The halogen constraint failure is fixed but not explained.** v2.7.0
   switched the per-iteration equilibration to `constraints = h-bonds` with
   `lincs_order = 8`, which took a fluorinated bisphenol from 0 of 7 builds to

{htpolynet-2.10.0 → htpolynet-2.10.2}/docs/source/user-guide/container-usage.rst

@@ -234,6 +234,36 @@ them.  Confirm from its GPU banner rather than assuming: if the banner still
 says ``unusable``, you are running the default image under a ``:cuda`` name,
 or the container was not given a device.
 
+Choosing mdrun GPU tasks
+""""""""""""""""""""""""
+
+``gromacs.mdrun_options`` in the configuration is passed to every ``mdrun``
+htpolynet runs for the system: densification, precure, every cure stage,
+repair, and postcure.  ``htpolynet postsim`` and ``htpolynet analyze`` use it
+too, but only when given the build's configuration with ``-ocfg``.  Each key
+becomes a flag, so this
+
+.. code-block:: yaml
+
+  gromacs:
+    mdrun_options:
+      nb: gpu
+      ntomp: 8
+
+runs ``mdrun -nb gpu -ntomp 8``.  With the short-range work on the GPU,
+Gromacs 2026's ``auto`` choices also put PME and the coordinate update on the
+GPU wherever they can.  Bonded interactions are the exception: ``auto`` keeps
+them on the CPU when PME is on the GPU, so add ``bonded: gpu`` to move them.
+The task-assignment lines near the top of each run's ``.log`` say where each
+task ran.
+
+Many of those runs are energy minimizations, and Gromacs refuses
+``-pme gpu`` and ``-update gpu`` for a minimizer.  htpolynet therefore passes
+``auto`` for ``pme``, ``update`` and ``bonded`` whenever the stage's
+integrator is not a dynamical one, so asking for them explicitly is safe.  Everything the cure uses
+otherwise (Berendsen coupling, h-bond constraints with LINCS, simulated
+annealing) is supported with the update on the GPU.
+
 .. note::
 
   The ``:cuda`` image is substantially larger, because the CUDA build of

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

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

{htpolynet-2.10.0 → 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.0 → htpolynet-2.10.2}/src/htpolynet/core/runtime.py

@@ -195,6 +195,28 @@ class Runtime:
                     if k not in current:
                         current[k]=v
 
+    def _report_parameterization_summary(self):
+        """Logs how many molecule templates were reused and how many were parameterized.
+
+        Counted after every derived template (symmetry, C=C chain, and
+        second-shell) exists, so the numbers cover everything this run needs;
+        a job that must not parameterize anything, e.g. one reading a
+        pre-filled read-only cache, can check for "0 freshly parameterized".
+        """
+        n_cached=sum(1 for M in self.molecules.values() if M.origin=='previously parameterized')
+        n_new=sum(1 for M in self.molecules.values() if (M.origin or '').startswith('newly parameterized'))
+        if not (n_cached or n_new): return
+        where=[]
+        if pfs._PFS_ and pfs._PFS_.userlibrary:
+            where.append(f'{pfs._PFS_.userlibrary.root}')
+        if pfs._USER_CACHE_ is not None:
+            where.append(f'{pfs._USER_CACHE_.root}')
+        logger.info(f'Parameterization summary: {n_cached} of {n_cached+n_new} molecule templates reused from the library '
+                    f'({" or ".join(where) or "unknown location"}), {n_new} freshly parameterized.')
+        if n_cached:
+            logger.info('  to force re-parameterization on the next run, use '
+                        '`htpolynet run --force-parameterization --force-checkin ...`')
+
     def _read_frcmods(self):
         """Reads the user frcmod file each constituent names, if any.
 
@@ -357,18 +379,6 @@ class Runtime:
         logger.debug(f'Generating: {list(self.molecules.keys())}')
         for mname,M in self.molecules.items():
             self._generate_molecule(M,force_parameterization=force_parameterization,force_checkin=force_checkin)
-        n_cached=sum(1 for M in self.molecules.values() if M.origin=='previously parameterized')
-        n_new=sum(1 for M in self.molecules.values() if M.origin=='newly parameterized')
-        if n_cached or n_new:
-            logger.info(
-                f'Parameterization summary: {n_cached} reused from cache '
-                f'(~/.htpolynet/molecules/parameterized/), {n_new} freshly parameterized.'
-            )
-            if n_cached:
-                logger.info(
-                    '  to force re-parameterization on the next run, use '
-                    '`htpolynet run --force-parameterization --force-checkin ...`'
-                )
         new_reactions,new_molecules=bondchain_expand_reactions(self.molecules)
         if len(new_molecules)>0:
             ess='' if len(new_molecules)==1 else 's'
@@ -392,6 +402,7 @@ class Runtime:
                 self.molecules[mname]=M
                 logger.debug(f'Generated {mname}')
 
+        self._report_parameterization_summary()
         self._check_frcmod_type_conflicts()
 
         for M in self.molecules:

{htpolynet-2.10.0 → htpolynet-2.10.2}/src/htpolynet/cure/curecontroller.py

@@ -890,7 +890,13 @@ class CureController:
         # monomer was mid-chain.
         if fmax<3:
             if mask is not None:
-                logger.info('No residue carries three or more cure-reactive sites, so crosslink percolation is not assessed. That is correct for a linear polymer; a system that crosslinks through a multi-residue molecule -- a dimethacrylate, a multi-arm prepolymer -- is outside what this residue-level check can see.')
+                logger.info('Crosslink percolation was not assessed: no residue carries three or more '
+                            'cure-reactive sites. For a chain polymer that is the answer -- a fully reacted '
+                            'difunctional unit is a chain interior, not a junction. But a system that '
+                            'crosslinks through a multi-residue molecule, such as a dimethacrylate built from '
+                            'a bisphenol and two methacrylates, does percolate through junctions this '
+                            'residue-level count cannot see, and there this line means "cannot assess", not '
+                            '"does not percolate".')
             return
         names=adf.loc[adf['resNum']==func.idxmax(),'resName']
         resname=names.iloc[0] if len(names) else f'residue {func.idxmax()}'

{htpolynet-2.10.0 → htpolynet-2.10.2}/src/htpolynet/external/gromacs.py

@@ -60,6 +60,56 @@ def insert_molecules(composition,boxSize,outName,inputs_dir='.',**kwargs):
                     logger.debug(l)
                 raise Exception('need bigger box')
 
+_DYNAMICAL_INTEGRATORS_ = ('md', 'md-vv', 'md-vv-avek', 'sd', 'bd')
+"""GROMACS integrators that do dynamics; the rest (steep, cg, l-bfgs, nm, tpi, ...) do not."""
+
+_DYNAMICS_ONLY_GPU_TASKS_ = ('pme', 'update', 'bonded')
+"""mdrun tasks not forced onto a GPU without a dynamical integrator.
+
+GROMACS refuses ``-pme gpu`` and ``-update gpu`` with a minimizer.  Whether it
+accepts ``-bonded gpu`` there has not been checked, and a minimization is
+cheap enough that running its bonded work on the CPU costs nothing that matters.
+"""
+
+
+def mdp_integrator(mdp_filename):
+    """Returns the integrator an mdp file selects, lower-cased; 'md' if it does not say.
+
+    Args:
+        mdp_filename (str): mdp file name
+
+    Returns:
+        str: integrator name
+    """
+    value = mdp_to_dict(mdp_filename).get('integrator', 'md')
+    return value.split(';')[0].strip().lower() or 'md'
+
+
+def mdrun_options_for(mdrun_options, integrator):
+    """Returns the mdrun options to use with a given integrator.
+
+    One ``gromacs.mdrun_options`` serves every stage of a build, minimizations
+    included.  GROMACS stops with a fatal error when ``-pme gpu`` or
+    ``-update gpu`` is given with a minimizer, so for a minimizer these, and
+    ``-bonded gpu``, become ``auto``.  Dynamics gets the options unchanged.
+
+    Args:
+        mdrun_options (dict): options from the configuration
+        integrator (str): the mdp's integrator
+
+    Returns:
+        dict: options to pass to mdrun
+    """
+    if integrator in _DYNAMICAL_INTEGRATORS_:
+        return mdrun_options
+    adjusted = dict(mdrun_options)
+    for task in _DYNAMICS_ONLY_GPU_TASKS_:
+        if str(adjusted.get(task, '')).lower() == 'gpu':
+            adjusted[task] = 'auto'
+            logger.debug(f'integrator {integrator} cannot run {task} on the GPU; passing -{task} auto for this run')
+    return adjusted
+
+
 def grompp_and_mdrun(gro='',top='',out='',mdp='',boxSize=[],single_molecule=False,**kwargs):
     """Launcher for grompp and mdrun.
 
@@ -75,7 +125,7 @@ def grompp_and_mdrun(gro='',top='',out='',mdp='',boxSize=[],single_molecule=Fals
     quiet=kwargs.get('quiet',True)
     ignore_codes=kwargs.get('ignore_codes',[-11])
     maxwarn=kwargs.get('maxwarn',4)
-    mdrun_options=kwargs.get('mdrun_options',{})
+    mdrun_options=dict(kwargs.get('mdrun_options',{}))
     for option in ['rdd','dds','dlb','npme','nt','ntpmi','ntomp','ntomp_pme','nb','tunepme','pme','pmefft','bonded','update']:
         if option in kwargs and not option in mdrun_options:
             mdrun_options[option]=kwargs[option]
@@ -91,6 +141,7 @@ def grompp_and_mdrun(gro='',top='',out='',mdp='',boxSize=[],single_molecule=Fals
         run(f'{sw.gmx} {sw.gmx_options} editconf -f {gro}.gro -o {gro} -box {box_str}', quiet=quiet)
     # nsteps=kwargs.get('nsteps',-2)
     run(f'{sw.gmx} {sw.gmx_options} grompp -f {mdp}.mdp -c {gro}.gro -p {top}.top -o {out}.tpr -maxwarn {maxwarn}', quiet=quiet)
+    mdrun_options = mdrun_options_for(mdrun_options, mdp_integrator(f'{mdp}.mdp'))
     if 'gpu_id' in mdrun_options:
         unusable = sw.gpu_unusable_reasons()
         if unusable:

htpolynet-2.10.2/tests/unit/test_mdrun_gpu_options.py

@@ -0,0 +1,49 @@
+"""
+
+.. module:: test_mdrun_gpu_options
+   :synopsis: one set of mdrun GPU options must work for minimizations as well as dynamics
+
+.. moduleauthor: Cameron F. Abrams, <cfa22@drexel.edu>
+
+"""
+from importlib.resources import files
+
+import pytest
+
+from htpolynet.external.gromacs import mdp_integrator, mdrun_options_for
+
+GPU = {'nb': 'gpu', 'pme': 'gpu', 'bonded': 'gpu', 'update': 'gpu', 'ntomp': 8}
+
+
+class TestMdrunOptionsFor:
+    def test_dynamics_keeps_everything(self):
+        assert mdrun_options_for(GPU, 'md') == GPU
+
+    @pytest.mark.parametrize('integrator', ['steep', 'cg', 'l-bfgs'])
+    def test_minimizer_downgrades_only_what_gromacs_rejects(self, integrator):
+        got = mdrun_options_for(GPU, integrator)
+        assert got['pme'] == 'auto' and got['update'] == 'auto' and got['bonded'] == 'auto'
+        assert got['nb'] == 'gpu' and got['ntomp'] == 8
+
+    def test_explicit_cpu_is_left_alone(self):
+        assert mdrun_options_for({'pme': 'cpu', 'update': 'cpu'}, 'steep') == {'pme': 'cpu', 'update': 'cpu'}
+
+    def test_the_configuration_is_not_mutated(self):
+        opts = dict(GPU)
+        mdrun_options_for(opts, 'steep')
+        assert opts == GPU
+
+
+class TestMdpIntegrator:
+    mdp = files('htpolynet.resources') / 'mdp'
+
+    @pytest.mark.parametrize('name,expected', [('min', 'steep'), ('drag-min', 'steep'), ('relax-min', 'steep'),
+                                               ('npt', 'md'), ('relax-nvt', 'md')])
+    def test_shipped_mdps(self, name, expected):
+        # min.mdp writes "integrator = steep;" with the semicolon attached
+        assert mdp_integrator(str(self.mdp / f'{name}.mdp')) == expected
+
+    def test_absent_means_md(self, tmp_path):
+        f = tmp_path / 'x.mdp'
+        f.write_text('nsteps = 10\n')
+        assert mdp_integrator(str(f)) == 'md'

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)