update toolchain and document

Author: MoseyQAQ

CMakeLists.txt

@@ -650,13 +650,13 @@ if(DEFINED DeePMD_DIR)
   endif()
 endif()
 
-option(ENABLE_NEPCPU "Enable NEP calculations on CPU" OFF)
-if(ENABLE_NEPCPU)
-  message(STATUS "NEP support enabled.")
-  include_directories(/home/mosey/devs/NEP_CPU/src/)
-  link_directories(/home/mosey/devs/NEP_CPU/src/)
-  add_compile_definitions(__NEP)
-  target_link_libraries(${ABACUS_BIN_NAME} /home/mosey/devs/NEP_CPU/src/libnep_cpu.so)
+if(DEFINED NEP_DIR)
+  find_package(NEP REQUIRED)
+
+  if(NEP_FOUND)
+    add_compile_definitions(__NEP)
+    target_link_libraries(${ABACUS_BIN_NAME} NEP::nep_cpu)
+  endif()
 endif()
 
 if(DEFINED TensorFlow_DIR)

cmake/FindNEP.cmake

@@ -0,0 +1,46 @@
+###############################################################################
+# - Find NEP_CPU
+# Finds the NEP_CPU header and library.
+#
+# This module will search for the NEP_CPU library, looking for a hint
+# from the NEP_DIR environment variable or CMake variable.
+#
+# This module defines the following variables:
+#
+#  NEP_FOUND        - True if the NEP_CPU library and headers were found.
+#  NEP_INCLUDE_DIR  - The directory where nep.h is located.
+#  NEP_LIBRARY      - The full path to the NEP_CPU library.
+#
+# It also defines the following imported target:
+#
+#  NEP::nep_cpu     - The NEP_CPU library target.
+#
+###############################################################################
+
+find_path(NEP_INCLUDE_DIR nep.h
+    HINTS ${NEP_DIR}
+    PATH_SUFFIXES "include"
+    )
+
+find_library(NEP_LIBRARY
+    NAMES nepcpu
+    HINTS ${NEP_DIR}
+    PATH_SUFFIXES "lib"
+    )
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(NEP
+    DEFAULT_MSG
+    NEP_LIBRARY NEP_INCLUDE_DIR)
+
+if(NEP_FOUND)
+    if(NOT TARGET NEP::nep_cpu)
+        add_library(NEP::nep_cpu UNKNOWN IMPORTED)
+        set_target_properties(NEP::nep_cpu PROPERTIES
+            IMPORTED_LOCATION "${NEP_LIBRARY}"
+            INTERFACE_INCLUDE_DIRECTORIES "${NEP_INCLUDE_DIR}"
+        )
+    endif()
+endif()
+
+mark_as_advanced(NEP_INCLUDE_DIR NEP_LIBRARY)

docs/advanced/input_files/input-main.md

@@ -532,6 +532,7 @@ These variables are used to control general system parameters.
   - tddft: real-time time-dependent density functional theory (TDDFT)
   - lj: Leonard Jones potential
   - dp: DeeP potential, see details in [md.md](../md.md#dpmd)
+  - nep: Neuroevolution Potential, see details in [md.md](../md.md#nep)
   - ks-lr: Kohn-Sham density functional theory + LR-TDDFT (Under Development Feature)
   - lr: LR-TDDFT with given KS orbitals (Under Development Feature)
 - **Default**: ksdft

docs/advanced/install.md

@@ -55,6 +55,17 @@ Similarly, DeePMD-kit supports PyTorch backend but its libraries are placed at a
 cmake -B build -DDeePMD_DIR=/dir_to_deepmd-kit -DTorch_DIR=/dir_to_pytorch
 ```
 
+## Build with NEP
+This interface enables running MD simulations with the NEP model. It requires the [NEP_CPU](https://github.com/brucefan1983/NEP_CPU) library, which can be easily installed using toolchain as shown below:
+```bash
+./install_abacus_toolchain.sh --with-nepcpu=install
+```
+
+To build ABACUS:
+```bash
+cmake -B build -DNEP_DIR=/path/to/nep_cpu
+```
+
 ## Build with LibRI and LibComm
 
 The new EXX implementation depends on two external libraries:

docs/advanced/md.md

@@ -87,4 +87,8 @@ ABACUS performs the [Multi-Scale Shock Technique (MSST) integration](https://jou
 Compiling ABACUS with [DeePMD-kit](https://github.com/deepmodeling/deepmd-kit), MD calculations based on machine learning DP model is enabled.
 
 To employ DPMD calculations, [esolver_type](./input_files/input-main.md#esolver_type) should be set to `dp`.
-And the filename of DP model is specified by keyword [pot_file](./input_files/input-main.md#pot_file).
+And the filename of DP model is specified by keyword [pot_file](./input_files/input-main.md#pot_file).
+
+## NEP
+
+If ABACUS is compiled with the Neuroevolution Potential ([NEP](https://gpumd.org/potentials/nep.html)), MD simulations using  NEP models are enabled. To use this feature, set [esolver_type](./input_files/input-main.md#esolver_type) to `nep` and specify the potential file path with the [pot_file](./input_files/input-main.md#pot_file) keyword in your INPUT file.

source/source_esolver/esolver_nep.cpp

@@ -1,24 +1,38 @@
+/**
+ * @file esolver_nep.cpp
+#include "source_io/module_parameter/parameter.h"
+ * @brief Implementation of ESolver_NEP class for neuroevolution potential (NEP).
+ *
+ * This file contains the implementation of the ESolver_NEP class, which is used for solving the energy and forces in a
+ * NEP simulation.
+ * NEP is a method for training deep neural networks to accurately predict the potential energy surface of a
+ * molecular system.
+ *
+ * For more information about NEP, see the following reference:
+ * 1. https://gpumd.org/potentials/nep.html
+ * 2. https://doi.org/10.1002/mgea.70028
+ *
+ * @author MoseyQAQ
+ * @date 2025-10-10
+ */
 #include "esolver_nep.h"
+
 #include "source_base/parallel_common.h"
 #include "source_base/timer.h"
 #include "source_io/output_log.h"
 #include "source_io/cif_io.h"
+
 #include <numeric>
 #include <unordered_map>
 
 using namespace ModuleESolver;
 
-ESolver_NEP::ESolver_NEP(const std::string& pot_file): nep(pot_file)
-{
-    classname = "ESolver_NEP";
-    nep_file = pot_file;
-}
-
 void ESolver_NEP::before_all_runners(UnitCell& ucell, const Input_para& inp)
 {   
     nep_potential = 0.0;
     nep_force.create(ucell.nat, 3);
     nep_virial.create(3, 3);
+    atype.resize(ucell.nat);
     _e.resize(ucell.nat);
     _f.resize(3 * ucell.nat);
     _v.resize(9 * ucell.nat);
@@ -28,10 +42,8 @@ void ESolver_NEP::before_all_runners(UnitCell& ucell, const Input_para& inp)
                                "# Generated by ABACUS ModuleIO::CifParser",
                                "data_?");
 
-    atype.resize(ucell.nat);
-
 #ifdef __NEP
-    /// determine the type map from STRU to DP model
+    /// determine the type map from STRU to NEP model
     type_map(ucell);
 #endif
 }
@@ -96,7 +108,7 @@ void ESolver_NEP::runner(UnitCell& ucell, const int istep)
         nep_force(i, 2) = _f[i + 2 * nat] * fact_f;
     }
 
-    // get the total virial by summing over all atomic contributions
+    // virial
     std::vector<double> v_sum(9, 0.0);
     for (int j = 0; j < 9; ++j)
     {
@@ -107,7 +119,7 @@ void ESolver_NEP::runner(UnitCell& ucell, const int istep)
         }
     }
 
-    // transform to stress tensor
+    // virial -> stress
     for (int i = 0; i < 3; ++i)
     {
         for (int j = 0; j < 3; ++j)
@@ -156,12 +168,13 @@ void ESolver_NEP::after_all_runners(UnitCell& ucell)
 
 #ifdef __NEP
 void ESolver_NEP::type_map(const UnitCell& ucell)
-{
+{   
+    // parse the element list from NEP model file
     std::unordered_map<std::string, int> label;
     std::string temp;
     for (int i = 0; i < nep.element_list.size(); ++i)
     {
-        label[nep.element_list[i]] = i;
+        label[nep.element_list[i]] = i; //> label: map from element string to index int.
     }
 
     std::cout << "\n Element list of model file " << nep_file << " " << std::endl;
@@ -180,6 +193,7 @@ void ESolver_NEP::type_map(const UnitCell& ucell)
     }
     std::cout << "\n -----------------------------------------------------------------" << std::endl;
 
+    // parse the atype based on the element list
     int iat = 0;
     for (int it = 0; it < ucell.ntype; ++it)
     {

source/source_esolver/esolver_nep.h

@@ -14,28 +14,93 @@ namespace ModuleESolver
 class ESolver_NEP : public ESolver
 {
   public:
-    ESolver_NEP(const std::string& pot_file);
+#ifdef __NEP
+    ESolver_NEP(const std::string& pot_file): nep(pot_file)
+  {
+      classname = "ESolver_NEP";
+      nep_file = pot_file;
+  }
+#else
+    ESolver_NEP(const std::string& pot_file)
+  {
+      classname = "ESolver_NEP";
+      nep_file = pot_file;
+  }
+#endif
 
+    /**
+     * @brief Initialize the NEP solver with given input parameters and unit cell
+     *
+     * @param inp input parameters
+     * @param cell unitcell information
+     */
     void before_all_runners(UnitCell& ucell, const Input_para& inp) override;
+  
+    /**
+     * @brief Run the NEP solver for a given ion/md step and unit cell
+     *
+     * @param istep the current ion/md step
+     * @param cell unitcell information
+     */
     void runner(UnitCell& ucell, const int istep) override;
+
+    /**
+     * @brief get the total energy without ion kinetic energy
+     *
+     * @param etot the computed energy
+     * @return total energy without ion kinetic energy
+     */
     double cal_energy() override;
+
+    /**
+     * @brief get the computed atomic forces
+     *
+     * @param force the computed atomic forces
+     */
     void cal_force(UnitCell& ucell, ModuleBase::matrix& force) override;
+
+    /**
+     * @brief get the computed lattice virials
+     *
+     * @param stress the computed lattice virials
+     */
     void cal_stress(UnitCell& ucell, ModuleBase::matrix& stress) override;
+
+    /**
+     * @brief Prints the final total energy of the NEP model to the output file
+     *
+     * This function prints the final total energy of the NEP model in eV to the output file along with some formatting.
+     */
     void after_all_runners(UnitCell& ucell) override;
 
   private:
+    /**
+     * @brief determine the type map of NEP model
+     *
+     * @param ucell unitcell information
+     */
     void type_map(const UnitCell& ucell);
+
+    /**
+     * @brief NEP related variables for ESolver_NEP class
+     *
+     * These variables are related to the NEP method and are used in the ESolver_NEP class to compute the potential
+     * energy and forces.
+     *
+     * @note These variables are only defined if the __NEP preprocessor macro is defined.
+     */
 #ifdef __NEP
-    NEP3 nep;
+    NEP3 nep; ///< NEP3 object for NEP calculations
 #endif
-    std::string nep_file;
-    std::vector<int> atype = {};
-    double nep_potential;
-    ModuleBase::matrix nep_force;
-    ModuleBase::matrix nep_virial;
-    std::vector<double> _e;
-    std::vector<double> _f;
-    std::vector<double> _v;
+
+    std::string nep_file;                ///< directory of NEP model file
+    std::vector<int> atype = {};         ///< atom type mapping for NEP model
+    double nep_potential;                ///< computed potential energy
+    ModuleBase::matrix nep_force;        ///< computed atomic forces
+    ModuleBase::matrix nep_virial;       ///< computed lattice virials
+    std::vector<double> _e;              ///< temporary storage for energy computation
+    std::vector<double> _f;              ///< temporary storage for force computation
+    std::vector<double> _v;              ///< temporary storage for virial computation
 };
 
 } // namespace ModuleESolver

source/source_io/read_input_item_system.cpp

@@ -121,7 +121,7 @@ void ReadInput::item_system()
             {
                 if (access(para.input.mdp.pot_file.c_str(), 0) == -1)
                 {
-                    ModuleBase::WARNING_QUIT("ReadInput", "Can not find DP model !");
+                    ModuleBase::WARNING_QUIT("ReadInput", "Can not find `pot_file` !");
                 }
             }
         };

toolchain/build_abacus_intel.sh

@@ -48,8 +48,7 @@ cmake -B $BUILD_DIR -DCMAKE_INSTALL_PREFIX=$PREFIX \
         -DENABLE_RAPIDJSON=ON \
         -DRapidJSON_DIR=$RAPIDJSON \
         -DLIBRI_DIR=$LIBRI \
-	    -DLIBCOMM_DIR=$LIBCOMM \
-	-DENABLE_NEPCPU=ON
+	    -DLIBCOMM_DIR=$LIBCOMM
 #         -DENABLE_MLALGO=1 \
 #         -DTorch_DIR=$LIBTORCH \
 #         -Dlibnpy_INCLUDE_DIR=$LIBNPY \

toolchain/install_abacus_toolchain.sh

@@ -211,6 +211,8 @@ The --with-PKG options follow the rules:
                           Default = no
   --with-libcomm          Enable LibComm for higher-level methods like hybrid functionals, RPA or GW
                           Default = no
+  --with-nepcpu              Enable NEP (CPU version) for machine learning potentials
+                          Default = no
 
 FURTHER INSTRUCTIONS
 
@@ -246,7 +248,7 @@ EOF
 tool_list="gcc intel amd cmake"
 mpi_list="mpich openmpi intelmpi"
 math_list="mkl aocl openblas"
-lib_list="fftw libxc scalapack elpa cereal rapidjson libtorch libnpy libri libcomm"
+lib_list="fftw libxc scalapack elpa cereal rapidjson libtorch libnpy libri libcomm nepcpu"
 package_list="${tool_list} ${mpi_list} ${math_list} ${lib_list}"
 # ------------------------------------------------------------------------
 
@@ -596,6 +598,9 @@ while [ $# -ge 1 ]; do
     --with-libcomm*)
       with_libcomm=$(read_with "${1}")
       ;;
+    --with-nepcpu*)
+      with_nepcpu=$(read_with "${1}")
+      ;;
     --help*)
       show_help
       exit 0