b0d0037f50
if SSL report an error ("certificate verify failed") during the
handshake and thus refuses further communication with that server,
you can specify your own CA cert path by setting the environment
variable CURL_CA_BUNDLE to the path of your choice.
1420 lines
53 KiB
ReStructuredText
1420 lines
53 KiB
ReStructuredText
Packages with extra build options
|
|
=================================
|
|
|
|
When building with some packages, additional steps may be required,
|
|
in addition to:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D PKG_NAME=yes # CMake
|
|
make yes-name # make
|
|
|
|
as described on the :doc:`Build\_package <Build_package>` doc page.
|
|
|
|
For a CMake build there may be additional optional or required
|
|
variables to set. For a build with make, a provided library under the
|
|
lammps/lib directory may need to be built first. Or an external
|
|
library may need to exist on your system or be downloaded and built.
|
|
You may need to tell LAMMPS where it is found on your system.
|
|
|
|
This is the list of packages that may require additional steps.
|
|
|
|
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
|
|
| :ref:`COMPRESS <compress>` | :ref:`GPU <gpu>` | :ref:`KIM <kim>` | :ref:`KOKKOS <kokkos>` | :ref:`LATTE <latte>` | :ref:`MESSAGE <message>` |
|
|
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
|
|
| :ref:`MSCG <mscg>` | :ref:`OPT <opt>` | :ref:`POEMS <poems>` | :ref:`PYTHON <python>` | :ref:`VORONOI <voronoi>` | :ref:`USER-ADIOS <user-adios>` |
|
|
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
|
|
| :ref:`USER-ATC <user-atc>` | :ref:`USER-AWPMD <user-awpmd>` | :ref:`USER-COLVARS <user-colvars>` | :ref:`USER-H5MD <user-h5md>` | :ref:`USER-INTEL <user-intel>` | :ref:`USER-MOLFILE <user-molfile>` |
|
|
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
|
|
| :ref:`USER-NETCDF <user-netcdf>` | :ref:`USER-PLUMED <user-plumed>` | :ref:`USER-OMP <user-omp>` | :ref:`USER-QMMM <user-qmmm>` | :ref:`USER-QUIP <user-quip>` | :ref:`USER-SCAFACOS <user-scafacos>` |
|
|
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
|
|
| :ref:`USER-SMD <user-smd>` | :ref:`USER-VTK <user-vtk>` | | | | |
|
|
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _compress:
|
|
|
|
COMPRESS package
|
|
-------------------------------
|
|
|
|
To build with this package you must have the zlib compression library
|
|
available on your system.
|
|
|
|
**CMake build**\ :
|
|
|
|
If CMake cannot find the library, you can set these variables:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D ZLIB_INCLUDE_DIR=path # path to zlib.h header file
|
|
-D ZLIB_LIBRARIES=path # path to libz.a (.so) file
|
|
|
|
**Traditional make**\ :
|
|
|
|
If make cannot find the library, you can edit the
|
|
lib/compress/Makefile.lammps file to specify the paths and library
|
|
name.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _gpu:
|
|
|
|
GPU package
|
|
---------------------
|
|
|
|
To build with this package, you must choose options for precision and
|
|
which GPU hardware to build for.
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D GPU_API=value # value = opencl (default) or cuda
|
|
-D GPU_PREC=value # precision setting
|
|
# value = double or mixed (default) or single
|
|
-D OCL_TUNE=value # hardware choice for GPU_API=opencl
|
|
# generic (default) or intel (Intel CPU) or fermi, kepler, cypress (NVIDIA)
|
|
-D GPU_ARCH=value # primary GPU hardware choice for GPU_API=cuda
|
|
# value = sm_XX, see below
|
|
# default is sm_30
|
|
-D CUDPP_OPT=value # optimization setting for GPU_API=cuda
|
|
# enables CUDA Performance Primitives Optimizations
|
|
# value = yes (default) or no
|
|
-D CUDA_MPS_SUPPORT=value # enables some tweaks required to run with active nvidia-cuda-mps daemon
|
|
# value = yes or no (default)
|
|
|
|
GPU\_ARCH settings for different GPU hardware is as follows:
|
|
|
|
* sm\_12 or sm\_13 for GT200 (supported by CUDA 3.2 until CUDA 6.5)
|
|
* sm\_20 or sm\_21 for Fermi (supported by CUDA 3.2 until CUDA 7.5)
|
|
* sm\_30 or sm\_35 or sm\_37 for Kepler (supported since CUDA 5)
|
|
* sm\_50 or sm\_52 for Maxwell (supported since CUDA 6)
|
|
* sm\_60 or sm\_61 for Pascal (supported since CUDA 8)
|
|
* sm\_70 for Volta (supported since CUDA 9)
|
|
* sm\_75 for Turing (supported since CUDA 10)
|
|
|
|
A more detailed list can be found, for example,
|
|
at `Wikipedia's CUDA article <https://en.wikipedia.org/wiki/CUDA#GPUs_supported>`_
|
|
|
|
CMake can detect which version of the CUDA toolkit is used and thus can
|
|
include support for **all** major GPU architectures supported by this toolkit.
|
|
Thus the GPU\_ARCH setting is merely an optimization, to have code for
|
|
the preferred GPU architecture directly included rather than having to wait
|
|
for the JIT compiler of the CUDA driver to translate it.
|
|
|
|
**Traditional make**\ :
|
|
|
|
Before building LAMMPS, you must build the GPU library in lib/gpu.
|
|
You can do this manually if you prefer; follow the instructions in
|
|
lib/gpu/README. Note that the GPU library uses MPI calls, so you must
|
|
use the same MPI library (or the STUBS library) settings as the main
|
|
LAMMPS code. This also applies to the -DLAMMPS\_BIGBIG,
|
|
-DLAMMPS\_SMALLBIG, or -DLAMMPS\_SMALLSMALL settings in whichever
|
|
Makefile you use.
|
|
|
|
You can also build the library in one step from the lammps/src dir,
|
|
using a command like these, which simply invoke the lib/gpu/Install.py
|
|
script with the specified args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-gpu # print help message
|
|
make lib-gpu args="-b" # build GPU library with default Makefile.linux
|
|
make lib-gpu args="-m xk7 -p single -o xk7.single" # create new Makefile.xk7.single, altered for single-precision
|
|
make lib-gpu args="-m mpi -a sm_60 -p mixed -b" # build GPU library with mixed precision and P100 using other settings in Makefile.mpi
|
|
|
|
Note that this procedure starts with a Makefile.machine in lib/gpu, as
|
|
specified by the "-m" switch. For your convenience, machine makefiles
|
|
for "mpi" and "serial" are provided, which have the same settings as
|
|
the corresponding machine makefiles in the main LAMMPS source
|
|
folder. In addition you can alter 4 important settings in the
|
|
Makefile.machine you start from via the corresponding -c, -a, -p, -e
|
|
switches (as in the examples above), and also save a copy of the new
|
|
Makefile if desired:
|
|
|
|
* CUDA\_HOME = where NVIDIA CUDA software is installed on your system
|
|
* CUDA\_ARCH = sm\_XX, what GPU hardware you have, same as CMake GPU\_ARCH above
|
|
* CUDA\_PRECISION = precision (double, mixed, single)
|
|
* EXTRAMAKE = which Makefile.lammps.\* file to copy to Makefile.lammps
|
|
|
|
The file Makefile.linux\_multi is set up to include support for multiple
|
|
GPU architectures as supported by the CUDA toolkit in use. This is done
|
|
through using the "--gencode " flag, which can be used multiple times and
|
|
thus support all GPU architectures supported by your CUDA compiler.
|
|
|
|
If the library build is successful, 3 files should be created:
|
|
lib/gpu/libgpu.a, lib/gpu/nvc\_get\_devices, and
|
|
lib/gpu/Makefile.lammps. The latter has settings that enable LAMMPS
|
|
to link with CUDA libraries. If the settings in Makefile.lammps for
|
|
your machine are not correct, the LAMMPS build will fail, and
|
|
lib/gpu/Makefile.lammps may need to be edited.
|
|
|
|
.. note::
|
|
|
|
If you re-build the GPU library in lib/gpu, you should always
|
|
un-install the GPU package in lammps/src, then re-install it and
|
|
re-build LAMMPS. This is because the compilation of files in the GPU
|
|
package uses the library settings from the lib/gpu/Makefile.machine
|
|
used to build the GPU library.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _kim:
|
|
|
|
KIM package
|
|
---------------------
|
|
|
|
To build with this package, the KIM library with API v2 must be downloaded
|
|
and built on your system. It must include the KIM models that you want to
|
|
use with LAMMPS. If you want to use the :doc:`kim\_query <kim_commands>`
|
|
command, you also need to have libcurl installed with the matching
|
|
development headers and the curl-config tool.
|
|
|
|
See `Obtaining KIM Models <http://openkim.org/doc/usage/obtaining-models>`_ to
|
|
learn how to install a pre-build binary of the OpenKIM Repository of Models.
|
|
See the list of all KIM models here: https://openkim.org/browse/models
|
|
|
|
(Also note that when downloading and installing from source
|
|
the KIM API library with all its models, may take a long time (tens of
|
|
minutes to hours) to build. Of course you only need to do that once.)
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D DOWNLOAD_KIM=value # download OpenKIM API v2 for build, value = no (default) or yes
|
|
-D LMP_DEBUG_CURL=value # set libcurl verbose mode on/off, value = off (default) or on
|
|
-D LMP_NO_SSL_CHECK=value # tell libcurl to not verify the peer, value = no (default) or yes
|
|
|
|
If DOWNLOAD\_KIM is set, the KIM library will be downloaded and built
|
|
inside the CMake build directory. If the KIM library is already on
|
|
your system (in a location CMake cannot find it), set the PKG\_CONFIG\_PATH
|
|
environment variable so that libkim-api can be found.
|
|
|
|
For using KIM web queries.
|
|
|
|
If LMP\_DEBUG\_CURL is set, the libcurl verbose mode will be on, and any
|
|
libcurl calls within the KIM web query display a lot of information about
|
|
libcurl operations. You hardly ever want this set in production use, you will
|
|
almost always want this when you debug/report problems.
|
|
|
|
The libcurl performs peer SSL certificate verification by default. This
|
|
verification is done using a CA certificate store that the SSL library can
|
|
use to make sure the peer's server certificate is valid. If SSL reports an
|
|
error ("certificate verify failed") during the handshake and thus refuses
|
|
further communication with that server, you can set LMP\_NO\_SSL\_CHECK.
|
|
If LMP\_NO\_SSL\_CHECK is set, libcurl does not verify the peer and connection
|
|
succeeds regardless of the names in the certificate. This option is insecure.
|
|
As an alternative, you can specify your own CA cert path by setting the
|
|
environment variable CURL\_CA\_BUNDLE to the path of your choice. A call to the
|
|
KIM web query would get this value from the environmental variable.
|
|
|
|
**Traditional make**\ :
|
|
|
|
You can download and build the KIM library manually if you prefer;
|
|
follow the instructions in lib/kim/README. You can also do it in one
|
|
step from the lammps/src dir, using a command like these, which simply
|
|
invoke the lib/kim/Install.py script with the specified args.
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-kim # print help message
|
|
make lib-kim args="-b " # (re-)install KIM API lib with only example models
|
|
make lib-kim args="-b -a Glue_Ercolessi_Adams_Al__MO_324507536345_001" # ditto plus one model
|
|
make lib-kim args="-b -a everything" # install KIM API lib with all models
|
|
make lib-kim args="-n -a EAM_Dynamo_Ackland_W__MO_141627196590_002" # add one model or model driver
|
|
make lib-kim args="-p /usr/local" # use an existing KIM API installation at the provided location
|
|
make lib-kim args="-p /usr/local -a EAM_Dynamo_Ackland_W__MO_141627196590_002" # ditto but add one model or driver
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _kokkos:
|
|
|
|
KOKKOS package
|
|
---------------------------
|
|
|
|
To build with this package, you must choose which hardware you want to
|
|
build for, either CPUs (multi-threading via OpenMP) or KNLs (OpenMP)
|
|
or GPUs (NVIDIA Cuda).
|
|
|
|
For a CMake or make build, these are the possible choices for the
|
|
KOKKOS\_ARCH settings described below. Note that for CMake, these are
|
|
really Kokkos variables, not LAMMPS variables. Hence you must use
|
|
case-sensitive values, e.g. BDW, not bdw.
|
|
|
|
* ARMv80 = ARMv8.0 Compatible CPU
|
|
* ARMv81 = ARMv8.1 Compatible CPU
|
|
* ARMv8-ThunderX = ARMv8 Cavium ThunderX CPU
|
|
* BGQ = IBM Blue Gene/Q CPUs
|
|
* Power8 = IBM POWER8 CPUs
|
|
* Power9 = IBM POWER9 CPUs
|
|
* SNB = Intel Sandy/Ivy Bridge CPUs
|
|
* HSW = Intel Haswell CPUs
|
|
* BDW = Intel Broadwell Xeon E-class CPUs
|
|
* SKX = Intel Sky Lake Xeon E-class HPC CPUs (AVX512)
|
|
* KNC = Intel Knights Corner Xeon Phi
|
|
* KNL = Intel Knights Landing Xeon Phi
|
|
* Kepler30 = NVIDIA Kepler generation CC 3.0
|
|
* Kepler32 = NVIDIA Kepler generation CC 3.2
|
|
* Kepler35 = NVIDIA Kepler generation CC 3.5
|
|
* Kepler37 = NVIDIA Kepler generation CC 3.7
|
|
* Maxwell50 = NVIDIA Maxwell generation CC 5.0
|
|
* Maxwell52 = NVIDIA Maxwell generation CC 5.2
|
|
* Maxwell53 = NVIDIA Maxwell generation CC 5.3
|
|
* Pascal60 = NVIDIA Pascal generation CC 6.0
|
|
* Pascal61 = NVIDIA Pascal generation CC 6.1
|
|
* Volta70 = NVIDIA Volta generation CC 7.0
|
|
* Volta72 = NVIDIA Volta generation CC 7.2
|
|
* Turing75 = NVIDIA Turing generation CC 7.5
|
|
|
|
**CMake build**\ :
|
|
|
|
For multicore CPUs using OpenMP, set these 2 variables.
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D KOKKOS_ARCH=archCPU # archCPU = CPU from list above
|
|
-D KOKKOS_ENABLE_OPENMP=yes
|
|
|
|
For Intel KNLs using OpenMP, set these 2 variables:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D KOKKOS_ARCH=KNL
|
|
-D KOKKOS_ENABLE_OPENMP=yes
|
|
|
|
For NVIDIA GPUs using CUDA, set these 4 variables:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D KOKKOS_ARCH="archCPU;archGPU" # archCPU = CPU from list above that is hosting the GPU
|
|
# archGPU = GPU from list above
|
|
-D KOKKOS_ENABLE_CUDA=yes
|
|
-D KOKKOS_ENABLE_OPENMP=yes
|
|
-D CMAKE_CXX_COMPILER=wrapper # wrapper = full path to Cuda nvcc wrapper
|
|
|
|
The wrapper value is the Cuda nvcc compiler wrapper provided in the
|
|
Kokkos library: lib/kokkos/bin/nvcc\_wrapper. The setting should
|
|
include the full path name to the wrapper, e.g.
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D CMAKE_CXX_COMPILER=/home/username/lammps/lib/kokkos/bin/nvcc_wrapper
|
|
|
|
**Traditional make**\ :
|
|
|
|
Choose which hardware to support in Makefile.machine via
|
|
KOKKOS\_DEVICES and KOKKOS\_ARCH settings. See the
|
|
src/MAKE/OPTIONS/Makefile.kokkos\* files for examples.
|
|
|
|
For multicore CPUs using OpenMP:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
KOKKOS_DEVICES = OpenMP
|
|
KOKKOS_ARCH = archCPU # archCPU = CPU from list above
|
|
|
|
For Intel KNLs using OpenMP:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
KOKKOS_DEVICES = OpenMP
|
|
KOKKOS_ARCH = KNL
|
|
|
|
For NVIDIA GPUs using CUDA:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
KOKKOS_DEVICES = Cuda
|
|
KOKKOS_ARCH = archCPU,archGPU # archCPU = CPU from list above that is hosting the GPU
|
|
# archGPU = GPU from list above
|
|
|
|
For GPUs, you also need these 2 lines in your Makefile.machine before
|
|
the CC line is defined, in this case for use with OpenMPI mpicxx. The
|
|
2 lines define a nvcc wrapper compiler, which will use nvcc for
|
|
compiling CUDA files and use a C++ compiler for non-Kokkos, non-CUDA
|
|
files.
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
KOKKOS_ABSOLUTE_PATH = $(shell cd $(KOKKOS_PATH); pwd)
|
|
export OMPI_CXX = $(KOKKOS_ABSOLUTE_PATH)/config/nvcc_wrapper
|
|
CC = mpicxx
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _latte:
|
|
|
|
LATTE package
|
|
-------------------------
|
|
|
|
To build with this package, you must download and build the LATTE
|
|
library.
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D DOWNLOAD_LATTE=value # download LATTE for build, value = no (default) or yes
|
|
-D LATTE_LIBRARY=path # LATTE library file (only needed if a custom location)
|
|
|
|
If DOWNLOAD\_LATTE is set, the LATTE library will be downloaded and
|
|
built inside the CMake build directory. If the LATTE library is
|
|
already on your system (in a location CMake cannot find it),
|
|
LATTE\_LIBRARY is the filename (plus path) of the LATTE library file,
|
|
not the directory the library file is in.
|
|
|
|
**Traditional make**\ :
|
|
|
|
You can download and build the LATTE library manually if you prefer;
|
|
follow the instructions in lib/latte/README. You can also do it in
|
|
one step from the lammps/src dir, using a command like these, which
|
|
simply invokes the lib/latte/Install.py script with the specified
|
|
args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-latte # print help message
|
|
make lib-latte args="-b" # download and build in lib/latte/LATTE-master
|
|
make lib-latte args="-p $HOME/latte" # use existing LATTE installation in $HOME/latte
|
|
make lib-latte args="-b -m gfortran" # download and build in lib/latte and
|
|
# copy Makefile.lammps.gfortran to Makefile.lammps
|
|
|
|
Note that 3 symbolic (soft) links, "includelink" and "liblink" and
|
|
"filelink.o", are created in lib/latte to point into the LATTE home
|
|
dir. When LAMMPS itself is built it will use these links. You should
|
|
also check that the Makefile.lammps file you create is appropriate for
|
|
the compiler you use on your system to build LATTE.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _message:
|
|
|
|
MESSAGE package
|
|
-----------------------------
|
|
|
|
This package can optionally include support for messaging via sockets,
|
|
using the open-source `ZeroMQ library <http://zeromq.org>`_, which must
|
|
be installed on your system.
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D MESSAGE_ZMQ=value # build with ZeroMQ support, value = no (default) or yes
|
|
-D ZMQ_LIBRARY=path # ZMQ library file (only needed if a custom location)
|
|
-D ZMQ_INCLUDE_DIR=path # ZMQ include directory (only needed if a custom location)
|
|
|
|
**Traditional make**\ :
|
|
|
|
Before building LAMMPS, you must build the CSlib library in
|
|
lib/message. You can build the CSlib library manually if you prefer;
|
|
follow the instructions in lib/message/README. You can also do it in
|
|
one step from the lammps/src dir, using a command like these, which
|
|
simply invoke the lib/message/Install.py script with the specified args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-message # print help message
|
|
make lib-message args="-m -z" # build with MPI and socket (ZMQ) support
|
|
make lib-message args="-s" # build as serial lib with no ZMQ support
|
|
|
|
The build should produce two files: lib/message/cslib/src/libmessage.a
|
|
and lib/message/Makefile.lammps. The latter is copied from an
|
|
existing Makefile.lammps.\* and has settings to link with the ZeroMQ
|
|
library if requested in the build.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _mscg:
|
|
|
|
MSCG package
|
|
-----------------------
|
|
|
|
To build with this package, you must download and build the MS-CG
|
|
library. Building the MS-CG library and using it from LAMMPS requires
|
|
a C++11 compatible compiler and that the GSL (GNU Scientific Library)
|
|
headers and libraries are installed on your machine. See the
|
|
lib/mscg/README and MSCG/Install files for more details.
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D DOWNLOAD_MSCG=value # download MSCG for build, value = no (default) or yes
|
|
-D MSCG_LIBRARY=path # MSCG library file (only needed if a custom location)
|
|
-D MSCG_INCLUDE_DIR=path # MSCG include directory (only needed if a custom location)
|
|
|
|
If DOWNLOAD\_MSCG is set, the MSCG library will be downloaded and built
|
|
inside the CMake build directory. If the MSCG library is already on
|
|
your system (in a location CMake cannot find it), MSCG\_LIBRARY is the
|
|
filename (plus path) of the MSCG library file, not the directory the
|
|
library file is in. MSCG\_INCLUDE\_DIR is the directory the MSCG
|
|
include file is in.
|
|
|
|
**Traditional make**\ :
|
|
|
|
You can download and build the MS-CG library manually if you prefer;
|
|
follow the instructions in lib/mscg/README. You can also do it in one
|
|
step from the lammps/src dir, using a command like these, which simply
|
|
invoke the lib/mscg/Install.py script with the specified args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-mscg # print help message
|
|
make lib-mscg args="-b -m serial" # download and build in lib/mscg/MSCG-release-master
|
|
# with the settings compatible with "make serial"
|
|
make lib-mscg args="-b -m mpi" # download and build in lib/mscg/MSCG-release-master
|
|
# with the settings compatible with "make mpi"
|
|
make lib-mscg args="-p /usr/local/mscg-release" # use the existing MS-CG installation in /usr/local/mscg-release
|
|
|
|
Note that 2 symbolic (soft) links, "includelink" and "liblink", will
|
|
be created in lib/mscg to point to the MS-CG src/installation dir.
|
|
When LAMMPS is built in src it will use these links. You should not
|
|
need to edit the lib/mscg/Makefile.lammps file.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _opt:
|
|
|
|
OPT package
|
|
---------------------
|
|
|
|
**CMake build**\ :
|
|
|
|
No additional settings are needed besides "-D PKG\_OPT=yes".
|
|
|
|
**Traditional make**\ :
|
|
|
|
The compile flag "-restrict" must be used to build LAMMPS with the OPT
|
|
package when using Intel compilers. It should be added to the CCFLAGS
|
|
line of your Makefile.machine. See src/MAKE/OPTIONS/Makefile.opt for
|
|
an example.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _poems:
|
|
|
|
POEMS package
|
|
-------------------------
|
|
|
|
**CMake build**\ :
|
|
|
|
No additional settings are needed besides "-D PKG\_OPT=yes".
|
|
|
|
**Traditional make**\ :
|
|
|
|
Before building LAMMPS, you must build the POEMS library in lib/poems.
|
|
You can do this manually if you prefer; follow the instructions in
|
|
lib/poems/README. You can also do it in one step from the lammps/src
|
|
dir, using a command like these, which simply invoke the
|
|
lib/poems/Install.py script with the specified args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-poems # print help message
|
|
make lib-poems args="-m serial" # build with GNU g++ compiler (settings as with "make serial")
|
|
make lib-poems args="-m mpi" # build with default MPI C++ compiler (settings as with "make mpi")
|
|
make lib-poems args="-m icc" # build with Intel icc compiler
|
|
|
|
The build should produce two files: lib/poems/libpoems.a and
|
|
lib/poems/Makefile.lammps. The latter is copied from an existing
|
|
Makefile.lammps.\* and has settings needed to build LAMMPS with the
|
|
POEMS library (though typically the settings are just blank). If
|
|
necessary, you can edit/create a new lib/poems/Makefile.machine file
|
|
for your system, which should define an EXTRAMAKE variable to specify
|
|
a corresponding Makefile.lammps.machine file.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _python:
|
|
|
|
PYTHON package
|
|
---------------------------
|
|
|
|
Building with the PYTHON package requires you have a Python shared
|
|
library available on your system, which needs to be a Python 2
|
|
version, 2.6 or later. Python 3 is not yet supported. See
|
|
lib/python/README for more details.
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D PYTHON_EXECUTABLE=path # path to Python executable to use
|
|
|
|
Without this setting, CMake will guess the default Python on your
|
|
system. To use a different Python version, you can either create a
|
|
virtualenv, activate it and then run cmake. Or you can set the
|
|
PYTHON\_EXECUTABLE variable to specify which Python interpreter should
|
|
be used. Note note that you will also need to have the development
|
|
headers installed for this version, e.g. python2-devel.
|
|
|
|
**Traditional make**\ :
|
|
|
|
The build uses the lib/python/Makefile.lammps file in the compile/link
|
|
process to find Python. You should only need to create a new
|
|
Makefile.lammps.\* file (and copy it to Makefile.lammps) if the LAMMPS
|
|
build fails.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _voronoi:
|
|
|
|
VORONOI package
|
|
-----------------------------
|
|
|
|
To build with this package, you must download and build the `Voro++ library <voro-home_>`_.
|
|
|
|
.. _voro-home: http://math.lbl.gov/voro++
|
|
|
|
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D DOWNLOAD_VORO=value # download Voro++ for build, value = no (default) or yes
|
|
-D VORO_LIBRARY=path # Voro++ library file (only needed if at custom location)
|
|
-D VORO_INCLUDE_DIR=path # Voro++ include directory (only needed if at custom location)
|
|
|
|
If DOWNLOAD\_VORO is set, the Voro++ library will be downloaded and
|
|
built inside the CMake build directory. If the Voro++ library is
|
|
already on your system (in a location CMake cannot find it),
|
|
VORO\_LIBRARY is the filename (plus path) of the Voro++ library file,
|
|
not the directory the library file is in. VORO\_INCLUDE\_DIR is the
|
|
directory the Voro++ include file is in.
|
|
|
|
**Traditional make**\ :
|
|
|
|
You can download and build the Voro++ library manually if you prefer;
|
|
follow the instructions in lib/voronoi/README. You can also do it in
|
|
one step from the lammps/src dir, using a command like these, which
|
|
simply invoke the lib/voronoi/Install.py script with the specified
|
|
args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-voronoi # print help message
|
|
make lib-voronoi args="-b" # download and build the default version in lib/voronoi/voro++-<version>
|
|
make lib-voronoi args="-p $HOME/voro++" # use existing Voro++ installation in $HOME/voro++
|
|
make lib-voronoi args="-b -v voro++0.4.6" # download and build the 0.4.6 version in lib/voronoi/voro++-0.4.6
|
|
|
|
Note that 2 symbolic (soft) links, "includelink" and "liblink", are
|
|
created in lib/voronoi to point to the Voro++ src dir. When LAMMPS
|
|
builds in src it will use these links. You should not need to edit
|
|
the lib/voronoi/Makefile.lammps file.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-adios:
|
|
|
|
USER-ADIOS package
|
|
-----------------------------------
|
|
|
|
The USER-ADIOS package requires the `ADIOS I/O library <https://github.com/ornladios/ADIOS2>`_,
|
|
version 2.3.1 or newer. Make sure that you have ADIOS built either with or
|
|
without MPI to match if you build LAMMPS with or without MPI.
|
|
ADIOS compilation settings for LAMMPS are automatically detected, if the PATH
|
|
and LD\_LIBRARY\_PATH environment variables have been updated for the local ADIOS
|
|
installation and the instructions below are followed for the respective build systems.
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D ADIOS2_DIR=path # path is where ADIOS 2.x is installed
|
|
-D PKG_USER-ADIOS=yes
|
|
|
|
**Traditional make**\ :
|
|
|
|
Turn on the USER-ADIOS package before building LAMMPS. If the ADIOS 2.x software is installed in PATH, there is nothing else to do:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make yes-user-adios
|
|
|
|
otherwise, set ADIOS2\_DIR environment variable when turning on the package:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
ADIOS2_DIR=path make yes-user-adios # path is where ADIOS 2.x is installed
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-atc:
|
|
|
|
USER-ATC package
|
|
-------------------------------
|
|
|
|
The USER-ATC package requires the MANYBODY package also be installed.
|
|
|
|
**CMake build**\ :
|
|
|
|
No additional settings are needed besides "-D PKG\_USER-ATC=yes"
|
|
and "-D PKG\_MANYBODY=yes".
|
|
|
|
**Traditional make**\ :
|
|
|
|
Before building LAMMPS, you must build the ATC library in lib/atc.
|
|
You can do this manually if you prefer; follow the instructions in
|
|
lib/atc/README. You can also do it in one step from the lammps/src
|
|
dir, using a command like these, which simply invoke the
|
|
lib/atc/Install.py script with the specified args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-atc # print help message
|
|
make lib-atc args="-m serial" # build with GNU g++ compiler and MPI STUBS (settings as with "make serial")
|
|
make lib-atc args="-m mpi" # build with default MPI compiler (settings as with "make mpi")
|
|
make lib-atc args="-m icc" # build with Intel icc compiler
|
|
|
|
The build should produce two files: lib/atc/libatc.a and
|
|
lib/atc/Makefile.lammps. The latter is copied from an existing
|
|
Makefile.lammps.\* and has settings needed to build LAMMPS with the ATC
|
|
library. If necessary, you can edit/create a new
|
|
lib/atc/Makefile.machine file for your system, which should define an
|
|
EXTRAMAKE variable to specify a corresponding Makefile.lammps.machine
|
|
file.
|
|
|
|
Note that the Makefile.lammps file has settings for the BLAS and
|
|
LAPACK linear algebra libraries. As explained in lib/atc/README these
|
|
can either exist on your system, or you can use the files provided in
|
|
lib/linalg. In the latter case you also need to build the library in
|
|
lib/linalg with a command like these:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-linalg # print help message
|
|
make lib-linalg args="-m serial" # build with GNU Fortran compiler (settings as with "make serial")
|
|
make lib-linalg args="-m mpi" # build with default MPI Fortran compiler (settings as with "make mpi")
|
|
make lib-linalg args="-m gfortran" # build with GNU Fortran compiler
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-awpmd:
|
|
|
|
USER-AWPMD package
|
|
-----------------------------------
|
|
|
|
**CMake build**\ :
|
|
|
|
No additional settings are needed besides "-D PKG\_USER-AQPMD=yes".
|
|
|
|
**Traditional make**\ :
|
|
|
|
Before building LAMMPS, you must build the AWPMD library in lib/awpmd.
|
|
You can do this manually if you prefer; follow the instructions in
|
|
lib/awpmd/README. You can also do it in one step from the lammps/src
|
|
dir, using a command like these, which simply invoke the
|
|
lib/awpmd/Install.py script with the specified args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-awpmd # print help message
|
|
make lib-awpmd args="-m serial" # build with GNU g++ compiler and MPI STUBS (settings as with "make serial")
|
|
make lib-awpmd args="-m mpi" # build with default MPI compiler (settings as with "make mpi")
|
|
make lib-awpmd args="-m icc" # build with Intel icc compiler
|
|
|
|
The build should produce two files: lib/awpmd/libawpmd.a and
|
|
lib/awpmd/Makefile.lammps. The latter is copied from an existing
|
|
Makefile.lammps.\* and has settings needed to build LAMMPS with the
|
|
AWPMD library. If necessary, you can edit/create a new
|
|
lib/awpmd/Makefile.machine file for your system, which should define
|
|
an EXTRAMAKE variable to specify a corresponding
|
|
Makefile.lammps.machine file.
|
|
|
|
Note that the Makefile.lammps file has settings for the BLAS and
|
|
LAPACK linear algebra libraries. As explained in lib/awpmd/README
|
|
these can either exist on your system, or you can use the files
|
|
provided in lib/linalg. In the latter case you also need to build the
|
|
library in lib/linalg with a command like these:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-linalg # print help message
|
|
make lib-linalg args="-m serial" # build with GNU Fortran compiler (settings as with "make serial")
|
|
make lib-linalg args="-m mpi" # build with default MPI Fortran compiler (settings as with "make mpi")
|
|
make lib-linalg args="-m gfortran" # build with GNU Fortran compiler
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-colvars:
|
|
|
|
USER-COLVARS package
|
|
---------------------------------------
|
|
|
|
This package includes into the LAMMPS distribution the Colvars library, which
|
|
can be built for the most part with all major versions of the C++ language.
|
|
|
|
A few of the most recent features require C++11 support. In particular, the
|
|
library is optionally built together with the
|
|
`Lepton <https://simtk.org/projects/lepton>`_ library, a copy of which is also
|
|
included in the LAMMPS distribution. Lepton implements the
|
|
`customFunction <http://colvars.github.io/colvars-refman-lammps/colvars-refman-lammps.html#colvar|customFunction>`_
|
|
feature, and requires C++11 support.
|
|
|
|
See `here <https://colvars.github.io/README-c++11.html>`_ for a detailed list of
|
|
C++11-only features.
|
|
|
|
**CMake build**\ :
|
|
|
|
This is the recommended build recipe: no additional settings are normally
|
|
needed besides "-D PKG\_USER-COLVARS=yes".
|
|
|
|
Building and linking of Lepton (or other C++11-only features) is enabled
|
|
automatically when compilation is carried out with C++11 support, and disabled
|
|
otherwise. Optionally, Lepton build may be manually controlled with the flag
|
|
"-D COLVARS\_LEPTON=yes\|no".
|
|
|
|
**Traditional make**\ :
|
|
|
|
Before building LAMMPS, one must build the Colvars library in lib/colvars.
|
|
|
|
This can be done manually in the same folder by using or adapting one of the
|
|
provided Makefiles: for example, Makefile.g++ for the GNU compiler.
|
|
|
|
In general, it is safer to use build setting consistent with the rest of
|
|
LAMMPS. This is best carried out from the LAMMPS src directory using a
|
|
command like these, which simply invoke the lib/colvars/Install.py script with
|
|
the specified args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-colvars # print help message
|
|
make lib-colvars args="-m serial" # build with GNU g++ compiler (settings as with "make serial")
|
|
make lib-colvars args="-m mpi" # build with default MPI compiler (settings as with "make mpi")
|
|
make lib-colvars args="-m g++-debug" # build with GNU g++ compiler and colvars debugging enabled
|
|
|
|
The "machine" argument of the "-m" flag is used to find a Makefile.machine to
|
|
use as build recipe. If it does not already exist in lib/colvars, it will be
|
|
auto-generated by using compiler flags consistent with those parsed from the
|
|
core LAMMPS makefiles.
|
|
|
|
Optional flags may be specified as environment variables:
|
|
|
|
COLVARS\_DEBUG=yes make lib-colvars args="-m machine" # Build with debug code (much slower)
|
|
COLVARS\_LEPTON=no make lib-colvars args="-m machine" # Build without Lepton (included otherwise)
|
|
|
|
The build should produce two files: the library lib/colvars/libcolvars.a
|
|
(which also includes Lepton objects if enabled) and the specification file
|
|
lib/colvars/Makefile.lammps. The latter is auto-generated, and normally does
|
|
not need to be edited.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-plumed:
|
|
|
|
USER-PLUMED package
|
|
-------------------------------------
|
|
|
|
.. _plumedinstall: http://plumed.github.io/doc-master/user-doc/html/\_installation.html
|
|
|
|
Before building LAMMPS with this package, you must first build PLUMED.
|
|
PLUMED can be built as part of the LAMMPS build or installed separately
|
|
from LAMMPS using the generic `plumed installation instructions <plumedinstall_>`_.
|
|
|
|
|
|
PLUMED can be linked into MD codes in three different modes: static,
|
|
shared, and runtime. With the "static" mode, all the code that PLUMED
|
|
requires is linked statically into LAMMPS. LAMMPS is then fully
|
|
independent from the PLUMED installation, but you have to rebuild/relink
|
|
it in order to update the PLUMED code inside it. With the "shared"
|
|
linkage mode, LAMMPS is linked to a shared library that contains the
|
|
PLUMED code. This library should preferably be installed in a globally
|
|
accessible location. When PLUMED is linked in this way the same library
|
|
can be used by multiple MD packages. Furthermore, the PLUMED library
|
|
LAMMPS uses can be updated without the need for a recompile of LAMMPS
|
|
for as long as the shared PLUMED library is ABI-compatible.
|
|
|
|
The third linkage mode is "runtime" which allows the user to specify
|
|
which PLUMED kernel should be used at runtime by using the PLUMED\_KERNEL
|
|
environment variable. This variable should point to the location of the
|
|
libplumedKernel.so dynamical shared object, which is then loaded at
|
|
runtime. This mode of linking is particularly convenient for doing
|
|
PLUMED development and comparing multiple PLUMED versions as these sorts
|
|
of comparisons can be done without recompiling the hosting MD code. All
|
|
three linkage modes are supported by LAMMPS on selected operating
|
|
systems (e.g. Linux) and using either CMake or traditional make
|
|
build. The "static" mode should be the most portable, while the
|
|
"runtime" mode support in LAMMPS makes the most assumptions about
|
|
operating system and compiler environment. If one mode does not work,
|
|
try a different one, switch to a different build system, consider a
|
|
global PLUMED installation or consider downloading PLUMED during the
|
|
LAMMPS build.
|
|
|
|
**CMake build**\ :
|
|
|
|
When the "-D PKG\_USER-PLUMED" flag is included in the cmake command you
|
|
must ensure that GSL is installed in locations that are specified in
|
|
your environment. There are then two additional commands that control
|
|
the manner in which PLUMED is obtained and linked into LAMMPS.
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D DOWNLOAD_PLUMED=value # download PLUMED for build, value = no (default) or yes
|
|
-D PLUMED_MODE=value # Linkage mode for PLUMED, value = static (default), shared, or runtime
|
|
|
|
If DOWNLOAD\_PLUMED is set to "yes", the PLUMED library will be
|
|
downloaded (the version of PLUMED that will be downloaded is hard-coded
|
|
to a vetted version of PLUMED, usually a recent stable release version)
|
|
and built inside the CMake build directory. If DOWNLOAD\_PLUMED is set
|
|
to "no" (the default), CMake will try to detect and link to an installed
|
|
version of PLUMED. For this to work, the PLUMED library has to be
|
|
installed into a location where the pkg-config tool can find it or the
|
|
PKG\_CONFIG\_PATH environment variable has to be set up accordingly.
|
|
PLUMED should be installed in such a location if you compile it using
|
|
the default make; make install commands.
|
|
|
|
The PLUMED\_MODE setting determines the linkage mode for the PLUMED
|
|
library. The allowed values for this flag are "static" (default),
|
|
"shared", or "runtime". For a discussion of PLUMED linkage modes,
|
|
please see above. When DOWNLOAD\_PLUMED is enabled the static linkage
|
|
mode is recommended.
|
|
|
|
**Traditional make**\ :
|
|
|
|
PLUMED needs to be installed before the USER-PLUMED package is installed
|
|
so that LAMMPS can find the right settings when compiling and linking
|
|
the LAMMPS executable. You can either download and build PLUMED inside
|
|
the LAMMPS plumed library folder or use a previously installed PLUMED
|
|
library and point LAMMPS to its location. You also have to choose the
|
|
linkage mode: "static" (default), "shared" or "runtime". For a
|
|
discussion of PLUMED linkage modes, please see above.
|
|
|
|
Download/compilation/configuration of the plumed library can be done
|
|
from the src folder through the following make args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-plumed # print help message
|
|
make lib-plumed args="-b" # download and build PLUMED in lib/plumed/plumed2
|
|
make lib-plumed args="-p $HOME/.local" # use existing PLUMED installation in $HOME/.local
|
|
make lib-plumed args="-p /usr/local -m shared" # use existing PLUMED installation in
|
|
# /usr/local and use shared linkage mode
|
|
|
|
Note that 2 symbolic (soft) links, "includelink" and "liblink" are
|
|
created in lib/plumed that point to the location of the PLUMED build to
|
|
use. A new file lib/plumed/Makefile.lammps is also created with settings
|
|
suitable for LAMMPS to compile and link PLUMED using the desired linkage
|
|
mode. After this step is completed, you can install the USER-PLUMED
|
|
package and compile LAMMPS in the usual manner:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make yes-user-plumed
|
|
make machine
|
|
|
|
Once this compilation completes you should be able to run LAMMPS in the
|
|
usual way. For shared linkage mode, libplumed.so must be found by the
|
|
LAMMPS executable, which on many operating systems means, you have to
|
|
set the LD\_LIBRARY\_PATH environment variable accordingly.
|
|
|
|
Support for the different linkage modes in LAMMPS varies for different
|
|
operating systems, using the static linkage is expected to be the most
|
|
portable, and thus set to be the default.
|
|
|
|
If you want to change the linkage mode, you have to re-run "make
|
|
lib-plumed" with the desired settings **and** do a re-install if the
|
|
USER-PLUMED package with "make yes-user-plumed" to update the required
|
|
makefile settings with the changes in the lib/plumed folder.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-h5md:
|
|
|
|
USER-H5MD package
|
|
---------------------------------
|
|
|
|
To build with this package you must have the HDF5 software package
|
|
installed on your system, which should include the h5cc compiler and
|
|
the HDF5 library.
|
|
|
|
**CMake build**\ :
|
|
|
|
No additional settings are needed besides "-D PKG\_USER-H5MD=yes".
|
|
|
|
This should auto-detect the H5MD library on your system. Several
|
|
advanced CMake H5MD options exist if you need to specify where it is
|
|
installed. Use the ccmake (terminal window) or cmake-gui (graphical)
|
|
tools to see these options and set them interactively from their user
|
|
interfaces.
|
|
|
|
**Traditional make**\ :
|
|
|
|
Before building LAMMPS, you must build the CH5MD library in lib/h5md.
|
|
You can do this manually if you prefer; follow the instructions in
|
|
lib/h5md/README. You can also do it in one step from the lammps/src
|
|
dir, using a command like these, which simply invoke the
|
|
lib/h5md/Install.py script with the specified args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-h5md # print help message
|
|
make lib-h5md args="-m h5cc" # build with h5cc compiler
|
|
|
|
The build should produce two files: lib/h5md/libch5md.a and
|
|
lib/h5md/Makefile.lammps. The latter is copied from an existing
|
|
Makefile.lammps.\* and has settings needed to build LAMMPS with the
|
|
system HDF5 library. If necessary, you can edit/create a new
|
|
lib/h5md/Makefile.machine file for your system, which should define an
|
|
EXTRAMAKE variable to specify a corresponding Makefile.lammps.machine
|
|
file.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-intel:
|
|
|
|
USER-INTEL package
|
|
-----------------------------------
|
|
|
|
To build with this package, you must choose which hardware you want to
|
|
build for, either x86 CPUs or Intel KNLs in offload mode. You should
|
|
also typically :ref:`install the USER-OMP package <user-omp>`, as it can be
|
|
used in tandem with the USER-INTEL package to good effect, as explained
|
|
on the :doc:`Speed intel <Speed_intel>` doc page.
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D INTEL_ARCH=value # value = cpu (default) or knl
|
|
-D INTEL_LRT_MODE=value # value = threads, none, or c++11
|
|
|
|
In Long-range thread mode (LRT) a modified verlet style is used, that
|
|
operates the Kspace calculation in a separate thread concurrently to
|
|
other calculations. This has to be enabled in the :doc:`package intel <package>`
|
|
command at runtime. With the setting "threads" it used the pthreads
|
|
library, while c++11 will use the built-in thread support of C++11
|
|
compilers. The option "none" skips compilation of this feature. The
|
|
default is to use "threads" if pthreads is available and otherwise "none".
|
|
|
|
Best performance is achieved with Intel hardware, Intel compilers, as well as
|
|
the Intel TBB and MKL libraries. However, the code also compiles, links, and
|
|
runs with other compilers and without TBB and MKL.
|
|
|
|
**Traditional make**\ :
|
|
|
|
Choose which hardware to compile for in Makefile.machine via the
|
|
following settings. See src/MAKE/OPTIONS/Makefile.intel\_cpu\* and
|
|
Makefile.knl files for examples. and src/USER-INTEL/README for
|
|
additional information.
|
|
|
|
For CPUs:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
OPTFLAGS = -xHost -O2 -fp-model fast=2 -no-prec-div -qoverride-limits -qopt-zmm-usage=high
|
|
CCFLAGS = -g -qopenmp -DLAMMPS_MEMALIGN=64 -no-offload -fno-alias -ansi-alias -restrict $(OPTFLAGS)
|
|
LINKFLAGS = -g -qopenmp $(OPTFLAGS)
|
|
LIB = -ltbbmalloc
|
|
|
|
For KNLs:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
OPTFLAGS = -xMIC-AVX512 -O2 -fp-model fast=2 -no-prec-div -qoverride-limits
|
|
CCFLAGS = -g -qopenmp -DLAMMPS_MEMALIGN=64 -no-offload -fno-alias -ansi-alias -restrict $(OPTFLAGS)
|
|
LINKFLAGS = -g -qopenmp $(OPTFLAGS)
|
|
LIB = -ltbbmalloc
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-molfile:
|
|
|
|
USER-MOLFILE package
|
|
---------------------------------------
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D MOLFILE_INCLUDE_DIRS=path # (optional) path where VMD molfile plugin headers are installed
|
|
-D PKG_USER-MOLFILE=yes
|
|
|
|
Using "-D PKG\_USER-MOLFILE=yes" enables the package, and setting
|
|
"-D MOLFILE\_INCLUDE DIRS" allows to provide a custom location for
|
|
the molfile plugin header files. These should match the ABI of the
|
|
plugin files used, and thus one typically sets them to include
|
|
folder of the local VMD installation in use. LAMMPS ships with a
|
|
couple of default header files that correspond to a popular VMD
|
|
version, usually the latest release.
|
|
|
|
**Traditional make**\ :
|
|
|
|
The lib/molfile/Makefile.lammps file has a setting for a dynamic
|
|
loading library libdl.a that is typically present on all systems. It
|
|
is required for LAMMPS to link with this package. If the setting is
|
|
not valid for your system, you will need to edit the Makefile.lammps
|
|
file. See lib/molfile/README and lib/molfile/Makefile.lammps for
|
|
details. It is also possible to configure a different folder with
|
|
the VMD molfile plugin header files. LAMMPS ships with a couple of
|
|
default headers, but these are not compatible with all VMD versions,
|
|
so it is often best to change this setting to the location of the
|
|
same include files of the local VMD installation in use.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-netcdf:
|
|
|
|
USER-NETCDF package
|
|
-------------------------------------
|
|
|
|
To build with this package you must have the NetCDF library installed
|
|
on your system.
|
|
|
|
**CMake build**\ :
|
|
|
|
No additional settings are needed besides "-D PKG\_USER-NETCDF=yes".
|
|
|
|
This should auto-detect the NETCDF library if it is installed on your
|
|
system at standard locations. Several advanced CMake NETCDF options
|
|
exist if you need to specify where it was installed. Use the ccmake
|
|
(terminal window) or cmake-gui (graphical) tools to see these options
|
|
and set them interactively from their user interfaces.
|
|
|
|
**Traditional make**\ :
|
|
|
|
The lib/netcdf/Makefile.lammps file has settings for NetCDF include
|
|
and library files which LAMMPS needs to build with this package. If
|
|
the settings are not valid for your system, you will need to edit the
|
|
Makefile.lammps file. See lib/netcdf/README for details.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-omp:
|
|
|
|
USER-OMP package
|
|
-------------------------------
|
|
|
|
**CMake build**\ :
|
|
|
|
No additional settings are required besides "-D PKG\_USER-OMP=yes". If
|
|
CMake detects OpenMP support, the USER-OMP code will be compiled with
|
|
multi-threading support enabled, otherwise as optimized serial code.
|
|
|
|
**Traditional make**\ :
|
|
|
|
To enable multi-threading support in the USER-OMP package (and other
|
|
styles supporting OpenMP) the following compile and link flags must
|
|
be added to your Makefile.machine file.
|
|
See src/MAKE/OPTIONS/Makefile.omp for an example.
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
CCFLAGS: -fopenmp # for GNU Compilers
|
|
CCFLAGS: -qopenmp -restrict # for Intel compilers on Linux
|
|
LINKFLAGS: -fopenmp # for GNU Compilers
|
|
LINKFLAGS: -qopenmp # for Intel compilers on Linux
|
|
|
|
For other platforms and compilers, please consult the documentation
|
|
about OpenMP support for your compiler. Please see the note about
|
|
how to address compatibility :ref:`issues with the 'default(none)' directive <default-none-issues>` of some compilers.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-qmmm:
|
|
|
|
USER-QMMM package
|
|
---------------------------------
|
|
|
|
.. note::
|
|
|
|
The LAMMPS executable these steps produce is not yet functional
|
|
for a QM/MM simulation. You must also build Quantum ESPRESSO and
|
|
create a new executable (pwqmmm.x) which links LAMMPS and Quantum
|
|
ESPRESSO together. These are steps 3 and 4 described in the
|
|
lib/qmmm/README file. Unfortunately, the Quantum ESPRESSO developers
|
|
have been breaking the interface that the QM/MM code in LAMMPS is using,
|
|
so that currently (Summer 2018) using this feature requires either
|
|
correcting the library interface feature in recent Quantum ESPRESSO
|
|
releases, or using an outdated version of QE. The last version of
|
|
Quantum ESPRESSO known to work with this QM/MM interface was version
|
|
5.4.1 from 2016.
|
|
|
|
**CMake build**\ :
|
|
|
|
The CMake build system currently does not support building the full
|
|
QM/MM-capable hybrid executable of LAMMPS and QE called pwqmmm.x.
|
|
You must use the traditional make build for this package.
|
|
|
|
**Traditional make**\ :
|
|
|
|
Before building LAMMPS, you must build the QMMM library in lib/qmmm.
|
|
You can do this manually if you prefer; follow the first two steps
|
|
explained in lib/qmmm/README. You can also do it in one step from the
|
|
lammps/src dir, using a command like these, which simply invoke the
|
|
lib/qmmm/Install.py script with the specified args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-qmmm # print help message
|
|
make lib-qmmm args="-m serial" # build with GNU Fortran compiler (settings as in "make serial")
|
|
make lib-qmmm args="-m mpi" # build with default MPI compiler (settings as in "make mpi")
|
|
make lib-qmmm args="-m gfortran" # build with GNU Fortran compiler
|
|
|
|
The build should produce two files: lib/qmmm/libqmmm.a and
|
|
lib/qmmm/Makefile.lammps. The latter is copied from an existing
|
|
Makefile.lammps.\* and has settings needed to build LAMMPS with the
|
|
QMMM library (though typically the settings are just blank). If
|
|
necessary, you can edit/create a new lib/qmmm/Makefile.machine file
|
|
for your system, which should define an EXTRAMAKE variable to specify
|
|
a corresponding Makefile.lammps.machine file.
|
|
|
|
You can then install QMMM package and build LAMMPS in the usual
|
|
manner. After completing the LAMMPS build and compiling Quantum
|
|
ESPRESSO with external library support, go back to the lib/qmmm folder
|
|
and follow the instructions on the README file to build the combined
|
|
LAMMPS/QE QM/MM executable (pwqmmm.x) in the lib/qmmm folder.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-quip:
|
|
|
|
USER-QUIP package
|
|
---------------------------------
|
|
|
|
To build with this package, you must download and build the QUIP
|
|
library. It can be obtained from GitHub. For support of GAP
|
|
potentials, additional files with specific licensing conditions need
|
|
to be downloaded and configured. See step 1 and step 1.1 in the
|
|
lib/quip/README file for details on how to do this.
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D QUIP_LIBRARY=path # path to libquip.a (only needed if a custom location)
|
|
|
|
CMake will not download and build the QUIP library. But once you have
|
|
done that, a CMake build of LAMMPS with "-D PKG\_USER-QUIP=yes" should
|
|
work. Set QUIP\_LIBRARY if CMake cannot find the QUIP library.
|
|
|
|
**Traditional make**\ :
|
|
|
|
The download/build procedure for the QUIP library, described in
|
|
lib/quip/README file requires setting two environment variables,
|
|
QUIP\_ROOT and QUIP\_ARCH. These are accessed by the
|
|
lib/quip/Makefile.lammps file which is used when you compile and link
|
|
LAMMPS with this package. You should only need to edit
|
|
Makefile.lammps if the LAMMPS build can not use its settings to
|
|
successfully build on your system.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-scafacos:
|
|
|
|
USER-SCAFACOS package
|
|
-----------------------------------------
|
|
|
|
To build with this package, you must download and build the `ScaFaCoS Coulomb solver library <scafacos-home_>`_
|
|
|
|
.. _scafacos-home: http://www.scafacos.de
|
|
|
|
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D DOWNLOAD_SCAFACOS=value # download ScaFaCoS for build, value = no (default) or yes
|
|
-D SCAFACOS_LIBRARY=path # ScaFaCos library file (only needed if at custom location)
|
|
-D SCAFACOS_INCLUDE_DIR=path # ScaFaCoS include directory (only needed if at custom location)
|
|
|
|
If DOWNLOAD\_SCAFACOS is set, the ScaFaCoS library will be downloaded
|
|
and built inside the CMake build directory. If the ScaFaCoS library
|
|
is already on your system (in a location CMake cannot find it),
|
|
SCAFACOS\_LIBRARY is the filename (plus path) of the ScaFaCoS library
|
|
file, not the directory the library file is in. SCAFACOS\_INCLUDE\_DIR
|
|
is the directory the ScaFaCoS include file is in.
|
|
|
|
**Traditional make**\ :
|
|
|
|
You can download and build the ScaFaCoS library manually if you
|
|
prefer; follow the instructions in lib/scafacos/README. You can also
|
|
do it in one step from the lammps/src dir, using a command like these,
|
|
which simply invoke the lib/scafacos/Install.py script with the
|
|
specified args:
|
|
|
|
make lib-scafacos # print help message
|
|
make lib-scafacos args="-b" # download and build in lib/scafacos/scafacos-<version>
|
|
make lib-scafacos args="-p $HOME/scafacos # use existing ScaFaCoS installation in $HOME/scafacos
|
|
|
|
Note that 2 symbolic (soft) links, "includelink" and "liblink", are
|
|
created in lib/scafacos to point to the ScaFaCoS src dir. When LAMMPS
|
|
builds in src it will use these links. You should not need to edit
|
|
the lib/scafacos/Makefile.lammps file.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-smd:
|
|
|
|
USER-SMD package
|
|
-------------------------------
|
|
|
|
To build with this package, you must download the Eigen3 library.
|
|
Eigen3 is a template library, so you do not need to build it.
|
|
|
|
**CMake build**\ :
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
-D DOWNLOAD_EIGEN3 # download Eigen3, value = no (default) or yes
|
|
-D EIGEN3_INCLUDE_DIR=path # path to Eigen library (only needed if a custom location)
|
|
|
|
If DOWNLOAD\_EIGEN3 is set, the Eigen3 library will be downloaded and
|
|
inside the CMake build directory. If the Eigen3 library is already on
|
|
your system (in a location CMake cannot find it), EIGEN3\_INCLUDE\_DIR
|
|
is the directory the Eigen3++ include file is in.
|
|
|
|
**Traditional make**\ :
|
|
|
|
You can download the Eigen3 library manually if you prefer; follow the
|
|
instructions in lib/smd/README. You can also do it in one step from
|
|
the lammps/src dir, using a command like these, which simply invoke
|
|
the lib/smd/Install.py script with the specified args:
|
|
|
|
|
|
.. parsed-literal::
|
|
|
|
make lib-smd # print help message
|
|
make lib-smd args="-b" # download to lib/smd/eigen3
|
|
make lib-smd args="-p /usr/include/eigen3" # use existing Eigen installation in /usr/include/eigen3
|
|
|
|
Note that a symbolic (soft) link named "includelink" is created in
|
|
lib/smd to point to the Eigen dir. When LAMMPS builds it will use
|
|
this link. You should not need to edit the lib/smd/Makefile.lammps
|
|
file.
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _user-vtk:
|
|
|
|
USER-VTK package
|
|
-------------------------------
|
|
|
|
To build with this package you must have the VTK library installed on
|
|
your system.
|
|
|
|
**CMake build**\ :
|
|
|
|
No additional settings are needed besides "-D PKG\_USER-VTK=yes".
|
|
|
|
This should auto-detect the VTK library if it is installed on your
|
|
system at standard locations. Several advanced VTK options exist if
|
|
you need to specify where it was installed. Use the ccmake (terminal
|
|
window) or cmake-gui (graphical) tools to see these options and set
|
|
them interactively from their user interfaces.
|
|
|
|
**Traditional make**\ :
|
|
|
|
The lib/vtk/Makefile.lammps file has settings for accessing VTK files
|
|
and its library, which LAMMPS needs to build with this package. If
|
|
the settings are not valid for your system, check if one of the other
|
|
lib/vtk/Makefile.lammps.\* files is compatible and copy it to
|
|
Makefile.lammps. If none of the provided files work, you will need to
|
|
edit the Makefile.lammps file. See lib/vtk/README for details.
|
|
|
|
|
|
.. _lws: http://lammps.sandia.gov
|
|
.. _ld: Manual.html
|
|
.. _lc: Commands_all.html
|