htpolynet 2.9.0__tar.gz → 2.10.0__tar.gz

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

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.10.0] - 2026-09-15
+
+### Added
+
+- **A constituent can carry its own frcmod.**  `frcmod: file.frcmod` on a
+  constituent loads that Amber parameter file into `tleap` after GAFF and
+  `parmchk2`, so its parameters override theirs.  It is loaded for the
+  molecule and for every template containing it, including cure, capping,
+  repair and multiply-substituted templates.  The file's contents are part of
+  the parameter cache record, so an edited frcmod re-parameterizes instead of
+  reusing stale numbers.  A system has one table per bonded type, so setup
+  stops with the type's name if an overridden type also appears, with other
+  parameters, in a molecule built without the file.
+
 ## [2.9.0] - 2026-09-15
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: htpolynet
-Version: 2.9.0
+Version: 2.10.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/

{htpolynet-2.9.0 → htpolynet-2.10.0}/docs/source/user-guide/configs/configs-for-run.rst

@@ -98,8 +98,35 @@ In this section we show all subdirectives for each of the five main directives i
     ``smiles``                               string             (optional) SMILES for in-config monomer generation; htpolynet runs ``obabel`` (or RDKit) to materialize ``lib/molecules/inputs/<NAME>.mol2`` before parameterization
     ``rename_atoms``                         dict               (optional) ``{1-based-mol2-index: atom-name}`` map applied after obabel writes the mol2 (obabel path; pairs with ``smiles``)
     ``reactive_atoms``                       dict               (optional) ``{smiles-atom-map-label: atom-name}`` map (RDKit path; pairs with a ``smiles`` that uses ``[*:N]`` atom-mapping tokens).  ``rdkit`` is a required runtime dependency and is pulled in by any normal ``htpolynet`` install
+    ``frcmod``                               string             (optional) path, relative to the configuration file, to an Amber ``frcmod`` of parameter overrides for this molecule; see below
     =====================================    =================  =====================
 
+    ``frcmod`` corrects GAFF for one monomer without touching the others, for
+    example a torsion refit against quantum-chemical scans.  ``tleap`` loads
+    the file after GAFF and ``parmchk2``, so its entries win.  It is loaded
+    for the molecule itself and for every template that contains it: cure
+    products, capping and repair templates, and the multiply-substituted
+    templates htpolynet derives.  The file's contents are part of each of
+    those parameterizations' cache records, so editing it re-parameterizes
+    them on the next run rather than reusing the old numbers.
+
+    .. code-block:: yaml
+
+       constituents:
+         BAF:
+           smiles: "FC(F)(F)C(c1ccc([OH:1])cc1)(c1ccc([OH:2])cc1)C(F)(F)F"
+           reactive_atoms: {1: O1, 2: O2}
+           frcmod: baf-torsion.frcmod
+
+    One restriction follows from how GROMACS topologies work.  A system holds
+    one parameter table per bonded *type* (four atom types, for a dihedral),
+    shared by every molecule in it.  So an override cannot apply to a type in
+    one molecule and leave the same type alone in another: if a molecule
+    built without the frcmod also contains the overridden type, with
+    different parameters, setup stops and names it.  Either load the same
+    frcmod for every constituent that contains the type, or give the atoms
+    you want to treat differently their own atom type.
+
     In the example below, we are requesting a system of 100 styrene molecules.  The key ``STY`` signals to ``htpolynet`` that it should look for either ``STY.mol2`` or ``STY.pdb`` in ``./lib/molecules/inputs`` **or** it should look for ``STY.gro``, ``STY.itp``, ``STY.top``, and ``STY.grx`` in ``./lib/molecules/parameterized``.  The latter is the case if either ``htpolynet run`` or ``htpolynet parameterized`` has already been run with ``STY.mol2`` or ``STY.pdb``.  If neither set of files is found but the constituent carries a ``smiles`` key, ``htpolynet`` generates the input ``mol2`` itself.  Multiple records in ``constituents`` should all have the "key":"record" syntax and be separated by commas.
 
     Any entry in ``constituents`` for which the ``count`` is 0 or missing is treated as an intermediate for which stereocenters or symmetry-equivalent atoms are specified.

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

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

{htpolynet-2.9.0 → htpolynet-2.10.0}/src/htpolynet/core/paramcache.py

@@ -17,6 +17,7 @@ libraries keep working rather than silently re-parameterizing wholesale.
 
 Author: Cameron F. Abrams <cfa22@drexel.edu>
 """
+import hashlib
 import json
 import logging
 import os
@@ -33,6 +34,30 @@ _KEY_FIELDS = (
 )
 """Fields that determine the parameters, with human-readable labels."""
 
+FRCMOD_FIELD = 'frcmod'
+"""Record field holding a digest of the user frcmod files loaded after parmchk2's.
+
+Written only when a molecule has any, so records of molecules without one are
+unchanged; its absence means "none" when compared.
+"""
+
+
+def frcmod_digest(frcmods):
+    """Returns a digest identifying a list of user frcmod files by content.
+
+    Args:
+        frcmods (list): (label, text) tuples, in load order
+
+    Returns:
+        str or None: hex digest, or None if the list is empty
+    """
+    if not frcmods:
+        return None
+    h = hashlib.sha256()
+    for label, text in frcmods:
+        h.update(label.encode('utf-8') + b'\0' + text.encode('utf-8') + b'\0')
+    return h.hexdigest()[:16]
+
 
 def build_key(ambertools=None):
     """Returns the provenance record describing a parameterization run under
@@ -49,8 +74,12 @@ def build_key(ambertools=None):
     """
     from ..external.ambertools import AMBERTOOLS_DEFAULTS
     ambertools = ambertools or {}
-    return {field: ambertools.get(field, AMBERTOOLS_DEFAULTS[field])
-            for field, _ in _KEY_FIELDS}
+    key = {field: ambertools.get(field, AMBERTOOLS_DEFAULTS[field])
+           for field, _ in _KEY_FIELDS}
+    digest = frcmod_digest(ambertools.get(FRCMOD_FIELD))
+    if digest:
+        key[FRCMOD_FIELD] = digest
+    return key
 
 
 def key_filename(prefix):
@@ -129,4 +158,8 @@ def describe_mismatch(stored, requested):
             continue
         if stored[field] != requested.get(field):
             diffs.append(f'{label} {stored[field]!r} cached, {requested.get(field)!r} requested')
+    # unlike the fields above, an absent frcmod digest is a statement: none was loaded
+    if stored.get(FRCMOD_FIELD) != requested.get(FRCMOD_FIELD):
+        diffs.append(f'user frcmod {stored.get(FRCMOD_FIELD) or "none"} cached, '
+                     f'{requested.get(FRCMOD_FIELD) or "none"} requested')
     return diffs

{htpolynet-2.9.0 → htpolynet-2.10.0}/src/htpolynet/core/runtime.py

@@ -20,7 +20,7 @@ from ..core import projectfilesystem as pfs
 from ..core.configuration import Configuration
 from ..core.molecule import Molecule, MoleculeDict
 from ..core.topocoord import TopoCoord
-from ..core.topology import select_topology_type_option
+from ..core.topology import conflicting_types, select_topology_type_option
 from ..cure.chain import ChainManager
 from ..cure.curecontroller import CureController, CureState
 from ..cure.expandreactions import bondchain_expand_reactions, generate_stereo_reactions, generate_symmetry_reactions, sibling_expand_reactions
@@ -150,6 +150,7 @@ class Runtime:
         self.restart=restart
         if restart:
             logger.info(f'Restarting in {pfs.proj()}')
+        self.frcmods=self._read_frcmods()
         self.molecules:MoleculeDict={}
         # molecules reused from a library entry that carries no provenance
         # record, collected for a stage-end summary; see generate_molecules
@@ -194,6 +195,66 @@ class Runtime:
                     if k not in current:
                         current[k]=v
 
+    def _read_frcmods(self):
+        """Reads the user frcmod file each constituent names, if any.
+
+        Returns:
+            dict: {constituent name: frcmod text}
+
+        Raises:
+            FileNotFoundError: if a named frcmod file does not exist
+        """
+        frcmods={}
+        for name,rec in (self.cfg.constituents or {}).items():
+            fn=(rec or {}).get('frcmod')
+            if not fn: continue
+            path=os.path.join(pfs.root(),fn)
+            if not os.path.isfile(path):
+                raise FileNotFoundError(f'frcmod {fn!r} for constituent {name} not found (looked for {path})')
+            with open(path) as f:
+                frcmods[name]=f.read()
+            logger.info(f'{name}: user frcmod {fn} will be loaded for {name} and every template containing it')
+        return frcmods
+
+    def _ambertools_for(self,M:Molecule):
+        """Returns the AmberTools directives for parameterizing M.
+
+        These are the configuration's, plus the user frcmod files of every
+        constituent residue M contains, so that a template built around a
+        monomer carries the same override as the monomer.
+
+        Args:
+            M (Molecule): molecule about to be parameterized, or checked against the cache
+
+        Returns:
+            dict: ambertools directives
+        """
+        amb=dict(self.cfg.ambertools or {})
+        residues=set(getattr(M,'sequence',None) or [M.name])
+        frc=[(n,t) for n,t in sorted(getattr(self,'frcmods',{}).items()) if n in residues]
+        if frc:
+            amb['frcmod']=frc
+        return amb
+
+    def _check_frcmod_type_conflicts(self):
+        """Refuses a set of molecules that a user frcmod leaves with conflicting bonded types.
+
+        Raises:
+            RuntimeError: if a type is parameterized differently in molecules built with and
+                without (or with different) user frcmod files
+        """
+        if not getattr(self,'frcmods',None): return
+        tops={n:(M.TopoCoord.Topology,paramcache.frcmod_digest(self._ambertools_for(M).get('frcmod')))
+              for n,M in self.molecules.items() if M.TopoCoord.Topology.D.get('atoms') is not None}
+        conflicts=conflicting_types(tops)
+        if not conflicts: return
+        for typename,key,a,b in conflicts[:10]:
+            logger.error(f'{typename} {"-".join(key[:-1])} (func {key[-1]}) differs between {a} and {b}')
+        raise RuntimeError(f'{len(conflicts)} bonded type(s) are parameterized differently in molecules built with and '
+                           f'without a user frcmod.  A system has one table per type, so the override cannot apply to '
+                           f'some molecules and not others.  Give the overridden atoms their own atom type, or apply '
+                           f'the frcmod to every constituent that contains the type.')
+
     def _build_molecules_and_reactions(self):
         """Builds Molecule and Reaction objects from the parsed configuration.
 
@@ -331,6 +392,8 @@ class Runtime:
                 self.molecules[mname]=M
                 logger.debug(f'Generated {mname}')
 
+        self._check_frcmod_type_conflicts()
+
         for M in self.molecules:
             self.molecules[M].is_reactant=is_reactant(M,self.reactions,stage=reaction_stage.cure)
 
@@ -781,7 +844,7 @@ class Runtime:
             list: descriptions of the differing directives; empty if the cached
                 parameterization agrees with this run or carries no record
         """
-        requested = paramcache.build_key(self.cfg.ambertools)
+        requested = paramcache.build_key(self._ambertools_for(M))
         # Discard any record left in the project directory by an earlier run so
         # that what we check is the record belonging to the library entry that
         # previously_parameterized() just found.
@@ -829,7 +892,7 @@ class Runtime:
             generatable=(not M.generator) or (all([m in self.molecules for m in M.generator.reactants.values()]))
             if generatable:
                 logger.debug(f'Generating {mname}')
-                M.generate(available_molecules=self.molecules,gaff=self.cfg.gaff,ambertools=self.cfg.ambertools)
+                M.generate(available_molecules=self.molecules,gaff=self.cfg.gaff,ambertools=self._ambertools_for(M))
                 self._checkin_parameterization(mname, force_checkin)
                 M.origin='newly parameterized'
             else:
@@ -899,7 +962,7 @@ class Runtime:
                 # assert it matches what falls out of the merged dataframe).
                 M.set_sequence_from_moldict(self.molecules)
                 M.generate(available_molecules=self.molecules,
-                           gaff=self.cfg.gaff, ambertools=self.cfg.ambertools)
+                           gaff=self.cfg.gaff, ambertools=self._ambertools_for(M))
                 self._checkin_parameterization(mname, True)
                 M.origin='newly parameterized (stale cache refreshed)'
             else:

{htpolynet-2.9.0 → htpolynet-2.10.0}/src/htpolynet/core/topology.py

@@ -137,6 +137,49 @@ _GromacsTopologyDirectiveDefaults_ = {
     'defaults': [1, 2, 'yes', 0.5, 0.83333333]
 }
 
+def conflicting_types(topologies, typenames=('bondtypes', 'angletypes', 'dihedraltypes')):
+    """Finds bonded types that two groups of topologies parameterize differently.
+
+    A merged topology keeps one table per type, shared by every molecule in
+    it, so a type with different parameters in two molecules cannot be
+    honored for both: drop_duplicates keeps both sets, and GROMACS applies
+    them together.  A user frcmod loaded for some molecules and not others is
+    the usual way to create one.
+
+    Args:
+        topologies (dict): {name: (Topology, group)}; types are compared only between topologies
+            whose groups differ, e.g. a digest of the frcmod files each was built with
+        typenames (tuple): type sections to compare
+
+    Returns:
+        list: (typename, type key, name of one topology, name of another) tuples, one per conflicting
+            type; the key is the atom types followed by the function number
+    """
+    seen = {}
+    conflicts = []
+    for name, (T, group) in topologies.items():
+        for typename in typenames:
+            df = T.D.get(typename)
+            if df is None or df.empty:
+                continue
+            hashables = _GromacsTopologyHashables_[typename]
+            params = [c for c in df.columns if c not in hashables]
+            rows = {}
+            for r in df.itertuples(index=False):
+                r = r._asdict()
+                t = tuple(r[h] for h in hashables)
+                # a proper and an improper can share atom types; they are different types
+                key = (*min(t, t[::-1]), int(r['func']) if 'func' in r else 0)
+                rows.setdefault(key, []).append(tuple(round(float(r[p]), 4) if isinstance(r[p], (int, float)) else r[p]
+                                                      for p in params))
+            for key, values in rows.items():
+                values = tuple(sorted(values))
+                first = seen.setdefault((typename, key), (name, group, values))
+                if first[1] != group and first[2] != values:
+                    conflicts.append((typename, key, first[0], name))
+    return conflicts
+
+
 def select_topology_type_option(options, typename='dihedraltypes', rule='stiffest'):
     """Selects from a list of topological interaction options of type typename using the provided rule.
 

{htpolynet-2.9.0 → htpolynet-2.10.0}/src/htpolynet/external/ambertools.py

@@ -28,6 +28,15 @@ invocations below and the provenance record written beside their output; see
 """
 
 
+def leapsafe(name):
+    """Returns a tleap-safe file stem for name.
+
+    tleap reads a bare filename containing 'e' after a digit as a number, so
+    names are hashed, as GAFFParameterize does for its own files.
+    """
+    return 'u' + hashlib.shake_128(name.encode('utf-8')).hexdigest(8).replace('e', 'x')
+
+
 def GAFFParameterize(inputPrefix, outputPrefix, input_structure_format='mol2', ambertools=None):
     """Manages execution of antechamber, parmchk2, and tleap to generate GAFF parameters,
     then converts the result to Gromacs gro/top files via parmed.
@@ -36,7 +45,9 @@ def GAFFParameterize(inputPrefix, outputPrefix, input_structure_format='mol2', a
         inputPrefix (str): basename of input structure file
         outputPrefix (str): basename of output files
         input_structure_format (str): format of input structure file, defaults to 'mol2'; 'pdb' is other option
-        ambertools (dict | None): ambertools configuration directives, defaults to None
+        ambertools (dict | None): ambertools configuration directives, defaults to None; an
+            ``frcmod`` entry, a list of (label, text) tuples, names user frcmod files that
+            tleap loads after parmchk2's, so their parameters take precedence
 
     Raises:
         parmed.exceptions.GromacsError: if parmed fails to convert tleap output
@@ -65,6 +76,13 @@ def GAFFParameterize(inputPrefix, outputPrefix, input_structure_format='mol2', a
         f' -at {atomtype} -i {new_structin} -o {mol2out} -pf Y -nc {netcharge} -eq 1 -pl 10', quiet=False)
     logger.debug(f'AmberTools> Antechamber generated {mol2out}')
     run(f'parmchk2 -i {mol2out} -o {frcmodout} -f mol2 -s {atomtype}', quiet=False)
+    user_frcmods = []
+    for label, text in ambertools.get('frcmod') or []:
+        fn = f'{leapsafe(label)}-user.frcmod'
+        with open(fn, 'w') as f:
+            f.write(text)
+        user_frcmods.append(fn)
+        logger.info(f'AmberTools> loading user frcmod for {label} into {outputPrefix}')
 
     # Antechamber ignores SUBSTRUCTURE records, so patch the antechamber output
     # mol2 with the original resName/resNum before passing it to tleap.
@@ -92,6 +110,8 @@ def GAFFParameterize(inputPrefix, outputPrefix, input_structure_format='mol2', a
             # fires, and we abort even though tleap would have completed once
             # the frcmod was loaded.
             f'loadamberparams {leapprefix}.frcmod',
+            # user files last, so they override both GAFF and parmchk2's guesses
+            *[f'loadamberparams {fn}' for fn in user_frcmods],
             f'mymol = loadmol2 {leapprefix}.mol2',
             'check mymol',
             f'saveamberparm mymol {leapprefix}-tleap.top {leapprefix}-tleap.crd',
@@ -102,6 +122,8 @@ def GAFFParameterize(inputPrefix, outputPrefix, input_structure_format='mol2', a
     run(f'tleap -f {inputPrefix}-tleap.in', override=('Error!', 'Unspecified tleap error'))
 
     os.remove(f'{leapprefix}.frcmod')
+    for fn in user_frcmods:
+        os.remove(fn)
     shutil.move(f'{leapprefix}.mol2',      mol2out)
     shutil.move(f'{leapprefix}-tleap.top', f'{outputPrefix}-tleap.top')
     shutil.move(f'{leapprefix}-tleap.crd', f'{outputPrefix}-tleap.crd')

{htpolynet-2.9.0 → htpolynet-2.10.0}/src/htpolynet/schema/base.yaml

@@ -192,6 +192,18 @@ attributes:
       - name: symmetry_equivalent_atoms
         type: list
         text: Sets of symmetry-equivalent atom names, if any.
+      - name: frcmod
+        type: str
+        required: false
+        text: >
+          Path, relative to the configuration file, to an Amber frcmod file of
+          parameter overrides for this molecule.  tleap loads it after GAFF and
+          parmchk2, so its entries win.  It is loaded for this molecule and for
+          every template containing it, and it is part of each parameterization's
+          cache record, so editing the file re-parameterizes them.  A system
+          keeps one table per bonded type, so an overridden type must not also
+          occur, unoverridden, in a molecule without this residue; setup stops if
+          it does.
       - name: conformers
         type: dict
         required: false

{htpolynet-2.9.0 → htpolynet-2.10.0}/tests/unit/test_paramcache.py

@@ -63,8 +63,10 @@ def _library_entry(library, name, **ambertools):
 
 def _runtime(**ambertools):
     """A stand-in for Runtime carrying only what the check reads off it."""
-    return SimpleNamespace(cfg=SimpleNamespace(ambertools=ambertools),
-                           unverified_parameterizations=[])
+    r = SimpleNamespace(cfg=SimpleNamespace(ambertools=ambertools),
+                        unverified_parameterizations=[], frcmods={})
+    r._ambertools_for = lambda M: Runtime._ambertools_for(r, M)
+    return r
 
 
 def _mismatch(name='TAZ', **ambertools):

htpolynet-2.10.0/tests/unit/test_user_frcmod.py

@@ -0,0 +1,149 @@
+"""
+
+.. module:: test_user_frcmod
+   :synopsis: a constituent's frcmod reaches its own parameterization, every template containing it,
+              and the parameter-cache record, and nothing else
+
+.. moduleauthor: Cameron F. Abrams, <cfa22@drexel.edu>
+
+"""
+import os
+import shutil
+from types import SimpleNamespace
+
+import pandas as pd
+import pytest
+
+import htpolynet.core.projectfilesystem as pfs
+from htpolynet.core import paramcache
+from htpolynet.core.molecule import Molecule
+from htpolynet.core.runtime import Runtime
+from htpolynet.core.topology import Topology, conflicting_types
+
+FRC = ('BAF', 'MASS\n\nDIHE\nca-ca-c3-ca   1     0.3190    180.0    -2.0\n\n')
+
+
+class TestCacheRecord:
+    def test_no_frcmod_leaves_the_record_as_it_was(self):
+        assert paramcache.FRCMOD_FIELD not in paramcache.build_key({'charge_method': 'bcc'})
+
+    def test_frcmod_is_recorded_by_content(self):
+        a = paramcache.build_key({'frcmod': [FRC]})
+        b = paramcache.build_key({'frcmod': [(FRC[0], FRC[1] + 'x')]})
+        assert a[paramcache.FRCMOD_FIELD] != b[paramcache.FRCMOD_FIELD]
+        assert a == paramcache.build_key({'frcmod': [FRC]})
+
+    def test_plain_cache_entry_is_a_miss_when_a_frcmod_is_requested(self):
+        diffs = paramcache.describe_mismatch(paramcache.build_key({}), paramcache.build_key({'frcmod': [FRC]}))
+        assert any('frcmod' in d for d in diffs)
+
+    def test_overridden_cache_entry_is_a_miss_when_none_is_requested(self):
+        assert paramcache.describe_mismatch(paramcache.build_key({'frcmod': [FRC]}), paramcache.build_key({}))
+
+    def test_edited_frcmod_is_a_miss(self):
+        assert paramcache.describe_mismatch(paramcache.build_key({'frcmod': [FRC]}),
+                                            paramcache.build_key({'frcmod': [(FRC[0], FRC[1] + '\n')]}))
+
+    def test_record_from_before_frcmods_matches_a_run_without_one(self):
+        stored = {'charge_method': 'bcc', 'net_charge': 0, 'atom_type': 'gaff'}
+        assert paramcache.describe_mismatch(stored, paramcache.build_key({})) == []
+
+
+class TestWhichMoleculesGetIt:
+    def runtime(self):
+        r = SimpleNamespace(cfg=SimpleNamespace(ambertools={'atom_type': 'gaff2'}), frcmods={'BAF': FRC[1]})
+        return r
+
+    def test_the_monomer(self):
+        amb = Runtime._ambertools_for(self.runtime(), SimpleNamespace(name='BAF', sequence=['BAF']))
+        assert amb['frcmod'] == [FRC]
+        assert amb['atom_type'] == 'gaff2'
+
+    def test_every_template_containing_it(self):
+        M = SimpleNamespace(name='BAF~O1-C1~BAF~O1-C2~TAZ', sequence=['BAF', 'BAF', 'TAZ'])
+        assert Runtime._ambertools_for(self.runtime(), M)['frcmod'] == [FRC]
+
+    def test_not_a_molecule_without_it(self):
+        assert 'frcmod' not in Runtime._ambertools_for(self.runtime(), SimpleNamespace(name='TAZ', sequence=['TAZ']))
+
+    def test_configuration_directives_are_not_mutated(self):
+        r = self.runtime()
+        Runtime._ambertools_for(r, SimpleNamespace(name='BAF', sequence=['BAF']))
+        assert 'frcmod' not in r.cfg.ambertools
+
+
+class TestReadFrcmods:
+    def runtime(self, constituents):
+        return SimpleNamespace(cfg=SimpleNamespace(constituents=constituents))
+
+    def test_reads_relative_to_the_configuration(self, tmp_path):
+        (tmp_path / 'baf.frcmod').write_text(FRC[1])
+        pfs.pfs_setup(root=str(tmp_path), mock=True)
+        got = Runtime._read_frcmods(self.runtime({'BAF': {'frcmod': 'baf.frcmod'}, 'TAZ': {'count': 1}}))
+        assert got == {'BAF': FRC[1]}
+
+    def test_a_missing_file_stops_setup(self, tmp_path):
+        pfs.pfs_setup(root=str(tmp_path), mock=True)
+        with pytest.raises(FileNotFoundError, match='BAF'):
+            Runtime._read_frcmods(self.runtime({'BAF': {'frcmod': 'nope.frcmod'}}))
+
+
+def dihedraltypes(rows):
+    T = Topology()
+    T.D['dihedraltypes'] = pd.DataFrame(rows, columns=['i', 'j', 'k', 'l', 'func', 'phase', 'kd', 'pn'])
+    return T
+
+
+class TestConflictingTypes:
+    plain = [('ca', 'c3', 'ca', 'ca', 9, 0.0, 0.0, 2)]
+    fitted = [('ca', 'c3', 'ca', 'ca', 9, 180.0, 1.335, 2), ('ca', 'c3', 'ca', 'ca', 9, 180.0, 0.959, 4)]
+
+    def test_overridden_type_also_present_without_the_override(self):
+        c = conflicting_types({'BAF': (dihedraltypes(self.fitted), 'd1'), 'BPA': (dihedraltypes(self.plain), None)})
+        assert c == [('dihedraltypes', ('ca', 'c3', 'ca', 'ca', 9), 'BAF', 'BPA')]
+
+    def test_an_improper_with_the_same_atom_types_is_a_different_type(self):
+        improper = [('ca', 'c3', 'ca', 'ca', 4, 180.0, 0.263, 2)]
+        both = self.fitted + improper
+        assert conflicting_types({'BAF': (dihedraltypes(both), 'd1'), 'X': (dihedraltypes(improper), None)}) == []
+
+    def test_reversed_type_names_are_the_same_type(self):
+        rev = [('ca', 'ca', 'c3', 'ca', 9, 0.0, 0.0, 2)]
+        assert conflicting_types({'BAF': (dihedraltypes(self.fitted), 'd1'), 'BPA': (dihedraltypes(rev), None)})
+
+    def test_same_group_differences_are_not_this_check(self):
+        # discrepancies among plain GAFF molecules are resolve_type_discrepancies' business
+        assert conflicting_types({'A': (dihedraltypes(self.fitted), None), 'B': (dihedraltypes(self.plain), None)}) == []
+
+    def test_agreeing_parameters_are_fine(self):
+        assert conflicting_types({'BAF': (dihedraltypes(self.plain), 'd1'), 'TAZ': (dihedraltypes(self.plain), None)}) == []
+
+
+_MISSING = [t for t in ('antechamber', 'parmchk2', 'tleap', 'gmx') if shutil.which(t) is None]
+
+
+@pytest.mark.skipif(bool(_MISSING), reason=f'external tools not on PATH: {", ".join(_MISSING)}')
+class TestTleapLoadsIt:
+    def parameterize(self, root, ambertools):
+        orig = os.getcwd()
+        pfs.pfs_setup(root=str(root), projdir='proj', mock=False)
+        try:
+            M = Molecule.New('STY', None)
+            M.set_sequence_from_moldict({'STY': M})
+            M.generate(ambertools=ambertools, gaff={'minimize_molecules': False})
+            return Topology.read_top('STY.top').D['dihedraltypes'], paramcache.read_key('STY')
+        finally:
+            os.chdir(orig)
+
+    def test_the_override_replaces_the_gaff_torsion(self, tmp_path_factory):
+        plain, plain_key = self.parameterize(tmp_path_factory.mktemp('plain'), {'charge_method': 'gas'})
+        t = plain.iloc[0]
+        names = '-'.join(str(x).ljust(2) for x in (t.i, t.j, t.k, t.l))
+        frcmod = f'override\nDIHE\n{names}   1    7.7700    180.0     3.0\n\n'
+        over, over_key = self.parameterize(tmp_path_factory.mktemp('over'),
+                                           {'charge_method': 'gas', 'frcmod': [('STY', frcmod)]})
+        rows = over[(over.i == t.i) & (over.j == t.j) & (over.k == t.k) & (over.l == t.l)]
+        assert list(rows.kd.round(3)) == [round(7.77 * 4.184, 3)]
+        assert list(rows.pn) == [3]
+        assert paramcache.FRCMOD_FIELD not in plain_key
+        assert over_key[paramcache.FRCMOD_FIELD] == paramcache.frcmod_digest([('STY', frcmod)])