LAMMPS + ReaxFF

Use this skill when the user wants to run molecular dynamics in LAMMPS with a ReaxFF force field, prepare or explain an

input.lammps

file, and set up charge equilibration (QEq) correctly.

Agent responsibilities

1. Confirm the ReaxFF force field file (e.g.

   ffield.reax.*

   ). Do not guess which file is appropriate.
   • If the user does not have a force field yet, point them to known sources (e.g. LAMMPS

     potentials/ffield.reax.*

     at https://github.com/lammps/lammps/tree/develop/potentials).
2. Confirm the structure/data file (e.g.

   data.system

   ) and the atom type → element mapping needed by

   pair_coeff

   .
3. Ensure the input includes charge handling:
   • Use a charge-capable atom style, such as

     atom_style charge

     or

     atom_style full

     , and ensure charges are initialized either from the data file (with a charge column compatible with the chosen

     atom_style

     ) or via explicit commands (e.g.

     set

     or equal-style variables). Do not rely on

     fix property/atom q

     as a substitute for a real charge field used by ReaxFF/QEq.
   • Add one charge equilibration fix, typically

     fix qeq/reaxff

     , unless the user explicitly requests otherwise.
4. Write the LAMMPS input script yourself; keep examples readable and annotated.
5. When possible, validate command availability against LAMMPS docs or local

   lmp -h

   output before execution.
6. Report clearly which command was run, which files were used, and where outputs were written.

Minimum information to collect

Ask only for what is missing:

• LAMMPS data file path (or structure + how to generate a data file)
• ReaxFF force field file path (

  ffield.reax...

  )
• Atom types present and their element mapping (for

  pair_coeff * * ffield ...

  )
• Ensemble (NVE / NVT / NPT)
• Temperature, pressure (if NPT), timestep, run length
• Execution mode: online provisioning vs user-specified LAMMPS binary

Execution mode

Online mode (only if internet access +

uv

is available)

Use:

uvx --from 'lammps[mpi]' lmp -in input.lammps

Notes:

• If you see

  error while loading shared libraries: libmpi.so...

  , you likely installed an MPI-linked

  lmp

  without MPI runtime libraries. Prefer

  uvx --from 'lammps[mpi]' ...

  (bundles MPI runtime), or load/install MPICH/OpenMPI via system packages/conda/HPC module.

Offline mode (common / HPC)

Do not invent the executable. Ask which command should be used, e.g.:

• lmp -in input.lammps

• mpirun -np 32 lmp_mpi -in input.lammps

• srun lmp -in input.lammps

Example: annotated NVT input (ReaxFF + QEq)

See also

assets/input.reaxff.nvt.lammps

.

# --------- user knobs ---------
variable        NSTEPS      equal 200000
variable        THERMO      equal 200
variable        DUMP        equal 1000

variable        TEMP        equal 300.0
variable        TAU_T       equal 100.0

# Timestep (fs for units real). For high-T / reactive runs, 0.1 fs is often safer.
variable        DT          equal 0.25


# QEq parameters
variable        QEQ_EVERY   equal 1
variable        QEQ_TOL     equal 1.0e-6
variable        QEQ_CUTLO   equal 0.0
variable        QEQ_CUTHI   equal 10.0

units           real
boundary        p p p
atom_style      charge

read_data       data.system

neighbor        2.0 bin
neigh_modify    every 1 delay 0 check yes

# ReaxFF potential
pair_style      reaxff NULL
pair_coeff      * * ffield.reax C H O

# Charge equilibration (required for most ReaxFF parameterizations)
fix             fqeq all qeq/reaxff ${QEQ_EVERY} ${QEQ_CUTLO} ${QEQ_CUTHI} ${QEQ_TOL} reaxff
# (`reaxff` here means QEq parameters are extracted from the ReaxFF force field file.)

# Thermo and trajectory
thermo_style    custom step temp pe ke etotal press vol density
thermo          ${THERMO}

dump            1 all custom ${DUMP} traj.lammpstrj id type q x y z

# Dynamics
velocity        all create ${TEMP} 12345 mom yes rot yes dist gaussian
fix             fnvt all nvt temp ${TEMP} ${TEMP} ${TAU_T}

timestep        ${DT}
run             ${NSTEPS}

Notes on the example

• units real

  is a common choice for ReaxFF (time in fs). Many published ReaxFF workflows use

  real

  , but the correct choice depends on the parameterization and your conventions.
• Timestep:

  0.25 fs

  may be fine for moderate temperatures, but for high-temperature ReaxFF (especially with H present) it is common to reduce to

  0.1 fs

  (or even

  0.05 fs

  if needed). A quick sanity check is a short NVE segment to verify total-energy drift before running long NVT/NPT.

• atom_style charge

  is used because ReaxFF and QEq require per-atom charges.

• pair_style reaxff NULL

  uses default ReaxFF control settings. If you have a ReaxFF control file, replace

  NULL

  with its filename.

• pair_coeff * * ffield.reax C H O

  :
  • The trailing symbols define the element mapping for LAMMPS atom types (type 1->C, type 2->H, type 3->O in this example). Adjust to match your data file.

• fix qeq/reaxff ... reaxff

  uses QEq parameters extracted from the ReaxFF force field file.

Sanity checks (recommended before long runs)

1. Short NVE stability check (no thermostat/barostat)

• Run 1–5 ps NVE and check that

  etotal

  drift is reasonable (and that the run does not blow up).

Example (

units real

):

reset_timestep  0
unfix           fnvt
fix             fnve all nve

# high-T ReaxFF often needs a smaller timestep
# (common choices: 0.1 fs; if needed 0.05 fs)
timestep        0.1
run             2000

• If it blows up: reduce timestep (e.g. 0.25 fs → 0.1 fs → 0.05 fs), check the initial geometry, and ensure QEq converges.

2. QEq convergence

• If QEq hits max iterations often, consider better initial charges, looser timestep, or

  maxiter

  (see LAMMPS

  fix qeq/reaxff

  ).

Optional: species analysis

If the user wants reaction product tracking, add

fix reaxff/species

(see

references/reaxff-workflow.md

). This writes time series counts of detected molecular species using bond-order cutoffs.

Output checklist

After a run, report at least:

• executed command
• input script path
• data file path
• ffield path and element mapping used
• whether QEq was enabled and with which settings
• main log path (

  log.lammps

  )
• trajectory/species output paths (if any)

References

• pair_style reaxff: https://docs.lammps.org/pair_reaxff.html
• fix qeq/reaxff: https://docs.lammps.org/fix_qeq_reaxff.html
• fix reaxff/species: https://docs.lammps.org/fix_reaxff_species.html