Potential¶

LAMMPS pair_style lj/cut: the one-type cut Lennard-Jones / Mie kernel (n/m exponents) a neighbour loop feeds (MD's nonbond kernel). A pair list with a row per pair is ExplicitTerms("pair", "lj/cut", pairs, epsilon=..., sigma=...).compile().

evaluate_pairs(pos, neighbors, factor=None)

pair_energy_force(r2, disp)

Bases: Protocol

Structured force provider: one method, coordinates in, energy+forces out.

evaluate(pos)

Composite of the one Potential concept — itself a potential.

Potentials() is empty; push moves members in (a PairLjCut, another Potentials such as one ExplicitTerms.compile built, or an object with evaluate(pos) -> (energy, forces)). The engine is unit-agnostic: nothing scales the energy or forces implicitly.

evaluate(arg)

Kernels for a neighbour-driven evaluation, each with its special-bonds weights.

Opaque: hand it to an integrator. Taking it apart would mean

re-deciding which member is which and how its close neighbours are

scaled -- the two things PotentialCompiler.compile_typed decides once.

One style's terms over explicit instances (molrs::ff::compile::ExplicitTerms): atoms (n, arity), each per-term parameter a number (broadcast) or one value per term, as stored (angle values in degrees); style parameters (cutoff, coulomb, an unregistered style's expression) a number or a string. Works for every registered style, built-in or custom. A parameter the style does not declare raises TypeError.

compile()

Compiles a ForceField into evaluable kernels.

Owns a copy of the force field taken at construction; later edits to that ForceField do not reach it. compile(frame) binds a typed frame now; defer() returns Potentials that bind the frame they are evaluated on; compile_typed(frame) builds the kernels of a neighbour-driven (MD) evaluation. Both doors price a pair only inside its style's cutoff (r < cutoff, as LAMMPS; ∞ when the style states none).

Declare a force-field IR style as a class; defining the subclass registers it (:func:register_style).

Attributes¶

category : str The category (built-in, or from :func:register_category). name : str The style name. params : list of ParamSpec, or dict of {name: dim} The per-type parameters, in order. style_params : list of ParamSpec, or dict of {name: dim}, optional Style-level parameters (cutoff, mixing, special keep their reserved meanings). expression : str, optional The energy as an expression. special : {"lj", "coul"}, optional A pair style's special-bonds class. samples : list of dict, optional Registration samples, {"q": (lo, hi), <param>: value}. compound : bool kernel takes positions x ((n, arity, 3)), not q. replace : bool Replace a style of the name registered at run time. lammps : {"positional", "positional:"}, optional The style's LAMMPS form (:func:register_style's lammps).

A kernel(self, q, **params) -> (e, de_dq) method (or kernel(self, x, **params) -> (e, grad) for a compound style) prices the style by Python; with an expression beside it the two must agree. Pass register=False in the class statement for an intermediate base that declares no style.

Examples¶

import numpy as np from molrs.ff import style_registry class Quartic(style_registry.StyleDeclaration): ... category = "bond" ... name = "quartic/doc" ... params = {"k": "E/L^4", "r0": "L"} ... expression = "k*(r-r0)^4" ... def kernel(self, r, k, r0): ... d = r - r0 ... return k * d4, 4 * k * d3 e, de = Quartic.evaluate([1.5], k=2.0, r0=1.0) float(e[0]), float(de[0]) (0.125, 1.0) Quartic.unregister()

evaluate(q=None, *, x=None, **params)

unregister()