samgen 0.1.2__py3-none-any.whl

samgen/__init__.py

@@ -0,0 +1,17 @@
+"""samgen — build self-assembled monolayer (SAM) surfaces for GROMACS.
+
+Three independently runnable stages:
+    generate_geometry()  -> tiled surface .gro (no force field needed)
+    assemble_topology()  -> integrated topol.top + reordered .gro
+    build()              -> geometry then topology in one shot
+"""
+
+from .geometry import generate_geometry, build_twosided_strand, generate_twosided
+from .topology import assemble_topology
+from ._build import build
+
+__all__ = [
+    "generate_geometry", "build_twosided_strand", "generate_twosided",
+    "assemble_topology", "build",
+]
+__version__ = "0.0.1"

samgen/_build.py

@@ -0,0 +1,51 @@
+"""Stage 3: `build` = geometry then topology in one shot.
+
+Convenience path for one-sided surfaces (and two-sided where the parameterized
+strand already exists). Loads components from the config, runs geometry, then
+assembles the topology against the generated surface.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Dict, Optional
+
+from .core.molecule import Molecule
+from .geometry import generate_geometry
+from .topology import assemble_topology
+
+
+def load_components(config: dict, root: str = ".") -> Dict[str, Molecule]:
+    """Instantiate Molecules for every key in config['components'].
+
+    Also stashes per-component orientation metadata under config['components_meta']
+    (anchor, canonicalize, backbone_carbons) for the geometry stage.
+    """
+    comps: Dict[str, Molecule] = {}
+    meta: Dict[str, dict] = {}
+    for key, spec in config["components"].items():
+        gro = os.path.join(root, spec["gro"])
+        itp = os.path.join(root, spec["itp"]) if spec.get("itp") else None
+        comps[key] = Molecule.from_files(name=spec["resname"], gro=gro, itp=itp)
+        meta[key] = {k: spec[k] for k in ("anchor", "canonicalize",
+                                          "backbone_carbons", "allow_anchor_autodetect")
+                     if k in spec}
+    config["components_meta"] = meta
+    return comps
+
+
+def build(config: dict, root: str = ".", out_gro: str = "sam.gro",
+          out_top: str = "topol.top", out_reordered: Optional[str] = "sam-reordered.gro",
+          input_fn=input, is_tty=None):
+    """Full pipeline. Returns (surface_gro, top, counts)."""
+    components = load_components(config, root)
+    out = config.get("output", {})
+    geom = generate_geometry(config, components, out_gro=out_gro,
+                             manifest_path=out_gro + ".manifest.json", root=root,
+                             input_fn=input_fn, is_tty=is_tty)
+
+    order = out.get("order") or [m.name for m in components.values()]
+    itp_map = {m.name: m.itp_path for m in components.values()}
+    counts = assemble_topology(out_gro, itp_map=itp_map, order=order,
+                               out_top=out_top, out_gro=out_reordered)
+    return geom.surface_gro, out_top, counts

samgen/cli.py

@@ -0,0 +1,118 @@
+"""Command-line interface: `samgen geometry|topology|build CONFIG`.
+
+Mirrors the three independently runnable stages. Anchor handling follows the
+prompt-first / consent-to-guess policy: prompt in interactive mode, never
+silently auto-detect in batch mode without explicit consent.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+try:
+    import yaml
+except ImportError:  # keep import-light; yaml only needed for the CLI
+    yaml = None
+
+from ._build import build, load_components
+from .geometry import generate_geometry, generate_twosided
+from .topology import assemble_topology
+from .interactive import resolve_anchor_interactive
+
+
+def _load_config(path: str) -> dict:
+    if yaml is None:
+        sys.exit("PyYAML is required for the CLI: pip install pyyaml")
+    with open(path) as fh:
+        return yaml.safe_load(fh)
+
+
+def cmd_geometry(args):
+    cfg = _load_config(args.config)
+    root = os.path.dirname(os.path.abspath(args.config))
+    comps = load_components(cfg, root)
+    res = generate_geometry(cfg, comps, out_gro=args.out,
+                            manifest_path=args.out + ".manifest.json", root=root)
+    print(f"wrote {res.surface_gro} ({res.manifest['natoms']} atoms)")
+
+
+def cmd_topology(args):
+    cfg = _load_config(args.config)
+    root = os.path.dirname(os.path.abspath(args.config))
+    comps = load_components(cfg, root)
+    order = cfg.get("output", {}).get("order") or [m.name for m in comps.values()]
+    itp_map = {m.name: m.itp_path for m in comps.values()}
+    counts = assemble_topology(args.gro, itp_map=itp_map, order=order,
+                               out_top=args.out, out_gro=args.reordered,
+                               validate=args.validate)
+    print(f"wrote {args.out}: {counts}")
+
+
+def cmd_build(args):
+    cfg = _load_config(args.config)
+    root = os.path.dirname(os.path.abspath(args.config))
+    gro, top, counts = build(cfg, root, out_gro=args.out, out_top=args.top)
+    print(f"wrote {gro} and {top}: {counts}")
+
+
+def cmd_twosided(args):
+    cfg = _load_config(args.config)
+    root = os.path.dirname(os.path.abspath(args.config))
+    comps = load_components(cfg, root)
+    key = args.component or next(iter(comps))
+    if key not in comps:
+        sys.exit(f"component {key!r} not in config (have: {list(comps)})")
+    mol = comps[key]
+    specified = cfg["components"][key].get("anchor")
+    allow = cfg.get("allow_anchor_autodetect", False)
+    res = resolve_anchor_interactive(mol, specified, allow)
+    if res.cap_carbon_idx is None:
+        sys.exit(f"anchor {mol.struct.atoms[res.anchor_idx].atomname!r} has no "
+                 "methyl cap to strip; cannot build a shared-S two-sided strand")
+    tsr, geom = generate_twosided(mol, res.anchor_idx, res.cap_carbon_idx, cfg,
+                                  out_strand=args.out, out_surface=args.surface)
+    print(f"wrote two-sided strand {tsr.strand_gro} ({tsr.natoms} atoms) and "
+          f"geometry-only surface {args.surface} ({geom.manifest['natoms']} atoms). "
+          "Parameterize the strand, then build the surface from its .itp.")
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="samgen", description="Build SAM surfaces for GROMACS")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    g = sub.add_parser("geometry", help="tile a surface (no force field)")
+    g.add_argument("config")
+    g.add_argument("-o", "--out", default="sam.gro")
+    g.set_defaults(func=cmd_geometry)
+
+    t = sub.add_parser("topology", help="assemble topol.top for an existing .gro")
+    t.add_argument("config")
+    t.add_argument("--gro", required=True, help="existing surface .gro")
+    t.add_argument("-o", "--out", default="topol.top")
+    t.add_argument("--reordered", default="sam-reordered.gro")
+    t.add_argument("--validate", action="store_true", help="run gmx grompp gate")
+    t.set_defaults(func=cmd_topology)
+
+    b = sub.add_parser("build", help="geometry + topology in one shot")
+    b.add_argument("config")
+    b.add_argument("-o", "--out", default="sam.gro")
+    b.add_argument("--top", default="topol.top")
+    b.set_defaults(func=cmd_build)
+
+    w = sub.add_parser("twosided", help="build a two-sided (shared-S) strand + SAM geometry")
+    w.add_argument("config")
+    w.add_argument("--component", help="which component to fuse (default: first)")
+    w.add_argument("-o", "--out", default="twosided-strand.gro",
+                   help="output strand .gro (parameterize this)")
+    w.add_argument("--surface", default="twosided-sam.gro",
+                   help="output full two-sided SAM geometry (geometry-only)")
+    w.set_defaults(func=cmd_twosided)
+
+    args = p.parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

samgen/core/__init__.py

@@ -0,0 +1 @@
+"""Core building blocks: gro I/O, molecules, lattice, orientation, anchors."""

samgen/core/anchor.py

@@ -0,0 +1,140 @@
+"""Anchor (gold-facing S) and methyl-cap detection.
+
+Policy: prompt the user first; auto-detect ONLY with explicit consent, and
+always report what was picked and why. Detection never silently guesses.
+"""
+
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass
+from typing import Optional
+import numpy as np
+
+from .molecule import Molecule
+
+# Carbon mass (GAFF C2 united-atom CH2 ~14.03, c3 ~12.01). A methyl cap carbon
+# in these models is a carbon bonded to the anchor S and to nothing else heavy.
+_H_MASS = (1.0, 1.1)
+
+
+@dataclass
+class AnchorResult:
+    anchor_idx: int           # 0-indexed S atom
+    cap_carbon_idx: Optional[int]   # methyl cap carbon bonded to the anchor S
+    reason: str               # human-readable explanation (for the consent prompt)
+
+
+def resolve_anchor(
+    mol: Molecule,
+    specified: Optional[str | int],
+    allow_autodetect: bool,
+) -> AnchorResult:
+    """Resolve the anchor atom.
+
+    `specified` may be an atom name (e.g. "S41") or a 1-based index. If None and
+    autodetect is not permitted, raise so batch runs fail clearly.
+    """
+    if specified is not None:
+        idx = _resolve_specified(mol, specified)
+        return AnchorResult(idx, _find_cap(mol, idx), f"specified ({specified})")
+
+    if not allow_autodetect:
+        raise ValueError(
+            f"{mol.name}: no anchor specified. Set it in the config, or pass "
+            "allow_anchor_autodetect: true to consent to auto-detection."
+        )
+    return autodetect_anchor(mol)
+
+
+def autodetect_anchor(mol: Molecule) -> AnchorResult:
+    """Heuristic anchor detection. Only call after the user has consented.
+
+    Anchor = the gold-facing sulfur, detected as the S bonded to a terminal
+    methyl cap. Falls back to the lowest-z sulfur. Raises on ambiguity.
+    """
+    sulfurs = mol.sulfur_indices()
+    if not sulfurs:
+        raise ValueError(f"{mol.name}: no sulfur found; specify the anchor manually")
+
+    capped = [(s, c) for s in sulfurs if (c := _find_cap(mol, s)) is not None]
+    if len(capped) == 1:
+        s, c = capped[0]
+        name = mol.struct.atoms[s].atomname
+        return AnchorResult(s, c, f"S {name!r} bonded to methyl cap "
+                                  f"{mol.struct.atoms[c].atomname!r}")
+    if len(capped) > 1:
+        names = ", ".join(mol.struct.atoms[s].atomname for s, _ in capped)
+        raise ValueError(
+            f"{mol.name}: ambiguous anchor — multiple capped sulfurs ({names}). "
+            "Specify the anchor manually."
+        )
+
+    # Fallback: lowest-z sulfur (assumes a pre-oriented, S-down strand).
+    coords = mol.coords
+    s = min(sulfurs, key=lambda i: coords[i][2])
+    name = mol.struct.atoms[s].atomname
+    return AnchorResult(s, None, f"lowest-z sulfur {name!r} (no methyl cap found)")
+
+
+def _resolve_specified(mol: Molecule, specified: str | int) -> int:
+    if isinstance(specified, int):
+        return specified - 1  # 1-based -> 0-based
+    s = str(specified)
+    if s.isdigit():
+        return int(s) - 1
+    for i, atom in enumerate(mol.struct.atoms):
+        if atom.atomname == s:
+            return i
+    raise ValueError(f"{mol.name}: anchor atom {specified!r} not found")
+
+
+def backbone_head(mol: Molecule, anchor_idx: int, n_carbons: int = 9) -> int:
+    """Index of the Nth alkyl backbone carbon from the anchor S.
+
+    Walks the linear carbon chain from the anchor (skipping the methyl cap).
+    Used as the orientation 'head' so the tilt/twist axis follows the alkyl
+    spacer, not a divergent ligand headgroup. Warns and stops early if the
+    chain branches or ends before N carbons.
+    """
+    if mol.bonds is None or mol.masses is None:
+        raise ValueError(f"{mol.name}: backbone detection needs an .itp bond graph")
+
+    cap = _find_cap(mol, anchor_idx)
+    # approximation: O/N bonded in-chain would also pass this carbon test
+    # (fine for thiol alkyl SAMs).
+    starts = [nb for nb in mol.neighbors(anchor_idx)
+              if mol.masses[nb] >= 11.0 and nb != cap]
+    if not starts:
+        raise ValueError(f"{mol.name}: no alkyl chain carbon bonded to the anchor")
+
+    prev, cur, count = anchor_idx, starts[0], 1
+    while count < n_carbons:
+        nxt = [nb for nb in mol.neighbors(cur)
+               if mol.masses[nb] >= 11.0 and nb != prev]
+        if len(nxt) == 0:
+            warnings.warn(f"{mol.name}: alkyl chain ends after {count} carbons "
+                          f"(< {n_carbons}); orienting on the shorter segment")
+            break
+        if len(nxt) > 1:
+            warnings.warn(f"{mol.name}: alkyl chain branches at carbon {count}; "
+                          f"orienting on the segment up to the branch")
+            break
+        prev, cur = cur, nxt[0]
+        count += 1
+    return cur
+
+
+def _find_cap(mol: Molecule, sulfur_idx: int) -> Optional[int]:
+    """A methyl cap carbon: bonded to the S and to 3 H and no other heavy atom."""
+    if mol.bonds is None or mol.masses is None:
+        return None
+    for nb in mol.neighbors(sulfur_idx):
+        if mol.masses[nb] < 11.0:  # not a carbon
+            continue
+        heavy = [x for x in mol.neighbors(nb) if mol.masses[x] >= 11.0]
+        hyd = [x for x in mol.neighbors(nb) if mol.masses[x] < 11.0]
+        # carbon's only heavy neighbour is the sulfur, plus ~3 hydrogens
+        if heavy == [sulfur_idx] and len(hyd) >= 2:
+            return nb
+    return None

samgen/core/gro.py

@@ -0,0 +1,98 @@
+"""Robust GROMACS .gro reader/writer.
+
+The .gro format is fixed-width by column. We centralise that layout here so the
+rest of the package never touches raw columns.
+
+.gro fixed layout (1-indexed columns), positions in nm:
+    1-5    residue number
+    6-10   residue name
+    11-15  atom name
+    16-20  atom number
+    21-28  x   (%8.3f)
+    29-36  y
+    37-44  z
+    [45-52 53-60 61-68]  optional vx vy vz (%8.4f)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple
+import numpy as np
+
+
+@dataclass
+class GroAtom:
+    resid: int
+    resname: str
+    atomname: str
+    atomnum: int
+    x: float
+    y: float
+    z: float
+    # Velocities are preserved if present so we never silently drop data.
+    vel: Optional[Tuple[float, float, float]] = None
+
+
+@dataclass
+class GroStructure:
+    title: str
+    atoms: List[GroAtom]
+    box: Tuple[float, ...]  # 3 (or 9, for triclinic) box values, nm
+
+    @property
+    def coords(self) -> np.ndarray:
+        """N x 3 array of positions in nm."""
+        return np.array([[a.x, a.y, a.z] for a in self.atoms], dtype=float)
+
+    def set_coords(self, coords: np.ndarray) -> None:
+        for atom, (x, y, z) in zip(self.atoms, coords):
+            atom.x, atom.y, atom.z = float(x), float(y), float(z)
+
+    @property
+    def natoms(self) -> int:
+        return len(self.atoms)
+
+
+def read_gro(path: str) -> GroStructure:
+    with open(path) as fh:
+        lines = fh.read().splitlines()
+
+    title = lines[0]
+    natoms = int(lines[1].strip())
+    atoms: List[GroAtom] = []
+
+    for line in lines[2 : 2 + natoms]:
+        resid = int(line[0:5])
+        resname = line[5:10].strip()
+        atomname = line[10:15].strip()
+        atomnum = int(line[15:20])
+        x = float(line[20:28])
+        y = float(line[28:36])
+        z = float(line[36:44])
+        vel = None
+        if len(line) >= 68:  # velocities present
+            vel = (float(line[44:52]), float(line[52:60]), float(line[60:68]))
+        atoms.append(GroAtom(resid, resname, atomname, atomnum, x, y, z, vel))
+
+    box = tuple(float(v) for v in lines[2 + natoms].split())
+    return GroStructure(title=title, atoms=atoms, box=box)
+
+
+def write_gro(struct: GroStructure, path: str) -> None:
+    lines = [struct.title, f"{struct.natoms:5d}"]
+    for a in struct.atoms:
+        # GROMACS truncates resid/atomnum to 5 digits (mod 100000); match it so
+        # large surfaces stay valid .gro files.
+        resid = a.resid % 100000
+        atomnum = a.atomnum % 100000
+        line = (
+            f"{resid:5d}{a.resname:<5.5s}{a.atomname:>5.5s}{atomnum:5d}"
+            f"{a.x:8.3f}{a.y:8.3f}{a.z:8.3f}"
+        )
+        if a.vel is not None:
+            line += f"{a.vel[0]:8.4f}{a.vel[1]:8.4f}{a.vel[2]:8.4f}"
+        lines.append(line)
+    lines.append(" ".join(f"{v:.5f}" for v in struct.box))
+    with open(path, "w") as fh:
+        fh.write("\n".join(lines) + "\n")

samgen/core/lattice.py

@@ -0,0 +1,107 @@
+"""Hexagonal Au(111) lattice for SAM tiling.
+
+Geometry follows Love et al. 2005 (alkanethiolate
+(sqrt(3) x sqrt(3))R30 overlayer on Au(111)), lattice constant a = 0.288 nm:
+
+    colsep = sqrt(3) * a   (spacing along a row)
+    rowsep = 1.5 * a       (spacing between rows)
+    offset = sqrt(3)/2 * a (x-shift applied to alternate rows -> hex packing)
+
+Reference: Love, Estroff, Kriebel, Nuzzo & Whitesides, Chem. Rev. 105 (2005)
+1103-1169.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Iterator, Tuple
+
+
+@dataclass
+class Lattice:
+    a: float = 0.288  # Au(111) lattice constant, nm
+    # Optional explicit overrides. When None, spacings are computed from `a`.
+    # Lattice.rounded() supplies pre-rounded constants for a slightly different
+    # (rounded) spacing convention.
+    colsep_override: float | None = None
+    rowsep_override: float | None = None
+    offset_override: float | None = None
+
+    @classmethod
+    def rounded(cls) -> "Lattice":
+        """Pre-rounded spacing constants for a = 0.288 nm.
+
+        An alternative to the exact sqrt(3)*a spacing: colsep/rowsep/offset are
+        rounded to 3-4 decimals. Use when a rounded-constant cell is required.
+        """
+        return cls(a=0.288, colsep_override=0.499,
+                   rowsep_override=0.432, offset_override=0.2494)
+
+    @property
+    def colsep(self) -> float:
+        return self.colsep_override if self.colsep_override is not None else math.sqrt(3.0) * self.a
+
+    @property
+    def rowsep(self) -> float:
+        return self.rowsep_override if self.rowsep_override is not None else 1.5 * self.a
+
+    @property
+    def offset(self) -> float:
+        return self.offset_override if self.offset_override is not None else math.sqrt(3.0) / 2.0 * self.a
+
+    # Tiny epsilon so a strand sitting exactly on the box edge isn't double-
+    # counted by the "< box" fill condition.
+    _EPS = 1e-9
+
+    def dimensions(self, boxx: float, boxy: float,
+                   even_cols: bool = False) -> Tuple[int, int]:
+        """Return (ncols, nrows) for a *periodic* tile bounded by boxx x boxy.
+
+        Safeguards keep the final box a valid periodic cell:
+
+        * ncols is fixed by the first (non-offset) row and applied to EVERY row,
+          so offset rows aren't one strand short. Offset rows therefore extend
+          slightly past boxx by design.
+        * nrows is rounded up to an even number, so tiling always ends on a
+          complete A/B (non-offset/offset) row pair and stays periodic in y.
+        * `even_cols` rounds ncols up to even too. Patterned designs
+          (grid/density/multilig) require this so the 2-site stagger lines up
+          with the design grid; the uniform design does not.
+        """
+        ncols = int((boxx - self._EPS) // self.colsep) + 1
+        nrows = int((boxy - self._EPS) // self.rowsep) + 1
+        if even_cols and ncols % 2 == 1:
+            ncols += 1
+        if nrows % 2 == 1:          # complete the A/B row pair
+            nrows += 1
+        return ncols, nrows
+
+    def sites_for(self, ncols: int, nrows: int) -> Iterator[Tuple[int, int, float, float]]:
+        """Yield (row, col, x, y) for an explicit ncols x nrows tile.
+
+        Alternate rows are x-shifted by `offset` for hexagonal packing.
+        """
+        for row in range(nrows):
+            xstart = self.offset if (row % 2 == 1) else 0.0
+            y = row * self.rowsep
+            for col in range(ncols):
+                yield row, col, xstart + col * self.colsep, y
+
+    def sites(self, boxx: float, boxy: float,
+              even_cols: bool = False) -> Iterator[Tuple[int, int, float, float]]:
+        """Yield sites for the periodic tile bounded by boxx x boxy."""
+        ncols, nrows = self.dimensions(boxx, boxy, even_cols)
+        yield from self.sites_for(ncols, nrows)
+
+    def site_density(self) -> float:
+        """Au site areal density (sites per nm^2) = 1 / (colsep * rowsep)."""
+        return 1.0 / (self.colsep * self.rowsep)
+
+    def final_box(self, ncols: int, nrows: int, boxz: float) -> Tuple[float, float, float]:
+        """Periodic box that matches how many sites were actually placed.
+
+        Slightly different from the requested box: x and y snap to whole
+        multiples of colsep/rowsep so inter-strand spacing is preserved.
+        """
+        return (ncols * self.colsep, nrows * self.rowsep, boxz)

samgen/core/molecule.py

@@ -0,0 +1,81 @@
+"""A SAM component: coordinates plus (optional) force-field knowledge.
+
+When an .itp is supplied we parse just enough of it to support anchor detection
+and topology assembly: per-atom mass (to find sulfur by element, not by name)
+and the bond graph (to tell a terminal/anchor S from an in-chain thioether).
+We deliberately do NOT parse the full force field here — topology.py owns that.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+import numpy as np
+
+from .gro import GroStructure, read_gro
+
+
+@dataclass
+class Molecule:
+    name: str                 # residue name as it appears in the .gro / [molecules]
+    struct: GroStructure
+    itp_path: Optional[str] = None
+    masses: Optional[List[float]] = None          # per-atom, in itp atom order
+    bonds: Optional[List[Tuple[int, int]]] = None  # 0-indexed atom pairs
+
+    @property
+    def coords(self) -> np.ndarray:
+        return self.struct.coords
+
+    @classmethod
+    def from_files(cls, name: str, gro: str, itp: Optional[str] = None) -> "Molecule":
+        struct = read_gro(gro)
+        masses, bonds = (None, None)
+        if itp is not None:
+            masses, bonds = _parse_itp(itp)
+        return cls(name=name, struct=struct, itp_path=itp, masses=masses, bonds=bonds)
+
+    def sulfur_indices(self) -> List[int]:
+        """0-indexed atoms whose mass is ~32.06 (sulfur). Name-independent."""
+        if self.masses is None:
+            raise ValueError(
+                f"{self.name}: need an .itp to identify sulfur by mass"
+            )
+        return [i for i, m in enumerate(self.masses) if abs(m - 32.06) < 0.5]
+
+    def neighbors(self, atom_idx: int) -> List[int]:
+        if self.bonds is None:
+            raise ValueError(f"{self.name}: need an .itp bond graph")
+        out = []
+        for a, b in self.bonds:
+            if a == atom_idx:
+                out.append(b)
+            elif b == atom_idx:
+                out.append(a)
+        return out
+
+
+def _parse_itp(path: str) -> Tuple[List[float], List[Tuple[int, int]]]:
+    """Minimal .itp parse: [atoms] masses + [bonds] graph (first moleculetype)."""
+    masses: List[float] = []
+    bonds: List[Tuple[int, int]] = []
+    section = None
+    with open(path) as fh:
+        for raw in fh:
+            line = raw.split(";", 1)[0].strip()  # strip comments
+            if not line:
+                continue
+            if line.startswith("["):
+                section = line.strip("[] ").lower()
+                continue
+            if section == "atoms":
+                # nr type resnr resname atomname cgnr charge mass ...
+                cols = line.split()
+                if len(cols) >= 8:
+                    masses.append(float(cols[7]))
+            elif section == "bonds":
+                cols = line.split()
+                if len(cols) >= 2:
+                    # itp atom indices are 1-based -> store 0-based
+                    bonds.append((int(cols[0]) - 1, int(cols[1]) - 1))
+    return masses, bonds