ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'clean-master2' of github.com:julient31/lammps into pppm_spin

Browse Source 
Conflicts:
	src/SPIN/pair_spin_exchange.cpp
	src/atom.cpp
	src/pair.cpp
This commit is contained in:
julient31
2019-04-19 15:02:25 -06:00
parent 7a2d326103 898860328b
commit a696b26301
4475 changed files with 423708 additions and 327416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
doc/src/Build.txt Normal file
View File

@ -0,0 +1,49 @@
"Previous Section"_Install.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc - "Next Section"_Run_head.html :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Build LAMMPS :h2
LAMMPS can be built as an executable or library from source code via
either traditional makefiles (which may require manual editing)
for use with GNU make or gmake, or a build environment generated by CMake
(Unix Makefiles, Xcode, Visual Studio, KDevelop or more). As an
alternative you can download a package with pre-built executables
as described on the "Install"_Install.html doc page.
<!-- RST
.. toctree::
:maxdepth: 1
Build_cmake
Build_make
Build_link
Build_basics
Build_settings
Build_package
Build_extras
Build_windows
END_RST -->
<!-- HTML_ONLY -->
"Build LAMMPS with CMake"_Build_cmake.html
"Build LAMMPS with make"_Build_make.html
"Link LAMMPS as a library to another code"_Build_link.html
"Basic build options"_Build_basics.html
"Optional build settings"_Build_settings.html
"Include packages in build"_Build_package.html
"Packages with extra build options"_Build_extras.html
"Notes for building LAMMPS on Windows"_Build_windows.html :all(b)
If you have problems building LAMMPS, it is often due to software
issues on your local machine. If you can, find a local expert to
help. If you're still stuck, send an email to the "LAMMPS mail
list"_http://lammps.sandia.gov/mail.html.

331
doc/src/Build_basics.txt Normal file
View File

@ -0,0 +1,331 @@
"Higher level section"_Build.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Basic build options :h3
The following topics are covered on this page, for building both with
CMake and make:
"Serial vs parallel build"_#serial
"Choice of compiler and compile/link options"_#compile
"Build LAMMPS as an executable or a library"_#exe
"Build the LAMMPS documentation"_#doc
"Install LAMMPS after a build"_#install :ul
:line
Serial vs parallel build :h4,link(serial)
LAMMPS can be built to run in parallel using the ubiquitous "MPI
(message-passing
interface)"_https://en.wikipedia.org/wiki/Message_Passing_Interface
library. Or it can built to run on a single processor (serial)
without MPI. It can also be built with support for OpenMP threading
(see more discussion below).
[CMake variables]:
-D BUILD_MPI=value # yes or no, default is yes if CMake finds MPI, else no
-D BUILD_OMP=value # yes or no (default)
-D LAMMPS_MACHINE=name # name = mpi, serial, mybox, titan, laptop, etc
# no default value :pre
The executable created by CMake (after running make) is lmp_name. If
the LAMMPS_MACHINE variable is not specified, the executable is just
lmp. Using BUILD_MPI=no will produce a serial executable.
[Traditional make]:
cd lammps/src
make mpi # parallel build, produces lmp_mpi using Makefile.mpi
make serial # serial build, produces lmp_serial using Makefile/serial
make mybox :pre # uses Makefile.mybox to produce lmp_mybox :pre
Serial build (see src/MAKE/Makefile.serial):
MPI_INC = -I../STUBS
MPI_PATH = -L../STUBS
MPI_LIB = -lmpi_stubs :pre
For a parallel build, if MPI is installed on your system in the usual
place (e.g. under /usr/local), you do not need to specify the 3
variables MPI_INC, MPI_PATH, MPI_LIB. The MPI wrapper on the compiler
(e.g. mpicxx, mpiCC) knows where to find the needed include and
library files. Failing this, these 3 variables can be used to specify
where the mpi.h file (MPI_INC), and the MPI library files (MPI_PATH)
are found, and the name of the library files (MPI_LIB).
For a serial build, you need to specify the 3 variables, as shown
above.
For a serial LAMMPS build, use the dummy MPI library provided in
src/STUBS. You also need to build the STUBS library for your platform
before making LAMMPS itself. A "make serial" build does this for.
Otherwise, type "make mpi-stubs" from the src directory, or "make"
from the src/STUBS dir. If the build fails, you will need to edit the
STUBS/Makefile for your platform.
The file STUBS/mpi.c provides a CPU timer function called MPI_Wtime()
that calls gettimeofday() . If your system doesn't support
gettimeofday() , you'll need to insert code to call another timer.
Note that the ANSI-standard function clock() rolls over after an hour
or so, and is therefore insufficient for timing long LAMMPS
simulations.
[CMake and make info]:
If you are installing MPI yourself, we recommend MPICH2 from Argonne
National Laboratory or OpenMPI. MPICH can be downloaded from the
"Argonne MPI site"_http://www.mcs.anl.gov/research/projects/mpich2/.
OpenMPI can be downloaded from the "OpenMPI
site"_http://www.open-mpi.org. Other MPI packages should also work.
If you are running on a large parallel machine, your system admins or
the vendor should have already installed a version of MPI, which is
likely to be faster than a self-installed MPICH or OpenMPI, so find
out how to build and link with it.
The majority of OpenMP (threading) support in LAMMPS is provided by
the USER-OMP package; see the "Speed omp"_Speed_omp.html doc page for
details. The USER-INTEL package also provides OpenMP support (it is
compatible with USER-OMP) and adds vectorization support when compiled
with the Intel compilers on top of that. Also, the KOKKOS package can
be compiled for using OpenMP threading.
However, there are a few commands in LAMMPS that have native OpenMP
support. These are commands in the MPIIO, SNAP, USER-DIFFRACTION, and
USER-DPD packages. In addition some packages support OpenMP threading
indirectly through the libraries they interface to: e.g. LATTE and
USER-COLVARS. See the "Packages details"_Packages_details.html doc
page for more info on these packages and the doc pages for their
respective commands for OpenMP threading info.
For CMake, if you use BUILD_OMP=yes, you can use these packages and
turn on their native OpenMP support and turn on their native OpenMP
support at run time, by setting the OMP_NUM_THREADS environment
variable before you launch LAMMPS.
For building via conventional make, the CCFLAGS and LINKFLAGS
variables in Makefile.machine need to include the compiler flag that
enables OpenMP. For GNU compilers it is -fopenmp. For (recent) Intel
compilers it is -qopenmp. If you are using a different compiler,
please refer to its documentation.
[OpenMP Compiler compatibility info]: :link(default-none-issues)
Some compilers do not fully support the 'default(none)' directive
and others (e.g. GCC version 9 and beyond) may implement OpenMP 4.0
semantics, which are incompatible with the OpenMP 3.1 directives used
in LAMMPS (for maximal compatibility with compiler versions in use).
In those case, all 'default(none)' directives (which aid in detecting
incorrect and unwanted sharing) can be replaced with 'default(shared)'
while dropping all 'shared()' directives. The script
'src/USER-OMP/hack_openmp_for_pgi_gcc9.sh' can be used to automate
this conversion.
:line
Choice of compiler and compile/link options :h4,link(compile)
The choice of compiler and compiler flags can be important for
performance. Vendor compilers can produce faster code than
open-source compilers like GNU. On boxes with Intel CPUs, we suggest
trying the "Intel C++ compiler"_intel.
:link(intel,https://software.intel.com/en-us/intel-compilers)
On parallel clusters or supercomputers which use "modules" for their
compile/link environments, you can often access different compilers by
simply loading the appropriate module before building LAMMPS.
[CMake variables]:
-D CMAKE_CXX_COMPILER=name # name of C++ compiler
-D CMAKE_C_COMPILER=name # name of C compiler
-D CMAKE_Fortran_COMPILER=name # name of Fortran compiler :pre
-D CMAKE_CXX_FLAGS=string # flags to use with C++ compiler
-D CMAKE_C_FLAGS=string # flags to use with C compiler
-D CMAKE_Fortran_FLAGS=string # flags to use with Fortran compiler :pre
By default CMake will use a compiler it finds and it will add
optimization flags appropriate to that compiler and any "accelerator
packages"_Speed_packages.html you have included in the build.
You can tell CMake to look for a specific compiler with these variable
settings. Likewise you can specify the FLAGS variables if you want to
experiment with alternate optimization flags. You should specify all
3 compilers, so that the small number of LAMMPS source files written
in C or Fortran are built with a compiler consistent with the one used
for all the C++ files:
Building with GNU Compilers:
cmake ../cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_Fortran_COMPILER=gfortran
Building with Intel Compilers:
cmake ../cmake -DCMAKE_C_COMPILER=icc -DCMAKE_CXX_COMPILER=icpc -DCMAKE_Fortran_COMPILER=ifort
Building with LLVM/Clang Compilers:
cmake ../cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_Fortran_COMPILER=flang :pre
NOTE: When the cmake command completes, it prints info to the screen
as to which compilers it is using, and what flags will be used in the
compilation. Note that if the top-level compiler is mpicxx, it is
simply a wrapper on a real compiler. The underlying compiler info is
what will be listed in the CMake output. You should check to insure
you are using the compiler and optimization flags are the ones you
want.
[Makefile.machine settings]:
Parallel build (see src/MAKE/Makefile.mpi):
CC = mpicxx
CCFLAGS = -g -O3
LINK = mpicxx
LINKFLAGS = -g -O :pre
Serial build (see src/MAKE/Makefile.serial):
CC = g++
CCFLAGS = -g -O3
LINK = g++
LINKFLAGS = -g -O :pre
The "compiler/linker settings" section of a Makefile.machine lists
compiler and linker settings for your C++ compiler, including
optimization flags. You should always use mpicxx or mpiCC for
a parallel build, since these compiler wrappers will include
a variety of settings appropriate for your MPI installation.
NOTE: If you build LAMMPS with any "accelerator
packages"_Speed_packages.html included, they have specific
optimization flags that are either required or recommended for optimal
performance. You need to include these in the CCFLAGS and LINKFLAGS
settings above. For details, see the individual package doc pages
listed on the "Speed packages"_Speed_packages.html doc page. Or
examine these files in the src/MAKE/OPTIONS directory. They
correspond to each of the 5 accelerator packages and their hardware
variants:
Makefile.opt # OPT package
Makefile.omp # USER-OMP package
Makefile.intel_cpu # USER-INTEL package for CPUs
Makefile.intel_coprocessor # USER-INTEL package for KNLs
Makefile.gpu # GPU package
Makefile.kokkos_cuda_mpi # KOKKOS package for GPUs
Makefile.kokkos_omp # KOKKOS package for CPUs (OpenMP)
Makefile.kokkos_phi # KOKKOS package for KNLs (OpenMP) :pre
:line
Build LAMMPS as an executable or a library :h4,link(exe)
LAMMPS can be built as either an executable or as a static or shared
library. The LAMMPS library can be called from another application or
a scripting language. See the "Howto couple"_Howto_couple.html doc
page for more info on coupling LAMMPS to other codes. See the
"Python"_Python_head.html doc page for more info on wrapping and
running LAMMPS from Python via its library interface.
[CMake variables]:
-D BUILD_EXE=value # yes (default) or no
-D BUILD_LIB=value # yes or no (default)
-D BUILD_SHARED_LIBS=value # yes or no (default) :pre
Setting BUILD_EXE=no will not produce an executable. Setting
BUILD_LIB=yes will produce a static library named liblammps.a.
Setting both BUILD_LIB=yes and BUILD_SHARED_LIBS=yes will produce a
shared library named liblammps.so.
[Traditional make]:
cd lammps/src
make machine # build LAMMPS executable lmp_machine
make mode=lib machine # build LAMMPS static lib liblammps_machine.a
make mode=shlib machine # build LAMMPS shared lib liblammps_machine.so :pre
The two library builds also create generic soft links, named
liblammps.a and liblammps.so, which point to the liblammps_machine
files.
[CMake and make info]:
Note that for a shared library to be usable by a calling program, all
the auxiliary libraries it depends on must also exist as shared
libraries. This will be the case for libraries included with LAMMPS,
such as the dummy MPI library in src/STUBS or any package libraries in
the lib/packages directory, since they are always built as shared
libraries using the -fPIC switch. However, if a library like MPI or
FFTW does not exist as a shared library, the shared library build will
generate an error. This means you will need to install a shared
library version of the auxiliary library. The build instructions for
the library should tell you how to do this.
As an example, here is how to build and install the "MPICH
library"_mpich, a popular open-source version of MPI, distributed by
Argonne National Lab, as a shared library in the default
/usr/local/lib location:
:link(mpich,http://www-unix.mcs.anl.gov/mpi)
./configure --enable-shared
make
make install :pre
You may need to use "sudo make install" in place of the last line if
you do not have write privileges for /usr/local/lib. The end result
should be the file /usr/local/lib/libmpich.so.
:line
Build the LAMMPS documentation :h4,link(doc)
[CMake variable]:
-D BUILD_DOC=value # yes or no (default) :pre
This will create the HTML doc pages within the CMake build directory.
The reason to do this is if you want to "install" LAMMPS on a system
after the CMake build via "make install", and include the doc pages in
the install.
[Traditional make]:
cd lammps/doc
make html # html doc pages
make pdf # single Manual.pdf file :pre
This will create a lammps/doc/html dir with the HTML doc pages so that
you can browse them locally on your system. Type "make" from the
lammps/doc dir to see other options.
NOTE: You can also download a tarball of the documentation for the
current LAMMPS version (HTML and PDF files), from the website
"download page"_http://lammps.sandia.gov/download.html.
:line
Install LAMMPS after a build :h4,link(install)
After building LAMMPS, you may wish to copy the LAMMPS executable of
library, along with other LAMMPS files (library header, doc files) to
a globally visible place on your system, for others to access. Note
that you may need super-user privileges (e.g. sudo) if the directory
you want to copy files to is protected.
[CMake variable]:
cmake -D CMAKE_INSTALL_PREFIX=path \[options ...\] ../cmake
make # perform make after CMake command
make install # perform the installation into prefix :pre
[Traditional make]:
There is no "install" option in the src/Makefile for LAMMPS. If you
wish to do this you will need to first build LAMMPS, then manually
copy the desired LAMMPS files to the appropriate system directories.

198
doc/src/Build_cmake.txt Normal file
View File

@ -0,0 +1,198 @@
"Higher level section"_Build.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Build LAMMPS with CMake :h3
This page is a short summary of how to use CMake to build LAMMPS.
Details on CMake variables that enable specific LAMMPS build options
are given on the pages linked to from the "Build"_Build.html doc page.
Richard Berger (Temple U) has also written a "more comprehensive
guide"_https://github.com/lammps/lammps/blob/master/cmake/README.md
for how to use CMake to build LAMMPS. If you are new to CMake it is a
good place to start.
:line
Building LAMMPS with CMake is a two-step process. First you use CMake
to create a build environment in a new directory. On Linux systems,
this will be based on makefiles for use with make. Then you use the
make command to build LAMMPS, which uses the created
Makefile(s). Example:
cd lammps # change to the LAMMPS distribution directory
mkdir build; cd build # create a new directory (folder) for build
cmake \[options ...\] ../cmake # configuration with (command-line) cmake
make # compilation :pre
The cmake command will detect available features, enable selected
packages and options, and will generate the build environment. The make
command will then compile and link LAMMPS, producing (by default) an
executable called "lmp" and a library called "liblammps.a" in the
"build" folder.
If your machine has multiple CPU cores (most do these days), using a
command like "make -jN" (with N being the number of available local
CPU cores) can be much faster. If you plan to do development on
LAMMPS or need to re-compile LAMMPS repeatedly, installation of the
ccache (= Compiler Cache) software may speed up repeated compilation
even more.
After compilation, you can optionally copy the LAMMPS executable and
library into your system folders (by default under $HOME/.local) with:
make install # optional, copy LAMMPS executable & library elsewhere :pre
:line
There are 3 variants of CMake: a command-line version (cmake), a text mode
UI version (ccmake), and a graphical GUI version (cmake-GUI). You can use
any of them interchangeably to configure and create the LAMMPS build
environment. On Linux all the versions produce a Makefile as their
output. See more details on each below.
You can specify a variety of options with any of the 3 versions, which
affect how the build is performed and what is included in the LAMMPS
executable. Links to pages explaining all the options are listed on
the "Build"_Build.html doc page.
You must perform the CMake build system generation and compilation in
a new directory you create. It can be anywhere on your local machine.
In these Build pages we assume that you are building in a directory
called "lammps/build". You can perform separate builds independently
with different options, so long as you perform each of them in a
separate directory you create. All the auxiliary files created by one
build process (executable, object files, log files, etc) are stored in
this directory or sub-directories within it that CMake creates.
NOTE: To perform a CMake build, no packages can be installed or a
build been previously attempted in the LAMMPS src directory by using
"make" commands to "perform a conventional LAMMPS
build"_Build_make.html. CMake detects if this is the case and
generates an error, telling you to type "make no-all purge" in the src
directory to un-install all packages. The purge removes all the *.h
files auto-generated by make.
You must have CMake version 2.8 or later on your system to build
LAMMPS. A handful of LAMMPS packages (KOKKOS, LATTE, MSCG) require a
later version. CMake will print a message telling you if a later
version is required. Installation instructions for CMake are below.
After the initial build, if you edit LAMMPS source files, or add your
own new files to the source directory, you can just re-type make from
your build directory and it will re-compile only the files that have
changed. If you want to change CMake options you can run cmake (or
ccmake or cmake-gui) again from the same build directory and alter
various options; see details below. Or you can remove the entire build
folder, recreate the directory and start over.
:line
[Command-line version of CMake]:
cmake \[options ...\] /path/to/lammps/cmake # build from any dir
cmake \[options ...\] ../cmake # build from lammps/build :pre
The cmake command takes one required argument, which is the LAMMPS
cmake directory which contains the CMakeLists.txt file.
The argument can be preceeded or followed by various CMake
command-line options. Several useful ones are:
-D CMAKE_INSTALL_PREFIX=path # where to install LAMMPS executable/lib if desired
-D CMAKE_BUILD_TYPE=type # type = Release or Debug
-G output # style of output CMake generates
-DVARIABLE=value # setting for a LAMMPS feature to enable
-D VARIABLE=value # ditto, but cannot come after CMakeLists.txt dir
-C path/to/preset/file # load some CMake settings before configuring :pre
All the LAMMPS-specific -D variables that a LAMMPS build supports are
described on the pages linked to from the "Build"_Build.html doc page.
All of these variable names are upper-case and their values are
lower-case, e.g. -D LAMMPS_SIZES=smallbig. For boolean values, any of
these forms can be used: yes/no, on/off, 1/0.
On Unix/Linux machines, CMake generates a Makefile by default to
perform the LAMMPS build. Alternate forms of build info can be
generated via the -G switch, e.g. Visual Studio on a Windows machine,
Xcode on MacOS, or KDevelop on Linux. Type "cmake --help" to see the
"Generator" styles of output your system supports.
NOTE: When CMake runs, it prints configuration info to the screen.
You should review this to verify all the features you requested were
enabled, including packages. You can also see what compilers and
compile options will be used for the build. Any errors in CMake
variable syntax will also be flagged, e.g. mis-typed variable names or
variable values.
CMake creates a CMakeCache.txt file when it runs. This stores all the
settings, so that when running CMake again you can use the current
folder '.' instead of the path to the LAMMPS cmake folder as the
required argument to the CMake command. Either way the existing
settings will be inherited unless the CMakeCache.txt file is removed.
If you later want to change a setting you can rerun cmake in the build
directory with different setting. Please note that some automatically
detected variables will not change their value when you rerun cmake.
In these cases it is usually better to first remove all the
files/directories in the build directory, or start with a fresh build
directory.
:line
[Curses version (terminal-style menu) of CMake]:
ccmake ../cmake :pre
You initiate the configuration and build environment generation steps
separately. For the first you have to type [c], for the second you
have to type [g]. You may need to type [c] multiple times, and may be
required to edit some of the entries of CMake configuration variables
in between. Please see the "ccmake
manual"_https://cmake.org/cmake/help/latest/manual/ccmake.1.html for
more information.
:line
[GUI version of CMake]:
cmake-gui ../cmake :pre
You initiate the configuration and build environment generation steps
separately. For the first you have to click on the [Configure] button,
for the second you have to click on the [Generate] button. You may
need to click on [Configure] multiple times, and may be required to
edit some of the entries of CMake configuration variables in between.
Please see the "cmake-gui
manual"_https://cmake.org/cmake/help/latest/manual/cmake-gui.1.html
for more information.
:line
[Installing CMake]
Check if your machine already has CMake installed:
which cmake # do you have it?
which cmake3 # version 3 may have this name
cmake --version # what specific version you have :pre
On clusters or supercomputers which use environment modules to manage
software packages, do this:
module list # is a cmake module already loaded?
module avail # is a cmake module available?
module load cmake3 # load cmake module with appropriate name :pre
Most Linux distributions offer pre-compiled cmake packages through
their package management system. If you do not have CMake or a new
enough version, you can download the latest version at
"https://cmake.org/download/"_https://cmake.org/download/.
Instructions on how to install it on various platforms can be found
"on this page"_https://cmake.org/install/.

1160
doc/src/Build_extras.txt Normal file
View File

File diff suppressed because it is too large Load Diff

85
doc/src/Build_link.txt Normal file
View File

@ -0,0 +1,85 @@
"Higher level section"_Build.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Link LAMMPS as a library to another code :h3
LAMMPS can be used as a library by another application, including
Python scripts. The files src/library.cpp and library.h define the
C-style API for using LAMMPS as a library. See the "Howto
library"_Howto_library.html doc page for a description of the
interface and how to extend it for your needs.
The "Build basics"_Build_basics.html doc page explains how to build
LAMMPS as either a shared or static library. This results in one of
these 2 files:
liblammps.so # shared library
liblammps.a # static library
:line
[Link with LAMMPS as a static library]:
The calling application can link to LAMMPS as a static library with a
link command like this:
g++ caller.o -L/home/sjplimp/lammps/src -llammps -o caller
The -L argument is the path to where the liblammps.a file is. The
-llammps argument is shorthand for the file liblammps.a.
:line
[Link with LAMMPS as a shared library]:
If you wish to link to liblammps.so, the operating system finds shared
libraries to load at run-time using the environment variable
LD_LIBRARY_PATH. To enable this you can do one of two things:
(1) Copy the liblammps.so file to a location the system can find it,
such as /usr/local/lib. I.e. a directory already listed in your
LD_LIBRARY_PATH variable. You can type
printenv LD_LIBRARY_PATH :pre
to see what directories are in that list.
(2) Add the LAMMPS src directory (or the directory you perform CMake
build in) to your LD_LIBRARY_PATH, so that the current version of the
shared library is always available to programs that use it.
For the csh or tcsh shells, you would add something like this to your
~/.cshrc file:
setenv LD_LIBRARY_PATH $\{LD_LIBRARY_PATH\}:/home/sjplimp/lammps/src :pre
:line
[Calling the LAMMPS library]:
Either flavor of library (static or shared) allows one or more LAMMPS
objects to be instantiated from the calling program.
When used from a C++ program, all of LAMMPS is wrapped in a LAMMPS_NS
namespace; you can safely use any of its classes and methods from
within the calling code, as needed.
When used from a C or Fortran program, the library has a simple
C-style interface, provided in src/library.cpp and src/library.h.
See the "Python library"_Python_library.html doc page for a
description of the Python interface to LAMMPS, which wraps the C-style
interface.
See the sample codes in examples/COUPLE/simple for examples of C++ and
C and Fortran codes that invoke LAMMPS through its library interface.
Other examples in the COUPLE directory use coupling ideas discussed on
the "Howto couple"_Howto_couple.html doc page.

85
doc/src/Build_make.txt Normal file
View File

@ -0,0 +1,85 @@
"Higher level section"_Build.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Build LAMMPS with make :h3
Building LAMMPS with traditional makefiles requires that you have a
Makefile."machine" file appropriate for your system in the src/MAKE,
src/MAKE/MACHINES, src/MAKE/OPTIONS, or src/MAKE/MINE directory (see
below). It can include various options for customizing your LAMMPS
build with a number of global compilation options and features.
To include LAMMPS packages (i.e. optional commands and styles) you
must install them first, as discussed on the "Build
package"_Build_package.html doc page. If the packages require
provided or external libraries, you must build those libraries before
building LAMMPS. Building "LAMMPS with CMake"_Build_cmake.html can
automate all of this for many types of machines, especially
workstations, desktops and laptops, so we suggest you try it first.
These commands perform a default LAMMPS build, producing the LAMMPS
executable lmp_serial or lmp_mpi in lammps/src:
cd lammps/src
make serial # build a serial LAMMPS executable
make mpi # build a parallel LAMMPS executable with MPI
make # see a variety of make options :pre
This initial compilation can take a long time, since LAMMPS is a large
project with many features. If your machine has multiple CPU cores
(most do these days), using a command like "make -jN mpi" (with N =
the number of available CPU cores) can be much faster. If you plan to
do development on LAMMPS or need to re-compile LAMMPS repeatedly, the
installation of the ccache (= Compiler Cache) software may speed up
compilation even more.
After the initial build, whenever you edit LAMMPS source files, or add
or remove new files to the source directory (e.g. by installing or
uninstalling packages), you must re-compile and relink the LAMMPS
executable with the same "make" command. This makefiles dependencies
should insure that only the subset of files that need to be are
re-compiled.
NOTE: When you build LAMMPS for the first time, a long list of *.d
files will be printed out rapidly. This is not an error; it is the
Makefile doing its normal creation of dependencies.
:line
The lammps/src/MAKE tree contains all the Makefile.machine files
included in the LAMMPS distribution. Typing "make machine" uses
Makefile.machine. Thus the "make serial" or "make mpi" lines above
use Makefile.serial and Makefile.mpi. Others are in these dirs:
OPTIONS # Makefiles which enable specific options
MACHINES # Makefiles for specific machines
MINE # customized Makefiles you create (you may need to create this folder) :pre
Typing "make" lists all the available Makefile.machine files. A file
with the same name can appear in multiple folders (not a good idea).
The order the dirs are searched is as follows: src/MAKE/MINE,
src/MAKE, src/MAKE/OPTIONS, src/MAKE/MACHINES. This gives preference
to a customized file you put in src/MAKE/MINE.
Makefiles you may wish to try include these (some require a package
first be installed). Many of these include specific compiler flags
for optimized performance. Please note, however, that some of these
customized machine Makefile are contributed by users. Since both
compilers, OS configurations, and LAMMPS itself keep changing, their
settings may become outdated:
make mac # build serial LAMMPS on a Mac
make mac_mpi # build parallel LAMMPS on a Mac
make intel_cpu # build with the USER-INTEL package optimized for CPUs
make knl # build with the USER-INTEL package optimized for KNLs
make opt # build with the OPT package optimized for CPUs
make omp # build with the USER-OMP package optimized for OpenMP
make kokkos_omp # build with the KOKKOS package for OpenMP
make kokkos_cuda_mpi # build with the KOKKOS package for GPUs
make kokkos_phi # build with the KOKKOS package for KNLs :pre

241
doc/src/Build_package.txt Normal file
View File

@ -0,0 +1,241 @@
"Higher level section"_Build.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Include packages in build :h3
In LAMMPS, a package is a group of files that enable a specific set of
features. For example, force fields for molecular systems or
rigid-body constraints are in packages. In the src directory, each
package is a sub-directory with the package name in capital letters.
An overview of packages is given on the "Packages"_Packages.html doc
page. Brief overviews of each package are on the "Packages
details"_Packages_details.html doc page.
When building LAMMPS, you can choose to include or exclude each
package. In general there is no need to include a package if you
never plan to use its features.
If you get a run-time error that a LAMMPS command or style is
"Unknown", it is often because the command is contained in a package,
and your build did not include that package. Running LAMMPS with the
"-h command-line switch"_Run_options.html will print all the included
packages and commands for that executable.
For the majority of packages, if you follow the single step below to
include it, you can then build LAMMPS exactly the same as you would
without any packages installed. A few packages may require additional
steps, as explained on the "Build extras"_Build_extras.html doc page.
These links take you to the extra instructions for those select
packages:
"COMPRESS"_Build_extras.html#compress,
"GPU"_Build_extras.html#gpu,
"KIM"_Build_extras.html#kim,
"KOKKOS"_Build_extras.html#kokkos,
"LATTE"_Build_extras.html#latte,
"MEAM"_Build_extras.html#meam,
"MESSAGE"_Build_extras.html#message,
"MSCG"_Build_extras.html#mscg,
"OPT"_Build_extras.html#opt,
"POEMS"_Build_extras.html#poems,
"PYTHON"_Build_extras.html#python,
"VORONOI"_Build_extras.html#voronoi,
"USER-ADIOS"_Build_extras.html#user-adios,
"USER-ATC"_Build_extras.html#user-atc,
"USER-AWPMD"_Build_extras.html#user-awpmd,
"USER-COLVARS"_Build_extras.html#user-colvars,
"USER-H5MD"_Build_extras.html#user-h5md,
"USER-INTEL"_Build_extras.html#user-intel,
"USER-MOLFILE"_Build_extras.html#user-molfile,
"USER-NETCDF"_Build_extras.html#user-netcdf,
"USER-PLUMED"_Build_extras.html#user-plumed,
"USER-OMP"_Build_extras.html#user-omp,
"USER-QMMM"_Build_extras.html#user-qmmm,
"USER-QUIP"_Build_extras.html#user-quip,
"USER-SCAFACOS"_Build_extras.html#user-scafacos,
"USER-SMD"_Build_extras.html#user-smd,
"USER-VTK"_Build_extras.html#user-vtk :tb(c=6,ea=c,a=l)
The mechanism for including packages is simple but different for CMake
versus make.
[CMake variables]:
-D PKG_NAME=value # yes or no (default) :pre
Examples:
-D PKG_MANYBODY=yes
-D PKG_USER-INTEL=yes :pre
All standard and user packages are included the same way. Note that
USER packages have a hyphen between USER and the rest of the package
name, not an underscore.
See the shortcut section below for how to install many packages at
once with CMake.
NOTE: If you toggle back and forth between building with CMake vs
make, no packages in the src directory can be installed when you
invoke cmake. CMake will give an error if that is not the case,
indicating how you can un-install all packages in the src dir.
[Traditional make]:
cd lammps/src
make ps # check which packages are currently installed
make yes-name # install a package with name
make no-name # un-install a package with name
make mpi # build LAMMPS with whatever packages are now installed :pre
Examples:
make no-rigid
make yes-user-intel :pre
All standard and user packages are included the same way.
See the shortcut section below for how to install many packages at
once with make.
NOTE: You must always re-build LAMMPS (via make) after installing or
un-installing a package, for the action to take effect.
NOTE: You cannot install or un-install packages and build LAMMPS in a
single make command with multiple targets, e.g. make yes-colloid mpi.
This is because the make procedure creates a list of source files that
will be out-of-date for the build if the package configuration changes
within the same command. You can include or exclude multiple packages
in a single make command, e.g. make yes-colloid no-manybody.
[CMake and make info]:
Any package can be included or excluded in a LAMMPS build, independent
of all other packages. However, some packages include files derived
from files in other packages. LAMMPS checks for this and does the
right thing. Individual files are only included if their dependencies
are already included. Likewise, if a package is excluded, other files
dependent on that package are also excluded.
When you download a LAMMPS tarball or download LAMMPS source files
from the Git or SVN repositories, no packages are pre-installed in the
src directory.
NOTE: Prior to Aug 2018, if you downloaded a tarball, 3 packages
(KSPACE, MANYBODY, MOLECULE) were pre-installed in the src directory.
That is no longer the case, so that CMake will build as-is without the
need to un-install those packages.
:line
[CMake shortcuts for installing many packages]:
Instead of specifying all the CMake options via the command-line,
CMake allows initializing the variable cache using script files. These
are regular CMake files which can manipulate and set variables, and
can also contain control flow constructs.
LAMMPS includes several of these files to define configuration
"presets", similar to the options that exist for the Make based
system. Using these files you can enable/disable portions of the
available packages in LAMMPS. If you need a custom preset you can take
one of them as a starting point and customize it to your needs.
cmake -C ../cmake/presets/all_on.cmake \[OPTIONS\] ../cmake |
enable all packages |
cmake -C ../cmake/presets/all_off.cmake \[OPTIONS\] ../cmake |
disable all packages |
cmake -C ../cmake/presets/minimal.cmake \[OPTIONS\] ../cmake |
enable just a few core packages |
cmake -C ../cmake/presets/most.cmake \[OPTIONS\] ../cmake |
enable most common packages |
cmake -C ../cmake/presets/nolib.cmake \[OPTIONS\] ../cmake |
disable packages that do require extra libraries or tools |
cmake -C ../cmake/presets/clang.cmake \[OPTIONS\] ../cmake |
change settings to use the Clang compilers by default |
cmake -C ../cmake/presets/mingw.cmake \[OPTIONS\] ../cmake |
enable all packages compatible with MinGW compilers :tb(c=2,s=|,a=l)
NOTE: Running cmake this way manipulates the variable cache in your
current build directory. You can combine multiple presets and options
in a single cmake run, or change settings incrementally by running
cmake with new flags.
[Example:]
# build LAMMPS with most commonly used packages, but then remove
# those requiring additional library or tools, but still enable
# GPU package and configure it for using CUDA. You can run.
mkdir build
cd build
cmake -C ../cmake/presets/most.cmake -C ../cmake/presets/nolib.cmake -D PKG_GPU=on -D GPU_API=cuda ../cmake :pre
# to add another package, say BODY to the previous configuration you can run:
cmake -D PKG_BODY=on . :pre
# to reset the package selection from above to the default of no packages
# but leaving all other settings untouched. You can run:
cmake -C ../cmake/presets/no_all.cmake . :pre
:line
[Make shortcuts for installing many packages]:
The following commands are useful for managing package source files
and their installation when building LAMMPS via traditional make.
Just type "make" in lammps/src to see a one-line summary.
These commands install/un-install sets of packages:
make yes-all | install all packages
make no-all | un-install all packages
make yes-standard or make yes-std | install standard packages
make no-standard or make no-std| un-install standard packages
make yes-user | install user packages
make no-user | un-install user packages
make yes-lib | install packages that require extra libraries
make no-lib | un-install packages that require extra libraries
make yes-ext | install packages that require external libraries
make no-ext | un-install packages that require external libraries :tb(s=|,a=l)
which install/un-install various sets of packages. Typing "make
package" will list all the these commands.
NOTE: Installing or un-installing a package works by simply copying
files back and forth between the main src directory and
sub-directories with the package name (e.g. src/KSPACE, src/USER-ATC),
so that the files are included or excluded when LAMMPS is built.
The following make commands help manage files that exist in both the
src directory and in package sub-directories. You do not normally
need to use these commands unless you are editing LAMMPS files or are
"installing a patch"_Install_patch.html downloaded from the LAMMPS web
site.
Type "make package-status" or "make ps" to show which packages are
currently installed. For those that are installed, it will list any
files that are different in the src directory and package
sub-directory.
Type "make package-installed" or "make pi" to show which packages are
currently installed, without listing the status of packages that are
not installed.
Type "make package-update" or "make pu" to overwrite src files with
files from the package sub-directories if the package is installed.
It should be used after a "patch has been applied"_Install_patch.html,
since patches only update the files in the package sub-directory, but
not the src files.
Type "make package-overwrite" to overwrite files in the package
sub-directories with src files.
Type "make package-diff" to list all differences between pairs of
files in both the src dir and a package dir.

344
doc/src/Build_settings.txt Normal file
View File

@ -0,0 +1,344 @@
"Higher level section"_Build.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Optional build settings :h3
LAMMPS can be built with several optional settings. Each sub-section
explain how to do this for building both with CMake and make.
"FFT library"_#fft for use with the "kspace_style pppm"_kspace_style.html command
"Size of LAMMPS data types"_#size
"Read or write compressed files"_#gzip
"Output of JPG and PNG files"_#graphics via the "dump image"_dump_image.html command
"Output of movie files"_#graphics via the "dump_movie"_dump_image.html command
"Memory allocation alignment"_#align
"Workaround for long long integers"_#longlong
"Error handling exceptions"_#exceptions when using LAMMPS as a library :all(b)
:line
FFT library :h4,link(fft)
When the KSPACE package is included in a LAMMPS build, the
"kspace_style pppm"_kspace_style.html command performs 3d FFTs which
require use of an FFT library to compute 1d FFTs. The KISS FFT
library is included with LAMMPS but other libraries can be faster.
LAMMPS can use them if they are available on your system.
[CMake variables]:
-D FFT=value # FFTW3 or MKL or KISS, default is FFTW3 if found, else KISS
-D FFT_SINGLE=value # yes or no (default), no = double precision
-D FFT_PACK=value # array (default) or pointer or memcpy :pre
NOTE: The values for the FFT variable must be in upper-case. This is
an exception to the rule that all CMake variables can be specified
with lower-case values.
Usually these settings are all that is needed. If CMake cannot find
the FFT library, you can set these variables:
-D FFTW3_INCLUDE_DIRS=path # path to FFTW3 include files
-D FFTW3_LIBRARIES=path # path to FFTW3 libraries
-D MKL_INCLUDE_DIRS=path # ditto for Intel MKL library
-D MKL_LIBRARIES=path :pre
[Makefile.machine settings]:
FFT_INC = -DFFT_FFTW3 # -DFFT_FFTW3, -DFFT_FFTW (same as -DFFT_FFTW3), -DFFT_MKL, or -DFFT_KISS
# default is KISS if not specified
FFT_INC = -DFFT_SINGLE # do not specify for double precision
FFT_INC = -DFFT_PACK_ARRAY # or -DFFT_PACK_POINTER or -DFFT_PACK_MEMCPY :pre
# default is FFT_PACK_ARRAY if not specified
FFT_INC = -I/usr/local/include
FFT_PATH = -L/usr/local/lib
FFT_LIB = -lfftw3 # FFTW3 double precision
FFT_LIB = -lfftw3 -lfftw3f # FFTW3 single precision
FFT_LIB = -lmkl_intel_lp64 -lmkl_sequential -lmkl_core # MKL with Intel compiler
FFT_LIB = -lmkl_gf_lp64 -lmkl_sequential -lmkl_core # MKL with GNU compier :pre
As with CMake, you do not need to set paths in FFT_INC or FFT_PATH, if
make can find the FFT header and library files. You must specify
FFT_LIB with the appropriate FFT libraries to include in the link.
[CMake and make info]:
The "KISS FFT library"_http://kissfft.sf.net is included in the LAMMPS
distribution. It is portable across all platforms. Depending on the
size of the FFTs and the number of processors used, the other
libraries listed here can be faster.
However, note that long-range Coulombics are only a portion of the
per-timestep CPU cost, FFTs are only a portion of long-range
Coulombics, and 1d FFTs are only a portion of the FFT cost (parallel
communication can be costly). A breakdown of these timings is printed
to the screen at the end of a run using the "kspace_style
pppm"_kspace_style.html command. The "Run output"_Run_output.html
doc page gives more details.
FFTW is a fast, portable FFT library that should also work on any
platform and can be faster than the KISS FFT library. You can
download it from "www.fftw.org"_http://www.fftw.org. LAMMPS requires
version 3.X; the legacy version 2.1.X is no longer supported.
Building FFTW for your box should be as simple as ./configure; make;
make install. The install command typically requires root privileges
(e.g. invoke it via sudo), unless you specify a local directory with
the "--prefix" option of configure. Type "./configure --help" to see
various options.
The Intel MKL math library is part of the Intel compiler suite. It
can be used with the Intel or GNU compiler (see FFT_LIB setting above).
Performing 3d FFTs in parallel can be time consuming due to data
access and required communication. This cost can be reduced by
performing single-precision FFTs instead of double precision. Single
precision means the real and imaginary parts of a complex datum are
4-byte floats. Double precision means they are 8-byte doubles. Note
that Fourier transform and related PPPM operations are somewhat less
sensitive to floating point truncation errors and thus the resulting
error is less than the difference in precision. Using the -DFFT_SINGLE
setting trades off a little accuracy for reduced memory use and
parallel communication costs for transposing 3d FFT data.
When using -DFFT_SINGLE with FFTW3 you may need to build the FFTW
library a second time with support for single-precision.
For FFTW3, do the following, which should produce the additional
library libfftw3f.a
make clean
./configure --enable-single; make; make install :pre
Performing 3d FFTs requires communication to transpose the 3d FFT
grid. The data packing/unpacking for this can be done in one of 3
modes (ARRAY, POINTER, MEMCPY) as set by the FFT_PACK syntax above.
Depending on the machine, the size of the FFT grid, the number of
processors used, one option may be slightly faster. The default is
ARRAY mode.
:line
Size of LAMMPS data types :h4,link(size)
LAMMPS has a few integer data types which can be defined as 4-byte or
8-byte integers. The default setting of "smallbig" is almost always
adequate.
[CMake variable]:
-D LAMMPS_SIZES=value # smallbig (default) or bigbig or smallsmall :pre
[Makefile.machine setting]:
LMP_INC = -DLAMMPS_SMALLBIG # or -DLAMMPS_BIGBIG or -DLAMMPS_SMALLSMALL :pre
# default is LAMMPS_SMALLBIG if not specified
[CMake and make info]:
The default "smallbig" setting allows for simulations with:
total atom count = 2^63 atoms (about 9e18)
total timesteps = 2^63 (about 9e18)
atom IDs = 2^31 (about 2 billion)
image flags = roll over at 512 :ul
The "bigbig" setting increases the latter two limits. It allows for:
total atom count = 2^63 atoms (about 9e18)
total timesteps = 2^63 (about 9e18)
atom IDs = 2^63 (about 9e18)
image flags = roll over at about 1 million (2^20) :ul
The "smallsmall" setting is only needed if your machine does not
support 8-byte integers. It allows for:
total atom count = 2^31 atoms (about 2 billion)
total timesteps = 2^31 (about 2 billion)
atom IDs = 2^31 (about 2 billion)
image flags = roll over at 512 (2^9) :ul
Atom IDs are not required for atomic systems which do not store bond
topology information, though IDs are enabled by default. The
"atom_modify id no"_atom_modify.html command will turn them off. Atom
IDs are required for molecular systems with bond topology (bonds,
angles, dihedrals, etc). Thus if you model a molecular system with
more than 2 billion atoms, you need the "bigbig" setting.
Image flags store 3 values per atom which count the number of times an
atom has moved through the periodic box in each dimension. See the
"dump"_dump.html doc page for a discussion. If an atom moves through
the periodic box more than this limit, the value will "roll over",
e.g. from 511 to -512, which can cause diagnostics like the
mean-squared displacement, as calculated by the "compute
msd"_compute_msd.html command, to be faulty.
Note that the USER-ATC package and the USER-INTEL package are currently
not compatible with the "bigbig" setting. Also, there are limitations
when using the library interface. Some functions with known issues
have been replaced by dummy calls printing a corresponding error rather
than crashing randomly or corrupting data.
Also note that the GPU package requires its lib/gpu library to be
compiled with the same size setting, or the link will fail. A CMake
build does this automatically. When building with make, the setting
in whichever lib/gpu/Makefile is used must be the same as above.
:line
Output of JPG, PNG, and movie files :h4,link(graphics)
The "dump image"_dump_image.html command has options to output JPEG or
PNG image files. Likewise the "dump movie"_dump_image.html command
outputs movie files in MPEG format. Using these options requires the
following settings:
[CMake variables]:
-D WITH_JPEG=value # yes or no
# default = yes if CMake finds JPEG files, else no
-D WITH_PNG=value # yes or no
# default = yes if CMake finds PNG and ZLIB files, else no
-D WITH_FFMPEG=value # yes or no
# default = yes if CMake can find ffmpeg, else no :pre
Usually these settings are all that is needed. If CMake cannot find
the graphics header, library, executable files, you can set these
variables:
-D JPEG_INCLUDE_DIR=path # path to jpeglib.h header file
-D JPEG_LIBRARIES=path # path to libjpeg.a (.so) file
-D PNG_INCLUDE_DIR=path # path to png.h header file
-D PNG_LIBRARIES=path # path to libpng.a (.so) file
-D ZLIB_INCLUDE_DIR=path # path to zlib.h header file
-D ZLIB_LIBRARIES=path # path to libz.a (.so) file
-D FFMPEG_EXECUTABLE=path # path to ffmpeg executable :pre
[Makefile.machine settings]:
LMP_INC = -DLAMMPS_JPEG
LMP_INC = -DLAMMPS_PNG
LMP_INC = -DLAMMPS_FFMPEG :pre
JPG_INC = -I/usr/local/include # path to jpeglib.h, png.h, zlib.h header files if make cannot find them
JPG_PATH = -L/usr/lib # paths to libjpeg.a, libpng.a, libz.a (.so) files if make cannot find them
JPG_LIB = -ljpeg -lpng -lz # library names :pre
As with CMake, you do not need to set JPG_INC or JPG_PATH, if make can
find the graphics header and library files. You must specify JPG_LIB
with a list of graphics libraries to include in the link. You must
insure ffmpeg is in a directory where LAMMPS can find it at runtime,
i.e. a dir in your PATH environment variable.
[CMake and make info]:
Using ffmpeg to output movie files requires that your machine
supports the "popen" function in the standard runtime library.
NOTE: On some clusters with high-speed networks, using the fork()
library calls (required by popen()) can interfere with the fast
communication library and lead to simulations using ffmpeg to hang or
crash.
:line
Read or write compressed files :h4,link(gzip)
If this option is enabled, large files can be read or written with
gzip compression by several LAMMPS commands, including
"read_data"_read_data.html, "rerun"_rerun.html, and "dump"_dump.html.
[CMake variables]:
-D WITH_GZIP=value # yes or no
# default is yes if CMake can find gzip, else no
-D GZIP_EXECUTABLE=path # path to gzip executable if CMake cannot find it :pre
[Makefile.machine setting]:
LMP_INC = -DLAMMPS_GZIP :pre
[CMake and make info]:
This option requires that your machine supports the "popen()" function
in the standard runtime library and that a gzip executable can be
found by LAMMPS during a run.
NOTE: On some clusters with high-speed networks, using the fork()
library calls (required by popen()) can interfere with the fast
communication library and lead to simulations using compressed output
or input to hang or crash. For selected operations, compressed file
I/O is also available using a compression library instead, which is
what the "COMPRESS package"_Packages_details.html#PKG-COMPRESS enables.
:line
Memory allocation alignment :h4,link(align)
This setting enables the use of the posix_memalign() call instead of
malloc() when LAMMPS allocates large chunks or memory. This can make
vector instructions on CPUs more efficient, if dynamically allocated
memory is aligned on larger-than-default byte boundaries.
On most current systems, the malloc() implementation returns
pointers that are aligned to 16-byte boundaries. Using SSE vector
instructions efficiently, however, requires memory blocks being
aligned on 64-byte boundaries.
[CMake variable]:
-D LAMMPS_MEMALIGN=value # 0, 8, 16, 32, 64 (default) :pre
Use a LAMMPS_MEMALIGN value of 0 to disable using posix_memalign()
and revert to using the malloc() C-library function instead. When
compiling LAMMPS for Windows systems, malloc() will always be used
and this setting ignored.
[Makefile.machine setting]:
LMP_INC = -DLAMMPS_MEMALIGN=value # 8, 16, 32, 64 :pre
Do not set -DLAMMPS_MEMALIGN, if you want to have memory allocated
with the malloc() function call instead. -DLAMMPS_MEMALIGN [cannot]
be used on Windows, as it does use different function calls for
allocating aligned memory, that are not compatible with how LAMMPS
manages its dynamical memory.
:line
Workaround for long long integers :h4,link(longlong)
If your system or MPI version does not recognize "long long" data
types, the following setting will be needed. It converts "long long"
to a "long" data type, which should be the desired 8-byte integer on
those systems:
[CMake variable]:
-D LAMMPS_LONGLONG_TO_LONG=value # yes or no (default) :pre
[Makefile.machine setting]:
LMP_INC = -DLAMMPS_LONGLONG_TO_LONG :pre
:line
Exception handling when using LAMMPS as a library :h4,link(exceptions)
This setting is useful when external codes drive LAMMPS as a library.
With this option enabled LAMMPS errors do not kill the caller.
Instead, the call stack is unwound and control returns to the caller,
e.g. to Python.
[CMake variable]:
-D LAMMPS_EXCEPTIONS=value # yes or no (default) :pre
[Makefile.machine setting]:
LMP_INC = -DLAMMPS_EXCEPTIONS :pre

102
doc/src/Build_windows.txt Normal file
View File

@ -0,0 +1,102 @@
"Higher level section"_Build.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Notes for building LAMMPS on Windows :h3
"General remarks"_#generic
"Running Linux on Windows"_#linux
"Using GNU GCC ported to Windows"_#gnu
"Using a cross-compiler"_#cross :ul
:line
General remarks :h4,link(generic)
LAMMPS is developed and tested primarily on Linux machines. The vast
majority of HPC clusters and supercomputers today runs on Linux as well.
Thus portability to other platforms is desired, but not always achieved.
The LAMMPS developers strongly rely on LAMMPS users giving feedback and
providing assistance in resolving portability issues. This particularly
true for compiling LAMMPS on Windows, since this platform has significant
differences with some low-level functionality.
Running Linux on Windows :h4,link(linux)
So before trying to build LAMMPS on Windows, please consider if using
the pre-compiled Windows binary packages are sufficient for your needs
(as an aside, those packages themselves are build on a Linux machine
using cross-compilers). If it is necessary for your to compile LAMMPS
on a Windows machine (e.g. because it is your main desktop), please also
consider using a virtual machine software and run a Linux virtual machine,
or - if have a recently updated Windows 10 installation - consider using
the Windows subsystem for Linux, which allows to run a bash shell from
Ubuntu and from there on, you can pretty much use that shell like you
are running on an Ubuntu Linux machine (e.g. installing software via
apt-get). For more details on that, please see "this tutorial"_Howto_bash.html
Using GNU GCC ported to Windows :h4,link(gnu)
One option for compiling LAMMPS on Windows natively, that has been known
to work in the past is to install a bash shell, unix shell utilities,
perl, GNU make, and a GNU compiler ported to Windows. The Cygwin package
provides a unix/linux interface to low-level Windows functions, so LAMMPS
can be compiled on Windows. The necessary (minor) modifications to LAMMPS
are included, but may not always up-to-date for recently added functionality
and the corresponding new code. A machine makefile for using cygwin for
the old build system is provided. Using CMake for this mode of compilation
is untested and not likely to work.
When compiling for Windows do [not] set the -DLAMMPS_MEMALIGN define
in the LMP_INC makefile variable and add -lwsock32 -lpsapi to the linker
flags in LIB makefile variable. Try adding -static-libgcc or -static or
both to the linker flags when your resulting LAMMPS Windows executable
complains about missing .dll files. The CMake configuration should set
this up automatically, but is untested.
In case of problems, you are recommended to contact somebody with
experience in using cygwin. If you do come across portability problems
requiring changes to the LAMMPS source code, or figure out corrections
yourself, please report them on the lammps-users mailing list, or file
them as an issue or pull request on the LAMMPS GitHub project.
Using a cross-compiler :h4,link(cross)
If you need to provide custom LAMMPS binaries for Windows, but do not
need to do the compilation on Windows, please consider using a Linux
to Windows cross-compiler. This is how currently the Windows binary
packages are created by the LAMMPS developers. Because of that, this is
probably the currently best tested and supported way to build LAMMPS
executables for Windows. There are makefiles provided for the
traditional build system, but CMake has also been successfully tested
using the mingw32-cmake and mingw64-cmake wrappers that are bundled
with the cross-compiler environment on Fedora machines. A CMake preset
selecting all packages compatible with this cross-compilation build
is provided. You likely need to disable the GPU package unless you
download and install the contents of the pre-compiled "OpenCL ICD loader
library"_https://download.lammps.org/thirdparty/opencl-win-devel.tar.gz
into your MinGW64 cross-compiler environment. The cross-compilation
currently will only produce non-MPI serial binaries.
Please keep in mind, though, that this only applies to compiling LAMMPS.
Whether the resulting binaries do work correctly is no tested by the
LAMMPS developers. We instead rely on the feedback of the users
of these pre-compiled LAMMPS packages for Windows. We will try to resolve
issues to the best of our abilities if we become aware of them. However
this is subject to time constraints and focus on HPC platforms.
Native Visual C++ support :h4,link(native)
Support for the Visual C++ compilers is currently not available. The
CMake build system is capable of creating suitable a Visual Studio
style build environment, but the LAMMPS code itself is not fully ported
to support Visual C++. Volunteers to take on this task are welcome.

12
doc/src/Commands.txt
View File

@ -1,4 +1,4 @@
"Previous Section"_Run.html - "LAMMPS WWW Site"_lws -
"Previous Section"_Run_head.html - "LAMMPS WWW Site"_lws -
"LAMMPS Documentation"_ld - "LAMMPS Commands"_lc - "Next
Section"_Packages.html :c
@ -16,6 +16,7 @@ commands in it are used to define a LAMMPS simulation.
<!-- RST
.. toctree::
:maxdepth: 1
Commands_input
Commands_parse
@ -23,6 +24,7 @@ commands in it are used to define a LAMMPS simulation.
Commands_category
.. toctree::
:maxdepth: 1
Commands_all
Commands_fix
@ -40,10 +42,10 @@ END_RST -->
"Input script structure"_Commands_structure.html
"Commands by category"_Commands_category.html :all(b)
"All commands"_Commands_all.html
"Fix commands"_Commands_fix.html
"Compute commands"_Commands_compute.html
"Pair commands"_Commands_pair.html
"General commands"_Commands_all.html
"Fix commands"_Commands_fix.html
"Compute commands"_Commands_compute.html
"Pair commands"_Commands_pair.html
"Bond, angle, dihedral, improper commands"_Commands_bond.html
"KSpace solvers"_Commands_kspace.html :all(b)

13
doc/src/Commands_all.txt
View File

@ -7,7 +7,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:line
"All commands"_Commands_all.html,
"General commands"_Commands_all.html,
"Fix styles"_Commands_fix.html,
"Compute styles"_Commands_compute.html,
"Pair styles"_Commands_pair.html,
@ -17,9 +17,9 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
"Improper styles"_Commands_bond.html#improper,
"KSpace styles"_Commands_kspace.html :tb(c=3,ea=c)
All commands :h3
General commands :h3
An alphabetic list of all LAMMPS commmands.
An alphabetic list of all general LAMMPS commands.
"angle_coeff"_angle_coeff.html,
"angle_style"_angle_style.html,
@ -48,32 +48,38 @@ An alphabetic list of all LAMMPS commmands.
"dimension"_dimension.html,
"displace_atoms"_displace_atoms.html,
"dump"_dump.html,
"dump adios"_dump_adios.html,
"dump image"_dump_image.html,
"dump_modify"_dump_modify.html,
"dump movie"_dump_image.html,
"dump netcdf"_dump_netcdf.html,
"dump netcdf/mpiio"_dump_netcdf.html,
"dump vtk"_dump_vtk.html,
"dynamical_matrix"_dynamical_matrix.html,
"echo"_echo.html,
"fix"_fix.html,
"fix_modify"_fix_modify.html,
"group"_group.html,
"group2ndx"_group2ndx.html,
"hyper"_hyper.html,
"if"_if.html,
"info"_info.html,
"improper_coeff"_improper_coeff.html,
"improper_style"_improper_style.html,
"include"_include.html,
"jump"_jump.html,
"kim_query"_kim_query.html,
"kspace_modify"_kspace_modify.html,
"kspace_style"_kspace_style.html,
"label"_label.html,
"lattice"_lattice.html,
"log"_log.html,
"mass"_mass.html,
"message"_message.html,
"minimize"_minimize.html,
"min_modify"_min_modify.html,
"min_style"_min_style.html,
"min_style spin"_min_spin.html,
"molecule"_molecule.html,
"ndx2group"_group2ndx.html,
"neb"_neb.html,
@ -103,6 +109,7 @@ An alphabetic list of all LAMMPS commmands.
"restart"_restart.html,
"run"_run.html,
"run_style"_run_style.html,
"server"_server.html,
"set"_set.html,
"shell"_shell.html,
"special_bonds"_special_bonds.html,

26
doc/src/Commands_bond.txt
View File

@ -5,11 +5,11 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:link(ld,Manual.html)
:link(lc,Commands_all.html)
"All commands"_Commands_all.html,
"General commands"_Commands_all.html,
"Fix styles"_Commands_fix.html,
"Compute styles"_Commands_compute.html,
"Pair styles"_Commands_pair.html,
"Bond styles"_Commands_bond.html,
"Bond styles"_Commands_bond.html#bond,
"Angle styles"_Commands_bond.html#angle,
"Dihedral styles"_Commands_bond.html#dihedral,
"Improper styles"_Commands_bond.html#improper,
@ -34,9 +34,10 @@ OPT.
"fene (iko)"_bond_fene.html,
"fene/expand (o)"_bond_fene_expand.html,
"gromos (o)"_bond_gromos.html,
"harmonic (ko)"_bond_harmonic.html,
"harmonic (iko)"_bond_harmonic.html,
"harmonic/shift (o)"_bond_harmonic_shift.html,
"harmonic/shift/cut (o)"_bond_harmonic_shift_cut.html,
"mm3"_bond_mm3.html,
"morse (o)"_bond_morse.html,
"nonlinear (o)"_bond_nonlinear.html,
"oxdna/fene"_bond_oxdna.html,
@ -57,20 +58,24 @@ OPT.
"zero"_angle_zero.html,
"hybrid"_angle_hybrid.html :tb(c=3,ea=c)
"charmm (ko)"_angle_charmm.html,
"charmm (iko)"_angle_charmm.html,
"class2 (ko)"_angle_class2.html,
"cosine (o)"_angle_cosine.html,
"class2/p6"_angle_class2.html,
"cosine (ko)"_angle_cosine.html,
"cosine/buck6d"_angle_cosine_buck6d.html,
"cosine/delta (o)"_angle_cosine_delta.html,
"cosine/periodic (o)"_angle_cosine_periodic.html,
"cosine/shift (o)"_angle_cosine_shift.html,
"cosine/shift/exp (o)"_angle_cosine_shift_exp.html,
"cosine/squared (o)"_angle_cosine_squared.html,
"cross"_angle_cross.html,
"dipole (o)"_angle_dipole.html,
"fourier (o)"_angle_fourier.html,
"fourier/simple (o)"_angle_fourier_simple.html,
"harmonic (iko)"_angle_harmonic.html,
"mm3"_angle_mm3.html,
"quartic (o)"_angle_quartic.html,
"sdk"_angle_sdk.html,
"sdk (o)"_angle_sdk.html,
"table (o)"_angle_table.html :tb(c=4,ea=c)
:line
@ -95,9 +100,9 @@ OPT.
"helix (o)"_dihedral_helix.html,
"multi/harmonic (o)"_dihedral_multi_harmonic.html,
"nharmonic (o)"_dihedral_nharmonic.html,
"opls (iko)"_dihedral_opls.htm;,
"opls (iko)"_dihedral_opls.html,
"quadratic (o)"_dihedral_quadratic.html,
"spherical (o)"_dihedral_spherical.html,
"spherical"_dihedral_spherical.html,
"table (o)"_dihedral_table.html,
"table/cut"_dihedral_table_cut.html :tb(c=4,ea=c)
@ -112,13 +117,16 @@ OPT.
"none"_improper_none.html,
"zero"_improper_zero.html,
"hybrid"_improper_hybrid.html :tb(c=3,ea=c)
"hybrid"_improper_hybrid.html :tb(c=3,ea=c)
"class2 (ko)"_improper_class2.html,
"cossq (o)"_improper_cossq.html,
"cvff (io)"_improper_cvff.html,
"distance"_improper_distance.html,
"distharm"_improper_distharm.html,
"fourier (o)"_improper_fourier.html,
"harmonic (iko)"_improper_harmonic.html,
"inversion/harmonic"_improper_inversion_harmonic.html,
"ring (o)"_improper_ring.html,
"sqdistharm"_improper_sqdistharm.html,
"umbrella (o)"_improper_umbrella.html :tb(c=4,ea=c)

7
doc/src/Commands_category.txt
View File

@ -10,10 +10,9 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
Commands by category :h3
This page lists most of the LAMMPS commands, grouped by category. The
"Commands all"_Commands_all.html doc page lists all commands
alphabetically. It also includes long lists of style options for
entries that appear in the following categories as a single command
(fix, compute, pair, etc).
"General commands"_Commands_all.html doc page lists all general commands
alphabetically. Style options for entries like fix, compute, pair etc.
have their own pages where they are listed alphabetically.
Initialization:

12
doc/src/Commands_compute.txt
View File

@ -7,7 +7,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:line
"All commands"_Commands_all.html,
"General commands"_Commands_all.html,
"Fix styles"_Commands_fix.html,
"Compute styles"_Commands_compute.html,
"Pair styles"_Commands_pair.html,
@ -25,6 +25,7 @@ additional letters in parenthesis: g = GPU, i = USER-INTEL, k =
KOKKOS, o = USER-OMP, t = OPT.
"ackland/atom"_compute_ackland_atom.html,
"adf"_compute_adf.html,
"aggregate/atom"_compute_cluster_atom.html,
"angle"_compute_angle.html,
"angle/local"_compute_angle_local.html,
@ -35,6 +36,7 @@ KOKKOS, o = USER-OMP, t = OPT.
"bond/local"_compute_bond_local.html,
"centro/atom"_compute_centro_atom.html,
"chunk/atom"_compute_chunk_atom.html,
"chunk/spread/atom"_compute_chunk_spread_atom.html,
"cluster/atom"_compute_cluster_atom.html,
"cna/atom"_compute_cna_atom.html,
"cnp/atom"_compute_cnp_atom.html,
@ -91,12 +93,15 @@ KOKKOS, o = USER-OMP, t = OPT.
"pe/tally"_compute_tally.html,
"plasticity/atom"_compute_plasticity_atom.html,
"pressure"_compute_pressure.html,
"pressure/cylinder"_compute_pressure_cylinder.html,
"pressure/uef"_compute_pressure_uef.html,
"property/atom"_compute_property_atom.html,
"property/chunk"_compute_property_chunk.html,
"property/local"_compute_property_local.html,
"ptm/atom"_compute_ptm_atom.html,
"rdf"_compute_rdf.html,
"reduce"_compute_reduce.html,
"reduce/chunk"_compute_reduce_chunk.html,
"reduce/region"_compute_reduce.html,
"rigid/local"_compute_rigid_local.html,
"saed"_compute_saed.html,
@ -115,7 +120,7 @@ KOKKOS, o = USER-OMP, t = OPT.
"smd/tlsph/strain"_compute_smd_tlsph_strain.html,
"smd/tlsph/strain/rate"_compute_smd_tlsph_strain_rate.html,
"smd/tlsph/stress"_compute_smd_tlsph_stress.html,
"smd/triangle/mesh/vertices"_compute_smd_triangle_mesh_vertices.html,
"smd/triangle/vertices"_compute_smd_triangle_vertices.html,
"smd/ulsph/num/neighs"_compute_smd_ulsph_num_neighs.html,
"smd/ulsph/strain"_compute_smd_ulsph_strain.html,
"smd/ulsph/strain/rate"_compute_smd_ulsph_strain_rate.html,
@ -126,6 +131,8 @@ KOKKOS, o = USER-OMP, t = OPT.
"snav/atom"_compute_sna_atom.html,
"spin"_compute_spin.html,
"stress/atom"_compute_stress_atom.html,
"stress/mop"_compute_stress_mop.html,
"stress/mop/profile"_compute_stress_mop.html,
"stress/tally"_compute_tally.html,
"tdpd/cc/atom"_compute_tdpd_cc_atom.html,
"temp (k)"_compute_temp.html,
@ -133,6 +140,7 @@ KOKKOS, o = USER-OMP, t = OPT.
"temp/body"_compute_temp_body.html,
"temp/chunk"_compute_temp_chunk.html,
"temp/com"_compute_temp_com.html,
"temp/cs"_compute_temp_cs.html,
"temp/deform"_compute_temp_deform.html,
"temp/deform/eff"_compute_temp_deform_eff.html,
"temp/drude"_compute_temp_drude.html,

47
doc/src/Commands_fix.txt
View File

@ -7,7 +7,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:line
"All commands"_Commands_all.html,
"General commands"_Commands_all.html,
"Fix styles"_Commands_fix.html,
"Compute styles"_Commands_compute.html,
"Pair styles"_Commands_pair.html,
@ -40,11 +40,13 @@ OPT.
"ave/time"_fix_ave_time.html,
"aveforce"_fix_aveforce.html,
"balance"_fix_balance.html,
"bocs"_fix_bocs.html,
"bond/break"_fix_bond_break.html,
"bond/create"_fix_bond_create.html,
"bond/react"_fix_bond_react.html,
"bond/swap"_fix_bond_swap.html,
"box/relax"_fix_box_relax.html,
"client/md"_fix_client_md.html,
"cmap"_fix_cmap.html,
"colvars"_fix_colvars.html,
"controller"_fix_controller.html,
@ -54,27 +56,31 @@ OPT.
"drag"_fix_drag.html,
"drude"_fix_drude.html,
"drude/transform/direct"_fix_drude_transform.html,
"drude/transform/reverse"_fix_drude_transform.html,
"drude/transform/inverse"_fix_drude_transform.html,
"dt/reset"_fix_dt_reset.html,
"edpd/source"_fix_dpd_source.html,
"efield"_fix_efield.html,
"ehex"_fix_ehex.html,
"electron/stopping"_fix_electron_stopping.html,
"enforce2d (k)"_fix_enforce2d.html,
"eos/cv"_fix_eos_cv.html,
"eos/table"_fix_eos_table.html,
"eos/table/rx (k)"_fix_eos_table_rx.html,
"evaporate"_fix_evaporate.html,
"external"_fix_external.html,
"ffl"_fix_ffl.html,
"filter/corotate"_fix_filter_corotate.html,
"flow/gauss"_fix_flow_gauss.html,
"freeze"_fix_freeze.html,
"freeze (k)"_fix_freeze.html,
"gcmc"_fix_gcmc.html,
"gld"_fix_gld.html,
"gle"_fix_gle.html,
"gravity (o)"_fix_gravity.html,
"gravity (ko)"_fix_gravity.html,
"grem"_fix_grem.html,
"halt"_fix_halt.html,
"heat"_fix_heat.html,
"hyper/global"_fix_hyper_global.html,
"hyper/local"_fix_hyper_local.html,
"imd"_fix_imd.html,
"indent"_fix_indent.html,
"ipi"_fix_ipi.html,
@ -91,6 +97,7 @@ OPT.
"lineforce"_fix_lineforce.html,
"manifoldforce"_fix_manifoldforce.html,
"meso"_fix_meso.html,
"meso/move"_fix_meso_move.html,
"meso/stationary"_fix_meso_stationary.html,
"momentum (k)"_fix_momentum.html,
"move"_fix_move.html,
@ -106,15 +113,16 @@ OPT.
"nph/eff"_fix_nh_eff.html,
"nph/sphere (o)"_fix_nph_sphere.html,
"nphug (o)"_fix_nphug.html,
"npt (kio)"_fix_nh.html,
"npt (iko)"_fix_nh.html,
"npt/asphere (o)"_fix_npt_asphere.html,
"npt/body"_fix_npt_body.html,
"npt/eff"_fix_nh_eff.html,
"npt/sphere (o)"_fix_npt_sphere.html,
"npt/uef"_fix_nh_uef.html,
"nve (kio)"_fix_nve.html,
"nve (iko)"_fix_nve.html,
"nve/asphere (i)"_fix_nve_asphere.html,
"nve/asphere/noforce"_fix_nve_asphere_noforce.html,
"nve/awpmd"_fix_nve_awpmd.html,
"nve/body"_fix_nve_body.html,
"nve/dot"_fix_nve_dot.html,
"nve/dotc/langevin"_fix_nve_dotc_langevin.html,
@ -123,7 +131,7 @@ OPT.
"nve/line"_fix_nve_line.html,
"nve/manifold/rattle"_fix_nve_manifold_rattle.html,
"nve/noforce"_fix_nve_noforce.html,
"nve/sphere (o)"_fix_nve_sphere.html,
"nve/sphere (ko)"_fix_nve_sphere.html,
"nve/spin"_fix_nve_spin.html,
"nve/tri"_fix_nve_tri.html,
"nvk"_fix_nvk.html,
@ -142,6 +150,7 @@ OPT.
"phonon"_fix_phonon.html,
"pimd"_fix_pimd.html,
"planeforce"_fix_planeforce.html,
"plumed"_fix_plumed.html,
"poems"_fix_poems.html,
"pour"_fix_pour.html,
"precession/spin"_fix_precession_spin.html,
@ -161,34 +170,34 @@ OPT.
"qmmm"_fix_qmmm.html,
"qtb"_fix_qtb.html,
"rattle"_fix_shake.html,
"reax/bonds"_fix_reax_bonds.html,
"reax/c/bonds (k)"_fix_reax_bonds.html,
"reax/c/bonds (k)"_fix_reaxc_bonds.html,
"reax/c/species (k)"_fix_reaxc_species.html,
"recenter"_fix_recenter.html,
"restrain"_fix_restrain.html,
"rhok"_fix_rhok.html,
"rigid (o)"_fix_rigid.html,
"rigid/meso"_fix_rigid_meso.html,
"rigid/nph (o)"_fix_rigid.html,
"rigid/nph/small"_fix_rigid.html,
"rigid/npt (o)"_fix_rigid.html,
"rigid/npt/small"_fix_rigid.html,
"rigid/nve (o)"_fix_rigid.html,
"rigid/nve/small"_fix_rigid.html,
"rigid/nvt (o)"_fix_rigid.html,
"rigid/nvt/small"_fix_rigid.html,
"rigid/small (o)"_fix_rigid.html,
"rigid/small/nph"_fix_rigid.html,
"rigid/small/npt"_fix_rigid.html,
"rigid/small/nve"_fix_rigid.html,
"rigid/small/nvt"_fix_rigid.html,
"rx (k)"_fix_rx.html,
"saed/vtk"_fix_saed_vtk.html,
"setforce (k)"_fix_setforce.html,
"shake"_fix_shake.html,
"shardlow (k)"_fix_shardlow.html,
"smd"_fix_smd.html,
"smd/adjust/dt"_fix_smd_adjust_dt.html,
"smd/integrate/tlsph"_fix_smd_integrate_tlsph.html,
"smd/integrate/ulsph"_fix_smd_integrate_ulsph.html,
"smd/move/triangulated/surface"_fix_smd_move_triangulated_surface.html,
"smd/adjust_dt"_fix_smd_adjust_dt.html,
"smd/integrate_tlsph"_fix_smd_integrate_tlsph.html,
"smd/integrate_ulsph"_fix_smd_integrate_ulsph.html,
"smd/move_tri_surf"_fix_smd_move_triangulated_surface.html,
"smd/setvel"_fix_smd_setvel.html,
"smd/wall/surface"_fix_smd_wall_surface.html,
"smd/wall_surface"_fix_smd_wall_surface.html,
"spring"_fix_spring.html,
"spring/chunk"_fix_spring_chunk.html,
"spring/rg"_fix_spring_rg.html,
@ -226,4 +235,4 @@ OPT.
"wall/reflect (k)"_fix_wall_reflect.html,
"wall/region"_fix_wall_region.html,
"wall/region/ees"_fix_wall_ees.html,
"wall/srd"_fix_wall_srd.html :tb(c=8,ea=c)
"wall/srd"_fix_wall_srd.html :tb(c=6,ea=c)

5
doc/src/Commands_kspace.txt
View File

@ -7,7 +7,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:line
"All commands"_Commands_all.html,
"General commands"_Commands_all.html,
"Fix styles"_Commands_fix.html,
"Compute styles"_Commands_compute.html,
"Pair styles"_Commands_pair.html,
@ -33,4 +33,5 @@ OPT.
"pppm/disp (i)"_kspace_style.html,
"pppm/disp/tip4p"_kspace_style.html,
"pppm/stagger"_kspace_style.html,
"pppm/tip4p (o)"_kspace_style.html :tb(c=4,ea=c)
"pppm/tip4p (o)"_kspace_style.html,
"scafacos"_kspace_style.html :tb(c=4,ea=c)

91
doc/src/Commands_pair.txt
View File

@ -7,7 +7,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:line
"All commands"_Commands_all.html,
"General commands"_Commands_all.html,
"Fix styles"_Commands_fix.html,
"Compute styles"_Commands_compute.html,
"Pair styles"_Commands_pair.html,
@ -26,13 +26,14 @@ OPT.
"none"_pair_none.html,
"zero"_pair_zero.html,
"hybrid"_pair_hybrid.html,
"hybrid (k)"_pair_hybrid.html,
"hybrid/overlay (k)"_pair_hybrid.html :tb(c=4,ea=c)
"adp (o)"_pair_adp.html,
"agni (o)"_pair_agni.html,
"airebo (oi)"_pair_airebo.html,
"airebo/morse (oi)"_pair_airebo.html,
"airebo (io)"_pair_airebo.html,
"airebo/morse (io)"_pair_airebo.html,
"atm"_pair_atm.html,
"awpmd/cut"_pair_awpmd.html,
"beck (go)"_pair_beck.html,
"body/nparticle"_pair_body_nparticle.html,
@ -41,37 +42,39 @@ OPT.
"bop"_pair_bop.html,
"born (go)"_pair_born.html,
"born/coul/dsf"_pair_born.html,
"born/coul/dsf/cs"_pair_born.html,
"born/coul/dsf/cs"_pair_cs.html,
"born/coul/long (go)"_pair_born.html,
"born/coul/long/cs"_pair_born.html,
"born/coul/long/cs (g)"_pair_cs.html,
"born/coul/msm (o)"_pair_born.html,
"born/coul/wolf (go)"_pair_born.html,
"born/coul/wolf/cs"_pair_born.html,
"born/coul/wolf/cs (g)"_pair_cs.html,
"brownian (o)"_pair_brownian.html,
"brownian/poly (o)"_pair_brownian.html,
"buck (giko)"_pair_buck.html,
"buck/coul/cut (giko)"_pair_buck.html,
"buck/coul/long (giko)"_pair_buck.html,
"buck/coul/long/cs"_pair_buck.html,
"buck/coul/long/cs"_pair_cs.html,
"buck/coul/msm (o)"_pair_buck.html,
"buck/long/coul/long (o)"_pair_buck_long.html,
"buck/mdf"_pair_mdf.html,
"buck6d/coul/gauss/dsf"_pair_buck6d_coul_gauss.html,
"buck6d/coul/gauss/long"_pair_buck6d_coul_gauss.html,
"colloid (go)"_pair_colloid.html,
"comb (o)"_pair_comb.html,
"comb3"_pair_comb.html,
"coul/cut (gko)"_pair_coul.html,
"coul/cut/soft (o)"_pair_lj_soft.html,
"coul/cut/soft (o)"_pair_fep_soft.html,
"coul/debye (gko)"_pair_coul.html,
"coul/diel (o)"_pair_coul_diel.html,
"coul/dsf (gko)"_pair_coul.html,
"coul/long (gko)"_pair_coul.html,
"coul/long/cs"_pair_coul.html,
"coul/long/soft (o)"_pair_lj_soft.html,
"coul/msm"_pair_coul.html,
"coul/long/cs (g)"_pair_cs.html,
"coul/long/soft (o)"_pair_fep_soft.html,
"coul/msm (o)"_pair_coul.html,
"coul/shield"_pair_coul_shield.html,
"coul/streitz"_pair_coul.html,
"coul/wolf (ko)"_pair_coul.html,
"coul/wolf/cs"_pair_coul.html,
"coul/wolf/cs"_pair_cs.html,
"dpd (gio)"_pair_dpd.html,
"dpd/fdt"_pair_dpd_fdt.html,
"dpd/fdt/energy (k)"_pair_dpd_fdt.html,
@ -80,6 +83,7 @@ OPT.
"eam (gikot)"_pair_eam.html,
"eam/alloy (gikot)"_pair_eam.html,
"eam/cd (o)"_pair_eam.html,
"eam/cd/old (o)"_pair_eam.html,
"eam/fs (gikot)"_pair_eam.html,
"edip (o)"_pair_edip.html,
"edip/multi"_pair_edip.html,
@ -89,11 +93,12 @@ OPT.
"exp6/rx (k)"_pair_exp6_rx.html,
"extep"_pair_extep.html,
"gauss (go)"_pair_gauss.html,
"gauss/cut"_pair_gauss.html,
"gauss/cut (o)"_pair_gauss.html,
"gayberne (gio)"_pair_gayberne.html,
"gran/hertz/history (o)"_pair_gran.html,
"gran/hooke (o)"_pair_gran.html,
"gran/hooke/history (o)"_pair_gran.html,
"gran/hooke/history (ko)"_pair_gran.html,
"granular"_pair_granular.html,
"gw"_pair_gw.html,
"gw/zbl"_pair_gw.html,
"hbond/dreiding/lj (o)"_pair_hbond_dreiding.html,
@ -103,50 +108,57 @@ OPT.
"kolmogorov/crespi/full"_pair_kolmogorov_crespi_full.html,
"kolmogorov/crespi/z"_pair_kolmogorov_crespi_z.html,
"lcbop"_pair_lcbop.html,
"lebedeva/z"_pair_lebedeva_z.html,
"lennard/mdf"_pair_mdf.html,
"line/lj"_pair_line_lj.html,
"list"_pair_list.html,
"lj/charmm/coul/charmm (iko)"_pair_charmm.html,
"lj/charmm/coul/charmm/implicit (ko)"_pair_charmm.html,
"lj/charmm/coul/long (giko)"_pair_charmm.html,
"lj/charmm/coul/long/soft (o)"_pair_charmm.html,
"lj/charmm/coul/msm"_pair_charmm.html,
"lj/charmm/coul/long (gikot)"_pair_charmm.html,
"lj/charmm/coul/long/soft (o)"_pair_fep_soft.html,
"lj/charmm/coul/msm (o)"_pair_charmm.html,
"lj/charmmfsw/coul/charmmfsh"_pair_charmm.html,
"lj/charmmfsw/coul/long"_pair_charmm.html,
"lj/class2 (gko)"_pair_class2.html,
"lj/class2/coul/cut (ko)"_pair_class2.html,
"lj/class2/coul/cut/soft"_pair_fep_soft.html,
"lj/class2/coul/long (gko)"_pair_class2.html,
"lj/class2/coul/long/soft"_pair_fep_soft.html,
"lj/class2/soft"_pair_fep_soft.html,
"lj/cubic (go)"_pair_lj_cubic.html,
"lj/cut (gikot)"_pair_lj.html,
"lj/cut/coul/cut (gko)"_pair_lj.html,
"lj/cut/coul/cut/soft (o)"_pair_lj_soft.html,
"lj/cut/coul/cut/soft (o)"_pair_fep_soft.html,
"lj/cut/coul/debye (gko)"_pair_lj.html,
"lj/cut/coul/dsf (gko)"_pair_lj.html,
"lj/cut/coul/long (gikot)"_pair_lj.html,
"lj/cut/coul/long/cs"_pair_lj.html,
"lj/cut/coul/long/soft (o)"_pair_lj_soft.html,
"lj/cut/coul/long/cs"_pair_cs.html,
"lj/cut/coul/long/soft (o)"_pair_fep_soft.html,
"lj/cut/coul/msm (go)"_pair_lj.html,
"lj/cut/coul/wolf (o)"_pair_lj.html,
"lj/cut/dipole/cut (go)"_pair_dipole.html,
"lj/cut/dipole/long"_pair_dipole.html,
"lj/cut/dipole/long (g)"_pair_dipole.html,
"lj/cut/dipole/sf (go)"_pair_dipole.html,
"lj/cut/soft (o)"_pair_lj_soft.html,
"lj/cut/soft (o)"_pair_fep_soft.html,
"lj/cut/thole/long (o)"_pair_thole.html,
"lj/cut/tip4p/cut (o)"_pair_lj.html,
"lj/cut/tip4p/long (ot)"_pair_lj.html,
"lj/cut/tip4p/long/soft (o)"_pair_lj_soft.html,
"lj/cut/tip4p/long/soft (o)"_pair_fep_soft.html,
"lj/expand (gko)"_pair_lj_expand.html,
"lj/expand/coul/long (g)"_pair_lj_expand.html,
"lj/gromacs (gko)"_pair_gromacs.html,
"lj/gromacs/coul/gromacs (ko)"_pair_gromacs.html,
"lj/long/coul/long (io)"_pair_lj_long.html,
"lj/long/coul/long (iot)"_pair_lj_long.html,
"lj/long/dipole/long"_pair_dipole.html,
"lj/long/tip4p/long"_pair_lj_long.html,
"lj/long/tip4p/long (o)"_pair_lj_long.html,
"lj/mdf"_pair_mdf.html,
"lj/sdk (gko)"_pair_sdk.html,
"lj/sdk/coul/long (go)"_pair_sdk.html,
"lj/sdk/coul/msm (o)"_pair_sdk.html,
"lj/sf/dipole/sf (go)"_pair_dipole.html,
"lj/smooth (o)"_pair_lj_smooth.html,
"lj/smooth/linear (o)"_pair_lj_smooth_linear.html,
"lj/switch3/coulgauss/long"_pair_lj_switch3_coulgauss.html,
"lj96/cut (go)"_pair_lj96.html,
"lubricate (o)"_pair_lubricate.html,
"lubricate/poly (o)"_pair_lubricate.html,
@ -154,19 +166,18 @@ OPT.
"lubricateU/poly"_pair_lubricateU.html,
"mdpd"_pair_meso.html,
"mdpd/rhosum"_pair_meso.html,
"meam"_pair_meam.html,
"meam/c"_pair_meam.html,
"meam/c"_pair_meamc.html,
"meam/spline (o)"_pair_meam_spline.html,
"meam/sw/spline"_pair_meam_sw_spline.html,
"mgpt"_pair_mgpt.html,
"mie/cut (o)"_pair_mie.html,
"mie/cut (g)"_pair_mie.html,
"momb"_pair_momb.html,
"morse (gkot)"_pair_morse.html,
"morse/smooth/linear"_pair_morse.html,
"morse/soft"_pair_morse.html,
"morse/smooth/linear (o)"_pair_morse.html,
"morse/soft"_pair_fep_soft.html,
"multi/lucy"_pair_multi_lucy.html,
"multi/lucy/rx (k)"_pair_multi_lucy_rx.html,
"nb3b/harmonic (o)"_pair_nb3b_harmonic.html,
"nb3b/harmonic"_pair_nb3b_harmonic.html,
"nm/cut (o)"_pair_nm.html,
"nm/cut/coul/cut (o)"_pair_nm.html,
"nm/cut/coul/long (o)"_pair_nm.html,
@ -178,7 +189,9 @@ OPT.
"oxdna2/coaxstk"_pair_oxdna2.html,
"oxdna2/dh"_pair_oxdna2.html,
"oxdna2/excv"_pair_oxdna2.html,
"oxdna2/hbond"_pair_oxdna2.html,
"oxdna2/stk"_pair_oxdna2.html,
"oxdna2/xstk"_pair_oxdna2.html,
"peri/eps"_pair_peri.html,
"peri/lps (o)"_pair_peri.html,
"peri/pmb (o)"_pair_peri.html,
@ -186,13 +199,13 @@ OPT.
"polymorphic"_pair_polymorphic.html,
"python"_pair_python.html,
"quip"_pair_quip.html,
"reax"_pair_reax.html,
"reax/c (ko)"_pair_reaxc.html,
"rebo (oi)"_pair_airebo.html,
"rebo (io)"_pair_airebo.html,
"resquared (go)"_pair_resquared.html,
"sdpd/taitwater/isothermal"_pair_sdpd_taitwater_isothermal.html,
"smd/hertz"_pair_smd_hertz.html,
"smd/tlsph"_pair_smd_tlsph.html,
"smd/triangulated/surface"_pair_smd_triangulated_surface.html,
"smd/tri_surface"_pair_smd_triangulated_surface.html,
"smd/ulsph"_pair_smd_ulsph.html,
"smtbq"_pair_smtbq.html,
"snap (k)"_pair_snap.html,
@ -221,11 +234,11 @@ OPT.
"thole"_pair_thole.html,
"tip4p/cut (o)"_pair_coul.html,
"tip4p/long (o)"_pair_coul.html,
"tip4p/long/soft (o)"_pair_lj_soft.html,
"tip4p/long/soft (o)"_pair_fep_soft.html,
"tri/lj"_pair_tri_lj.html,
"ufm (got)"_pair_ufm.html,
"vashishta (ko)"_pair_vashishta.html,
"vashishta (gko)"_pair_vashishta.html,
"vashishta/table (o)"_pair_vashishta.html,
"yukawa (gok)"_pair_yukawa.html,
"yukawa (gko)"_pair_yukawa.html,
"yukawa/colloid (go)"_pair_yukawa_colloid.html,
"zbl (gok)"_pair_zbl.html :tb(c=4,ea=c)
"zbl (gko)"_pair_zbl.html :tb(c=4,ea=c)

6
doc/src/Commands_parse.txt
View File

@ -14,7 +14,7 @@ LAMMPS commands are case sensitive. Command names are lower-case, as
are specified command arguments. Upper case letters may be used in
file names or user-chosen ID strings.
Here are 6 rulse for how each line in the input script is parsed by
Here are 6 rules for how each line in the input script is parsed by
LAMMPS:
(1) If the last printable character on the line is a "&" character,
@ -71,7 +71,7 @@ floating-point value. The format string is used to output the result
of the variable expression evaluation. If a format string is not
specified a high-precision "%.20g" is used as the default.
This can be useful for formatting print output to a desired precion:
This can be useful for formatting print output to a desired precision:
print "Final energy per atom: $(pe/atoms:%10.3f) eV/atom" :pre
@ -91,7 +91,7 @@ See the "variable"_variable.html command for more details of how
strings are assigned to variables and evaluated, and how they can be
used in input script commands.
(4) The line is broken into "words" separated by whitespace (tabs,
(4) The line is broken into "words" separated by white-space (tabs,
spaces). Note that words can thus contain letters, digits,
underscores, or punctuation characters.

3
doc/src/Developer/.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
/developer.aux
/developer.log
/developer.toc

36
doc/src/Developer/developer.tex
View File

@ -22,10 +22,10 @@ users.
LAMMPS source files are in two directories of the distribution
tarball. The src directory has the majority of them, all of which are
C++ files (*.cpp and *.h). Many of these files are in the src
directory itself. There are also dozens of "packages", which can be
directory itself. There are also dozens of ``packages'', which can be
included or excluded when LAMMPS is built. See the
doc/Section\_build.html section of the manual for more information
about packages, or type "make" from within the src directory, which
about packages, or type ``make'' from within the src directory, which
lists package-related commands, such as ``make package-status''. The
source files for each package are in an all-uppercase sub-directory of
src, like src/MOLECULE or src/USER-CUDA. If the package is currently
@ -38,17 +38,17 @@ The lib directory also contains source code for external libraries,
used by a few of the packages. Each sub-directory, like meam or gpu,
contains the source files, some of which are in different languages
such as Fortran. The files are compiled into libraries from within
each sub-directory, e.g. performing a "make" in the lib/meam directory
each sub-directory, e.g. performing a ``make'' in the lib/meam directory
creates a libmeam.a file. These libraries are linked to during a
LAMMPS build, if the corresponding package is installed.
LAMMPS C++ source files almost always come in pairs, such as run.cpp
and run.h. The pair of files defines a C++ class, the Run class in
this case, which contains the code invoked by the "run" command in a
this case, which contains the code invoked by the ``run'' command in a
LAMMPS input script. As this example illustrates, source file and
class names often have a one-to-one correspondence with a command used
in a LAMMPS input script. Some source files and classes do not have a
corresponding input script command, e.g. force.cpp and the Force
corresponding input script command, e.g. ``force.cpp'' and the Force
class. They are discussed in the next section.
\pagebreak
@ -57,12 +57,12 @@ class. They are discussed in the next section.
Though LAMMPS has a lot of source files and classes, its class
hierarchy is quite simple, as outlined in Fig \ref{fig:classes}. Each
boxed name refers to a class and has a pair of associated source files
in lammps/src, e.g. memory.cpp and memory.h. More details on the
in lammps/src, e.g. ``memory.cpp'' and ``memory.h''. More details on the
class and its methods and data structures can be found by examining
its *.h file.
LAMMPS (lammps.cpp/h) is the top-level class for the entire code. It
holds an "instance" of LAMMPS and can be instantiated one or more
holds an ``instance'' of LAMMPS and can be instantiated one or more
times by a calling code. For example, the file src/main.cpp simply
instantiates one instance of LAMMPS and passes it the input script.
@ -81,7 +81,7 @@ enabled by a bit of cleverness in the Pointers class (see
src/pointers.h) which every class inherits from.
There are a handful of virtual parent classes in LAMMPS that define
what LAMMPS calls "styles". They are shaded red in Fig
what LAMMPS calls ``styles''. They are shaded red in Fig
\ref{fig:classes}. Each of these are parents of a number of child
classes that implement the interface defined by the parent class. For
example, the fix style has around 100 child classes. They are the
@ -89,17 +89,17 @@ possible fixes that can be specified by the fix command in an input
script, e.g. fix nve, fix shake, fix ave/time, etc. The corresponding
classes are Fix (for the parent class), FixNVE, FixShake, FixAveTime,
etc. The source files for these classes are easy to identify in the
src directory, since they begin with the word "fix", e,g,
src directory, since they begin with the word ``fix'', e,g,
fix\_nve.cpp, fix\_shake,cpp, fix\_ave\_time.cpp, etc.
The one exception is child class files for the "command" style. These
The one exception is child class files for the ``command'' style. These
implement specific commands in the input script that can be invoked
before/after/between runs or which launch a simulation. Examples are
the create\_box, minimize, run, and velocity commands which encode the
CreateBox, Minimize, Run, and Velocity classes. The corresponding
files are create\_box,cpp, minimize.cpp, run.cpp, and velocity.cpp.
The list of command style files can be found by typing "grep
COMMAND\_CLASS *.h" from within the src directory, since that word in
The list of command style files can be found by typing ``grep
COMMAND\_CLASS *.h'' from within the src directory, since that word in
the header file identifies the class as an input script command.
Similar words can be grepped to list files for the other LAMMPS
styles. E.g. ATOM\_CLASS, PAIR\_CLASS, BOND\_CLASS, REGION\_CLASS,
@ -471,13 +471,13 @@ FixStyle(your/fix/name,FixMine)
\end{verbatim}
\end{center}
Where "your/fix/name" is a name of your fix in the script and FixMine
Where ``your/fix/name'' is a name of your fix in the script and FixMine
is the name of the class. This code allows LAMMPS to find your fix
when it parses input script. In addition, your fix header must be
included in the file "style\_fix.h". In case if you use LAMMPS make,
included in the file ``style\_fix.h''. In case if you use LAMMPS make,
this file is generated automatically - all files starting with prefix
fix\_ are included, so call your header the same way. Otherwise, don't
forget to add your include into "style\_fix.h".
forget to add your include into ``style\_fix.h''.
Let's write a simple fix which will print average velocity at the end
of each timestep. First of all, implement a constructor:
@ -567,11 +567,11 @@ void FixPrintVel::end_of_step()
\end{center}
In the code above, we use MathExtra routines defined in
"math\_extra.h". There are bunch of math functions to work with
``math\_extra.h''. There are bunch of math functions to work with
arrays of doubles as with math vectors.
In this code we use an instance of Atom class. This object is stored
in the Pointers class (see "pointers.h"). This object contains all
in the Pointers class (see ``pointers.h''). This object contains all
global information about the simulation system. Data from Pointers
class available to all classes inherited from it using protected
inheritance. Hence when you write you own class, which is going to use
@ -689,7 +689,7 @@ int FixSavePos::unpack_exchange(int nlocal, double *buf)
Now, a little bit about memory allocation. We used Memory class which
is just a bunch of template functions for allocating 1D and 2D
arrays. So you need to add include "memory.h" to have access to them.
arrays. So you need to add include ``memory.h'' to have access to them.
Finally, if you need to write/read some global information used in
your fix to the restart file, you might do it by setting flag

BIN
doc/src/Eqs/angle_cross.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 7.8 KiB

9
doc/src/Eqs/angle_cross.tex Normal file
View File

@ -0,0 +1,9 @@
\documentclass[12pt]{article}
\begin{document}
\thispagestyle{empty}
$$
E = K_{SS} \left(r_{12}-r_{12,0}\right)\left(r_{32}-r_{32,0}\right) + K_{BS0}\left(r_{12}-r_{12,0}\right)\left(\theta-\theta_0\right) + K_{BS1}\left(r_{32}-r_{32,0}\right)\left(\theta-\theta_0\right)
$$
\end{document}

BIN
doc/src/Eqs/angle_mm3.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 9.0 KiB

9
doc/src/Eqs/angle_mm3.tex Normal file
View File

@ -0,0 +1,9 @@
\documentclass[12pt]{article}
\begin{document}
\thispagestyle{empty}
$$
E = K (\theta - \theta_0)^2 \left[ 1 - 0.014(\theta - \theta_0) + 5.6(10)^{-5} (\theta - \theta_0)^2 - 7.0(10)^{-7} (\theta - \theta_0)^3 + 9(10)^{-10} (\theta - \theta_0)^4 \right]
$$
\end{document}

BIN
doc/src/Eqs/bond_mm3.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.7 KiB

9
doc/src/Eqs/bond_mm3.tex Normal file
View File

@ -0,0 +1,9 @@
\documentclass[12pt]{article}
\begin{document}
\thispagestyle{empty}
$$
E = K (r - r_0)^2 \left[ 1 - 2.55(r-r_0) + (7/12) 2.55^2(r-r_0)^2 \right]
$$
\end{document}

BIN
doc/src/Eqs/improper_distharm.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.1 KiB

9
doc/src/Eqs/improper_distharm.tex Normal file
View File

@ -0,0 +1,9 @@
\documentclass[12pt]{article}
\begin{document}
\thispagestyle{empty}
$$
E = K (d - d_0)^2
$$
\end{document}

BIN
doc/src/Eqs/improper_sqdistharm.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.2 KiB

9
doc/src/Eqs/improper_sqdistharm.tex Normal file
View File

@ -0,0 +1,9 @@
\documentclass[12pt]{article}
\begin{document}
\thispagestyle{empty}
$$
E = K (d^2 - d_0^2)^2
$$
\end{document}

BIN
doc/src/Eqs/min_spin_damping.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.9 KiB

13
doc/src/Eqs/min_spin_damping.tex Normal file
View File

@ -0,0 +1,13 @@
\documentclass[preview]{standalone}
\usepackage{varwidth}
\usepackage[utf8x]{inputenc}
\usepackage{amsmath, amssymb, graphics, setspace}
\begin{document}
\begin{varwidth}{50in}
\begin{equation}
\frac{d \vec{s}_{i}}{dt} = \lambda\, \vec{s}_{i} \times\left( \vec{\omega}_{i} \times\vec{s}_{i} \right)
\nonumber
\end{equation}
\end{varwidth}
\end{document}

BIN
doc/src/Eqs/min_spin_timestep.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.8 KiB

14
doc/src/Eqs/min_spin_timestep.tex Normal file
View File

@ -0,0 +1,14 @@
\documentclass[preview]{standalone}
\usepackage{varwidth}
\usepackage[utf8x]{inputenc}
\usepackage{amsmath, amssymb, graphics, setspace}
\begin{document}
\begin{varwidth}{50in}
\begin{equation}
{\Delta t}_{\rm max} = \frac{2\pi}{\kappa
\left|\vec{\omega}_{\rm max} \right|}
\nonumber
\end{equation}
\end{varwidth}
\end{document}

BIN
doc/src/Eqs/pair_atm.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.3 KiB

9
doc/src/Eqs/pair_atm.tex Normal file
View File

@ -0,0 +1,9 @@
\documentclass[12pt]{article}
\begin{document}
\begin{equation}
E=\nu\frac{1+3\cos\gamma_1\cos\gamma_2\cos\gamma_3}{r_{12}^3r_{23}^3r_{31}^3}
\end{equation}
\end{document}

BIN
doc/src/Eqs/pair_coulgauss.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.5 KiB

9
doc/src/Eqs/pair_coulgauss.tex Normal file
View File

@ -0,0 +1,9 @@
\documentclass[12pt]{article}
\begin{document}
\thispagestyle{empty}
\begin{eqnarray*}
E &=& \frac{q_i q_j \mathrm{erf}\left( r/\sqrt{\gamma_1^2+\gamma_2^2} \right) }{\epsilon r_{ij}}
\end{eqnarray*}
\end{document}

BIN
doc/src/Eqs/pair_lebedeva.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 30 KiB

BIN
doc/src/Eqs/pair_lj_switch3.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.6 KiB

11
doc/src/Eqs/pair_lj_switch3.tex Normal file
View File

@ -0,0 +1,11 @@
\documentclass[12pt]{article}
\begin{document}
\thispagestyle{empty}
\begin{eqnarray*}
E = 4\epsilon \left[ \left(\frac{\sigma}{r}\right)^{12}-\left(\frac{\sigma}{r}\right)^{6} \right]
% \qquad r < r_c \\
\end{eqnarray*}
\end{document}

BIN
doc/src/Eqs/pair_mm3_switch3.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 11 KiB

11
doc/src/Eqs/pair_mm3_switch3.tex Normal file
View File

@ -0,0 +1,11 @@
\documentclass[12pt]{article}
\begin{document}
\thispagestyle{empty}
\begin{eqnarray*}
E &=& \epsilon_{ij} \left[ -2.25 \left(\frac{r_{v,ij}}{r_{ij}}\right)^6 + 1.84(10)^5 \exp\left[-12.0 r_{ij}/r_{v,ij}\right] \right] S_3(r_{ij}) \\
r_{v,ij} &=& r_{v,i} + r_{v,j} \\
\epsilon_{ij} &=& \sqrt{\epsilon_i \epsilon_j}
\end{eqnarray*}
\end{document}

BIN
doc/src/Eqs/pair_switch3.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.6 KiB

14
doc/src/Eqs/pair_switch3.tex Normal file
View File

@ -0,0 +1,14 @@
\documentclass[12pt]{article}
\begin{document}
\thispagestyle{empty}
\begin{eqnarray*}
S_3(r) = \left\lbrace \begin{array}{ll}
1 & \quad\mathrm{if}\quad r < r_\mathrm{c} - w \\
3x^2 - 2x^3 & \quad\mathrm{if}\quad r < r_\mathrm{c} \quad\mathrm{with\quad} x=\frac{r_\mathrm{c} - r}{w} \\
0 & \quad\mathrm{if}\quad r >= r_\mathrm{c}
\end{array} \right.
\end{eqnarray*}
\end{document}

BIN
doc/src/Eqs/ptm_rmsd.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.7 KiB

21
doc/src/Eqs/ptm_rmsd.tex Normal file
View File

@ -0,0 +1,21 @@
\documentclass[12pt,article]{article}
\usepackage{indentfirst}
\usepackage{amsmath}
\newcommand{\set}[1]{\ensuremath{\mathbf{#1}}}
\newcommand{\mean}[1]{\ensuremath{\overline{#1}}}
\newcommand{\norm}[1]{\ensuremath{\left|\left|{#1}\right|\right|}}
\begin{document}
\begin{equation*}
\text{RMSD}(\set{u}, \set{v}) = \min_{s, \set{Q}} \sqrt{\frac{1}{N} \sum\limits_{i=1}^{N}
\norm{
s[\vec{u_i} - \mean{\set{u}}]
-
\set{Q} \vec{v_i}
}^2}
\end{equation*}
\end{document}

5
doc/src/Errors.txt
View File

@ -1,4 +1,4 @@
"Previous Section"_Python.html - "LAMMPS WWW Site"_lws -
"Previous Section"_Python_head.html - "LAMMPS WWW Site"_lws -
"LAMMPS Documentation"_ld - "LAMMPS Commands"_lc - "Next
Section"_Manual.html :c
@ -19,6 +19,7 @@ additional details for many of them.
<!-- RST
.. toctree::
:maxdepth: 1
Errors_common
Errors_bugs
@ -31,7 +32,7 @@ END_RST -->
"Common problems"_Errors_common.html
"Reporting bugs"_Errors_bugs.html
"Error messages"_Errors_messages.html
"Error messages"_Errors_messages.html
"Warning messages"_Errors_warnings.html :all(b)
<!-- END_HTML_ONLY -->

13
doc/src/Errors_common.txt
View File

@ -58,9 +58,9 @@ style", with ... being fix, compute, pair, etc, it means that you
mistyped the style name or that the command is part of an optional
package which was not compiled into your executable. The list of
available styles in your executable can be listed by using "the -h
command-line argument"_Section_start.html#start_6. The installation
and compilation of optional packages is explained in the "installation
instructions"_Section_start.html#start_3.
command-line swith"_Run_options.html. The installation and
compilation of optional packages is explained on the "Build
packages"_Build_package.html doc page.
For a given command, LAMMPS expects certain arguments in a specified
order. If you mess this up, LAMMPS will often flag the error, but it
@ -74,7 +74,7 @@ is an integer or floating-point number, respectively, and reject the
input with an error message (for instance, when an integer is required,
but a floating-point number 1.0 is provided):
ERROR: Expected integer parameter in input script or data file :pre
ERROR: Expected integer parameter instead of '1.0' in input script or data file :pre
Some commands allow for using variable references in place of numeric
constants so that the value can be evaluated and may change over the
@ -85,6 +85,9 @@ reading the input and before parsing commands,
NOTE: Using a variable reference (i.e. {v_name}) is only allowed if
the documentation of the corresponding command explicitly says it is.
Otherwise, you will receive an error message of this kind:
ERROR: Expected floating point parameter instead of 'v_name' in input script or data file :pre
Generally, LAMMPS will print a message to the screen and logfile and
exit gracefully when it encounters a fatal error. Sometimes it will
@ -93,7 +96,7 @@ decide if the WARNING is important or not. A WARNING message that is
generated in the middle of a run is only printed to the screen, not to
the logfile, to avoid cluttering up thermodynamic output. If LAMMPS
crashes or hangs without spitting out an error message first then it
could be a bug (see "this section"_#err_2) or one of the following
could be a bug (see "this section"_Errors_bugs.html) or one of the following
cases:
LAMMPS runs in the available memory a processor allows to be

136
doc/src/Errors_messages.txt
View File

@ -279,12 +279,6 @@ multibody joint). The bodies you have defined exceed this limit. :dd
This is an internal LAMMPS error. Please report it to the
developers. :dd
{Atom sorting has bin size = 0.0} :dt
The neighbor cutoff is being used as the bin size, but it is zero.
Thus you must explicitly list a bin size in the atom_modify sort
command or turn off sorting. :dd
{Atom style hybrid cannot have hybrid as an argument} :dt
Self-explanatory. :dd
@ -421,9 +415,9 @@ This is an internal error. It should normally not occur. :dd
This is an internal error. It should normally not occur. :dd
{Bad real space Coulomb cutoff in fix tune/kspace} :dt
{Bad real space Coulombic cutoff in fix tune/kspace} :dt
Fix tune/kspace tried to find the optimal real space Coulomb cutoff using
Fix tune/kspace tried to find the optimal real space Coulombic cutoff using
the Newton-Rhaphson method, but found a non-positive or NaN cutoff :dd
{Balance command before simulation box is defined} :dt
@ -460,7 +454,7 @@ compute. :dd
{Big particle in fix srd cannot be point particle} :dt
Big particles must be extended spheriods or ellipsoids. :dd
Big particles must be extended spheroids or ellipsoids. :dd
{Bigint setting in lmptype.h is invalid} :dt
@ -743,7 +737,7 @@ Self-explanatory. :dd
Self-explanatory. :dd
{Cannot (yet) use single precision with MSM (remove -DFFT_SINGLE from Makefile and recompile)} :dt
{Cannot (yet) use single precision with MSM (remove -DFFT_SINGLE from Makefile and re-compile)} :dt
Single precision cannot be used with MSM. :dd
@ -780,7 +774,7 @@ Cannot use tilt factors unless the simulation box is non-orthogonal. :dd
Self-explanatory. :dd
{Cannot change box z boundary to nonperiodic for a 2d simulation} :dt
{Cannot change box z boundary to non-periodic for a 2d simulation} :dt
Self-explanatory. :dd
@ -1092,11 +1086,6 @@ correct. :dd
The specified file cannot be opened. Check that the path and name are
correct. :dd
{Cannot open fix ave/spatial file %s} :dt
The specified file cannot be opened. Check that the path and name are
correct. :dd
{Cannot open fix ave/time file %s} :dt
The specified file cannot be opened. Check that the path and name are
@ -1293,7 +1282,7 @@ are defined. :dd
You cannot reset the timestep when a fix that keeps track of elapsed
time is in place. :dd
{Cannot run 2d simulation with nonperiodic Z dimension} :dt
{Cannot run 2d simulation with non-periodic Z dimension} :dt
Use the boundary command to make the z dimension periodic in order to
run a 2d simulation. :dd
@ -1677,10 +1666,6 @@ provided by an atom map. An atom map does not exist (by default) for
non-molecular problems. Using the atom_modify map command will force
an atom map to be created. :dd
{Cannot use fix ave/spatial z for 2 dimensional model} :dt
Self-explanatory. :dd
{Cannot use fix bond/break with non-molecular systems} :dt
Only systems with bonds that can be changed can be used. Atom_style
@ -2125,29 +2110,29 @@ Self-explanatory. :dd
Fix setforce cannot be used in this manner. Use fix addforce
instead. :dd
{Cannot use nonperiodic boundares with fix ttm} :dt
{Cannot use non-periodic boundares with fix ttm} :dt
This fix requires a fully periodic simulation box. :dd
{Cannot use nonperiodic boundaries with Ewald} :dt
{Cannot use non-periodic boundaries with Ewald} :dt
For kspace style ewald, all 3 dimensions must have periodic boundaries
unless you use the kspace_modify command to define a 2d slab with a
non-periodic z dimension. :dd
{Cannot use nonperiodic boundaries with EwaldDisp} :dt
{Cannot use non-periodic boundaries with EwaldDisp} :dt
For kspace style ewald/disp, all 3 dimensions must have periodic
boundaries unless you use the kspace_modify command to define a 2d
slab with a non-periodic z dimension. :dd
{Cannot use nonperiodic boundaries with PPPM} :dt
{Cannot use non-periodic boundaries with PPPM} :dt
For kspace style pppm, all 3 dimensions must have periodic boundaries
unless you use the kspace_modify command to define a 2d slab with a
non-periodic z dimension. :dd
{Cannot use nonperiodic boundaries with PPPMDisp} :dt
{Cannot use non-periodic boundaries with PPPMDisp} :dt
For kspace style pppm/disp, all 3 dimensions must have periodic
boundaries unless you use the kspace_modify command to define a 2d
@ -2425,10 +2410,6 @@ Self-explanatory. :dd
Self-explanatory. :dd
{Compute ID for fix ave/spatial does not exist} :dt
Self-explanatory. :dd
{Compute ID for fix ave/time does not exist} :dt
Self-explanatory. :dd
@ -3364,21 +3345,21 @@ probably due to errors in the Python code. :dd
The default minimum order is 2. This can be reset by the
kspace_modify minorder command. :dd
{Coulomb cut not supported in pair_style buck/long/coul/coul} :dt
{Coulombic cutoff not supported in pair_style buck/long/coul/coul} :dt
Must use long-range Coulombic interactions. :dd
{Coulomb cut not supported in pair_style lj/long/coul/long} :dt
{Coulombic cutoff not supported in pair_style lj/long/coul/long} :dt
Must use long-range Coulombic interactions. :dd
{Coulomb cut not supported in pair_style lj/long/tip4p/long} :dt
{Coulombic cutoff not supported in pair_style lj/long/tip4p/long} :dt
Must use long-range Coulombic interactions. :dd
{Coulomb cutoffs of pair hybrid sub-styles do not match} :dt
{Coulombic cutoffs of pair hybrid sub-styles do not match} :dt
If using a Kspace solver, all Coulomb cutoffs of long pair styles must
If using a Kspace solver, all Coulombic cutoffs of long pair styles must
be the same. :dd
{Coulombic cut not supported in pair_style lj/long/dipole/long} :dt
@ -4074,10 +4055,6 @@ Self-explanatory. :dd
Self-explanatory. :dd
{Fix ID for fix ave/spatial does not exist} :dt
Self-explanatory. :dd
{Fix ID for fix ave/time does not exist} :dt
Self-explanatory. :dd
@ -4379,51 +4356,6 @@ same style. :dd
Self-explanatory. :dd
{Fix ave/spatial compute does not calculate a per-atom array} :dt
Self-explanatory. :dd
{Fix ave/spatial compute does not calculate a per-atom vector} :dt
A compute used by fix ave/spatial must generate per-atom values. :dd
{Fix ave/spatial compute does not calculate per-atom values} :dt
A compute used by fix ave/spatial must generate per-atom values. :dd
{Fix ave/spatial compute vector is accessed out-of-range} :dt
The index for the vector is out of bounds. :dd
{Fix ave/spatial fix does not calculate a per-atom array} :dt
Self-explanatory. :dd
{Fix ave/spatial fix does not calculate a per-atom vector} :dt
A fix used by fix ave/spatial must generate per-atom values. :dd
{Fix ave/spatial fix does not calculate per-atom values} :dt
A fix used by fix ave/spatial must generate per-atom values. :dd
{Fix ave/spatial fix vector is accessed out-of-range} :dt
The index for the vector is out of bounds. :dd
{Fix ave/spatial for triclinic boxes requires units reduced} :dt
Self-explanatory. :dd
{Fix ave/spatial settings invalid with changing box size} :dt
If the box size changes, only the units reduced option can be
used. :dd
{Fix ave/spatial variable is not atom-style variable} :dt
A variable used by fix ave/spatial must generate per-atom values. :dd
{Fix ave/time cannot set output array intensive/extensive from these inputs} :dt
One of more of the vector inputs has individual elements which are
@ -5078,7 +5010,7 @@ Self-explanatory. :dd
Occurs when number of neighbor atoms for an atom increased too much
during a run. Increase SAFE_ZONE and MIN_CAP in fix_qeq.h and
recompile. :dd
re-compile. :dd
{Fix qeq/point requires atom attribute q} :dt
@ -5092,7 +5024,7 @@ Self-explanatory. :dd
Occurs when number of neighbor atoms for an atom increased too much
during a run. Increase SAFE_ZONE and MIN_CAP in fix_qeq.h and
recompile. :dd
re-compile. :dd
{Fix qeq/shielded requires atom attribute q} :dt
@ -5110,7 +5042,7 @@ Self-explanatory. :dd
Occurs when number of neighbor atoms for an atom increased too much
during a run. Increase SAFE_ZONE and MIN_CAP in fix_qeq.h and
recompile. :dd
re-compile. :dd
{Fix qeq/slater requires atom attribute q} :dt
@ -5541,7 +5473,7 @@ See the package gpu command. :dd
{GPUs are requested but Kokkos has not been compiled for CUDA} :dt
Recompile Kokkos with CUDA support to use GPUs. :dd
Re-compile Kokkos with CUDA support to use GPUs. :dd
{Ghost velocity forward comm not yet implemented with Kokkos} :dt
@ -6000,9 +5932,9 @@ map command will force an atom map to be created. :dd
Self-explanatory. :dd
{Input line quote not followed by whitespace} :dt
{Input line quote not followed by white-space} :dt
An end quote must be followed by whitespace. :dd
An end quote must be followed by white-space. :dd
{Insertion region extends outside simulation box} :dt
@ -6985,7 +6917,7 @@ types. :dd
{Invalid use of library file() function} :dt
This function is called thru the library interface. This
This function is called through the library interface. This
error should not occur. Contact the developers if it does. :dd
{Invalid value in set command} :dt
@ -7056,12 +6988,6 @@ The atom style defined does not have this attribute. :dd
The atom style defined does not have these attributes. :dd
{KIM neighbor iterator exceeded range} :dt
This should not happen. It likely indicates a bug
in the KIM implementation of the interatomic potential
where it is requesting neighbors incorrectly. :dd
{KOKKOS package does not yet support comm_style tiled} :dt
Self-explanatory. :dd
@ -7076,7 +7002,7 @@ The kspace accuracy designated in the input must be greater than zero. :dd
{KSpace accuracy too large to estimate G vector} :dt
Reduce the accuracy request or specify gwald explicitly
Reduce the accuracy request or specify gewald explicitly
via the kspace_modify command. :dd
{KSpace accuracy too low} :dt
@ -7911,8 +7837,8 @@ Atom IDs must be positive integers. :dd
{One or more atom IDs is too big} :dt
The limit on atom IDs is set by the SMALLBIG, BIGBIG, SMALLSMALL
setting in your Makefile. See Section_start 2.2 of the manual for
more details. :dd
setting in your LAMMPS build. See the "Build
settings"_Build_settings.html doc page for more info. :dd
{One or more atom IDs is zero} :dt
@ -8076,7 +8002,7 @@ Self-explanatory. :dd
{Package command after simulation box is defined} :dt
The package command cannot be used afer a read_data, read_restart, or
The package command cannot be used after a read_data, read_restart, or
create_box command. :dd
{Package gpu command without GPU package installed} :dt
@ -9260,7 +9186,7 @@ creates one large file for all processors. :dd
{Restart file byte ordering is not recognized} :dt
The file does not appear to be a LAMMPS restart file since it doesn't
contain a recognized byte-orderomg flag at the beginning. :dd
contain a recognized byte-ordering flag at the beginning. :dd
{Restart file byte ordering is swapped} :dt
@ -9472,7 +9398,7 @@ You may also want to boost the page size. :dd
{Small to big integers are not sized correctly} :dt
This error occurs whenthe sizes of smallint, imageint, tagint, bigint,
This error occurs when the sizes of smallint, imageint, tagint, bigint,
as defined in src/lmptype.h are not what is expected. Contact
the developers if this occurs. :dd
@ -10253,10 +10179,6 @@ valid. :dd
Self-explanatory. :dd
{Unrecognized virial argument in pair_style command} :dt
Only two options are supported: LAMMPSvirial and KIMvirial :dd
{Unsupported mixing rule in kspace_style ewald/disp} :dt
Only geometric mixing is supported. :dd

32
doc/src/Errors_warnings.txt
View File

@ -13,7 +13,7 @@ This is an alphabetic list of the WARNING messages LAMMPS prints out
and the reason why. If the explanation here is not sufficient, the
documentation for the offending command may help. Warning messages
also list the source file and line number where the warning was
generated. For example, a message lile this:
generated. For example, a message like this:
WARNING: Bond atom missing in box size check (domain.cpp:187) :pre
@ -178,12 +178,6 @@ When using fixes like box/relax, the potential energy used by the minimizer
is augmented by an additional energy provided by the fix. Thus the printed
converged energy may be different from the total potential energy. :dd
{Energy tally does not account for 'zero yes'} :dt
The energy removed by using the 'zero yes' flag is not accounted
for in the energy tally and thus energy conservation cannot be
monitored in this case. :dd
{Estimated error in splitting of dispersion coeffs is %g} :dt
Error is greater than 0.0001 percent. :dd
@ -291,24 +285,6 @@ This may cause accuracy problems. :dd
This may cause accuracy problems. :dd
{Fix thermal/conductivity comes before fix ave/spatial} :dt
The order of these 2 fixes in your input script is such that fix
thermal/conductivity comes first. If you are using fix ave/spatial to
measure the temperature profile induced by fix viscosity, then this
may cause a glitch in the profile since you are averaging immediately
after swaps have occurred. Flipping the order of the 2 fixes
typically helps. :dd
{Fix viscosity comes before fix ave/spatial} :dt
The order of these 2 fixes in your input script is such that
fix viscosity comes first. If you are using fix ave/spatial
to measure the velocity profile induced by fix viscosity, then
this may cause a glitch in the profile since you are averaging
immediately after swaps have occurred. Flipping the order
of the 2 fixes typically helps. :dd
{Fixes cannot send data in Kokkos communication, switching to classic communication} :dt
This is current restriction with Kokkos. :dd
@ -775,7 +751,7 @@ Self-explanatory. :dd
This may indicate the shell command did not operate as expected. :dd
{Should not allow rigid bodies to bounce off relecting walls} :dt
{Should not allow rigid bodies to bounce off reflecting walls} :dt
LAMMPS allows this, but their dynamics are not computed correctly. :dd
@ -868,10 +844,10 @@ Most FENE models need this setting for the special_bonds command. :dd
Most FENE models need this setting for the special_bonds command. :dd
{Using a manybody potential with bonds/angles/dihedrals and special_bond exclusions} :dt
{Using a many-body potential with bonds/angles/dihedrals and special_bond exclusions} :dt
This is likely not what you want to do. The exclusion settings will
eliminate neighbors in the neighbor list, which the manybody potential
eliminate neighbors in the neighbor list, which the many-body potential
needs to calculated its terms correctly. :dd
{Using compute temp/deform with inconsistent fix deform remap option} :dt

10
doc/src/Examples.txt
View File

@ -78,7 +78,7 @@ micelle: self-assembly of small lipid-like molecules into 2d bilayers
min: energy minimization of 2d LJ melt
mscg: parameterize a multi-scale coarse-graining (MSCG) model
msst: MSST shock dynamics
nb3b: use of nonbonded 3-body harmonic pair style
nb3b: use of non-bonded 3-body harmonic pair style
neb: nudged elastic band (NEB) calculation for barrier finding
nemd: non-equilibrium MD of 2d sheared system
obstacle: flow around two voids in a 2d channel
@ -112,10 +112,10 @@ web site.
If you uncomment the "dump image"_dump_image.html line(s) in the input
script a series of JPG images will be produced by the run (assuming
you built LAMMPS with JPG support; see "Section
2.2"_Section_start.html#start_2 for details). These can be viewed
individually or turned into a movie or animated by tools like
ImageMagick or QuickTime or various Windows-based tools. See the
you built LAMMPS with JPG support; see the
"Build_settings"_Build_settings.html doc page for details). These can
be viewed individually or turned into a movie or animated by tools
like ImageMagick or QuickTime or various Windows-based tools. See the
"dump image"_dump_image.html doc page for more details. E.g. this
Imagemagick command would create a GIF file suitable for viewing in a
browser.

173
doc/src/Howto.txt
View File

@ -8,26 +8,45 @@ Section"_Examples.html :c
:line
How to discussions :h2
Howto discussions :h2
These doc pages describe how to perform various tasks with LAMMPS,
both for users and developers. The
"glossary"_http://lammps.sandia.gov website page also lists MD
terminology with links to corresponding LAMMPS manual pages.
The example input scripts included in the examples dir of the LAMMPS
terminology with links to corresponding LAMMPS manual pages. The
example input scripts included in the examples dir of the LAMMPS
distribution and highlighted on the "Examples"_Examples.html doc page
also show how to setup and run various kinds of simulations.
Tutorials howto :h3
<!-- RST
.. toctree::
:name: tutorials
:maxdepth: 1
Howto_github
Howto_pylammps
Howto_bash
END_RST -->
<!-- HTML_ONLY -->
"Using GitHub with LAMMPS"_Howto_github.html
"PyLAMMPS interface to LAMMPS"_Howto_pylammps.html
"Using LAMMPS with bash on Windows"_Howto_bash.html :all(b)
<!-- END_HTML_ONLY -->
General howto :h3
<!-- RST
.. toctree::
:name: general_howto
:maxdepth: 1
Howto_restart
Howto_viz
@ -35,41 +54,117 @@ also show how to setup and run various kinds of simulations.
Howto_replica
Howto_library
Howto_couple
Howto_client_server
END_RST -->
<!-- HTML_ONLY -->
"Restart a simulation"_Howto_restart.html
"Visualize LAMMPS snapshots"_Howto_viz.html
"Run multiple simulations from one input script"_Howto_multiple.html
"Multi-replica simulations"_Howto_replica.html
"Library interface to LAMMPS"_Howto_library.html
"Couple LAMMPS to other codes"_Howto_couple.html
"Using LAMMPS in client/server mode"_Howto_client_server.html :all(b)
<!-- END_HTML_ONLY -->
Settings howto :h3
<!-- RST
.. toctree::
Howto_output
Howto_chunk
.. toctree::
:name: settings
:maxdepth: 1
Howto_2d
Howto_triclinic
Howto_walls
Howto_nemd
Howto_granular
Howto_spherical
Howto_dispersion
.. toctree::
Howto_temperature
Howto_thermostat
Howto_barostat
Howto_walls
Howto_nemd
Howto_dispersion
END_RST -->
<!-- HTML_ONLY -->
"2d simulations"_Howto_2d.html
"Triclinic (non-orthogonal) simulation boxes"_Howto_triclinic.html
"Thermostats"_Howto_thermostat.html
"Barostats"_Howto_barostat.html
"Walls"_Howto_walls.html
"NEMD simulations"_Howto_nemd.html
"Long-range dispersion settings"_Howto_dispersion.html :all(b)
<!-- END_HTML_ONLY -->
Analysis howto :h3
<!-- RST
.. toctree::
:name: analysis
:maxdepth: 1
Howto_output
Howto_chunk
Howto_temperature
Howto_elastic
Howto_kappa
Howto_viscosity
Howto_diffusion
END_RST -->
<!-- HTML_ONLY -->
"Output from LAMMPS (thermo, dumps, computes, fixes, variables)"_Howto_output.html
"Use chunks to calculate system properties"_Howto_chunk.html :all(b)
"Calculate temperature"_Howto_temperature.html
"Calculate elastic constants"_Howto_elastic.html
"Calculate thermal conductivity"_Howto_kappa.html
"Calculate viscosity"_Howto_viscosity.html
"Calculate a diffusion coefficient"_Howto_diffusion.html :all(b)
<!-- END_HTML_ONLY -->
Force fields howto :h3
<!-- RST
.. toctree::
:name: force
:maxdepth: 1
Howto_bioFF
Howto_tip3p
Howto_tip4p
Howto_spc
.. toctree::
END_RST -->
<!-- HTML_ONLY -->
"CHARMM, AMBER, COMPASS, and DREIDING force fields"_Howto_bioFF.html
"TIP3P water model"_Howto_tip3p.html
"TIP4P water model"_Howto_tip4p.html
"SPC water model"_Howto_spc.html :all(b)
<!-- END_HTML_ONLY -->
Packages howto :h3
<!-- RST
.. toctree::
:name: packages
:maxdepth: 1
Howto_spherical
Howto_granular
Howto_body
Howto_polarizable
Howto_coreshell
@ -80,49 +175,17 @@ also show how to setup and run various kinds of simulations.
END_RST -->
<!-- HTML_ONLY -->
"Using GitHub with LAMMPS"_Howto_github.html
"PyLAMMPS interface to LAMMPS"_Howto_pylammps.html
"Using LAMMPS with bash on Windows"_Howto_bash.html
"Restart a simulation"_Howto_restart.html
"Visualize LAMMPS snapshots"_Howto_viz.html
"Run multiple simulations from one input script"_Howto_multiple.html
"Multi-replica simulations"_Howto_replica.html
"Library interface to LAMMPS"_Howto_library.html
"Couple LAMMPS to other codes"_Howto_couple.html :all(b)
"Output from LAMMPS (thermo, dumps, computes, fixes, variables)"_Howto_output.html
"Use chunks to calculate system properties"_Howto_chunk.html :all(b)
"2d simulations"_Howto_2d.html
"Triclinic (non-orthogonal) simulation boxes"_Howto_triclinic.html
"Walls"_Howto_walls.html
"NEMD simulations"_Howto_nemd.html
"Granular models"_Howto_granular.html
"Finite-size spherical and aspherical particles"_Howto_spherical.html
"Long-range dispersion settings"_Howto_dispersion.html :all(b)
"Calculate temperature"_Howto_temperature.html
"Thermostats"_Howto_thermostat.html
"Barostats"_Howto_barostat.html
"Calculate elastic constants"_Howto_elastic.html
"Calculate thermal conductivity"_Howto_kappa.html
"Calculate viscosity"_Howto_viscosity.html
"Calculate a diffusion coefficient"_Howto_diffusion.html :all(b)
"CHARMM, AMBER, and DREIDING force fields"_Howto_bioFF.html
"TIP3P water model"_Howto_tip3p.html
"TIP4P water model"_Howto_tip4p.html
"SPC water model"_Howto_spc.html :all(b)
"Granular models"_Howto_granular.html
"Body style particles"_Howto_body.html
"Polarizable models"_Howto_polarizable.html
"Adiabatic core/shell model"_Howto_coreshell.html
"Drude induced dipoles"_Howto_drude.html
"Drude induced dipoles (extended)"_Howto_drude2.html :all(b)
"Drude induced dipoles (extended)"_Howto_drude2.html
"Manifolds (surfaces)"_Howto_manifold.html
"Magnetic spins"_Howto_spins.html
"Magnetic spins"_Howto_spins.html :all(b)
<!-- END_HTML_ONLY -->

8
doc/src/Howto_barostat.txt
View File

@ -19,7 +19,7 @@ barostat attempts to equilibrate the system to the requested T and/or
P.
Barostatting in LAMMPS is performed by "fixes"_fix.html. Two
barosttating methods are currently available: Nose-Hoover (npt and
barostatting methods are currently available: Nose-Hoover (npt and
nph) and Berendsen:
"fix npt"_fix_nh.html
@ -64,11 +64,11 @@ Thermodynamic output, which can be setup via the
"thermo_style"_thermo_style.html command, often includes pressure
values. As explained on the doc page for the
"thermo_style"_thermo_style.html command, the default pressure is
setup by the thermo command itself. It is NOT the presure associated
setup by the thermo command itself. It is NOT the pressure associated
with any barostatting fix you have defined or with any compute you
have defined that calculates a presure. The doc pages for the
have defined that calculates a pressure. The doc pages for the
barostatting fixes explain the ID of the pressure compute they create.
Thus if you want to view these pressurse, you need to specify them
Thus if you want to view these pressures, you need to specify them
explicitly via the "thermo_style custom"_thermo_style.html command.
Or you can use the "thermo_modify"_thermo_modify.html command to
re-define what pressure compute is used for default thermodynamic

6
doc/src/Howto_bash.txt Executable file → Normal file
View File

@ -40,7 +40,7 @@ Install Windows Subsystem for Linux :h5
Next you must ensure that the Window Subsystem for Linux is installed. Again,
search for "enable windows features" in the Settings dialog. This opens a
dialog with a list of features you can install. Add a checkmark to Windows
Subsystem for Linux (Beta) and press OK.
Subsystem for Linux (Beta) and press OK.
:image(JPG/bow_tutorial_04_small.png,JPG/bow_tutorial_04.png)
:image(JPG/bow_tutorial_05.png,JPG/bow_tutorial_05.png)
@ -54,12 +54,12 @@ enter. This will then download Ubuntu for Windows.
:image(JPG/bow_tutorial_06.png)
:image(JPG/bow_tutorial_07.png)
During installation, you will be asked for a new password. This will be used
for installing new software and running commands with sudo.
:image(JPG/bow_tutorial_08.png)
Type exit to close the command-line window.
Go to the Start menu and type "bash" again. This time you will see a "Bash on

91
doc/src/Howto_bioFF.txt
View File

@ -7,29 +7,31 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:line
CHARMM, AMBER, and DREIDING force fields :h3
CHARMM, AMBER, COMPASS, and DREIDING force fields :h3
A force field has 2 parts: the formulas that define it and the
coefficients used for a particular system. Here we only discuss
formulas implemented in LAMMPS that correspond to formulas commonly
used in the CHARMM, AMBER, and DREIDING force fields. Setting
coefficients is done in the input data file via the
"read_data"_read_data.html command or in the input script with
used in the CHARMM, AMBER, COMPASS, and DREIDING force fields. Setting
coefficients is done either from special sections in an input data file
via the "read_data"_read_data.html command or in the input script with
commands like "pair_coeff"_pair_coeff.html or
"bond_coeff"_bond_coeff.html. See the "Tools"_Tools.html doc page for
additional tools that can use CHARMM or AMBER to assign force field
coefficients and convert their output into LAMMPS input.
"bond_coeff"_bond_coeff.html and so on. See the "Tools"_Tools.html doc
page for additional tools that can use CHARMM, AMBER, or Materials
Studio generated files to assign force field coefficients and convert
their output into LAMMPS input.
See "(MacKerell)"_#howto-MacKerell for a description of the CHARMM force
field. See "(Cornell)"_#howto-Cornell for a description of the AMBER force
field.
field. See "(Cornell)"_#howto-Cornell for a description of the AMBER
force field. See "(Sun)"_#howto-Sun for a description of the COMPASS
force field.
:link(charmm,http://www.scripps.edu/brooks)
:link(amber,http://amber.scripps.edu)
These style choices compute force field formulas that are consistent
with common options in CHARMM or AMBER. See each command's
documentation for the formula it computes.
The interaction styles listed below compute force field formulas that
are consistent with common options in CHARMM or AMBER. See each
command's documentation for the formula it computes.
"bond_style"_bond_harmonic.html harmonic
"angle_style"_angle_charmm.html charmm
@ -44,28 +46,54 @@ documentation for the formula it computes.
"special_bonds"_special_bonds.html charmm
"special_bonds"_special_bonds.html amber :ul
NOTE: For CHARMM, newer {charmmfsw} or {charmmfsh} styles were
released in March 2017. We recommend they be used instead of the
older {charmm} styles. See discussion of the differences on the "pair
charmm"_pair_charmm.html and "dihedral charmm"_dihedral_charmm.html
doc pages.
NOTE: For CHARMM, newer {charmmfsw} or {charmmfsh} styles were released
in March 2017. We recommend they be used instead of the older {charmm}
styles. See discussion of the differences on the "pair
charmm"_pair_charmm.html and "dihedral charmm"_dihedral_charmm.html doc
pages.
COMPASS is a general force field for atomistic simulation of common
organic molecules, inorganic small molecules, and polymers which was
developed using ab initio and empirical parameterization techniques.
See the "Tools"_Tools.html doc page for the msi2lmp tool for creating
LAMMPS template input and data files from BIOVIA’s Materials Studio
files. Please note that the msi2lmp tool is very old and largely
unmaintained, so it does not support all features of Materials Studio
provided force field files, especially additions during the last decade.
You should watch the output carefully and compare results, where
possible. See "(Sun)"_#howto-Sun for a description of the COMPASS force
field.
These interaction styles listed below compute force field formulas that
are consistent with the COMPASS force field. See each command's
documentation for the formula it computes.
"bond_style"_bond_class2.html class2
"angle_style"_angle_class2.html class2
"dihedral_style"_dihedral_class2.html class2
"improper_style"_improper_class2.html class2 :ul
"pair_style"_pair_class2.html lj/class2
"pair_style"_pair_class2.html lj/class2/coul/cut
"pair_style"_pair_class2.html lj/class2/coul/long :ul
"special_bonds"_special_bonds.html lj/coul 0 0 1 :ul
DREIDING is a generic force field developed by the "Goddard
group"_http://www.wag.caltech.edu at Caltech and is useful for
predicting structures and dynamics of organic, biological and
main-group inorganic molecules. The philosophy in DREIDING is to use
general force constants and geometry parameters based on simple
hybridization considerations, rather than individual force constants
and geometric parameters that depend on the particular combinations of
atoms involved in the bond, angle, or torsion terms. DREIDING has an
"explicit hydrogen bond term"_pair_hbond_dreiding.html to describe
interactions involving a hydrogen atom on very electronegative atoms
(N, O, F).
predicting structures and dynamics of organic, biological and main-group
inorganic molecules. The philosophy in DREIDING is to use general force
constants and geometry parameters based on simple hybridization
considerations, rather than individual force constants and geometric
parameters that depend on the particular combinations of atoms involved
in the bond, angle, or torsion terms. DREIDING has an "explicit hydrogen
bond term"_pair_hbond_dreiding.html to describe interactions involving a
hydrogen atom on very electronegative atoms (N, O, F).
See "(Mayo)"_#howto-Mayo for a description of the DREIDING force field
These style choices compute force field formulas that are consistent
with the DREIDING force field. See each command's
The interaction styles listed below compute force field formulas that
are consistent with the DREIDING force field. See each command's
documentation for the formula it computes.
"bond_style"_bond_harmonic.html harmonic
@ -96,6 +124,13 @@ documentation for the formula it computes.
[(MacKerell)] MacKerell, Bashford, Bellott, Dunbrack, Evanseck, Field,
Fischer, Gao, Guo, Ha, et al, J Phys Chem, 102, 3586 (1998).
:link(howto-Cornell)
[(Cornell)] Cornell, Cieplak, Bayly, Gould, Merz, Ferguson,
Spellmeyer, Fox, Caldwell, Kollman, JACS 117, 5179-5197 (1995).
:link(howto-Sun)
[(Sun)] Sun, J. Phys. Chem. B, 102, 7338–7364 (1998).
:link(howto-Mayo)
[(Mayo)] Mayo, Olfason, Goddard III, J Phys Chem, 94, 8897-8909
(1990).

6
doc/src/Howto_body.txt
View File

@ -132,7 +132,7 @@ x1 y1 z1
xN yN zN :pre
where M = 6 + 3*N, and N is the number of sub-particles in the body
particle.
particle.
The integer line has a single value N. The floating point line(s)
list 6 moments of inertia followed by the coordinates of the N
@ -315,7 +315,7 @@ x1 y1 z1
...
xN yN zN
0 1
1 2
1 2
2 3
...
0 1 2 -1
@ -337,7 +337,7 @@ the sphere that surrounds each vertex. The diameter value can be
different for each body particle. These floating-point values can be
listed on as many lines as you wish; see the
"read_data"_read_data.html command for more details. Because the
maxmimum vertices per face is hard-coded to be 4
maximum number of vertices per face is hard-coded to be 4
(i.e. quadrilaterals), faces with more than 4 vertices need to be
split into triangles or quadrilaterals. For triangular faces, the
last vertex index should be set to -1.

47
doc/src/Howto_chunk.txt
View File

@ -22,8 +22,8 @@ commands, to calculate various properties of a system:
"fix ave/chunk"_fix_ave_chunk.html
any of the "compute */chunk"_compute.html commands :ul
Here, each of the 3 kinds of chunk-related commands is briefly
overviewed. Then some examples are given of how to compute different
Here a brief overview for each of the 4 kinds of chunk-related commands
is provided. Then some examples are given of how to compute different
properties with chunk commands.
Compute chunk/atom command: :h4
@ -83,8 +83,9 @@ chunk.
Compute */chunk commands: :h4
Currently the following computes operate on chunks of atoms to produce
per-chunk values.
The following computes operate on chunks of atoms to produce per-chunk
values. Any compute whose style name ends in "/chunk" is in this
category:
"compute com/chunk"_compute_com_chunk.html
"compute gyration/chunk"_compute_gyration_chunk.html
@ -111,8 +112,8 @@ of a center of mass, which requires summing mass*position over the
atoms and then dividing by summed mass.
All of these computes produce a global vector or global array as
output, wih one or more values per chunk. They can be used
in various ways:
output, wih one or more values per chunk. The output can be used in
various ways:
As input to the "fix ave/time"_fix_ave_time.html command, which can
write the values to a file and optionally time average them. :ulb,l
@ -122,9 +123,27 @@ histogram values across chunks. E.g. a histogram of cluster sizes or
molecule diffusion rates. :l
As input to special functions of "equal-style
variables"_variable.html, like sum() and max(). E.g. to find the
largest cluster or fastest diffusing molecule. :l
:ule
variables"_variable.html, like sum() and max() and ave(). E.g. to
find the largest cluster or fastest diffusing molecule or average
radius-of-gyration of a set of molecules (chunks). :l,ule
Other chunk commands: :h4
"compute chunk/spread/atom"_compute_chunk_spread_atom.html
"compute reduce/chunk"_compute_reduce_chunk.html :ul
The "compute chunk/spread/atom"_compute_chunk_spread_atom.html command
spreads per-chunk values to each atom in the chunk, producing per-atom
values as its output. This can be useful for outputting per-chunk
values to a per-atom "dump file"_dump.html. Or for using an atom's
associated chunk value in an "atom-style variable"_variable.html.
The "compute reduce/chunk"_compute_reduce_chunk.html command reduces a
peratom value across the atoms in each chunk to produce a value per
chunk. When used with the "compute
chunk/spread/atom"_compute_chunk_spread_atom.html command it can
create peratom values that induce a new set of chunks with a second
"compute chunk/atom"_compute_chunk_atom.html command.
Example calculations with chunks :h4
@ -164,3 +183,13 @@ compute cluster all cluster/atom 1.0
compute cc1 all chunk/atom c_cluster compress yes
compute size all property/chunk cc1 count
fix 1 all ave/histo 100 1 100 0 20 20 c_size mode vector ave running beyond ignore file tmp.histo :pre
(6) An example of using a per-chunk value to apply per-atom forces to
compress individual polymer chains (molecules) in a mixture, is
explained on the "compute
chunk/spread/atom"_compute_chunk_spread_atom.html command doc page.
(7) An example of using one set of per-chunk values for molecule
chunks, to create a 2nd set of micelle-scale chunks (clustered
molecules, due to hydrophobicity), is explained on the "compute
chunk/reduce"_compute_reduce_chunk.html command doc page.

131
doc/src/Howto_client_server.txt Normal file
View File

@ -0,0 +1,131 @@
"Higher level section"_Howto.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Using LAMMPS in client/server mode :h3
Client/server coupling of two codes is where one code is the "client"
and sends request messages to a "server" code. The server responds to
each request with a reply message. This enables the two codes to work
in tandem to perform a simulation. LAMMPS can act as either a client
or server code.
Some advantages of client/server coupling are that the two codes run
as stand-alone executables; they are not linked together. Thus
neither code needs to have a library interface. This often makes it
easier to run the two codes on different numbers of processors. If a
message protocol (format and content) is defined for a particular kind
of simulation, then in principle any code that implements the
client-side protocol can be used in tandem with any code that
implements the server-side protocol, without the two codes needing to
know anything more specific about each other.
A simple example of client/server coupling is where LAMMPS is the
client code performing MD timestepping. Each timestep it sends a
message to a server quantum code containing current coords of all the
atoms. The quantum code computes energy and forces based on the
coords. It returns them as a message to LAMMPS, which completes the
timestep.
Alternate methods for code coupling with LAMMPS are described on
the "Howto couple"_Howto_couple.html doc page.
LAMMPS support for client/server coupling is in its "MESSAGE
package"_Packages_details.html#PKG-MESSAGE which implements several
commands that enable LAMMPS to act as a client or server, as discussed
below. The MESSAGE package also wraps a client/server library called
CSlib which enables two codes to exchange messages in different ways,
either via files, sockets, or MPI. The CSlib is provided with LAMMPS
in the lib/message dir. The CSlib has its own
"website"_http://cslib.sandia.gov with documentation and test
programs.
NOTE: For client/server coupling to work between LAMMPS and another
code, the other code also has to use the CSlib. This can sometimes be
done without any modifications to the other code by simply wrapping it
with a Python script that exchanges CSlib messages with LAMMPS and
prepares input for or processes output from the other code. The other
code also has to implement a matching protocol for the format and
content of messages that LAMMPS exchanges with it.
These are the commands currently in the MESSAGE package for two
protocols, MD and MC (Monte Carlo). New protocols can easily be
defined and added to this directory, where LAMMPS acts as either the
client or server.
"message"_message.html
"fix client md"_fix_client_md.html = LAMMPS is a client for running MD
"server md"_server_md.html = LAMMPS is a server for computing MD forces
"server mc"_server_mc.html = LAMMPS is a server for computing a Monte Carlo energy :ul
The server doc files give details of the message protocols
for data that is exchanged between the client and server.
These example directories illustrate how to use LAMMPS as either a
client or server code:
examples/message
examples/COUPLE/README
examples/COUPLE/lammps_mc
examples/COUPLE/lammps_vasp :ul
The examples/message dir couples a client instance of LAMMPS to a
server instance of LAMMPS.
The lammps_mc dir shows how to couple LAMMPS as a server to a simple
Monte Carlo client code as the driver.
The lammps_vasp dir shows how to couple LAMMPS as a client code
running MD timestepping to VASP acting as a server providing quantum
DFT forces, through a Python wrapper script on VASP.
Here is how to launch a client and server code together for any of the
4 modes of message exchange that the "message"_message.html command
and the CSlib support. Here LAMMPS is used as both the client and
server code. Another code could be substituted for either.
The examples below show launching both codes from the same window (or
batch script), using the "&" character to launch the first code in the
background. For all modes except {mpi/one}, you could also launch the
codes in separate windows on your desktop machine. It does not
matter whether you launch the client or server first.
In these examples either code can be run on one or more processors.
If running in a non-MPI mode (file or zmq) you can launch a code on a
single processor without using mpirun.
IMPORTANT: If you run in mpi/two mode, you must launch both codes via
mpirun, even if one or both of them runs on a single processor. This
is so that MPI can figure out how to connect both MPI processes
together to exchange MPI messages between them.
For message exchange in {file}, {zmq}, or {mpi/two} modes:
% mpirun -np 1 lmp_mpi -log log.client < in.client &
% mpirun -np 2 lmp_mpi -log log.server < in.server :pre
% mpirun -np 4 lmp_mpi -log log.client < in.client &
% mpirun -np 1 lmp_mpi -log log.server < in.server :pre
% mpirun -np 2 lmp_mpi -log log.client < in.client &
% mpirun -np 4 lmp_mpi -log log.server < in.server :pre
For message exchange in {mpi/one} mode:
Launch both codes in a single mpirun command:
mpirun -np 2 lmp_mpi -mpicolor 0 -in in.message.client -log log.client : -np 4 lmp_mpi -mpicolor 1 -in in.message.server -log log.server :pre
The two -np values determine how many procs the client and the server
run on.
A LAMMPS executable run in this manner must use the -mpicolor color
command-line option as their its option, where color is an integer
label that will be used to distinguish one executable from another in
the multiple executables that the mpirun command launches. In this
example the client was colored with a 0, and the server with a 1.

14
doc/src/Howto_coreshell.txt
View File

@ -19,7 +19,7 @@ polarizable"_Howto_polarizable.html doc page for a discussion of all
the polarizable models available in LAMMPS.
Technically, shells are attached to the cores by a spring force f =
k*r where k is a parametrized spring constant and r is the distance
k*r where k is a parameterized spring constant and r is the distance
between the core and the shell. The charges of the core and the shell
add up to the ion charge, thus q(ion) = q(core) + q(shell). This
setup introduces the ion polarizability (alpha) given by
@ -111,7 +111,7 @@ the core and shell particles corresponds to the polarization,
hereby an instantaneous relaxation of the shells is approximated
and a fast core/shell spring frequency ensures a nearly constant
internal kinetic energy during the simulation.
Thermostats can alter this polarization behaviour, by scaling the
Thermostats can alter this polarization behavior, by scaling the
internal kinetic energy, meaning the shell will not react freely to
its electrostatic environment.
Therefore it is typically desirable to decouple the relative motion of
@ -119,7 +119,7 @@ the core/shell pair, which is an imaginary degree of freedom, from the
real physical system. To do that, the "compute
temp/cs"_compute_temp_cs.html command can be used, in conjunction with
any of the thermostat fixes, such as "fix nvt"_fix_nh.html or "fix
langevin"_fix_langevin. This compute uses the center-of-mass velocity
langevin"_fix_langevin.html. This compute uses the center-of-mass velocity
of the core/shell pairs to calculate a temperature, and insures that
velocity is what is rescaled for thermostatting purposes. This
compute also works for a system with both core/shell pairs and
@ -150,9 +150,9 @@ The pressure for the core/shell system is computed via the regular
LAMMPS convention by "treating the cores and shells as individual
particles"_#MitchellFincham2. For the thermo output of the pressure
as well as for the application of a barostat, it is necessary to
use an additional "pressure"_compute_pressure compute based on the
default "temperature"_compute_temp and specifying it as a second
argument in "fix modify"_fix_modify.html and
use an additional "pressure"_compute_pressure.html compute based on
the default "temperature"_compute_temp.html and specifying it as a
second argument in "fix modify"_fix_modify.html and
"thermo_modify"_thermo_modify.html resulting in:
(...)
@ -165,7 +165,7 @@ fix_modify press_bar temp CSequ press thermo_press_lmp # pressure modification
If "compute temp/cs"_compute_temp_cs.html is used, the decoupled
relative motion of the core and the shell should in theory be
stable. However numerical fluctuation can introduce a small
momentum to the system, which is noticable over long trajectories.
momentum to the system, which is noticeable over long trajectories.
Therefore it is recommendable to use the "fix
momentum"_fix_momentum.html command in combination with "compute
temp/cs"_compute_temp_cs.html when equilibrating the system to

37
doc/src/Howto_couple.txt
View File

@ -16,10 +16,12 @@ atoms and pass those forces to LAMMPS. Or a continuum finite element
nodal points, compute a FE solution, and return interpolated forces on
MD atoms.
LAMMPS can be coupled to other codes in at least 3 ways. Each has
LAMMPS can be coupled to other codes in at least 4 ways. Each has
advantages and disadvantages, which you'll have to think about in the
context of your application.
:line
(1) Define a new "fix"_fix.html command that calls the other code. In
this scenario, LAMMPS is the driver code. During its timestepping,
the fix is invoked, and can make library calls to the other code,
@ -32,6 +34,8 @@ LAMMPS.
:link(poems,http://www.rpi.edu/~anderk5/lab)
:line
(2) Define a new LAMMPS command that calls the other code. This is
conceptually similar to method (1), but in this case LAMMPS and the
other code are on a more equal footing. Note that now the other code
@ -46,12 +50,14 @@ In this scenario, the other code can be called as a library, as in
(1), or it could be a stand-alone code, invoked by a system() call
made by the command (assuming your parallel machine allows one or more
processors to start up another program). In the latter case the
stand-alone code could communicate with LAMMPS thru files that the
stand-alone code could communicate with LAMMPS through files that the
command writes and reads.
See the "Modify command"_Modify_command.html doc page for info on how
to add a new command to LAMMPS.
:line
(3) Use LAMMPS as a library called by another code. In this case the
other code is the driver and calls LAMMPS as needed. Or a wrapper
code could link and call both LAMMPS and another code as libraries.
@ -77,17 +83,16 @@ strain induced across grain boundaries :l
:link(quest,http://dft.sandia.gov/Quest)
:link(spparks,http://www.sandia.gov/~sjplimp/spparks.html)
"This section"_Section_start.html#start_5 of the documentation
describes how to build LAMMPS as a library. Once this is done, you
can interface with LAMMPS either via C++, C, Fortran, or Python (or
any other language that supports a vanilla C-like interface). For
example, from C++ you could create one (or more) "instances" of
LAMMPS, pass it an input script to process, or execute individual
commands, all by invoking the correct class methods in LAMMPS. From C
or Fortran you can make function calls to do the same things. See the
"Python"_Python.html doc pages for a description of the Python wrapper
provided with LAMMPS that operates through the LAMMPS library
interface.
The "Build basics"_Build_basics.html doc page describes how to build
LAMMPS as a library. Once this is done, you can interface with LAMMPS
either via C++, C, Fortran, or Python (or any other language that
supports a vanilla C-like interface). For example, from C++ you could
create one (or more) "instances" of LAMMPS, pass it an input script to
process, or execute individual commands, all by invoking the correct
class methods in LAMMPS. From C or Fortran you can make function
calls to do the same things. See the "Python"_Python_head.html doc
pages for a description of the Python wrapper provided with LAMMPS
that operates through the LAMMPS library interface.
The files src/library.cpp and library.h contain the C-style interface
to LAMMPS. See the "Howto library"_Howto_library.html doc page for a
@ -103,3 +108,9 @@ on all the processors. Or it might allocate half the processors to
LAMMPS and half to the other code and run both codes simultaneously
before syncing them up periodically. Or it might instantiate multiple
instances of LAMMPS to perform different calculations.
:line
(4) Couple LAMMPS with another code in a client/server mode. This is
described on the "Howto client/server"_Howto_client_server.html doc
page.

2
doc/src/Howto_diffusion.txt
View File

@ -7,7 +7,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:line
Calculate a diffusion coefficient :h3
Calculate diffusion coefficients :h3
The diffusion coefficient D of a material can be measured in at least
2 ways using various options in LAMMPS. See the examples/DIFFUSE

4
doc/src/Howto_dispersion.txt
View File

@ -7,7 +7,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:line
Long-raage dispersion settings :h3
Long-range dispersion settings :h3
The PPPM method computes interactions by splitting the pair potential
into two parts, one of which is computed in a normal pairwise fashion,
@ -74,7 +74,7 @@ command.
A reasonable approach that combines the upsides of both methods is to
make the first run using the {kspace_modify force/disp/real} and
{kspace_modify force/disp/kspace} commands, write down the PPPM
parameters from the outut, and specify these parameters using the
parameters from the output, and specify these parameters using the
second approach in subsequent runs (which have the same composition,
force field, and approximately the same volume).

2
doc/src/Howto_drude.txt
View File

@ -17,7 +17,7 @@ for a discussion of all the polarizable models available in LAMMPS.
The Drude model has a number of features aimed at its use in
molecular systems ("Lamoureux and Roux"_#howto-Lamoureux):
Thermostating of the additional degrees of freedom associated with the
Thermostatting of the additional degrees of freedom associated with the
induced dipoles at very low temperature, in terms of the reduced
coordinates of the Drude particles with respect to their cores. This
makes the trajectory close to that of relaxed induced dipoles. :ulb,l

8
doc/src/Howto_drude2.txt
View File

@ -82,7 +82,7 @@ decouple the degrees of freedom associated with the Drude oscillators
from those of the normal atoms. Thermalizing the Drude dipoles at
temperatures comparable to the rest of the simulation leads to several
problems (kinetic energy transfer, very short timestep, etc.), which
can be remediate by the "cold Drude" technique ("Lamoureux and
can be remedied by the "cold Drude" technique ("Lamoureux and
Roux"_#Lamoureux2).
Two closely related models are used to represent polarization through
@ -213,7 +213,7 @@ of mass of the DC-DP pairs, with relaxation time 100 and with random
seed 12345. This fix applies also a Langevin thermostat at temperature
1. to the relative motion of the DPs around their DCs, with relaxation
time 20 and random seed 13977. Only the DCs and non-polarizable
atoms need to be in this fix's group. LAMMPS will thermostate the DPs
atoms need to be in this fix's group. LAMMPS will thermostat the DPs
together with their DC. For this, ghost atoms need to know their
velocities. Thus you need to add the following command:
@ -360,7 +360,7 @@ fix NPH all nph iso 1. 1. 500 :pre
It is also possible to use a Nose-Hoover instead of a Langevin
thermostat. This requires to use "{fix
drude/transform}"_fix_drude_transform.html just before and after the
time intergation fixes. The {fix drude/transform/direct} converts the
time integration fixes. The {fix drude/transform/direct} converts the
atomic masses, positions, velocities and forces into a reduced
representation, where the DCs transform into the centers of mass of
the DC-DP pairs and the DPs transform into their relative position
@ -396,7 +396,7 @@ global pressure and thus a global temperature whatever the fix group.
We do want the pressure to correspond to the whole system, but we want
the temperature to correspond to the fix group only. We must then use
the {fix_modify} command for this. In the end, the block of
instructions for thermostating and barostating will look like
instructions for thermostatting and barostatting will look like
compute TATOMS ATOMS temp
fix DIRECT all drude/transform/direct

2
doc/src/Howto_elastic.txt
View File

@ -30,7 +30,7 @@ examples/elastic directory described on the "Examples"_Examples.html
doc page.
Calculating elastic constants at finite temperature is more
challenging, because it is necessary to run a simulation that perfoms
challenging, because it is necessary to run a simulation that performs
time averages of differential properties. One way to do this is to
measure the change in average stress tensor in an NVT simulations when
the cell volume undergoes a finite deformation. In order to balance

50
doc/src/Howto_github.txt
View File

@ -96,7 +96,7 @@ machine to a directory with the name you chose. If none is given, it will
default to "lammps". Typical names are "mylammps" or something similar.
You can use this local clone to make changes and
test them without interfering with the repository on Github.
test them without interfering with the repository on GitHub.
To pull changes from upstream into this copy, you can go to the directory
and use git pull:
@ -150,7 +150,7 @@ After the commit, the changes can be pushed to the same branch on GitHub:
$ git push :pre
Git will ask you for your user name and password on GitHub if you have
not configured anything. If your local branch is not present on Github yet,
not configured anything. If your local branch is not present on GitHub yet,
it will ask you to add it by running
$ git push --set-upstream origin github-tutorial-update :pre
@ -254,20 +254,53 @@ them, or if a developer has requested that something needs to be changed
before the feature can be accepted into the official LAMMPS version.
After each push, the automated checks are run again.
[Labels]
LAMMPS developers may add labels to your pull request to assign it to
categories (mostly for bookkeeping purposes), but a few of them are
important: needs_work, work_in_progress, test-for-regression, and
full-regression-test. The first two indicate, that your pull request
is not considered to be complete. With "needs_work" the burden is on
exclusively on you; while "work_in_progress" can also mean, that a
LAMMPS developer may want to add changes. Please watch the comments
to the pull requests. The two "test" labels are used to trigger
extended tests before the code is merged. This is sometimes done by
LAMMPS developers, if they suspect that there may be some subtle
side effects from your changes. It is not done by default, because
those tests are very time consuming.
[Reviews]
As of Summer 2018, a pull request needs at least 1 approving review
from a LAMMPS developer with write access to the repository.
In case your changes touch code that certain developers are associated
with, they are auto-requested by the GitHub software. Those associations
are set in the file
".github/CODEOWNERS"_https://github.com/lammps/lammps/blob/master/.github/CODEOWNERS
Thus if you want to be automatically notified to review when anybody
changes files or packages, that you have contributed to LAMMPS, you can
add suitable patterns to that file, or a LAMMPS developer may add you.
Otherwise, you can also manually request reviews from specific developers,
or LAMMPS developers - in their assessment of your pull request - may
determine who else should be reviewing your contribution and add that person.
Through reviews, LAMMPS developers also may request specific changes from you.
If those are not addressed, your pull requests cannot be merged.
[Assignees]
There is an assignee label for pull requests. If the request has not
There is an assignee property for pull requests. If the request has not
been reviewed by any developer yet, it is not assigned to anyone. After
revision, a developer can choose to assign it to either a) you, b) a
LAMMPS developer (including him/herself) or c) Steve Plimpton (sjplimp).
LAMMPS developer (including him/herself) or c) Axel Kohlmeyer (akohlmey).
Case a) happens if changes are required on your part :ulb,l
Case b) means that at the moment, it is being tested and reviewed by a
LAMMPS developer with the expectation that some changes would be required.
After the review, the developer can choose to implement changes directly
or suggest them to you. :l
Case c) means that the pull request has been assigned to the lead
developer Steve Plimpton and means it is considered ready for merging. :ule,l
Case c) means that the pull request has been assigned to the developer
overseeing the merging of pull requests into the master branch. :ule,l
In this case, Axel assigned the tutorial to Steve:
@ -336,7 +369,7 @@ commit and push again:
$ git commit -m "Merged Axel's suggestions and updated text"
$ git push git@github.com:Pakketeretet2/lammps :pre
This merge also shows up on the lammps Github page:
This merge also shows up on the lammps GitHub page:
:c,image(JPG/tutorial_reverse_pull_request7.png)
@ -381,3 +414,6 @@ Furthermore, the naming of the patches now follow the pattern
"patch_<Day><Month><Year>" to simplify comparisons between releases.
Finally, all patches and submissions are subject to automatic testing
and code checks to make sure they at the very least compile.
A discussion of the LAMMPS developer GitHub workflow can be found in the file
"doc/github-development-workflow.md"_https://github.com/lammps/lammps/blob/master/doc/github-development-workflow.md

2
doc/src/Howto_granular.txt
View File

@ -53,5 +53,5 @@ computations between frozen atoms by using this command:
NOTE: By default, for 2d systems, granular particles are still modeled
as 3d spheres, not 2d discs (circles), meaning their moment of inertia
will be the same as in 3d. If you wish to model granular particles in
2d as 2d discs, see the note on this topic on the "Howto 2d"_Howto_2d
2d as 2d discs, see the note on this topic on the "Howto 2d"_Howto_2d.html
doc page, where 2d simulations are discussed.

46
doc/src/Howto_library.txt
View File

@ -9,10 +9,10 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
Library interface to LAMMPS :h3
As described in "Section 2.5"_Section_start.html#start_5, LAMMPS can
be built as a library, so that it can be called by another code, used
in a "coupled manner"_Howto_couple.html with other codes, or driven
through a "Python interface"_Python.html.
As described on the "Build basics"_Build_basics.html doc page, LAMMPS
can be built as a library, so that it can be called by another code,
used in a "coupled manner"_Howto_couple.html with other codes, or
driven through a "Python interface"_Python_head.html.
All of these methodologies use a C-style interface to LAMMPS that is
provided in the files src/library.cpp and src/library.h. The
@ -35,8 +35,8 @@ details.
NOTE: You can write code for additional functions as needed to define
how your code talks to LAMMPS and add them to src/library.cpp and
src/library.h, as well as to the "Python interface"_Python.html. The
added functions can access or change any internal LAMMPS data you
src/library.h, as well as to the "Python interface"_Python_head.html.
The added functions can access or change any internal LAMMPS data you
wish.
void lammps_open(int, char **, MPI_Comm, void **)
@ -51,12 +51,11 @@ void lammps_free(void *) :pre
The lammps_open() function is used to initialize LAMMPS, passing in a
list of strings as if they were "command-line
arguments"_Section_start.html#start_6 when LAMMPS is run in
stand-alone mode from the command line, and a MPI communicator for
LAMMPS to run under. It returns a ptr to the LAMMPS object that is
created, and which is used in subsequent library calls. The
lammps_open() function can be called multiple times, to create
multiple instances of LAMMPS.
arguments"_Run_options.html when LAMMPS is run in stand-alone mode
from the command line, and a MPI communicator for LAMMPS to run under.
It returns a ptr to the LAMMPS object that is created, and which is
used in subsequent library calls. The lammps_open() function can be
called multiple times, to create multiple instances of LAMMPS.
LAMMPS will run on the set of processors in the communicator. This
means the calling code can run LAMMPS on all or a subset of
@ -88,7 +87,7 @@ commands to LAMMPS to execute, the same as if they were coming from an
input script.
Via these functions, the calling code can read or generate a series of
LAMMPS commands one or multiple at a time and pass it thru the library
LAMMPS commands one or multiple at a time and pass it through the library
interface to setup a problem and then run it in stages. The caller
can interleave the command function calls with operations it performs,
calls to extract information from or set information within LAMMPS, or
@ -167,26 +166,28 @@ void lammps_gather_atoms_subset(void *, char *, int, int, int, int *, void *)
void lammps_scatter_atoms(void *, char *, int, int, void *)
void lammps_scatter_atoms_subset(void *, char *, int, int, int, int *, void *) :pre
void lammps_create_atoms(void *, int, tagint *, int *, double *, double *,
imageint *, int) :pre
The gather functions collect peratom info of the requested type (atom
coords, atom types, forces, etc) from all processors, and returns the
same vector of values to each callling processor. The scatter
same vector of values to each calling processor. The scatter
functions do the inverse. They distribute a vector of peratom values,
passed by all calling processors, to invididual atoms, which may be
owned by different processos.
passed by all calling processors, to individual atoms, which may be
owned by different processors.
IMPORTANT NOTE: These functions are not compatible with the
-DLAMMPS_BIGBIG setting when compiling LAMMPS. Dummy functions
that result in an error message and abort will be substituted
instead of resulting in random crashes and memory corruption.
The lammps_gather_atoms() function does this for all N atoms in the
system, ordered by atom ID, from 1 to N. The
lammps_gather_atoms_concat() function does it for all N atoms, but
simply concatenates the subset of atoms owned by each processor. The
resulting vector is not ordered by atom ID. Atom IDs can be requetsed
resulting vector is not ordered by atom ID. Atom IDs can be requested
by the same function if the caller needs to know the ordering. The
lammps_gather_subset() function allows the caller to request values
for only a subset of atoms (identified by ID).
For all 3 gather function, per-atom image flags can be retrieved in 2 ways.
If the count is specified as 1, they are returned
If the count is specified as 1, they are returned
in a packed format with all three image flags stored in a single integer.
If the count is specified as 3, the values are unpacked into xyz flags
by the library before returning them.
@ -197,6 +198,9 @@ those values to each atom in the system. The
lammps_scatter_atoms_subset() function takes a subset of IDs as an
argument and only scatters those values to the owning atoms.
void lammps_create_atoms(void *, int, tagint *, int *, double *, double *,
imageint *, int) :pre
The lammps_create_atoms() function takes a list of N atoms as input
with atom types and coords (required), an optionally atom IDs and
velocities and image flags. It uses the coords of each atom to assign

4
doc/src/Howto_manifold.txt
View File

@ -31,8 +31,8 @@ plane @ a b c x0 y0 z0 @ a*(x-x0) + b*(y-y0) + c*(z-z0) = 0 @ A plane with norma
plane_wiggle @ a w @ z - a*sin(w*x) = 0 @ A plane with a sinusoidal modulation on z along x.
sphere @ R @ x^2 + y^2 + z^2 - R^2 = 0 @ A sphere of radius R
supersphere @ R q @ | x |^q + | y |^q + | z |^q - R^q = 0 @ A supersphere of hyperradius R
spine @ a, A, B, B2, c @ -(x^2 + y^2) + (a^2 - z^2/f(z)^2)*(1 + (A*sin(g(z)*z^2))^4), f(z) = c if z > 0, 1 otherwise; g(z) = B if z > 0, B2 otherwise @ An approximation to a dendtritic spine
spine_two @ a, A, B, B2, c @ -(x^2 + y^2) + (a^2 - z^2/f(z)^2)*(1 + (A*sin(g(z)*z^2))^2), f(z) = c if z > 0, 1 otherwise; g(z) = B if z > 0, B2 otherwise @ Another approximation to a dendtritic spine
spine @ a, A, B, B2, c @ -(x^2 + y^2) + (a^2 - z^2/f(z)^2)*(1 + (A*sin(g(z)*z^2))^4), f(z) = c if z > 0, 1 otherwise; g(z) = B if z > 0, B2 otherwise @ An approximation to a dendritic spine
spine_two @ a, A, B, B2, c @ -(x^2 + y^2) + (a^2 - z^2/f(z)^2)*(1 + (A*sin(g(z)*z^2))^2), f(z) = c if z > 0, 1 otherwise; g(z) = B if z > 0, B2 otherwise @ Another approximation to a dendritic spine
thylakoid @ wB LB lB @ Various, see "(Paquay)"_#Paquay1 @ A model grana thylakoid consisting of two block-like compartments connected by a bridge of width wB, length LB and taper length lB
torus @ R r @ (R - sqrt( x^2 + y^2 ) )^2 + z^2 - r^2 @ A torus with large radius R and small radius r, centered on (0,0,0) :tb(s=@)

3
doc/src/Howto_multiple.txt
View File

@ -80,8 +80,7 @@ jump in.polymer :pre
All of the above examples work whether you are running on 1 or
multiple processors, but assumed you are running LAMMPS on a single
partition of processors. LAMMPS can be run on multiple partitions via
the "-partition" command-line switch as described in "this
section"_Section_start.html#start_6 of the manual.
the "-partition command-line switch"_Run_options.html.
In the last 2 examples, if LAMMPS were run on 3 partitions, the same
scripts could be used if the "index" and "loop" variables were

11
doc/src/Howto_nemd.txt
View File

@ -24,6 +24,11 @@ by subtracting out the streaming velocity of the shearing atoms. The
velocity profile or other properties of the fluid can be monitored via
the "fix ave/chunk"_fix_ave_chunk.html command.
NOTE: A recent (2017) book by "(Daivis and Todd)"_#Daivis-nemd
discusses use of the SLLOD method and non-equilibrium MD (NEMD)
thermostatting generally, for both simple and complex fluids,
e.g. molecular systems. The latter can be tricky to do correctly.
As discussed in the previous section on non-orthogonal simulation
boxes, the amount of tilt or skew that can be applied is limited by
LAMMPS for computational efficiency to be 1/2 of the parallel box
@ -46,3 +51,9 @@ An alternative method for calculating viscosities is provided via the
NEMD simulations can also be used to measure transport properties of a fluid
through a pore or channel. Simulations of steady-state flow can be performed
using the "fix flow/gauss"_fix_flow_gauss.html command.
:line
:link(Daivis-nemd)
[(Daivis and Todd)] Daivis and Todd, Nonequilibrium Molecular Dynamics (book),
Cambridge University Press, https://doi.org/10.1017/9781139017848, (2017).

6
doc/src/Howto_polarizable.txt
View File

@ -45,8 +45,8 @@ high symmetry around each site leads to stable trajectories of the
core-shell pairs. However, bonded atoms in molecules can be so close
that a core would interact too strongly or even capture the Drude
particle of a neighbor. The Drude dipole model is relatively more
complex in order to remediate this and other issues. Specifically, the
Drude model includes specific thermostating of the core-Drude pairs
complex in order to remedy this and other issues. Specifically, the
Drude model includes specific thermostatting of the core-Drude pairs
and short-range damping of the induced dipoles.
The three polarization methods can be implemented through a
@ -77,5 +77,5 @@ motion of the Drude particles with respect to their cores is kept
approaching the self-consistent regime. In both models the
temperature is regulated using the velocities of the center of mass of
core+shell (or Drude) pairs, but in the Drude model the actual
relative core-Drude particle motion is thermostated separately as
relative core-Drude particle motion is thermostatted separately as
well.

41
doc/src/Howto_pylammps.txt
View File

@ -57,6 +57,17 @@ library is then loaded by the Python interface. In this example we enable the
MOLECULE package and compile LAMMPS with C++ exceptions, PNG, JPEG and FFMPEG
output support enabled.
Step 1a: For the CMake based build system, the steps are:
mkdir $LAMMPS_DIR/build-shared
cd $LAMMPS_DIR/build-shared :pre
# MPI, PNG, Jpeg, FFMPEG are auto-detected
cmake ../cmake -DPKG_MOLECULE=yes -DLAMMPS_EXCEPTIONS=yes -DBUILD_LIB=yes -DBUILD_SHARED_LIBS=yes
make :pre
Step 1b: For the legacy, make based build system, the steps are:
cd $LAMMPS_DIR/src :pre
# add packages if necessary
@ -68,12 +79,11 @@ make mpi mode=shlib LMP_INC="-DLAMMPS_PNG -DLAMMPS_JPEG -DLAMMPS_FFMPEG -DLAMMPS
Step 2: Installing the LAMMPS Python package :h6
PyLammps is part of the lammps Python package. To install it simply install
that package into your current Python installation.
that package into your current Python installation with:
cd $LAMMPS_DIR/python
python install.py :pre
make install-python :pre
NOTE: Recompiling the shared library requires reinstalling the Python package
NOTE: Recompiling the shared library requires re-installing the Python package
Installation inside of a virtualenv :h5
@ -94,14 +104,21 @@ apt-get install python-virtualenv :pre
Creating a virtualenv with lammps installed :h6
# create virtualenv name 'testing' :pre
# create virtualenv named 'testing'
virtualenv $HOME/python/testing :pre
# activate 'testing' environment
source testing/bin/activate :pre
source $HOME/python/testing/bin/activate :pre
Now configure and compile the LAMMPS shared library as outlined above.
When using CMake and the shared library has already been build, you
need to re-run CMake to update the location of the python executable
to the location in the virtual environment with:
cmake . -DPYTHON_EXECUTABLE=$(which python) :pre
# install LAMMPS package in virtualenv
(testing) cd $LAMMPS_DIR/python
(testing) python install.py :pre
(testing) make install-python :pre
# install other useful packages
(testing) pip install matplotlib jupyter mpi4py :pre
@ -141,16 +158,16 @@ Python code if {L} was a lammps instance:
L.command("region box block 0 10 0 5 -0.5 0.5") :pre
With the PyLammps interface, any command can be split up into arbitrary parts
separated by whitespace, passed as individual arguments to a region method.
separated by white-space, passed as individual arguments to a region method.
L.region("box block", 0, 10, 0, 5, -0.5, 0.5) :pre
Note that each parameter is set as Python literal floating-point number. In the
PyLammps interface, each command takes an arbitrary parameter list and transparently
merges it to a single command string, separating individual parameters by whitespace.
merges it to a single command string, separating individual parameters by white-space.
The benefit of this approach is avoiding redundant command calls and easier
parameterization. In the original interface parametrization needed to be done
parameterization. In the original interface parameterization needed to be done
manually by creating formatted strings.
L.command("region box block %f %f %f %f %f %f" % (xlo, xhi, ylo, yhi, zlo, zhi)) :pre
@ -328,7 +345,7 @@ jupyter notebook :pre
IPyLammps Examples :h4
Examples of IPython notebooks can be found in the python/examples/pylammps
subdirectory. To open these notebooks launch {jupyter notebook} inside this
sub-directory. To open these notebooks launch {jupyter notebook} inside this
directory and navigate to one of them. If you compiled and installed
a LAMMPS shared library with exceptions, PNG, JPEG and FFMPEG support
you should be able to rerun all of these notebooks.

19
doc/src/Howto_replica.txt
View File

@ -9,7 +9,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
Multi-replica simulations :h3
Several commands in LAMMPS run mutli-replica simulations, meaning
Several commands in LAMMPS run multi-replica simulations, meaning
that multiple instances (replicas) of your simulation are run
simultaneously, with small amounts of data exchanged between replicas
periodically.
@ -29,29 +29,28 @@ runs different replicas at a series of temperature to facilitate
rare-event sampling.
These commands can only be used if LAMMPS was built with the REPLICA
package. See the "Making LAMMPS"_Section_start.html#start_3 section
for more info on packages.
package. See the "Build package"_Build_package.html doc page for more
info.
PIMD runs different replicas whose individual particles are coupled
together by springs to model a system or ring-polymers.
This commands can only be used if LAMMPS was built with the USER-MISC
package. See the "Making LAMMPS"_Section_start.html#start_3 section
for more info on packages.
package. See the "Build package"_Build_package.html doc page for more
info.
In all these cases, you must run with one or more processors per
replica. The processors assigned to each replica are determined at
run-time by using the "-partition command-line
switch"_Section_start.html#start_6 to launch LAMMPS on multiple
partitions, which in this context are the same as replicas. E.g.
these commands:
switch"_Run_options.html to launch LAMMPS on multiple partitions,
which in this context are the same as replicas. E.g. these commands:
mpirun -np 16 lmp_linux -partition 8x2 -in in.temper
mpirun -np 8 lmp_linux -partition 8x1 -in in.neb :pre
would each run 8 replicas, on either 16 or 8 processors. Note the use
of the "-in command-line switch"_Section_start.html#start_6 to specify
the input script which is required when running in multi-replica mode.
of the "-in command-line switch"_Run_options.html to specify the input
script which is required when running in multi-replica mode.
Also note that with MPI installed on a machine (e.g. your desktop),
you can run on more (virtual) processors than you have physical

4
doc/src/Howto_restart.txt
View File

@ -16,8 +16,8 @@ restart files can be saved to disk using the "restart"_restart.html
command. At a later time, these binary files can be read via a
"read_restart"_read_restart.html command in a new script. Or they can
be converted to text data files using the "-r command-line
switch"_Section_start.html#start_6 and read by a
"read_data"_read_data.html command in a new script.
switch"_Run_options.html and read by a "read_data"_read_data.html
command in a new script.
Here we give examples of 2 scripts that read either a binary restart
file or a converted data file and then issue a new run command to

2
doc/src/Howto_spc.txt
View File

@ -30,7 +30,7 @@ r0 of OH bond = 1.0
theta of HOH angle = 109.47 :all(b),p
Note that as originally proposed, the SPC model was run with a 9
Angstrom cutoff for both LJ and Coulommbic terms. It can also be used
Angstrom cutoff for both LJ and Coulombic terms. It can also be used
with long-range Coulombics (Ewald or PPPM in LAMMPS), without changing
any of the parameters above, though it becomes a different model in
that mode of usage.

6
doc/src/Howto_spherical.txt
View File

@ -35,7 +35,7 @@ There are several "atom styles"_atom_style.html that allow for
definition of finite-size particles: sphere, dipole, ellipsoid, line,
tri, peri, and body.
The sphere style defines particles that are spheriods and each
The sphere style defines particles that are spheroids and each
particle can have a unique diameter and mass (or density). These
particles store an angular velocity (omega) and can be acted upon by
torque. The "set" command can be used to modify the diameter and mass
@ -159,7 +159,7 @@ ellipsoidal particles:
The advantage of these fixes is that those which thermostat the
particles include the rotational degrees of freedom in the temperature
calculation and thermostatting. The "fix langevin"_fix_langevin
calculation and thermostatting. The "fix langevin"_fix_langevin.html
command can also be used with its {omgea} or {angmom} options to
thermostat the rotational degrees of freedom for spherical or
ellipsoidal particles. Other thermostatting fixes only operate on the
@ -236,7 +236,7 @@ particles are point masses.
Also note that body particles cannot be modeled with the "fix
rigid"_fix_rigid.html command. Body particles are treated by LAMMPS
as single particles, though they can store internal state, such as a
list of sub-particles. Individual body partices are typically treated
list of sub-particles. Individual body particles are typically treated
as rigid bodies, and their motion integrated with a command like "fix
nve/body"_fix_nve_body.html. Interactions between pairs of body
particles are computed via a command like "pair_style

56
doc/src/Howto_spins.txt
View File

@ -9,51 +9,51 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
Magnetic spins :h3
The magnetic spin simualtions are enabled by the SPIN package, whose
The magnetic spin simulations are enabled by the SPIN package, whose
implementation is detailed in "Tranchida"_#Tranchida7.
The model representents the simulation of atomic magnetic spins coupled
to lattice vibrations. The dynamics of those magnetic spins can be used
to simulate a broad range a phenomena related to magneto-elasticity, or
or to study the influence of defects on the magnetic properties of
materials.
The model represents the simulation of atomic magnetic spins coupled
to lattice vibrations. The dynamics of those magnetic spins can be used
to simulate a broad range a phenomena related to magneto-elasticity, or
or to study the influence of defects on the magnetic properties of
materials.
The magnetic spins are interacting with each others and with the
lattice via pair interactions. Typically, the magnetic exchange
interaction can be defined using the
The magnetic spins are interacting with each others and with the
lattice via pair interactions. Typically, the magnetic exchange
interaction can be defined using the
"pair/spin/exchange"_pair_spin_exchange.html command. This exchange
applies a magnetic torque to a given spin, considering the orientation
of its neighboring spins and their relative distances.
It also applies a force on the atoms as a function of the spin
orientations and their associated inter-atomic distances.
of its neighboring spins and their relative distances.
It also applies a force on the atoms as a function of the spin
orientations and their associated inter-atomic distances.
The command "fix precession/spin"_fix_precession_spin.html allows to
apply a constant magnetic torque on all the spins in the system. This
torque can be an external magnetic field (Zeeman interaction), or an
uniaxial magnetic anisotropy.
uniaxial magnetic anisotropy.
A Langevin thermostat can be applied to those magnetic spins using
"fix langevin/spin"_fix_langevin_spin.html. Typically, this thermostat
can be coupled to another Langevin thermostat applied to the atoms
using "fix langevin"_fix_langevin.html in order to simulate
thermostated spin-lattice system.
A Langevin thermostat can be applied to those magnetic spins using
"fix langevin/spin"_fix_langevin_spin.html. Typically, this thermostat
can be coupled to another Langevin thermostat applied to the atoms
using "fix langevin"_fix_langevin.html in order to simulate
thermostatted spin-lattice system.
The magnetic Gilbert damping can also be applied using "fix
langevin/spin"_fix_langevin_spin.html. It allows to either dissipate
the thermal energy of the Langevin thermostat, or to perform a
The magnetic Gilbert damping can also be applied using "fix
langevin/spin"_fix_langevin_spin.html. It allows to either dissipate
the thermal energy of the Langevin thermostat, or to perform a
relaxation of the magnetic configuration toward an equilibrium state.
All the computed magnetic properties can be outputed by two main
commands. The first one is "compute spin"_compute_spin.html, that
enables to evaluate magnetic averaged quantities, such as the total
All the computed magnetic properties can be output by two main
commands. The first one is "compute spin"_compute_spin.html, that
enables to evaluate magnetic averaged quantities, such as the total
magnetization of the system along x, y, or z, the spin temperature, or
the magnetic energy. The second command is "compute
the magnetic energy. The second command is "compute
property/atom"_compute_property_atom.html. It enables to output all the
per atom magnetic quantities. Typically, the orientation of a given
per atom magnetic quantities. Typically, the orientation of a given
magnetic spin, or the magnetic force acting on this spin.
:line
:link(Tranchida7)
[(Tranchida)] Tranchida, Plimpton, Thibaudeau and Thompson,
[(Tranchida)] Tranchida, Plimpton, Thibaudeau and Thompson,
arXiv preprint arXiv:1801.10233, (2018).

13
doc/src/Howto_temperature.txt
View File

@ -7,7 +7,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:line
Calcalate temperature :h3
Calculate temperature :h3
Temperature is computed as kinetic energy divided by some number of
degrees of freedom (and the Boltzmann constant). Since kinetic energy
@ -17,7 +17,10 @@ aggregate motion of particles) and its thermal velocity. The sum of
the two is the particle's total velocity, but the latter is often what
is wanted to compute a temperature.
LAMMPS has several options for computing temperatures, any of which can be used in "thermostatting"_Howto_thermostat.html and "barostatting"_Howto_barostat.html. These "compute commands"_compute.html calculate temperature:
LAMMPS has several options for computing temperatures, any of which
can be used in "thermostatting"_Howto_thermostat.html and
"barostatting"_Howto_barostat.html. These "compute
commands"_compute.html calculate temperature:
"compute temp"_compute_temp.html
"compute temp/sphere"_compute_temp_sphere.html
@ -35,6 +38,6 @@ velocities) that are removed when computing the thermal temperature.
temp/asphere"_compute_temp_asphere.html compute kinetic energy for
finite-size particles that includes rotational degrees of freedom.
They both allow for velocity biases indirectly, via an optional extra
argument which is another temperature compute that subtracts a velocity bias.
This allows the translational velocity of spherical or aspherical
particles to be adjusted in prescribed ways.
argument which is another temperature compute that subtracts a
velocity bias. This allows the translational velocity of spherical or
aspherical particles to be adjusted in prescribed ways.

11
doc/src/Howto_thermostat.txt
View File

@ -43,6 +43,11 @@ nvt/asphere"_fix_nvt_asphere.html thermostat not only translation
velocities but also rotational velocities for spherical and aspherical
particles.
NOTE: A recent (2017) book by "(Daivis and Todd)"_#Daivis-thermostat
discusses use of the SLLOD method and non-equilibrium MD (NEMD)
thermostatting generally, for both simple and complex fluids,
e.g. molecular systems. The latter can be tricky to do correctly.
DPD thermostatting alters pairwise interactions in a manner analogous
to the per-particle thermostatting of "fix
langevin"_fix_langevin.html.
@ -87,3 +92,9 @@ specify them explicitly via the "thermo_style
custom"_thermo_style.html command. Or you can use the
"thermo_modify"_thermo_modify.html command to re-define what
temperature compute is used for default thermodynamic output.
:line
:link(Daivis-thermostat)
[(Daivis and Todd)] Daivis and Todd, Nonequilibrium Molecular Dynamics (book),
Cambridge University Press, https://doi.org/10.1017/9781139017848, (2017).

6
doc/src/Howto_tip3p.txt
View File

@ -10,7 +10,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
TIP3P water model :h3
The TIP3P water model as implemented in CHARMM
"(MacKerell)"_#howto-MacKerell specifies a 3-site rigid water molecule with
"(MacKerell)"_#howto-tip3p specifies a 3-site rigid water molecule with
charges and Lennard-Jones parameters assigned to each of the 3 atoms.
In LAMMPS the "fix shake"_fix_shake.html command can be used to hold
the two O-H bonds and the H-O-H angle rigid. A bond style of
@ -60,6 +60,10 @@ models"_http://en.wikipedia.org/wiki/Water_model.
:line
:link(howto-tip3p)
[(MacKerell)] MacKerell, Bashford, Bellott, Dunbrack, Evanseck, Field,
Fischer, Gao, Guo, Ha, et al, J Phys Chem, 102, 3586 (1998).
:link(Jorgensen1)
[(Jorgensen)] Jorgensen, Chandrasekhar, Madura, Impey, Klein, J Chem
Phys, 79, 926 (1983).

4
doc/src/Howto_tip4p.txt
View File

@ -31,7 +31,7 @@ using the "fix shake"_fix_shake.html command.
These are the additional parameters (in real units) to set for O and H
atoms and the water molecule to run a rigid TIP4P model with a cutoff
"(Jorgensen)"_#Jorgensen1. Note that the OM distance is specified in
"(Jorgensen)"_#Jorgensen5. Note that the OM distance is specified in
the "pair_style"_pair_style.html command, not as part of the pair
coefficients.
@ -107,6 +107,6 @@ models"_http://en.wikipedia.org/wiki/Water_model.
:line
:link(Jorgensen1)
:link(Jorgensen5)
[(Jorgensen)] Jorgensen, Chandrasekhar, Madura, Impey, Klein, J Chem
Phys, 79, 926 (1983).

2
doc/src/Howto_triclinic.txt
View File

@ -200,7 +200,7 @@ used with non-orthogonal basis vectors to define a lattice that will
tile a triclinic simulation box via the
"create_atoms"_create_atoms.html command.
A second use is to run Parinello-Rahman dynamics via the "fix
A second use is to run Parrinello-Rahman dynamics via the "fix
npt"_fix_nh.html command, which will adjust the xy, xz, yz tilt
factors to compensate for off-diagonal components of the pressure
tensor. The analog for an "energy minimization"_minimize.html is

11
doc/src/Howto_viscosity.txt
View File

@ -37,6 +37,11 @@ used to shear the fluid in between them, again with some kind of
thermostat that modifies only the thermal (non-shearing) components of
velocity to prevent the fluid from heating up.
NOTE: A recent (2017) book by "(Daivis and Todd)"_#Daivis-viscosity
discusses use of the SLLOD method and non-equilibrium MD (NEMD)
thermostatting generally, for both simple and complex fluids,
e.g. molecular systems. The latter can be tricky to do correctly.
In both cases, the velocity profile setup in the fluid by this
procedure can be monitored by the "fix ave/chunk"_fix_ave_chunk.html
command, which determines grad(Vstream) in the equation above.
@ -131,3 +136,9 @@ mean-square-displacement formulation for self-diffusivity. The
time-integrated momentum fluxes play the role of Cartesian
coordinates, whose mean-square displacement increases linearly
with time at sufficiently long times.
:line
:link(Daivis-viscosity)
[(Daivis and Todd)] Daivis and Todd, Nonequilibrium Molecular Dynamics (book),
Cambridge University Press, https://doi.org/10.1017/9781139017848, (2017).

65
doc/src/Install.txt Normal file
View File

@ -0,0 +1,65 @@
"Previous Section"_Intro.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc - "Next Section"_Build.html
:c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Install LAMMPS :h2
You can download LAMMPS as an executable or as source code.
With source code, you also have to "build LAMMPS"_Build.html. But you
have more flexibility as to what features to include or exclude in the
build. If you plan to "modify or extend LAMMPS"_Modify.html, then you
need the source code.
<!-- RST
.. toctree::
:maxdepth: 1
Install_linux
Install_mac
Install_windows
Install_tarball
Install_git
Install_svn
Install_patch
END_RST -->
<!-- HTML_ONLY -->
"Download an executable for Linux"_Install_linux.html
"Download an executable for Mac"_Install_mac.html
"Download an executable for Windows"_Install_windows.html :all(b)
"Download source as a tarball"_Install_tarball.html
"Donwload source via Git"_Install_git.html
"Donwload source via SVN"_Install_svn.html
"Install patch files"_Install_patch.html :all(b)
<!-- END_HTML_ONLY -->
These are the files and sub-directories in the LAMMPS distribution:
README: text file
LICENSE: GNU General Public License (GPL)
bench: benchmark problems
cmake: CMake build files
doc: documentation
examples: simple test problems
lib: additional provided or external libraries
potentials: interatomic potential files
python: Python wrapper on LAMMPS
src: source files
tools: pre- and post-processing tools :tb(s=:,a=l)
You will have all of these if you download source. You will only have
some of them if you download executables, as explained on the pages
listed above.

113
doc/src/Install_git.txt Normal file
View File

@ -0,0 +1,113 @@
"Higher level section"_Install.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Download source via Git :h3
All LAMMPS development is coordinated through the "LAMMPS GitHub
site". If you clone the LAMMPS repository onto your local machine, it
has several advantages:
You can stay current with changes to LAMMPS with a single git
command. :ulb,l
You can create your own development branches to add code to LAMMPS. :l
You can submit your new features back to GitHub for inclusion in
LAMMPS. :l,ule
You must have "Git"_git installed on your system to communicate with
the public Git server for LAMMPS.
IMPORTANT NOTE: As of Oct 2016, the official home of public LAMMPS
development is on GitHub. The previously advertised LAMMPS git
repositories on git.lammps.org and bitbucket.org are now deprecated,
may not be up-to-date, and may go away at any time.
:link(git,http://git-scm.com)
You can follow LAMMPS development on 3 different Git branches:
[stable] : this branch is updated with every stable release
[unstable] : this branch is updated with every patch release
[master] : this branch continuously follows ongoing development :ul
To access the Git repositories on your box, use the clone command to
create a local copy of the LAMMPS repository with a command like:
git clone -b unstable https://github.com/lammps/lammps.git mylammps :pre
where "mylammps" is the name of the directory you wish to create on
your machine and "unstable" is one of the 3 branches listed above.
(Note that you actually download all 3 branches; you can switch
between them at any time using "git checkout <branch name>".)
Once the command completes, your directory will contain the same files
as if you unpacked a current LAMMPS tarball, with the exception, that
the HTML documentation files are not included. They can be fetched
from the LAMMPS website by typing "make fetch" in the doc directory.
Or they can be generated from the content provided in doc/src by
typing "make html" from the the doc directory.
After initial cloning, as bug fixes and new features are added to
LAMMPS, as listed on "this page"_Errors_bugs.html, you can stay
up-to-date by typing the following Git commands from within the
"mylammps" directory:
git checkout unstable # not needed if you always stay in this branch
git checkout stable # use one of the 3 checkout commands
git checkout master
git pull :pre
Doing a "pull" will not change any files you have added to the LAMMPS
directory structure. It will also not change any existing LAMMPS
files you have edited, unless those files have changed in the
repository. In that case, Git will attempt to merge the new
repository file with your version of the file and tell you if there
are any conflicts. See the Git documentation for details.
If you want to access a particular previous release version of LAMMPS,
you can instead "checkout" any version with a published tag. See the
output of "git tag -l" for the list of tags. The Git command to do
this is as follows.
git checkout tagID :pre
Stable versions and what tagID to use for a particular stable version
are discussed on "this page"_Errors_bugs.html. Note that this command
will print some warnings, because in order to get back to the latest
revision and to be able to update with "git pull" again, you first
will need to first type "git checkout unstable" (or check out any
other desired branch).
Once you have updated your local files with a "git pull" (or "git
checkout"), you still need to re-build LAMMPS if any source files have
changed. To do this, you should cd to the src directory and type:
make purge # remove any deprecated src files
make package-update # sync package files with src files
make foo # re-build for your machine (mpi, serial, etc) :pre
just as described on the "Install patch"_Install_patch.html doc page,
after a patch has been installed.
IMPORTANT NOTE: If you wish to edit/change a src file that is from a
package, you should edit the version of the file inside the package
sub-directory with src, then re-install the package. The version in
the src dir is merely a copy and will be wiped out if you type "make
package-update".
IMPORTANT NOTE: The GitHub servers support both the "git://" and
"https://" access protocols for anonymous read-only access. If you
have a correspondingly configured GitHub account, you may also use SSH
with "git@github.com:/lammps/lammps.git".
The LAMMPS GitHub project is managed by Christoph Junghans (LANL,
junghans at lanl.gov), Axel Kohlmeyer (Temple U, akohlmey at
gmail.com) and Richard Berger (Temple U, richard.berger at
temple.edu).

170
doc/src/Install_linux.txt Normal file
View File

@ -0,0 +1,170 @@
"Higher level section"_Install.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Download an executable for Linux :h3
Binaries are available for different versions of Linux:
"Pre-built Ubuntu Linux executables"_#ubuntu
"Pre-built Fedora Linux executables"_#fedora
"Pre-built EPEL Linux executables (RHEL, CentOS)"_#epel
"Pre-built OpenSuse Linux executables"_#opensuse
"Gentoo Linux executable"_#gentoo :all(b)
:line
Pre-built Ubuntu Linux executables :h4,link(ubuntu)
A pre-built LAMMPS executable suitable for running on the latest
Ubuntu Linux versions, can be downloaded as a Debian package. This
allows you to install LAMMPS with a single command, and stay
up-to-date with the current version of LAMMPS by simply updating your
operating system.
To install the appropriate personal-package archive (PPA), do the
following once:
sudo add-apt-repository ppa:gladky-anton/lammps
sudo apt-get update :pre
To install LAMMPS do the following once:
sudo apt-get install lammps-daily :pre
This downloads an executable named "lmp_daily" to your box, which
can then be used in the usual way to run input scripts:
lmp_daily -in in.lj :pre
To update LAMMPS to the most current version, do the following:
sudo apt-get update :pre
which will also update other packages on your system.
To get a copy of the current documentation and examples:
sudo apt-get install lammps-daily-doc :pre
which will download the doc files in
/usr/share/doc/lammps-daily-doc/doc and example problems in
/usr/share/doc/lammps-doc/examples.
Note that you may still wish to download the tarball to get potential
files and auxiliary tools.
To un-install LAMMPS, do the following:
sudo apt-get remove lammps-daily :pre
Note that the lammps-daily executable is built with the following
sequence of make commands, as if you had done the same with the
unpacked tarball files in the src directory:
make yes-all; make no-lib; make openmpi
Thus it builds with FFTW3 and OpenMPI.
Thanks to Anton Gladky (gladky.anton at gmail.com) for setting up this
Ubuntu package capability.
:line
Pre-built Fedora Linux executables :h4,link(fedora)
Pre-built LAMMPS packages for stable releases are available
in the Fedora Linux distribution as of version 28. The packages
can be installed via the dnf package manager. There are 3 basic
varieties (lammps = no MPI, lammps-mpich = MPICH MPI library,
lammps-openmpi = OpenMPI MPI library) and for each support for
linking to the C library interface (lammps-devel, lammps-mpich-devel,
lammps-openmpi-devel), the header for compiling programs using
the C library interface (lammps-headers), and the LAMMPS python
module for Python 3. All packages can be installed at the same
time and the name of the LAMMPS executable is {lmp} and {lmp_openmpi}
or {lmp_mpich} respectively. By default, {lmp} will refer to the
serial executable, unless one of the MPI environment modules is loaded
("module load mpi/mpich-x86_64" or "module load mpi/openmpi-x86_64").
Then the corresponding parallel LAMMPS executable can be used.
The same mechanism applies when loading the LAMMPS python module.
To install LAMMPS with OpenMPI and run an input in.lj with 2 CPUs do:
dnf install lammps-openmpi
module load mpi/openmpi-x86_64
mpirun -np 2 lmp -in in.lj :pre
The "dnf install" command is needed only once. In case of a new LAMMPS
stable release, "dnf update" will automatically update to the newer
version as soon at the RPM files are built and uploaded to the download
mirrors. The "module load" command is needed once per (shell) session
or shell terminal instance, unless it is automatically loaded from the
shell profile.
Please use "lmp -help" to see which compilation options, packages,
and styles are included in the binary.
Thanks to Christoph Junghans (LANL) for making LAMMPS available in Fedora.
:line
Pre-built EPEL Linux executable :h4,link(epel)
Pre-built LAMMPS packages for stable releases are available
in the "Extra Packages for Enterprise Linux (EPEL) repository"_https://fedoraproject.org/wiki/EPEL
for use with Red Hat Enterprise Linux (RHEL) or CentOS version 7.x
and compatible Linux distributions. Names of packages, executable,
and content are the same as described above for Fedora Linux.
But RHEL/CentOS 7.x uses the "yum" package manager instead of "dnf"
in Fedora 28.
Please use "lmp -help" to see which compilation options, packages,
and styles are included in the binary.
Thanks to Christoph Junghans (LANL) for making LAMMPS available in EPEL.
:line
Pre-built OpenSuse Linux executable :h4,link(opensuse)
A pre-built LAMMPS package for stable releases is available
in OpenSuse as of Leap 15.0. You can install the package with:
zypper install lammps :pre
This includes support for OpenMPI. The name of the LAMMPS executable
is {lmp}. Thus to run an input in parallel on 2 CPUs you would do:
mpirun -np 2 lmp -in in.lj :pre
Please use "lmp -help" to see which compilation options, packages,
and styles are included in the binary.
Thanks to Christoph Junghans (LANL) for making LAMMPS available in OpenSuse.
:line
Gentoo Linux executable :h4,link(gentoo)
LAMMPS is part of Gentoo's main package tree and can be installed by
typing:
% emerge --ask lammps :pre
Note that in Gentoo the LAMMPS source is downloaded and the package is
built on the your machine.
Certain LAMMPS packages can be enable via USE flags, type
% equery uses lammps :pre
for details.
Thanks to Nicolas Bock and Christoph Junghans (LANL) for setting up
this Gentoo capability.

56
doc/src/Install_mac.txt Normal file
View File

@ -0,0 +1,56 @@
"Higher level section"_Install.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Download an executable for Mac :h3
LAMMPS can be downloaded, built, and configured for OS X on a Mac with
"Homebrew"_homebrew. Only four of the LAMMPS packages are unavailable
at this time because of additional needs not yet met: KIM, GPU,
USER-INTEL, USER-ATC.
After installing Homebrew, you can install LAMMPS on your system with
the following commands:
% brew tap homebrew/science
% brew install lammps # serial version
% brew install lammps --with-mpi # mpi support :pre
This will install the executable "lammps", a python module named
"lammps", and additional resources with all the standard packages. To
get the location of the additional resources type this:
% brew info lammps :pre
This command also tells you additional installation options available.
The user-packages are available as options, just install them like
this example for the USER-OMP package:
% brew install lammps --enable-user-omp :pre
It is usually best to install LAMMPS with the most up to date source
files, which can be done with the "--HEAD" option:
% brew install lammps --HEAD :pre
To re-install the LAMMPS HEAD, run this command occasionally (make sure
to use the desired options).
% brew install --force lammps --HEAD $\{options\} :pre
Once LAMMPS is installed, you can test the installation with the
Lennard-Jones benchmark file:
% brew test lammps -v :pre
If you have problems with the installation you can post issues to
"this link"_homebrew.
Thanks to Derek Thomas (derekt at cello.t.u-tokyo.ac.jp) for setting
up the Homebrew capability.
:link(homebrew,https://github.com/Homebrew/homebrew-science/issues)

68
doc/src/Install_patch.txt Normal file
View File

@ -0,0 +1,68 @@
"Higher level section"_Install.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Applying patches :h3
It is easy to stay current with the most recent LAMMPS patch releases
if you use Git or SVN to track LAMMPS development. Instructions for
how to stay current are on the "Install git"_Install_git.html and
"Install svn"_Install_svn.html doc pages.
If you prefer to download a tarball, as described on the "Install
git"_Install_tarball.html doc page, you can stay current by
downloading "patch files" when new patch releases are made. A link to
a patch file is posted on the "bug and feature
page"_http://lammps.sandia.gov/bug.html of the LAMMPS website, along
with a list of changed files and details about what is in the new patch
release. This page explains how to apply the patch file to your local
LAMMPS directory.
NOTE: You should not apply patch files to a local Git or SVN repo of
LAMMPS, only to an unpacked tarball. Use Git and SVN commands to
update repo versions of LAMMPS.
Here are the steps to apply a patch file. Note that if your version
of LAMMPS is several patch releases behind, you need to apply all the
intervening patch files in succession to bring your version of LAMMPS
up to date.
Download the patch file. You may have to shift-click in your browser
to download the file instead of display it. Patch files have names
like patch.12Dec16. :ulb,l
Put the patch file in your top-level LAMMPS directory, where the
LICENSE and README files are. :l
Apply the patch by typing the following command from your top-level
LAMMPS directory, where the redirected file is the name of the patch
file. :l
patch -bp1 < patch.12Dec16 :pre
A list of updated files print out to the screen. The -b switch
creates backup files of your originals (e.g. src/force.cpp.orig), so
you can manually undo the patch if something goes wrong. :l
Type the following from the src directory, to enforce consistency
between the src and package directories. This is OK to do even if you
don't use one or more packages. If you are applying several patches
successively, you only need to type this once at the end. The purge
command removes deprecated src files if any were removed by the patch
from package sub-directories. :l
make purge
make package-update :pre
Re-build LAMMPS via the "make" command. :l,ule
IMPORTANT NOTE: If you wish to edit/change a src file that is from a
package, you should edit the version of the file inside the package
sub-dir of src, then re-install the package. The version in the src
dir is merely a copy and will be wiped out if you type "make
package-update".

88
doc/src/Install_svn.txt Normal file
View File

@ -0,0 +1,88 @@
"Higher level section"_Install.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Download source via SVN :h3
IMPORTANT NOTE: As of Oct 2016, SVN support is now implemented via a
git-to-subversion interface service on GitHub and no longer through a
mirror of the internal SVN repository at Sandia.
You must have the "Subversion (SVN) client software"_svn installed on
your system to communicate with the Git server in this mode.
:link(svn,http://subversion.apache.org)
You can follow LAMMPS development on 3 different SVN branches:
[stable] : this branch is updated with every stable release
[unstable] : this branch is updated with every patch release
[master] : this branch continuously follows ongoing development :ul
The corresponding command lines to do an initial checkout are as
follows. (Note that unlike Git, you must perform a separate checkout
into a unique directory for each of the 3 branches.)
svn checkout https://github.com/lammps/lammps.git/branches/unstable mylammps
svn checkout https://github.com/lammps/lammps.git/branches/stable mylammps
svn checkout https://github.com/lammps/lammps.git/trunk mylammps :pre
where "mylammps" is the name of the directory you wish to create on
your machine.
Once the command completes, your directory will contain the same files
as if you unpacked a current LAMMPS tarball, with the exception, that
the HTML documentation files are not included. They can be fetched
from the LAMMPS website by typing "make fetch" in the doc directory.
Or they can be generated from the content provided in doc/src by
typing "make html" from the the doc directory.
After initial checkout, as bug fixes and new features are added to
LAMMPS, as listed on "this page"_Errors_bugs.html, you can stay
up-to-date by typing the following SVN commands from within the
"mylammps" directory:
svn update :pre
You can also check if there are any updates by typing:
svn -qu status :pre
Doing an "update" will not change any files you have added to the
LAMMPS directory structure. It will also not change any existing
LAMMPS files you have edited, unless those files have changed in the
repository. In that case, SVN will attempt to merge the new
repository file with your version of the file and tell you if there
are any conflicts. See the SVN documentation for details.
Please refer to the "subversion client support help pages on
GitHub"_https://help.github.com/articles/support-for-subversion-clients
if you want to use advanced features like accessing particular
previous release versions via tags.
Once you have updated your local files with an "svn update" (or "svn
co"), you still need to re-build LAMMPS if any source files have
changed. To do this, you should cd to the src directory and type:
make purge # remove any deprecated src files
make package-update # sync package files with src files
make foo # re-build for your machine (mpi, serial, etc) :pre
just as described on the "Install patch"_Install_patch.html doc page,
after a patch has been installed.
IMPORTANT NOTE: If you wish to edit/change a src file that is from a
package, you should edit the version of the file inside the package
sub-directory with src, then re-install the package. The version in
the src dir is merely a copy and will be wiped out if you type "make
package-update".
The LAMMPS GitHub project is managed by Christoph Junghans (LANL,
junghans at lanl.gov), Axel Kohlmeyer (Temple U, akohlmey at
gmail.com) and Richard Berger (Temple U, richard.berger at
temple.edu).

68
doc/src/Install_tarball.txt Normal file
View File

@ -0,0 +1,68 @@
"Higher level section"_Install.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Download source and documentation as a tarball :h3
You can download a current LAMMPS tarball from the "download page"_download
of the "LAMMPS website"_lws.
:link(download,http://lammps.sandia.gov/download.html)
:link(bug,http://lammps.sandia.gov/bug.html)
:link(older,http://lammps.sandia.gov/tars)
You have two choices of tarballs, either the most recent stable
release or the most current patch release. Stable releases occur a
few times per year, and undergo more testing before release. Patch
releases occur a couple times per month. The new contents in all
releases are listed on the "bug and feature page"_bug of the website.
Both tarballs include LAMMPS documentation (HTML and PDF files)
corresponding to that version. The download page also has an option
to download the current-version LAMMPS documentation by itself.
Older versions of LAMMPS can also be downloaded from "this
page"_older.
Once you have a tarball, unzip and untar it with the following
command:
tar -xzvf lammps*.tar.gz :pre
This will create a LAMMPS directory with the version date
in its name, e.g. lammps-23Jun18.
:line
You can also download a zip file via the "Clone or download" button on
the "LAMMPS GitHub site"_git. The file name will be lammps-master.zip
which can be unzipped with the following command, to create
a lammps-master dir:
unzip lammps*.zip :pre
This version is the most up-to-date LAMMPS development version. It
will have the date of the most recent patch release (see the file
src/version.h). But it will also include any new bug-fixes or
features added since the last patch release. They will be included in
the next patch release tarball.
:link(git,https://github.com/lammps/lammps)
:line
If you download a current LAMMPS tarball, one way to stay current as
new patch tarballs are released, is to download a patch file which you
can apply to your local directory to update it for each new patch
release. (Or of course you could just download the newest tarball
periodically.)
The patch files are posted on the "bug and feature page"_bug of the
website, along with a list of changed files and details about what is
in the new patch release. Instructions for applying a patch file are
on the "Install patch"_Install_patch.html doc page.

52
doc/src/Install_windows.txt Normal file
View File

@ -0,0 +1,52 @@
"Higher level section"_Install.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Commands_all.html)
:line
Download an executable for Windows :h3
Pre-compiled Windows installers which install LAMMPS executables on a
Windows system can be downloaded from this site:
"http://packages.lammps.org/windows.html"_http://packages.lammps.org/windows.html
Note that each installer package has a date in its name, which
corresponds to the LAMMPS version of the same date. Installers for
current and older versions of LAMMPS are available. 32-bit and 64-bit
installers are available, and each installer contains both a serial
and parallel executable. The installer site also explains how to
install the Windows MPI package (MPICH2 from Argonne National Labs),
needed to run in parallel.
The LAMMPS binaries contain all optional packages included in the
source distribution except: KIM, KOKKOS, USER-INTEL, and USER-QMMM.
The serial version also does not include the MPIIO and
USER-LB packages. GPU support is provided for OpenCL.
The installer site also has instructions on how to run LAMMPS under
Windows, once it is installed, in both serial and parallel.
When you download the installer package, you run it on your Windows
machine. It will then prompt you with a dialog, where you can choose
the installation directory, unpack and copy several executables,
potential files, documentation pdfs, selected example files, etc. It
will then update a few system settings (e.g. PATH, LAMMPS_POTENTIALS)
and add an entry into the Start Menu (with references to the
documentation, LAMMPS homepage and more). From that menu, there is
also a link to an uninstaller that removes the files and undoes the
environment manipulations.
Note that to update to a newer version of LAMMPS, you should typically
uninstall the version you currently have, download a new installer,
and go through the install procedure described above. I.e. the same
procedure for installing/updating most Windows programs. You can
install multiple versions of LAMMPS (in different directories), but
only the executable for the last-installed package will be found
automatically, so this should only be done for debugging purposes.
Thanks to Axel Kohlmeyer (Temple U, akohlmey at gmail.com) for setting
up this Windows capability.

2
doc/src/Intro.txt
View File

@ -15,8 +15,10 @@ These pages provide a brief introduction to LAMMPS.
<!-- RST
.. toctree::
:maxdepth: 1
Intro_overview
Manual_version
Intro_features
Intro_nonfeatures
Intro_opensource

367
doc/src/Intro_authors.txt
View File

@ -7,7 +7,7 @@ Documentation"_ld - "LAMMPS Commands"_lc :c
:line
LAMMPS authors :h3
Authors of LAMMPS :h3
The primary LAMMPS developers are at Sandia National Labs and Temple
University:
@ -15,7 +15,8 @@ University:
"Steve Plimpton"_sjp, sjplimp at sandia.gov
Aidan Thompson, athomps at sandia.gov
Stan Moore, stamoor at sandia.gov
Axel Kohlmeyer, akohlmey at gmail.com :ul
Axel Kohlmeyer, akohlmey at gmail.com
Richard Berger, richard.berger at temple.edu :ul
:link(sjp,http://www.cs.sandia.gov/~sjplimp)
@ -24,26 +25,31 @@ and Ray Shan, now at Materials Design.
:line
The following folks are responsible for significant contributions to
the code, or other aspects of the LAMMPS development effort. Many of
the packages they have written are somewhat unique to LAMMPS and the
code would not be as general-purpose as it is without their expertise
and efforts.
The "Authors page"_http://lammps.sandia.gov/authors.html of the
"LAMMPS website"_lws has a comprehensive list of all the individuals
who have contributed code for a new feature or command or tool to
LAMMPS.
Axel Kohlmeyer (Temple U), akohlmey at gmail.com, SVN and Git repositories, indefatigable mail list responder, USER-CG-CMM, USER-OMP, USER-COLVARS, USER-MOLFILE, USER-QMMM packages
:line
The following folks deserve special recognition. Many of the packages
they have written are unique for an MD code and LAMMPS would not be as
general-purpose as it is without their expertise and efforts.
Metin Aktulga (MSU), USER-REAXC package for C version of ReaxFF
Mike Brown (Intel), GPU and USER-INTEL packages
Colin Denniston (U Western Ontario), USER-LB package
Georg Ganzenmuller (EMI), USER-SMD and USER-SPH packages
Andres Jaramillo-Botero (Caltech), USER-EFF package for electron force field
Reese Jones (Sandia) and colleagues, USER-ATC package for atom/continuum coupling
Christoph Kloss (DCS Computing), LIGGGHTS code for granular materials, built on top of LAMMPS
Rudra Mukherjee (JPL), POEMS package for articulated rigid body motion
Trung Ngyuen (Northwestern U), GPU and RIGID and BODY packages
Mike Parks (Sandia), PERI package for Peridynamics
Roy Pollock (LLNL), Ewald and PPPM solvers
Mike Brown (ORNL), brownw at ornl.gov, GPU and USER-INTEL packages
Greg Wagner (Sandia), gjwagne at sandia.gov, MEAM package for MEAM potential
Mike Parks (Sandia), mlparks at sandia.gov, PERI package for Peridynamics
Rudra Mukherjee (JPL), Rudranarayan.M.Mukherjee at jpl.nasa.gov, POEMS package for articulated rigid body motion
Reese Jones (Sandia) and collaborators, rjones at sandia.gov, USER-ATC package for atom/continuum coupling
Ilya Valuev (JIHT), valuev at physik.hu-berlin.de, USER-AWPMD package for wave-packet MD
Christian Trott (U Tech Ilmenau), christian.trott at tu-ilmenau.de, USER-CUDA and KOKKOS packages
Andres Jaramillo-Botero (Caltech), ajaramil at wag.caltech.edu, USER-EFF package for electron force field
Christoph Kloss (JKU), Christoph.Kloss at jku.at, USER-LIGGGHTS package for granular models and granular/fluid coupling
Metin Aktulga (LBL), hmaktulga at lbl.gov, USER-REAXC package for C version of ReaxFF
Georg Gunzenmueller (EMI), georg.ganzenmueller at emi.fhg.de, USER-SMD and USER-SPH packages
Colin Denniston (U Western Ontario), cdennist at uwo.ca, USER-LB package :ul
Christian Trott (Sandia), USER-CUDA and KOKKOS packages
Ilya Valuev (JIHT), USER-AWPMD package for wave packet MD
Greg Wagner (Northwestern U), MEAM package for MEAM potential :ul
:line
@ -52,328 +58,9 @@ page"_http://lammps.sandia.gov/history.html of the website, LAMMPS
originated as a cooperative project between DOE labs and industrial
partners. Folks involved in the design and testing of the original
version of LAMMPS were the following:
John Carpenter (Mayo Clinic, formerly at Cray Research)
Terry Stouch (Lexicon Pharmaceuticals, formerly at Bristol Myers Squibb)
Steve Lustig (Dupont)
Jim Belak and Roy Pollock (LLNL) :ul
:line
:line
Here is a timeline for when various individuals contributed to a new
feature or command or tool added to LAMMPS:
Jul18 : DEM polygonal and polyhedron particles : Trung Nguyen (Northwestern U)
Jun18 : SPIN package : Julien Tranchida (Sandia and CEA)
Jun18 : compute entropy/atom : Pablo Piaggi (EPLF, Switzerland)
May18 : fix bond/react : Jake Gissinger (CU Boulder)
Apr18 : USER-BOCS package : Nicholas Dunn and Michael DeLyser (Penn State U)
Mar18: pair coul/shield, kolmogorov/crespi/full, ilp/graphene/hbn : Wengen Ouyang (Tel Aviv U)
Feb18 : pair lj/cut/coul/wolf : Vishal Boddu (U of Erlangen-Nuremberg)
Feb18 : USER-MOFFF package : Hendrik Heenen (Technical U of Munich) and Rochus Schmid (Ruhr-University Bochum)
Feb18 : pair ufm : Rodolfo Paula Leite and Maurice de Koning (Unicamp/Brazil)
Dec17 : fix python/move : Richard Berger (Temple U)
Nov17 : pair extep : Jaap Kroes (Radboud U)
Oct17 : USER-UEF package : David Nicholson (MIT)
Oct17 : fix rhok : Ulf Pederson (Roskilde U)
Oct17 : bond gromos : Axel Kohlmeyer (Temple U)
Oct17 : pair born/coul/wolf/cs and coul/wolf/cs : Vishal Boddu
Sep17 : fix latte : Christian Negre (LANL)
Sep17 : temper_npt : Amulya Pervaje and Cody Addington (NCSU)
Aug17 : USER-MESO package : Zhen Li (Brown University)
Aug17 : compute aggregate/atom & fragment/atom : Axel Kohlmeyer (Temple U)
Jul17 : pair meam/c : Sebastian Hutter (Otto-von-Guericke University)
Jun17 : pair reaxc/omp : Metin Aktulga (MSU) and Axel Kohlmeyer (Temple U)
Jun17 : pair vashishita/gpu : Anders Hafreager (UiO)
Jun17 : kspace pppm/disp/intel and pair lj/long/coul/long/intel : Mike Brown (Intel) and William McDoniel (RWTH Aachen U)
Jun17 : compute cnp/atom : Paulo Branicio (USC)
May17 : fix python and pair python : Richard Berger (Temple U)
May17 : pair edip/multi : Chao Jiang (U Wisconsin)
May17 : pair gw and gw/zbl : German Samolyuk (ORNL)
Mar17 : pair charmm fsw and fsh : Robert Meissner & Lucio Colombi Ciacchi (Bremen U), Robert Latour (Clemson U)
Mar17 : pair momb : Ya Zhou, Kristen Fichthorn, and Tonnam Balankura (PSU)
Mar17 : fix filter/corotate : Lukas Fath (KIT)
Mar17 : pair kolmogorov/crespi/z : Jaap Kroes (Radboud Universiteit)
Feb17 : Kokkos versions of the class2 bond/angle/dihedral/improper : Ray Shan (Materials Design)
Jan17 : USER-CGDNA package : Oliver Henrich (U Edinburgh)
Jan17 : fix mscg : Lauren Abbott (Sandia)
Nov16 : temper/grem and fix grem : David Stelter (BU), Edyta Malolepsza (Broad Institute), Tom Keyes (BU)
Nov16 : pair agni : Axel Kohlmeyer (Temple U) and Venkatesh Botu
Nov16 : pair tersoff/mod.c : Ganga P Purja Pun (George Mason University)
Nov16 : pair born/coul/dsf and pair born/coul/dsf/cs : Ariel Lozano
Nov16 : fix reaxc/species/kk & fix reaxc/bonds/kk : Stan Moore (Sandia)
Oct16 : fix wall/gran/region : Dan Bolintineanu (Sandia)
Sep16 : weight options for balance & fix balance : Axel Kohlmeyer (Temple U) & Iain Bethune (EPCC)
Sep16 : fix cmap : Xiaohu Hu (ORNL), David Hyde-Volpe & Tigran Abramyan & Robert Latour (Clemson U), Chris Lorenz (Kings College, London)
Sep16 : pair vashishta/table : Anders Hafreager (U Oslo)
Sep16 : kspace pppm/kk : Stan Moore (Sandia)
Aug16 : fix flow/gauss : Steve Strong and Joel Eaves (U Colorado)
Aug16 : fix controller : Aidan Thompson (Sandia)
Jul16 : dipole integration by DLM method : Iain Bethune (EPCC)
Jul16 : dihedral spherical : Andrew Jewett
Jun16 : pair reax/c/kk : Ray Shan (Materials Design), Stan Moore (Sandia)
Jun16 : fix orient/bcc : Tegar Wicaksono (UBC)
Jun16 : fix ehex : Peter Wirnsberger (University of Cambridge)
Jun16 : reactive DPD extensions to USER-DPD : James Larentzos (ARL), Timothy Mattox (Engility Corp), John Brennan (ARL), Christopher Stone (Computational Science & Engineering, LLC)
May16 : USER-MANIFOLD package : Stefan Paquay (Eindhoven U of Tech, The Netherlands)
Apr16 : write_coeff : Axel Kohlmeyer (Temple U)
Apr16 : pair morse/soft : Stefan Paquay (Eindhoven U of Tech, The Netherlands)
Apr16 : compute dipole/chunk : Axel Kohlmeyer (Temple U)
Apr16 : bond write : Axel Kohlmeyer (Temple U)
Mar16 : pair morse/smooth/linear : Stefan Paquay (Eindhoven U of Tech, The Netherlands)
Feb16 : pair/bond/angle/dihedral/improper zero : Carsten Svaneborg (SDU)
Feb16 : dump custom/vtk : Richard Berger (JKU) and Daniel Queteschiner (DCS Computing)
Feb16 : fix (nvt/npt/nph)/body and compute temp/body : Trung Nguyen
Feb16 : USER-DPD package : James Larentzos (ARL), Timothy Mattox (Engility Corp), John Brennan (ARL)
Dec15 : fix qeq/fire : Ray Shan (Sandia)
Dec15 : pair lj/mdf, pair lennard/mdf, pair buck/mdf, improper distance : Paolo Raiteri (Curtin University)
Nov15 : compute orientorder/atom : Aidan Thompson (Sandia) and Axel Kohlmeyer (U Temple)
Nov15 : compute hexorder/atom : Aidan Thompson (Sandia)
Oct15 : displace_atoms variable option : Reese Jones (Sandia)
Oct15 : pair mgpt & USER-MGPT package : Tomas Oppelstrup and John Moriarty (LLNL)
Oct15 : pair smtbq & USER-SMTBQ package : Nicolas Salles, Emile Maras, Olivier Politano, and Robert Tetot (LAAS-CNRS)
Oct15 : fix ave/correlate/long command : Jorge Ramirez (UPM) and Alexei Likhtman (U Reading)
Oct15 : pair vashishta command : Aidan Thompson (Sandia) and Yongnan Xiong (HNU)
Aug15 : USER-TALLY package : Axel Kohlmeyer (Temple U)
Aug15 : timer command : Axel Kohlmeyer (Temple U)
Aug15 : USER-H5MD package : Pierre de Buyl (KU Leuven)
Aug15 : COMPRESS package : Axel Kohlmeyer (Temple U)
Aug15 : USER-SMD package : Georg Gunzenmueller (EMI)
Jul15 : new HTML format for "doc pages"_Manual.html with search option : Richard Berger (JKU)
Jul15 : rRESPA with pair hybrid : Sam Genheden (U of Southampton)
Jul15 : pair_modify special : Axel Kohlmeyer (Temple U)
Jul15 : pair polymorphic : Xiaowang Zhou and Reese Jones (Sandia)
Jul15 : USER-DRUDE package : Alain Dequidt and Agilio Padua (U Blaise Pascal Clermont-Ferrand) and Julien Devemy (CNRS)
Jul15 : USER-QTB package : Yuan Shen, Tingting Qi, and Evan Reed (Stanford U)
Jul15 : USER-DIFFRACTION package : Shawn Coleman (ARL)
Mar15 : fix temp/csld : Axel Kohlmeyer (Temple U)
Mar15 : CORESHELL package : Hendrik Heenen (Technical University of Munich)
Feb15 : pair quip for GAP and other potentials : Albert Bartok-Partay (U Cambridge)
Feb15 : pair coul/streitz for Streitz-Mintmire potential : Ray Shan (Sandia)
Feb15 : fix tfmc : Kristof Bal (U of Antwerp)
Feb15 : fix ttm/mod : Sergey Starikov and Vasily Pisarev (JIHT of RAS)
Jan15 : fix atom/swap for MC swaps of atom types/charge : Paul Crozier (Sandia)
Nov14 : fix pimd for path-integral MD : Chris Knight and Yuxing Peng (U Chicago)
Nov14 : fix gle and fix ipi for path-integral MD : Michele Ceriotti (EPFL)
Nov14 : pair style srp : Tim Sirk (ARL) and Pieter in 't Veld (BASF)
Nov14 : fix ave/spatial/sphere : Niall Jackson (Imperial College)
Sep14 : QEQ package and several fix qeq/variant styles : Ray Shan (Sandia)
Sep14 : SNAP package and pair style : Aidan Thompson (Sandia) and collaborators
Aug14 : USER-INTEL package : Mike Brown (Intel)
May14 : KOKKOS pacakge : Christian Trott and Carter Edwards (Sandia)
May14 : USER-FEP pacakge : Agilio Padua (U Blaise Pascal Clermont-Ferrand)
Apr14 : fix rigid/small NVE/NVT/NPH/NPT : Trung Nguyen (ORNL)
Apr14 : fix qmmm for QM/MM coupling : Axel Kohlmeyer (Temple U)
Mar14 : kspace_modify collective for faster FFTs on BG/Q : Paul Coffman (IBM)
Mar14 : fix temp/csvr and fix oneway : Axel Kohlmeyer (Temple U)
Feb14 : pair peri/eps, compute dilatation/atom, compute plasticity/atom : Rezwanur Rahman and John Foster (UTSA)
Jan14 : MPI-IO options for dump and restart files : Paul Coffman (IBM)
Nov13 : USER-LB package for Lattice Boltzmann : Francis Mackay and Colin Denniston (U Western Ontario)
Nov13 : fix ti/rs and ti/spring : Rodrigo Freitas (UC Berkeley)
Nov13 : pair comb3 : Ray Shan (Sandia), Tao Liang and Dundar Yilmaz (U Florida)
Nov13 : write_dump and dump movie : Axel Kohlmeyer (Temple U)
Sep13 : xmgrace tool : Vikas Varshney
Sep13 : pair zbl : Aidan Thompson and Stephen Foiles (Sandia)
Aug13 : pair nm and variants : Julien Devemy (ICCF)
Aug13 : fix wall/lj1043 : Jonathan Lee (Sandia)
Jul13 : pair peri/ves : Rezwan Rahman, JT Foster (U Texas San Antonio)
Jul13 : pair tersoff/mod : Vitaly Dozhdikov (JIHT of RAS)
Jul13 : compute basal/atom : Christopher Barrett,(Mississippi State)
Jul13 : polybond tool : Zachary Kraus (Georgia Tech)
Jul13 : fix gld : Stephen Bond and Andrew Baczewski (Sandia)
Jun13 : pair nb3b/harmonic : Todd Zeitler (Sandia)
Jun13 : kspace_style pppm/stagger : Stan Moore (Sandia)
Jun13 : fix tune/kspace : Paul Crozier (Sandia)
Jun13 : long-range point dipoles : Stan Moore (Sandia) and Pieter in 't Veld (BASF)
May13 : compute msd/nongauss : Rob Hoy
May13 : pair list : Axel Kohlmeyer (Temple U)
May13 : triclinic support for long-range solvers : Stan Moore (Sandia)
Apr13 : dump_modify nfile and fileper : Christopher Knight
Mar13 : fix phonon : Ling-Ti Kong (Shanghai Jiao Tong University)
Mar13 : pair_style lj/cut/tip4p/cut : Pavel Elkind (Gothenburg University)
Feb13 : immediate variables in input script : Daniel Moller (Autonomous University of Barcelona)
Feb13 : fix species : Ray Shan (Sandia)
Jan13 : compute voronoi/atom : Daniel Schwen
Nov12 : pair_style mie/cut : Cassiano Aimoli Petrobras (U Notre Dame)
Oct12 : pair_style meam/sw/spline : Robert Rudd (LLNL)
Oct12 : angle_style fourier and fourier/simple and quartic : Loukas Peristeras (Scienomics)
Oct12 : dihedral_style fourier and nharmonic and quadratic : Loukas Peristeras (Scienomics)
Oct12 : improper_style fourier : Loukas Peristeras (Scienomics)
Oct12 : kspace_style pppm/disp for 1/r^6 : Rolf Isele-Holder (Aachen University)
Oct12 : moltemplate molecular builder tool : Andrew Jewett (UCSB)
Sep12 : pair_style lj/cut/coul/dsf and coul/dsf : Trung Nguyen (ORNL)
Sep12 : multi-level summation long-range solver : Stan Moore, Stephen Bond, and Paul Crozier (Sandia)
Aug12 : fix rigid/npt and fix rigid/nph : Trung Nguyen (ORNL)
Aug12 : Fortran wrapper on lib interface : Karl Hammond (UT, Knoxville)
Aug12 : kspace_modify diff for 2-FFT PPPM : Rolf Isele-Holder (Aachen University), Stan Moore (BYU), Paul Crozier (Sandia)
Jun12 : pair_style bop : Don Ward and Xiaowang Zhou (Sandia)
Jun12 : USER-MOLFILE package : Axel Kohlmeyer (U Temple)
Jun12 : USER-COLVARS package : Axel Kohlmeyer (U Temple)
May12 : read_dump : Tim Sirk (ARL)
May12 : improper_style cossq and ring : Georgios Vogiatzis (CoMSE, NTU Athens)
May12 : pair_style lcbop : Dominik Wojt (Wroclaw University of Technology)
Feb12 : PPPM per-atom energy/virial : Stan Moore (BYU)
Feb12 : Ewald per-atom energy/virial : German Samolyuk (ORNL), Stan Moore (BYU)
Feb12 : minimize forcezero linesearch : Asad Hasan (CMU)
Feb12 : pair_style beck : Jon Zimmerman (Sandia)
Feb12 : pair_style meam/spline : Alex Stukowski (LLNL)
Jan12 : pair_style kim : Valeriu Smirichinski, Ryan Elliott, Ellad Tadmor (U Minn)
Jan12 : dihedral_style table : Andrew Jewett (UCSB)
Jan12 : angle_style dipole : Mario Orsi
Jan12 : pair_style lj/smooth/linear : Jon Zimmerman (Sandia)
Jan12 : fix reax/c/bond : Tzu-Ray Shan (Sandia)
Dec11 : pair_style coul/wolf : Yongfeng Zhang (INL)
Dec11 : run_style verlet/split : Yuxing Peng and Chris Knight (U Chicago)
Dec11 : pair_style tersoff/table : Luca Ferraro (CASPUR)
Nov11 : per-atom energy/stress for reax/c : Tzu-Ray Shan (Sandia)
Oct11 : Fast Lubrication Dynamics (FLD) package: Amit Kumar, Michael Bybee, Jonathan Higdon (UIUC)
Oct11 : USER-OMP package : Axel Kohlmeyer (Temple U)
Sep11 : pair_style edip : Luca Ferraro (CASPUR)
Aug11 : USER-SPH package : Georg Ganzenmuller (FIHSD, EMI, Germany)
Aug11 : fix restrain : Craig Tenney (Sandia)
Aug11 : USER-CUDA package : Christian Trott (U Tech Ilmenau)
Aug11 : pair_style lj/sf : Laurent Joly (U Lyon)
Aug11 : bond_style harmonic/shift and harmonic/shift/cut : Carsten Svaneborg
Aug11 : angle_style cosine/shift and cosine/shift/exp : Carsten Svaneborg
Aug11 : dihedral_style cosine/shift/exp : Carsten Svaneborg
Aug11 : pair_style dipole/sf : Mario Orsi
Aug11 : fix addtorque and compute temp/rotate : Laurent Joly (U Lyon)
Aug11 : FFT support via FFTW3, MKL, ACML, KISSFFT libraries : \
Axel Kohlmeyer (Temple U)
Jun11 : pair_style adp : Chris Weinberger (Sandia), Stephen Foiles (Sandia), \
Chandra Veer Singh (Cornell)
Jun11 : Windows build option via Microsoft Visual Studio : \
Ilya Valuev (JIHT, Moscow, Russia)
Jun11 : antisymmetrized wave packet MD : Ilya Valuev (JIHT, Moscow, Russia)
Jun11 : dump image : Nathan Fabian (Sandia)
May11 : pppm GPU single and double : Mike Brown (ORNL)
May11 : pair_style lj/expand/gpu : Inderaj Bains (NVIDIA)
2010 : pair_style reax/c and fix qeq/reax : Metin Aktulga (Purdue, now LBNL)
- : DREIDING force field, pair_style hbond/dreiding, etc : Tod Pascal (Caltech)
- : fix adapt and compute ti for thermodynamic integration for \
free energies : Sai Jayaraman (Sandia)
- : pair_style born and gauss : Sai Jayaraman (Sandia)
- : stochastic rotation dynamics (SRD) via fix srd : \
Jeremy Lechman (Sandia) and Pieter in 't Veld (BASF)
- : ipp Perl script tool : Reese Jones (Sandia)
- : eam_database and createatoms tools : Xiaowang Zhou (Sandia)
- : electron force field (eFF) : Andres Jaramillo-Botero and Julius Su (Caltech)
- : embedded ion method (EIM) potential : Xiaowang Zhou (Sandia)
- : COMB potential with charge equilibration : Tzu-Ray Shan (U Florida)
- : fix ave/correlate : Benoit Leblanc, Dave Rigby, \
Paul Saxe (Materials Design) and Reese Jones (Sandia)
- : pair_style peri/lps : Mike Parks (Sandia)
- : fix msst : Lawrence Fried (LLNL), Evan Reed (LLNL, Stanford)
- : thermo_style custom tpcpu & spcpu keywords : Axel Kohlmeyer (Temple U)
- : fix rigid/nve, fix rigid/nvt : Tony Sheh and Trung Dac Nguyen (U Michigan)
- : public SVN & Git repositories for LAMMPS : \
Axel Kohlmeyer (Temple U) and Bill Goldman (Sandia)
- : compute heat/flux : German Samolyuk (ORNL) and \
Mario Pinto (Computational Research Lab, Pune, India)
- : pair_style yukawa/colloid : Randy Schunk (Sandia)
- : fix wall/colloid : Jeremy Lechman (Sandia)
2009 : fix imd for real-time viz and interactive MD : Axel Kohlmeyer (Temple Univ)
- : concentration-dependent EAM potential : \
Alexander Stukowski (Technical University of Darmstadt)
- : parallel replica dymamics (PRD) : Mike Brown (Sandia)
- : min_style hftn : Todd Plantenga (Sandia)
- : fix atc : Reese Jones, Jon Zimmerman, Jeremy Templeton (Sandia)
- : dump cfg : Liang Wan (Chinese Academy of Sciences)
- : fix nvt with Nose/Hoover chains : Andy Ballard (U Maryland)
- : pair_style lj/cut/gpu, pair_style gayberne/gpu : Mike Brown (Sandia)
- : pair_style lj96/cut, bond_style table, angle_style table : Chuanfu Luo
- : fix langevin tally : Carolyn Phillips (U Michigan)
- : compute heat/flux for Green-Kubo : Reese Jones (Sandia), \
Philip Howell (Siemens), Vikas Varsney (AFRL)
- : region cone : Pim Schravendijk
- : pair_style born/coul/long : Ahmed Ismail (Sandia)
- : fix ttm : Paul Crozier (Sandia) and Carolyn Phillips (U Michigan)
- : fix box/relax : Aidan Thompson and David Olmsted (Sandia)
- : ReaxFF potential : Aidan Thompson (Sandia) and Hansohl Cho (MIT)
- : compute cna/atom : Liang Wan (Chinese Academy of Sciences)
2008 : Tersoff/ZBL potential : Dave Farrell (Northwestern U)
- : peridynamics : Mike Parks (Sandia)
- : fix smd for steered MD : Axel Kohlmeyer (U Penn)
- : GROMACS pair potentials : Mark Stevens (Sandia)
- : lmp2vmd tool : Axel Kohlmeyer (U Penn)
- : compute group/group : Naveen Michaud-Agrawal (Johns Hopkins U)
- : USER-CG-CMM package for coarse-graining : Axel Kohlmeyer (U Penn)
- : cosine/delta angle potential : Axel Kohlmeyer (U Penn)
- : VIM editor add-ons for LAMMPS input scripts : Gerolf Ziegenhain
- : pair_style lubricate : Randy Schunk (Sandia)
- : compute ackland/atom : Gerolf Ziegenhain
- : kspace_style ewald/n, pair_style lj/coul, pair_style buck/coul : \
Pieter in 't Veld (Sandia)
- : AI-REBO bond-order potential : Ase Henry (MIT)
- : making LAMMPS a true "object" that can be instantiated \
multiple times, e.g. as a library : Ben FrantzDale (RPI)
- : pymol_asphere viz tool : Mike Brown (Sandia)
2007 : NEMD SLLOD integration : Pieter in 't Veld (Sandia)
- : tensile and shear deformations : Pieter in 't Veld (Sandia)
- : GayBerne potential : Mike Brown (Sandia)
- : ellipsoidal particles : Mike Brown (Sandia)
- : colloid potentials : Pieter in 't Veld (Sandia)
- : fix heat : Paul Crozier and Ed Webb (Sandia)
- : neighbor multi and communicate multi : Pieter in 't Veld (Sandia)
- : MATLAB post-processing scripts : Arun Subramaniyan (Purdue)
- : triclinic (non-orthogonal) simulation domains : Pieter in 't Veld (Sandia)
- : thermo_extract tool: Vikas Varshney (Wright Patterson AFB)
- : fix ave/time and fix ave/spatial : Pieter in 't Veld (Sandia)
- : MEAM potential : Greg Wagner (Sandia)
- : optimized pair potentials for lj/cut, charmm/long, eam, morse : \
James Fischer (High Performance Technologies), \
David Richie and Vincent Natoli (Stone Ridge Technologies)
2006 : fix wall/lj126 : Mark Stevens (Sandia)
- : Stillinger-Weber and Tersoff potentials : \
Aidan Thompson and Xiaowang Zhou (Sandia)
- : region prism : Pieter in 't Veld (Sandia)
- : fix momentum and recenter : Naveen Michaud-Agrawal (Johns Hopkins U)
- : multi-letter variable names : Naveen Michaud-Agrawal (Johns Hopkins U)
- : OPLS dihedral potential: Mark Stevens (Sandia)
- : POEMS coupled rigid body integrator: Rudranarayan Mukherjee (RPI)
- : faster pair hybrid potential: James Fischer \
(High Performance Technologies, Inc), Vincent Natoli and \
David Richie (Stone Ridge Technology)
- : breakable bond quartic potential: Chris Lorenz and Mark Stevens (Sandia)
- : DCD and XTC dump styles: Naveen Michaud-Agrawal (Johns Hopkins U)
- : grain boundary orientation fix : Koenraad Janssens and \
David Olmsted (Sandia)
- : pair_style lj/smooth potential : Craig Maloney (UCSB)
- : radius-of-gyration spring fix : Naveen Michaud-Agrawal \
(Johns Hopkins U) and Paul Crozier (Sandia)
- : self spring fix : Naveen Michaud-Agrawal (Johns Hopkins U)
- : EAM CoAl and AlCu potentials : Kwang-Reoul Lee (KIST, Korea)
- : cosine/squared angle potential : Naveen Michaud-Agrawal (Johns Hopkins U)
- : helix dihedral potential : Naveen Michaud-Agrawal (Johns Hopkins U) and \
Mark Stevens (Sandia)
- : Finnis/Sinclair EAM: Tim Lau (MIT)
- : dissipative particle dynamics (DPD) potentials: Kurt Smith (U Pitt) and \
Frank van Swol (Sandia)
- : TIP4P potential (4-site water): Ahmed Ismail and \
Amalie Frischknecht (Sandia)
2005 : uniaxial strain fix: Carsten Svaneborg (Max Planck Institute)
- : compressed dump files: Erik Luijten (U Illinois)
- : cylindrical indenter fix: Ravi Agrawal (Northwestern U)
- : electric field fix: Christina Payne (Vanderbilt U)
- : AMBER <-> LAMMPS tool: Keir Novik (Univ College London) and \
Vikas Varshney (U Akron)
- : CHARMM <-> LAMMPS tool: Pieter in 't Veld and Paul Crozier (Sandia)
- : Morse bond potential: Jeff Greathouse (Sandia)
- : radial distribution functions: Paul Crozier & Jeff Greathouse (Sandia)
- : force tables for long-range Coulombics: Paul Crozier (Sandia)
2004 : targeted molecular dynamics (TMD): Paul Crozier (Sandia) and \
Christian Burisch (Bochum University, Germany)
- : FFT support for SGI SCLS (Altix): Jim Shepherd (Ga Tech)
- : lmp2cfg and lmp2traj tools: Ara Kooser, Jeff Greathouse, \
Andrey Kalinichev (Sandia)
- : parallel tempering: Mark Sears (Sandia)
earlier : granular force fields and BC: Leo Silbert & Gary Grest (Sandia)
- : multi-harmonic dihedral potential: Mathias Putz (Sandia)
- : embedded atom method (EAM) potential: Stephen Foiles (Sandia)
- : msi2lmp tool: Steve Lustig (Dupont), Mike Peachey & John Carpenter (Cray)
- : HTFN energy minimizer: Todd Plantenga (Sandia)
- : class 2 force fields: Eric Simon (Cray)
- : NVT/NPT integrators: Mark Stevens (Sandia)
- : rRESPA: Mark Stevens & Paul Crozier (Sandia)
- : Ewald and PPPM solvers: Roy Pollock (LLNL) : :tb(s=:,ca1=c)

16
doc/src/Intro_features.txt
View File

@ -20,7 +20,7 @@ classes of functionality:
"Integrators"_#integrate
"Diagnostics"_#diag
"Output"_#output
"Multi-replica models"_#replica
"Multi-replica models"_#replica1
"Pre- and post-processing"_#prepost
"Specialized features (beyond MD itself)"_#special :ul
@ -40,7 +40,7 @@ General features :h4,link(general)
syntax for defining and using variables and formulas
syntax for looping over runs and breaking out of loops
run one or multiple simulations simultaneously (in parallel) from one script
build as library, invoke LAMMPS thru library interface or provided Python wrapper
build as library, invoke LAMMPS through library interface or provided Python wrapper
couple with other codes: LAMMPS calls other code, other code calls LAMMPS, umbrella code calls both :ul
Particle and model types :h4,link(particle)
@ -68,7 +68,7 @@ commands)
pairwise potentials: Lennard-Jones, Buckingham, Morse, Born-Mayer-Huggins, \
Yukawa, soft, class 2 (COMPASS), hydrogen bond, tabulated
charged pairwise potentials: Coulombic, point-dipole
manybody potentials: EAM, Finnis/Sinclair EAM, modified EAM (MEAM), \
many-body potentials: EAM, Finnis/Sinclair EAM, modified EAM (MEAM), \
embedded ion method (EIM), EDIP, ADP, Stillinger-Weber, Tersoff, \
REBO, AIREBO, ReaxFF, COMB, SNAP, Streitz-Mintmire, 3-body polymorphic
long-range interactions for charge, point-dipoles, and LJ dispersion: \
@ -110,11 +110,11 @@ Atom creation :h4,link(create)
displace atoms :ul
Ensembles, constraints, and boundary conditions :h4,link(ensemble)
("fix"_fix.html command)
("fix"_fix.html command)
2d or 3d systems
orthogonal or non-orthogonal (triclinic symmetry) simulation domains
constant NVE, NVT, NPT, NPH, Parinello/Rahman integrators
constant NVE, NVT, NPT, NPH, Parrinello/Rahman integrators
thermostatting options for groups and geometric regions of atoms
pressure control via Nose/Hoover or Berendsen barostatting in 1 to 3 dimensions
simulation box deformation (tensile and shear)
@ -128,7 +128,7 @@ Ensembles, constraints, and boundary conditions :h4,link(ensemble)
variety of additional boundary conditions and constraints :ul
Integrators :h4,link(integrate)
("run"_run.html, "run_style"_run_style.html, "minimize"_minimize.html commands)
("run"_run.html, "run_style"_run_style.html, "minimize"_minimize.html commands)
velocity-Verlet integrator
Brownian dynamics
@ -142,7 +142,7 @@ Diagnostics :h4,link(diag)
see various flavors of the "fix"_fix.html and "compute"_compute.html commands :ul
Output :h4,link(output)
("dump"_dump.html, "restart"_restart.html commands)
("dump"_dump.html, "restart"_restart.html commands)
log file of thermodynamic info
text dump files of atom coords, velocities, other per-atom quantities
@ -154,7 +154,7 @@ Output :h4,link(output)
time averaging of system-wide quantities
atom snapshots in native, XYZ, XTC, DCD, CFG formats :ul
Multi-replica models :h4,link(replica)
Multi-replica models :h4,link(replica1)
"nudged elastic band"_neb.html
"parallel replica dynamics"_prd.html

71
doc/src/Intro_nonfeatures.txt
View File

@ -13,25 +13,29 @@ LAMMPS is designed to be a fast, parallel engine for molecular
dynamics (MD) simulations. It provides only a modest amount of
functionality for setting up simulations and analyzing their output.
Specifically, LAMMPS does not:
Specifically, LAMMPS was not conceived and designed for:
run thru a GUI
build molecular systems
being run through a GUI
building molecular systems, or building molecular topologies
assign force-field coefficients automagically
perform sophisticated analyses of your MD simulation
perform sophisticated analysis of your MD simulation
visualize your MD simulation interactively
plot your output data :ul
Although over the years these limitations have been somewhat
reduced through features added to LAMMPS or external tools
that either closely interface with LAMMPS or extend LAMMPS.
Here are suggestions on how to perform these tasks:
GUI: LAMMPS can be built as a library and a Python wrapper that wraps
[GUI:] LAMMPS can be built as a library and a Python wrapper that wraps
the library interface is provided. Thus, GUI interfaces can be
written in Python (or C or C++ if desired) that run LAMMPS and
visualize or plot its output. Examples of this are provided in the
python directory and described on the "Python"_Python.html doc
page. :ulb,l
python directory and described on the "Python"_Python_head.html doc
page. Also, there are several external wrappers or GUI front ends. :ulb,l
Builder: Several pre-processing tools are packaged with LAMMPS. Some
[Builder:] Several pre-processing tools are packaged with LAMMPS. Some
of them convert input files in formats produced by other MD codes such
as CHARMM, AMBER, or Insight into LAMMPS input formats. Some of them
are simple programs that will build simple molecular systems, such as
@ -40,41 +44,54 @@ molecular builder that will generate complex molecular models. See
the "Tools"_Tools.html doc page for details on tools packaged with
LAMMPS. The "Pre/post processing
page"_http:/lammps.sandia.gov/prepost.html of the LAMMPS website
describes a variety of 3rd party tools for this task. :l
describes a variety of 3rd party tools for this task. Furthermore,
some LAMMPS internal commands allow to reconstruct, or selectively add
topology information, as well as provide the option to insert molecule
templates instead of atoms for building bulk molecular systems. :l
Force-field assignment: The conversion tools described in the previous
[Force-field assignment:] The conversion tools described in the previous
bullet for CHARMM, AMBER, and Insight will also assign force field
coefficients in the LAMMPS format, assuming you provide CHARMM, AMBER,
or Accelerys force field files. :l
or BIOVIA (formerly Accelrys) force field files. The tools
"ParmEd"_https://parmed.github.io/ParmEd/html/index.html and
"InterMol"_https://github.com/shirtsgroup/InterMol are particularly
powerful and flexible in converting force field and topology data
between various MD simulation programs. :l
Simulation analyses: If you want to perform analyses on-the-fly as
[Simulation analysis:] If you want to perform analysis on-the-fly as
your simulation runs, see the "compute"_compute.html and
"fix"_fix.html doc pages, which list commands that can be used in a
LAMMPS input script. Also see the "Modify"_Modify.html doc page for
info on how to add your own analysis code or algorithms to LAMMPS.
For post-processing, LAMMPS output such as "dump file
snapshots"_dump.html can be converted into formats used by other MD or
post-processing codes. Some post-processing tools packaged with
LAMMPS will do these conversions. Scripts provided with the {python}
tool in the tools directory can extract and massage data in dump files
to make it easier to import into other programs. See the
post-processing codes. To some degree, that conversion can be done
directly inside of LAMMPS by interfacing to the VMD molfile plugins.
The "rerun"_rerun.html command also allows to do some post-processing
of existing trajectories, and through being able to read a variety
of file formats, this can also be used for analyzing trajectories
from other MD codes. Some post-processing tools packaged with
LAMMPS will do these conversions. Scripts provided in the
tools/python directory can extract and massage data in dump files to
make it easier to import into other programs. See the
"Tools"_Tools.html doc page for details on these various options. :l
Visualization: LAMMPS can produce JPG or PNG snapshot images
on-the-fly via its "dump image"_dump_image.html command. For
high-quality, interactive visualization there are many excellent and
free tools available. See the "Other Codes
[Visualization:] LAMMPS can produce NETPBM, JPG or PNG snapshot images
on-the-fly via its "dump image"_dump_image.html command and pass
them to an external program, "FFmpeg"_https://www.ffmpeg.org to generate
movies from them. For high-quality, interactive visualization there are
many excellent and free tools available. See the "Other Codes
page"_http://lammps.sandia.gov/viz.html page of the LAMMPS website for
visualization packages that can use LAMMPS output data. :l
Plotting: See the next bullet about Pizza.py as well as the
"Python"_Python.html doc page for examples of plotting LAMMPS output.
Scripts provided with the {python} tool in the tools directory will
extract and massage data in log and dump files to make it easier to
analyze and plot. See the "Tools"_Tools.html doc page for more
discussion of the various tools. :l
[Plotting:] See the next bullet about Pizza.py as well as the
"Python"_Python_head.html doc page for examples of plotting LAMMPS
output. Scripts provided with the {python} tool in the tools
directory will extract and massage data in log and dump files to make
it easier to analyze and plot. See the "Tools"_Tools.html doc page
for more discussion of the various tools. :l
Pizza.py: Our group has also written a separate toolkit called
[Pizza.py:] Our group has also written a separate toolkit called
"Pizza.py"_http://pizza.sandia.gov which can do certain kinds of
setup, analysis, plotting, and visualization (via OpenGL) for LAMMPS
simulations. It thus provides some functionality for several of the

4
doc/src/Intro_overview.txt
View File

@ -17,7 +17,7 @@ variety of interatomic potentials (force fields) and boundary
conditions. It can model 2d or 3d systems with only a few particles
up to millions or billions.
LAMMPS can be built and run on a laptop or destop machine, but is
LAMMPS can be built and run on a laptop or desktop machine, but is
designed for parallel computers. It will run on any parallel machine
that supports the "MPI"_mpi message-passing library. This includes
shared-memory boxes and distributed-memory clusters and
@ -45,7 +45,7 @@ nature; some long-range models are included as well.
LAMMPS uses neighbor lists to keep track of nearby particles. The
lists are optimized for systems with particles that are repulsive at
short distances, so that the local density of particles never becomes
too large. This is in contrast to methods used for modeling plasmas
too large. This is in contrast to methods used for modeling plasma
or gravitational bodies (e.g. galaxy formation).
On parallel machines, LAMMPS uses spatial-decomposition techniques to

BIN
doc/src/JPG/coul_soft.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 12 KiB

After

Width:  |  Height:  |  Size: 38 KiB

BIN
doc/src/JPG/lj_soft.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 12 KiB

After

Width:  |  Height:  |  Size: 35 KiB

Some files were not shown because too many files have changed in this diff Show More