betaFeedback

WorksPhysics and Astronomy

IANN: A Unified Framework for Equivariant InterAtomic Neural Networks with User-Friendly Implementation

Abstract

Machine-learning interatomic potentials (MLIPs) now approach density functional theory (DFT) accuracy at a fraction of its cost, but the practical benefit is limited by software fragmentation: each state-of-the-art architecture is released as a separate codebase, with its own data format, configuration system, training loop and molecular-dynamics interface. Comparing two architectures on the same dataset, or moving a trained model into a production simulation, therefore requires substantial re-engineering. We introduce IANN (InterAtomic Neural Network), an open-source PyTorch framework that reimplements equivariant graph neural networks - PaiNN, NequIP, MACE, Allegro, EquiformerV2, EquiformerV3 and UMA - behind a unified data object, a unified trainer and a single deployment route, so that the architecture is a one-word change in a configuration dictionary. Forces, stresses and virials are obtained for every architecture from one analytic differentiation of the energy with respect to the edge vectors of the atomic graph, exact under periodic boundary conditions. Distributed training is configured automatically from the SLURM, PBS or MPI environment, so the same script runs unchanged from a workstation to a multi-node GPU allocation. Self-describing checkpoints serve directly as ASE calculators, as ensembles reporting uncertainties, or as TorchScript models run inside LAMMPS through bundled C++ pair styles with single- and multi-GPU inference. Trained on a common dataset of millions of structures, the architectures can be compared under identical conditions. We further release PaiNN foundation models trained on 41.9 million curated DFT structures from MPtrj, Alexandria, OMat24, MatPES, OC20, OC22, OC25, MPr2SCAN and MatPESr2SCAN, spanning the PBE, RPBE and r2SCAN functionals. Additionally, IANN provides an agent interface to facilitate integration with autonomous agents.

Manuscript.pdf

training is configured automatically from the SLURM, PBS, or MPI environment, so the same training script runs unchanged in various computing environments, such as a multi-GPU workstation and a multi-GPU/node supercomputer. Trained model checkpoints are self-describing and can be directly used as ASE calculators, combined into ensembles that report energies, forces, and their associated uncertainties, or compiled into TorchScript and executed within LAMMPS through bundled C++ pair styles supporting single- and multi-GPU inference and on-the-fly ensemble variance estimation. We demonstrate the framework by training different architectures on a common dataset with millions of structures, enabling meaningful comparisons through consistent training, graph construction, and evaluation procedures. We further provide PaiNN foundation models trained on 41.9 million curated DFT structures from the open-source MPtrj, Alexandria, OMat24, MatPES, OC20, OC22, OC25, MPr²SCAN, and MatPESr²SCAN datasets, spanning three exchange-correlation functionals (PBE, RPBE, and r²SCAN). Additionally, IANN provides an agent interface to facilitate integration with autonomous agents. As open-source, MIT-licensed software, IANN provides an accessible and unified platform for developing, benchmarking, and deploying advanced machine-learning interatomic potentials, accelerating their broader application across computational catalysis, energy storage and battery design, molecular therapeutics, and broader materials discovery.

Introduction

Atomistic simulations based on density functional theory (DFT) have become a cornerstone of modern computational materials science and molecular science. By establishing fundamental relationships between atomic structures and physical properties from first principles, DFT enables the prediction and characterization of materials and molecules before their experimental synthesis, transforming materials discovery and design from empirical trial-and-error approaches into rational, knowledge-driven processes. In catalysis, DFT enables the calculations of adsorption energies, reaction free energies, and activation barriers for elementary reaction steps, including the potential dependence in electrocatalytic systems, where the stability, selectivity and activity of the catalyst can be evaluated through thermodynamic and kinetic analyses, including the phase and Pourbaix diagrams, scaling relationships, and volcano plots.[1, 2, 3, 4] In battery materials, formation energies, ion-migration barriers, and interfacial decomposition energies encode key factors governing capacity, rate capability, and cycle life.[5] [6, 7] In drug discovery, DFT provides insights into conformational energetics, protonation states, and molecular interactions that govern the binding affinity of a candidate molecule for its biological target.[8] Despite its broad applicability, DFT is fundamentally bottlenecked by its high computational cost. This computational burden makes a wide range of applications, including geometry optimization of complex systems, high-throughput screening, large-scale simulations, long-timescale molecular dynamics (MD), and extensive finite-temperature sampling, prohibitively expensive for routine use.

Machine-learning interatomic potentials (MLIPs) were developed to address this bottleneck by learning the potential-energy surface from a finite set of reference calculations and then evaluating it at a cost that is orders of magnitude lower.[9–11] Early high-dimensional neural network potentials described each atomic environment through hand-crafted invariant descriptors,[9] and were then followed by learned invariant representations built on message passing.[12, 13] The current generation is explicitly equivariant: internal features transform under rotation in the same way as the physical tensors they represent, which markedly improves data efficiency and accuracy. Specifically, PaiNN extends scalar node features with Cartesian vector features,[14] while NequIP and Allegro employ spherical harmonics to construct equivariant representations of higher angular orders.[15, 16] MACE combines equivariant message passing with a systematic many-body expansion,[17] whereas the Equiformer family introduces equivariant attention mechanisms, with the latest EquiformerV3, which supports higher-degree spherical harmonics while selectively truncating the interaction orders retained at each degree.[18–20] UMA replaces the SO(3)\mathrm{SO}(3) tensor product itself: each edge is rotated to align with a common axis, allowing the convolution to be decomposed into independent SO(2)\mathrm{SO}(2) operations on spherical harmonic features. Its context-conditioning mechanism further enables a single set of model parameters to be shared across multiple domains.[21] Most recently, large-scale models trained on millions of atomic structures, such as UMA[21] and MACE-MP[22], have emerged as foundation models designed for zero-shot prediction or fine-tuning across diverse atomistic systems.

Despite this rapid progress, an important practical challenge remains largely overlooked. Each architecture is typically released as an independent research codebase, with its own conventions for dataset format, configuration systems, training workflows, logging, checkpoint structures, and integration with production MD engines (sometimes even missed). These inconsistencies create substantial practical barriers for researchers seeking to develop machine learning potentials for specific chemical systems. First, an honest comparison between two architectures on one’s own data, with identical data splits, loss weights, optimizer, and stopping criteria, requires reimplementing at least one of them or accepting confounded results. Second, the cost of switching architecture after the fact is high, which biases groups towards whichever model they adopted first. Third, model deployment remains architecture-specific, as integrating a trained potential into LAMMPS[23] typically requires dedicated wrappers and pair-style implementations for each architecture. Fourth, high-performance-computing (HPC) concerns leak into user workflows, as distributed training must be adapted to the launcher and scheduler of each machine. Fifth, extensibility is limited: adding a custom architecture or modifying existing model components often requires substantial changes to the framework-specific code, making it difficult to experiment with new ideas without becoming tied to a particular implementation. In addition, most existing frameworks lack an agent-friendly interface, which would enable autonomous agents to orchestrate model training, inference, and deployment.

IANN (InterAtomic Neural Network) framework addresses these challenges by implementing different neural network architectures as configurable options within a unified PyTorch[24] framework. Its equivariant models use the unified data object and trainer, allowing users to compare inductive biases on their own data while holding the splits, loss weights, optimiser, and stopping criteria fixed. The common interfaces also make it easier to add or modify architectures without rebuilding the surrounding workflow. Beyond training, checkpoints can be directly utilized with an ASE[25] calculator, assembled into ensembles for uncertainty quantification, or compiled to TorchScript for use in LAMMPS[23] through bundled pair styles. Training, inference, and deployment are accessible non-interactively, enabling agent-driven workflows.

Key and specific contributions of this work include:

  • A unified data representation. All architectures consume and return AtomsData, a typed, TorchScript-compatible data object built directly, so that datasets, batching and neighbour-list construction are shared across models rather than reimplemented per model.

  • A unified trainer. One unified dictionary configures the model, loss, optimizer, learning-rate schedule, data splitting and normalisation, early stopping, checkpointing and distributed execution, with roughly ten lines of user code.

  • Uniform analytic derivatives. Forces, stresses, and virials are obtained for each architecture by differentiating the predicted energy with respect to the graph edge vectors through a single unified implementation.

  • Launcher-agnostic parallelism. Distributed data-parallel training detects SLURM, PBS, OpenMPI, MPICH/Intel MPI, and MVAPICH2 environments and derives rank, world size, local rank, and rendezvous address automatically; the same script runs unchanged from a workstation to a multi-node GPU allocation.

  • A production path to LAMMPS. A generic TorchScript wrapper plus C++ pair styles (pair_style iann and pair_style iann/multi_gpu) run any IANN model inside LAMMPS, and a companion compute style exposes ensemble variance as a thermodynamic quantity for on-the-fly reliability monitoring.

  • Curated databases at three levels of theory. We curated, standardized, and reorganized public DFT datasets into three functional databases (PBE, RPBE, and r²SCAN), comprising 41.9 million structures that were cleaned of geometric outliers and unreliable labels and packaged in a unified format.[26]

  • Provided foundation models. Multiple foundation models trained on the curated open-source databases are provided,[27] serving either directly for inference or as starting checkpoints for fine-tuning on a small in-house dataset.

  • An agent interface. The framework provides an interface with machine-readable output, a Model Context Protocol server, and a set of agent skills, enabling large-language-model (LLM) agents to directly train, inspect, and deploy models.

Theoretical background

Locality and the atomic graph

All models implemented in IANN exploit the locality of atomic interactions through the standard decomposition of the total potential energy into atomic contributions,

E=∑i=1NEi(1)E = \sum_{i=1}^{N} E_i \tag*{(1)}

where EiE_i depends only on the local environment of atom ii within a cutoff radius rcr_{\mathrm{c}}. This locality assumption is physically motivated by the short-range nature of atomic interactions and enables efficient scaling to large systems. This locality assumption naturally represents each atomic configuration as a graph G=(V,E)\mathcal{G} = (\mathcal{V}, \mathcal{E}), where the vertex set V={1,…,N}\mathcal{V} = \{1,\ldots,N\} corresponds to atoms and the edge set E\mathcal{E} connects atom pairs within the cutoff distance,

E={(i,j)∣∥d⃗ij∥<rc},d⃗ij=r⃗j−r⃗i+Sijh,(2)\mathcal{E} = \left\{(i,j) \mid\lVert\vec{d}_{ij} \rVert< r_{\mathrm{c}}\right\}, \qquad\vec{d}_{ij} = \vec{r}_{j} - \vec{r}_{i} + \mathbf{S}_{ij}\mathbf{h}, \tag*{(2)}

where h\mathbf{h} is the 3×33 \times3 cell matrix whose columns define the periodic lattice vectors, and Sij∈Z3\mathbf{S}_{ij} \in\mathbb{Z}^{3} is the integer image shift vector that selects the periodic replica of atom jj nearest to ii. Working with edge vectors d⃗ij\vec{d}_{ij} rather than with absolute positions ensures exact translational invariance by construction and encodes periodicity as a graph property rather than requiring special treatment in the network architecture.

Equivariant message passing

A function ff acting on graph features is equivariant with respect to rotations if

f(Rd⃗ij)=D(R)f(d⃗ij)(3)f(\mathbf{R}\vec{d}_{ij}) = \mathbf{D}(\mathbf{R})f(\vec{d}_{ij}) \tag*{(3)}

for every rotation R\mathbf{R}, where D(R)\mathbf{D}(\mathbf{R}) is the representation of R\mathbf{R} acting on the output space. Scalars transform with D=1\mathbf{D} = 1 (invariance) and Cartesian vectors with D=R\mathbf{D} = \mathbf{R} (covariance). Models built on spherical harmonics generalize this to irreducible representations of arbitrary degree ℓ≤ℓmax⁡\ell\leq\ell_{\max}, where D\mathbf{D} is the corresponding Wigner DD-matrix. Equivariance enables the network to represent directional information—such as bond orientations and local symmetry breaking—without learning rotational symmetries from data, thereby improving sample efficiency and generalization.

All architectures in IANN follow the general message-passing framework

m⃗i(t)=⨁j∈N(i)Mt(hi(t),hj(t),R(∥d⃗ij∥),Y(d^ij)),hi(t+1)=Ut(hi(t),m⃗i(t))(4)\vec{m}_{i}^{(t)} = \bigoplus_{j \in\mathcal{N}(i)} M_t\left(h_i^{(t)}, h_j^{(t)}, R(\lVert\vec{d}_{ij}\rVert), Y(\hat{d}_{ij})\right), \qquad h_i^{(t+1)} = U_t\left(h_i^{(t)}, \vec{m}_i^{(t)}\right) \tag*{(4)}

where hi(t)h_i^{(t)} are the node features of atom ii at layer tt (in general containing mixed irreducible representations), N(i)\mathcal{N}(i) denotes the neighbors of atom ii within the cutoff radius, RR is a radial basis function multiplied by a smooth cutoff envelope, YY denotes spherical harmonics evaluated on the normalized edge direction d^ij=d⃗ij/∥d⃗ij∥\hat{d}_{ij}=\vec{d}_{ij}/\lVert\vec{d}_{ij}\rVert, and ⨁\bigoplus represents permutation-invariant aggregation—implemented in IANN as a scatter-add operation over edges. The architectures differ in how the message function Mt\mathcal{M}_t mixes irreducible representations: PaiNN uses gated products of scalar and vector channels; NequIP, Allegro, and MACE employ tensor products of irreducible representations; the Equiformer family implements equivariant attention mechanisms; UMA utilizes a spherical-channel backbone. Architectures also differ in whether they include explicit many-body expansions, but all share a common interface defined by Eq. (4). After TT message-passing layers, a readout network maps the invariant (ℓ=0\ell=0) component of hi(T)h_i^{(T)} to the atomic energy EiE_i in Eq. (1).

Radial information is encoded using a Bessel function basis with a polynomial cutoff envelope [28]

Rn(d)=2rcsin⁡(nπd/rc)du(d),n=1,…,Nbasis,(5)R_n(d)=\sqrt{\frac{2}{r_c}}\frac{\sin(n\pi d/r_c)}{d}u(d),\qquad n=1,\ldots,N_{\mathrm{basis}}, \tag*{(5)}

where d=∥d⃗ij∥d=\lVert\vec{d}_{ij}\rVert is the interatomic distance, and the envelope function u(d)u(d) and its first p−1p-1 derivatives vanish at d=rcd=r_c. This ensures that energies and forces remain continuous as atoms enter or leave the cutoff sphere—a prerequisite for stable molecular dynamics simulations.

Analytic derivatives

Forces are not predicted by a separate network head but obtained as exact analytic derivatives of the predicted energy with respect to atomic positions, which guarantees that the resulting force field is conservative. IANN computes these derivatives with respect to the edge vectors rather than the atomic positions directly,

F⃗i=−∂E∂r⃗i=∑j∈N(i)∂E∂d⃗ij−∑j:i∈N(j)∂E∂d⃗ji,(6)\vec{F}_i=-\frac{\partial E}{\partial\vec{r}_i}=\sum_{j\in\mathcal{N}(i)}\frac{\partial E}{\partial\vec{d}_{ij}}-\sum_{j:i\in\mathcal{N}(j)}\frac{\partial E}{\partial\vec{d}_{ji}}, \tag*{(6)}

which follows from ∂d⃗ij/∂r⃗i=−I\partial\vec{d}_{ij}/\partial\vec{r}_i=-\mathbf{I} and ∂d⃗ij/∂r⃗j=+I\partial\vec{d}_{ij}/\partial\vec{r}_j=+\mathbf{I}. In the implementation, a single call to automatic differentiation produces ∂E/∂d⃗ij\partial E/\partial\vec{d}_{ij} for all edges simultaneously, and the two sums in Eq. (6) are evaluated as scatter-add operations onto the center and neighbor indices of each edge (Figure 2c). This route is preferred over differentiating with respect to r⃗i\vec{r}_i directly because the periodic image shifts Sijh\mathbf{S}_{ij}\mathbf{h} of Eq. (2) are absorbed into the graph construction phase. Consequently, the same code path correctly handles isolated molecules, slab geometries, and fully periodic bulk systems without modification. The virial tensor and stress tensor are computed from the same edge derivatives:

Figure 2. The underlying mechanism: a shared graph convention, a unified data object, and a shared derivative route. (a) A structure becomes a graph: atom ii bonds to atom jj within the cutoff rcr_{\mathrm{c}}. (b) The unified data object: AtomsData, which describes the graph and its associated data. (c) The architecture-independent forward pass that yields forces, stress and virial.

W=∑(i,j)∈Ed⃗ij⊗∂E∂d⃗ij,σ=1VW,(7)\mathbf{W}=\sum_{(i,j)\in\mathcal{E}}\vec{d}_{ij}\otimes\frac{\partial E}{\partial\vec{d}_{ij}},\qquad\boldsymbol{\sigma}=\frac{1}{V}\mathbf{W}, \tag*{(7)}

where W\mathbf{W} is the 3×33\times3 virial tensor, VV is the simulation cell volume, and σ\boldsymbol{\sigma} is the stress tensor. Because the virial is constructed from the same per-edge gradients ∂E/∂d⃗ij\partial E/\partial\vec{d}_{ij} as the forces, no additional backward pass through the network is required. In molecular dynamics simulations, the kinetic contribution to the pressure is added by the integrator rather than computed by the model.

Training objective

Models are trained by minimizing a weighted combination of energy, force, virial, and stress residuals:

L=wELE+wFLF+wWLW+wσLσ,wE=1−wF−wW−wσ,(8)\mathcal{L} = w_E \mathcal{L}_E + w_F \mathcal{L}_F + w_W \mathcal{L}_W + w_\sigma\mathcal{L}_\sigma,\qquad w_E = 1 - w_F - w_W - w_\sigma, \tag*{(8)}

where the energy weight wEw_E is determined automatically from the user-specified derivative weights to ensure ∑w=1\sum w = 1. The energy loss term uses mean-squared error normalized per atom:

LE=1B∑b=1B(E^b−EbNb)2,(9)\mathcal{L}_E = \frac{1}{B}\sum_{b=1}^{B}\left(\frac{\hat{E}_b-E_b}{N_b}\right)^2, \tag*{(9)}

where BB is the batch size, E^b\hat{E}_b and EbE_b are the predicted and reference energies for structure bb, and NbN_b is the number of atoms in structure bb. This per-atom normalization prevents large structures from dominating batches with heterogeneous system sizes. The force loss term uses the mean Euclidean norm of the per-atom force error:

LF=1N∑i=1N∥F⃗^i−F⃗i∥2,(10)\mathcal{L}_F = \frac{1}{N}\sum_{i=1}^{N}\left\lVert\hat{\vec{F}}_i-\vec{F}_i\right\rVert_2, \tag*{(10)}

where NN is the total number of atoms in the batch, and F⃗^i\hat{\vec{F}}_i and F⃗i\vec{F}_i are the predicted and reference forces on atom ii. This L1L_1 norm in force space is rotationally invariant and less sensitive to outliers than the squared (L2L_2) norm. Optionally, training targets are standardized using the mean and standard deviation of the per-atom training energies, and predictions are de-standardized within the model before output. This ensures that saved model checkpoints always predict energies in physical units regardless of the standardization used during training.

Related work

Several mature frameworks address different aspects of the MLIP workflow. SchNetPack[29, 30] pioneered the concept of a modular atomistic deep-learning toolbox with reusable data pipelines, training loops, and ASE integration, establishing a benchmark for usability. Its model zoo focuses on the SchNet, PaiNN, and FieldSchNet architectures. DeePMD-kit[31, 32] is widely deployed in the production environment, offering highly optimized descriptors, extensive MD engine integration, and mature HPC support. However, it is built around the Deep Potential model family rather than the equivariant graph neural networks that currently define the state-of-the-art in accuracy. GPUMD[33] achieves exceptional molecular dynamics throughput using the neuroevolution-potential (NEP) model, though it is similarly limited to a single architecture family. TorchMD-NET[34] implements equivariant transformer architectures with specialized support for biomolecular simulations. The reference implementations of NequIP [15], Allegro [16], MACE [17], and the Equiformer family [18, 19] are well-engineered within their respective scopes. However, each constitutes a separate package with its own data format, configuration schema, and deployment workflow, preventing interoperability: models cannot generally be exchanged or compared directly across these frameworks. Workflow-level tools address complementary challenges: CURATOR [35] and DP-GEN [36] automate active learning and dataset generation, while AdsorbML [37] provides an efficient screening protocol that combines pre-trained potentials with selective DFT refinement.

IANN occupies the intermediate layer between individual model implementations and high-level workflow tools. Rather than proposing novel architectures or active-learning strategies, it standardizes the software interface—encompassing data objects, training loops, model checkpoints, ASE calculators, and MD engine exports—enabling architectures with fundamentally different inductive biases to be trained, compared, and deployed through identical code paths. Three key features distinguish IANN from existing frameworks. First, architecture selection becomes a controllable experimental variable that can be systematically varied while holding all other factors constant—precisely what is required for rigorous benchmarking on domain-specific datasets. Second, deployment is fully model-agnostic: because all architectures expose a unified tensor-level interface, a single TorchScript wrapper and a single pair of LAMMPS pair styles support all models, including ensemble predictions. Third, HPC parallelism is managed by the framework rather than requiring user intervention. This design choice is practically significant because training workflows must often execute seamlessly across diverse computing environments, from local workstations to HPC clusters with varying job schedulers and MPI implementations.

Software structure

Figure 1 shows the structure of IANN, which consists of five main layers with two auxiliary ones. It starts from first layer, data layer (iann.data) as shown in the bottom in Figure 1, which serves unified data to the second layer, models (iann.models) and trainer (iann.trainer) layer. There are plenty of MLIPs architectures that can be chosen and trained on the unified trainer on a single GPU or in parallel across many. Training writes a self-describing checkpoint that the third layer consumes either as an ASE calculator via iann.calculators (with optional ensemble support) or as a TorchScript model compiled for LAMMPS via iann.plugins. Two auxiliary layers attach to these: iann.foundations supplies pre-trained potentials at three levels of DFT theory, to be reused directly or refined by the trainer, and the bundled pair styles execute the compiled model inside LAMMPS. The fourth layer is the calculations those two interfaces drive, such as surrogate DFT single points, relaxations and nudged-elastic-band searches, enhanced sampling, and molecular dynamics. The final layer (fifth layer) encompasses the application domains served by IANN: catalysis, battery materials, and drug discovery. The subsections that follow describe these architectural layers in sequence.

Figure 1. Software structure of the IANN framework: five main layers with two auxiliary layers.

Data layer

In order to deal with various structure formats, and to turn them into the graph that a model can consume, IANN provides a unified data layer (iann.data). Trajectory or database are read through ASE that can support various formats. The neighbour lists that define the graph nodes and edges are built by a C++ compiled asap3 whose cost grows linearly with the number of atoms. Both are packed into a unified data object, AtomsData, which is natively accepted by every architecture and readily compiled via TorchScript. This allows the same object to serve both training in Python and inference inside LAMMPS in C++. More detailed construction can be found in Section S2 of the Supporting Information.

Models and trainer layer

Based on the unified data object, the second layer implements several state-of-the-art MLIPs architectures alongside a template for custom models (iann.models), all managed through a unified trainer (iann.trainer). The trainer handles the training loop, the objective on energies, forces, stresses and virials, logging, checkpointing, learning-rate scheduling, early stopping, and restarts. It also detects the environment and configures distributed data-parallel training automatically from SLURM, PBS, OpenMPI, MPICH/Intel MPI, or MVAPICH2 without any change to the script. The architectures — PaiNN[14] NequIP[15] MACE[17] Allegro[16] EquiformerV2[19] EquiformerV3[20] and UMA[21] — are available by their name in a configuration dictionary. Each is reimplemented against the shared AtomsData interface, so that one data object, one derivative route, and one exporter serve them all. The accuracies reported here are therefore those of the IANN implementations rather than of the original releases. The same trainer then supplies the objective and runs on a single GPU or in parallel across many[38] without a change to the script. The trainer configurations and the corresponding implementation details are described in full as Section S2 and § 5.10.

Calculators and plugins layer

After training a model, a unified and user-friendly interface is needed to load the trained checkpoint for doing calculations, which is exactly what the third layer provides. The third layer provides unified calculators (iann.calculators and plugins iann.plugins), making the full ASE ecosystem directly accessible without requiring additional code. In addition, EnsembleCalculator can utilise ensemble checkpoints to do prediction with variance of total energy, forces, and atomic properties (like atomic energy) directly as an acquisition signal for active learning.[39, 40] The LAMMPS plugin can use the compiled TorchScript single model or ensemble model to do inference in serial or in parallel, which does not depend on the specific architectures.

Calculations layer and applications layer

Building directly on the third layer, the calculations layer invokes these calculators and plugins to drive various atomistic simulations: single-point evaluation, geometry relaxation, and nudged-elastic-band searches through ASE as surrogates for the corresponding DFT calculations, molecular dynamics through either ASE or LAMMPS, and free-energy methods such as metadynamics through ASE-PLUMED calculator. These calculations serve the application domains at the top of Figure 1, which include catalysis, battery materials, and drug discovery.

Foundation models

To accelerate project workflows and avoid training models from scratch, IANN distributes pretrained foundation potentials (iann.foundations). The foundation models are released,[27] trained on 41.9 million curated DFT structures and grouped by exchange-correlation functional. Each model can serve directly as a zero-shot calculator or as an initialization checkpoint for fine-tuning on targeted in-house data to boost predictive accuracy (see § 1.6.4).

Deployment to LAMMPS

To bypass the size and timescale bottlenecks of Python-driven simulations, IANN deploys compiled models directly inside LAMMPS (pair_style iann). Built on the LibTorch C++ API, the pair styles run in serial or multi-GPU parallel configurations. Furthermore, the plugin natively supports ensemble predictions: loading an ensemble checkpoint automatically instantiates a companion compute that streams energy and force variances alongside standard thermodynamic variables, enabling real-time detection of out-of-distribution drift.

Agent interface

Beyond the core framework, an agent interface exposes these underlying operations programmatically, enabling fully autonomous model training, inspection, and deployment without human intervention. Instead of introducing a separate layer into Figure 1, the agent interface serves as a parallel entry point to the core stack through three complementary mechanisms: structured CLI output, an MCP server, and task-specific agent skills. Detailed descriptions of each interface and the constraints governing autonomous execution are provided in § 5.9 of the Supporting Information.

Underlying mechanism

The core architectural mechanism enabling the uniformity across Figure 1 is illustrated in Figure 2. It comprises three key components: a shared graph convention, a unified data object consumed and produced by every model, and a single analytic derivative pathway. The details of each component are described below.

Graph convention

Before processing by any architecture, an atomic structure is converted into a graph representation. This graph is materialized as node and edge tensors according to Eq. (2). The nodes are represented by a single integer array of atomic numbers, and the edges by integer indices array and edge vectors d⃗ij\vec{d}_{ij}. The graph is directed, so each edge appears twice: once from ii to jj and once from jj to ii. For periodic boundary conditions, the lattice shift vector Sijh\mathbf{S}_{ij}h is incorporated during graph construction. Crucially, the edge vectors are flagged to track gradients, enabling the unified, single-step differentiation detailed below.

Unified data object

The graph is packaged into a unified data structure (AtomsData) that every architecture consumes and returns, making the trainer and calculators architecture-agnostic. This data object also carries training labels, batching indices, optional intermediate representations, predictive variances, and ensemble metadata. The data object is also compatible with TorchScript, which allows the same model object to be compiled for LAMMPS without an architecture-specific adapter.

Derivative route

The architecture-independent forward pass in Figure 2c closes the loop. Every architecture implements an identical forward signature—mapping AtomsData to AtomsData—and extracts atomic forces through a single differentiation with respect to edge vectors (Eq. (6)). A subsequent contraction of these same per-edge gradients against the edge vectors yields the virial and Cauchy stress (Eq. (7)), allowing all three derived physical quantities to be obtained in a single backward pass. The loss functions, trainer, calculators, and TorchScript exporter are implemented against that signature alone and contain no architecture-specific logic. This design offers two key advantages. First, selecting a network architecture is reduced to a simple configuration parameter, allowing different models to be trained and evaluated using a single unified script. Second, a universal wrapper exports any supported architecture to LAMMPS, ensuring that adding a new model leaves the downstream deployment pipeline untouched.

A complete workflow

A primary design objective of IANN is usability, enabling practitioners to train and deploy models with minimal code and without low-level framework knowledge. As shown below, Listing 1 demonstrates how to train a model directly from an ASE trajectory. Switching between supported architectures—including nequip, mace, allegro, equiformerV2, equiformerV3, and UMA—requires only modifying the model name and corresponding hyperparameters in the config dictionary. Furthermore, custom architectures can be integrated into the framework with minimal boilerplate, as illustrated below.

Listing 1: Training a model with a registered architecture.

from iann.trainer import Trainer

trainer = Trainer(
    model="painn",
    config={"num_channels": 128,
            "num_layers": 3,
            "cutoff": 5.5,
            "batch_size": 16,
            "learning_rate": 1e-4,
            "forces_weight": 0.9,
            "val_ratio": 0.1,
            "device": "cuda",
            "output_dir": "output"},
    distributed=True,
)
trainer.train("dataset.traj")

The resulting checkpoint is loaded into an ASE calculator in Listing 2 to drive downstream calculations. Because each checkpoint encapsulates its network architecture and hyperparameters, the calculator automatically reconstructs the underlying model without manual specification.

Uncertainty quantification is equally seamless: swapping MLCalculator for EnsembleCalculator with a list of checkpoints yields both mean predictions and calibrated variances. Finally, deployment to LAMMPS requires only a single export step to generate a TorchScript model compatible with pair_style iann.

Listing 2: Running inference with a model checkpoint with its own architecture and parameters.

from ase.io import read
from ase.optimize import BFGS
from iann.calculators import MLCalculator

atoms = read("start.traj")
atoms.calc = MLCalculator("output/model.pt", device="cuda")
BFGS(atoms, trajectory="relax.traj").run(fmax=0.03)

Results and discussion

Curated DFT databases

Training a robust foundation potential requires DFT data generated at a consistent level of theory. However, existing public DFT repositories use a range of exchange-correlation functionals and vary in structural quality. To address this, we systematically screened the source databases for conspicuous energy and force outliers and removed them prior to training. After filtering, we categorized the databases by exchange-correlation functionals and converted them into a standardized ASE trajectory format (Table 1), which the framework ingests directly without requiring auxiliary preprocessing or database conversion. The PBE[50] database includes MPtrj,[41, 42] sAlex (subsample of Alexandria),[43, 44] OMat24,[44] MatPES,[45] and OC22, which cover 89 elements for bulk and surface chemistry;[46] the RPBE[51] database includes OC20[47] and OC25,[48] which together cover the catalysis-relevant surface and solid–liquid-interface chemistry with 73 elements; and the r2^{2}SCAN[52] database includes the meta-GGA subsets of the Materials Project[49] and MatPES, which cover 89 elements.[45] The detailed system information, total structure counts, atom counts (in millions), and element coverages for each database are provided in Table 1. It can be noted that the PBE database is the largest by structure count, with 31.9 million structures, followed by the RPBE database with 9.37 million, and the r2^{2}SCAN database with 0.63 million. When measured by atom count, the order of the first two is inverted: the RPBE dataset comprises 1,210.8 million atoms compared to 972.0 million for PBE and 8.1 million for r2^{2}SCAN. This inversion arises because the surface and interface supercells in the RPBE sources are substantially larger than the bulk unit cells that dominate the PBE collection.

FunctionalSource datasetSystem typeStructuresAtoms (M)Elem.Ref.
PBEMPtrjBulk, relaxations1,579,09149.289[41, 42]
PBEsAlexBulk, relaxations10,423,284107.589[43, 44]
PBEOMat24Bulk, off-equilibrium11,274,650157.189[44]
PBEMatPESBulk, MD snapshots434,0923.989[45]
PBEOC22Surfaces, oxides8,199,197654.357[46]
PBEPBE total31,910,314972.089
RPBEOC20 (2M)Surfaces, relaxations1,999,572146.556[47]
RPBEOC25Solid–liquid interf.7,370,4611064.373[48]
RPBERPBE total9,370,0331210.873
r2SCANr^2\mathrm{SCAN}MP r2SCANr^2\mathrm{SCAN}Bulk, relaxations238,2415.088[49]
r2SCANr^2\mathrm{SCAN}MatPES r2SCANr^2\mathrm{SCAN}Bulk, MD snapshots387,3063.089[45]
r2SCANr^2\mathrm{SCAN}r2SCANr^2\mathrm{SCAN} total625,5478.189

Table 1. Curated DFT databases grouped by exchange-correlation functional.

These three DFT levels databases also differ markedly in chemical diversity and dataset scale as shown in Figure 3. Each periodic table tile indicates the element count and is shaded on an independent logarithmic scale according to its functional-specific colormap: blue for PBE, orange for RPBE, and green for r2^{2}SCAN. Darker tones correspond to higher counts, while dashed gray cells designate elements absent from that dataset. The PBE and r2^{2}SCAN databases span nearly the entire periodic table—including the lanthanides and actinides up to plutonium (Pu)—yet differ in depth by more than an order of magnitude. Conversely, the RPBE database exhibits a narrower elemental breadth, containing no actinides and only five lanthanides, but compensates with massive statistical depth: it encompasses 9.0 million structures containing hydrogen and 8.6 million containing oxygen, directly reflecting its provenance in surface science and solid–liquid interface catalysis. In addition, complete per-element, per-atom, and structure counts for each database are mapped onto periodic tables in Section S16 in the Supporting Information. Altogether, the curated collection contains 41.9 million labeled configurations, accessible through Hugging Face Datasets.[26]

Figure 3. Elemental composition of three levels of curated DFT databases: number of structures containing each element on a logarithmic colour scale. Each element tile is divided into three stepped sub-cells from top left to bottom right, corresponding to PBE, RPBE, and r2^{2}SCAN.

Foundation models across architectures

Seamless cross-architecture training is a cornerstone of IANN, enabling users to train diverse model architectures on an identical dataset with minimal modifications to the configuration script. Here, we present a systematic benchmark comparing the energy and force prediction accuracy across multiple architectures trained on the same database. While this benchmark is not designed as a controlled ablation study, it provides a realistic assessment of empirical performance in practical deployments. Model parameter count serves as the common metric of comparison. Consequently, aside from the distinct network architectures and their parameterizations, all models share identical training splits, graph conventions, loss formulations, and evaluation routines. We trained seven architectures on the curated MPtrj database (1,579,091 PBE structures) under uniform training settings: a 5.5 Å interaction cutoff, the Adam optimizer, identical gradient clipping, and standardized early-stopping patience. For the loss function in Eq. (9), we adopted a staged weighting scheme, transitioning from wF=0.9w_F = 0.9 to emphasize force learning early on to wF=0.3w_F = 0.3 to optimize asymptotic energy accuracy. For each architecture, channel widths, layer depths, and angular resolutions (ℓmax⁡\ell_{\max}, mmax⁡m_{\max}) were selected to standardize model capacity around 1 million parameters (spanning 0.57 to 1.43 M). Learning rates were tuned independently for each network to match its characteristic optimization dynamics.

Table 2: Validation accuracy and parameter counts for seven representative architectures trained via IANN on the curated MPtrj dataset. [27] Parameter count serves as the common metric of model capacity across disparate architectures; network depth, channel dimensions, and angular resolutions for each model are detailed in Table S2.

The energy and forces accuracies of the seven architectures are summarized in Table 2. Validation errors are evaluated on a held-out 5% split of the curated MPtrj dataset using the mean absolute error (MAE). Here, models are deliberately constrained to approximately 1 million parameters to ensure rapid inference and facilitate lightweight fine-tuning. Two key trends emerge from these results. First, when evaluated on the same benchmark at comparable model capacities, energy errors vary relatively little across architectures, from 0.029 to 0.054 eV/atom, whereas force errors show a wider spread, from 0.040 to 0.069 eV/A˚\mathring{\mathrm{A}}. Second, attention-based architectures achieve the strongest overall accuracy on this dataset: EquiformerV3 delivers competitive energy and force errors of 0.040 eV/atom and 0.046 eV/A˚\mathring{\mathrm{A}} with 0.94 M parameters, while UMA achieves the lowest errors overall, recording an energy error of 0.029 eV/atom and a force error of 0.040 eV/A˚\mathring{\mathrm{A}} but uses more parameters, at 1.17 M. PaiNN is also highly competitive: with just 0.60 M parameters, it achieves errors of 0.041 eV/atom for energy and 0.050 eV/A˚\mathring{\mathrm{A}} for forces, while delivering the fastest inference throughput (Table S6). This balance of accuracy, efficiency, and speed motivates our choice of PaiNN as the core architecture for the foundation potentials at all three DFT levels.

ModelParametersEMAEE_{\mathrm{MAE}} (eV/atom)FMAEF_{\mathrm{MAE}} (eV/Å)
PaiNN600,5770.0410.050
NequIP1,379,5130.0500.069
Allegro567,6240.0400.066
MACE1,429,3760.0540.069
EquiformerV2773,0890.0400.059
EquiformerV3943,2490.0400.046
UMA1,173,6980.0290.040

Table 2.

ArchitectureParamsFloora^{a} (ms)Crossoverb^{b} (µs/atom)N∗cN^{*c}Max NdN^{d}Mem @ 10310^{3} (GiB)MDe^{e} (ns/day)EMAEfE_{\mathrm{MAE}}^{f} (meV/at.)FMAEfF_{\mathrm{MAE}}^{f} (meV/Å)
PaiNN600,5819.015.956410,9761.363.004150
NequIP1,383,07924.318.51,31610,9760.922.035069
Allegro570,06219.1180.71064,0005.720.764066
MACE1,435,68620.815.01,39110,9760.762.235469
EquiformerV2773,093114.6306.737486419.770.364059
EquiformerV3966,08153.6171.63122,04813.280.664046
UMA1,174,12128.491.43116,9124.321.192940

Table S6. Table S6: Inference cost and accuracy of different architectures on one Tesla V100-PCIE-32GB, float32, 5.5 Å cutoff for energy+forces on bulk fcc Pt supercells.

Foundation models at three DFT levels

Table 3: PaiNN foundation models within IANN grouped by three levels of DFT exchange-correlation functional.[27] Each model is trained on a single source database. Errors here are evaluated across entire source databases rather than on validation sets.

Leveraging the curated datasets in Table 1, we trained foundation potentials across all three DFT levels, using PaiNN as the underlying architecture. Training was conducted under identical architectural hyperparameters—128 channels, 3 interaction layers, a 5.5 A˚\mathring{\mathrm{A}} cutoff, and 600,577 total parameters—ensuring that performance variations across rows reflect dataset composition rather than model capacity. Each model was optimized using the per-atom energy loss, a batch size of 16, and an initial learning rate of 10−410^{-4}. In the final training phase, each run was restarted at a reduced learning rate directly through the trainer, facilitating asymptotic convergence without resetting the optimizer state from scratch. As summarized in Table 3, we provide five foundation potentials at the PBE level, two at the RPBE level, and two at the r2r^{2}SCAN level, each trained on an individual database. We deliberately avoid merging datasets within a given functional because underlying DFT parameters, such as Hubbard UU corrections and D3 dispersion schemes, differ across source repositories. Distributing separate models per source preserves internal thermodynamic consistency

FunctionalModel NameDatabaseStructure CountEMAEE_{\mathrm{MAE}} (eV/atom)FMAEF_{\mathrm{MAE}} (eV/A˚\mathring{\mathrm{A}})
PBEPBE-MPtrjMPtrj1,579,0580.05170.0498
PBE-sAlexsAlex10,422,8930.04080.0513
PBE-OMat24OMat2411,261,4000.02610.1382
PBE-MatPESMatPES434,0830.04630.0930
PBE-OC22OC228,198,6950.03810.0528
RPBERPBE-OC20OC201,999,2160.02630.0630
RPBE-OC25OC257,369,6010.01160.0753
r²SCANr²SCAN-MPtrjMPtrj238,2410.02060.0117
r²SCAN-MatPESMatPES387,2850.04460.1127

Table 3. PaiNN foundation models within IANN grouped by three levels of DFT exchange-correlation functional. Each model is trained on a single source database. Errors here are evaluated across entire source databases rather than on validation sets.

and allows practitioners to select the checkpoint whose reference settings most closely match their target application. Across all models, training dataset size does not strictly correlate with final validation error. For PBE, per-database energy MAEs range from 0.0261 to 0.0517 eV/atom, higher than those for RPBE (0.0116 to 0.0263 eV/atom) and comparable to r2r^{2}SCAN (0.0206 to 0.0446 eV/atom). Force MAEs for PBE span 0.0498 to 0.1382 eV/A˚\AA, exhibiting wider variance than RPBE (0.0630 to 0.0753 eV/A˚\AA) and r2r^{2}SCAN (0.0117 to 0.1127 eV/A˚\AA). The elevated force errors observed for PBE-OMat24 and r2r^{2}SCAN-MatPES reflect their strong off-equilibrium sampling, which includes heavily rattled geometries in OMat24 and high-temperature dynamic configurations in MatPES.

To enable direct comparison, the validation energy and force MAEs from Table 3 are plotted against one another in Figure 4a, with the corresponding training dataset sizes shown in Figure 4b. We can note that r2r^{2}SCAN-MPtrj achieves the lowest force MAE (0.0117 eV/A˚\AA), while RPBE-OC25 attains the lowest energy MAE (0.0116 eV/atom). Notably, predictive accuracy does not correlate monotonically with dataset scale: RPBE-OC25 is trained on 7.4 million configurations yet records the lowest energy error, whereas r2r^{2}SCAN-MatPES is trained on 387,285 structures but yields an elevated force MAE of 0.1127 eV/A˚\AA. This demonstrates that foundation model fidelity is governed not merely by dataset volume, but critically by structural diversity and configuration space sampling. While Figure 4a summarizes global accuracies, elemental transferability is often more decisive in practice. To this end, Figure 4c–Figure 4h resolve energy and force errors as a function of atomic number across all PBE, RPBE, and r2r^{2}SCAN functionals. Although per-element accuracy varies markedly across the periodic table, the elemental profiles within a single functional remain strikingly congruent across different source databases. This consistency demonstrates that elemental error trends are primarily dictated by the underlying level of theory rather than dataset provenance. Detailed per-element MAE values for each model are summarized in § 5.23 in the Supporting Information.

Figure 4. The PaiNN foundation models trained on each DFT database. (a) Energy MAE against force MAE. (b) Number of structures that each was trained on. (c, e, g) Per-element energy MAE against atomic number. (d, f, h) Per-element force MAE against atomic number for the PBE, RPBE and r2r^{2}SCAN functionals, respectively.

Fine-tuning foundation models

The foundation models provide the intended starting baselines for downstream fine-tuning where high task-specific precision is required. In typical computational catalysis workflows, the DFT calculations for a specific reaction coordinate are limited to a few hundred configurations, well below the sample volume required for training from scratch. Fine-tuning a pre-trained foundation model on this sparse dataset readily adapts the potential to the target chemistry. Within IANN, fine-tuning is executed simply by loading the pre-trained checkpoint and resuming optimization on the specialized in-house dataset. The training routine remains identical to Listing 1, requiring only that the model arguments point to the desired foundation checkpoint. To evaluate the fine-tuning performance, we validated the model on AdsTraj, an independent RPBE dataset comprising 33,920 configurations across 26 transition metals, six representative adsorbates (H*, C*, O*, CO*, OH*, and HOCO*), and diverse adsorption sites. [53] The dataset was split into 90% training and 10% test partitions. As shown in Figure 5a, the zero-shot energy MAE of the RPBE-OC20 PaiNN foundation model fluctuates across metals and adsorbates, highlighting the inherent non-uniformity of generalized priors across chemical space. The aligned column bars in Figure 5b compute the ensemble MAE per element across all sampled frames, showing an overall baseline error of 0.024 eV/atom with particularly high fidelity on metals including V, Co, Ni, Cu, Y, Zr, Pd, Ag, Hf, Ta, W, and Au. Parity plots comparing adsorption energies under zero-shot, trained from scratch, and fine-tuned are illustrated in Figure 5c–Figure 5e, with quantitative benchmarks summarized in Table 4. It can be observed that zero-shot evaluation shows an MAE of 0.715 eV with an R2R^2 of 0.846, which has lower accuracy than the model trained from scratch on AdsTraj alone (0.483 eV MAE, R2=0.926R^2 = 0.926). Notably, the fine-tuned RPBE-OC20 checkpoint dramatically outperforms both baselines, reducing the MAE to 0.217 eV and achieving an R2R^2 of 0.986. These findings

Figure 5. Benchmark performance of the RPBE-OC20 PaiNN foundation model on the AdsTraj. (a) Heatmap of energy MAE across transition metal surfaces (Sc to Au) and key catalytic adsorbates (C*, H*, O*, CO*, OH*, and HOCO*). (b) Energy MAE resolved across metals. Parity plots of adsorption energy under (c) zero-shot, (d) from scratch, and (e) fine-tuning.

StrategyTraining structuresEadsE_{\mathrm{ads}} MAE (eV)R2R^2
Zero-shot (foundation model)00.7150.846
From scratch (train from scratch)24,1540.4830.926
Fine-tuned (train on foundation model)24,1540.2170.986

Table 4. Performance comparison across zero-shot, training from scratch, and fine-tuning.

demonstrate that pre-trained foundation models provide superior inductive priors, enabling fine-tuned potentials to decisively surpass models trained from scratch within identical, data-scarce regimes.

Per-atom energy and force errors across varying training-set sizes are summarized in Table S4 in the Supporting Information. Notably, when trained on the full dataset, the fine-tuned model attains the lowest per-atom energy error (7.1 meV/atom) and force error (36.7 meV/A˚\mathring{\mathrm{A}}), substantially outperforming both the zero-shot foundation model (24.0 meV/atom and 67.2 meV/A˚\mathring{\mathrm{A}}) and the model trained from scratch (14.1 meV/atom and 45.4 meV/A˚\mathring{\mathrm{A}}). Throughout the data-scaling series, the fine-tuned model consistently surpasses the model trained from scratch at every training-set size. This demonstrates that pre-trained representations accelerate convergence and enhance predictive accuracy in data-limited regimes, confirming that the pre-trained weights supply superior inductive priors relative to random initialization across all stages of fine-tuning.

StrategyStructuresEMAEE_{\mathrm{MAE}} (meV atom−1^{-1})FMAEF_{\mathrm{MAE}} (meV Å−1^{-1})Eads,MAEE_{\mathrm{ads,MAE}} (eV)
Zero-shot025.067.20.715
From scratch862283.6565.771.1
From scratch1,023794.0181.428.2
From scratch2,119524.6223.718.1
From scratch5,42432.291.51.033
From scratch11,99119.765.50.689
From scratch24,15414.145.40.483
Fine-tuned8689.679.23.058
Fine-tuned1,02342.977.71.669
Fine-tuned2,11926.064.00.969
Fine-tuned5,42416.653.60.513
Fine-tuned11,9919.149.40.324
Fine-tuned24,1547.136.70.217

Table S4. Data efficiency of fine-tuning on the AdsTraj dataset.

Inference cost across architectures

While model accuracy is a primary criterion of merit, computational efficiency is an equally vital consideration, especially for long-timescale and large-scale applications such as molecular dynamics and high-throughput screening.[54] To provide a comprehensive assessment beyond static error metrics, we benchmark the inference cost across all seven architectures trained on the MPtrj database. The wall-clock time per evaluation against the number of atoms, peak GPU memory versus the number of atoms, force MAE versus sustained throughput, and NNP speedup over DFT (VASP, RPBE functional) are considered to evaluate the cost for each model (Figure 6). All benchmarks were conducted in single precision (float32) on a single NVIDIA Tesla V100 GPU (32 GB), evaluating bulk supercells ranging from 32 to 10,976 atoms under the standardized 5.5 A˚\mathring{\mathrm{A}} cutoff.

Figure 6. Inference cost of the architectures via IANN. (a) Wall time per energy-and-force call against system size. (b) Peak GPU memory versus the number of atoms. (c) Force MAE against sustained throughput for each model. (d) NNP Speedups over DFT (VASP, RPBE). The shaded region is where the DFT reference is extrapolated.

Figure 6a plots the wall-clock execution time per energy-and-force evaluation as a function of system size across all architectures. Open circles identify the transition threshold N∗N^*, marking the crossover from the latency-bound regime to the throughput-bound scaling regime, while crosses denote the maximum system size reached before encountering out-of-memory (OOM). We can see that each architecture exhibits a distinct latency floor below which evaluation time is invariant to system size, reflecting a regime where kernel launch overhead dominates and GPU compute capacity remains underutilized. These latency floors range from 9.0 ms for PaiNN, to 19–28 ms for NequIP, MACE, Allegro and UMA, reaching 54 ms for EquiformerV3 and 115 ms for EquiformerV2. This indicates that PaiNN requires the shortest time for GPU kernel launches and data transfers, whereas EquiformerV2 takes the longest. Meanwhile, NequIP, MACE, Allegro, and UMA exhibit similar latency floor times, and EquiformerV3 lies intermediate between this group and EquiformerV2. The crossover N∗N^{*} at which the per-atom cost begins to dominate ranges from about 100 atoms for Allegro to roughly 1400 for MACE and NequIP. Above N∗N^{*} the cost is linear in NN as the locality of Eq. (1) requires. For the few-hundred-atom slabs typical of surface catalysis, architectural selection is effectively governed by the baseline latency floor rather than marginal scaling, as per-atom overhead remains negligible until systems reach significantly larger scales. In this regime, MACE, PaiNN, and NequIP demonstrate the lowest marginal per-atom cost, while

UMA, EquiformerV3, Allegro, and EquiformerV2 exhibit steeper scaling slopes. Figure 6b displays peak GPU memory allocation versus system size, revealing strict linear scaling with atom count across all models. Consistent with the computational latency trends in Figure 6a, PaiNN, NequIP, and MACE maintain the lowest memory footprints, allowing them to simulate substantially larger systems before encountering GPU memory ceilings compared to the heavier architectures.

Force MAE against sustained throughput for each model is shown in Figure 6c. Sustained throughput is defined as the number of atoms normalized by wall-clock time per energy-and-force call. In this metric, PaiNN, NequIP, and MACE exhibit higher throughput than UMA, EquiformerV3, Allegro, and EquiformerV2, reflecting their lower per-call computational cost. However, UMA, EquiformerV3, and PaiNN attain the lower force MAEs than NequIP, MACE, Allegro, and EquiformerV2, which indicates that they are more accurate in terms of force prediction in current configurations. Balancing this trade-off between predictive error and inference latency is essential when tailoring architecture selection to target application scales.

Figure 6d compares the computational speedups of different models relative to plane-wave DFT (VASP, RPBE). Across all architectures, the neural network potentials achieve speedups ranging from three to six orders of magnitude over DFT. In the extrapolated DFT regime (shaded region in Figure 6d), this computational advantage widens progressively with system size, underscoring the benefit of neural network potentials for large-scale simulations. Furthermore, inter-model performance varies by up to 10×10 \times between the fastest and slowest architectures—a performance gap that translates into substantial wall-clock savings during high-throughput screening or long-timescale molecular dynamics runs.

Parallel performance

Parallel performance divides into two parts: training parallelism and inference parallelism. Scalable multi-GPU training is essential for pre-training large models on massive structural datasets. To evaluate multi-GPU scaling efficiency and sustained throughput across architectures, we benchmarked training on the curated MPtrj dataset across 1 to 16 NVIDIA A100 GPUs (configured with one MPI rank per GPU) under a fixed per-device batch size, as shown in Figure S13. It can be seen that training acceleration scales near-linearly as GPU counts increase, with individual architectures achieving speedups between 10.5×10.5 \times and 13.7×13.7 \times across 16 GPUs. Consequently, parallel training efficiency gradually attenuates with scale, spanning from 65.7% to 86.0% at 16 GPUs. Aggregate training throughput scales concurrently with GPU allocation, though absolute performance diverges markedly across architectures, ranging from 323 to 3,892 structures per second on 16 GPUs. Overall, while parallel scaling efficiency gradually declines with increasing GPU counts across all models, MACE, NequIP, and PaiNN sustain the highest multi-GPU training throughput, in close alignment with their favorable memory and latency profiles in Figure 6b. In addition, we profiled the computational budget of an individual training iteration across five key components: data loading with neighbor-list construction, host-to-device transfer, forward and backward passes, the gradient all-reduce, and the optimizer update with gradient clipping. It can be seen that graph evaluation, neighbor-list building, and gradient synchronization clearly dominate the training overhead. Complete scaling measurements and timing distributions are detailed in Figure S13 and Tables S9 and S10 in the Supporting Information.

Parallel training scaling and training-step time breakdown for PaiNN, NequIP, Allegro, MACE, EquiformerV2, EquiformerV3, and UMA on 1–16 A100 GPUs

Figure S13. Parallel training on 1–16 A100 GPUs, batch 16 structures per rank, on the cleaned MPtrj database. (a) Speedup X(P)/X(1)X(P)/X(1) against rank count, with the ideal line. (b) Parallel efficiency. (c) Global throughput in structures per second. (d) Where one training step goes at P=16P = 16: data loading and neighbour-list construction, host-to-device transfer, forward and backward, the gradient all-reduce, and gradient clipping plus the optimizer update. The all-reduce share is what separates the curves in (b).

Inference parallelism denotes distributing model evaluation across multiple GPUs, which is essential for large-scale simulations. We evaluated the parallel inference scalability of IANN using the PaiNN foundation potential deployed through our native LAMMPS interface (pair_style iann/multi_gpu). Benchmarks were conducted on thermally rattled FCC Cu supercells across 1 to 8 NVIDIA A100 GPUs (80 GB), assigning one MPI rank per GPU. Figure 7a presents the wall-clock time per MD step across system sizes and GPU allocations. It can be seen that the per-step wall-clock latency decreases systematically as additional GPUs are allocated, with multi-GPU acceleration becoming particularly pronounced for larger systems. Conversely, for smaller systems below approximately 5000 atoms, scaling up to 8 GPUs yields no performance gain due to device underutilization and communication bottlenecks. When compared against the serial baseline, execution on 1 or 2 GPUs using the parallel implementation incurs higher latency across all system sizes. This runtime penalty occurs because spatial domain decomposition in pair_style iann/multi_gpu requires each MPI rank to evaluate extended ghost-atom buffers across subdomain boundaries. Consequently, the aggregate atom count evaluated across ranks exceeds that of serial execution, increasing per-step computation. Additionally, inter-GPU and cross-node communication overhead adds to the total wall-clock time per MD step. Beyond two GPUs, however, per-step wall-clock latency drops below the serial baseline for sufficiently large systems, confirming that distributed compute gains outpace communication overhead as system scale expands. Parallel inference efficiency is illustrated in Figure 7b: parallel efficiency diminishes with higher GPU counts, with smaller systems suffering greater efficiency losses. For instance, in an 864-atom supercell, 8-GPU efficiency drops below 20%. However, when the number of atoms is larger than 23k, the parallel efficiency is about 50%, which is fully consistent with Figure 7a.

Figure 7. Performance of the IANN LAMMPS interface on A100-80GB GPUs. (a) Time per MD step against the number of atoms for 1–8 GPUs. (b) Parallel efficiency against GPU count. (c) Throughput against the number of atoms. (d) Maximum number of atoms versus GPU count.

Sustained throughput, defined as atom count normalized by wall-clock time per MD step, is illustrated in Figure 7c. Computational throughput increases steadily with GPU allocation across all scales, except for the 8-GPU configuration on small systems. In large-scale regimes (around 30k atoms), the 8-GPU throughput reaches approximately 5×5 \times that of single-GPU parallel execution (iann/multi_gpu) and 3×3 \times that of the serial baseline. The maximum number of atoms that can be handled is also evaluated, and shown in Figure 7d. Cross markers indicate configurations that encountered out-of-memory errors. It can be seen that the maximum atom capacity scales linearly with GPU count: only 25,000 atoms can be handled on 1 GPU, while 200,000 atoms can be handled on 8 GPUs, which is an exact eightfold increase. This indicates that the maximum number of atoms is limited by the available GPU memory. Furthermore, the serial implementation handles roughly twice the capacity of the single-GPU parallel configuration, as serial execution bypasses ghost-atom buffer allocation across subdomain boundaries. Overall, parallel inference achieves high scalability in the large-system regime, while total atom capacity remains strictly memory-bound. Comprehensive numerical records, including per-step execution times, parallel efficiencies, and memory thresholds across all configurations, are detailed in Table S11 in the Supporting Information.

Time per step (s)Parallel efficiency (%)
NN1 GPU2 GPUs4 GPUs8 GPUsE2E_2E4E_4E8E_8Y8Y_8 (atom step s−1^{-1})serial (s)
8640.08960.07320.06290.085461361310,1150.0151
2,0480.09900.06900.04710.124072531016,5130.0330
5,3240.19050.15060.10850.123663441943,0740.0789
6,9120.22860.18240.14800.132763392252,0990.0994
10,9760.33070.20220.16330.148882512873,7630.1587
13,5000.38760.23220.20730.1285834738105,0580.1930
16,3840.45010.27240.19820.1272835744128,8250.2300
19,6520.51860.33490.18660.1509776943130,2750.2849
23,3280.60170.35790.20990.1636847246142,5920.3337
27,436‡Poom0.40490.23470.1447ref8670189,5670.3904
32,000‡Poom0.45630.28630.1585ref8072201,8290.4523
42,592‡Poom0.57880.33570.2185ref8666194,8840.6036
48,668‡Poom0.64080.36750.2343ref8768207,690oom
55,296‡Poomoom0.41700.2775n/aref75199,243oom
70,304‡Poomoom0.50330.3118n/aref81225,463oom
87,808‡Poomoom0.59550.3549n/aref84247,402oom
108,000‡Poomoomoom0.4060n/an/aref266,003oom
131,072‡Poomoomoom0.4550n/an/aref288,102oom
157,216‡Poomoomoom0.5152n/an/aref305,149oom
186,624‡Poomoomoom0.6181n/an/aref301,917oom

Table S11. The performance of the IANN LAMMPS interface of pair_style iann/multi_gpu on NVIDIA A100-80GB GPUs in Figure 7 in the manuscript is tabulated here.

Limitations

Long-range electrostatics, charge transfer, and magnetic degrees of freedom are not captured by the strictly local decomposition of Eq. (1) and remain currently unsupported.[54] Furthermore, because the released foundation models inherit the DFT parameters of their underlying training datasets, absolute energies are not transferable across different exchange-correlation functionals—the primary motivation for organizing them by functional rather than pooling them into a single model. Regarding the curated databases in Table 1, outlier filtering enhances training stability but renders them unsuitable for direct benchmarking against published literature, as the excluded structures often constitute the most physically challenging configurations; the uncurated source datasets should be used for such benchmarks. Finally, because architectures are natively reimplemented within our unified interface rather than wrapped as upstream external dependencies, checkpoint binaries from original third-party implementations cannot be loaded directly into IANN. Consequently, models within this framework must either be trained from scratch or fine-tuned from an existing IANN foundation checkpoint.

Conclusions

In this work, we presented IANN, an open-source framework for interatomic neural networks designed to bridge architectural development and production molecular modeling. By integrating diverse equivariant graph neural networks within a unified data structure, trainer, and deployment interface, IANN enables seamless architectural transitions via a single-word modification in the configuration dictionary. Across all supported architectures, atomic forces, virials, and stresses are derived through unified analytic differentiation with respect to graph edge vectors, ensuring exact evaluations under periodic boundary conditions. Furthermore, distributed data-parallel training automatically adapts to SLURM, PBS, or standard MPI schedulers, allowing a single execution script to scale without modification from multi-GPU workstations to multi-node supercomputers. Trained, self-describing checkpoints can be deployed directly as ASE calculators with optional uncertainty estimation, compiled to TorchScript predictors supporting on-the-fly variance evaluation during single- or multi-GPU LAMMPS simulations, or queried via an agent interface. This architectural uniformity facilitates rigorous, controlled benchmarking: across 1.6 million PBE-level structures, energy and force errors vary only modestly among architectures—spanning 0.029 to 0.054 eV/atom and 0.040 to 0.069 eV/A˚\mathrm{\mathring{A}}, respectively. In contrast, computational latency and memory footprints diverge substantially, demonstrating that architecture selection for production simulations must be governed by accuracy–efficiency trade-offs rather than error metrics alone. Finally, our released foundation models—systematically organized by exchange-correlation functional—provide reusable inductive priors that close the loop on active-learning workflows natively backed by uncertainty quantification.

Code availability

IANN is released under the MIT license and is available at https://github.com/changzhiai/IANN, with documentation at https://iann.readthedocs.io. The version described in this paper is archived at https://doi.org/10.5281/zenodo.17809948.

Data availability

The curated reference databases of Table 1 are available at https://huggingface.co/datasets/changzhiai/dft-databases. The foundation models of Table 3 and the architecture comparison of Table 2, together with the training script, are available at https://huggingface.co/changzhiai/iann-foundation-models. The underlying published datasets are cited in Table 1 and remain the appropriate reference for benchmarking.

Acknowledgments

This research was supported by the U.S. Department of Energy, Office of Science, Office of Basic Energy Sciences, Chemical Sciences, Geosciences, and Biosciences Division, Catalysis Science Program to the SUNCAT Center for Interface Science and Catalysis. This research used high-performance computing (HPC) resources of the National Energy Research Scientific Computing Center (NERSC), a Department of Energy User Facility using NERSC award BES-ERCAP0032527. This work also used the HPC resources of the SLAC Shared Science Data Facility (S3DF) at SLAC National Accelerator Laboratory operated by Stanford University for the U.S. Department of Energy’s Office of Science. Work was also performed on the Carbon HPC cluster at the Center for Nanoscale Materials, a U.S. Department of Energy Office of Science User Facility, and was supported by the U.S. DOE, Office of Basic Energy Sciences, under Contract No. DE-AC02-06CH11357.

Keywords

Machine-learning interatomic potentials; Equivariant graph neural networks; Molecular dynamics; Heterogeneous catalysis; Scientific software; Uncertainty quantification

SI.pdf

Supporting Information

Installation

IANN requires Python 3.8 or newer and PyTorch 1.9 or newer. The package and its dependencies (numpy, ase, scipy, asap3, e3nn, toml, py-cpuinfo) are installed with

git clone https://github.com/changzhiai/IANN.git
cd IANN
pip install -e .

GPU support follows the standard PyTorch CUDA installation. e3nn is used for equivariant tensor algebra by default. The optional NVIDIA cuEquivariance[1] library can also be used to accelerate the equivariant tensor products, especially for NequIP and MACE. The LAMMPS interface additionally requires LibTorch (the PyTorch C++ API), CMake ≥3.18\ge3.18 and a C++11 compiler; build instructions are given in the Documentation.

Framework implementation details

This section collects the implementation detail behind the framework overview of the manuscript, in the order the modules are described there. It documents the choices a reader may need in order to reproduce or extend it.

Graph construction and batching

Graph construction is handled by AseDataReader. Periodic systems use the linear-scaling cell-list neighbour list from asap3, non-periodic systems a direct distance-matrix cutoff; in both cases the reader returns edge indices together with the minimum-image edge vectors, and flags the edge vectors as requiring gradients when forces are needed. AseDataset wraps an ASE trajectory or database and reads structures lazily, so that datasets larger than memory are handled without a preprocessing step or a database conversion. Batching is performed by a collate function that concatenates the per-structure tensors, builds an image index that assigns every atom to its structure, and offsets the edge indices of each structure by the cumulative atom count, so that a batch is itself a single valid AtomsData object describing one disconnected graph.

Shared building blocks

Equivariant tensor algebra is provided by e3nn,[2] and the NequIP and MACE implementations transparently use NVIDIA’s cuEquivariance[1] kernels when the optional dependency is installed and chosen. Building blocks that are architecture-independent — the Bessel radial basis of the manuscript, the polynomial cutoff envelope, gated nonlinearities and activation functions — live in iann.tools and are shared.

Adding an architecture

Adding an architecture requires implementing a torch.nn.Module whose forward accepts and returns AtomsData and registering it in the model registry; the data pipeline, trainer, calculators and LAMMPS export are then inherited unchanged.

Trainer configuration

Trainer is configured by a single dictionary that is merged into a documented set of defaults (reproduced in full in the next section). It covers the architecture (num_channels, num_layers, cutoff, and architecture-specific keys such as ℓmax⁡\ell_{\max}, mmax⁡m_{\max}), the objective (forces_weight, virial_weight, stress_weight, loss_per_atom), optimisation (optimizer_type, learning_rate, scheduler_type, max_grad_norm, max_steps or max_epochs, stop_patience), data handling (val_ratio, random_seed, save_split, load_split, norm_data, norm_per_atom), distributed execution and output. Adam, AdamW[3, 4] and SGD optimisers are available, together with seven learning-rate schedules selected by scheduler_type: LambdaLR (the default), ReduceLROnPlateau, CosineAnnealingLR, CosineAnnealingWarmRestarts, StepLR, MultiStepLR and ExponentialLR.[5]

Reproducibility safeguards in the trainer

Several decisions in the trainer exist specifically to remove recurring sources of error. Dataset splits can be written to and reloaded from a JSON file, so that a restarted or fine-tuned run provably reuses the original validation set. Energy statistics for normalisation are computed over the training split only, optionally from a random subsample and with threaded file I/O, which keeps the start-up cost of a multi-million-structure dataset bounded. For architectures that normalise messages by the mean coordination number, the average number of neighbours is measured from the training data automatically rather than being left as a user-supplied constant. Early stopping monitors an exponentially smoothed validation loss, which avoids terminating on a single noisy evaluation. Checkpoints store the architecture name and the complete set of architecture keyword arguments alongside the parameters, so that a model can be reconstructed exactly from the file alone; for older checkpoints that predate this convention, the loader infers the architecture from signatures in the parameter names. Restarts distinguish two intentions explicitly: resuming continues the step counter, optimiser state and schedule exactly, whereas fine-tuning (reset_lr) reloads the parameters but starts a fresh schedule at the requested learning rate.

Detecting the distributed environment

Distributed data-parallel training is enabled with distributed=True and configured by inspecting the environment. The trainer recognises SLURM (SLURM_PROCID, SLURM_NTASKS, SLURM_LOCALID) and the rank variables of OpenMPI, MPICH/Intel MPI and MVAPICH2, and from these derives the global rank, world size, per-node local rank and rendezvous address. PBS/Torque allocations are supported through the same path: PBS exports no rank variables of its own, so the ranks are read from whichever MPI launcher started the processes, while PBS_NODEFILE supplies the rendezvous host and the node list recorded in the log, deduplicated because PBS repeats each host once per requested core. The NCCL backend is selected on GPUs and Gloo on CPUs. On a bare multi-GPU node with no external launcher, the trainer spawns one worker process per visible GPU itself; under srun or mpirun it detects that the launcher has already created the processes and only reads its own coordinates. The practical consequence is that the training script of the manuscript is submitted unchanged on a laptop, a workstation and a multi-node allocation, with the job script alone determining the degree of parallelism.

Resolving and fine-tuning foundation models

A small selection ships inside the package and is resolved by name through foundation_model() irrespective of the working directory; the complete set is hosted separately. Any of them can be used as a zero-shot calculator or as the initialisation for fine-tuning, by passing the checkpoint path as load_model in the trainer configuration together with reset_lr to start a fresh learning-rate schedule.

Exporting a model to LAMMPS

For production MD, a trained model is compiled to TorchScript by convert_model_for_lammps, which wraps the model in a module whose forward takes only plain tensors — the same seven fields that define the graph — and returns a dictionary of energy, forces and atomic energies. Because that signature is architecture-independent, one wrapper and one exporter cover all models, and a companion function combines several checkpoints into a single ensemble module.

Agent interface

Command line. The package installs an iann entry point with nine subcommands — doctor, models, foundation, inspect, predict, train, status, export and agent — covering the operations of the layers above; doctor reports whether an environment can run IANN, and inspect which structural parameters a checkpoint does not record — the usual cause of a parameter-shape mismatch when a model is rebuilt from its weights. Every subcommand accepts --json, under which standard output carries nothing but the JSON document, and exit codes separate success from a failed operation and from a malformed command line, so a failure is never a traceback nor a silent empty result. Training requires an explicit step budget, because max_steps defaults to 10610^{6} and a call that omitted one would begin a run lasting days.

MCP server. The same operations are served as nine tools over stdio by mcp_server, so that a client implementing the Model Context Protocol, and therefore a large-language-model agent, can call them without knowing how the framework is invoked. Both front ends call one implementation — a single function per operation, returning a plain dictionary — so the two cannot drift apart; the protocol SDK is an optional dependency, and the command line needs nothing beyond the base requirements.

Agent skills. iann agent install writes a set of repository notes and five skills into a working copy, recording what cannot be inferred from the source: which environment to use, that scripts are run from the repository root, and that a training run must be given a step budget. The notes are not specific to any one assistant. Job submission to SLURM or PBS, uploads to the model hub and deletion of files are not exposed at all, which confines an automated caller to reads and a bounded amount of local computation; the whole interface is contained in the iann.agent subpackage and documented in the Documentation.

Default trainer configuration

Table S1 lists the configuration keys recognised by iann.trainer.Trainer together with their defaults. Any subset can be overridden through the config dictionary passed to the constructor; keys that are not recognised by the trainer are forwarded to the model constructor, which is how architecture-specific parameters such as lmax, num_basis or parity are set.

KeyDefaultMeaning
Model
num_channels128Feature channels per node
num_layers3Message-passing layers
cutoff5.5Cutoff radius (Å)
Objective
forces_weight0.9Weight wFw_F of the force term
virial_weight0.0Weight wWw_W of the virial term
stress_weight0.0Weight wσw_\sigma of the stress term
loss_per_atomTrueDivide the energy residual by the number of atoms
Optimisation
optimizer_typeadamadam, adamw or sgd
learning_rate1e-4Initial learning rate
KeyDefaultMeaning
scheduler_typeLambdaLROne of ReduceLROnPlateau, LambdaLR, CosineAnnealingLR, CosineAnnealingWarmRestarts, StepLR, MultiStepLR, ExponentialLR
max_grad_norm10.0Gradient-norm clipping threshold
batch_size12Structures per batch and per rank
max_steps1000000Optimiser steps before stopping
max_epochsNoneAlternative stopping criterion
stop_patience200Evaluations without improvement before early stopping
log_interval2000Steps between validation and logging
Data
val_ratio0.1Fraction held out for validation
random_seed666Seed for splitting and initialisation
save_splitFalseFile name for storing the split
load_splitFalseFile name of a split to reuse
norm_dataFalseStandardise energy targets
norm_per_atomFalseStandardise per-atom energies
norm_sample_sizeNoneSubsample size for the normalisation statistics
norm_num_workers0Threads used to read the statistics
Restart
load_modelFalseCheckpoint path to resume or fine-tune from
reset_lrFalseTrue: fresh schedule and step counter (fine-tuning); False: resume exactly
Distributed
dist_timeout600Timeout of collective operations (s)
master_port12356Rendezvous port
Output
deviceNonecpu or cuda; auto-detected if unset
output_diroutputOutput directory
output_logoutput.logLog file
output_modelmodel.ptCheckpoint file
log_inputFalseEcho the user configuration to the log
debugFalseVerbose diagnostics

Table S1. Configuration keys of iann.trainer.Trainer and their default values.

DFT databases

The DFT databases are collected and curated as shown in Table 1 in the manuscript, regrouped by exchange-correlation functional and converted to ASE trajectory format. The sources span three functionals: PBE for MPtrj, sAlex, OMat24, MatPES and OC22; RPBE for OC20 and OC25; and r2SCANr^{2}\mathrm{SCAN} for the meta-GGA subsets of the Materials Project and MatPES. Note that a shared functional does not imply identical settings. For example, MPtrj, OMat24 and OC22 apply a Hubbard correction, the remaining PBE sources do not. OC25 has D3 dispersion corrections, OC20 does not. Outlier structures were removed from every source dataset based on abnormally high energy or force components, abnormally short interatomic distances, or the presence of overlapping atoms.

Foundation models details across architectures

Every architecture compared here is reimplemented within IANN against the shared AtomsData interface rather than taken from the authors’ released code, so the settings below are those of the IANN implementations and need not coincide with the ones published with the original models.

The configuration details of each architecture in the accuracy comparison of the manuscript are given in Table S2. The table lists the number of channels, the highest spherical harmonic degree ℓmax⁡\ell_{\max} and order mmax⁡m_{\max}, the number of message-passing layers, the total number of trainable parameters, the per-rank batch size, the initial learning rate and the gradient-norm clipping threshold. All runs used the curated MPtrj database (1,579,091 PBE structures), a cutoff of 5.5 Å, the Adam optimiser with the LambdaLR schedule, the per-atom energy loss and an early-stopping patience of 500 evaluations; all other keys retain the defaults of Table S1.

ModelChannelsℓmax⁡\ell_{\max}mmax⁡m_{\max}LayersParametersBatchLRClip
PaiNN*128113600,577161×10−41 \times10^{-4}10.0
NequIP321131,379,513161×10−41 \times10^{-4}10.0
Allegro128114567,624161×10−41 \times10^{-4}10.0
MACE481131,429,376161×10−41 \times10^{-4}10.0
EquiformerV216423773,08981×10−41 \times10^{-4}10.0
EquiformerV332323943,249161×10−41 \times10^{-4}10.0
UMA642231,173,698161×10−41 \times10^{-4}10.0

Table S2. Settings of the training of each architecture. ℓmax⁡\ell_{\max} is the highest spherical harmonic degree the features carry and mmax⁡m_{\max} the highest order kept at each degree; NequIP, MACE and Allegro build full O(3)O(3) irreps, so mmax⁡=ℓmax⁡m_{\max} = \ell_{\max}, whereas the Equiformers truncate below ℓmax⁡\ell_{\max} to cut the cost of the SO(2)SO(2) convolution. *Equivalent values: PaiNN exposes neither setting, but its Cartesian scalars and vectors are equivariant to ℓ≤1\ell\leq1 with all orders present.

EquiformerV2 additionally used grid_resolution=12 and avg_degree=43.0; UMA used hidden_channels=64, edge_channels=64 and num_distance_basis=128. All architectures except PaiNN were trained with per-atom energy standardisation (norm_per_atom=True), with the statistics estimated from a random subsample of 5000 training frames (norm_sample_size). For MACE, NequIP and Allegro the trainer measured the average number of neighbours from the training data automatically.

Foundation model details across datasets

Table S3: Accuracy of the released PaiNN foundation models. Energies are per atom; forces are per Angstrom. NstructN_{\mathrm{struct}} and NatomN_{\mathrm{atom}} count the structures and atoms entering each fit.

DatasetNstructN_{\mathrm{struct}}NatomN_{\mathrm{atom}}Energy (eV atom−1^{-1})Force (eV Å−1^{-1})
MAER2R^2MAER2R^2
PBE
Alexandria10,422,893107,451,4440.04080.99880.05130.9512
MatPES434,0833,865,2010.04630.99840.09300.9583
MPtrj1,579,05849,229,8390.05170.99800.04980.9767
OC228,198,695654,300,2660.03810.99860.05280.8373
OMat2411,261,400156,856,5500.02610.99910.13820.9961
RPBE
OC201,999,216146,438,3270.02630.99970.06300.9422
OC257,369,6011,064,203,1620.01160.99980.07530.9864
r2r^{2}SCAN
MatPES387,2853,039,0300.04460.99990.11270.9507
MPtrj238,2415,022,9510.02060.99990.01170.9710

Table S3.

Parity plots for the foundation models

Figure S1–S9 give fitting parity plots of energy and forces between each foundation model and its DFT reference data, one figure per released model in the order of Table 3 in the manuscript. The colorbar shows the number of structures in each bin, and the dashed line is the y=xy=x diagonal. The details of the training databases and the full error statistics are given in Table S3 of the next section.

Energy and force parity plots between the prediction of the PBE-MPtrj foundation model and the DFT reference.

Figure S1. Energy and force parity plots between the prediction of the PBE-MPtrj foundation model and the DFT reference.

Energy and force parity plots between the prediction of the PBE-sAlex foundation model and the DFT reference.

Figure S2. Energy and force parity plots between the prediction of the PBE-sAlex foundation model and the DFT reference.

Energy and force parity plots between the prediction of the PBE-OMat24 foundation model and the DFT reference.

Figure S3. Energy and force parity plots between the prediction of the PBE-OMat24 foundation model and the DFT reference.

Energy and force parity plots between the prediction of the PBE-MatPES foundation model and the DFT reference

Figure S4. Energy and force parity plots between the prediction of the PBE-MatPES foundation model and the DFT reference.

Energy and force parity plots between the prediction of the PBE-OC22 foundation model and the DFT reference

Figure S5. Energy and force parity plots between the prediction of the PBE-OC22 foundation model and the DFT reference.

Energy and force parity plots between the prediction of the RPBE-OC20 foundation model and the DFT reference

Figure S6. Energy and force parity plots between the prediction of the RPBE-OC20 foundation model and the DFT reference.

Energy and force parity plots between the prediction of the RPBE-OC25 foundation model and the DFT reference.

Figure S7. Energy and force parity plots between the prediction of the RPBE-OC25 foundation model and the DFT reference.

Energy and force parity plots between the prediction of the r²SCAN-MPtrj foundation model and the DFT reference.

Figure S8. Energy and force parity plots between the prediction of the r2r^{2}SCAN-MPtrj_{\mathrm{trj}} foundation model and the DFT reference.

Energy and force parity plots between the prediction of the r²SCAN-MatPES foundation model and the DFT reference.

Figure S9. Energy and force parity plots between the prediction of the r2r^{2}SCAN-MatPES foundation model and the DFT reference.

Fine-tuning details

Table S4 gives the full series behind the full-budget comparison. Training was performed on the same train set of 24,154 structures from the AdsTraj training set, evaluated throughout on the same test set of 7,296 structures. The zero-shot row is the error of the RPBE-OC20 foundation model on the test set, without any fine-tuning. The “from scratch” rows are the errors of models trained from random initialisation on the indicated number of training structures, and the “fine-tuned” rows are the errors of the same model after fine-tuning from RPBE-OC20 on the same number of training structures. The final row is the same as Table 4 in the manuscript.

Training cost

Four-panel plots showing training wall time, throughput, peak GPU memory, and training-step versus inference-call cost for different models

Figure S10. Cost of training measured on the same V100 as inference. (a) Wall time per optimizer step against batch size, in 108-atom cells. (b) Training throughput in structures per second, and where it saturates. (c) Peak GPU memory versus batch size. (d) One training step against one inference call on the same cell. The corresponding numbers are in Table S5.

ArchitectureBaB^{a}stepb^{b} (ms)struct./sGPU-h per 10610^{6} stepsmem (GiB)step at B=16cB=16^{c} (ms)vs inferenced^{d}
PaiNN1686.018623.93.886.02.8×
NequIP16110.114530.62.0110.12.2×
Allegro16935.417259.810.9935.42.8×
MACE1691.317525.42.791.32.5×
EquiformerV28824.910229.119.91649.82.4×
EquiformerV316919.117255.325.5919.12.6×
UMA16515.431143.216.7515.43.0×

Table S5. Table S5: Cost and corresponding details of all architectures trained on Tesla V100 GPU.

Inference cost

Table S8. DFT calculations on CPUs: VASP 6.3.2 single points on the same Pt(111)+CO cells, RPBE, cutoff with 450 eV, and 64 MPI ranks on one node.

Atomsb^{b}LOOP+ (s)a^{a}SCF stepss per SCF step
182.5350.07
388.3390.21
6621.7380.57
10263.3451.41
146149.7433.48

caption:

Wall time consumption in an energy+forces call

Figure S11. The wall time consumption in an energy+forces call with same models and hardware as Figure 6 in the manuscript. (a) Share of each call spent building the neighbour list against system size. (b) Throughput against batch size at a fixed 108-atom cell. (c) Cost against the number of edges in the graph at the 5.5 Å cutoff for two geometries: bulk fcc Pt at 42 edges per atom (filled) and the Pt(111) slab at 33 (open), whose surface atoms are missing a quarter of their neighbours. (d) Ratio of CPU to GPU wall time, per architecture and per size.

Energy-only inference versus energy+forces inference

Figure S12. Energy-only inference versus energy+forces inference. (a) Time per energy-only call against system size, timed under no autograd graph is built. (b) Forces cost, as the ratio of the two timing modes. (c) Peak GPU memory in both modes. Solid is for the energy+forces mode and open is for the energy-only mode. (d) Throughput in the two modes against each other. The corresponding numbers are in Table S7.

Table S7. Energy-only inference against energy+forces. Energy-only is timed under no autograd graph retained.

ArchitectureFloor EE (ms)CrossoverE_E (μ\mus/atom)FloorE+F_{E+F} (ms)CrossoverE+F_{E+F} (μ\mus/atom)Force cost,a^{a} FloorForce cost,a^{a} CrossoverMemEb^{b}_{E} (GiB)MemE+Fb^{b}_{E+F} (GiB)
PaiNN3.16.99.015.92.90×2.30×0.331.36
NequIP6.75.524.318.53.61×3.33×0.290.92
Allegro4.554.319.1180.74.28×3.33×1.075.72
MACE8.25.520.815.02.55×2.72×0.210.76
EquiformerV239.095.5114.6306.72.94×3.21×7.7319.77
EquiformerV319.358.953.6171.62.78×2.91×2.0713.28
UMA11.139.328.491.42.57×2.33×0.704.32

caption:

Parallel training details

Table S9: Training efficiency of different architectures on MPtrj on 1 to 16 NVIDIA A100-SXM4-80GB GPUs. BB is each run’s own per-rank batch size, so the global batch is P×BP \times B and the work per GPU is fixed; XX is the global throughput in structures per second and the efficiency is X(P)/(PX(1))X(P)/(P X(1)). The all-reduce column is the part of the gradient reduction that is not hidden behind the backward pass.

ArchitectureBB per rankGlobal BB at P=16P=16X(1)X(1) (struct./s)X(16)X(16) (struct./s)SpeedupEfficiency (%)All-reduce (% step)Mem/GPU (GiB)
PaiNN16256305.43892.512.7579.7 ± 0.719.53.22
NequIP16256218.62919.713.3683.6 ± 0.28.11.62
Allegro1625670.3756.510.7767.3 ± 1.041.19.24
MACE16256208.82869.013.7486.0 ± 0.57.52.17
EquiformerV2812830.8323.210.5065.7 ± 1.643.224.27
EquiformerV31625661.3727.511.8674.1 ± 0.329.119.99
UMA1625695.41082.111.3471.1 ± 0.437.212.75

Table S9. Training efficiency of different architectures on MPtrj on 1 to 16 NVIDIA A100-SXM4-80GB GPUs.

Table S10: Training global throughput X(P)X(P) in structures per second, and parallel efficiency X(P)/(PX(1))X(P)/(P X(1)), at every allocation from 1 to 16 A100 GPUs. BB is the per-rank batch size, so the global batch at each column is P×BP \times B. Every world size times an identical set of structures.

ArchitectureBB\multicolumn{5}{c}{X(P)X(P) (structures s−1^{-1})}\multicolumn{4}{c}{Parallel efficiency (%) }
12481624816
PaiNN1630557711062042389294.390.583.579.7
NequIP162194317981509292098.591.386.583.6
Allegro167011822341075684.479.773.067.3
MACE162094097751470286998.092.888.186.0
EquiformerV2831559817632389.079.571.365.7
EquiformerV3166111320938572791.985.078.574.1
UMA1695174316575108291.482.875.471.1

Table S10. Training global throughput X(P)X(P) in structures per second, and parallel efficiency X(P)/(PX(1))X(P)/(P X(1)), at every allocation from 1 to 16 A100 GPUs.

Parallel inference details

Table S11: The performance of the IANN LAMMPS interface of pair_style iann/multi_gpu on NVIDIA A100-80GB GPUs in Figure 7 in the manuscript is tabulated here. The step time per step on 1 to 8 GPUs, the corresponding efficiencies derived from them, and the Y8Y_8 throughput at eight GPUs are listed at each system size. For 8 GPUs, four GPUs sit in one node (NVLink), and eight span two (Slingshot). The last column is the exact serial run of LAMMPS interface with pair_style iann on a single GPU.

oom: CUDA out of memory on the 80 GB device – measured, not inferred, and reproduced in all three repeats.

n/a: not defined, because the run it would be derived from oomed. ‡P: this size does not fit on one GPU, so its efficiencies are referenced to PP GPUs rather than one. Every entry is the median of three independent jobs. Runs use PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True and a warm-up run before each timed run; without these the large cells are 16–29% slower and their efficiencies correspondingly overestimated. tPt_P is the wall-clock step time. The model-evaluation component alone scales smoothly at every size.

Distributed submission scripts

The parallelization training submission script on a SLURM machine with four GPUs per node:

#!/bin/bash
#SBATCH -N 2
#SBATCH -C gpu
#SBATCH -q regular
#SBATCH -t 04:00:00
#SBATCH --gpus-per-node=4
#SBATCH --ntasks-per-node=4
#SBATCH --cpus-per-task=32

export GPUS_PER_NODE=$SLURM_GPUS_ON_NODE
export NNODES=$SLURM_NNODES

srun -N $NNODES -n $((NNODES*GPUS_PER_NODE)) python train.py

Rank, world size, per-node local rank and the rendezvous address are read from the scheduler environment by the trainer. Under PBS with mpirun, the first host of $PBS_NODEFILE is used as the rendezvous address unless MASTER_ADDR is exported explicitly and forwarded to every rank.

LAMMPS interface

A trained checkpoint is compiled to TorchScript with:

from iann.plugins.converter import convert_model_for_lammps

convert_model_for_lammps(model_path="output/model.pt",
                         output_path="model_lmp.pt")

Several checkpoints are combined into one ensemble module with convert_models_for_lammps. The model type is read from the checkpoint metadata and does not have to be supplied. The exported file is used in a LAMMPS input script as:

units metal
atom_style atomic
boundary p p p
read_data initial.data

pair_style iann painn model_lmp.pt 5.5
pair_coeff * *

neighbor 0.5 bin
neigh_modify every 1 delay 0 check yes

compute variance all iann/variance
thermo_style custom step pe ke etotal temp press &
             c_variance[1] c_variance[2] c_variance[3] c_variance[4]
thermo 100

timestep 0.001
fix 1 all nvt temp 300.0 300.0 0.1
run 100000

where the four components of c_variance are the mean energy variance, the mean force variance, the maximum energy variance and the maximum force variance over the ensemble. Replacing pair_style iann by pair_style iann/multi_gpu assigns one GPU to each MPI rank, so that device placement follows the LAMMPS domain decomposition.

Uncertainty quantification

from iann.calculators import AtomicEnsembleCalculator

calc = AtomicEnsembleCalculator(
    model_paths=["m1.pt", "m2.pt", "m3.pt"], device="cuda")
atoms.calc = calc
energy = atoms.get_potential_energy()
unc = calc.get_ensemble()
print(unc["energy_var"], unc["atomic_energy_var"])

EnsembleCalculator returns not only average energy and forces but also the variance of the total energy and of the forces; AtomicEnsembleCalculator additionally returns the variance of the per-atom energy decomposition, which localises the uncertainty on individual atoms.

Appendix: Periodic-table statistics for each database

Figure S14–Figure S49 repeat the element-resolved maps for each source database on its own, using the model trained on that database alone.

Periodic table heatmap showing PBE-MPtrj element count

Figure S14. PBE-MPtrj: number of structures containing each element. 1,579,091 structures, 49,231,714 atoms, 89 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Image not extracted

Figure S49. r2SCAN-MatPES: per-element force MAE (eV/A˚\mathrm{eV}/\mathrm{\mathring{A}}) of the model trained on this database alone, which reaches 0.1129 eV/A˚\mathrm{eV}/\mathrm{\mathring{A}} overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table heatmap showing PBE-MPtrj atom count

Figure S15. PBE-MPtrj: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table map of per-element energy MAE for PBE-MPtrj

Figure S16. PBE-MPtrj: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0517 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table map of per-element force MAE for PBE-MPtrj

Figure S17. PBE-MPtrj: per-element force MAE (eV/A˚\AA) of the model trained on this database alone, which reaches 0.0498 eV/A˚\AA overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Element count (PBE-sAlex)

Figure S18. PBE-sAlex: number of structures containing each element. 10,423,284 structures, 107,455,806 atoms, 89 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Atom count (PBE-sAlex)

Figure S19. PBE-sAlex: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table showing per-element energy MAE for PBE-sAlex

Figure S20. PBE-sAlex: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0408 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table showing per-element force MAE for PBE-sAlex

Figure S21. PBE-sAlex: per-element force MAE (eV/A˚\AA) of the model trained on this database alone, which reaches 0.0513 eV/A˚\AA overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Element count (PBE-OMat24) periodic-table map

Figure 22. PBE-OMat24: number of structures containing each element. 11,274,650 structures, 157,069,839 atoms, 89 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Atom count (PBE-OMat24) periodic-table map

Figure 23. PBE-OMat24: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic-table map of per-element energy MAE for PBE-OMat24

Figure S24. PBE-OMat24: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0264 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic-table map of per-element force MAE for PBE-OMat24

Figure S25. PBE-OMat24: per-element force MAE (eV/Å) of the model trained on this database alone, which reaches 0.1391 eV/Å overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Element count (PBE-MatPES) periodic-table map

Figure S26. PBE-MatPES: number of structures containing each element. 434,092 structures, 3,865,819 atoms, 89 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Atom count (PBE-MatPES) periodic-table map

Figure S27. PBE-MatPES: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table showing per-element energy MAE for PBE-MatPES

Figure S28. PBE-MatPES: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0463 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table showing per-element force MAE for PBE-MatPES

Figure S29. PBE-MatPES: per-element force MAE (eV/Å) of the model trained on this database alone, which reaches 0.0930 eV/Å overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table showing element count for PBE-OC22

Figure S30. PBE-OC22: number of structures containing each element. 8,199,197 structures, 654,340,594 atoms, 57 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table showing atom count for PBE-OC22

Figure S31. PBE-OC22: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic-table map of per-element energy MAE for PBE-OC22

Figure S32. PBE-OC22: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0381 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic-table map of per-element force MAE for PBE-OC22

Figure S33. PBE-OC22: per-element force MAE (eV/A˚\text{\AA}) of the model trained on this database alone, which reaches 0.0528 eV/A˚\text{\AA} overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Element count (RPBE-OC20)

Figure S34. RPBE-OC20: number of structures containing each element. 1,999,572 structures, 146,467,030 atoms, 56 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Atom count (RPBE-OC20)

Figure S35. RPBE-OC20: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Energy MAE (RPBE-OC20) periodic-table map

Figure S36. RPBE-OC20: per-element energy MAE (eV/atom\mathrm{eV/atom}) of the model trained on this database alone, which reaches 0.0263 eV/atom\mathrm{eV/atom} overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Force MAE (RPBE-OC20) periodic-table map

Figure S37. RPBE-OC20: per-element force MAE (eV/A˚\mathrm{eV/\mathring{A}}) of the model trained on this database alone, which reaches 0.0630 eV/A˚\mathrm{eV/\mathring{A}} overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table showing element count for RPBE-OC25

Figure S38. RPBE-OC25: number of structures containing each element. 7,370,461 structures, 1,064,330,294 atoms, 73 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic table showing atom count for RPBE-OC25

Figure S39. RPBE-OC25: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic-table map of per-element energy MAE for RPBE-OC25

Figure S40. RPBE-OC25: per-element energy MAE (eV/atom\mathrm{eV}/\mathrm{atom}) of the model trained on this database alone, which reaches 0.0116 eV/atom\mathrm{eV}/\mathrm{atom} overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Periodic-table map of per-element force MAE for RPBE-OC25

Figure S41. RPBE-OC25: per-element force MAE (eV/A˚\mathrm{eV}/\text{\AA}) of the model trained on this database alone, which reaches 0.0753 eV/A˚\mathrm{eV}/\text{\AA} overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Element count (r2SCAN-MPtrj)

Figure S42. r2SCAN-MPtrj: number of structures containing each element. 238,241 structures, 5,022,951 atoms, 88 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Atom count (r2SCAN-MPtrj)

Figure S43. r2SCAN-MPtrj: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Image not extracted

Figure S44. r2SCAN-MPtrj: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0206 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Image not extracted

Figure S45. r2SCAN-MPtrj: per-element force MAE (eV/A˚\mathring{\mathrm{A}}) of the model trained on this database alone, which reaches 0.0117 eV/A˚\mathring{\mathrm{A}} overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Image not extracted

Figure S46. r2SCAN-MatPES: number of structures containing each element. 387,306 structures, 3,040,410 atoms, 89 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Image not extracted

Figure S47. r2SCAN-MatPES: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Image not extracted

Figure S48. r2SCAN-MatPES: per-element energy MAE (eV/atom\mathrm{eV}/\mathrm{atom}) of the model trained on this database alone, which reaches 0.0446 eV/atom\mathrm{eV}/\mathrm{atom} overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

References

  1. [1]NVIDIA, cuEquivariance: GPU-accelerated primitives for equivariant neural networks, https: //github.com/NVIDIA/cuEquivariance, 2025.
  2. [2]M. Geiger, T. Smidt, e3nn: Euclidean neural networks, arXiv:2207.09453, 2022.arxiv.org/abs/2207.09453
  3. [3]D. P. Kingma, J. Ba in International Conference on Learning Representations, 2015.
  4. [4]I. Loshchilov, F. Hutter in International Conference on Learning Representations, 2019.
  5. [5]I. Loshchilov, F. Hutter in International Conference on Learning Representations, 2017.

Paper details

vlnc:W_bd68yyxu
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

Not recorded for this paper

View statement
Looking for related papers…
Contents