LAMMPS: Difference between revisions

<translate>

''Parent page: [[Biomolecular simulation]]''

'''LAMMPS''' is a classical molecular dynamics code. The name stands for '''L'''arge-scale '''A'''tomic / '''M'''olecular '''M'''assively '''P'''arallel '''S'''imulator. LAMMPS is distributed by [http://www.sandia.gov/  Sandia National Laboratories], a US Department of Energy laboratory.  

* Project web site: http://lammps.sandia.gov/

* Documentation: [http://lammps.sandia.gov/doc/Manual.html Online Manual].

* Mailing List: http://lammps.sandia.gov/mail.html

LAMMPS is parallelized with [[MPI]] and [[OpenMP]], and can run on [[Using GPUs with Slurm|GPU]]s.

All supported force fields are listed on the [https://lammps.sandia.gov/doc/Intro_features.html#ff package web site],

classified by functional form (e.g. pairwise potentials, many-body potentials, etc.)  

Here are some types of modelling and force fields suitable for each:

* Biomolecules: CHARMM, AMBER, OPLS, COMPASS (class 2), long-range Coulombics via PPPM, point dipoles, ...

* Polymers: all-atom, united-atom, coarse-grain (bead-spring FENE), bond-breaking, …

* Mesoscale: granular, DPD, Gay-Berne, colloidal, peri-dynamics, DSMC...

Combinations of potentials can be used for hybrid systems, e.g. water on metal, polymer/semiconductor interfaces, colloids in solution, ...

To see which versions of LAMMPS are installed on Compute Canada systems, run <code>module spider lammps</code>. See [[Using modules]] for more about <code>module</code> subcommands.

LAMMPS version numbers are based on their release dates, and have the format YYYYMMDD.

For each release installed, one or more modules are are available.  

For example, the release of 31 March 2017 has three modules:   

* Built with MPI: <code>lammps/20170331</code>  

* Built with USER-OMP support:  <code>lammps-omp/20170331</code>  

* Built with USER-INTEL support: <code>lammps-user-intel/20170331</code>

These versions are also available with GPU support.  

In order to use the GPU-enabled version, load the [[CUDA]] module before loading the LAMMPS module:

  $ module load lammps-omp/20170331

The name of the executable may differ from one version to another. All prebuilt versions on Compute Canada clusters have a symbolic link called <code>lmp</code>. It means that no matter which module you pick, you can execute LAMMPS by calling <code>lmp</code>.

If you wish to see the original name of the executable for a given module, list the files in the <code>${EBROOTLAMMPS}/bin</code> directory. For example:

  $ ls ${EBROOTLAMMPS}/bin/

  lmp lmp_icc_openmpi

In this example the executable is <code>lmp_icc_openmpi</code>, and <code>lmp</code> is the symbolic link to it.  

The reason there are different modules for the same release is the difference in the ''packages'' included. Recent versions of LAMMPS contain about 60 different packages that can be enabled or disabled when compiling the program. Not all packages can be enabled in a single executable. All [https://lammps.sandia.gov/doc/Packages.html packages] are documented on the official web page.

For each LAMMPS module we provide a file <code>list-packages.txt</code> listing the enabled ("Supported") and disabled ("Not Supported") packages. Once you have loaded a particular module, run <code>cat ${EBROOTLAMMPS}/list-packages.txt</code> to see the contents.

If your simulation does not work with one module, it may be related to the fact that the necessary package was not included.

The input file below can be used with either of the example job scripts.

<tabs>

<tab name="INPUT">

{{File

# 3d Lennard-Jones melt

units          lj

atom_style      atomic

lattice        fcc 0.8442

region          box block 0 15 0 15 0 15

mass            1 1.0

velocity        all create 1.44 87287 loop geom

pair_style      lj/cut 2.5

pair_coeff      1 1 1.0 1.0 2.5

neigh_modify    delay 5 every 1

fix            1 all nve

thermo          5

write_data    config.end_sim

# End of the Input file.

}}

</tab>

<tab name="Serial job">

{{File

#!/bin/bash

#SBATCH --ntasks=1

#SBATCH --mem-per-cpu=2500M      # memory; default unit is megabytes.

#SBATCH --time=0-00:30          # time (DD-HH:MM).

# Load the module:

module load nixpkgs/16.09  intel/2016.4  openmpi/2.1.1 lammps-omp/20170811

echo "Starting run at: `date`"

lmp_exec=lmp_icc_openmpi

lmp_input="lammps.in"

lmp_output="lammps_lj_output.txt"

${lmp_exec} < ${lmp_input} > ${lmp_output}

echo "Program finished with exit code $? at: `date`"

}}

</tab>

<tab name="MPI job">

{{File

#!/bin/bash

#SBATCH --ntasks=4              # number of MPI processes.

#SBATCH --mem-per-cpu=2500M      # memory; default unit is megabytes.

#SBATCH --time=0-00:30          # time (DD-HH:MM).

# Load the module:

module load nixpkgs/16.09  intel/2016.4  openmpi/2.1.1 lammps-omp/20170811

echo "Starting run at: `date`"

lmp_exec=lmp_icc_openmpi

lmp_input="lammps.in"

lmp_output="lammps_lj_output.txt"

srun ${lmp_exec} < ${lmp_input} > ${lmp_output}

echo "Program finished with exit code $? at: `date`"

}}

</tab>

</tabs>

Most of the CPU time for molecular dynamics simulations is spent in computing the pair interactions between particles. LAMMPS uses domain decomposition to split the work among the available processors by assigning a part of the simulation box to each processor. During the computation of the interactions between particles, communication between the processors is required. For a given number of particles, the more processors that are used, the more parts of the simulation box there are which must exchange data. Therefore, the communication time increases with increasing number of processors, eventually leading to low CPU efficiency.  

Before running extensive simulations for a given problem size or a size of the simulation box, you should run tests to see how the program's performance changes with the number of cores. Run short tests using different numbers of cores to find a suitable number of cores that will (approximately) maximize the efficiency of the simulation.

The following example shows the timing for a simulation of a system of 4000 particles using 12 MPI tasks. This is an example of a very low efficiency: by using 12 cores, the system of 4000 atoms was divided to 12 small boxes. The code spent 46.45% of the time computing pair interactions and 44.5% in communications between the processors. The large number of small boxes for a such small system is responsible for the large fraction of time spent in communication.   

{| class="wikitable" style="text-align: center; border-width: 2px;width: 100%;"

!colspan="6" style="text-align: left;"|Loop time of 15.4965 on 12 procs for 25000 steps with 4000 atoms.<br />

|}

In the next example, we compare the time spent in communication and computing the pair interactions for different system sizes:  

{| class="wikitable" style="text-align: center; border-width: 2px;width: 100%;"

!