【LAMMPS学习】三、构建LAMMPS(7)具有额外构建选项的软件包

3. 构建 LAMMPS

3.7.具有额外构建选项的软件包

当使用某些包进行构建时，除了Build_package页面上描述的步骤之外，可能还需要额外的步骤。

对于CMake构建，可能有额外的可选或必需的变量要设置。对于使用make进行构建，可能需要首先构建lamp /lib目录下提供的库。或者需要在您的系统上存在外部库，或者需要下载并构建外部库。您可能需要告诉LAMMPS它在您的系统中的位置。这是可能需要额外步骤的软件包列表。

ADIOS	ATC	AWPMD	COLVARS	COMPRESS	ELECTRODE
GPU	H5MD	INTEL	KIM	KOKKOS	LEPTON
MACHDYN	MDI	ML-HDNNP	ML-IAP	ML-PACE	ML-POD
ML-QUIP	MOLFILE	NETCDF	OPENMP	OPT	PLUMED
POEMS	PYTHON	QMMM	SCAFACOS	VORONOI	VTK

3.7.1.COMPRESS包

要使用此软件包进行构建，您的系统上必须有可用的 zlib 压缩库，才能构建带有“/gz”后缀的转储样式。还有一些使用 Zstandard 库的样式，带有“/zstd”后缀。 zstd 库版本必须至少为 1.4。旧版本使用不兼容的 API，因此 LAMMPS 将无法编译。

CMake构建

如果 CMake 找不到 zlib 库或包含文件，您可以设置以下变量：

-D ZLIB_INCLUDE_DIR=path    # path to zlib.h header file
-D ZLIB_LIBRARY=path        # path to libz.a (.so) file

对 Zstandard 压缩的支持是自动检测的，因此 CMake 依赖于 pkg-config 工具来识别使用此库进行编译所需的标志，因此相应的 libzstandard.pc 文件必须位于 pkg-config 所在的文件夹中可以找到它，这可能需要将其添加到 PKG_CONFIG_PATH 环境变量中。

传统make构建

要包含对 Zstandard 压缩的支持，必须将 -DLAMMPS_ZSTD 添加到编译器标志中。如果 make 找不到库，您可以编辑文件 lib/compress/Makefile.lammps 来指定路径和库名称。这必须在安装包之前完成。

3.7.2. GPU 包

要使用此包进行构建，您必须选择精度选项以及要构建的 GPU 硬件。 GPU 包目前支持三种不同类型的后端：OpenCL、CUDA 和 HIP。

CMake 构建

-D GPU_API=value             # value = opencl (default) or cuda or hip
-D GPU_PREC=value            # precision setting
                             # value = double or mixed (default) or single
-D GPU_ARCH=value            # primary GPU hardware choice for GPU_API=cuda
                             # value = sm_XX (see below, default is sm_50)
-D GPU_DEBUG=value           # enable debug code in the GPU package library, mostly useful for developers
                             # value = yes or no (default)
-D HIP_PATH=value            # value = path to HIP installation. Must be set if GPU_API=HIP
-D HIP_ARCH=value            # primary GPU hardware choice for GPU_API=hip
                             # value depends on selected HIP_PLATFORM
                             # default is 'gfx906' for HIP_PLATFORM=amd and 'sm_50' for HIP_PLATFORM=nvcc
-D HIP_USE_DEVICE_SORT=value # enables GPU sorting
                             # value = yes (default) or no
-D CUDPP_OPT=value           # use GPU binning on with CUDA (should be off for modern GPUs)
                             # enables CUDA Performance Primitives, must be "no" for CUDA_MPS_SUPPORT=yes
                             # value = yes or no (default)
-D CUDA_MPS_SUPPORT=value    # enables some tweaks required to run with active nvidia-cuda-mps daemon
                             # value = yes or no (default)
-D CUDA_BUILD_MULTIARCH=value  # enables building CUDA kernels for all supported GPU architectures
                               # value = yes (default) or no
-D USE_STATIC_OPENCL_LOADER=value  # downloads/includes OpenCL ICD loader library, no local OpenCL headers/libs needed
                                   # value = yes (default) or no

GPU_ARCH 针对不同GPU硬件的设置如下：

sm_30 for Kepler（从 CUDA 5 到 CUDA 10.x 均受支持）
sm_35 或 sm_37 用于 Kepler（从 CUDA 5 到 CUDA 11.x 均受支持）
sm_50 或 sm_52 适用于 Maxwell（自 CUDA 6 起支持）
sm_60 或 sm_61 for Pascal（自 CUDA 8 起支持）
sm_70 for Volta（自 CUDA 9 起支持）
sm_75 for Turing（自 CUDA 10 起支持）
sm_80 或 sm_86 用于 Ampere（自 CUDA 11 起支持，sm_86 自 CUDA 11.1 起支持）
sm_89 for Lovelace（自 CUDA 11.8 起支持）
sm_90 for Hopper（自 CUDA 12.0 起支持）

例如，可以在 Wikipedia 的 CUDA文章中找到更详细的列表

CMake 可以检测使用的是哪个版本的 CUDA 工具包，因此将尝试包含对该工具包支持的所有主要 GPU 架构的支持。因此，GPU_ARCH 设置仅仅是一种优化，直接包含首选 GPU 架构的代码，而不必等待 CUDA 驱动程序的 JIT 编译器对其进行翻译。可以通过将 CUDA_ENABLE_MULTIARCH 设置为 no 来关闭此行为（例如，以加快编译速度）。

使用 CUDA 编译 CUDA 或 HIP 时，需要 8.0 或更高版本的 CUDA 工具包以及 Kepler 或更高版本的 GPU 架构，并且所使用的 CUDA 工具包和所使用的 CUDA 驱动程序也必须支持该架构。针对 OpenCL 进行编译时，需要 OpenCL 版本 1.2 或更高版本，并且 GPU 必须受到 GPU 驱动程序和与驱动程序捆绑的 OpenCL 运行时的支持。

使用 CMake 构建时，不得使用传统构建过程在 lib/gpu 中构建 GPU 库。 CMake 将检测该进程生成的文件，并终止并显示错误并提供如何删除它们的建议。

如果您正在针对 OpenCL 进行编译，则默认设置是下载、构建并链接静态 OpenCL ICD 加载程序库和标准 OpenCL 标头。这样，不需要存在本地 OpenCL 开发标头或库，只需安装 OpenCL 兼容驱动程序即可使用 OpenCL。如果不需要，您可以将 USE_STATIC_OPENCL_LOADER 设置为 no 。

GPU 库使用 OpenMP 提供一些多线程支持。如果 LAMMPS 是使用 -D BUILD_OMP=on 构建的，则也将启用此功能。

如果您使用 HIP 进行编译，请注意，在运行 CMake 之前，您必须设置适当的环境变量。 HCC_AMDGPU_TARGET （对于 ROCm <= 4.0）或 CUDA_PATH 等某些变量对于 hipcc 和链接器正常工作是必需的。

2022 年 8 月 3 日版本中的新增功能。

支持使用 HIP 的 CHIP-SPV 实现。它允许人们通过 OpenCL 或零级后端在 Intel GPU 上运行 HIP 代码。要使用 CHIP-SPV，您必须在 CMake 命令行中设置 -DHIP_USE_DEVICE_SORT=OFF ，因为 CHIP-SPV 尚不支持 hipCUB。截至 2022 年夏季，英特尔 GPU 的 HIP 使用处于实验阶段。您应该仅在准备在 Argonne 的 Aurora 系统上运行时使用此选项。

# AMDGPU target (ROCm <= 4.0)
export HIP_PLATFORM=hcc
export HIP_PATH=/path/to/HIP/install
export HCC_AMDGPU_TARGET=gfx906
cmake -D PKG_GPU=on -D GPU_API=HIP -D HIP_ARCH=gfx906 -D CMAKE_CXX_COMPILER=hipcc ..
make -j 4

# AMDGPU target (ROCm >= 4.1)
export HIP_PLATFORM=amd
export HIP_PATH=/path/to/HIP/install
cmake -D PKG_GPU=on -D GPU_API=HIP -D HIP_ARCH=gfx906 -D CMAKE_CXX_COMPILER=hipcc ..
make -j 4

# CUDA target (not recommended, use GPU_ARCH=cuda)
# !!! DO NOT set CMAKE_CXX_COMPILER !!!
export HIP_PLATFORM=nvcc
export HIP_PATH=/path/to/HIP/install
export CUDA_PATH=/usr/local/cuda
cmake -D PKG_GPU=on -D GPU_API=HIP -D HIP_ARCH=sm_70 ..
make -j 4

# SPIR-V target (Intel GPUs)
export HIP_PLATFORM=spirv
export HIP_PATH=/path/to/HIP/install
export CMAKE_CXX_COMPILER=<hipcc/clang++>
cmake -D PKG_GPU=on -D GPU_API=HIP ..
make -j 4

传统make

在构建 LAMMPS 之前，您必须在 lib/gpu 中构建 GPU 库。如果您愿意，可以手动执行此操作；请按照 lib/gpu/README 中的说明进行操作。请注意，GPU 库使用 MPI 调用，因此您必须使用与主 LAMMPS 代码相同的 MPI 库（或 STUBS 库）设置。这也适用于您使用的任何 Makefile 中的 -DLAMMPS_BIGBIG 、 -DLAMMPS_SMALLBIG 或 -DLAMMPS_SMALLSMALL 设置。

您还可以使用如下命令从 lammps/src 目录一步构建库，该命令只需使用指定的参数调用 lib/gpu/Install.py 脚本：

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

请注意，此过程从 lib/gpu 中的 Makefile.machine 开始，由“-m”开关指定。为了您的方便，提供了“mpi”和“serial”的机器makefile，它们与主LAMMPS源文件夹中相应的机器makefile具有相同的设置。此外，您可以通过相应的 -c、-a、-p、-e 开关（如上面的示例）更改您启动的 Makefile.machine 中的 4 个重要设置，如果需要，还可以保存新 Makefile 的副本：

CUDA_HOME = 系统上 NVIDIA CUDA 软件的安装位置
CUDA_ARCH = sm_XX，你有什么GPU硬件，与上面的CMake GPU_ARCH相同
CUDA_PRECISION = 精度（双精度、混合精度、单精度）
EXTRAMAKE = 要复制到 Makefile.lammps 的 Makefile.lammps.* 文件

GPU 库使用 OpenMP 提供一些多线程支持。您需要将启用 OpenMP 的编译器标志添加到 CUDR_OPTS Makefile 变量中。

如果库构建成功，应创建 3 个文件：

lib/gpu/libgpu.a 、 lib/gpu/nvc_get_devices 和 lib/gpu/Makefile.lammps 。

后者具有使 LAMMPS 能够与 CUDA 库链接的设置。如果您计算机的 Makefile.lammps 中的设置不正确，则 LAMMPS 构建将会失败，并且可能需要编辑 lib/gpu/Makefile.lammps 。

注意：如果您在 lib/gpu 中重新构建 GPU 库，则应始终卸载 lammps/src 中的 GPU 包，然后重新安装并重新构建 LAMMPS。这是因为 GPU 包中的文件编译使用用于构建 GPU 库的 lib/gpu/Makefile.machine 中的库设置。

3.7.3. KIM 包

要使用此包进行构建，必须下载带有 API v2 的 KIM 库并在您的系统上构建。它必须包含您想要与 LAMMPS 一起使用的 KIM 模型。

如果您想使用 kim property 命令，则需要使用安装的 PYTHON 包并链接到 Python 3.6 或更高版本来构建 LAMMPS。有关更多详细信息，请参阅 PYTHON 包构建信息。使用 Python 成功构建 LAMMPS 后，您还需要安装 kim-property Python 包，这可以使用 pip 作为 pip install kim-property 轻松完成，或者从 conda-forge 通道作为 conda install kim-property 如果 LAMMPS 是在 Conda 中构建的。更详细的信息可参见：kim-property 安装。

除了安装KIM API之外，还需要安装KIM模型库（原子间势）。请参阅获取 KIM 模型，了解如何安装 OpenKIM 模型存储库的预构建二进制文件。请在此处查看所有 KIM 模型的列表：https://openkim.org/browse/models

（另请注意，从源代码下载并安装 KIM API 库及其所有模型时，可能需要很长时间（几十分钟到几小时）来构建。当然，您只需要执行一次。）

CMake构建

-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
-D KIM_EXTRA_UNITTESTS=value    # enables extra unit tests, value = no (default) or yes

如果 DOWNLOAD_KIM 设置为 yes（或 on），则将下载 KIM API 库并在 CMake 构建目录中构建。如果 KIM 库已安装在您的系统上（在 CMake 找不到它的位置），可能需要设置 PKG_CONFIG_PATH 环境变量以便可以找到 libkim-api，或运行命令 < b2> 。

仅当明确请求（ KIM_EXTRA_UNITTESTS 设置为 yes（或 on））并且满足先决条件时，额外的单元测试才可用。有关详细信息，请参阅 KIM Extra 单元测试。

传统make
如果您愿意，可以手动下载并构建 KIM 库；请按照 lib/kim/README 中的说明进行操作。您还可以使用类似这样的命令从 lammps/src 目录一步完成此操作，该命令只需使用指定的参数调用 lib/kim/Install.py 脚本。

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

当使用“-b”选项时，KIM 库是使用其本机 cmake 构建系统构建的。如果系统上 cmake 可执行文件的名称不是 cmake ，则 lib/kim/Install.py 脚本支持 CMAKE 环境变量。可以在命令行上提供其他环境变量以供 cmake 使用。例如，要使用 cmake3 可执行文件并告诉它使用 gnu 版本 11 编译器来构建 KIM，可以使用以下命令行。

CMAKE=cmake3 CXX=g++-11 CC=gcc-11 FC=gfortran-11 make lib-kim args="-b "  # (re-)install KIM API lib using cmake3 and gnu v11 compilers with only example models

需要通过编辑您正在使用的 Makefile.machine 将它们添加到 LMP_INC 变量来应用下面讨论的调试 OpenKIM Web 查询的设置。例如：

LMP_INC = -DLMP_NO_SSL_CHECK

在 LAMMPS 中调试 OpenKIM Web 查询

如果设置了 LMP_DEBUG_CURL ，则将打开 libcurl 详细模式，并且 KIM Web 查询中的任何 libcurl 调用都会显示有关 libcurl 操作的大量信息。您几乎不需要在生产使用中使用此设置，当您调试或报告问题时您几乎总是需要此设置。

libcurl 库默认执行对等 SSL 证书验证。此验证是使用 CA 证书存储完成的，SSL 库可以使用该存储来确保对等方的服务器证书有效。如果 SSL 在握手期间报告错误（“证书验证失败”）并因此拒绝与该服务器进一步通信，您可以设置 LMP_NO_SSL_CHECK 来覆盖该行为。当使用 LMP_NO_SSL_CHECK 设置编译 LAMMPS 时，libcurl 不会验证对等方，并且无论证书中的名称如何，连接尝试都会成功。此选项是不安全的。作为替代方案，您可以通过将环境变量 CURL_CA_BUNDLE 设置为您选择的路径来指定您自己的 CA 证书路径。对 KIM Web 查询的调用将从环境变量中获取该值。

KIM 额外单元测试（仅限 CMake）

在开发、测试或调试过程中，如果在 LAMMPS 中启用了单元测试，还可以通过将 KIM_EXTRA_UNITTESTS 设置为 yes（或 on）来启用对 KIM 命令的额外测试。

启用额外的单元测试有一些要求，

它需要能够访问互联网。
它需要安装 libcurl 以及匹配的开发标头和curl-config 工具。
它需要使用安装的 PYTHON 包并链接到 Python 3.6 或更高版本来构建 LAMMPS。有关更多详细信息，请参阅 PYTHON 包构建信息。
它需要安装 kim-property Python 包，这可以使用 pip 作为 pip install kim-property 轻松完成，或者从 conda-forge 通道作为 conda install kim-property （如果构建了 LAMMPS）在康达。更详细的信息可参见：kim-property 安装。
还需要安装 EAM_Dynamo_MendelevAckland_2007v3_Zr__MO_004835508849_000 、 EAM_Dynamo_ErcolessiAdams_1994_Al__MO_123629422045_005 和 LennardJones612_UniversalShifted__MO_959249795837_003 KIM 模型。请参阅获取 KIM 模型以了解如何安装 OpenKIM 模型存储库的预构建二进制文件，或请参阅安装 KIM 模型以了解如何安装特定的 KIM 模型。

3.7.4. KOKKOS 包

使用 KOKKOS 包需要选择多个设置。您必须选择是否要在主机上进行并行编译，以及是否要将计算卸载到设备（例如 GPU）。默认设置是没有主机并行化和设备卸载。此外，还可以通过选择硬件架构来选择指令集。由于大多数硬件都是向后兼容的，因此您可以选择旧体系结构的设置，以使可执行文件可以在此体系结构和较新的体系结构上运行。

注：如果您在与 LAMMPS 编译所用的 GPU 架构不同的 GPU 架构上运行 Kokkos，则在设备初始化期间，当即时编译器为新硬件重新编译所有 GPU 内核时，将会出现延迟。然而，这仅支持相同主要硬件版本和不同次要硬件版本的 GPU，例如5.0 和 5.2，但不是 5.2 和 6.0。如果发生这种情况，LAMMPS 将中止并显示一条指示不匹配的错误消息。

下面讨论的设置已经过 LAMMPS 测试并被确认可以工作。 Kokkos 是一个活跃的项目，正在进行改进和项目，包括对其他架构的支持。有关 Kokkos 的更多信息可以在 Kokkos GitHub项目上找到。

可用的架构设置

这些是 Kokkos 架构 ID 的可能选择。它们必须以大写形式指定。

Arch-ID	HOST or GPU	Description
NATIVE	HOST	Local machine
AMDAVX	HOST	AMD 64-bit x86 CPU (AVX 1)
ZEN	HOST	AMD Zen class CPU (AVX 2)
ZEN2	HOST	AMD Zen2 class CPU (AVX 2)
ZEN3	HOST	AMD Zen3 class CPU (AVX 2)
ARMV80	HOST	ARMv8.0 Compatible CPU
ARMV81	HOST	ARMv8.1 Compatible CPU
ARMV8_THUNDERX	HOST	ARMv8 Cavium ThunderX CPU
ARMV8_THUNDERX2	HOST	ARMv8 Cavium ThunderX2 CPU
A64FX	HOST	ARMv8.2 with SVE Support
WSM	HOST	Intel Westmere CPU (SSE 4.2)
SNB	HOST	Intel Sandy/Ivy Bridge CPU (AVX 1)
HSW	HOST	Intel Haswell CPU (AVX 2)
BDW	HOST	Intel Broadwell Xeon E-class CPU (AVX 2 + transactional mem)
SKL	HOST	Intel Skylake Client CPU
SKX	HOST	Intel Skylake Xeon Server CPU (AVX512)
ICL	HOST	Intel Ice Lake Client CPU (AVX512)
ICX	HOST	Intel Ice Lake Xeon Server CPU (AVX512)
SPR	HOST	Intel Sapphire Rapids Xeon Server CPU (AVX512)
KNC	HOST	Intel Knights Corner Xeon Phi
KNL	HOST	Intel Knights Landing Xeon Phi
BGQ	HOST	IBM Blue Gene/Q CPU
POWER7	HOST	IBM POWER7 CPU
POWER8	HOST	IBM POWER8 CPU
POWER9	HOST	IBM POWER9 CPU
KEPLER30	GPU	NVIDIA Kepler generation CC 3.0 GPU
KEPLER32	GPU	NVIDIA Kepler generation CC 3.2 GPU
KEPLER35	GPU	NVIDIA Kepler generation CC 3.5 GPU
KEPLER37	GPU	NVIDIA Kepler generation CC 3.7 GPU
MAXWELL50	GPU	NVIDIA Maxwell generation CC 5.0 GPU
MAXWELL52	GPU	NVIDIA Maxwell generation CC 5.2 GPU
MAXWELL53	GPU	NVIDIA Maxwell generation CC 5.3 GPU
PASCAL60	GPU	NVIDIA Pascal generation CC 6.0 GPU
PASCAL61	GPU	NVIDIA Pascal generation CC 6.1 GPU
VOLTA70	GPU	NVIDIA Volta generation CC 7.0 GPU
VOLTA72	GPU	NVIDIA Volta generation CC 7.2 GPU
TURING75	GPU	NVIDIA Turing generation CC 7.5 GPU
AMPERE80	GPU	NVIDIA Ampere generation CC 8.0 GPU
AMPERE86	GPU	NVIDIA Ampere generation CC 8.6 GPU
ADA89	GPU	NVIDIA Ada Lovelace generation CC 8.9 GPU
HOPPER90	GPU	NVIDIA Hopper generation CC 9.0 GPU
AMD_GFX906	GPU	AMD GPU MI50/MI60
AMD_GFX908	GPU	AMD GPU MI100
AMD_GFX90A	GPU	AMD GPU MI200
AMD_GFX942	GPU	AMD GPU MI300
AMD_GFX1030	GPU	AMD GPU V620/W6800
AMD_GFX1100	GPU	AMD GPU RX7900XTX
INTEL_GEN	GPU	SPIR64-based devices, e.g. Intel GPUs, using JIT
INTEL_DG1	GPU	Intel Iris XeMAX GPU
INTEL_GEN9	GPU	Intel GPU Gen9
INTEL_GEN11	GPU	Intel GPU Gen11
INTEL_GEN12LP	GPU	Intel GPU Gen12LP
INTEL_XEHP	GPU	Intel GPU Xe-HP
INTEL_PVC	GPU	Intel GPU Ponte Vecchio

此列表上次更新是在Kokkos库的4.2版。

基本CMake构建设置

对于使用 OpenMP 的多核 CPU，请设置这 2 个变量。

-D Kokkos_ARCH_HOSTARCH=yes  # HOSTARCH = HOST from list above
-D Kokkos_ENABLE_OPENMP=yes
-D BUILD_OMP=yes

请注意，为 KOKKOS 启用 OpenMP 需要为其余 LAMMPS 启用 OpenMP。

对于使用 OpenMP 的 Intel KNL，设置以下变量：

-D Kokkos_ARCH_KNL=yes
-D Kokkos_ENABLE_OPENMP=yes

对于使用 CUDA 的 NVIDIA GPU，设置以下变量：

-D Kokkos_ARCH_HOSTARCH=yes   # HOSTARCH = HOST from list above
-D Kokkos_ARCH_GPUARCH=yes    # GPUARCH = GPU from list above
-D Kokkos_ENABLE_CUDA=yes
-D Kokkos_ENABLE_OPENMP=yes

这还可以通过内部 KISSFFT 库或（根据偏好）使用与 CUDA 工具包捆绑的 cuFFT 库在 GPU 上执行 FFT，具体取决于 CMake 是否可以识别其位置。

对于使用 HIP 的 AMD 或 NVIDIA GPU，请设置以下变量：

-D Kokkos_ARCH_HOSTARCH=yes   # HOSTARCH = HOST from list above
-D Kokkos_ARCH_GPUARCH=yes    # GPUARCH = GPU from list above
-D Kokkos_ENABLE_HIP=yes
-D Kokkos_ENABLE_OPENMP=yes

这将通过内部 KISSFFT 库或使用 hipFFT 包装器库在 GPU 上启用 FFT，后者将调用适合平台的供应商库：AMD GPU 上的 rocFFT 或 NVIDIA GPU 上的 cuFFT。

为了简化编译， cmake/presets 文件夹中包含了五个预设文件，kokkos-serial.cmake 、 kokkos-openmp.cmake 、 kokkos-cuda.cmake 、 kokkos-hip.cmake 和 kokkos-sycl.cmake 。他们将启用 KOKKOS 软件包并启用一些硬件选择。为了支持 GPU，必须自定义这些预设文件以匹配所使用的硬件。因此，要在启用一些通用包的情况下使用 CUDA 设备并行化进行编译，您可以执行以下操作：

mkdir build-kokkos-cuda
cd build-kokkos-cuda
cmake -C ../cmake/presets/basic.cmake -C ../cmake/presets/kokkos-cuda.cmake ../cmake
cmake --build .

基本传统make构建设置

通过 KOKKOS_DEVICES 和 KOKKOS_ARCH 设置在 Makefile.machine 中选择支持的硬件。有关示例，请参阅 src/MAKE/OPTIONS/Makefile.kokkos* 文件。

对于使用 OpenMP 的多核 CPU：

KOKKOS_DEVICES = OpenMP
KOKKOS_ARCH = HOSTARCH          # HOSTARCH = HOST from list above

对于使用 OpenMP 的 Intel KNL：

KOKKOS_DEVICES = OpenMP
KOKKOS_ARCH = KNL

对于使用 CUDA 的 NVIDIA GPU：

KOKKOS_DEVICES = Cuda
KOKKOS_ARCH = HOSTARCH,GPUARCH  # HOSTARCH = HOST from list above that is hosting the GPU
KOKKOS_CUDA_OPTIONS = "enable_lambda"
                                # GPUARCH = GPU from list above
FFT_INC = -DFFT_CUFFT           # enable use of cuFFT (optional)
FFT_LIB = -lcufft               # link to cuFFT library

对于 GPU，在定义 CC 行之前，您还需要在 Makefile.machine 中添加以下行。他们告诉 mpicxx 使用 nvcc 编译器包装器，它将使用 nvcc 来编译 CUDA 文件，并使用 C++ 编译器来编译非 Kokkos、非 CUDA 文件。

# For OpenMPI
KOKKOS_ABSOLUTE_PATH = $(shell cd $(KOKKOS_PATH); pwd)
export OMPI_CXX = $(KOKKOS_ABSOLUTE_PATH)/config/nvcc_wrapper
CC = mpicxx

# For MPICH and derivatives
KOKKOS_ABSOLUTE_PATH = $(shell cd $(KOKKOS_PATH); pwd)
CC = mpicxx -cxx=$(KOKKOS_ABSOLUTE_PATH)/config/nvcc_wrapper

对于使用 HIP 的 AMD 或 NVIDIA GPU：

KOKKOS_DEVICES = HIP
KOKKOS_ARCH = HOSTARCH,GPUARCH  # HOSTARCH = HOST from list above that is hosting the GPU
                                # GPUARCH = GPU from list above
FFT_INC = -DFFT_HIPFFT           # enable use of hipFFT (optional)
FFT_LIB = -lhipfft               # link to hipFFT library

高级 KOKKOS 编译设置

使用 KOKKOS 包构建时还有其他允许的选项，可以提高性能或帮助调试或分析。以下是一些与 LAMMPS 结合使用可能有用的示例。有关完整列表（随着 Kokkos 包本身的发展而不断变化），请查阅 Kokkos 库文档。

作为通过 OpenMP 使用多线程（ -DKokkos_ENABLE_OPENMP=on 或 KOKKOS_DEVICES=OpenMP ）的替代方案，也可以直接使用 Posix 线程（ -DKokkos_ENABLE_PTHREAD=on 或 KOKKOS_DEVICES=Pthread ).虽然线程与单个或一组 CPU 内核的绑定是在 OpenMP 中使用环境变量进行管理的，但您需要“hwloc”或“libnuma”库的帮助来实现 Pthread 线程并行化选项。要启用与 CMake 的使用： -DKokkos_ENABLE_HWLOC=on 或 -DKokkos_ENABLE_LIBNUMA=on ；以及传统的 make:KOKKOS_USE_TPLS=hwloc 或 KOKKOS_USE_TPLS=libnuma 。

CMake 选项 -DKokkos_ENABLE_LIBRT=on 或 makefile 设置 KOKKOS_USE_TPLS=librt 允许在许多类 Unix 平台上使用更准确的计时器机制进行内部分析。

CMake 选项 -DKokkos_ENABLE_DEBUG=on 或 makefile 设置 KOKKOS_DEBUG=yes 允许打印有用的运行时调试信息。它还支持对 Kokkos 数据结构进行运行时边界检查。正如预期的那样，启用此选项会对性能产生负面影响，因此仅建议在 LAMMPS 中开发支持 Kokkos 的样式时使用。

CMake 选项 -DKokkos_ENABLE_CUDA_UVM=on 或 makefile 设置 KOKKOS_CUDA_OPTIONS=enable_lambda,force_uvm 允许在 Kokkos 中使用 CUDA“统一虚拟内存”(UVM)。 UVM 允许透明地使用主机上的 RAM 来补充 GPU 上使用的内存（会带来一些性能损失），从而能够运行原本无法放入 GPU 上 RAM 的更大问题。

请注意，使用 GPU 时，必须始终使用 enable_lambda 选项编译 LAMMPS KOKKOS 包。因此，CMake 配置将始终启用它。

3.7.5. LEPTON 包

要使用此包进行构建，您必须构建 Lepton 库，该库包含在 LAMMPS 源代码发行版的 lib/lepton 文件夹中。

CMake构建

这是在 LAMMPS 中使用 Lepton 的推荐构建过程。除了 -D PKG_LEPTON=yes 之外，通常不需要其他设置。

在 x86 硬件上，Lepton 库还将包含一个即时编译器，以加快执行速度。这是自动检测到的，但可以通过设置 -D LEPTON_ENABLE_JIT=no 显式禁用（或通过将其设置为 yes 启用）。

传统make

在构建 LAMMPS 之前，必须在 lib/lepton 中构建 Lepton 库。

这可以通过使用或调整提供的 Makefile 之一在同一文件夹中手动完成：例如，对于 GNU C++ 编译器为 Makefile.serial ，或者对于 MPI 编译器包装器为 Makefile.mpi 。 Lepton 库是用 C++-11 编写的，因此可能需要指示 C++ 编译器启用对此的支持。

一般来说，使用与 LAMMPS 其余部分一致的构建设置会更安全。最好使用如下命令从 LAMMPS src 目录执行此操作，该命令只需使用指定的参数调用 lib/lepton/Install.py 脚本：

make lib-lepton                      # print help message
make lib-lepton args="-m serial"     # build with GNU g++ compiler (settings as with "make serial")
make lib-lepton args="-m mpi"        # build with default MPI compiler (settings as with "make mpi")

“-m”标志的“machine”参数用于查找 Makefile.machine 以用作构建配方。
构建应生成一个 build 文件夹和库 lib/lepton/liblmplepton.a

3.7.6. MACHDYN 包

要使用此包进行构建，您必须下载 Eigen3 库。 Eigen3 是一个模板库，因此您不需要构建它。

CMake构建

-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)

如果设置了 DOWNLOAD_EIGEN3 ，则将下载 Eigen3 库并将其放置在 CMake 构建目录中。如果 Eigen3 库已在您的系统上（位于 CMake 找不到它的位置），请将 EIGEN3_INCLUDE_DIR 设置为 Eigen3 包含文件所在的目录。

传统make

如果您愿意，可以手动下载 Eigen3 库；请按照 lib/machdyn/README 中的说明进行操作。您还可以使用如下命令从 lammps/src 目录一步完成此操作，该命令只需使用指定的参数调用 lib/machdyn/Install.py 脚本：

make lib-machdyn                         # print help message
make lib-machdyn args="-b"               # download to lib/machdyn/eigen3
make lib-machdyn args="-p /usr/include/eigen3"    # use existing Eigen installation in /usr/include/eigen3

请注意，在 lib/machdyn 中创建了一个名为 includelink 的符号（软）链接，以指向 Eigen 目录。当 LAMMPS 构建时，它将使用此链接。您不需要编辑 lib/machdyn/Makefile.lammps 文件。

3.7.7. ML-IAP 包

构建 ML-IAP 包需要包含 ML-SNAP 包。如果不满足此要求，将会出现错误消息。使用 mliappy 模型还需要启用 Python 支持，这又需要包含 PYTHON 包，并需要安装 cython 软件及其有效的 cythonize 命令。此功能需要使用 Python 3.6 或更高版本编译 LAMMPS。

CMake构建

-D MLIAP_ENABLE_PYTHON=value   # enable mliappy model (default is autodetect)

如果没有此设置，CMake 将检查是否可以找到合适的 Python 版本和 cythonize 命令并相应地选择默认值。在构建过程中，提供的 .pyx 文件将自动转换为 C++ 代码并进行编译。请不要在 src/ML-IAP 文件夹中手动运行 cythonize ，因为如果未启用 Python 支持，可能会导致编译错误。如果您不小心这样做，请删除生成的 .cpp 和 .h 文件。

传统make

构建在编译/链接过程中使用 lib/python/Makefile.mliap_python 文件添加一条规则，以更新由 cythonize 命令生成的文件，以防相应的 .pyx 文件被修改。如果 LAMMPS 构建失败，您可能需要修改 lib/python/Makefile.lammps 。

要在启用 Python 支持的情况下构建 ML-IAP 包，您需要将 -DMLIAP_PYTHON 添加到机器 makefile 中的 LMP_INC 变量。如果安装 ML-IAP 软件包期间未自动执行此操作，您可能需要对 src 文件夹中的 .pyx 文件手动运行 cythonize 命令。请不要在 src/ML-IAP 文件夹中运行 cythonize ，因为如果未启用 Python 支持，可能会导致编译错误。如果您不小心这样做了，请删除生成的 .cpp 和 .h 文件。

3.7.8.OPT包

CMake构建

除 -D PKG_OPT=yes 外无需其他设置

传统make构建

使用 Intel 编译器时，必须使用编译器标志 -restrict 来通过 OPT 包构建 LAMMPS。它应该添加到 Makefile.machine 的 CCFLAGS 行中。有关示例，请参阅 src/MAKE/OPTIONS/Makefile.opt 。

3.7.9. POEMS 包

CMake构建

除 -D PKG_OPT=yes 外无需其他设置

传统make构建

在构建 LAMMPS 之前，您必须在 lib/poems 中构建 POEMS 库。如果您愿意，可以手动执行此操作；请按照 lib/poems/README 中的说明进行操作。您还可以使用如下命令从 lammps/src 目录一步完成此操作，该命令只需使用指定的参数调用 lib/poems/Install.py 脚本：

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

构建应生成两个文件： lib/poems/libpoems.a 和 lib/poems/Makefile.lammps 。后者是从现有的 Makefile.lammps.* 复制的，并且具有使用 POEMS 库构建 LAMMPS 所需的设置（尽管通常这些设置只是空白）。如有必要，您可以为系统编辑/创建一个新的 lib/poems/Makefile.machine 文件，该文件应定义一个 EXTRAMAKE 变量来指定相应的 Makefile.lammps.machine 文件。

3.7.10. PYTHON 包

CMake构建

如果没有此设置，CMake 将猜测系统上的默认 Python 版本。要使用不同的 Python 版本，您可以创建一个 virtualenv，激活它，然后运行 cmake。或者您可以设置 Python_EXECUTABLE 变量来指定应使用哪个 Python 解释器。请注意，您还需要为此版本安装开发标头，例如python2-开发。

传统make构建

构建在编译/链接过程中使用 lib/python/Makefile.lammps 文件来查找 Python。如果 LAMMPS 构建失败，您只需要创建一个新的 Makefile.lammps.* 文件（并将其复制到 Makefile.lammps ）。

3.7.11. VORONOI 包

要使用此包进行构建，您必须下载并构建 Voro++ 库或安装操作系统提供的二进制包。

CMake构建

-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)

如果设置了 DOWNLOAD_VORO ，则将下载 Voro++ 库并在 CMake 构建目录中构建。如果 Voro++ 库已在您的系统上（位于 CMake 找不到它的位置），则 VORO_LIBRARY 是 Voro++ 库文件的文件名（加上路径），而不是库文件所在的目录。 VORO_INCLUDE_DIR 是 Voro++ 包含文件所在的目录。

传统make构建

如果您愿意，可以手动下载并构建 Voro++ 库；请按照 lib/voronoi/README 中的说明进行操作。您还可以使用如下命令从 lammps/src 目录一步完成此操作，该命令只需使用指定的参数调用 lib/voronoi/Install.py 脚本：

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

请注意，在 lib/voronoi 中创建了 2 个符号（软）链接 includelink 和 liblink ，以指向 Voro++ 源目录。当 LAMMPS 在 src 中构建时，它将使用这些链接。您不需要编辑 lib/voronoi/Makefile.lammps 文件。

3.7.12. ADIOS 包

ADIOS 软件包需要 ADIOS I/O 库 2.3.1 或更高版本。如果您构建带有或不带有 MPI 的 LAMMPS，请确保您构建的 ADIOS 带有或不带 MPI 来匹配。如果已为本地 ADIOS 安装更新 PATH 和 LD_LIBRARY_PATH 环境变量，并且针对相应的构建系统遵循以下说明，则会自动检测 LAMMPS 的 ADIOS 编译设置。

CMake构建

-D ADIOS2_DIR=path        # path is where ADIOS 2.x is installed
-D PKG_ADIOS=yes

传统make构建

在构建 LAMMPS 之前打开 ADIOS 软件包。如果 ADIOS 2.x 软件安装在 PATH 中，则无需执行其他操作：

make yes-adios

否则，请在打开软件包时设置 ADIOS2_DIR 环境变量：

ADIOS2_DIR=path make yes-adios   # path is where ADIOS 2.x is installed

3.7.13. ATC 包

ATC 软件包还需要安装 MANYBODY 软件包。

CMake构建

除了 -D PKG_ATC=yes 和 -D PKG_MANYBODY=yes 之外，不需要其他设置。

传统make构建

在构建 LAMMPS 之前，您必须在 lib/atc 中构建 ATC 库。如果您愿意，可以手动执行此操作；请按照 lib/atc/README 中的说明进行操作。您还可以使用如下命令从 lammps/src 目录一步完成此操作，该命令只需使用指定的参数调用 lib/atc/Install.py 脚本：

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

构建应生成两个文件： lib/atc/libatc.a 和 lib/atc/Makefile.lammps 。后者是从现有的 Makefile.lammps.* 复制的，并且具有使用 ATC 库构建 LAMMPS 所需的设置。如有必要，您可以为系统编辑/创建一个新的 lib/atc/Makefile.machine 文件，该文件应定义一个 EXTRAMAKE 变量来指定相应的 Makefile.lammps.<machine> 文件。

请注意，Makefile.lammps 文件具有 BLAS 和 LAPACK 线性代数库的设置。如 lib/atc/README 中所述，这些文件可以存在于您的系统上，或者您可以使用 lib/linalg 中提供的文件。在后一种情况下，您还需要使用如下命令在 lib/linalg 中构建库：

make lib-linalg                   # print help message
make lib-linalg args="-m serial"  # build with GNU C++ compiler (settings as with "make serial")
make lib-linalg args="-m mpi"     # build with default MPI C++ compiler (settings as with "make mpi")
make lib-linalg args="-m g++"     # build with GNU Fortran compiler

3.7.14. AWPMD 包

CMake构建

除了 -D PKG_AQPMD=yes 之外不需要其他设置。

传统make构建

在构建 LAMMPS 之前，您必须在 lib/awpmd 中构建 AWPMD 库。如果您愿意，可以手动执行此操作；请按照 lib/awpmd/README 中的说明进行操作。您还可以使用如下命令从 lammps/src 目录一步完成此操作，该命令只需使用指定的参数调用 lib/awpmd/Install.py 脚本：

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

构建应生成两个文件： lib/awpmd/libawpmd.a 和 lib/awpmd/Makefile.lammps 。后者是从现有的 Makefile.lammps.* 复制的，并且具有使用 AWPMD 库构建 LAMMPS 所需的设置。如有必要，您可以为系统编辑/创建一个新的 lib/awpmd/Makefile.machine 文件，该文件应定义一个 EXTRAMAKE 变量来指定相应的 Makefile.lammps.<machine> 文件。

请注意， Makefile.lammps 文件具有 BLAS 和 LAPACK 线性代数库的设置。如 lib/awpmd/README 中所述，这些文件可以存在于您的系统上，或者您可以使用 lib/linalg 中提供的文件。在后一种情况下，您还需要使用如下命令在 lib/linalg 中构建库：

make lib-linalg                   # print help message
make lib-linalg args="-m serial"  # build with GNU C++ compiler (settings as with "make serial")
make lib-linalg args="-m mpi"     # build with default MPI C++ compiler (settings as with "make mpi")
make lib-linalg args="-m g++"     # build with GNU C++ compiler

3.7.15. COLVARS 包

该软件包允许使用 LAMMPS 源代码发行版中包含的 Colvars 模块。

CMake构建

这是在 LAMMPS 中使用 Colvars 的推荐构建过程。除了 -D PKG_COLVARS=yes 之外，通常不需要其他设置。

传统make构建

与随 LAMMPS 一起分发的其他库一样，需要在启用 COLVARS 包的情况下构建 LAMMPS 程序之前构建 Colvars 库。

在 LAMMPS src 目录中，可以通过以下命令之一最轻松、安全地完成此操作，该命令隐式依赖于带有可选参数的 lib/colvars/Install.py 脚本：

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

“-m”标志的“machine”参数用于查找用作构建配方的 Makefile.machine 文件。如果 lib/colvars 中尚不存在这样的配方，则会自动生成与核心 LAMMPS makefile 中使用的一致的合适设置。

在 2023 年 2 月 8 日版本中进行了更改。

请注意，Colvars 使用 Lepton 库，该库现已包含在 LEPTON 包中；如果您使用 make lib-colvars 命令以外的任何命令，请确保事先构建 Lepton。

可选标志可以指定为环境变量：

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)

构建应生成两个文件：库 lib/colvars/libcolvars.a 和规范文件 lib/colvars/Makefile.lammps 。后者是自动生成的，通常不需要编辑。

3.7.16.ELECTRODE包

该软件包依赖于 KSPACE 软件包。

CMake构建

-D PKG_ELECTRODE=yes          # enable the package itself
-D PKG_KSPACE=yes             # the ELECTRODE package requires KSPACE
-D USE_INTERNAL_LINALG=value  #

ELECTRODE 包中的功能依赖于 KSPACE 包中的代码，因此必须启用后者。

ELECTRODE 包还需要 LAPACK（和 BLAS），CMake 可以识别它们的位置并将该信息传递给 ELECTRODE 构建脚本。但在某些系统上，当不需要链接或依赖关系时，这可能会导致问题。在这些情况下尝试启用 USE_INTERNAL_LINALG 以使用捆绑的线性代数库并解决该限制。

传统make构建

在构建 LAMMPS 之前，您必须在 lib/electrode 中配置 ELECTRODE 支持库和设置。如果您愿意，您可以手动执行此操作，或者使用如下命令从 lammps/src 目录一步执行此操作，该命令只需使用指定的参数调用 lib/electrode/Install.py 脚本：

make lib-electrode                   # print help message
make lib-electrode args="-m serial"  # build with GNU g++ compiler and MPI STUBS (settings as with "make serial")
make lib-electrode args="-m mpi"     # build with default MPI compiler (settings as with "make mpi")

请注意， Makefile.lammps 文件具有 BLAS 和 LAPACK 线性代数库的设置。这些可以存在于您的系统上，也可以使用 lib/linalg 中提供的文件。在后一种情况下，您还需要使用如下命令在 lib/linalg 中构建库：

make lib-linalg                   # print help message
make lib-linalg args="-m serial"  # build with GNU C++ compiler (settings as with "make serial")
make lib-linalg args="-m mpi"     # build with default MPI C++ compiler (settings as with "make mpi")
make lib-linalg args="-m g++"     # build with GNU C++ compiler

包本身通过 make yes-KSPACE 和 make yes-ELECTRODE 激活

3.7.17. ML-PACE 包

这个包需要一个可以在 lib/pace 或其他地方下载和构建的库，这必须在使用这个包构建 LAMMPS 之前完成。该库的代码可以在以下位置找到：https://github.com/ICAMS/lammps-user-pace/

CMake构建

默认情况下，当使用 -D PKG_ML-PACE=yes 启用 ML-PACE 包时，将从 git 存储库下载该库并自动构建该库。在使用 CMake 配置时，可以通过设置变量 PACELIB_URL 来自定义源的位置（例如，在无法访问互联网的计算机上使用本地存档）。由于 CMake 使用 md5sum 检查存档的有效性，如果您提供的库版本与自动下载的库版本不同，您可能还需要设置 PACELIB_MD5 。

传统make构建

您可以使用这些调用 lib/pace/Install.py 脚本的命令从 lammps/src 目录一步下载并构建 ML-PACE 库。

make lib-pace                          # print help message
make lib-pace args="-b"                # download and build the default version in lib/pace

您不需要编辑 lib/pace/Makefile.lammps 文件。

3.7.18. ML-POD 包

CMake构建

除了 -D PKG_ML-POD=yes 之外不需要其他设置。

传统make构建

在构建 LAMMPS 之前，您必须在 lib/mlpod 中配置 ML-POD 支持设置。如果您愿意，您可以手动执行此操作，或者使用如下命令从 lammps/src 目录一步执行此操作，该命令只需使用指定的参数调用 lib/mlpod/Install.py 脚本:

make lib-mlpod                   # print help message
make lib-mlpod args="-m serial"  # build with GNU g++ compiler and MPI STUBS (settings as with "make serial")
make lib-mlpod args="-m mpi"     # build with default MPI compiler (settings as with "make mpi")
make lib-mlpod args="-m mpi -e linalg"   # same as above but use the bundled linalg lib

请注意， Makefile.lammps 文件具有使用 BLAS 和 LAPACK 线性代数库的设置。这些可以存在于您的系统上，也可以使用 lib/linalg 中提供的文件。在后一种情况下，您还需要使用如下命令在 lib/linalg 中构建库：

make lib-linalg                   # print help message
make lib-linalg args="-m serial"  # build with GNU C++ compiler (settings as with "make serial")
make lib-linalg args="-m mpi"     # build with default MPI C++ compiler (settings as with "make mpi")
make lib-linalg args="-m g++"     # build with GNU C++ compiler

包本身通过 make yes-ML-POD 激活。

3.7.19. ML-QUIP 包

要使用此包进行构建，您必须下载并构建 QUIP 库。可以从 GitHub 获取。为了支持 GAP 潜力，需要下载和配置具有特定许可条件的其他文件。自动下载将从 CMake 中下载非商业用途版本。

CMake构建

-D DOWNLOAD_QUIP=value       # download QUIP library for build, value = no (default) or yes
-D QUIP_LIBRARY=path         # path to libquip.a (only needed if a custom location)
-D USE_INTERNAL_LINALG=value # Use the internal linear algebra library instead of LAPACK
                             #   value = no (default) or yes

如果在本地计算机上找不到 QUIP 库，CMake 将尝试从 GitHub 下载并构建 QUIP 库。这需要安装git。它将使用与编译 LAMMPS 相同的编译器和标志。目前仅 GNU 和 Intel 编译器支持此功能。如果您想使用之前编译并安装的 QUIP 库并且 CMake 找不到它，请设置 QUIP_LIBRARY 变量。

QUIP 库需要 LAPACK（和 BLAS），CMake 可以识别它们的位置并将该信息传递给 QUIP 构建脚本。但在某些系统上，这会触发 CMake 的（当前）限制，并且配置将失败。在这些情况下尝试启用 USE_INTERNAL_LINALG 以使用捆绑的线性代数库并解决该限制。

传统make构建

lib/quip/README 文件中描述的 QUIP 库的下载/构建过程需要设置两个环境变量 QUIP_ROOT 和 QUIP_ARCH 。这些可以通过 lib/quip/Makefile.lammps 文件访问，当您使用此包编译和链接 LAMMPS 时会使用该文件。如果 LAMMPS 构建无法使用其设置在您的系统上成功构建，您只需编辑 Makefile.lammps 即可。

3.7.20.PLUMED 包

在使用此软件包构建 LAMMPS 之前，您必须首先构建 PLUMED。 PLUMED 可以作为 LAMMPS 构建的一部分进行构建，也可以使用通用 PLUMED 安装说明与 LAMMPS 分开安装。 PLUMED 软件包已经过测试，可与 Plumed 版本 2.4.x、2.5.x 和 2.6.x 配合使用，并且在尝试使用不同版本的 Plumed 内核运行计算时会出错。

PLUMED 可以通过三种不同的模式链接到 MD 代码：静态、共享和运行时。在“静态”模式下，PLUMED 所需的所有代码都静态链接到 LAMMPS 中。然后，LAMMPS 完全独立于 PLUMED 安装，但您必须重建/重新链接它才能更新其中的 PLUMED 代码。通过“共享”链接模式，LAMMPS 链接到包含 PLUMED 代码的共享库。该库最好安装在全局可访问的位置。当 PLUMED 以这种方式链接时，多个 MD 包可以使用同一个库。此外，只要共享 PLUMED 库与 ABI 兼容，LAMMPS 使用的 PLUMED 库就可以更新，无需重新编译 LAMMPS。

第三种链接模式是“运行时”，它允许用户通过使用 PLUMED_KERNEL 环境变量来指定在运行时应使用哪个 PLUMED 内核。该变量应指向 libplumedKernel.so 动态共享对象的位置，然后在运行时加载该对象。这种链接模式对于进行 PLUMED 开发和比较多个 PLUMED 版本特别方便，因为无需重新编译托管 MD 代码即可完成此类比较。 LAMMPS 在选定的操作系统（例如 Linux）上支持所有三种链接模式，并使用 CMake 或传统的 make 构建。 “静态”模式应该是最可移植的，而LAMMPS中的“运行时”模式支持对操作系统和编译环境做出了最多的假设。如果一种模式不起作用，请尝试另一种模式，切换到不同的构建系统，考虑全局 PLUMED 安装或考虑在 LAMMPS 构建期间下载 PLUMED。

CMake构建

当 cmake 命令中包含 -D PKG_PLUMED=yes 标志时，您必须确保 GSL 安装在环境中指定的位置。然后还有两个附加变量控制获取 PLUMED 并将其链接到 LAMMPS 的方式。

-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

如果 DOWNLOAD_PLUMED 设置为“yes”，则将下载 PLUMED 库（将下载的 PLUMED 版本被硬编码为经过审查的 PLUMED 版本，通常是最近的稳定发行版本）并在 CMake 构建目录中构建。如果 DOWNLOAD_PLUMED 设置为“no”（默认值），CMake 将尝试检测并链接到已安装的 PLUMED 版本。为此，必须将 PLUMED 库安装到 pkg-config 工具可以找到它的位置，或者必须相应地设置 PKG_CONFIG_PATH 环境变量。如果使用默认 make 编译，PLUMED 应该安装在这样的位置；进行安装命令。

PLUMED_MODE 设置确定 PLUMED 库的链接模式。该标志允许的值为“静态”（默认）、“共享”或“运行时”。如果您想切换联动模式，只需使用不同的设置重新运行 CMake 即可。有关 PLUMED 联动模式的讨论，请参见上文。当 DOWNLOAD_PLUMED 启用时，建议使用静态链接模式。

传统make构建

需要在安装 PLUMED 软件包之前安装 PLUMED，以便 LAMMPS 在编译和链接 LAMMPS 可执行文件时可以找到正确的设置。您可以在 LAMMPS 羽毛库文件夹中下载并构建 PLUMED，也可以使用以前安装的 PLUMED 库并将 LAMMPS 指向其位置。您还必须选择链接模式：“静态”（默认）、“共享”或“运行时”。有关 PLUMED 联动模式的讨论，请参见上文。

可以通过以下 make args 从 src 文件夹下载/编译/配置 plumed 库：

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

请注意，在 lib/plumed 中创建了 2 个符号（软）链接 includelink 和 liblink ，它们指向要使用的 PLUMED 构建的位置。还使用适合 LAMMPS 的设置创建一个新文件 lib/plumed/Makefile.lammps ，以便使用所需的链接模式编译和链接 PLUMED。这一步完成后，就可以按照通常的方式安装PLUMED包并编译LAMMPS了：

make yes-plumed
make machine

编译完成后，您应该能够以通常的方式运行 LAMMPS。对于共享链接模式，LAMMPS 可执行文件必须找到 libplumed.so，这在许多操作系统上意味着您必须相应地设置 LD_LIBRARY_PATH 环境变量。

对于不同的操作系统，LAMMPS 对不同链接模式的支持有所不同，使用静态链接预计是最可移植的，因此设置为默认值。

如果您想更改链接模式，则必须使用所需的设置重新运行“make lib-plumed”，并重新安装“make yes-plumed”的 PLUMED 软件包，以使用以下命令更新所需的 makefile 设置： lib/plumed 文件夹中的更改。

3.7.21. H5MD 包

要使用此软件包进行构建，您必须在系统上安装 HDF5 软件包，其中应包括 h5cc 编译器和 HDF5 库。

CMake构建

除了 -D PKG_H5MD=yes 之外不需要其他设置。

这应该会自动检测您系统上的 H5MD 库。如果您需要指定 CMake H5MD 的安装位置，则存在多个高级 CMake H5MD 选项。使用 ccmake（终端窗口）或 cmake-gui（图形）工具查看这些选项并从用户界面以交互方式设置它们。

传统make构建

在构建 LAMMPS 之前，您必须在 lib/h5md 中构建 CH5MD 库。如果您愿意，可以手动执行此操作；请按照 lib/h5md/README 中的说明进行操作。您还可以使用如下命令从 lammps/src 目录一步完成此操作，该命令只需使用指定的参数调用 lib/h5md/Install.py 脚本：

make lib-h5md                     # print help message
make lib-h5md args="-m h5cc"      # build with h5cc compiler

构建应生成两个文件： lib/h5md/libch5md.a 和 lib/h5md/Makefile.lammps 。后者是从现有的 Makefile.lammps.* 复制的，并且具有使用系统 HDF5 库构建 LAMMPS 所需的设置。如有必要，您可以为您的系统编辑/创建一个新的 lib/h5md/Makefile.machine 文件，该文件应定义一个 EXTRAMAKE 变量来指定相应的 Makefile.lammps.<machine> 文件。

3.7.22. ML-HDNNP 包

要使用 ML-HDNNP 包进行构建，需要下载并构建外部 n2p2 库 v2.1.4 （或更高版本）。 LAMMPS 构建过程提供 n2p2 的自动下载和编译，或者允许您手动选择 n2p2 的安装目录。有关 CMake 和传统构建系统的详细信息，请参阅下面的方框。

如果手动安装 n2p2，您只需要构建 n2p2 核心库 libnnp 和接口库 libnnpif 。使用 GCC 时，在 n2p2 src 目录中执行 make libnnpif 就足够了。有关更多详细信息，请参阅 lib/hdnnp/README 和 n2p2 构建文档。

CMake构建

-D DOWNLOAD_N2P2=value    # download n2p2 for build, value = no (default) or yes
-D N2P2_DIR=path          # n2p2 base directory (only needed if a custom location)

如果设置了 DOWNLOAD_N2P2 ，则将下载 n2p2 库并在 CMake 构建目录中构建。如果 n2p2 库已经在您的系统上（在 CMake 找不到它的位置），请将 N2P2_DIR 设置为 n2p2 所在的路径。如果 n2p2 直接位于 lib/hdnnp/n2p2 中，CMake 会自动找到它。

传统make构建

如果您愿意，可以手动下载并构建 n2p2 库；请按照 lib/hdnnp/README 中的说明进行操作。您还可以使用如下命令从 lammps/src 目录一步完成此操作，该命令只需使用指定的参数调用 lib/hdnnp/Install.py 脚本：

make lib-hdnnp             # print help message
make lib-hdnnp args="-b"   # download and build in lib/hdnnp/n2p2-...
make lib-hdnnp args="-b -v 2.1.4" # download and build specific version
make lib-hdnnp args="-p /usr/local/n2p2" # use the existing n2p2 installation in /usr/local/n2p2

请注意，将在 lib/hdnnp 中创建 3 个符号（软）链接 includelink 、liblink 和 Makefile.lammps 来指向 n2p2/include 、n2p2/lib 和 n2p2/lib/Makefile.lammps-extra 。当 LAMMPS 在 src 中构建时，它将使用这些链接。

3.7.23. INTEL 包

要使用此软件包进行构建，您必须选择要为其构建的硬件，x86 CPU 或卸载模式下的 Intel KNL。您通常还应该安装 OPENMP 软件包，因为它可以与 INTEL 软件包一起使用，以达到良好的效果，如 INTEL 软件包页面上所述。
使用 Intel 编译器时需要 16.0 或更高版本。您还可以使用 GNU 或 Clang 编译器，它们将比常规样式和 OPENMP 样式提供性能改进，但不如 Intel 编译器。另请注意，某些编译器被发现不完整或不正确地应用内存对齐约束，因此在使用 INTEL 包中的功能时可能会导致原本正确的代码出现分段错误。

CMake构建

-D INTEL_ARCH=value     # value = cpu (default) or knl
-D INTEL_LRT_MODE=value # value = threads, none, or c++11

传统make构建

通过以下设置在 Makefile.machine 中选择要编译的硬件。有关示例，请参阅 src/MAKE/OPTIONS/Makefile.intel_cpu* 和 Makefile.knl 文件。和 src/INTEL/README 了解更多信息。

对于CPU：

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

对于 KNL：

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

在远程线程模式 (LRT) 中，使用修改后的 verlet 样式，该样式在单独的线程中与其他计算同时运行 Kspace 计算。必须在运行时在 package intel 命令中启用此功能。通过设置“threads”，它使用 pthreads 库，而“c++11”将使用 C++11 编译器的内置线程支持。选项“none”会跳过此功能的编译。如果 pthreads 可用，则默认使用“threads”，否则“none”。
最佳性能是通过英特尔硬件、英特尔编译器以及英特尔 TBB 和 MKL 库实现的。但是，该代码还可以使用其他编译器/硬件进行编译、链接和运行，而无需 TBB 和 MKL。

3.7.24. MDI 包

CMake构建

-D DOWNLOAD_MDI=value    # download MDI Library for build, value = no (default) or yes

传统make构建

在构建 LAMMPS 之前，您必须在 lib/mdi 中构建 MDI 库。您可以通过从 lib/mdi 目录执行以下命令之一来完成此操作：

python Install.py -m gcc       # build using gcc compiler
python Install.py -m icc       # build using icc compiler

构建应生成两个文件： lib/mdi/includelink/mdi.h 和 lib/mdi/liblink/libmdi.so 。

3.7.26. NETCDF 包

要使用此软件包进行构建，您必须在系统上安装 NetCDF 库。

CMake构建

除了 -D PKG_NETCDF=yes 之外不需要其他设置。
如果 NETCDF 库安装在系统上的标准位置，这应该会自动检测它。如果您需要指定它的安装位置，则存在多个高级 CMake NETCDF 选项。使用 ccmake （终端窗口）或 cmake-gui （图形）工具查看这些选项并从用户界面以交互方式设置它们。

传统make构建

lib/netcdf/Makefile.lammps 文件具有 LAMMPS 需要使用此包构建的 NetCDF 包含文件和库文件的设置。如果设置对您的系统无效，您将需要编辑 Makefile.lammps 文件。有关详细信息，请参阅 lib/netcdf/README 。

3.7.27. OPENMP 包

CMake构建

除了 -D PKG_OPENMP=yes 之外不需要其他设置。如果 CMake 检测到 OpenMP 编译器支持，则将在启用多线程支持的情况下编译 OPENMP 代码，否则作为优化的串行代码。

传统make构建

要在 OPENMP 包（以及支持 OpenMP 的其他样式）中启用多线程支持，必须将以下编译和链接标志添加到 Makefile.machine 文件中。有关示例，请参阅 src/MAKE/OPTIONS/Makefile.omp 。

CCFLAGS: -fopenmp               # for GNU and Clang Compilers
CCFLAGS: -qopenmp -restrict     # for Intel compilers on Linux
LINKFLAGS: -fopenmp             # for GNU and Clang Compilers
LINKFLAGS: -qopenmp             # for Intel compilers on Linux

对于其他平台和编译器，请查阅有关您的编译器的 OpenMP 支持的文档。

在 macOS 上添加 OpenMP 支持

Apple 提供了 Xcode 包和 IDE 用于在 macOS 上编译软件，因此您可能已经安装了它来编译 LAMMPS。他们的编译器基于 Clang，但虽然它能够处理 OpenMP 指令，但缺少必要的头文件和 OpenMP 运行时库。 R 开发人员已经找到了一种以兼容方式构建它们的方法。可以从 https://mac.r-project.org/openmp/ 下载它们。只需按照说明添加这些文件，Xcode C++ 编译器就可以使用 -D BUILD_OMP=yes 编译 LAMMPS。

3.7.28. QMMM 包

要使用 LAMMPS 通过 QMMM 包进行 QM/MM 模拟，您需要将 LAMMPS 构建为库。可以构建包含修复 qmmm 的 LAMMPS 可执行文件，但无法对其进行 QM/MM 模拟。您还必须构建 QM 代码（目前仅支持 Quantum ESPRESSO (QE)），并创建一个将 LAMMPS 和 QM 代码链接在一起的新可执行文件。详细信息在 lib/qmmm/README 文件中给出。还建议阅读有关将 LAMMPS 作为库链接的说明以获取背景信息。这需要兼容的 Quantum Espresso 和 LAMMPS 版本。当前界面和 makefile 上次验证可在 Quantum Espresso 版本 6.3 至 6.5 上运行是在 2020 年 2 月。

CMake构建

使用 CMake 时，需要构建 LAMMPS 库，并且建议构建共享库，因为从 lib 文件夹中的源构建的任何库（包括基本的 libqmmm.a）都不包含在静态 LAMMPS 库中（目前）未安装，但它们的代码包含在共享 LAMMPS 库中。因此，为 QMMM 配置构建 LAMMPS 的典型命令行是：

cmake -C ../cmake/presets/basic.cmake -D PKG_QMMM=yes \
    -D BUILD_LIB=yes -DBUILD_SHARED_LIBS=yes ../cmake

完成 LAMMPS 构建并使用外部库支持（通过“make Couple”）配置和编译 Quantum ESPRESSO 后，返回到 lib/qmmm 文件夹并按照 README 文件上的说明构建组合的 LAMMPS/ lib/qmmm 文件夹中的 QE QM/MM 可执行文件 (pwqmmm.x)。

传统make构建

在构建 LAMMPS 之前，您必须在 lib/qmmm 中构建 QMMM 库。如果您愿意，可以手动执行此操作；请按照 lib/qmmm/README 中说明的前两个步骤进行操作。您还可以使用如下命令从 lammps/src 目录一步完成此操作，该命令只需使用指定的参数调用 lib/qmmm/Install.py 脚本：

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

构建应生成两个文件： lib/qmmm/libqmmm.a 和 lib/qmmm/Makefile.lammps 。后者是从现有的 Makefile.lammps.* 复制的，并且具有使用 QMMM 库构建 LAMMPS 所需的设置（尽管通常这些设置只是空白）。如有必要，您可以为系统编辑/创建一个新的 lib/qmmm/Makefile.<machine> 文件，该文件应定义一个 EXTRAMAKE 变量来指定相应的 Makefile.lammps.<machine> 文件。
然后，您可以安装 QMMM 包并以通常的方式构建 LAMMPS。完成 LAMMPS 构建并在外部库支持下编译 Quantum ESPRESSO（通过“make Couple”）后，返回到 lib/qmmm 文件夹并按照 README 文件中的说明构建组合的 LAMMPS/QE QM/ lib/qmmm 文件夹中的 MM 可执行文件 (pwqmmm.x)。

3.7.29. SCAFACOS 包

要使用此包进行构建，您必须下载并构建 ScaFaCoS Coulomb 求解器库

CMake构建

-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)

如果设置了 DOWNLOAD_SCAFACOS ，则将下载 ScaFaCoS 库并在 CMake 构建目录中构建。如果 ScaFaCoS 库已在您的系统上（位于 CMake 找不到它的位置），则 SCAFACOS_LIBRARY 是 ScaFaCoS 库文件的文件名（加路径），而不是库文件所在的目录。 SCAFACOS_INCLUDE_DIR 是 ScaFaCoS 包含文件所在的目录。

传统make构建

如果您愿意，可以手动下载并构建 ScaFaCoS 库；请按照 lib/scafacos/README 中的说明进行操作。您还可以使用如下命令从 lammps/src 目录一步完成此操作，该命令只需使用指定的参数调用 lib/scafacos/Install.py 脚本：

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

请注意，在 lib/scafacos 中创建了 2 个符号（软）链接 includelink 和 liblink ，以指向 ScaFaCoS src 目录。当 LAMMPS 在 src 中构建时，它将使用这些链接。您不需要编辑 lib/scafacos/Makefile.lammps 文件。

3.7.30. VTK 包

要使用此软件包进行构建，您必须在系统上安装 VTK 库。

CMake构建

除了 -D PKG_VTK=yes 之外不需要其他设置。

如果 VTK 库安装在系统上的标准位置，这应该会自动检测它。如果您需要指定 VTK 的安装位置，则存在多个高级 VTK 选项。使用 ccmake （终端窗口）或 cmake-gui （图形）工具查看这些选项并从用户界面以交互方式设置它们。

传统make构建

lib/vtk/Makefile.lammps 文件具有用于访问 VTK 文件及其库的设置，LAMMPS 需要使用此包来构建这些文件。如果这些设置对您的系统无效，请检查其他 lib/vtk/Makefile.lammps.* 文件之一是否兼容，并将其复制到 Makefile.lammps。如果提供的文件均不起作用，您将需要编辑 Makefile.lammps 文件。有关详细信息，请参阅 lib/vtk/README 。