Previous Section - LAMMPS WWW Site - LAMMPS Documentation - LAMMPS Commands - Next Section

### 4. Packages

This section gives an overview of the add-on optional packages that extend LAMMPS functionality. Packages are groups of files that enable a specific set of features. For example, force fields for molecular systems or granular systems are in packages. You can see the list of all packages by typing "make package" from within the src directory of the LAMMPS distribution.

Here are links for two tables below, which list standard and user packages.

4.1 Standard packages
4.2 User packages

Section 2.3 of the manual describes the difference between standard packages and user packages. It also has general details on how to include/exclude specific packages as part of the LAMMPS build process, and on how to build auxiliary libraries or modify a machine Makefile if a package requires it.

Following the two tables below, is a sub-section for each package. It has a summary of what the package contains. It has specific instructions on how to install it, build or obtain any auxiliary library it requires, and any Makefile.machine changes it requires. It also lists pointers to examples of its use or documentation provided in the LAMMPS distribution. If you want to know the complete list of commands that a package adds to LAMMPS, simply list the files in its directory, e.g. "ls src/GRANULAR". Source files with names that start with compute, fix, pair, bond, etc correspond to command styles with the same names.

NOTE: The USER package sub-sections below are still being filled in, as of March 2016.

Unless otherwise noted below, every package is independent of all the others. I.e. any package can be included or excluded in a LAMMPS build, independent of all other packages. However, note that some packages include commands derived from commands in other packages. If the other package is not installed, the derived command from the new package will also not be installed when you include the new one. E.g. the pair lj/cut/coul/long/omp command from the USER-OMP package will not be installed as part of the USER-OMP package if the KSPACE package is not also installed, since it contains the pair lj/cut/coul/long command. If you later install the KSPACE package and the USER-OMP package is already installed, both the pair lj/cut/coul/long and lj/cut/coul/long/omp commands will be installed.

#### 4.1 Standard packages

The current list of standard packages is as follows. Each package name links to a sub-section below with more details.

Package | Description | Author(s) | Doc page | Example | Library
ASPHERE | aspherical particles | - | Section 6.6.14 | ellipse | -
BODY | body-style particles | - | body | body | -
CLASS2 | class 2 force fields | - | pair_style lj/class2 | - | -
COLLOID | colloidal particles | Kumar (1) | atom_style colloid | colloid | -
COMPRESS | I/O compression | Axel Kohlmeyer (Temple U) | dump */gz | - | -
CORESHELL | adiabatic core/shell model | Hendrik Heenen (Technical U of Munich) | Section 6.6.25 | coreshell | -
DIPOLE | point dipole particles | - | pair_style dipole/cut | dipole | -
GPU | GPU-enabled styles | Mike Brown (ORNL) | Section 5.3.1 | gpu | lib/gpu
GRANULAR | granular systems | - | Section 6.6.6 | pour | -
KIM | openKIM potentials | Smirichinski & Elliot & Tadmor (3) | pair_style kim | kim | KIM
KOKKOS | Kokkos-enabled styles | Trott & Moore (4) | Section 5.3.3 | kokkos | lib/kokkos
KSPACE | long-range Coulombic solvers | - | kspace_style | peptide | -
MANYBODY | many-body potentials | - | pair_style tersoff | shear | -
MEAM | modified EAM potential | Greg Wagner (Sandia) | pair_style meam | meam | lib/meam
MC | Monte Carlo options | - | fix gcmc | - | -
MOLECULE | molecular system force fields | - | Section 6.6.3 | peptide | -
OPT | optimized pair styles | Fischer & Richie & Natoli (2) | Section 5.3.5 | - | -
PERI | Peridynamics models | Mike Parks (Sandia) | pair_style peri | peri | -
POEMS | coupled rigid body motion | Rudra Mukherjee (JPL) | fix poems | rigid | lib/poems
PYTHON | embed Python code in an input script | - | python | python | lib/python
REAX | ReaxFF potential | Aidan Thompson (Sandia) | pair_style reax | reax | lib/reax
REPLICA | multi-replica methods | - | Section 6.6.5 | tad | -
RIGID | rigid bodies | - | fix rigid | rigid | -
SHOCK | shock loading methods | - | fix msst | - | -
SNAP | quantum-fit potential | Aidan Thompson (Sandia) | pair snap | snap | -
SRD | stochastic rotation dynamics | - | fix srd | srd | -
VORONOI | Voronoi tesselations | Daniel Schwen (LANL) | compute voronoi/atom | - | Voro++

The "Authors" column lists a name(s) if a specific person is responible for creating and maintaining the package.

(1) The COLLOID package includes Fast Lubrication Dynamics pair styles which were created by Amit Kumar and Michael Bybee from Jonathan Higdon's group at UIUC.

(2) The OPT package was created by James Fischer (High Performance Technologies), David Richie, and Vincent Natoli (Stone Ridge Technolgy).

(3) The KIM package was created by Valeriu Smirichinski, Ryan Elliott, and Ellad Tadmor (U Minn).

(4) The KOKKOS package was created primarily by Christian Trott and Stan Moore (Sandia). It uses the Kokkos library which was developed by Carter Edwards, Christian Trott, and others at Sandia.

The "Doc page" column links to either a sub-section of the Section 6 of the manual, or an input script command implemented as part of the package, or to additional documentation provided within the package.

The "Example" column is a sub-directory in the examples directory of the distribution which has an input script that uses the package. E.g. "peptide" refers to the examples/peptide directory.

The "Library" column lists an external library which must be built first and which LAMMPS links to when it is built. If it is listed as lib/package, then the code for the library is under the lib directory of the LAMMPS distribution. See the lib/package/README file for info on how to build the library. If it is not listed as lib/package, then it is a third-party library not included in the LAMMPS distribution. See details on all of this below for individual packages.

##### ASPHERE package

Contents: Several computes, time-integration fixes, and pair styles for aspherical particle models: ellipsoids, 2d lines, 3d triangles.

To install via make or Make.py:

    make yes-asphere
    make machine

    Make.py -p asphere -a machine

To un-install via make or Make.py:

    make no-asphere
    make machine

    Make.py -p ^asphere -a machine

Supporting info: Section 6.14, pair_style gayberne, pair_style resquared, doc/PDF/pair_gayberne_extra.pdf, doc/PDF/pair_resquared_extra.pdf, examples/ASPHERE, examples/ellipse

##### BODY package

Contents: Support for body-style particles. Computes, time-integration fixes, pair styles, as well as the body styles themselves. See the body doc page for an overview.

To install via make or Make.py:

    make yes-body
    make machine

    Make.py -p body -a machine

To un-install via make or Make.py:

    make no-body
    make machine

    Make.py -p ^body -a machine

Supporting info: atom_style body, body, pair_style body, examples/body

##### CLASS2 package

Contents: Bond, angle, dihedral, improper, and pair styles for the COMPASS CLASS2 molecular force field.

To install via make or Make.py:

    make yes-class2
    make machine

    Make.py -p class2 -a machine

To un-install via make or Make.py:

    make no-class2
    make machine

    Make.py -p ^class2 -a machine

Supporting info: bond_style class2, angle_style class2, dihedral_style class2, improper_style class2, pair_style lj/class2

##### COLLOID package

Contents: Support for coarse-grained colloidal particles. Wall fix and pair styles that implement colloidal interaction models for finite-size particles. This includes the Fast Lubrication Dynamics method for hydrodynamic interactions, which is a simplified approximation to Stokesian dynamics.

To install via make or Make.py:

    make yes-colloid
    make machine

    Make.py -p colloid -a machine

To un-install via make or Make.py:

    make no-colloid
    make machine

    Make.py -p ^colloid -a machine

Supporting info: fix wall/colloid, pair_style colloid, pair_style yukawa/colloid, pair_style brownian, pair_style lubricate, pair_style lubricateU, examples/colloid, examples/srd

##### COMPRESS package

Contents: Support for compressed output of dump files via the zlib compression library, using dump styles with a "gz" in their style name.

Building with the COMPRESS package assumes you have the zlib compression library available on your system. The build uses the lib/compress/Makefile.lammps file in the compile/link process. You should only need to edit this file if the LAMMPS build cannot find the zlib info it specifies.

To install via make or Make.py:

    make yes-compress
    make machine

    Make.py -p compress -a machine

To un-install via make or Make.py:

    make no-compress
    make machine

    Make.py -p ^compress -a machine

Supporting info: src/COMPRESS/README, lib/compress/README, dump atom/gz, dump cfg/gz, dump custom/gz, dump xyz/gz

##### CORESHELL package

Contents: Compute and pair styles that implement the adiabatic core/shell model for polarizability. The compute temp/cs command measures the temperature of a system with core/shell particles. The pair styles augment Born, Buckingham, and Lennard-Jones styles with core/shell capabilities. See Section 6.26 for an overview of how to use the package.

To install via make or Make.py:

    make yes-coreshell
    make machine

    Make.py -p coreshell -a machine

To un-install via make or Make.py:

    make no-coreshell
    make machine

    Make.py -p ^coreshell -a machine

Supporting info: Section 6.26, compute temp/cs, pair_style born/coul/long/cs, >pair_style buck/coul/long/cs, pair_style lj/cut/coul/long/cs, examples/coreshell

##### DIPOLE package

Contents: An atom style and several pair styles to support point dipole models with short-range or long-range interactions.

To install via make or Make.py:

    make yes-dipole
    make machine

    Make.py -p dipole -a machine

To un-install via make or Make.py:

    make no-dipole
    make machine

    Make.py -p ^dipole -a machine

Supporting info: atom_style dipole, pair_style lj/cut/dipole/cut, pair_style lj/cut/dipole/long, pair_style lj/long/dipole/long, examples/dipole

##### GPU package

Contents: Dozens of pair styles and a version of the PPPM long-range Coulombic solver for NVIDIA GPUs. All of them have a "gpu" in their style name. Section 5.3.1 gives details of what hardware and Cuda software is required on your system, and how to build and use this package. See the KOKKOS package, which also has GPU-enabled styles.

Building LAMMPS with the GPU package requires first building the GPU library itself, which is a set of C and Cuda files in lib/gpu. Details of how to do this are in lib/gpu/README. As illustrated below, perform a "make" using one of the Makefile.machine files in lib/gpu which should create a lib/reax/libgpu.a file. Makefile.linux.* and Makefile.xk7 are examples for different platforms. There are 3 important settings in the Makefile.machine you use:

- CUDA_HOME = where NVIDIA Cuda software is installed on your system
- CUDA_ARCH = appropriate to your GPU hardware
- CUDA_PREC = precision (double, mixed, single) you desire

See example Makefile.machine files in lib/gpu for the syntax of these settings. See lib/gpu/Makefile.linux.double for ARCH settings for various NVIDIA GPUs. The "make" also creates a lib/gpu/Makefile.lammps file. This file has settings that enable LAMMPS to link with Cuda libraries. If the settings in Makefile.lammps for your machine are not correct, the LAMMPS link will fail. Note that the Make.py script has a "-gpu" option to allow the GPU library (with several of its options) and LAMMPS to be built in one step, with Type "python src/Make.py -h -gpu" to see the details.

To install via make or Make.py:

    cd ~/lammps/lib/gpu
    make -f Makefile.linux.mixed     # for example
    cd ~/lammps/src
    make yes-gpu
    make machine

    Make.py -p gpu -gpu mode=mixed arch=35 -a machine

To un-install via make or Make.py:

    make no-gpu
    make machine

    Make.py -p ^gpu -a machine

Supporting info: src/GPU/README, lib/gpu/README, Section 5.3, Section 5.3.1, Pair Styles section of Section 3.5 for any pair style listed with a (g), kspace_style, package gpu, examples/accelerate, bench/FERMI, bench/KEPLER

##### GRANULAR package

Contents: Fixes and pair styles that support models of finite-size granular particles, which interact with each other and boundaries via frictional and dissipative potentials.

To install via make or Make.py:

    make yes-granular
    make machine

    Make.py -p granular -a machine

To un-install via make or Make.py:

    make no-granular
    make machine

    Make.py -p ^granular -a machine

Supporting info: Section 6.6, fix pour, fix wall/gran, pair_style gran/hooke, pair_style gran/hertz/history, examples/pour, bench/in.chute

##### KIM package

Contents: A pair style that interfaces to the Knowledge Base for Interatomic Models (KIM) repository of interatomic potentials, so that KIM potentials can be used in a LAMMPS simulation.

To build LAMMPS with the KIM package you must have previously installed the KIM API (library) on your system. The lib/kim/README file explains how to download and install KIM. Building with the KIM package also uses the lib/kim/Makefile.lammps file in the compile/link process. You should not need to edit this file.

To install via make or Make.py:

    make yes-kim
    make machine

    Make.py -p kim -a machine

To un-install via make or Make.py:

    make no-kim
    make machine

    Make.py -p ^kim -a machine

Supporting info: src/KIM/README, lib/kim/README, pair_style kim, examples/kim

##### KOKKOS package

Contents: Dozens of atom, pair, bond, angle, dihedral, improper styles which run with the Kokkos library to provide optimization for multicore CPUs (via OpenMP), NVIDIA GPUs, or the Intel Xeon Phi (in native mode). All of them have a "kk" in their style name. Section 5.3.3 gives details of what hardware and software is required on your system, and how to build and use this package. See the GPU, OPT, USER-INTEL, USER-OMP packages, which also provide optimizations for the same range of hardware.

Building with the KOKKOS package requires choosing which of 3 hardware options you are optimizing for: CPU acceleration via OpenMP, GPU acceleration, or Intel Xeon Phi. (You can build multiple times to create LAMMPS executables for different hardware.) It also requires a C++11 compatible compiler. For GPUs, the NVIDIA "nvcc" compiler is used, and an appopriate KOKKOS_ARCH setting should be made in your Makefile.machine for your GPU hardware and NVIDIA software.

The simplest way to do this is to use Makefile.kokkos_cuda or Makefile.kokkos_omp or Makefile.kokkos_phi in src/MAKE/OPTIONS, via "make kokkos_cuda" or "make kokkos_omp" or "make kokkos_phi". (Check the KOKKOS_ARCH setting in Makefile.kokkos_cuda), Or, as illustrated below, you can use the Make.py script with its "-kokkos" option to choose which hardware to build for. Type "python src/Make.py -h -kokkos" to see the details. If these methods do not work on your system, you will need to read the Section 5.3.3 doc page for details of what Makefile.machine settings are needed.

To install via make or Make.py for each of 3 hardware options:

    make yes-kokkos
    make kokkos_omp    # for CPUs with OpenMP
    make kokkos_cuda   # for GPUs, check the KOKKOS_ARCH setting in Makefile.kokkos_cuda
    make kokkos_phi    # for Xeon Phis

Make.py -p kokkos -kokkos omp -a machine # for CPUs with OpenMP Make.py -p kokkos -kokkos cuda arch=35 -a machine # for GPUs of style arch Make.py -p kokkos -kokkos phi -a machine # for Xeon Phis

To un-install via make or Make.py:

    make no-kokkos
    make machine

    Make.py -p ^kokkos -a machine

Supporting info: src/KOKKOS/README, lib/kokkos/README, Section 5.3, Section 5.3.3, Pair Styles section of Section 3.5 for any pair style listed with a (k), package kokkos, examples/accelerate, bench/FERMI, bench/KEPLER

##### KSPACE package

Contents: A variety of long-range Coulombic solvers, and pair styles which compute the corresponding short-range portion of the pairwise Coulombic interactions. These include Ewald, particle-particle particle-mesh (PPPM), and multilevel summation method (MSM) solvers.

Building with the KSPACE package requires a 1d FFT library be present on your system for use by the PPPM solvers. This can be the KISS FFT library provided with LAMMPS, or 3rd party libraries like FFTW or a vendor-supplied FFT library. See step 6 of Section 2.2.2 of the manual for details of how to select different FFT options in your machine Makefile. The Make.py tool has an "-fft" option which can insert these settings into your machine Makefile automatically. Type "python src/Make.py -h -fft" to see the details.

To install via make or Make.py:

    make yes-kspace
    make machine

    Make.py -p kspace -a machine

To un-install via make or Make.py:

    make no-kspace
    make machine

    Make.py -p ^kspace -a machine

Supporting info: kspace_style, doc/PDF/kspace.pdf, Section 6.7, Section 6.8, Section 6.9, pair_style coul, other pair style command doc pages which have "long" or "msm" in their style name, examples/peptide, bench/in.rhodo

##### MANYBODY package

Contents: A variety of many-body and bond-order potentials. These include (AI)REBO, EAM, EIM, BOP, Stillinger-Weber, and Tersoff potentials. Do a directory listing, "ls src/MANYBODY", to see the full list.

To install via make or Make.py:

    make yes-manybody
    make machine

    Make.py -p manybody -a machine

To un-install via make or Make.py:

    make no-manybody
    make machine

    Make.py -p ^manybody -a machine

Supporting info:

Examples: Pair Styles section of Section 3.5, examples/comb, examples/eim, examples/nb3d, examples/vashishta

##### MC package

Contents: Several fixes and a pair style that have Monte Carlo (MC) or MC-like attributes. These include fixes for creating, breaking, and swapping bonds, and for performing atomic swaps and grand-canonical MC in conjuction with dynamics.

To install via make or Make.py:

    make yes-mc
    make machine

    Make.py -p mc -a machine

To un-install via make or Make.py:

    make no-mc
    make machine

    Make.py -p ^mc -a machine

Supporting info: fix atom/swap, fix bond/break, fix bond/create, fix bond/swap, fix gcmc, pair_style dsmc

##### MEAM package

Contents: A pair style for the modified embedded atom (MEAM) potential.

Building LAMMPS with the MEAM package requires first building the MEAM library itself, which is a set of Fortran 95 files in lib/meam. Details of how to do this are in lib/meam/README. As illustrated below, perform a "make" using one of the Makefile.machine files in lib/meam which should create a lib/meam/libmeam.a file. Makefile.gfortran and Makefile.ifort are examples for the GNU Fortran and Intel Fortran compilers. The "make" also copies a lib/meam/Makefile.lammps.machine file to lib/meam/Makefile.lammps. This file has settings that enable the C++ compiler used to build LAMMPS to link with a Fortran library (typically the 2 compilers to be consistent e.g. both Intel compilers, or both GNU compilers). If the settings in Makefile.lammps for your compilers and machine are not correct, the LAMMPS link will fail. Note that the Make.py script has a "-meam" option to allow the MEAM library and LAMMPS to be built in one step. Type "python src/Make.py -h -meam" to see the details.

NOTE: The MEAM potential can run dramatically faster if built with the Intel Fortran compiler, rather than the GNU Fortran compiler.

To install via make or Make.py:

    cd ~/lammps/lib/meam
    make -f Makefile.gfortran    # for example
    cd ~/lammps/src
    make yes-meam
    make machine

    Make.py -p meam -meam make=gfortran -a machine

To un-install via make or Make.py:

    make no-meam
    make machine

    Make.py -p ^meam -a machine

Supporting info: lib/meam/README, pair_style meam, examples/meam

##### MISC package

Contents: A variety of computes, fixes, and pair styles that are not commonly used, but don't align with other packages. Do a directory listing, "ls src/MISC", to see the list of commands.

To install via make or Make.py:

    make yes-misc
    make machine

    Make.py -p misc -a machine

To un-install via make or Make.py:

    make no-misc
    make machine

    Make.py -p ^misc -a machine

Supporting info: compute ti, fix evaporate, fix tmm, fix viscosity, examples/misc

##### MOLECULE package

Contents: A large number of atom, pair, bond, angle, dihedral, improper styles that are used to model molecular systems with fixed covalent bonds. The pair styles include terms for the Dreiding (hydrogen-bonding) and CHARMM force fields, and TIP4P water model.

To install via make or Make.py:

    make yes-molecule
    make machine

    Make.py -p molecule -a machine

To un-install via make or Make.py:

    make no-molecule
    make machine

    Make.py -p ^molecule -a machine

Supporting info:atom_style, bond_style, angle_style, dihedral_style, improper_style, pair_style hbond/dreiding/lj, pair_style lj/charmm/coul/charmm, Section 6.3, examples/micelle, examples/peptide, bench/in.chain, bench/in.rhodo

##### MPIIO package

Contents: Support for parallel output/input of dump and restart files via the MPIIO library, which is part of the standard message-passing interface (MPI) library. It adds dump styles with a "mpiio" in their style name. Restart files with an ".mpiio" suffix are also written and read in parallel.

To install via make or Make.py:

    make yes-mpiio
    make machine

    Make.py -p mpiio -a machine

To un-install via make or Make.py:

    make no-mpiio
    make machine

    Make.py -p ^mpiio -a machine

Supporting info: dump, restart, write_restart, read_restart

##### OPT package

Contents: A handful of pair styles with an "opt" in their style name which are optimized for improved CPU performance on single or multiple cores. These include EAM, LJ, CHARMM, and Morse potentials. Section 5.3.5 gives details of how to build and use this package. See the KOKKOS, USER-INTEL, and USER-OMP packages, which also have styles optimized for CPU performance.

Some C++ compilers, like the Intel compiler, require the compile flag "-restrict" to build LAMMPS with the OPT package. It should be added to the CCFLAGS line of your Makefile.machine. Or use Makefile.opt in src/MAKE/OPTIONS, via "make opt". For compilers that use the flag, the Make.py command adds it automatically to the Makefile.auto file it creates and uses.

To install via make or Make.py:

    make yes-opt
    make machine

    Make.py -p opt -a machine

To un-install via make or Make.py:

    make no-opt
    make machine

    Make.py -p ^opt -a machine

Supporting info: Section 5.3, Section 5.3.5, Pair Styles section of Section 3.5 for any pair style listed with an (t), examples/accelerate, bench/KEPLER

##### PERI package

Contents: Support for the Peridynamics method, a particle-based meshless continuum model. The package includes an atom style, several computes which calculate diagnostics, and several Peridynamic pair styles which implement different materials models.

To install via make or Make.py:

    make yes-peri
    make machine

    Make.py -p peri -a machine

To un-install via make or Make.py:

    make no-peri
    make machine

    Make.py -p ^peri -a machine

Supporting info: doc/PDF/PDLammps_overview.pdf, doc/PDF/PDLammps_EPS.pdf, doc/PDF/PDLammps_VES.pdf, atom_style peri, compute damage/atom, pair_style peri/pmb, examples/peri

##### POEMS package

Contents: A fix that wraps the Parallelizable Open source Efficient Multibody Software (POEMS) librar, which is able to simulate the dynamics of articulated body systems. These are systems with multiple rigid bodies (collections of atoms or particles) whose motion is coupled by connections at hinge points.

Building LAMMPS with the POEMS package requires first building the POEMS library itself, which is a set of C++ files in lib/poems. Details of how to do this are in lib/poems/README. As illustrated below, perform a "make" using one of the Makefile.machine files in lib/poems which should create a lib/meam/libpoems.a file. Makefile.g++ and Makefile.icc are examples for the GNU and Intel C++ compilers. The "make" also creates a lib/poems/Makefile.lammps file which you should not need to change. Note the Make.py script has a "-poems" option to allow the POEMS library and LAMMPS to be built in one step. Type "python src/Make.py -h -poems" to see the details.

To install via make or Make.py:

    cd ~/lammps/lib/poems
    make -f Makefile.g++    # for example
    cd ~/lammps/src
    make yes-poems
    make machine

    Make.py -p poems -poems make=g++ -a machine

To un-install via make or Make.py:

    make no-meam
    make machine

    Make.py -p ^meam -a machine

Supporting info: src/POEMS/README, lib/poems/README, fix poems, examples/rigid

##### PYTHON package

Contents: A python command which allow you to execute Python code from a LAMMPS input script. The code can be in a separate file or embedded in the input script itself. See Section 11.2 for an overview of using Python from LAMMPS and for other ways to use LAMMPS and Python together.

Building with the PYTHON package assumes you have a Python shared library available on your system, which needs to be a Python 2 version, 2.6 or later. Python 3 is not yet supported. The build uses the contents of the lib/python/Makefile.lammps file to find all the Python files required in the build/link process. See the lib/python/README file if the settings in that file do not work on your system. Note that the Make.py script has a "-python" option to allow an alternate lib/python/Makefile.lammps file to be specified and LAMMPS to be built in one step. Type "python src/Make.py -h -python" to see the details.

To install via make or Make.py:

    make yes-python
    make machine

    Make.py -p python -a machine

To un-install via make or Make.py:

    make no-python
    make machine

    Make.py -p ^python -a machine

Supporting info: examples/python

##### QEQ package

Contents: Several fixes for performing charge equilibration (QEq) via severeal different algorithms. These can be used with pair styles that use QEq as part of their formulation.

To install via make or Make.py:

    make yes-qeq
    make machine

    Make.py -p qeq -a machine

To un-install via make or Make.py:

    make no-qeq
    make machine

    Make.py -p ^qeq -a machine

Supporting info: fix qeq/*, examples/qeq

##### REAX package

Contents: A pair style for the ReaxFF potential, a universal reactive force field, as well as a fix reax/bonds command for monitoring molecules as bonds are created and destroyed.

Building LAMMPS with the REAX package requires first building the REAX library itself, which is a set of Fortran 95 files in lib/reax. Details of how to do this are in lib/reax/README. As illustrated below, perform a "make" using one of the Makefile.machine files in lib/reax which should create a lib/reax/libreax.a file. Makefile.gfortran and Makefile.ifort are examples for the GNU Fortran and Intel Fortran compilers. The "make" also copies a lib/reax/Makefile.lammps.machine file to lib/reax/Makefile.lammps. This file has settings that enable the C++ compiler used to build LAMMPS to link with a Fortran library (typically the 2 compilers to be consistent e.g. both Intel compilers, or both GNU compilers). If the settings in Makefile.lammps for your compilers and machine are not correct, the LAMMPS link will fail. Note that the Make.py script has a "-reax" option to allow the REAX library and LAMMPS to be built in one step. Type "python src/Make.py -h -reax" to see the details.

To install via make or Make.py:

    cd ~/lammps/lib/reax
    make -f Makefile.gfortran    # for example
    cd ~/lammps/src
    make yes-reax
    make machine

    Make.py -p reax -reax make=gfortran -a machine

To un-install via make or Make.py:

    make no-reax
    make machine

    Make.py -p ^reax -a machine

Supporting info: lib/reax/README, pair_style reax, fix reax/bonds, examples/reax

##### REPLICA package

Contents: A collection of multi-replica methods that are used by invoking multiple instances (replicas) of LAMMPS simulations. Communication between individual replicas is performed in different ways by the different methods. See Section 6.5 for an overview of how to run multi-replica simulations in LAMMPS. Multi-replica methods included in the package are nudged elastic band (NEB), parallel replica dynamics (PRD), temperature accelerated dynamics (TAD), parallel tempering, and a verlet/split algorithm for performing long-range Coulombics on one set of processors, and the remainded of the force field calcalation on another set.

To install via make or Make.py:

    make yes-replica
    make machine

    Make.py -p replica -a machine

To un-install via make or Make.py:

    make no-replica
    make machine

    Make.py -p ^replica -a machine

Supporting info: Section 6.5, neb, prd, tad, temper, run_style verlet/split, examples/neb, examples/prd, examples/tad

##### RIGID package

Contents: A collection of computes and fixes which enforce rigid constraints on collections of atoms or particles. This includes SHAKE and RATTLE, as well as variants of rigid-body time integrators for a few large bodies or many small bodies.

To install via make or Make.py:

    make yes-rigid
    make machine

    Make.py -p rigid -a machine

To un-install via make or Make.py:

    make no-rigid
    make machine

    Make.py -p ^rigid -a machine

Supporting info: compute erotate/rigid, fix shake, fix rattle, fix rigid/*, examples/ASPHERE, examples/rigid

##### SHOCK package

Contents: A small number of fixes useful for running impact simulations where a shock-wave passes through a material.

To install via make or Make.py:

    make yes-shock
    make machine

    Make.py -p shock -a machine

To un-install via make or Make.py:

    make no-shock
    make machine

    Make.py -p ^shock -a machine

Supporting info: fix append/atoms, fix msst, fix nphug, fix wall/piston, examples/hugoniostat, examples/msst

##### SNAP package

Contents: A pair style for the spectral neighbor analysis potential (SNAP), which is an empirical potential which can be quantum accurate when fit to an archive of DFT data. Computes useful for analyzing properties of the potential are also included.

To install via make or Make.py:

    make yes-snap
    make machine

    Make.py -p snap -a machine

To un-install via make or Make.py:

    make no-snap
    make machine

    Make.py -p ^snap -a machine

Supporting info: pair snap, compute sna/atom, compute snad/atom, compute snav/atom, examples/snap

##### SRD package

Contents: Two fixes which implement the Stochastic Rotation Dynamics (SRD) method for coarse-graining of a solvent, typically around large colloidal-scale particles.

To install via make or Make.py:

    make yes-srd
    make machine

    Make.py -p srd -a machine

To un-install via make or Make.py:

    make no-srd
    make machine

    Make.py -p ^srd -a machine

Supporting info: fix srd, fix wall/srd, examples/srd, examples/ASPHERE

##### VORONOI package

Contents: A compute voronoi/atom command which computes the Voronoi tesselation of a collection of atoms or particles by wrapping the Voro++ lib

To build LAMMPS with the KIM package you must have previously installed the KIM API (library) on your system. The lib/kim/README file explains how to download and install KIM. Building with the KIM package also uses the lib/kim/Makefile.lammps file in the compile/link process. You should not need to edit this file.

To build LAMMPS with the VORONOI package you must have previously installed the Voro++ library on your system. The lib/voronoi/README file explains how to download and install Voro++. There is a lib/voronoi/install.py script which automates the process. Type "python install.py" to see instructions. The final step is to create soft links in the lib/voronoi directory for "includelink" and "liblink" which point to installed Voro++ directories. Building with the VORONOI package uses the contents of the lib/voronoi/Makefile.lammps file in the compile/link process. You should not need to edit this file. Note that the Make.py script has a "-voronoi" option to allow the Voro++ library to be downloaded and/or installed and LAMMPS to be built in one step. Type "python src/Make.py -h -voronoi" to see the details.

To install via make or Make.py:

    cd ~/lammps/lib/voronoi
    python install.py -g -b -l    # download Voro++, build in lib/voronoi, create links
    cd ~/lammps/src
    make yes-voronoi
    make machine

    Make.py -p voronoi -voronoi install="-g -b -l" -a machine

To un-install via make or Make.py:

    make no-voronoi
    make machine

    Make.py -p ^voronoi -a machine

Supporting info: src/VORONOI/README, lib/voronoi/README, compute voronoi/atom, examples/voronoi

#### 4.2 User packages

The current list of user-contributed packages is as follows:

Package | Description | Author(s) | Doc page | Example | Pic/movie | Library
USER-ATC | atom-to-continuum coupling | Jones & Templeton & Zimmerman (1) | fix atc | USER/atc | atc | lib/atc
USER-AWPMD | wave-packet MD | Ilya Valuev (JIHT) | pair_style awpmd/cut | USER/awpmd | - | lib/awpmd
USER-CG-CMM | coarse-graining model | Axel Kohlmeyer (Temple U) | pair_style lj/sdk | USER/cg-cmm | cg | -
USER-COLVARS | collective variables | Fiorin & Henin & Kohlmeyer (2) | fix colvars | USER/colvars | colvars | lib/colvars
USER-DIFFRACTION | virutal x-ray and electron diffraction | Shawn Coleman (ARL) | compute xrd | USER/diffraction | - | -
USER-DPD | reactive dissipative particle dynamics (DPD) | Larentzos & Mattox & Brennan (5) | src/USER-DPD/README | USER/dpd | - | -
USER-DRUDE | Drude oscillators | Dequidt & Devemy & Padua (3) | tutorial | USER/drude | - | -
USER-EFF | electron force field | Andres Jaramillo-Botero (Caltech) | pair_style eff/cut | USER/eff | eff | -
USER-FEP | free energy perturbation | Agilio Padua (U Blaise Pascal Clermont-Ferrand) | compute fep | USER/fep | - | -
USER-H5MD | dump output via HDF5 | Pierre de Buyl (KU Leuven) | dump h5md | - | - | lib/h5md
USER-INTEL | Vectorized CPU and Intel(R) coprocessor styles | W. Michael Brown (Intel) | Section 5.3.2 | examples/intel | - | -
USER-LB | Lattice Boltzmann fluid | Colin Denniston (U Western Ontario) | fix lb/fluid | USER/lb | - | -
USER-MGPT | fast MGPT multi-ion potentials | Tomas Oppelstrup & John Moriarty (LLNL) | pair_style mgpt | USER/mgpt | - | -
USER-MISC | single-file contributions | USER-MISC/README | USER-MISC/README | - | - | -
USER-MANIFOLD | motion on 2d surface | Stefan Paquay (Eindhoven U of Technology) | fix manifoldforce | USER/manifold | manifold | -
USER-MOLFILE | VMD molfile plug-ins | Axel Kohlmeyer (Temple U) | dump molfile | - | - | VMD-MOLFILE
USER-NC-DUMP | dump output via NetCDF | Lars Pastewka (Karlsruhe Institute of Technology | KIT) | dump nc | dump nc/mpiio | - | - | lib/netcdf
USER-OMP | OpenMP threaded styles | Axel Kohlmeyer (Temple U) | Section 5.3.4 | - | - | -
USER-PHONON | phonon dynamical matrix | Ling-Ti Kong (Shanghai Jiao Tong U) | fix phonon | USER/phonon | - | -
USER-QMMM | QM/MM coupling | Axel Kohlmeyer (Temple U) | fix qmmm | USER/qmmm | - | lib/qmmm
USER-QTB | quantum nuclear effects | Yuan Shen (Stanford) | fix qtb fix qbmsst | qtb | - | -
USER-QUIP | QUIP/libatoms interface | Albert Bartok-Partay (U Cambridge) | pair_style quip | USER/quip | - | lib/quip
USER-REAXC | C version of ReaxFF | Metin Aktulga (LBNL) | pair_style reaxc | reax | - | -
USER-SMD | smoothed Mach dynamics | Georg Ganzenmuller (EMI) | SMD User Guide | USER/smd | - | -
USER-SMTBQ | Second Moment Tight Binding - QEq potential | Salles & Maras & Politano & Tetot (4) | pair_style smtbq | USER/smtbq | - | -
USER-SPH | smoothed particle hydrodynamics | Georg Ganzenmuller (EMI) | SPH User Guide | USER/sph | sph | -
USER-TALLY | Pairwise tallied computes | Axel Kohlmeyer (Temple U) | compute XXX/tally | USER/tally | - | -
USER-VTK | VTK-style dumps | Berger and Queteschiner (6) | compute custom/vtk | - | - | lib/vtk

The "Authors" column lists a name(s) if a specific person is responible for creating and maintaining the package.

(1) The ATC package was created by Reese Jones, Jeremy Templeton, and Jon Zimmerman (Sandia).

(2) The COLVARS package was created by Axel Kohlmeyer (Temple U) using the colvars module library written by Giacomo Fiorin (Temple U) and Jerome Henin (LISM, Marseille, France).

(3) The DRUDE package was created by Alain Dequidt (U Blaise Pascal Clermont-Ferrand) and co-authors Julien Devemy (CNRS) and Agilio Padua (U Blaise Pascal).

(4) The SMTBQ package was created by Nicolas Salles, Emile Maras, Olivier Politano, and Robert Tetot (LAAS-CNRS, France).

(5) The USER-DPD package was created by James Larentzos (ARL), Timothy Mattox (Engility), and John Brennan (ARL).

(6) The USER-VTK package was created by Richard Berger (JKU) and Daniel Queteschiner (DCS Computing).

The "Doc page" column links to either a sub-section of the Section 6 of the manual, or an input script command implemented as part of the package, or to additional documentation provided within the package.

The "Example" column is a sub-directory in the examples directory of the distribution which has an input script that uses the package. E.g. "peptide" refers to the examples/peptide directory.

The "Library" column lists an external library which must be built first and which LAMMPS links to when it is built. If it is listed as lib/package, then the code for the library is under the lib directory of the LAMMPS distribution. See the lib/package/README file for info on how to build the library. If it is not listed as lib/package, then it is a third-party library not included in the LAMMPS distribution. See details on all of this below for individual packages.

##### USER-ATC package

Contents: ATC stands for atoms-to-continuum. This package implements a fix atc command to either couple MD with continuum finite element equations or perform on-the-fly post-processing of atomic information to continuum fields. See src/USER-ATC/README for more details.

To build LAMMPS with this package ...

To install via make or Make.py:

    make yes-user-atc
    make machine

    Make.py -p atc -a machine

To un-install via make or Make.py:

    make no-user-atc
    make machine

    Make.py -p ^atc -a machine

Supporting info:src/USER-ATC/README, fix atc, examples/USER/atc

Authors: Reese Jones (rjones at sandia.gov), Jeremy Templeton (jatempl at sandia.gov) and Jon Zimmerman (jzimmer at sandia.gov) at Sandia. Contact them directly if you have questions.

##### USER-AWPMD package

Contents: AWPMD stands for Antisymmetrized Wave Packet Molecular Dynamics. This package implements an atom, pair, and fix style which allows electrons to be treated as explicit particles in an MD calculation. See src/USER-AWPMD/README for more details.

To build LAMMPS with this package ...

Supporting info: src/USER-AWPMD/README, fix awpmd/cut, examples/USER/awpmd

Author: Ilya Valuev at the JIHT in Russia (valuev at physik.hu-berlin.de). Contact him directly if you have questions.

##### USER-CG-CMM package

Contents: CG-CMM stands for coarse-grained ??. This package implements several pair styles and an angle style using the coarse grained parametrization of Shinoda, DeVane, Klein, Mol Sim, 33, 27 (2007) (SDK), with extensions to simulate ionic liquids, electrolytes, lipids and charged amino acids. See src/USER-CG-CMM/README for more details.

Supporting info: src/USER-CG-CMM/README, pair lj/sdk, pair lj/sdk/coul/long, angle sdk, examples/USER/cg-cmm

Author: Axel Kohlmeyer at Temple U (akohlmey at gmail.com). Contact him directly if you have questions.

##### USER-COLVARS package

Contents: COLVARS stands for collective variables which can be used to implement Adaptive Biasing Force, Metadynamics, Steered MD, Umbrella Sampling and Restraints. This package implements a fix colvars command which wraps a COLVARS library which can perform those kinds of simulations. See src/USER-COLVARS/README for more details.

Supporting info: doc/PDF/colvars-refman-lammps.pdf, src/USER-COLVARS/README, lib/colvars/README, fix colvars, examples/USER/colvars

Authors: Axel Kohlmeyer at Temple U (akohlmey at gmail.com) wrote the fix. The COLVARS library itself is written and maintained by Giacomo Fiorin (ICMS, Temple University, Philadelphia, PA, USA) and Jerome Henin (LISM, CNRS, Marseille, France). Contact them directly if you have questions.

##### USER-DIFFRACTION package

Contents: This packages implements two computes and a fix for calculating x-ray and electron diffraction intensities based on kinematic diffraction theory. See src/USER-DIFFRACTION/README for more details.

Supporting info: compute saed, compute xrd, fix saed/vtk, examples/USER/diffraction

Author: Shawn P. Coleman (shawn.p.coleman8.ctr at mail.mil) while at the University of Arkansas. Contact him directly if you have questions.

##### USER-DPD package

Contents: DPD stands for dissipative particle dynamics, This package implements DPD for isothermal, isoenergetic, isobaric and isenthalpic conditions. It also has extensions for performing reactive DPD, where each particle has internal state for multiple species and a coupled set of chemical reaction ODEs are integrated each timestep. The DPD equations of motion are integrated efficiently through the Shardlow splitting algorithm. See src/USER-DPD/README for more details.

Supporting info: /src/USER-DPD/README, compute dpd compute dpd/atom fix eos/cv fix eos/table fix eos/table/rx fix shardlow fix rx pair table/rx pair dpd/fdt pair dpd/fdt/energy pair exp6/rx pair multi/lucy pair multi/lucy/rx, examples/USER/dpd

Authors: James Larentzos (ARL) (james.p.larentzos.civ at mail.mil), Timothy Mattox (Engility Corp) (Timothy.Mattox at engilitycorp.com) and John Brennan (ARL) (john.k.brennan.civ at mail.mil). Contact them directly if you have questions.

##### USER-DRUDE package

Contents: This package contains methods for simulating polarizable systems using thermalized Drude oscillators. It has computes, fixes, and pair styles for this purpose. See Section 6.27 for an overview of how to use the package. See src/USER-DRUDE/README for additional details. There are auxiliary tools for using this package in tools/drude.

Supporting info: Section 6.27, src/USER-DRUDE/README, fix drude, fix drude/transform/*, compute temp/drude, pair thole, pair lj/cut/thole/long, examples/USER/drude, tools/drude

Authors: Alain Dequidt at Universite Blaise Pascal Clermont-Ferrand (alain.dequidt at univ-bpclermont.fr); co-authors: Julien Devemy, Agilio Padua. Contact them directly if you have questions.

##### USER-EFF package

Contents: EFF stands for electron force field. This package contains atom, pair, fix and compute styles which implement the eFF as described in A. Jaramillo-Botero, J. Su, Q. An, and W.A. Goddard III, JCC, 2010. The eFF potential was first introduced by Su and Goddard, in 2007. See src/USER-EFF/README for more details. There are auxiliary tools for using this package in tools/eff; see its README file.

Supporting info:

Author: Andres Jaramillo-Botero at CalTech (ajaramil at wag.caltech.edu). Contact him directly if you have questions.

##### USER-FEP package

Contents: FEP stands for free energy perturbation. This package provides methods for performing FEP simulations by using a fix adapt/fep command with soft-core pair potentials, which have a "soft" in their style name. See src/USER-FEP/README for more details. There are auxiliary tools for using this package in tools/fep; see its README file.

Supporting info: src/USER-FEP/README, fix adapt/fep, compute fep, pair_style */soft, examples/USER/fep

Author: Agilio Padua at Universite Blaise Pascal Clermont-Ferrand (agilio.padua at univ-bpclermont.fr). Contact him directly if you have questions.

##### USER-H5MD package

Contents: H5MD stands for HDF5 for MD. HDF5 is a binary, portable, self-describing file format, used by many scientific simulations. H5MD is a format for molecular simulations, built on top of HDF5. This package implements a dump h5md command to output LAMMPS snapshots in this format. See src/USER-H5MD/README for more details.

Supporting info: src/USER-H5MD/README, lib/h5md/README, dump h5md

Author: Pierre de Buyl at KU Leuven (see http://pdebuyl.be) created this package as well as the H5MD format and library. Contact him directly if you have questions.

##### USER-INTEL package

Contents: Dozens of pair, bond, angle, dihedral, and improper styles that are optimized for Intel CPUs and the Intel Xeon Phi (in offload mode). All of them have an "intel" in their style name. Section 5.3.2 gives details of what hardware and compilers are required on your system, and how to build and use this package. Also see src/USER-INTEL/README for more details. See the KOKKOS, OPT, and USER-OMP packages, which also have CPU and Phi-enabled styles.

Supporting info: examples/accelerate, src/USER-INTEL/TEST

Section 5.3

Author: Mike Brown at Intel (michael.w.brown at intel.com). Contact him directly if you have questions.

For the USER-INTEL package, you have 2 choices when building. You can build with CPU or Phi support. The latter uses Xeon Phi chips in "offload" mode. Each of these modes requires additional settings in your Makefile.machine for CCFLAGS and LINKFLAGS.

For CPU mode (if using an Intel compiler):

- CCFLAGS: add -fopenmp, -DLAMMPS_MEMALIGN=64, -restrict, -xHost, -fno-alias, -ansi-alias, -override-limits
- LINKFLAGS: add -fopenmp

For Phi mode add the following in addition to the CPU mode flags:

- CCFLAGS: add -DLMP_INTEL_OFFLOAD and
- LINKFLAGS: add -offload

And also add this to CCFLAGS:

    -offload-option,mic,compiler,"-fp-model fast=2 -mGLOB_default_function_attrs=\"gather_scatter_loop_unroll=4\""

Examples:

##### USER-LB package

Supporting info:

This package contains a LAMMPS implementation of a background Lattice-Boltzmann fluid, which can be used to model MD particles influenced by hydrodynamic forces.

See this doc page and its related commands to get started:

fix lb/fluid

The people who created this package are Frances Mackay (fmackay at uwo.ca) and Colin (cdennist at uwo.ca) Denniston, University of Western Ontario. Contact them directly if you have questions.

Examples: examples/USER/lb

##### USER-MGPT package

Supporting info:

This package contains a fast implementation for LAMMPS of quantum-based MGPT multi-ion potentials. The MGPT or model GPT method derives from first-principles DFT-based generalized pseudopotential theory (GPT) through a series of systematic approximations valid for mid-period transition metals with nearly half-filled d bands. The MGPT method was originally developed by John Moriarty at Lawrence Livermore National Lab (LLNL).

In the general matrix representation of MGPT, which can also be applied to f-band actinide metals, the multi-ion potentials are evaluated on the fly during a simulation through d- or f-state matrix multiplication, and the forces that move the ions are determined analytically. The mgpt pair style in this package calculates forces and energies using an optimized matrix-MGPT algorithm due to Tomas Oppelstrup at LLNL.

See this doc page to get started:

pair_style mgpt

The persons who created the USER-MGPT package are Tomas Oppelstrup (oppelstrup2@llnl.gov) and John Moriarty (moriarty2@llnl.gov) Contact them directly if you have any questions.

Examples: examples/USER/mgpt

##### USER-MISC package

Supporting info:

The files in this package are a potpourri of (mostly) unrelated features contributed to LAMMPS by users. Each feature is a single pair of files (*.cpp and *.h).

More information about each feature can be found by reading its doc page in the LAMMPS doc directory. The doc page which lists all LAMMPS input script commands is as follows:

Section 3.5

User-contributed features are listed at the bottom of the fix, compute, pair, etc sections.

The list of features and author of each is given in the src/USER-MISC/README file.

You should contact the author directly if you have specific questions about the feature or its coding.

Examples: examples/USER/misc

##### USER-MANIFOLD package

Supporting info:

This package contains a dump molfile command which uses molfile plugins that are bundled with the VMD molecular visualization and analysis program, to enable LAMMPS to dump its information in formats compatible with various molecular simulation tools.

This package allows LAMMPS to perform MD simulations of particles constrained on a manifold (i.e., a 2D subspace of the 3D simulation box). It achieves this using the RATTLE constraint algorithm applied to single-particle constraint functions g(xi,yi,zi) = 0 and their derivative (i.e. the normal of the manifold) n = grad(g).

See this doc page to get started:

fix manifoldforce

The person who created this package is Stefan Paquay, at the Eindhoven University of Technology (TU/e), The Netherlands (s.paquay at tue.nl). Contact him directly if you have questions.

##### USER-MOLFILE package

Supporting info:

This package contains a dump molfile command which uses molfile plugins that are bundled with the VMD molecular visualization and analysis program, to enable LAMMPS to dump its information in formats compatible with various molecular simulation tools.

The package only provides the interface code, not the plugins. These can be obtained from a VMD installation which has to match the platform that you are using to compile LAMMPS for. By adding plugins to VMD, support for new file formats can be added to LAMMPS (or VMD or other programs that use them) without having to recompile the application itself.

See this doc page to get started:

dump molfile

The person who created this package is Axel Kohlmeyer at Temple U (akohlmey at gmail.com). Contact him directly if you have questions.

##### USER-NC-DUMP package

Contents: Dump styles for writing NetCDF format files. NetCDF is a binary, portable, self-describing file format on top of HDF5. The file format contents follow the AMBER NetCDF trajectory conventions (http://ambermd.org/netcdf/nctraj.xhtml), but include extensions to this convention. This package implements a dump nc command and a dump nc/mpiio command to output LAMMPS snapshots in this format. See src/USER-NC-DUMP/README for more details.

- NetCDF files can be directly visualized with the following tools: Ovito (http://www.ovito.org/). Ovito supports the AMBER convention and all of the above extensions.
- VMD (http://www.ks.uiuc.edu/Research/vmd/)
- AtomEye (http://www.libatoms.org/). The libAtoms version of AtomEye contains a NetCDF reader that is not present in the standard distribution of AtomEye

The person who created these files is Lars Pastewka at Karlsruhe Institute of Technology (lars.pastewka at kit.edu). Contact him directly if you have questions.

##### USER-OMP package

Supporting info:

This package provides OpenMP multi-threading support and other optimizations of various LAMMPS pair styles, dihedral styles, and fix styles.

See this section of the manual to get started:

Section 5.3

The person who created this package is Axel Kohlmeyer at Temple U (akohlmey at gmail.com). Contact him directly if you have questions.

For the USER-OMP package, your Makefile.machine needs additional settings for CCFLAGS and LINKFLAGS.

- CCFLAGS: add -fopenmp and -restrict
- LINKFLAGS: add -fopenmp

Examples: examples/accelerate, bench/KEPLER

##### USER-PHONON package

This package contains a fix phonon command that calculates dynamical matrices, which can then be used to compute phonon dispersion relations, directly from molecular dynamics simulations.

See this doc page to get started:

fix phonon

The person who created this package is Ling-Ti Kong (konglt at sjtu.edu.cn) at Shanghai Jiao Tong University. Contact him directly if you have questions.

Examples: examples/USER/phonon

##### USER-QMMM package

Supporting info:

This package provides a fix qmmm command which allows LAMMPS to be used in a QM/MM simulation, currently only in combination with pw.x code from the Quantum ESPRESSO package.

The current implementation only supports an ONIOM style mechanical coupling to the Quantum ESPRESSO plane wave DFT package. Electrostatic coupling is in preparation and the interface has been written in a manner that coupling to other QM codes should be possible without changes to LAMMPS itself.

See this doc page to get started:

fix qmmm

as well as the lib/qmmm/README file.

The person who created this package is Axel Kohlmeyer at Temple U (akohlmey at gmail.com). Contact him directly if you have questions.

##### USER-QTB package

Supporting info:

This package provides a self-consistent quantum treatment of the vibrational modes in a classical molecular dynamics simulation. By coupling the MD simulation to a colored thermostat, it introduces zero point energy into the system, alter the energy power spectrum and the heat capacity towards their quantum nature. This package could be of interest if one wants to model systems at temperatures lower than their classical limits or when temperatures ramp up across the classical limits in the simulation.

See these two doc pages to get started:

fix qtb provides quantum nulcear correction through a colored thermostat and can be used with other time integration schemes like fix nve or fix nph.

fix qbmsst enables quantum nuclear correction of a multi-scale shock technique simulation by coupling the quantum thermal bath with the shocked system.

The person who created this package is Yuan Shen (sy0302 at stanford.edu) at Stanford University. Contact him directly if you have questions.

Examples: examples/USER/qtb

##### USER-QUIP package

Supporting info:

Examples: examples/USER/quip

##### USER-REAXC package

Supporting info:

This package contains a implementation for LAMMPS of the ReaxFF force field. ReaxFF uses distance-dependent bond-order functions to represent the contributions of chemical bonding to the potential energy. It was originally developed by Adri van Duin and the Goddard group at CalTech.

The USER-REAXC version of ReaxFF (pair_style reax/c), implemented in C, should give identical or very similar results to pair_style reax, which is a ReaxFF implementation on top of a Fortran library, a version of which library was originally authored by Adri van Duin.

The reax/c version should be somewhat faster and more scalable, particularly with respect to the charge equilibration calculation. It should also be easier to build and use since there are no complicating issues with Fortran memory allocation or linking to a Fortran library.

For technical details about this implemention of ReaxFF, see this paper:

Parallel and Scalable Reactive Molecular Dynamics: Numerical Methods and Algorithmic Techniques, H. M. Aktulga, J. C. Fogarty, S. A. Pandit, A. Y. Grama, Parallel Computing, in press (2011).

See the doc page for the pair_style reax/c command for details of how to use it in LAMMPS.

The person who created this package is Hasan Metin Aktulga (hmaktulga at lbl.gov), while at Purdue University. Contact him directly, or Aidan Thompson at Sandia (athomps at sandia.gov), if you have questions.

Examples: examples/reax

##### USER-SMD package

Supporting info:

This package implements smoothed Mach dynamics (SMD) in LAMMPS. Currently, the package has the following features:

* Does liquids via traditional Smooth Particle Hydrodynamics (SPH)

* Also solves solids mechanics problems via a state of the art stabilized meshless method with hourglass control.

* Can specify hydrostatic interactions independently from material strength models, i.e. pressure and deviatoric stresses are separated.

* Many material models available (Johnson-Cook, plasticity with hardening, Mie-Grueneisen, Polynomial EOS). Easy to add new material models.

* Rigid boundary conditions (walls) can be loaded as surface geometries from *.STL files.

See the file doc/PDF/SMD_LAMMPS_userguide.pdf to get started.

There are example scripts for using this package in examples/USER/smd.

The person who created this package is Georg Ganzenmuller at the Fraunhofer-Institute for High-Speed Dynamics, Ernst Mach Institute in Germany (georg.ganzenmueller at emi.fhg.de). Contact him directly if you have questions.

Examples: examples/USER/smd

##### USER-SMTBQ package

Supporting info:

This package implements the Second Moment Tight Binding - QEq (SMTB-Q) potential for the description of ionocovalent bonds in oxides.

There are example scripts for using this package in examples/USER/smtbq.

See this doc page to get started:

pair_style smtbq

The persons who created the USER-SMTBQ package are Nicolas Salles, Emile Maras, Olivier Politano, Robert Tetot, who can be contacted at these email addreses: lammps@u-bourgogne.fr, nsalles@laas.fr. Contact them directly if you have any questions.

Examples: examples/USER/smtbq

##### USER-SPH package

Supporting info:

This package implements smoothed particle hydrodynamics (SPH) in LAMMPS. Currently, the package has the following features:

* Tait, ideal gas, Lennard-Jones equation of states, full support for complete (i.e. internal-energy dependent) equations of state

* Plain or Monaghans XSPH integration of the equations of motion

* Density continuity or density summation to propagate the density field

* Commands to set internal energy and density of particles from the input script

* Output commands to access internal energy and density for dumping and thermo output

See the file doc/PDF/SPH_LAMMPS_userguide.pdf to get started.

There are example scripts for using this package in examples/USER/sph.

The person who created this package is Georg Ganzenmuller at the Fraunhofer-Institute for High-Speed Dynamics, Ernst Mach Institute in Germany (georg.ganzenmueller at emi.fhg.de). Contact him directly if you have questions.

Examples: examples/USER/sph

##### USER-TALLY package

Supporting info:

Examples: examples/USER/tally

##### USER-VTK package