mdinterface 2.0.0__tar.gz → 2.0.1__tar.gz

{mdinterface-2.0.0 → mdinterface-2.0.1}/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to mdinterface are documented here.
 
 ## [Unreleased]
 
+## [2.0.1] - 2026-09-28
+
+Fixes GROMACS topology generation and validation for single- and multi-species systems, with LAMMPS/GROMACS energy and force regression coverage. Charge audits now report numerical noise near zero as `0.0` without changing atomic partial charges.
+
+### Fixed
+- Parameterization and polymer charge audits normalize numerical noise within `1e-12 e` of zero without altering atomic partial charges.
+- GROMACS exports restore scaled 1-4 interactions using explicit pairs derived from bond connectivity, including zero-valued torsions.
+- `SimCell.write_gromacs()` writes shared atom types before molecule definitions so mixed-species topologies can be preprocessed.
+- GROMACS system topologies preserve consecutive molecule order to match the coordinate file.
+- GROMACS exports reject incomplete or unsupported parameters and conflicting species definitions before writing files.
+- `SimCell.write_gromacs()` rejects assembled residues whose atom types, charges, masses, or atom counts differ from their species definitions.
+
 ## [2.0.0] - 2026-09-28
 
 Makes `SimCell` the sole system builder, removing the deprecated `SimulationBox` and `BoxBuilder` APIs and adding spatially constrained solvent regions and optional LAMMPS structural metadata. This major release also changes explicit centering behavior, requires Python 3.10 or newer, and adds RDKit molecular preparation, atomic force-field parameterization, export validation, and improved external-tool diagnostics.

{mdinterface-2.0.0 → mdinterface-2.0.1}/CONTRIBUTING.md

@@ -65,3 +65,7 @@ Update the relevant guide when changing a documented public API or workflow. API
 Add every user-visible change to `CHANGELOG.md` under `Unreleased`, grouped under `Added`, `Changed`, `Fixed`, or `Deprecated`. Write one concise, unwrapped sentence per bullet and describe one observable change. Omit internal refactoring, agent instructions, contributor-only documentation, CI maintenance, and release-process changes unless they affect what package users install or receive.
 
 See `docs/development/releasing.md` for the release process.
+
+### GROMACS conversion checks
+
+`pytest -q tests/test_gromacswriter.py` checks topology structure, parameter validation, molecule ordering, and unit conversions. With `gmx_d` (preferred), or `gmx`, and `lmp` on `PATH`, it also runs GROMACS preprocessing and compares single-point energies and forces against LAMMPS. Engine-dependent tests use the `integration` marker and skip when the executables are unavailable. Hosted integration CI installs both engines. `GMX_BINARY` can select a specific GROMACS executable; the packed electrolyte force comparison requires double precision. Frozen common-molecule fixtures avoid a BOSS dependency in CI. These tests use matched coordinates and explicit OPLS settings; they do not select production simulation protocols.

{mdinterface-2.0.0 → mdinterface-2.0.1}/MANIFEST.in

@@ -17,6 +17,7 @@ recursive-include docs *
 recursive-include examples *
 recursive-include scripts *.py
 recursive-include tests *.py
+recursive-include tests/data *.json *.md
 include assets/*
 
 # Exclude unwanted files

{mdinterface-2.0.0 → mdinterface-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdinterface
-Version: 2.0.0
+Version: 2.0.1
 Summary: Build Interface Systems for Molecular Dynamics Simulations
 Author-email: Fabrice Roncoroni <fabrice.roncoroni@gmail.com>
 License-Expression: Apache-2.0

{mdinterface-2.0.0 → mdinterface-2.0.1}/docs/guide/polymer.md

@@ -123,7 +123,7 @@ Refinement stages topology and charge changes and applies them only after every
 
 Refinement requires a connected graph and `snippet_radius >= 4`. Snippets preserve touched rings, formal-charge sites and their immediate neighbors, and multiple bonds; artificial caps are neutral. Charges and topology are recalculated for every junction without the former element-string cache. RDKit-backed snippets use the MOL handoff described in the [species guide](specie.md).
 
-Assembly removes leaving-atom partial charges, so an unrefined chain need not have its intended total charge. `round_charges()` only rounds the existing total. Refinement returns a charge audit containing the initial total, formal target, refined total, residual (refined minus formal), per-atom correction, final total, and junction count. It also logs the residual before applying the optional uniform `charge_correction="uniform"` correction; this correction enforces the chain total, not an integer charge on each repeat unit. Check local charge changes as well as the total. The piperion example runs refinement and checks both the chain charge and final membrane neutrality before export. Its whole-chain RDKit geometry step replaces the former optional ML-relaxation recipe.
+Assembly removes leaving-atom partial charges, so an unrefined chain need not have its intended total charge. `round_charges()` only rounds the existing total. Refinement returns a charge audit containing the initial total, formal target, refined total, residual (refined minus formal), per-atom correction, final total, and junction count. It also logs the residual before applying the optional uniform `charge_correction="uniform"` correction; this correction enforces the chain total, not an integer charge on each repeat unit. Check local charge changes as well as the total. The piperion example runs refinement and checks both the chain charge and final membrane neutrality before export. Its whole-chain RDKit geometry step replaces the former optional ML-relaxation recipe. Charge-audit totals and residuals within `1e-12 e` of zero are reported as `0.0`, without applying a numerical-noise correction or changing individual atomic partial charges.
 
 ### Serialization (optional)
 

{mdinterface-2.0.0 → mdinterface-2.0.1}/docs/guide/simcell.md

@@ -246,27 +246,42 @@ universe = simbox.universe
 ### GROMACS output *(experimental)*
 
 !!! warning
-    GROMACS output is experimental.  Unit conversions and dihedral mappings
-    have been validated for OPLS-AA molecules generated by LigParGen, but
-    other force fields or atom styles may need adjustments.  Verify the output
-    against a reference before production use.
+    GROMACS output assumes harmonic bonds and angles, four-term OPLS proper torsions, CVFF impropers, geometric Lennard-Jones mixing, and 0.5 scaling of both LJ and Coulomb 1-4 interactions. It is not a general force-field converter. Constraints, rigid-water settings, electrostatics methods, cutoffs, and simulation protocols must be chosen separately for your model.
 
-`write_gromacs()` produces three files in the directory of your choice:
+`write_gromacs()` produces these files in the directory of your choice:
 
-- `{prefix}.gro` — atomic coordinates and box vectors
-- `{resname}.itp` — per-species include topology (one per unique species)
-- `{prefix}.top` — system topology with molecule counts matching the GRO file
+- `{prefix}.gro` - atomic coordinates and box vectors, with standard GRO precision (0.001 nm).
+- `{resname}.itp` - per-species molecule definitions, bonded terms, and explicit 1-4 pairs derived from shortest bond-graph distances.
+- `{prefix}.top` - shared atom types before all molecule includes, OPLS defaults, and consecutive molecule counts matching the GRO coordinate order.
 
 ```python
 simbox.write_gromacs(prefix="system", outdir="gromacs_input/")
 ```
 
-Individual ITP files can also be written directly from a `Specie`:
+The exporter validates force-field completeness before creating files. Missing or nonfinite parameters, unsupported fifth torsion coefficients, invalid CVFF parameters, and conflicting atom types raise `ValueError`. Species sharing a residue name must have identical atom order, charges, masses, and topology parameters; use distinct `name=` values for different models. Assembled residues must match their species definitions, including charges and atom types.
+
+Individual ITP files include atom types by default:
 
 ```python
 water.write_gromacs_itp("water.itp")
 ```
 
+For manual multi-species assembly, keep molecule files separate from shared atom-type definitions:
+
+```python
+from mdinterface.io import write_gromacs_top
+
+species = [water, sodium, chloride]
+itp_files = []
+for specie in species:
+    filename = f"{specie.resname}.itp"
+    specie.write_gromacs_itp(filename, include_atomtypes=False)
+    itp_files.append(filename)
+write_gromacs_top(universe, itp_files, species=species)
+```
+
+GROMACS preprocessing tests cover mixtures, chains, and rings. Single-point energy and force comparisons against LAMMPS cover harmonic terms, OPLS torsions, scaled 1-4 interactions, and CVFF impropers, plus water, benzene, ethanol, methane, dimers, mixed molecular systems, and a packed water/NaCl box. Strict packed-system comparisons use double-precision GROMACS to limit rounding of small force components. These checks do not validate arbitrary force fields or production dynamics. Compare engines at identical coordinates because standard GRO rounding can change bonded energies.
+
 ## Verbosity
 
 ```python

{mdinterface-2.0.0 → mdinterface-2.0.1}/docs/guide/specie.md

@@ -96,7 +96,7 @@ report = cation.parameterize(charge_correction="none")
 cation.validate_force_field()
 ```
 
-Coordinates stay unchanged. The charge audit reports the initial, raw refined and final totals, formal target, residual, correction per atom and number of junctions. Charge correction is always explicit: `"none"` is the default, and `"uniform"` distributes the residual over all atoms. `ligpargen=True` uses this same parameterization path.
+Coordinates stay unchanged. The charge audit reports the initial, raw refined and final totals, formal target, residual, correction per atom and number of junctions. Charge correction is always explicit: `"none"` is the default, and `"uniform"` distributes the residual over all atoms. `ligpargen=True` uses this same parameterization path. Charge-audit totals and residuals within `1e-12 e` of zero are reported as `0.0`, without applying a numerical-noise correction or changing individual atomic partial charges.
 
 **Large molecules (>200 atoms):** `parameterize()` splits the molecule into chemically valid capped segments and refines the junctions. `segment_size` counts caps and cannot exceed 200. All segments and expanded junction snippets are checked before any LigParGen calculation. If the molecule cannot be split safely or a junction remains too large, parameterization fails with guidance rather than sending an oversized structure to BOSS. `snippet_radius` controls junction extent, and `cap_element` selects a neutral monovalent cap. All calculations and validation must succeed before parameters are applied. `refine_large_topology()` delegates to the same workflow with the same options and report.
 

{mdinterface-2.0.0 → mdinterface-2.0.1}/mdinterface/__init__.py

@@ -6,7 +6,7 @@ Initially developed to construct electrolyte/electrode interfaces, it is also we
 
 """
 
-__version__ = '2.0.0'
+__version__ = '2.0.1'
 __date__ = '28 Sep. 2026'
 __author__ = 'Fabrice Roncoroni'
 __all__ = ['SimCell', "Specie", "Polymer", "PackmolError", "LigParGenError"]

{mdinterface-2.0.0 → mdinterface-2.0.1}/mdinterface/build/builder.py

@@ -16,7 +16,7 @@ from typing import List, Optional, Union, Tuple, Any
 
 from mdinterface.utils.auxiliary import find_smallest_missing, label_to_element
 from mdinterface.io.lammpswriter import DATAWriter, write_lammps_coefficients
-from mdinterface.io.gromacswriter import write_gromacs_itp, write_gromacs_top
+from mdinterface.io.gromacswriter import write_gromacs_itp, write_gromacs_top, _prepare_species
 from mdinterface.build.box import make_interface_slab, add_component
 from mdinterface.build.regions import FilledRegion
 from mdinterface.build.compartment import (
@@ -557,11 +557,11 @@ class SimCell:
 
         Produces (all written to *outdir*):
 
-        - ``{prefix}.gro`` — atomic coordinates and box vectors.
-        - ``{resname}.itp`` — per-species include topology (one per unique
-          species), with ``[ atomtypes ]``, ``[ moleculetype ]``, ``[ atoms ]``,
-          ``[ bonds ]``, ``[ angles ]``, and ``[ dihedrals ]`` sections.
-        - ``{prefix}.top`` — system topology that includes the ITP files and
+        - ``{prefix}.gro`` - atomic coordinates and box vectors.
+        - ``{resname}.itp`` - per-species include topology (one per unique
+          species), with ``[ moleculetype ]``, ``[ atoms ]``,
+          ``[ bonds ]``, ``[ pairs ]``, ``[ angles ]``, and ``[ dihedrals ]`` sections.
+        - ``{prefix}.top`` - system topology that defines shared atom types, includes the ITP files, and
           lists molecule counts matching the GRO file.
 
         Parameters
@@ -579,16 +579,20 @@ class SimCell:
         RuntimeError
             If called before :meth:`build`.
 
+        ValueError
+            If parameters are incomplete or unsupported, species names collide
+            with different definitions, or assembled residues do not match.
+
         .. warning::
-            GROMACS output is **experimental**.  Unit conversions and dihedral
-            mappings have been validated for OPLS-AA molecules generated by
-            LigParGen, but other force fields or atom styles may need
-            adjustments.  Use with care and verify the output against a
-            reference.
+            Experimental export for harmonic bonds/angles, four-term OPLS
+            torsions, CVFF impropers, geometric LJ mixing and 0.5 LJ/Coulomb
+            1-4 scaling. Constraints and simulation settings are not generated.
         """
         if self._universe is None:
             raise RuntimeError("Call build() before write_gromacs().")
 
+        species = _prepare_species(self._all_species, self._universe)
+
         import os
         os.makedirs(outdir, exist_ok=True)
 
@@ -597,17 +601,13 @@ class SimCell:
             "write_gromacs is experimental -- verify output before production use."
         )
 
-        # -- one ITP per unique species (keyed by resname) -----------------
         itp_basenames = []
-        written = set()
-        for sp in self._all_species:
-            if sp.resname not in written:
-                itp_name = f"{sp.resname}.itp"
-                itp_path = os.path.join(outdir, itp_name)
-                write_gromacs_itp(sp, filename=itp_path)
-                itp_basenames.append(itp_name)   # basename only for #include
-                written.add(sp.resname)
-                logger.info("  >> Species topology: %s", itp_path)
+        for sp in species:
+            itp_name = f"{sp.resname}.itp"
+            itp_path = os.path.join(outdir, itp_name)
+            write_gromacs_itp(sp, filename=itp_path, include_atomtypes=False)
+            itp_basenames.append(itp_name)
+            logger.info("  >> Species topology: %s", itp_path)
 
         # -- coordinates (.gro) --------------------------------------------
         gro_file = os.path.join(outdir, f"{prefix}.gro")
@@ -617,7 +617,7 @@ class SimCell:
         # -- system topology (.top) ----------------------------------------
         top_file = os.path.join(outdir, f"{prefix}.top")
         write_gromacs_top(self._universe, itp_basenames,
-                          filename=top_file, system_name=system_name)
+                          filename=top_file, system_name=system_name, species=species)
         logger.info("  >> System topology:  %s", top_file)
 
     def to_ase(self) -> ase.Atoms:

{mdinterface-2.0.0 → mdinterface-2.0.1}/mdinterface/core/polymer.py

@@ -14,6 +14,8 @@ from mdinterface.build.polymerize import build_polymer
 from mdinterface.build.snippets import make_snippet, remap_snippet_topology
 
 # import random
+from mdinterface.utils.auxiliary import _clean_charge
+
 import numpy as np
 import logging
 
@@ -238,7 +240,7 @@ class Polymer(Specie):
 
         # get charges and connection elements
         charges = self.charges
-        initial_charge = float(charges.sum())
+        initial_charge = _clean_charge(charges.sum())
         pairs = self.junction_bonds
 
 
@@ -253,12 +255,12 @@ class Polymer(Specie):
         if not np.isfinite(charges).all():
             raise ValueError("Junction refinement returned nonfinite partial charges.")
         target = int(self.atoms.arrays["nominal_charge"].sum())
-        refined_charge = float(charges.sum())
-        residual = refined_charge - target
+        refined_charge = _clean_charge(charges.sum())
+        residual = _clean_charge(refined_charge - target)
         correction = 0.0
         logger.info("Polymer charge after junction refinement: %.8f e; formal: %d e; residual: %+.8f e",
-                    charges.sum(), target, residual)
-        if charge_correction == "uniform":
+                    refined_charge, target, residual)
+        if charge_correction == "uniform" and residual != 0:
             correction = -residual / len(charges)
             logger.info("Applying uniform partial-charge correction: %+.8f e per atom", correction)
             charges += correction
@@ -270,6 +272,6 @@ class Polymer(Specie):
             "refined_charge": refined_charge,
             "residual": residual,
             "correction_per_atom": correction,
-            "final_charge": float(charges.sum()),
+            "final_charge": _clean_charge(charges.sum()),
             "junctions": len(pairs),
         }

{mdinterface-2.0.0 → mdinterface-2.0.1}/mdinterface/core/specie.py

@@ -955,7 +955,7 @@ class Specie(object):
         
         return
     
-    def write_gromacs_itp(self, filename=None):
+    def write_gromacs_itp(self, filename=None, *, include_atomtypes=True):
         """
         Write a GROMACS include topology (.itp) file for this species.
 
@@ -966,12 +966,16 @@ class Specie(object):
         ----------
         filename : str, optional
             Output filename. Defaults to ``{resname}.itp``.
+        include_atomtypes : bool, default True
+            Include atom types in this file. For multi-species exports, use
+            False and supply ``species`` to ``write_gromacs_top`` to define
+            all atom types before all molecule definitions.
         """
         logger.warning(
             "write_gromacs_itp is experimental -- verify output before production use."
         )
         from mdinterface.io.gromacswriter import write_gromacs_itp
-        write_gromacs_itp(self, filename=filename)
+        write_gromacs_itp(self, filename=filename, include_atomtypes=include_atomtypes)
 
     def validate_force_field(self):
         """Raise if molecular parameters required for classical export are missing.

{mdinterface-2.0.0 → mdinterface-2.0.1}/mdinterface/externals/ligpargen.py

@@ -13,6 +13,8 @@ from mdinterface.io.read import read_lammps_data_file
 import logging
 import math
 import copy
+from mdinterface.utils.auxiliary import _clean_charge
+
 import numpy as np
 import os
 import ase
@@ -398,7 +400,7 @@ def refine_large_specie_topology(specie, snippet_radius=12, cap_element="H",
     if cap_element not in {"H", "F", "Cl", "Br", "I"}:
         raise ValueError("cap_element must be a neutral monovalent element.")
     staged, attributes = specie._parameterization_copy()
-    initial = float(staged.charges.sum())
+    initial = _clean_charge(staged.charges.sum())
     target = staged._resolve_charge(None)
     if len(staged.atoms) <= segment_size:
         result, atom_types, bonds, angles, dihedrals, impropers = run_ligpargen(staged.atoms, charge=target)
@@ -412,13 +414,13 @@ def refine_large_specie_topology(specie, snippet_radius=12, cap_element="H",
     charges = staged.charges
     if not np.isfinite(charges).all():
         raise ValueError("Parameterization returned nonfinite partial charges.")
-    refined = float(charges.sum())
-    residual = refined - target
-    correction = -residual / len(charges) if charge_correction == "uniform" else 0.0
+    refined = _clean_charge(charges.sum())
+    residual = _clean_charge(refined - target)
+    correction = -residual / len(charges) if charge_correction == "uniform" and residual != 0 else 0.0
     staged.atoms.set_initial_charges(charges + correction)
     report = dict(formal_charge=target, initial_charge=initial, refined_charge=refined,
                   residual=residual, correction_per_atom=correction,
-                  final_charge=float(staged.charges.sum()), junctions=junctions)
+                  final_charge=_clean_charge(staged.charges.sum()), junctions=junctions)
     staged.validate_force_field()
     specie._apply_parameterization(staged, attributes)
     logger.info("Parameterization charge audit: %s", report)

{mdinterface-2.0.0 → mdinterface-2.0.1}/mdinterface/io/gromacswriter.py

@@ -19,7 +19,10 @@ LAMMPS cvff improper dihedrals are mapped to ``funct=4``.
 """
 
 import logging
-import os
+from itertools import groupby
+
+import networkx as nx
+import numpy as np
 
 logger = logging.getLogger(__name__)
 
@@ -65,15 +68,92 @@ _DIHS_HDR  = "; {:>5}  {:>5}  {:>5}  {:>5}  {:>5}  {:>10}  {:>14}  {:>3}\n"
 _DIHS_FMT  = "  {:>5d}  {:>5d}  {:>5d}  {:>5d}  {:>5d}  {:>10.3f}  {:>14.6f}  {:>3d}\n"
 
 
-def write_gromacs_itp(specie, filename=None):
+def _validate_specie(specie):
+    specie.validate_force_field()
+    if not len(specie.atoms):
+        raise ValueError("Cannot export an empty GROMACS molecule.")
+    masses = specie.atoms.get_masses()
+    if not np.isfinite(masses).all() or (masses <= 0).any():
+        raise ValueError("GROMACS atom masses must be finite and positive.")
+    for tid in set(specie.dihedrals[1]):
+        if specie._dtype[tid].values[4] is not None:
+            raise ValueError("GROMACS export requires four-term OPLS dihedrals; A5 is unsupported.")
+    for tid in set(specie.impropers[1]):
+        _, sign, multiplicity = specie._itype[tid].values
+        if sign not in (-1, 1) or multiplicity not in range(7):
+            raise ValueError("GROMACS export requires CVFF impropers with d = +/-1 and integer n = 0..6.")
+
+
+def _atomtype_records(species):
+    records = {}
+    for specie in species:
+        labels, indices = specie.get_atom_types(return_index=True)
+        for label, index, atom in zip(labels, indices, specie.atoms):
+            parameter = specie._stype[index]
+            record = (atom.number, atom.mass, parameter.sig, parameter.eps)
+            if label in records and records[label] != record:
+                raise ValueError(f"Conflicting GROMACS atom type {label!r}.")
+            records[label] = record
+    return records
+
+
+def _write_atomtypes(stream, records):
+    nw = max(4, max(map(len, records)))
+    stream.write("[ atomtypes ]\n")
+    stream.write(_at_hdr(nw).format(
+        "name", "atnum", "mass", "charge", "ptype", "sigma(nm)", "eps(kJ/mol)"))
+    for label, (number, mass, sigma, epsilon) in records.items():
+        stream.write(_at_fmt(nw).format(
+            label, number, mass, 0.0, "A", sigma * _ANG_TO_NM, epsilon * _KCAL_TO_KJ))
+    stream.write("\n")
+
+
+def _species_signature(specie):
+    interactions = []
+    for name, key in (("bonds", "_btype"), ("angles", "_atype"),
+                      ("dihedrals", "_dtype"), ("impropers", "_itype")):
+        indices, types = getattr(specie, name)
+        parameters = getattr(specie, key)
+        interactions.append(tuple((tuple(ids), tuple(parameters[tid].values))
+                                  for ids, tid in zip(indices, types)))
+    return (tuple(specie.get_atom_types()), tuple(specie._sids),
+            tuple(specie.atoms.numbers), tuple(specie.atoms.get_masses()),
+            tuple(specie.charges), tuple(_atomtype_records([specie]).items()),
+            tuple(interactions))
+
+
+def _prepare_species(species, universe):
+    unique = {}
+    signatures = {}
+    for specie in species:
+        _validate_specie(specie)
+        signature = _species_signature(specie)
+        if specie.resname in signatures and signatures[specie.resname] != signature:
+            raise ValueError(f"Conflicting GROMACS molecule definitions for {specie.resname!r}; use distinct species names.")
+        unique[specie.resname] = specie
+        signatures[specie.resname] = signature
+    _atomtype_records(unique.values())
+    for residue in universe.residues:
+        if residue.resname not in unique:
+            raise ValueError(f"No GROMACS molecule definition for {residue.resname!r}.")
+        specie = unique[residue.resname]
+        atoms = residue.atoms
+        if (len(atoms) != len(specie.atoms)
+                or not np.array_equal(atoms.types, specie.get_atom_types())
+                or not np.allclose(atoms.charges, specie.charges, rtol=0, atol=1e-8)
+                or not np.allclose(atoms.masses, specie.atoms.get_masses(), rtol=0, atol=1e-8)):
+            raise ValueError(f"Assembled residue {residue.resname!r} does not match its GROMACS molecule definition.")
+    return list(unique.values())
+
+
+def write_gromacs_itp(specie, filename=None, *, include_atomtypes=True):
     """
     Write a GROMACS include topology (.itp) file for a Specie.
 
     .. warning::
-        GROMACS output is **experimental**.  Unit conversions and dihedral
-        mappings have been validated for OPLS-AA molecules generated by
-        LigParGen, but other force fields or atom styles may need adjustments.
-        Use with care and verify the output against a reference.
+        GROMACS output is experimental and assumes harmonic bonds and angles,
+        four-term OPLS proper torsions, CVFF impropers, geometric LJ mixing,
+        and 0.5 LJ/Coulomb 1-4 scaling. Constraints are not generated.
 
     Parameters
     ----------
@@ -81,14 +161,24 @@ def write_gromacs_itp(specie, filename=None):
         The molecular species to write.
     filename : str, optional
         Output filename. Defaults to ``{resname}.itp``.
+    include_atomtypes : bool, default True
+        Include atom-type definitions. For multi-species systems, set False
+        and pass the species to :func:`write_gromacs_top` so all atom types
+        precede all molecule definitions.
+
+    Raises
+    ------
+    ValueError
+        If parameters are incomplete, conflicting, or unsupported.
     """
+    _validate_specie(specie)
+    records = _atomtype_records([specie])
     if filename is None:
         filename = f"{specie.resname}.itp"
 
     masses   = specie.atoms.get_masses()
     charges  = specie.atoms.get_initial_charges()
-    atnums   = specie.atoms.get_atomic_numbers()
-    atom_types, type_indexes = specie.get_atom_types(return_index=True)
+    atom_types = specie.get_atom_types()
 
     bond_idxs,  bond_tids  = specie.bonds
     angle_idxs, angle_tids = specie.angles
@@ -98,8 +188,6 @@ def write_gromacs_itp(specie, filename=None):
     # column width for name/type: fit the longest label, at least "name" (4)
     nw = max(max(len(t) for t in atom_types), 4)
 
-    AT_HDR    = _at_hdr(nw)
-    AT_FMT    = _at_fmt(nw)
     ATOMS_HDR = _atoms_hdr(nw)
     ATOMS_FMT = _atoms_fmt(nw)
 
@@ -107,23 +195,8 @@ def write_gromacs_itp(specie, filename=None):
         f.write("; GROMACS ITP file generated by mdinterface\n")
         f.write(f"; Molecule: {specie.resname}\n\n")
 
-        # ------------------------------------------------------------------
-        # [ atomtypes ] -- unique FF types with LJ parameters
-        # ------------------------------------------------------------------
-        f.write("[ atomtypes ]\n")
-        f.write(AT_HDR.format(
-            "name", "atnum", "mass", "charge", "ptype", "sigma(nm)", "eps(kJ/mol)"))
-        seen = set()
-        for atype, atnum, mass, tidx in zip(
-                atom_types, atnums, masses, type_indexes):
-            if atype in seen:
-                continue
-            seen.add(atype)
-            stype = specie._stype[tidx]
-            sig = (stype.sig * _ANG_TO_NM) if stype.sig is not None else 0.0
-            eps = (stype.eps * _KCAL_TO_KJ) if stype.eps is not None else 0.0
-            f.write(AT_FMT.format(atype, atnum, mass, 0.0, "A", sig, eps))
-        f.write("\n")
+        if include_atomtypes:
+            _write_atomtypes(f, records)
 
         # ------------------------------------------------------------------
         # [ moleculetype ]
@@ -153,12 +226,22 @@ def write_gromacs_itp(specie, filename=None):
             f.write(_BONDS_HDR.format("ai", "aj", "funct", "b0(nm)", "kb(kJ/mol/nm2)"))
             for (ai, aj), tid in zip(bond_idxs, bond_tids):
                 bond = specie._btype[tid]
-                b0 = (bond.r0 * _ANG_TO_NM)                    if bond.r0 is not None else 0.0
+                b0 = bond.r0 * _ANG_TO_NM
                 # LAMMPS: E = K*(r-r0)^2  |  GROMACS: V = (kb/2)*(r-r0)^2  => kb = 2*K
-                kb = (2 * bond.kr * _KCAL_TO_KJ / _ANG_TO_NM**2) if bond.kr is not None else 0.0
+                kb = 2 * bond.kr * _KCAL_TO_KJ / _ANG_TO_NM**2
                 f.write(_BONDS_FMT.format(ai+1, aj+1, 1, b0, kb))
             f.write("\n")
 
+        graph = nx.Graph()
+        graph.add_edges_from(bond_idxs)
+        pairs = sorted((a, b) for a, distances in nx.all_pairs_shortest_path_length(graph, cutoff=3)
+                       for b, distance in distances.items() if a < b and distance == 3)
+        if pairs:
+            f.write("[ pairs ]\n; ai  aj  funct\n")
+            for ai, aj in pairs:
+                f.write(f"  {ai + 1}  {aj + 1}  1\n")
+            f.write("\n")
+
         # ------------------------------------------------------------------
         # [ angles ]
         # ------------------------------------------------------------------
@@ -167,9 +250,9 @@ def write_gromacs_itp(specie, filename=None):
             f.write(_ANGS_HDR.format("ai", "aj", "ak", "funct", "th0(deg)", "cth(kJ/mol/rad2)"))
             for (ai, aj, ak), tid in zip(angle_idxs, angle_tids):
                 angle = specie._atype[tid]
-                th0 = angle.theta0                          if angle.theta0 is not None else 0.0
+                th0 = angle.theta0
                 # LAMMPS: E = K*(θ-θ0)^2  |  GROMACS: V = (kt/2)*(θ-θ0)^2  => kt = 2*K
-                cth = (2 * angle.kr * _KCAL_TO_KJ)         if angle.kr    is not None else 0.0
+                cth = 2 * angle.kr * _KCAL_TO_KJ
                 f.write(_ANGS_FMT.format(ai+1, aj+1, ak+1, 1, th0, cth))
             f.write("\n")
 
@@ -195,10 +278,10 @@ def write_gromacs_itp(specie, filename=None):
                 vals = dih.values  # [K1, K2, K3, K4, K5?]
                 for vi, n, phi0 in opls_map:
                     K = vals[vi]
-                    if K is None or K == 0.0:
+                    if K == 0.0:
                         continue
                     kphi = K / 2.0 * _KCAL_TO_KJ
-                    f.write(_DIHS_FMT.format(ai+1, aj+1, ak+1, al+1, 9, phi0, kphi, n))
+                    f.write(_DIHS_FMT.format(ai+1, aj+1, ak+1, al+1, 9, phi0, kphi, int(n)))
             f.write("\n")
 
         # ------------------------------------------------------------------
@@ -217,14 +300,14 @@ def write_gromacs_itp(specie, filename=None):
                 imp      = specie._itype[tid]
                 K, d, n  = imp.values
                 phi0 = 0.0 if d == 1 else 180.0
-                kphi = (K * _KCAL_TO_KJ) if K is not None else 0.0
-                f.write(_DIHS_FMT.format(ai+1, aj+1, ak+1, al+1, 4, phi0, kphi, n))
+                kphi = K * _KCAL_TO_KJ
+                f.write(_DIHS_FMT.format(ai+1, aj+1, ak+1, al+1, 4, phi0, kphi, int(n)))
             f.write("\n")
 
 
 
 def write_gromacs_top(universe, itp_files, filename="system.top",
-                      system_name="MD System"):
+                      system_name="MD System", *, species=None):
     """
     Write a GROMACS system topology (.top) file.
 
@@ -239,13 +322,16 @@ def write_gromacs_top(universe, itp_files, filename="system.top",
         Output filename. Default ``"system.top"``.
     system_name : str, optional
         Title written in the ``[ system ]`` section.
+    species : sequence of Specie, optional
+        Species whose atom types are written before the molecule includes.
+        These ITP files must be written with ``include_atomtypes=False``.
+        Also validates residue identity against the assembled universe.
     """
-    # Preserve the order molecules appear in the GRO/universe so that
-    # [ molecules ] matches the coordinate file exactly.
-    seen = {}
-    for res in universe.residues:
-        name = res.resname
-        seen[name] = seen.get(name, 0) + 1
+    records = None
+    if species is not None:
+        records = _atomtype_records(_prepare_species(species, universe))
+    runs = [(name, sum(1 for _ in group))
+            for name, group in groupby(universe.residues.resnames)]
 
     with open(filename, "w") as f:
         f.write("; GROMACS topology file generated by mdinterface\n\n")
@@ -255,6 +341,9 @@ def write_gromacs_top(universe, itp_files, filename="system.top",
         f.write("; nbfunc  comb-rule  gen-pairs  fudgeLJ  fudgeQQ\n")
         f.write("  1       3          yes        0.5      0.5\n\n")
 
+        if records:
+            _write_atomtypes(f, records)
+
         for itp in itp_files:
             f.write(f'#include "{itp}"\n')
         f.write("\n")
@@ -264,6 +353,6 @@ def write_gromacs_top(universe, itp_files, filename="system.top",
 
         f.write("[ molecules ]\n")
         f.write("; {:<14}  {:>6}\n".format("molecule", "nmols"))
-        for resname, count in seen.items():
+        for resname, count in runs:
             f.write(f"  {resname:<14s}  {count:>6d}\n")
 

{mdinterface-2.0.0 → mdinterface-2.0.1}/mdinterface/utils/auxiliary.py

@@ -192,3 +192,9 @@ def round_list_to_sum(lst, target_sum, decimals=3):
             difference -= adjustment
     
     return rounded_list
+
+
+def _clean_charge(value):
+    """Normalize charge-report roundoff within 1e-12 e without rounding charges."""
+    value = float(value)
+    return 0.0 if abs(value) <= 1e-12 else value

{mdinterface-2.0.0 → mdinterface-2.0.1}/mdinterface.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdinterface
-Version: 2.0.0
+Version: 2.0.1
 Summary: Build Interface Systems for Molecular Dynamics Simulations
 Author-email: Fabrice Roncoroni <fabrice.roncoroni@gmail.com>
 License-Expression: Apache-2.0

{mdinterface-2.0.0 → mdinterface-2.0.1}/mdinterface.egg-info/SOURCES.txt

@@ -107,6 +107,7 @@ tests/test_chemistry.py
 tests/test_compartment.py
 tests/test_database.py
 tests/test_distribution_contents.py
+tests/test_gromacswriter.py
 tests/test_imports.py
 tests/test_ligpargen.py
 tests/test_parameterization.py
@@ -114,4 +115,8 @@ tests/test_regions.py
 tests/test_solvent.py
 tests/test_specie.py
 tests/test_structure_metadata.py
-tests/test_topology.py
+tests/test_topology.py
+tests/data/gromacs/README.md
+tests/data/gromacs/benzene.json
+tests/data/gromacs/ethanol.json
+tests/data/gromacs/methane.json