Python API

The atom and bond properties that can label a structure: {"atom": [{id, title, group}], "bond": [...]}.

The stages of a named equilibration protocol ("larsen21", "annealing", "pushoff"), one per line (K, atm, ps).

The water models CAPS has (SPC, SPC/E, SPC/Fw, TIP3P and its CHARMM and Ewald forms, TIP4P, TIP4P-Ew, TIP4P/2005, TIP4P/Ice, OPC): id, name, citation, sites, geometry, charges and Lennard-Jones. Apply one with doc.edit(op="water_model", model=id) and type the waters with it by a group {"molecules": "water", "water": id}.

Opens a structure or trajectory (LAMMPS data/dump, GROMACS .gro, PDB, XYZ, mol2, CIF …). first, last (inclusive) and stride keep only those file frames (counted from 0) of a trajectory: a LAMMPS dump's other frames are passed over unread and reading stops after last, so a long run is held at the size of what is kept.

Molecules packed into a periodic box with no two atoms of different molecules closer than tolerance (Å), as packmol does: molecules = [("CCO", 50), ("mol.pdb", 3), (doc, 10) …] — SMILES, structure files or documents with their counts — in box = edge or (x, y, z) Å; density compresses the packed cell to that g/cm³. Or inp = a packmol input file. forcefield types the cell, relax minimises it.

The library of literature many-body potentials (data/potentials): [{id, name, style, file, elements, for, citation, units}], file as an absolute path. A group of Field.assign_groups takes one by its id.

The structure a CAPS Studio macro runs on (Macro › Target: the open structure): the Studio saves it and names the file in CAPS_DOC. Outside the Studio, set CAPS_DOC to a structure file.

Gives the macro's result back to CAPS Studio (it opens it when the macro ends): saved to CAPS_OUT, else to result.data beside the script. Returns the path.

Opens a file that has no topology (XYZ, PDB, CIF …) with the Import choices: bonds "perceive" (covalent radii + tolerance Å), "file" or "none"; bond orders and aromaticity; molecules by connectivity; unwrapping; the cell.

What import_file would make of frame 0: counts, cell, bond orders and the first lines.

Runs a recipe (a dict, YAML/JSON text, or a path to one) as caps run does: build → type → grow → relax → md → equilibrate → analyze → export. Returns the structure; .properties and .files hold what the recipe analysed and wrote. progress(event) gets {stage, stages, name, status, detail, fraction}; return False to stop.

Chains of a repeat unit (SMILES with two * points, or a list of them for copolymers — sequence alternating, block with blocks=[…], random with weights=[…], gradient, pattern="AAB", terminal with r1, r2 and weights=[f1, f2]) grown in a periodic cell: one chain in a roomy cell by default (0.1 g/cm³), a melt with chains=… density=…. Atactic chains: pm (Bernoulli) or p_mr, p_rm (first-order Markov). Polydisperse: lengths={"distribution": "schulz-zimm", "nn": 40, "pdi": 1.1, "seed": 1} or chain_dp=[…]; the provenance records the sample drawn. Branched molecules: architecture="star" with arms=3|4 (each arm dp units on one core carbon), "comb" with arm_dp and spacing, or "branched" with arm_dp and branch_probability, "dendrimer" with arms, arm_dp and generations (each end splits in two branches of arm_dp units per generation); chains counts molecules. forcefield types it (default: the built-in GAFF for C and H, else UFF); relax=True minimises. region={"shape": "slab", "thickness": 30, "vacuum": 30} grows a film, {"shape": "cylinder" | "around_cylinder", "radius": 10} chains in or around a cylinder along z. method: "trials" (the roomiest of k trials), "rosenbluth" (a trial drawn by its Boltzmann weight: soft spheres and butane torsions) or "rosenbluth_lj" (the same with UFF Lennard-Jones), at method_temperature (K). orientation={"axis": "z", "strength": 4} grows oriented chains (an aligning field −s P₂ in kT on each unit's backbone chord; the report gives ⟨P₂⟩). head_cap / tail_cap: end groups in place of the end hydrogens (hydrogen, methyl, ethyl, tert-butyl, sec-butyl, phenyl, hydroxyl, carboxyl, vinyl, amine, or a SMILES with one *), bonded to the atom at the unit's first / second *.

The loaded libcaps (loaded on first use).

The provenance saved beside a file (<file>.provenance.json); {"ok": False, ...} without one.

Two manifests step by step: the parameters and seeds that differ.

BibTeX of every method a manifest cites.

A methods paragraph for a paper from a manifest: {"text": ..., "refs": [...]} with numbered references.

Chain lengths drawn from a distribution (monodisperse, schulz-zimm, flory, poisson): {lengths, sample {nn, mn, mw, pdi, min, max, sum}, target {…}, curve {n, number, weight}}. m0 is the repeat unit's molar mass (g/mol).

{name: bead SMILES} for a coarse-grained force field (its sources' molecule templates).

The terminal (Mayo–Lewis) model: {F1, paa, pbb, run_a, run_b, azeotrope, curve {f1, F1}, sequence, chain {…}}; sequence is what polymer(…, sequence="terminal") grows for its first chain at this seed.

Bernoulli (pm) or first-order Markov (p_mr, p_rm) triads and pentads; with dyads ("mrrm…", e.g. from Document.tacticity()) the counted values; with measured (ten pentad fractions, NMR) Bernoulli and Markov fits.

Flory–Huggins binary blend with χ = a + b/T: {chi_c, phi_c, tc, chi_t, coexist, spinodal, binodal {phi, t}, spinodal_curve {phi, t}}.

Hildebrand χ ≈ V(δs − δp)²/RT + 0.34 for [{name, v (cm³/mol), delta (MPa½)}]: [{name, chi, predicted}]. It ignores polarity and hydrogen bonding: check it against known behaviour.

β from erfc(β rc) = tolerance and the PME mesh (FFT sizes with factors 2, 3, 5, 7) for edges or doc's cell.

Flory–Huggins χ from the energy of mixing by MD (core chimd.hpp): A alone, B alone and a mixture, each relaxed and run NPT, χ = V_ref (φ_A CED_A + φ_B CED_B − CED_mix) / (RT φ_A φ_B). Enthalpic only and noisy: natural rubber against itself (χ must be 0) gives −1.2 ± 0.5 after 300 ps per cell, so run long, use larger cells and run the self-mixing control (polymer_b = polymer) beside it. polymer / polymer_b: repeat-unit SMILES; solvent: SMILES. Takes minutes to hours.

Flory–Huggins χ(T) from pair contacts (Fan, Olafson, Blanco & Hsu, Macromolecules 1992; core chipair.hpp): pair energies of rigid molecules at van der Waals contact, Boltzmann-averaged, and coordination numbers from packing; χ = ½(Z_AB E_AB + Z_BA E_BA − Z_AA E_AA − Z_BB E_BB)/RT, fitted to A + B/T. a, b: SMILES of molecules or repeat units (* ends capped with H). forcefield: a library id (gaff2 by default) or a path; None for the built-in GAFF subset / UFF. A screen, measured on known cases in the README (wrong for PS/THF and PS/PVME). Seconds.

The names of the built-in reaction templates (Document.react).

The text of a built-in reaction template (edit it and pass the text to Document.react).

A LAMMPS fix bond/react set (pre- and post-reaction molecule files and the map file) as a CAPS reaction template: {text, notes}; text goes to Document.react(). masses_from: a data file whose Masses give the elements.

The reaction library (data/reactions/library.json): every scheme — name, category, description, mapped reactant and product SMILES, what each map number marks — with its CAPS template (template, for Document.react) or why it does not convert (error; steps names the schemes that make it step by step).

Adds the hydrogens every atom lacks (valence rules); returns how many.

Adsorption locator: adsorbates [(smiles, count), …] added after the structure and placed by Monte Carlo simulated annealing as rigid bodies on the fixed structure (region "cell" or "above" its top face). The document's frames become the configurations kept, the lowest last. Returns {adsorption_energy, adsorbate_substrate, adsorbate_adsorbate, components: [{name, molecules, de_dn}], configs, notes}.

Properties of the frames (the ids of caps analyze: density, rdf, sq, xray, electron, neutron, rg, ree, cn, persistence, msd, diffusion, ced, ffv (radii="bondi" | "uff" | "forcefield"), zprofile / adhesion / interaction / orientation (surface="1-3,7" molecule ids, axis="x" | "y" | "z", zbin=0.5) …; tg runs a stepwise cooling of a copy, t_start/t_end/t_step/ps_per_step in options). A list of {id, name, value, error, unit, ...}.

The document's frames become one period of normal mode `mode` (1 = the lowest), the largest atom displacement `amplitude` Å. Returns {wavenumber, modes, reduced_mass, ir, frames, notes}.

One text per atom of the frame: any kind of label_kinds()["atom"] (element, element_name, charge, formal_charge, oxidation_state, hybridisation, mass_number, xyz, …; also "rs", "ez").

Each atom's view state: 0 shown, 1 ghost, 2 hidden.

A Kremer–Grest melt (mapped to real units) back to all atoms, one repeat unit (SMILES with two *) per bead: all-atom chains of the melt's lengths grown, each unit carried onto its bead, relaxed with the default force field. A new Document; assign a force field (e.g. gaff2) on it for runs.

(i, j, text) per bond: any kind of label_kinds()["bond"] (order, chemical, length, ff_r0, energy, …).

The reactions as a LAMMPS fix bond/react set in directory (templates as for react()): STEM.data, STEM.in and per template and environment _pre.mol, _post.mol, _map.txt, typed with the force field before and after the reaction. Options: stem, radius, variants, keep_byproducts, between_chains, weights, nevery, rmax, temperature, steps, dt, seed; forcefield: type the reactions with this force field (a library id such as opls2005, pcff, compass, or a path) instead of the assigned one, charges: auto | forcefield | gasteiger | qeq; lammps_styles (native: the force field's own styles, as export_engines | exact), kspace (auto | pppm | ewald | dsf | cut), kspace_accuracy, lammps_cutoff — the same force-field part as export_engines writes; survey_after: [0.25, 0.5] — templates also cut from copies cured by CAPS React to these conversions (steps whose groups appear only as the cure goes on; "first" / "second" variants of a two-step crosslinker), survey_relax; type_groups: [{"name": "PBS", "molecules": "33-50"}, …] (or "atoms": "1-407", "tag": name) — atom types split by component, numbered in that order, in the data file and every template, each a LAMMPS group; targets: [0.2, 0.4, …], limiting, link_reactions: ["enr_acid_ester_*"], check_every, max_steps — the input runs to each crosslink density, writes crosslink_progress.dat and STEM_XL20.data …; stall_chunks, rmax_step, rmax_limit raise Rmax when no reaction happens (the check uses the absolute Rmax and stops at the limit); stabilize_steps (200): steps each reaction's atoms stay under nve/limit afterwards (react … stabilize_steps); h_transfer_max (3.5 Å; 0: none): a hydrogen that changes partner must be this close to its new partner before the reaction happens (a distance constraint in each map file); every template is checked for LAMMPS's rule — each atom linked to an initiator without passing an edge atom — and atoms beyond an edge are left out (the notes say how many); mol_ids: reset | keep | molmap (keep_chain_ids=True: molmap — chains keep their ids, a crosslinker takes the id of the chain it first bonds to; LAMMPS 2 Apr 2025 or later). Returns {files, notes, variants, steps (coverage per reaction step), frames, link_reactions, candidates, covered}.

Bonds from rules [{"a": "C", "b": "C", "max": 1.68}, {"a": "Zn", "b": "O", "never": True}]: what they would give (bonds now and after, added, removed); apply=True sets them (one undoable edit).

This all-atom structure (every frame) mapped to beads — scheme unit | backbone_side | backbone_n | rules — with a bead model: Boltzmann-inverted harmonic bonds and angles, a repulsive WCA from the non-bonded bead g(r). rules (scheme "rules"): a preset id of data/cg/mapping_rules.json ("ester-cut") or a dict {"cut": [SMARTS], "names": {"B": SMARTS}, "position": "com"} (also "beads": {name: fragment SMARTS} or "explicit": [bead per atom]). A new Document (its model assigned); .report holds the inverted parameters (JSON).

Conformer search (in vacuum) of the frame shown or of the selected atoms: random staggered torsions ("torsions") or quenched snapshots of a 1000 K run ("anneal"), minimised and clustered by heavy-atom RMSD. The document's frames become the conformers, lowest first. Returns {conformers: [{energy, relative, population, found}], rotors, trials, notes}.

A new document at another resolution: "united-atom" (H on carbon folded in) or "coarse-grained" (beads of per_bead backbone atoms at their centre of mass); this one is unchanged.

One structure edit (the Studio's builder tools): edit(op="add_h"), edit(op="attach", target=5, smiles="*C(=O)O*") …

The current frame's energy by term (kcal/mol) with the force field runs use: bond, angle, dihedral, improper, vdw, coulomb, total — computed now (a Field report's energy is the one at assignment).

Runs an equilibration protocol from the current frame: "larsen21" (Larsen et al. 2011, 21 steps: t_max, p_max ramps down to temperature and pressure), "annealing" (cycles between t_low and t_high, ramp_ps and hold_ps), "pushoff", or protocol text written by hand (one stage per line, as protocol_text gives). until_converged adds NPT blocks of block_ps until density, energy and Rg stop drifting (at most max_blocks); .checks then holds the checks. Returns True when converged (or when no checks were asked for); the recorded frames become the document's frames.

The simulation files for LAMMPS (stem.data, stem.in with every pair_coeff and the run) and GROMACS (stem.top, stem.itp, stem.gro, stem.mdp; stem_em.mdp when a run minimises first) from the assigned force field, which must be complete. run: check | none | minimize | nvt | npt | tensile | creep | shear (LAMMPS: axis "x"/"y"/"z", strain_rate 1/ps and max_strain; stress_mpa; shear_rate 1/ps — stress_strain.dat, creep.dat, viscosity.dat) | protocol (protocol "larsen21", "annealing", "pushoff" or a protocol's text, t_max, p_max, production_ps: CAPS's stages in LAMMPS, -var scale shortens them); opts: minimize_first, temperature (K), pressure (atm), dt (fs), steps, thermo_every, dump_every, seed, units (auto | real | metal: LAMMPS in eV, ps, bar — automatic for AIREBO / REBO, which LAMMPS reads in metal units only), amber=True (stem.prmtop and stem.inpcrd for AMBER / OpenMM / ParmEd; a force field AMBER cannot hold gives amber_error), dlpoly=True; type_groups=[{"name": "PBS", "molecules": "7-10"}, …] ("atoms": "1-407" or "tag": name) splits the LAMMPS files' atom types by component (each group's types numbered in that order, the same coefficients; each a LAMMPS group by type). Returns {folder, files, notes, checks}; raises CapsError when refused.

The view's scene for other tools: "pov" (POV-Ray, with this camera), "glb" (glTF: Blender, ParaView) or "obj" (+ .mtl); the format follows the file's extension when not given. Returns {spheres, cylinders, triangles}.

A fragment's SMILES from atoms of the frame (0-based; None: the selection): those atoms and their hydrogens, each bond leaving them an attachment point * — "c1(ccccc1)*" for the ring of ethylbenzene.

Ghost these atoms: drawn faint, never picked (the view and its images only).

Hide these atoms (indices; None: all) in the view and its images. The structure, its exports and calculations keep them. Returns how many changed.

Holds atoms in place in relax, md and equilibration (no force, no motion; a freeze group in GROMACS files): molecule > 0 holds that molecule (an interface's surface is 1), atoms (indices from 0) any others; hold() frees them.

What add_h would add, by kind of atom: {rows: [{label, atoms, hydrogens}], heavy, h, add, …} (bond orders from the geometry when the structure has no H and no multiple bonds).

Inserts count copies of a molecule (SMILES; hydrogens added, UFF-cleaned) into the free space of the current frame — curatives before a cure, e.g. insert("SS", 40) for the sulfur_allylic template. The document becomes that frame and its force-field assignment is cleared (assign again after).

The structure's layers: molecules grouped by kind (residue name and formula), each molecule with its atom count, a profile along z (8 bins, peak 1), its view state (shown, ghost, hidden, mixed), lock and selected atoms.

Lock these atoms (None: all) against picking and edits in the Studio, or free them (locked=False).

Molecular dynamics from the current frame; the frames recorded become the document's frames. respa > 1: r-RESPA, the bonded forces every dt / respa (e.g. dt=2, respa=4 with hydrogens). constraints "h-bonds" (bonds to hydrogen, rigid water) or "all-bonds": SHAKE/RATTLE, for dt=2 (the alternative to respa). thermostat "nose-hoover" with barostat "mtk" runs as LAMMPS's fix nvt / fix npt iso. constraint_solver "lincs" puts the positions back on the constraints with LINCS (as GROMACS), "shake" with SHAKE (as LAMMPS); the same result to the tolerance.

The harmonic vibrations of the frame shown (minimise it tightly first): {value: ZPE kcal/mol, extra: {modes, imaginary modes, S_vib, Cv_vib …}, series: [IR spectrum (fixed charges), density of states, mode wavenumbers]}.

Bond rules: per pair of elements, the distances between their atoms as a histogram (counts from lo in steps of bin), the bonds the structure has between them, and the suggested cut-off (the first gap after the bonded peak).

A probe from atoms (0-based) in the frame shown: "point" (mass-weighted centre), "plane", "axis" or "ellipsoid" — its centre, principal directions (largest first), semi-axes and rms (a plane's flatness).

A probe measured against another over every frame: a, b as (kind, atoms); measure "distance" (Å; above a plane along its normal), "angle" (degrees), "rms" or "size". One value per frame.

The steps that produced this structure: doc.provenance() is the manifest (caps-manifest/1.0, written beside the file on save); doc.provenance.methods(), .citations(fmt="bibtex"|"text"), .bibtex().

Selects by the query grammar (design/boards/SmartSelect): smarts "c1ccccc1", element C N O, type c3, chain 1-4, index 1-20, ring 5, stereo R|S|*, within 5.0 of <query>, sel, combined with and / or / not / ( ). op "preview" counts without selecting. Returns the number of atoms.

Crosslinks the current frame cycle by cycle (Polymatic-style; REACTER-style capture and probability) with reaction templates: built-in names ("cc_crosslink", "sulfur_allylic", "peroxide_allylic", "polysulfide_allylic", "epoxy_amine_primary", "enr_acid_ester", "ester_condensation", "anhydride_alcohol", …; see reaction_templates()) or template text, one or a list. target is the conversion to stop at (0 … 1); crosslinks=("per_chain", 1.5) (or "crosslinks", "density" in mol/m³, "mc" in g/mol) stops at a number of links between chains instead. between_chains: bonds only between different chains; keep_byproducts: H2 / H2O stay as molecules; weights: one relative rate per template (else the closest pairs first); auto_capture widens the capture when no pair is found. The assigned force field types and relaxes every cycle and is re-assigned to the product (default_field=True: the built-in default, the assignment dropped). sites_per_chain: at most this many of each chain's reactive sites react (react_sites() counts them). Returns the report; network numbers in react_summary().

Each chain's reactive sites for the templates (built-in names or text, as for react()): chains [{chain, sites, units, atoms, mass}], total_sites, chains_n, units (repeat units), mass and repeat_unit_mass (g/mol).

The network of the last react(): chains, crosslinks (links between chains), target, density (mol/m³), per_chain, mc (g/mol), byproducts, the force field during and after the run.

Minimises the current frame with the Field assignment (else the built-in GAFF): 0 converged, 1 not quite. restraints: [(i, j, r0), …] or [(i, j, r0, k), …] — k (r − r0)² between atoms i and j (indices from 0, Å, k kcal/mol/Ų, default 10); dihedral ones as {"i", "j", "k", "l", "phi0", "kphi"} dicts; they stay set for later relaxations until relax(restraints=[]) clears them. box_axes: "z", "xy" … relaxes the box axis by axis (only those axes move); "" keeps the isotropic box relaxation (box=True). pushoff_md_ps > 0: the push-off by NVT MD first (Auhl et al. 2003), the LJ force cap raised to pushoff_cap (default 500 kcal/mol/Å) over that time.

A PNG of the current frame. engine="raytrace" traces it (CAPS's ray tracer: ambient occlusion, soft shadows, depth of field as a fraction of the view's half-width, e.g. 0.012 soft, 0.035 strong); bits=16 keeps 16 bits.

Sites, hydrogens and mass all-atom, united-atom and coarse-grained (mass conserved).

Molecules ("1-3,7"; "" none) that move as rigid bodies in the LAMMPS inputs written by export_engines (fix rigid/nvt/small; pairs inside a body excluded). CAPS's own runs have no rigid bodies. Returns how many.

Writes the current frame: .data (LAMMPS, with force-field sections when assigned), .pdb, .xyz, .mol2, .gro, .cif (P 1), .vasp or a file named POSCAR/CONTCAR (VASP 5, Direct; held atoms as Selective dynamics) …

Writes stem.top, stem.gro and stem.mdp for GROMACS with the same force field (a single-point run; energies and forces checked against GROMACS by bench/ff/check_gromacs.py). Returns the .mdp non-bonded settings, with "; note:" lines where GROMACS computes differently (DSF becomes PME; no cell).

The current frame for a viewer: z, xyz (flat), bonds (flat pairs), colours, radii, cell.

Show these atoms again (None: every hidden and ghosted atom).

Sorption of a gas in the frame held fixed: Widom insertion (excess chemical potential, Henry constant, solubility) and GCMC at each pressure (kPa). mixture: [(smiles, mole fraction), …] for an ideal gas mixture (each species at y_i p; per-species loadings, isosteric heats and selectivities over the first). Returns {widom_w, mu_ex, henry_mol_kg_kpa, solubility, species: [...], isotherm: [{pressure_kpa, loading, species_loading, selectivity, heat, ...}], notes}.

Tag these atoms (0-based; None: the selection) with NAME. op: "set" (exactly these), "add", "remove", "delete" (the tag itself), "rename" (atoms is then the new name) or "colour". Returns the tag's index.

The structure's tags: name -> list of atom indices (0-based). Tags are saved beside the structure (NAME.tags.json) and written as groups in LAMMPS inputs and GROMACS index files; analyze(group="tag:NAME") analyses one.

An interactive view for notebooks (drag to rotate, wheel to zoom, double-click to reset); a PNG where HTML is not shown. style: ball-and-stick, space-filling, sticks, no-hydrogens, lines; cell: draw the periodic cell (default: when there is more than one molecule).

A coarse-grained molecule: a bead template of the force field (MARTINI's DPPC, W, NA+ …; bead_templates()) or bead SMILES ("[Q0+1][Qa-1][Na]…"); one site per bead named by its type, bonds at the force field's lengths.

A polymer (repeat-unit SMILES with two *) coarse-grained from an all-atom reference melt: chains × dp grown, compressed to density (g/cm³) and mapped (see Document.cg_map). .report holds the inverted parameters. ibi: {"iterations": 6, "run_ps": 20} refines the non-bonded pair by iterative Boltzmann inversion (a table).

A coarse-grained melt (caps cgbuild): beads_per_unit={"BS": ["B", "S"], "BA": ["B", "A"]}, composition={"BS": 0.8, "BA": 0.2}, sequence bernoulli | markov (markov={"BA": {"BA": 0.9, "BT": 0.1}, …}) | block (blocks=[20, 10]) | gradient | alternating | pattern, lengths={"distribution": "schulz-zimm", "pdi": 2} (dp is the number average), bonded: the folder of caps cgfit bonded, maps: map.json file(s) for the bead masses (or masses={"B": 88.1, …}), reference: [map.json, frames …] of the all-atom chains to compare ⟨R²(n)⟩/n with. Writes OUT/melt.cg.data, melt.map.json, melt.internal.csv and in.cg_equil; returns the report (box, ree_rms, text …).

sites: [("Ti1", "Ti", x, y, z), …] (fractional).

A Kremer–Grest bead-spring melt with its own force field (FENE + WCA; cosine bending k_theta). Reduced units, or mapped to a polymer when sigma (Å), temperature (K, ε = k_B T) and bead_mass (g/mol) are all given; export_engines writes its LAMMPS deck (push-off, then the run).

A MARTINI polymer melt: chains of `repeats` × the repeat unit's bead SMILES ("[C1]", "[SN0]" …) packed, the MARTINI force field (a library id or a path) assigned and the cell compressed to the density (g/cm³) with it.

kind="tube" (n, m, length, periodic) | "sheet" (lx, ly, layers) | "particle" (crystal CIF, shape, radius; a metal particle takes thiolate="C6" | "C12" | "C18" | "MPA" | "MUA" | "MHA" | "*S…" SMILES and thiolate_fraction).

A 3D molecule from SMILES (one frame per conformer, lowest first). rotor_search: each minimised conformer's rotatable bonds tried at their staggered positions with the force field; hydrogens: "add" (from valences) or "as_written" (heavy atoms only, united-atom models).

Solvent and ions around a solute (or a box of solvent): shape, edge, padding, solvent, water_model, ion_mode, salt, concentration …

Per-particle columns by name: "Particle Identifier", "Molecule Identifier", "Particle Type", "Element", "Charge", "Selection", "Backbone" (1 on backbone atoms), "Position" (N × 3) and any property earlier steps made.

Marks the function CAPS calls: modify(frame, data).

The runs of one condition: r["density"] → (mean, standard deviation, n) over the runs that have it.

A sweep folder: its runs and the result of each condition.

The newest sweep folder (under ~/CAPS/sweeps).

One condition (a tacticity) of a sweep, its seeds pooled: the newest sweep unless folder is given.

Runs every (tacticity, DP, seed); failures are recorded, not raised. tg={"t_start": 500, "t_end": 200, "t_step": 25, "ps_per_step": 20} adds a stepwise-cooling Tg to each run (slow). progress(run, status) is told as runs finish.

Bond angles (degrees) along a chain of points.

Dihedral angles (degrees) along a chain of points: one per four consecutive points.