From f351867a03eb369be99681175942c509dfeb0c9b Mon Sep 17 00:00:00 2001 From: "njzjz-bot (driven by OpenClaw (model: custom-chat-jinzhezeng-group/gpt-5.5))[bot]" <48687836+njzjz-bot@users.noreply.github.com> Date: Mon, 15 Jun 2026 18:38:51 +0000 Subject: [PATCH 01/11] test(api): add universal DeepPot C API coverage Add focused parameterized C and C++ API smoke tests that exercise DeepPot metadata and atomic inference over the shared TensorFlow, PyTorch, PT-Expt, JAX, and Paddle fixture matrix when those backends and generated artifacts are available. Link torch into the C API test target so PT-Expt guards are detected consistently with the C++ API tests. Authored by OpenClaw (model: custom-chat-jinzhezeng-group/gpt-5.5) --- source/api_c/tests/CMakeLists.txt | 4 + source/api_c/tests/test_deeppot_universal.cc | 242 ++++++++++++++++++ source/api_cc/tests/test_deeppot_universal.cc | 207 +++++++++++++++ source/tests/infer/deeppot_universal_data.h | 127 +++++++++ 4 files changed, 580 insertions(+) create mode 100644 source/api_c/tests/test_deeppot_universal.cc create mode 100644 source/api_cc/tests/test_deeppot_universal.cc create mode 100644 source/tests/infer/deeppot_universal_data.h diff --git a/source/api_c/tests/CMakeLists.txt b/source/api_c/tests/CMakeLists.txt index ef19305004..f1a74a26a6 100644 --- a/source/api_c/tests/CMakeLists.txt +++ b/source/api_c/tests/CMakeLists.txt @@ -16,6 +16,10 @@ if(ENABLE_TENSORFLOW) endif() if(ENABLE_PYTORCH) target_compile_definitions(runUnitTests_c PRIVATE BUILD_PYTORCH) + # Link torch so __has_include() succeeds and + # BUILD_PT_EXPT is set for the test binary; otherwise pt_expt tests all + # GTEST_SKIP() with "PyTorch support is not enabled". + target_link_libraries(runUnitTests_c PRIVATE "${TORCH_LIBRARIES}") endif() if(ENABLE_JAX) target_compile_definitions(runUnitTests_c PRIVATE BUILD_JAX) diff --git a/source/api_c/tests/test_deeppot_universal.cc b/source/api_c/tests/test_deeppot_universal.cc new file mode 100644 index 0000000000..cb3bcd6c85 --- /dev/null +++ b/source/api_c/tests/test_deeppot_universal.cc @@ -0,0 +1,242 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later +#include +#include + +#include +#include +#include +#include +#include + +#include "../../tests/infer/deeppot_universal_data.h" +#include "DeepPotPTExpt.h" +#include "c_api.h" + +namespace { + +enum class Backend { TensorFlow, PyTorch, PTExpt, JAX, Paddle }; + +struct ModelCase { + std::string name; + Backend backend; + std::string model_path; + bool convert_pbtxt; + const deepmd_test::DeepPotRef* ref; + double double_tol; + double float_tol; + bool supports_float; +}; + +bool path_exists(const std::string& path) { + struct stat statbuf; + return stat(path.c_str(), &statbuf) == 0; +} + +bool backend_enabled(Backend backend) { + switch (backend) { + case Backend::TensorFlow: +#ifdef BUILD_TENSORFLOW + return true; +#else + return false; +#endif + case Backend::PyTorch: +#ifdef BUILD_PYTORCH + return true; +#else + return false; +#endif + case Backend::PTExpt: +#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT + return true; +#else + return false; +#endif + case Backend::JAX: +#ifdef BUILD_JAX + return true; +#else + return false; +#endif + case Backend::Paddle: +#ifdef BUILD_PADDLE + return true; +#else + return false; +#endif + } + return false; +} + +std::string backend_name(Backend backend) { + switch (backend) { + case Backend::TensorFlow: + return "TensorFlow"; + case Backend::PyTorch: + return "PyTorch"; + case Backend::PTExpt: + return "PTExpt"; + case Backend::JAX: + return "JAX"; + case Backend::Paddle: + return "Paddle"; + } + return "Unknown"; +} + +std::vector model_cases() { + return { + {"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/deeppot.pbtxt", + true, &deepmd_test::tf_deeppot_ref(), 1e-10, 1e-4, true}, + {"pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_sea.pth", + false, &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_sea.pt2", + false, &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + {"jax_savedmodel", Backend::JAX, + "../../tests/infer/deeppot_sea.savedmodel", false, + &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + {"paddle_json", Backend::Paddle, "../../tests/infer/deeppot_sea.json", + false, &deepmd_test::sea_deeppot_ref(), 1e-7, 1e-4, false}}; +} + +class UniversalDeepPotCTest : public ::testing::TestWithParam { + protected: + DP_DeepPot* dp = nullptr; + std::string converted_model; + + void SetUp() override { + const auto& param = GetParam(); + if (!backend_enabled(param.backend)) { + GTEST_SKIP() << backend_name(param.backend) << " support is not enabled."; + } + if (!path_exists(param.model_path)) { + GTEST_SKIP() << "Model artifact is not available: " << param.model_path; + } + + std::string model_path = param.model_path; + if (param.convert_pbtxt) { + converted_model = "deeppot_c_universal_" + param.name + ".pb"; + DP_ConvertPbtxtToPb(param.model_path.c_str(), converted_model.c_str()); + model_path = converted_model; + } + dp = DP_NewDeepPot(model_path.c_str()); + const char* error = DP_DeepPotCheckOK(dp); + const std::string error_message(error); + DP_DeleteChar(error); + ASSERT_TRUE(error_message.empty()) + << "Model artifact cannot be loaded by this backend: " << error_message; + } + + void TearDown() override { + DP_DeleteDeepPot(dp); + if (!converted_model.empty()) { + remove(converted_model.c_str()); + } + } +}; + +TEST_P(UniversalDeepPotCTest, Metadata) { + const auto& ref = *GetParam().ref; + + EXPECT_DOUBLE_EQ(DP_DeepPotGetCutoff(dp), ref.cutoff); + EXPECT_EQ(DP_DeepPotGetNumbTypes(dp), ref.numb_types); + EXPECT_EQ(DP_DeepPotGetNumbTypesSpin(dp), ref.numb_types_spin); + EXPECT_EQ(DP_DeepPotGetDimFParam(dp), ref.dim_fparam); + EXPECT_EQ(DP_DeepPotGetDimAParam(dp), ref.dim_aparam); + EXPECT_EQ(DP_DeepPotIsAParamNAll(dp), ref.aparam_nall); + EXPECT_EQ(DP_DeepPotHasDefaultFParam(dp), ref.has_default_fparam); + + const char* type_map = DP_DeepPotGetTypeMap(dp); + EXPECT_STREQ(type_map, ref.type_map.c_str()); + DP_DeleteChar(type_map); +} + +void check_compute_double(DP_DeepPot* dp, + const deepmd_test::DeepPotRef& ref, + const double tol) { + const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const std::vector& coord = deepmd_test::deeppot_coord(); + const std::vector& box = deepmd_test::deeppot_box(); + const std::vector& atype = deepmd_test::deeppot_atype(); + const std::vector expected_virial = deepmd_test::total_virial(ref); + + double energy = 0.0; + std::vector force(natoms * 3); + std::vector virial(9); + std::vector atomic_energy(natoms); + std::vector atomic_virial(natoms * 9); + DP_DeepPotCompute2(dp, 1, natoms, coord.data(), atype.data(), box.data(), + nullptr, nullptr, &energy, force.data(), virial.data(), + atomic_energy.data(), atomic_virial.data()); + + EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol); + for (int ii = 0; ii < natoms * 3; ++ii) { + EXPECT_NEAR(force[ii], ref.force[ii], tol); + } + for (size_t ii = 0; ii < 9; ++ii) { + EXPECT_NEAR(virial[ii], expected_virial[ii], tol); + } + for (int ii = 0; ii < natoms; ++ii) { + EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol); + } + for (int ii = 0; ii < natoms * 9; ++ii) { + EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol); + } +} + +void check_compute_float(DP_DeepPot* dp, + const deepmd_test::DeepPotRef& ref, + const double tol) { + const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const std::vector coord(deepmd_test::deeppot_coord().begin(), + deepmd_test::deeppot_coord().end()); + const std::vector box(deepmd_test::deeppot_box().begin(), + deepmd_test::deeppot_box().end()); + const std::vector& atype = deepmd_test::deeppot_atype(); + const std::vector expected_virial = deepmd_test::total_virial(ref); + + double energy = 0.0; + std::vector force(natoms * 3); + std::vector virial(9); + std::vector atomic_energy(natoms); + std::vector atomic_virial(natoms * 9); + DP_DeepPotComputef2(dp, 1, natoms, coord.data(), atype.data(), box.data(), + nullptr, nullptr, &energy, force.data(), virial.data(), + atomic_energy.data(), atomic_virial.data()); + + EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol); + for (int ii = 0; ii < natoms * 3; ++ii) { + EXPECT_NEAR(force[ii], ref.force[ii], tol); + } + for (size_t ii = 0; ii < 9; ++ii) { + EXPECT_NEAR(virial[ii], expected_virial[ii], tol); + } + for (int ii = 0; ii < natoms; ++ii) { + EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol); + } + for (int ii = 0; ii < natoms * 9; ++ii) { + EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol); + } +} + +TEST_P(UniversalDeepPotCTest, ComputeDouble) { + check_compute_double(dp, *GetParam().ref, GetParam().double_tol); +} + +TEST_P(UniversalDeepPotCTest, ComputeFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_compute_float(dp, *GetParam().ref, GetParam().float_tol); +} + +INSTANTIATE_TEST_SUITE_P( + AvailableBackends, + UniversalDeepPotCTest, + ::testing::ValuesIn(model_cases()), + [](const ::testing::TestParamInfo& info) { + return info.param.name; + }); + +} // namespace diff --git a/source/api_cc/tests/test_deeppot_universal.cc b/source/api_cc/tests/test_deeppot_universal.cc new file mode 100644 index 0000000000..b9015fdedf --- /dev/null +++ b/source/api_cc/tests/test_deeppot_universal.cc @@ -0,0 +1,207 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later +#include +#include + +#include +#include +#include +#include + +#include "../../tests/infer/deeppot_universal_data.h" +#include "DeepPot.h" +#include "DeepPotPTExpt.h" +#include "test_utils.h" + +namespace { + +enum class Backend { TensorFlow, PyTorch, PTExpt, JAX, Paddle }; + +struct ModelCase { + std::string name; + Backend backend; + std::string model_path; + bool convert_pbtxt; + const deepmd_test::DeepPotRef* ref; + double double_tol; + double float_tol; + bool supports_float; +}; + +bool path_exists(const std::string& path) { + struct stat statbuf; + return stat(path.c_str(), &statbuf) == 0; +} + +bool backend_enabled(Backend backend) { + switch (backend) { + case Backend::TensorFlow: +#ifdef BUILD_TENSORFLOW + return true; +#else + return false; +#endif + case Backend::PyTorch: +#ifdef BUILD_PYTORCH + return true; +#else + return false; +#endif + case Backend::PTExpt: +#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT + return true; +#else + return false; +#endif + case Backend::JAX: +#ifdef BUILD_JAX + return true; +#else + return false; +#endif + case Backend::Paddle: +#ifdef BUILD_PADDLE + return true; +#else + return false; +#endif + } + return false; +} + +std::string backend_name(Backend backend) { + switch (backend) { + case Backend::TensorFlow: + return "TensorFlow"; + case Backend::PyTorch: + return "PyTorch"; + case Backend::PTExpt: + return "PTExpt"; + case Backend::JAX: + return "JAX"; + case Backend::Paddle: + return "Paddle"; + } + return "Unknown"; +} + +std::vector model_cases() { + return { + {"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/deeppot.pbtxt", + true, &deepmd_test::tf_deeppot_ref(), 1e-10, 1e-4, true}, + {"pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_sea.pth", + false, &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_sea.pt2", + false, &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + {"jax_savedmodel", Backend::JAX, + "../../tests/infer/deeppot_sea.savedmodel", false, + &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + {"paddle_json", Backend::Paddle, "../../tests/infer/deeppot_sea.json", + false, &deepmd_test::sea_deeppot_ref(), 1e-7, 1e-4, false}}; +} + +class UniversalDeepPotTest : public ::testing::TestWithParam { + protected: + deepmd::DeepPot dp; + std::string converted_model; + + void SetUp() override { + const auto& param = GetParam(); + if (!backend_enabled(param.backend)) { + GTEST_SKIP() << backend_name(param.backend) << " support is not enabled."; + } + if (!path_exists(param.model_path)) { + GTEST_SKIP() << "Model artifact is not available: " << param.model_path; + } + + std::string model_path = param.model_path; + if (param.convert_pbtxt) { + converted_model = "deeppot_universal_" + param.name + ".pb"; + deepmd::convert_pbtxt_to_pb(param.model_path, converted_model); + model_path = converted_model; + } + dp.init(model_path); + } + + void TearDown() override { + if (!converted_model.empty()) { + remove(converted_model.c_str()); + } + } +}; + +TEST_P(UniversalDeepPotTest, Metadata) { + const auto& ref = *GetParam().ref; + std::string type_map; + + EXPECT_DOUBLE_EQ(dp.cutoff(), ref.cutoff); + EXPECT_EQ(dp.numb_types(), ref.numb_types); + EXPECT_EQ(dp.numb_types_spin(), ref.numb_types_spin); + EXPECT_EQ(dp.dim_fparam(), ref.dim_fparam); + EXPECT_EQ(dp.dim_aparam(), ref.dim_aparam); + EXPECT_EQ(dp.is_aparam_nall(), ref.aparam_nall); + EXPECT_EQ(dp.has_default_fparam(), ref.has_default_fparam); + dp.get_type_map(type_map); + EXPECT_EQ(type_map, ref.type_map); +} + +template +void check_compute(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol) { + const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const std::vector coord(deepmd_test::deeppot_coord().begin(), + deepmd_test::deeppot_coord().end()); + const std::vector box(deepmd_test::deeppot_box().begin(), + deepmd_test::deeppot_box().end()); + const std::vector atype = deepmd_test::deeppot_atype(); + const std::vector expected_virial = deepmd_test::total_virial(ref); + + double energy = 0.0; + std::vector force; + std::vector virial; + std::vector atomic_energy; + std::vector atomic_virial; + dp.compute(energy, force, virial, atomic_energy, atomic_virial, coord, atype, + box); + + ASSERT_EQ(force.size(), static_cast(natoms * 3)); + ASSERT_EQ(virial.size(), 9U); + ASSERT_EQ(atomic_energy.size(), static_cast(natoms)); + ASSERT_EQ(atomic_virial.size(), static_cast(natoms * 9)); + + EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol); + for (int ii = 0; ii < natoms * 3; ++ii) { + EXPECT_NEAR(force[ii], ref.force[ii], tol); + } + for (size_t ii = 0; ii < 9; ++ii) { + EXPECT_NEAR(virial[ii], expected_virial[ii], tol); + } + for (int ii = 0; ii < natoms; ++ii) { + EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol); + } + for (int ii = 0; ii < natoms * 9; ++ii) { + EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol); + } +} + +TEST_P(UniversalDeepPotTest, ComputeDouble) { + check_compute(dp, *GetParam().ref, GetParam().double_tol); +} + +TEST_P(UniversalDeepPotTest, ComputeFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_compute(dp, *GetParam().ref, GetParam().float_tol); +} + +INSTANTIATE_TEST_SUITE_P( + AvailableBackends, + UniversalDeepPotTest, + ::testing::ValuesIn(model_cases()), + [](const ::testing::TestParamInfo& info) { + return info.param.name; + }); + +} // namespace diff --git a/source/tests/infer/deeppot_universal_data.h b/source/tests/infer/deeppot_universal_data.h new file mode 100644 index 0000000000..24cebb44ab --- /dev/null +++ b/source/tests/infer/deeppot_universal_data.h @@ -0,0 +1,127 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later +#pragma once + +#include +#include +#include + +namespace deepmd_test { + +struct DeepPotRef { + std::vector atomic_energy; + std::vector force; + std::vector atomic_virial; + double cutoff = 6.0; + int numb_types = 2; + int numb_types_spin = 0; + int dim_fparam = 0; + int dim_aparam = 0; + bool aparam_nall = false; + bool has_default_fparam = false; + std::string type_map = "O H"; +}; + +inline const std::vector& deeppot_coord() { + static const std::vector coord = { + 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, + 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; + return coord; +} + +inline const std::vector& deeppot_atype() { + static const std::vector atype = {0, 1, 1, 0, 1, 1}; + return atype; +} + +inline const std::vector& deeppot_box() { + static const std::vector box = {13., 0., 0., 0., 13., + 0., 0., 0., 13.}; + return box; +} + +inline const DeepPotRef& tf_deeppot_ref() { + static const DeepPotRef ref = { + {-9.275780747115504710e+01, -1.863501786584258468e+02, + -1.863392472863538103e+02, -9.279281325486221021e+01, + -1.863671545232153903e+02, -1.863619822847602165e+02}, + {-3.034045420701179663e-01, 8.405844663871177014e-01, + 7.696947487118485642e-02, 7.662001266663505117e-01, + -1.880601391333554251e-01, -6.183333871091722944e-01, + -5.036172391059643427e-01, -6.529525836149027151e-01, + 5.432962643022043459e-01, 6.382357912332115024e-01, + -1.748518296794561167e-01, 3.457363524891907125e-01, + 1.286482986991941552e-03, 3.757251165286925043e-01, + -5.972588700887541124e-01, -5.987006197104716154e-01, + -2.004450304880958100e-01, 2.495901655353461868e-01}, + {-2.912234126853306959e-01, -3.800610846612756388e-02, + 2.776624987489437202e-01, -5.053761003913598976e-02, + -3.152373041953385746e-01, 1.060894290092162379e-01, + 2.826389131596073745e-01, 1.039129970665329250e-01, + -2.584378792325942586e-01, -3.121722367954994914e-01, + 8.483275876786681990e-02, 2.524662342344257682e-01, + 4.142176771106586414e-02, -3.820285230785245428e-02, + -2.727311173065460545e-02, 2.668859789777112135e-01, + -6.448243569420382404e-02, -2.121731470426218846e-01, + -8.624335220278558922e-02, -1.809695356746038597e-01, + 1.529875294531883312e-01, -1.283658185172031341e-01, + -1.992682279795223999e-01, 1.409924999632362341e-01, + 1.398322735274434292e-01, 1.804318474574856390e-01, + -1.470309318999652726e-01, -2.593983661598450730e-01, + -4.236536279233147489e-02, 3.386387920184946720e-02, + -4.174017537818433543e-02, -1.003500282164128260e-01, + 1.525690815194478966e-01, 3.398976109910181037e-02, + 1.522253908435125536e-01, -2.349125581341701963e-01, + 9.515545977581392825e-04, -1.643218849228543846e-02, + 1.993234765412972564e-02, 6.027265332209678569e-04, + -9.563256398907417355e-02, 1.510815124001868293e-01, + -7.738094816888557714e-03, 1.502832772532304295e-01, + -2.380965783745832010e-01, -2.309456719810296654e-01, + -6.666961081213038098e-02, 7.955566551234216632e-02, + -8.099093777937517447e-02, -3.386641099800401927e-02, + 4.447884755740908608e-02, 1.008593228579038742e-01, + 4.556718179228393811e-02, -6.078081273849572641e-02}}; + return ref; +} + +inline const DeepPotRef& sea_deeppot_ref() { + static const DeepPotRef ref = { + {-93.016873944029, -185.923296645958, -185.927096544970, -93.019371018039, + -185.926179995548, -185.924351901852}, + {0.006277522211, -0.001117962774, 0.000618580445, 0.009928999655, + 0.003026035654, -0.006941982227, 0.000667853212, -0.002449963843, + 0.006506463508, -0.007284129115, 0.000530662205, -0.000028806821, + 0.000068097781, 0.006121331983, -0.009019754602, -0.009658343745, + -0.006110103225, 0.008865499697}, + {-0.000155238009, 0.000116605516, -0.007869862476, 0.000465578340, + 0.008182547185, -0.002398713212, -0.008112887338, -0.002423738425, + 0.007210716605, -0.019203504012, 0.001724938709, 0.009909211091, + 0.001153857542, -0.001600015103, -0.000560024090, 0.010727836276, + -0.001034836404, -0.007973454377, -0.021517399106, -0.004064359664, + 0.004866398692, -0.003360038617, -0.007241406162, 0.005920941051, + 0.004899151657, 0.006290788591, -0.006478820311, 0.001921504710, + 0.001313470921, -0.000304091236, 0.001684345981, 0.004124109256, + -0.006396084465, -0.000701095618, -0.006356507032, 0.009818550859, + -0.015230664587, -0.000110244376, 0.000690319396, 0.000045953023, + -0.005726548770, 0.008769818495, -0.000572380210, 0.008860603423, + -0.013819348050, -0.021227082558, -0.004977781343, 0.006646239696, + -0.005987066507, -0.002767831232, 0.003746502525, 0.007697590397, + 0.003746130152, -0.005172634748}}; + return ref; +} + +inline double total_energy(const DeepPotRef& ref) { + return std::accumulate(ref.atomic_energy.begin(), ref.atomic_energy.end(), + 0.0); +} + +inline std::vector total_virial(const DeepPotRef& ref) { + std::vector virial(9, 0.0); + for (size_t atom = 0; atom < ref.atomic_energy.size(); ++atom) { + for (size_t dd = 0; dd < 9; ++dd) { + virial[dd] += ref.atomic_virial[atom * 9 + dd]; + } + } + return virial; +} + +} // namespace deepmd_test From 8966ac118499f4e5ac060ce294cb6c6d6a846568 Mon Sep 17 00:00:00 2001 From: "njzjz-bot (driven by OpenClaw (model: custom-chat-jinzhezeng-group/gpt-5.5))[bot]" <48687836+njzjz-bot@users.noreply.github.com> Date: Thu, 18 Jun 2026 17:24:44 +0000 Subject: [PATCH 02/11] test(api): tighten type map assertions Require exact PyTorch DeepTensor type-map metadata now that the separator handling is fixed, and drop stale parsing-only includes. Authored by OpenClaw (model: custom-chat-jinzhezeng-group/gpt-5.5) --- source/api_c/tests/test_deeppot_a_ptexpt.cc | 1 - source/api_cc/tests/test_deepdipole_pt.cc | 16 +++------------- 2 files changed, 3 insertions(+), 14 deletions(-) diff --git a/source/api_c/tests/test_deeppot_a_ptexpt.cc b/source/api_c/tests/test_deeppot_a_ptexpt.cc index 59a9832d7b..5f6535557c 100644 --- a/source/api_c/tests/test_deeppot_a_ptexpt.cc +++ b/source/api_c/tests/test_deeppot_a_ptexpt.cc @@ -5,7 +5,6 @@ #include #include -#include #include #include diff --git a/source/api_cc/tests/test_deepdipole_pt.cc b/source/api_cc/tests/test_deepdipole_pt.cc index 473f697188..cfb82bf721 100644 --- a/source/api_cc/tests/test_deepdipole_pt.cc +++ b/source/api_cc/tests/test_deepdipole_pt.cc @@ -7,7 +7,6 @@ #include #include #include -#include #include #include "DeepTensor.h" @@ -147,18 +146,9 @@ TYPED_TEST(TestInferDeepTensorPt, print_summary) { TYPED_TEST(TestInferDeepTensorPt, get_type_map) { deepmd::DeepTensor& dt = this->dt; - std::string type_map_str; - dt.get_type_map(type_map_str); - // Parse the type map string manually - std::vector type_map; - std::istringstream iss(type_map_str); - std::string token; - while (iss >> token) { - type_map.push_back(token); - } - EXPECT_EQ(type_map.size(), 2); - EXPECT_EQ(type_map[0], "O"); - EXPECT_EQ(type_map[1], "H"); + std::string type_map; + dt.get_type_map(type_map); + EXPECT_EQ(type_map, "O H"); } TYPED_TEST(TestInferDeepTensorPt, get_properties) { From 4b5e1b101ceb6bd03db5e1bc96af4296edf8d8b1 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Fri, 19 Jun 2026 23:26:40 +0800 Subject: [PATCH 03/11] checkpoint --- source/api_c/tests/test_deeppot_a.cc | 355 ------------------ source/api_c/tests/test_deeppot_a_ptexpt.cc | 312 --------------- source/api_c/tests/test_deeppot_universal.cc | 120 +++++- source/api_cc/tests/test_deeppot_ptexpt.cc | 123 ------ source/api_cc/tests/test_deeppot_universal.cc | 45 ++- source/tests/infer/deeppot_universal_data.h | 70 ++++ 6 files changed, 222 insertions(+), 803 deletions(-) delete mode 100644 source/api_c/tests/test_deeppot_a.cc delete mode 100644 source/api_c/tests/test_deeppot_a_ptexpt.cc diff --git a/source/api_c/tests/test_deeppot_a.cc b/source/api_c/tests/test_deeppot_a.cc deleted file mode 100644 index d5e2d42bf8..0000000000 --- a/source/api_c/tests/test_deeppot_a.cc +++ /dev/null @@ -1,355 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include - -#include -#include - -#include "c_api.h" - -class TestInferDeepPotA : public ::testing::Test { - protected: - double coord[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - float coordf[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - int atype[6] = {0, 1, 1, 0, 1, 1}; - double box[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - float boxf[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e = { - -9.275780747115504710e+01, -1.863501786584258468e+02, - -1.863392472863538103e+02, -9.279281325486221021e+01, - -1.863671545232153903e+02, -1.863619822847602165e+02}; - std::vector expected_f = { - -3.034045420701179663e-01, 8.405844663871177014e-01, - 7.696947487118485642e-02, 7.662001266663505117e-01, - -1.880601391333554251e-01, -6.183333871091722944e-01, - -5.036172391059643427e-01, -6.529525836149027151e-01, - 5.432962643022043459e-01, 6.382357912332115024e-01, - -1.748518296794561167e-01, 3.457363524891907125e-01, - 1.286482986991941552e-03, 3.757251165286925043e-01, - -5.972588700887541124e-01, -5.987006197104716154e-01, - -2.004450304880958100e-01, 2.495901655353461868e-01}; - std::vector expected_v = { - -2.912234126853306959e-01, -3.800610846612756388e-02, - 2.776624987489437202e-01, -5.053761003913598976e-02, - -3.152373041953385746e-01, 1.060894290092162379e-01, - 2.826389131596073745e-01, 1.039129970665329250e-01, - -2.584378792325942586e-01, -3.121722367954994914e-01, - 8.483275876786681990e-02, 2.524662342344257682e-01, - 4.142176771106586414e-02, -3.820285230785245428e-02, - -2.727311173065460545e-02, 2.668859789777112135e-01, - -6.448243569420382404e-02, -2.121731470426218846e-01, - -8.624335220278558922e-02, -1.809695356746038597e-01, - 1.529875294531883312e-01, -1.283658185172031341e-01, - -1.992682279795223999e-01, 1.409924999632362341e-01, - 1.398322735274434292e-01, 1.804318474574856390e-01, - -1.470309318999652726e-01, -2.593983661598450730e-01, - -4.236536279233147489e-02, 3.386387920184946720e-02, - -4.174017537818433543e-02, -1.003500282164128260e-01, - 1.525690815194478966e-01, 3.398976109910181037e-02, - 1.522253908435125536e-01, -2.349125581341701963e-01, - 9.515545977581392825e-04, -1.643218849228543846e-02, - 1.993234765412972564e-02, 6.027265332209678569e-04, - -9.563256398907417355e-02, 1.510815124001868293e-01, - -7.738094816888557714e-03, 1.502832772532304295e-01, - -2.380965783745832010e-01, -2.309456719810296654e-01, - -6.666961081213038098e-02, 7.955566551234216632e-02, - -8.099093777937517447e-02, -3.386641099800401927e-02, - 4.447884755740908608e-02, 1.008593228579038742e-01, - 4.556718179228393811e-02, -6.078081273849572641e-02}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - DP_DeepPot* dp = nullptr; - - void SetUp() override { -#ifndef BUILD_TENSORFLOW - GTEST_SKIP() << "Skip because TensorFlow support is not enabled."; -#endif - const char* file_name = "../../tests/infer/deeppot.pbtxt"; - const char* model_file = "deeppot.pb"; - DP_ConvertPbtxtToPb(file_name, model_file); - - dp = DP_NewDeepPot(model_file); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { - remove("deeppot.pb"); - DP_DeleteDeepPot(dp); - }; -}; - -TEST_F(TestInferDeepPotA, double_infer) { - double* ener_ = new double; - double* force_ = new double[natoms * 3]; - double* virial_ = new double[9]; - double* atomic_ener_ = new double[natoms]; - double* atomic_virial_ = new double[natoms * 9]; - - DP_DeepPotCompute(dp, natoms, coord, atype, box, ener_, force_, virial_, - atomic_ener_, atomic_virial_); - - double ener = *ener_; - std::vector force(force_, force_ + natoms * 3); - std::vector virial(virial_, virial_ + 9); - std::vector atomic_ener(atomic_ener_, atomic_ener_ + natoms); - std::vector atomic_virial(atomic_virial_, - atomic_virial_ + natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-10); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-10); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-10); - } - - delete ener_; - delete[] force_; - delete[] virial_; - delete[] atomic_ener_; - delete[] atomic_virial_; -} - -TEST_F(TestInferDeepPotA, float_infer) { - double* ener_ = new double; - float* force_ = new float[natoms * 3]; - float* virial_ = new float[9]; - float* atomic_ener_ = new float[natoms]; - float* atomic_virial_ = new float[natoms * 9]; - - DP_DeepPotComputef(dp, natoms, coordf, atype, boxf, ener_, force_, virial_, - atomic_ener_, atomic_virial_); - - double ener = *ener_; - std::vector force(force_, force_ + natoms * 3); - std::vector virial(virial_, virial_ + 9); - std::vector atomic_ener(atomic_ener_, atomic_ener_ + natoms); - std::vector atomic_virial(atomic_virial_, atomic_virial_ + natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), 1e-6); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-6); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-6); - } - - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-5); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-6); - } - delete ener_; - delete[] force_; - delete[] virial_; - delete[] atomic_ener_; - delete[] atomic_virial_; -} - -TEST_F(TestInferDeepPotA, cutoff) { - double cutoff = DP_DeepPotGetCutoff(dp); - EXPECT_EQ(cutoff, 6.0); -} - -TEST_F(TestInferDeepPotA, numb_types) { - int numb_types = DP_DeepPotGetNumbTypes(dp); - EXPECT_EQ(numb_types, 2); -} - -TEST_F(TestInferDeepPotA, numb_types_spin) { - int numb_types_spin = DP_DeepPotGetNumbTypesSpin(dp); - EXPECT_EQ(numb_types_spin, 0); -} - -TEST_F(TestInferDeepPotA, type_map) { - const char* type_map = DP_DeepPotGetTypeMap(dp); - char expected_type_map[] = "O H"; - EXPECT_EQ(strcmp(type_map, expected_type_map), 0); - DP_DeleteChar(type_map); -} - -class TestInferDeepPotANoPBC : public ::testing::Test { - protected: - double coord[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - float coordf[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - int atype[6] = {0, 1, 1, 0, 1, 1}; - std::vector expected_e = { - -9.255934839310273787e+01, -1.863253376736990106e+02, - -1.857237299341402945e+02, -9.279308539717486326e+01, - -1.863708105823244239e+02, -1.863635196514972563e+02}; - std::vector expected_f = { - -2.161037360255332107e+00, 9.052994347015581589e-01, - 1.635379623977007979e+00, 2.161037360255332107e+00, - -9.052994347015581589e-01, -1.635379623977007979e+00, - -1.167128117249453811e-02, 1.371975700096064992e-03, - -1.575265180249604477e-03, 6.226508593971802341e-01, - -1.816734122009256991e-01, 3.561766019664774907e-01, - -1.406075393906316626e-02, 3.789140061530929526e-01, - -6.018777878642909140e-01, -5.969188242856223736e-01, - -1.986125696522633155e-01, 2.472764510780630642e-01}; - std::vector expected_v = { - -7.042445481792056761e-01, 2.950213647777754078e-01, - 5.329418202437231633e-01, 2.950213647777752968e-01, - -1.235900311906896754e-01, -2.232594111831812944e-01, - 5.329418202437232743e-01, -2.232594111831813499e-01, - -4.033073234276823849e-01, -8.949230984097404917e-01, - 3.749002169013777030e-01, 6.772391014992630298e-01, - 3.749002169013777586e-01, -1.570527935667933583e-01, - -2.837082722496912512e-01, 6.772391014992631408e-01, - -2.837082722496912512e-01, -5.125052659994422388e-01, - 4.858210330291591605e-02, -6.902596153269104431e-03, - 6.682612642430500391e-03, -5.612247004554610057e-03, - 9.767795567660207592e-04, -9.773758942738038254e-04, - 5.638322117219018645e-03, -9.483806049779926932e-04, - 8.493873281881353637e-04, -2.941738570564985666e-01, - -4.482529909499673171e-02, 4.091569840186781021e-02, - -4.509020615859140463e-02, -1.013919988807244071e-01, - 1.551440772665269030e-01, 4.181857726606644232e-02, - 1.547200233064863484e-01, -2.398213304685777592e-01, - -3.218625798524068354e-02, -1.012438450438508421e-02, - 1.271639330380921855e-02, 3.072814938490859779e-03, - -9.556241797915024372e-02, 1.512251983492413077e-01, - -8.277872384009607454e-03, 1.505412040827929787e-01, - -2.386150620881526407e-01, -2.312295470054945568e-01, - -6.631490213524345034e-02, 7.932427266386249398e-02, - -8.053754366323923053e-02, -3.294595881137418747e-02, - 4.342495071150231922e-02, 1.004599500126941436e-01, - 4.450400364869536163e-02, -5.951077548033092968e-02}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - DP_DeepPot* dp = nullptr; - - void SetUp() override { -#ifndef BUILD_TENSORFLOW - GTEST_SKIP() << "Skip because TensorFlow support is not enabled."; -#endif - const char* file_name = "../../tests/infer/deeppot.pbtxt"; - const char* model_file = "deeppot.pb"; - DP_ConvertPbtxtToPb(file_name, model_file); - - dp = DP_NewDeepPot(model_file); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { - remove("deeppot.pb"); - - DP_DeleteDeepPot(dp); - }; -}; - -TEST_F(TestInferDeepPotANoPBC, double_infer) { - double* ener_ = new double; - double* force_ = new double[natoms * 3]; - double* virial_ = new double[9]; - double* atomic_ener_ = new double[natoms]; - double* atomic_virial_ = new double[natoms * 9]; - - DP_DeepPotCompute(dp, natoms, coord, atype, nullptr, ener_, force_, virial_, - atomic_ener_, atomic_virial_); - - double ener = *ener_; - std::vector force(force_, force_ + natoms * 3); - std::vector virial(virial_, virial_ + 9); - std::vector atomic_ener(atomic_ener_, atomic_ener_ + natoms); - std::vector atomic_virial(atomic_virial_, - atomic_virial_ + natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-10); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-10); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-10); - } - delete ener_; - delete[] force_; - delete[] virial_; - delete[] atomic_ener_; - delete[] atomic_virial_; -} - -TEST_F(TestInferDeepPotANoPBC, float_infer) { - double* ener_ = new double; - float* force_ = new float[natoms * 3]; - float* virial_ = new float[9]; - float* atomic_ener_ = new float[natoms]; - float* atomic_virial_ = new float[natoms * 9]; - - DP_DeepPotComputef(dp, natoms, coordf, atype, nullptr, ener_, force_, virial_, - atomic_ener_, atomic_virial_); - - double ener = *ener_; - std::vector force(force_, force_ + natoms * 3); - std::vector virial(virial_, virial_ + 9); - std::vector atomic_ener(atomic_ener_, atomic_ener_ + natoms); - std::vector atomic_virial(atomic_virial_, atomic_virial_ + natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), 1e-6); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-6); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-6); - } - - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-5); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-6); - } - delete ener_; - delete[] force_; - delete[] virial_; - delete[] atomic_ener_; - delete[] atomic_virial_; -} diff --git a/source/api_c/tests/test_deeppot_a_ptexpt.cc b/source/api_c/tests/test_deeppot_a_ptexpt.cc deleted file mode 100644 index 5f6535557c..0000000000 --- a/source/api_c/tests/test_deeppot_a_ptexpt.cc +++ /dev/null @@ -1,312 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C API inference for pt_expt (.pt2) backend. -// Uses the same model (converted from deeppot_sea.pth) and reference values -// as test_deeppot_ptexpt.cc (C++ API) to verify C API works with .pt2. -#include - -#include -#include -#include - -#include "c_api.h" - -class TestInferDeepPotAPtExptC : public ::testing::Test { - protected: - double coord[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - float coordf[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - int atype[6] = {0, 1, 1, 0, 1, 1}; - double box[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - float boxf[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - // Same reference values as test_deeppot_ptexpt.cc - std::vector expected_e = {-93.016873944029, -185.923296645958, - -185.927096544970, -93.019371018039, - -185.926179995548, -185.924351901852}; - std::vector expected_f = { - 0.006277522211, -0.001117962774, 0.000618580445, 0.009928999655, - 0.003026035654, -0.006941982227, 0.000667853212, -0.002449963843, - 0.006506463508, -0.007284129115, 0.000530662205, -0.000028806821, - 0.000068097781, 0.006121331983, -0.009019754602, -0.009658343745, - -0.006110103225, 0.008865499697}; - std::vector expected_v = { - -0.000155238009, 0.000116605516, -0.007869862476, 0.000465578340, - 0.008182547185, -0.002398713212, -0.008112887338, -0.002423738425, - 0.007210716605, -0.019203504012, 0.001724938709, 0.009909211091, - 0.001153857542, -0.001600015103, -0.000560024090, 0.010727836276, - -0.001034836404, -0.007973454377, -0.021517399106, -0.004064359664, - 0.004866398692, -0.003360038617, -0.007241406162, 0.005920941051, - 0.004899151657, 0.006290788591, -0.006478820311, 0.001921504710, - 0.001313470921, -0.000304091236, 0.001684345981, 0.004124109256, - -0.006396084465, -0.000701095618, -0.006356507032, 0.009818550859, - -0.015230664587, -0.000110244376, 0.000690319396, 0.000045953023, - -0.005726548770, 0.008769818495, -0.000572380210, 0.008860603423, - -0.013819348050, -0.021227082558, -0.004977781343, 0.006646239696, - -0.005987066507, -0.002767831232, 0.003746502525, 0.007697590397, - 0.003746130152, -0.005172634748}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - DP_DeepPot* dp = nullptr; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - const char* model_file = "../../tests/infer/deeppot_sea.pt2"; - dp = DP_NewDeepPot(model_file); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { DP_DeleteDeepPot(dp); }; -}; - -TEST_F(TestInferDeepPotAPtExptC, double_infer) { - double* ener_ = new double; - double* force_ = new double[natoms * 3]; - double* virial_ = new double[9]; - double* atomic_ener_ = new double[natoms]; - double* atomic_virial_ = new double[natoms * 9]; - - DP_DeepPotCompute(dp, natoms, coord, atype, box, ener_, force_, virial_, - atomic_ener_, atomic_virial_); - - double ener = *ener_; - std::vector force(force_, force_ + natoms * 3); - std::vector virial(virial_, virial_ + 9); - std::vector atomic_ener(atomic_ener_, atomic_ener_ + natoms); - std::vector atomic_virial(atomic_virial_, - atomic_virial_ + natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-10); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-10); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-10); - } - - delete ener_; - delete[] force_; - delete[] virial_; - delete[] atomic_ener_; - delete[] atomic_virial_; -} - -TEST_F(TestInferDeepPotAPtExptC, float_infer) { - double* ener_ = new double; - float* force_ = new float[natoms * 3]; - float* virial_ = new float[9]; - float* atomic_ener_ = new float[natoms]; - float* atomic_virial_ = new float[natoms * 9]; - - DP_DeepPotComputef(dp, natoms, coordf, atype, boxf, ener_, force_, virial_, - atomic_ener_, atomic_virial_); - - double ener = *ener_; - std::vector force(force_, force_ + natoms * 3); - std::vector virial(virial_, virial_ + 9); - std::vector atomic_ener(atomic_ener_, atomic_ener_ + natoms); - std::vector atomic_virial(atomic_virial_, atomic_virial_ + natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), 1e-6); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-4); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-4); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-5); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-4); - } - - delete ener_; - delete[] force_; - delete[] virial_; - delete[] atomic_ener_; - delete[] atomic_virial_; -} - -TEST_F(TestInferDeepPotAPtExptC, cutoff) { - double cutoff = DP_DeepPotGetCutoff(dp); - EXPECT_EQ(cutoff, 6.0); -} - -TEST_F(TestInferDeepPotAPtExptC, numb_types) { - int numb_types = DP_DeepPotGetNumbTypes(dp); - EXPECT_EQ(numb_types, 2); -} - -TEST_F(TestInferDeepPotAPtExptC, numb_types_spin) { - int numb_types_spin = DP_DeepPotGetNumbTypesSpin(dp); - EXPECT_EQ(numb_types_spin, 0); -} - -TEST_F(TestInferDeepPotAPtExptC, type_map) { - const char* type_map = DP_DeepPotGetTypeMap(dp); - EXPECT_STREQ(type_map, "O H"); - DP_DeleteChar(type_map); -} - -class TestInferDeepPotAPtExptCNoPbc : public ::testing::Test { - protected: - double coord[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - float coordf[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - int atype[6] = {0, 1, 1, 0, 1, 1}; - // Same NoPbc reference values as test_deeppot_ptexpt.cc - std::vector expected_e = {-93.003304908874, -185.915806542480, - -185.928116717624, -93.017934934346, - -185.924393412278, -185.923906740801}; - std::vector expected_f = { - 0.000868182637, -0.000363698132, -0.000657003077, -0.000868182637, - 0.000363698132, 0.000657003077, 0.007932614680, -0.001003609844, - 0.000737731722, -0.003883788858, 0.000686896282, -0.000578400682, - 0.004064895086, 0.006115547962, -0.008747097814, -0.008113720908, - -0.005798834400, 0.008587766774}; - std::vector expected_v = { - 0.007762485364, -0.003251851977, -0.005874313248, -0.003251851977, - 0.001362262315, 0.002460860955, -0.005874313248, 0.002460860955, - 0.004445426242, -0.007120030212, 0.002982715359, 0.005388130971, - 0.002982715359, -0.001249515894, -0.002257190002, 0.005388130971, - -0.002257190002, -0.004077504519, -0.015805863589, 0.001952684835, - -0.001522876482, 0.001796574704, -0.000358803950, 0.000369710813, - -0.001108943040, 0.000332585300, -0.000395481309, 0.008873525623, - 0.001919112114, -0.001486235522, 0.002002929532, 0.004222469272, - -0.006517211126, -0.001656192522, -0.006501210045, 0.010118622295, - -0.006548889778, -0.000465126991, 0.001002876603, 0.000240398734, - -0.005794489784, 0.008940685179, -0.000121727685, 0.008931999051, - -0.013852797563, -0.017962955675, -0.004645050453, 0.006214692837, - -0.005278283465, -0.002662692758, 0.003618275905, 0.007095320684, - 0.003648086464, -0.005023397513}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - DP_DeepPot* dp = nullptr; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - const char* model_file = "../../tests/infer/deeppot_sea.pt2"; - dp = DP_NewDeepPot(model_file); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { DP_DeleteDeepPot(dp); }; -}; - -TEST_F(TestInferDeepPotAPtExptCNoPbc, double_infer) { - double* ener_ = new double; - double* force_ = new double[natoms * 3]; - double* virial_ = new double[9]; - double* atomic_ener_ = new double[natoms]; - double* atomic_virial_ = new double[natoms * 9]; - - DP_DeepPotCompute(dp, natoms, coord, atype, nullptr, ener_, force_, virial_, - atomic_ener_, atomic_virial_); - - double ener = *ener_; - std::vector force(force_, force_ + natoms * 3); - std::vector virial(virial_, virial_ + 9); - std::vector atomic_ener(atomic_ener_, atomic_ener_ + natoms); - std::vector atomic_virial(atomic_virial_, - atomic_virial_ + natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-10); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-10); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-10); - } - - delete ener_; - delete[] force_; - delete[] virial_; - delete[] atomic_ener_; - delete[] atomic_virial_; -} - -TEST_F(TestInferDeepPotAPtExptCNoPbc, float_infer) { - double* ener_ = new double; - float* force_ = new float[natoms * 3]; - float* virial_ = new float[9]; - float* atomic_ener_ = new float[natoms]; - float* atomic_virial_ = new float[natoms * 9]; - - DP_DeepPotComputef(dp, natoms, coordf, atype, nullptr, ener_, force_, virial_, - atomic_ener_, atomic_virial_); - - double ener = *ener_; - std::vector force(force_, force_ + natoms * 3); - std::vector virial(virial_, virial_ + 9); - std::vector atomic_ener(atomic_ener_, atomic_ener_ + natoms); - std::vector atomic_virial(atomic_virial_, atomic_virial_ + natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), 1e-6); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-4); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-4); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-5); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-4); - } - - delete ener_; - delete[] force_; - delete[] virial_; - delete[] atomic_ener_; - delete[] atomic_virial_; -} diff --git a/source/api_c/tests/test_deeppot_universal.cc b/source/api_c/tests/test_deeppot_universal.cc index cb3bcd6c85..1bf1d49ee3 100644 --- a/source/api_c/tests/test_deeppot_universal.cc +++ b/source/api_c/tests/test_deeppot_universal.cc @@ -22,6 +22,7 @@ struct ModelCase { std::string model_path; bool convert_pbtxt; const deepmd_test::DeepPotRef* ref; + const deepmd_test::DeepPotRef* no_pbc_ref; double double_tol; double float_tol; bool supports_float; @@ -87,16 +88,19 @@ std::string backend_name(Backend backend) { std::vector model_cases() { return { {"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/deeppot.pbtxt", - true, &deepmd_test::tf_deeppot_ref(), 1e-10, 1e-4, true}, + true, &deepmd_test::tf_deeppot_ref(), + &deepmd_test::tf_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, {"pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_sea.pth", - false, &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + false, &deepmd_test::sea_deeppot_ref(), + &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_sea.pt2", - false, &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + false, &deepmd_test::sea_deeppot_ref(), + &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, {"jax_savedmodel", Backend::JAX, "../../tests/infer/deeppot_sea.savedmodel", false, - &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + &deepmd_test::sea_deeppot_ref(), nullptr, 1e-10, 1e-4, true}, {"paddle_json", Backend::Paddle, "../../tests/infer/deeppot_sea.json", - false, &deepmd_test::sea_deeppot_ref(), 1e-7, 1e-4, false}}; + false, &deepmd_test::sea_deeppot_ref(), nullptr, 1e-7, 1e-4, false}}; } class UniversalDeepPotCTest : public ::testing::TestWithParam { @@ -219,6 +223,73 @@ void check_compute_float(DP_DeepPot* dp, } } +void check_compute_legacy_double(DP_DeepPot* dp, + const deepmd_test::DeepPotRef& ref, + const double* box, + const double tol) { + const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const std::vector& coord = deepmd_test::deeppot_coord(); + const std::vector& atype = deepmd_test::deeppot_atype(); + const std::vector expected_virial = deepmd_test::total_virial(ref); + + double energy = 0.0; + std::vector force(natoms * 3); + std::vector virial(9); + std::vector atomic_energy(natoms); + std::vector atomic_virial(natoms * 9); + DP_DeepPotCompute(dp, natoms, coord.data(), atype.data(), box, &energy, + force.data(), virial.data(), atomic_energy.data(), + atomic_virial.data()); + + EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol); + for (int ii = 0; ii < natoms * 3; ++ii) { + EXPECT_NEAR(force[ii], ref.force[ii], tol); + } + for (size_t ii = 0; ii < 9; ++ii) { + EXPECT_NEAR(virial[ii], expected_virial[ii], tol); + } + for (int ii = 0; ii < natoms; ++ii) { + EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol); + } + for (int ii = 0; ii < natoms * 9; ++ii) { + EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol); + } +} + +void check_compute_legacy_float(DP_DeepPot* dp, + const deepmd_test::DeepPotRef& ref, + const float* box, + const double tol) { + const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const std::vector coord(deepmd_test::deeppot_coord().begin(), + deepmd_test::deeppot_coord().end()); + const std::vector& atype = deepmd_test::deeppot_atype(); + const std::vector expected_virial = deepmd_test::total_virial(ref); + + double energy = 0.0; + std::vector force(natoms * 3); + std::vector virial(9); + std::vector atomic_energy(natoms); + std::vector atomic_virial(natoms * 9); + DP_DeepPotComputef(dp, natoms, coord.data(), atype.data(), box, &energy, + force.data(), virial.data(), atomic_energy.data(), + atomic_virial.data()); + + EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol); + for (int ii = 0; ii < natoms * 3; ++ii) { + EXPECT_NEAR(force[ii], ref.force[ii], tol); + } + for (size_t ii = 0; ii < 9; ++ii) { + EXPECT_NEAR(virial[ii], expected_virial[ii], tol); + } + for (int ii = 0; ii < natoms; ++ii) { + EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol); + } + for (int ii = 0; ii < natoms * 9; ++ii) { + EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol); + } +} + TEST_P(UniversalDeepPotCTest, ComputeDouble) { check_compute_double(dp, *GetParam().ref, GetParam().double_tol); } @@ -231,6 +302,45 @@ TEST_P(UniversalDeepPotCTest, ComputeFloat) { check_compute_float(dp, *GetParam().ref, GetParam().float_tol); } +TEST_P(UniversalDeepPotCTest, ComputeLegacyDouble) { + const std::vector& box = deepmd_test::deeppot_box(); + check_compute_legacy_double(dp, *GetParam().ref, box.data(), + GetParam().double_tol); +} + +TEST_P(UniversalDeepPotCTest, ComputeLegacyFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + const std::vector& box_double = deepmd_test::deeppot_box(); + const std::vector box(box_double.begin(), box_double.end()); + check_compute_legacy_float(dp, *GetParam().ref, box.data(), + GetParam().float_tol); +} + +TEST_P(UniversalDeepPotCTest, ComputeLegacyNoPbcDouble) { + if (GetParam().no_pbc_ref == nullptr) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " NoPBC reference is not available."; + } + check_compute_legacy_double(dp, *GetParam().no_pbc_ref, nullptr, + GetParam().double_tol); +} + +TEST_P(UniversalDeepPotCTest, ComputeLegacyNoPbcFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (GetParam().no_pbc_ref == nullptr) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " NoPBC reference is not available."; + } + check_compute_legacy_float(dp, *GetParam().no_pbc_ref, nullptr, + GetParam().float_tol); +} + INSTANTIATE_TEST_SUITE_P( AvailableBackends, UniversalDeepPotCTest, diff --git a/source/api_cc/tests/test_deeppot_ptexpt.cc b/source/api_cc/tests/test_deeppot_ptexpt.cc index cbf1303633..41afb2eb2e 100644 --- a/source/api_cc/tests/test_deeppot_ptexpt.cc +++ b/source/api_cc/tests/test_deeppot_ptexpt.cc @@ -197,42 +197,6 @@ TYPED_TEST(TestInferDeepPotAPtExpt, cpu_build_nlist_numfv) { model.test_v(coord, box_); } -TYPED_TEST(TestInferDeepPotAPtExpt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - TYPED_TEST(TestInferDeepPotAPtExpt, cpu_lmp_nlist) { using VALUETYPE = TypeParam; std::vector& coord = this->coord; @@ -764,42 +728,6 @@ TYPED_TEST(TestInferDeepPotAPtExptNoPbc, cpu_build_nlist) { } } -TYPED_TEST(TestInferDeepPotAPtExptNoPbc, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - // Multi-frame PBC test via compute_mixed_type TYPED_TEST(TestInferDeepPotAPtExpt, cpu_build_nlist_nframes) { using VALUETYPE = TypeParam; @@ -916,57 +844,6 @@ TEST(TestDeepPotPTExptParser, load_tiny_file) { std::remove(tmpfile.c_str()); } -// Metadata accessor tests — exercise JSON parser on a real model -template -class TestDeepPotPTExptMetadata : public ::testing::Test { - protected: - static deepmd::DeepPot dp; - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init("../../tests/infer/deeppot_sea.pt2"); -#endif - } - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - }; - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestDeepPotPTExptMetadata::dp; - -TYPED_TEST_SUITE(TestDeepPotPTExptMetadata, ValueTypes); - -TYPED_TEST(TestDeepPotPTExptMetadata, type_map) { - std::string type_map; - this->dp.get_type_map(type_map); - EXPECT_EQ(type_map, "O H"); -} - -TYPED_TEST(TestDeepPotPTExptMetadata, cutoff) { - EXPECT_GT(this->dp.cutoff(), 0.0); -} - -TYPED_TEST(TestDeepPotPTExptMetadata, ntypes) { - EXPECT_EQ(this->dp.numb_types(), 2); -} - -TYPED_TEST(TestDeepPotPTExptMetadata, dim_fparam_zero) { - EXPECT_EQ(this->dp.dim_fparam(), 0); -} - -TYPED_TEST(TestDeepPotPTExptMetadata, dim_aparam_zero) { - EXPECT_EQ(this->dp.dim_aparam(), 0); -} - -TYPED_TEST(TestDeepPotPTExptMetadata, no_default_fparam) { - EXPECT_FALSE(this->dp.has_default_fparam()); -} - // JSON parser type-coverage via fparam model template class TestDeepPotPTExptJsonTypes : public ::testing::Test { diff --git a/source/api_cc/tests/test_deeppot_universal.cc b/source/api_cc/tests/test_deeppot_universal.cc index b9015fdedf..daf8285a54 100644 --- a/source/api_cc/tests/test_deeppot_universal.cc +++ b/source/api_cc/tests/test_deeppot_universal.cc @@ -22,6 +22,7 @@ struct ModelCase { std::string model_path; bool convert_pbtxt; const deepmd_test::DeepPotRef* ref; + const deepmd_test::DeepPotRef* no_pbc_ref; double double_tol; double float_tol; bool supports_float; @@ -87,16 +88,19 @@ std::string backend_name(Backend backend) { std::vector model_cases() { return { {"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/deeppot.pbtxt", - true, &deepmd_test::tf_deeppot_ref(), 1e-10, 1e-4, true}, + true, &deepmd_test::tf_deeppot_ref(), + &deepmd_test::tf_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, {"pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_sea.pth", - false, &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + false, &deepmd_test::sea_deeppot_ref(), + &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_sea.pt2", - false, &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + false, &deepmd_test::sea_deeppot_ref(), + &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, {"jax_savedmodel", Backend::JAX, "../../tests/infer/deeppot_sea.savedmodel", false, - &deepmd_test::sea_deeppot_ref(), 1e-10, 1e-4, true}, + &deepmd_test::sea_deeppot_ref(), nullptr, 1e-10, 1e-4, true}, {"paddle_json", Backend::Paddle, "../../tests/infer/deeppot_sea.json", - false, &deepmd_test::sea_deeppot_ref(), 1e-7, 1e-4, false}}; + false, &deepmd_test::sea_deeppot_ref(), nullptr, 1e-7, 1e-4, false}}; } class UniversalDeepPotTest : public ::testing::TestWithParam { @@ -147,12 +151,16 @@ TEST_P(UniversalDeepPotTest, Metadata) { template void check_compute(deepmd::DeepPot& dp, const deepmd_test::DeepPotRef& ref, - const double tol) { + const double tol, + const bool use_box = true) { const int natoms = static_cast(deepmd_test::deeppot_atype().size()); const std::vector coord(deepmd_test::deeppot_coord().begin(), deepmd_test::deeppot_coord().end()); - const std::vector box(deepmd_test::deeppot_box().begin(), - deepmd_test::deeppot_box().end()); + std::vector box; + if (use_box) { + box.assign(deepmd_test::deeppot_box().begin(), + deepmd_test::deeppot_box().end()); + } const std::vector atype = deepmd_test::deeppot_atype(); const std::vector expected_virial = deepmd_test::total_virial(ref); @@ -196,6 +204,27 @@ TEST_P(UniversalDeepPotTest, ComputeFloat) { check_compute(dp, *GetParam().ref, GetParam().float_tol); } +TEST_P(UniversalDeepPotTest, ComputeNoPbcDouble) { + if (GetParam().no_pbc_ref == nullptr) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " NoPBC reference is not available."; + } + check_compute(dp, *GetParam().no_pbc_ref, GetParam().double_tol, + false); +} + +TEST_P(UniversalDeepPotTest, ComputeNoPbcFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (GetParam().no_pbc_ref == nullptr) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " NoPBC reference is not available."; + } + check_compute(dp, *GetParam().no_pbc_ref, GetParam().float_tol, false); +} + INSTANTIATE_TEST_SUITE_P( AvailableBackends, UniversalDeepPotTest, diff --git a/source/tests/infer/deeppot_universal_data.h b/source/tests/infer/deeppot_universal_data.h index 24cebb44ab..0c9db4e97d 100644 --- a/source/tests/infer/deeppot_universal_data.h +++ b/source/tests/infer/deeppot_universal_data.h @@ -83,6 +83,50 @@ inline const DeepPotRef& tf_deeppot_ref() { return ref; } +inline const DeepPotRef& tf_deeppot_no_pbc_ref() { + static const DeepPotRef ref = { + {-9.255934839310273787e+01, -1.863253376736990106e+02, + -1.857237299341402945e+02, -9.279308539717486326e+01, + -1.863708105823244239e+02, -1.863635196514972563e+02}, + {-2.161037360255332107e+00, 9.052994347015581589e-01, + 1.635379623977007979e+00, 2.161037360255332107e+00, + -9.052994347015581589e-01, -1.635379623977007979e+00, + -1.167128117249453811e-02, 1.371975700096064992e-03, + -1.575265180249604477e-03, 6.226508593971802341e-01, + -1.816734122009256991e-01, 3.561766019664774907e-01, + -1.406075393906316626e-02, 3.789140061530929526e-01, + -6.018777878642909140e-01, -5.969188242856223736e-01, + -1.986125696522633155e-01, 2.472764510780630642e-01}, + {-7.042445481792056761e-01, 2.950213647777754078e-01, + 5.329418202437231633e-01, 2.950213647777752968e-01, + -1.235900311906896754e-01, -2.232594111831812944e-01, + 5.329418202437232743e-01, -2.232594111831813499e-01, + -4.033073234276823849e-01, -8.949230984097404917e-01, + 3.749002169013777030e-01, 6.772391014992630298e-01, + 3.749002169013777586e-01, -1.570527935667933583e-01, + -2.837082722496912512e-01, 6.772391014992631408e-01, + -2.837082722496912512e-01, -5.125052659994422388e-01, + 4.858210330291591605e-02, -6.902596153269104431e-03, + 6.682612642430500391e-03, -5.612247004554610057e-03, + 9.767795567660207592e-04, -9.773758942738038254e-04, + 5.638322117219018645e-03, -9.483806049779926932e-04, + 8.493873281881353637e-04, -2.941738570564985666e-01, + -4.482529909499673171e-02, 4.091569840186781021e-02, + -4.509020615859140463e-02, -1.013919988807244071e-01, + 1.551440772665269030e-01, 4.181857726606644232e-02, + 1.547200233064863484e-01, -2.398213304685777592e-01, + -3.218625798524068354e-02, -1.012438450438508421e-02, + 1.271639330380921855e-02, 3.072814938490859779e-03, + -9.556241797915024372e-02, 1.512251983492413077e-01, + -8.277872384009607454e-03, 1.505412040827929787e-01, + -2.386150620881526407e-01, -2.312295470054945568e-01, + -6.631490213524345034e-02, 7.932427266386249398e-02, + -8.053754366323923053e-02, -3.294595881137418747e-02, + 4.342495071150231922e-02, 1.004599500126941436e-01, + 4.450400364869536163e-02, -5.951077548033092968e-02}}; + return ref; +} + inline const DeepPotRef& sea_deeppot_ref() { static const DeepPotRef ref = { {-93.016873944029, -185.923296645958, -185.927096544970, -93.019371018039, @@ -109,6 +153,32 @@ inline const DeepPotRef& sea_deeppot_ref() { return ref; } +inline const DeepPotRef& sea_deeppot_no_pbc_ref() { + static const DeepPotRef ref = { + {-93.003304908874, -185.915806542480, -185.928116717624, -93.017934934346, + -185.924393412278, -185.923906740801}, + {0.000868182637, -0.000363698132, -0.000657003077, -0.000868182637, + 0.000363698132, 0.000657003077, 0.007932614680, -0.001003609844, + 0.000737731722, -0.003883788858, 0.000686896282, -0.000578400682, + 0.004064895086, 0.006115547962, -0.008747097814, -0.008113720908, + -0.005798834400, 0.008587766774}, + {0.007762485364, -0.003251851977, -0.005874313248, -0.003251851977, + 0.001362262315, 0.002460860955, -0.005874313248, 0.002460860955, + 0.004445426242, -0.007120030212, 0.002982715359, 0.005388130971, + 0.002982715359, -0.001249515894, -0.002257190002, 0.005388130971, + -0.002257190002, -0.004077504519, -0.015805863589, 0.001952684835, + -0.001522876482, 0.001796574704, -0.000358803950, 0.000369710813, + -0.001108943040, 0.000332585300, -0.000395481309, 0.008873525623, + 0.001919112114, -0.001486235522, 0.002002929532, 0.004222469272, + -0.006517211126, -0.001656192522, -0.006501210045, 0.010118622295, + -0.006548889778, -0.000465126991, 0.001002876603, 0.000240398734, + -0.005794489784, 0.008940685179, -0.000121727685, 0.008931999051, + -0.013852797563, -0.017962955675, -0.004645050453, 0.006214692837, + -0.005278283465, -0.002662692758, 0.003618275905, 0.007095320684, + 0.003648086464, -0.005023397513}}; + return ref; +} + inline double total_energy(const DeepPotRef& ref) { return std::accumulate(ref.atomic_energy.begin(), ref.atomic_energy.end(), 0.0); From 5f17e36cd00d3f3cfa75f313915eebdf8708b877 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 20 Jun 2026 00:31:01 +0800 Subject: [PATCH 04/11] test(api): consolidate deeppot universal tests --- .../test_deeppot_a_fparam_aparam_ptexpt.cc | 163 --- source/api_c/tests/test_deeppot_universal.cc | 192 ++- source/api_cc/tests/test_deeppot_a.cc | 668 --------- .../tests/test_deeppot_a_fparam_aparam.cc | 386 ------ .../tests/test_deeppot_a_fparam_aparam_pt.cc | 359 ----- .../test_deeppot_a_fparam_aparam_ptexpt.cc | 341 ----- source/api_cc/tests/test_deeppot_a_nframes.cc | 792 ----------- .../tests/test_deeppot_default_fparam_pt.cc | 217 --- .../test_deeppot_default_fparam_ptexpt.cc | 203 --- source/api_cc/tests/test_deeppot_jax.cc | 557 -------- source/api_cc/tests/test_deeppot_pd.cc | 648 --------- source/api_cc/tests/test_deeppot_pt.cc | 636 --------- source/api_cc/tests/test_deeppot_ptexpt.cc | 8 +- source/api_cc/tests/test_deeppot_universal.cc | 1202 ++++++++++++++++- source/lmp/tests/test_lammps_faparam.py | 2 +- source/tests/infer/deeppot_universal_data.h | 66 + source/tests/infer/gen_fparam_aparam.py | 3 +- 17 files changed, 1436 insertions(+), 5007 deletions(-) delete mode 100644 source/api_c/tests/test_deeppot_a_fparam_aparam_ptexpt.cc delete mode 100644 source/api_cc/tests/test_deeppot_a.cc delete mode 100644 source/api_cc/tests/test_deeppot_a_fparam_aparam.cc delete mode 100644 source/api_cc/tests/test_deeppot_a_fparam_aparam_pt.cc delete mode 100644 source/api_cc/tests/test_deeppot_a_fparam_aparam_ptexpt.cc delete mode 100644 source/api_cc/tests/test_deeppot_a_nframes.cc delete mode 100644 source/api_cc/tests/test_deeppot_default_fparam_pt.cc delete mode 100644 source/api_cc/tests/test_deeppot_default_fparam_ptexpt.cc delete mode 100644 source/api_cc/tests/test_deeppot_jax.cc delete mode 100644 source/api_cc/tests/test_deeppot_pd.cc delete mode 100644 source/api_cc/tests/test_deeppot_pt.cc diff --git a/source/api_c/tests/test_deeppot_a_fparam_aparam_ptexpt.cc b/source/api_c/tests/test_deeppot_a_fparam_aparam_ptexpt.cc deleted file mode 100644 index 9b5b086092..0000000000 --- a/source/api_c/tests/test_deeppot_a_fparam_aparam_ptexpt.cc +++ /dev/null @@ -1,163 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C API inference for pt_expt (.pt2) backend with fparam and aparam. -#include - -#include -#include - -#include "c_api.h" - -class TestInferDeepPotAFParamAParamPtExptC : public ::testing::Test { - protected: - double coord[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - float coordf[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - int atype[6] = {0, 0, 0, 0, 0, 0}; - double box[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - float boxf[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - double fparam[1] = {0.25852028}; - float fparamf[1] = {0.25852028}; - double aparam[6] = {0.25852028, 0.25852028, 0.25852028, - 0.25852028, 0.25852028, 0.25852028}; - float aparamf[6] = {0.25852028, 0.25852028, 0.25852028, - 0.25852028, 0.25852028, 0.25852028}; - // Same reference values as test_deeppot_a_fparam_aparam_ptexpt.cc (C++ API) - // Generated from pre-committed fparam_aparam_default.pth - std::vector expected_e = { - -1.038271223729636539e-01, -7.285433579124989123e-02, - -9.467600492266425860e-02, -1.467050207422957442e-01, - -7.660561676973243195e-02, -7.277296000253175023e-02}; - std::vector expected_f = { - 6.622266941151369601e-02, 5.278739714221529489e-02, - 2.265728009692277028e-02, -2.606048291367509331e-02, - -4.538812303131847109e-02, 1.058247419681241676e-02, - 1.679392617013223121e-01, -2.257826240741929533e-03, - -4.490146347357203138e-02, -1.148364179422036724e-01, - -1.169790528013799069e-02, 6.140403441496700837e-02, - -8.078778123309421355e-02, -5.838879041789352825e-02, - 6.773641084621376263e-02, -1.247724902386305318e-02, - 6.494524782787665373e-02, -1.174787360813439457e-01}; - std::vector expected_v = { - -1.589185601903579381e-01, 2.586167090689088510e-03, - -1.575150812458056548e-04, -1.855360549216640564e-02, - 1.949822308966445150e-02, -1.006552178977542650e-02, - 3.177030388421490936e-02, 1.714350280402104215e-03, - -1.290389705296313833e-03, -8.553511587973079699e-02, - -5.654638208496251539e-03, -1.286955066237439882e-02, - 2.464156699303176462e-02, -2.398203243424212178e-02, - -1.957110698882909630e-02, 2.233493653505165544e-02, - 6.107843889444162372e-03, 1.707076397717688723e-03, - -1.653994136896924094e-01, 3.894358809712639147e-02, - -2.169596032233910010e-02, 6.819702786556020371e-03, - -5.018240707559744503e-03, 2.640663592968431426e-03, - -1.985295554050418160e-03, -3.638422207618969423e-02, - 2.342932709960221863e-02, -8.501331666888653493e-02, - -2.181253119706856591e-03, 4.311299629418858387e-03, - -1.910329576491436726e-03, -1.808810428459609043e-03, - -1.540075460017477360e-03, -1.173703527688202929e-02, - -2.596307050960845741e-03, 6.705026635782097323e-03, - -9.038454847872562370e-02, 3.011717694088476838e-02, - -5.083053967307901710e-02, -2.951212926932282599e-03, - 2.342446057919112673e-02, -4.091208178777860222e-02, - -1.648470670751139844e-02, -2.872262362355524484e-02, - 4.763925761561256522e-02, -8.300037376164930147e-02, - 1.020429200603871836e-03, -1.026734257188876599e-03, - 5.678534821710372327e-02, 1.273635858276599142e-02, - -1.530143401888291177e-02, -1.061672032476311256e-01, - -2.486859787145567074e-02, 2.875323543588798395e-02}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - DP_DeepPot* dp = nullptr; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - const char* model_file = "../../tests/infer/fparam_aparam.pt2"; - dp = DP_NewDeepPot(model_file); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { DP_DeleteDeepPot(dp); }; -}; - -TEST_F(TestInferDeepPotAFParamAParamPtExptC, double_infer) { - double* ener_ = new double; - double* force_ = new double[natoms * 3]; - double* virial_ = new double[9]; - double* atomic_ener_ = new double[natoms]; - double* atomic_virial_ = new double[natoms * 9]; - - DP_DeepPotCompute2(dp, 1, natoms, coord, atype, box, fparam, aparam, ener_, - force_, virial_, atomic_ener_, atomic_virial_); - - double ener = *ener_; - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force_[ii] - expected_f[ii]), 1e-10); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial_[ii] - expected_tot_v[ii]), 1e-10); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atomic_ener_[ii] - expected_e[ii]), 1e-10); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atomic_virial_[ii] - expected_v[ii]), 1e-10); - } - - delete ener_; - delete[] force_; - delete[] virial_; - delete[] atomic_ener_; - delete[] atomic_virial_; -} - -TEST_F(TestInferDeepPotAFParamAParamPtExptC, float_infer) { - double* ener_ = new double; - float* force_ = new float[natoms * 3]; - float* virial_ = new float[9]; - float* atomic_ener_ = new float[natoms]; - float* atomic_virial_ = new float[natoms * 9]; - - DP_DeepPotComputef2(dp, 1, natoms, coordf, atype, boxf, fparamf, aparamf, - ener_, force_, virial_, atomic_ener_, atomic_virial_); - - double ener = *ener_; - EXPECT_LT(fabs(ener - expected_tot_e), 1e-6); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force_[ii] - expected_f[ii]), 1e-4); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial_[ii] - expected_tot_v[ii]), 1e-4); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atomic_ener_[ii] - expected_e[ii]), 1e-5); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atomic_virial_[ii] - expected_v[ii]), 1e-4); - } - - delete ener_; - delete[] force_; - delete[] virial_; - delete[] atomic_ener_; - delete[] atomic_virial_; -} diff --git a/source/api_c/tests/test_deeppot_universal.cc b/source/api_c/tests/test_deeppot_universal.cc index 1bf1d49ee3..d7d6841382 100644 --- a/source/api_c/tests/test_deeppot_universal.cc +++ b/source/api_c/tests/test_deeppot_universal.cc @@ -8,6 +8,7 @@ #include #include +#include "../../api_cc/tests/expected_ref.h" #include "../../tests/infer/deeppot_universal_data.h" #include "DeepPotPTExpt.h" #include "c_api.h" @@ -28,6 +29,18 @@ struct ModelCase { bool supports_float; }; +struct FParamAParamCase { + std::string name; + Backend backend; + std::string model_path; + bool convert_pbtxt; + const deepmd_test::DeepPotRef* builtin_ref; + std::string ref_path; + double double_tol; + double float_tol; + bool supports_float; +}; + bool path_exists(const std::string& path) { struct stat statbuf; return stat(path.c_str(), &statbuf) == 0; @@ -103,6 +116,32 @@ std::vector model_cases() { false, &deepmd_test::sea_deeppot_ref(), nullptr, 1e-7, 1e-4, false}}; } +std::vector fparam_aparam_cases() { + return {{"tensorflow_pb", Backend::TensorFlow, + "../../tests/infer/fparam_aparam.pbtxt", true, + &deepmd_test::tf_fparam_aparam_ref(), "", 1e-10, 1e-4, true}, + {"pytorch_pth", Backend::PyTorch, + "../../tests/infer/fparam_aparam.pth", false, nullptr, + "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4, true}, + {"pytorch_pt2", Backend::PTExpt, + "../../tests/infer/fparam_aparam.pt2", false, nullptr, + "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4, true}}; +} + +deepmd_test::DeepPotRef load_fparam_ref(const std::string& ref_path) { + deepmd_test::ExpectedRef ref_file; + ref_file.load(ref_path); + deepmd_test::DeepPotRef ref; + ref.atomic_energy = ref_file.get("default", "expected_e"); + ref.force = ref_file.get("default", "expected_f"); + ref.atomic_virial = ref_file.get("default", "expected_v"); + ref.numb_types = 1; + ref.dim_fparam = 1; + ref.dim_aparam = 1; + ref.type_map = "O"; + return ref; +} + class UniversalDeepPotCTest : public ::testing::TestWithParam { protected: DP_DeepPot* dp = nullptr; @@ -113,9 +152,8 @@ class UniversalDeepPotCTest : public ::testing::TestWithParam { if (!backend_enabled(param.backend)) { GTEST_SKIP() << backend_name(param.backend) << " support is not enabled."; } - if (!path_exists(param.model_path)) { - GTEST_SKIP() << "Model artifact is not available: " << param.model_path; - } + ASSERT_TRUE(path_exists(param.model_path)) + << "Model artifact is not available: " << param.model_path; std::string model_path = param.model_path; if (param.convert_pbtxt) { @@ -139,6 +177,52 @@ class UniversalDeepPotCTest : public ::testing::TestWithParam { } }; +class FParamAParamDeepPotCTest + : public ::testing::TestWithParam { + protected: + DP_DeepPot* dp = nullptr; + std::string converted_model; + deepmd_test::DeepPotRef loaded_ref; + const deepmd_test::DeepPotRef* ref = nullptr; + + void SetUp() override { + const auto& param = GetParam(); + if (!backend_enabled(param.backend)) { + GTEST_SKIP() << backend_name(param.backend) << " support is not enabled."; + } + ASSERT_TRUE(path_exists(param.model_path)) + << "Model artifact is not available: " << param.model_path; + if (param.builtin_ref != nullptr) { + ref = param.builtin_ref; + } else { + ASSERT_TRUE(path_exists(param.ref_path)) + << "Reference artifact is not available: " << param.ref_path; + loaded_ref = load_fparam_ref(param.ref_path); + ref = &loaded_ref; + } + + std::string model_path = param.model_path; + if (param.convert_pbtxt) { + converted_model = "deeppot_c_fparam_aparam_" + param.name + ".pb"; + DP_ConvertPbtxtToPb(param.model_path.c_str(), converted_model.c_str()); + model_path = converted_model; + } + dp = DP_NewDeepPot(model_path.c_str()); + const char* error = DP_DeepPotCheckOK(dp); + const std::string error_message(error); + DP_DeleteChar(error); + ASSERT_TRUE(error_message.empty()) + << "Model artifact cannot be loaded by this backend: " << error_message; + } + + void TearDown() override { + DP_DeleteDeepPot(dp); + if (!converted_model.empty()) { + remove(converted_model.c_str()); + } + } +}; + TEST_P(UniversalDeepPotCTest, Metadata) { const auto& ref = *GetParam().ref; @@ -290,6 +374,83 @@ void check_compute_legacy_float(DP_DeepPot* dp, } } +void check_fparam_compute_double(DP_DeepPot* dp, + const deepmd_test::DeepPotRef& ref, + const double tol) { + const int natoms = + static_cast(deepmd_test::fparam_aparam_atype().size()); + const std::vector& coord = deepmd_test::deeppot_coord(); + const std::vector& box = deepmd_test::deeppot_box(); + const std::vector& atype = deepmd_test::fparam_aparam_atype(); + const std::vector& fparam = deepmd_test::fparam_value(); + const std::vector& aparam = deepmd_test::aparam_value(); + const std::vector expected_virial = deepmd_test::total_virial(ref); + + double energy = 0.0; + std::vector force(natoms * 3); + std::vector virial(9); + std::vector atomic_energy(natoms); + std::vector atomic_virial(natoms * 9); + DP_DeepPotCompute2(dp, 1, natoms, coord.data(), atype.data(), box.data(), + fparam.data(), aparam.data(), &energy, force.data(), + virial.data(), atomic_energy.data(), atomic_virial.data()); + + EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol); + for (int ii = 0; ii < natoms * 3; ++ii) { + EXPECT_NEAR(force[ii], ref.force[ii], tol); + } + for (size_t ii = 0; ii < 9; ++ii) { + EXPECT_NEAR(virial[ii], expected_virial[ii], tol); + } + for (int ii = 0; ii < natoms; ++ii) { + EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol); + } + for (int ii = 0; ii < natoms * 9; ++ii) { + EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol); + } +} + +void check_fparam_compute_float(DP_DeepPot* dp, + const deepmd_test::DeepPotRef& ref, + const double tol) { + const int natoms = + static_cast(deepmd_test::fparam_aparam_atype().size()); + const std::vector coord(deepmd_test::deeppot_coord().begin(), + deepmd_test::deeppot_coord().end()); + const std::vector box(deepmd_test::deeppot_box().begin(), + deepmd_test::deeppot_box().end()); + const std::vector& atype = deepmd_test::fparam_aparam_atype(); + const std::vector fparam(deepmd_test::fparam_value().begin(), + deepmd_test::fparam_value().end()); + const std::vector aparam(deepmd_test::aparam_value().begin(), + deepmd_test::aparam_value().end()); + const std::vector expected_virial = deepmd_test::total_virial(ref); + + double energy = 0.0; + std::vector force(natoms * 3); + std::vector virial(9); + std::vector atomic_energy(natoms); + std::vector atomic_virial(natoms * 9); + DP_DeepPotComputef2(dp, 1, natoms, coord.data(), atype.data(), box.data(), + fparam.data(), aparam.data(), &energy, force.data(), + virial.data(), atomic_energy.data(), + atomic_virial.data()); + + EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol); + for (int ii = 0; ii < natoms * 3; ++ii) { + EXPECT_NEAR(force[ii], ref.force[ii], tol); + } + for (size_t ii = 0; ii < 9; ++ii) { + EXPECT_NEAR(virial[ii], expected_virial[ii], tol); + } + for (int ii = 0; ii < natoms; ++ii) { + EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol); + } + for (int ii = 0; ii < natoms * 9; ++ii) { + EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol); + } +} + TEST_P(UniversalDeepPotCTest, ComputeDouble) { check_compute_double(dp, *GetParam().ref, GetParam().double_tol); } @@ -341,6 +502,24 @@ TEST_P(UniversalDeepPotCTest, ComputeLegacyNoPbcFloat) { GetParam().float_tol); } +TEST_P(FParamAParamDeepPotCTest, Metadata) { + EXPECT_EQ(DP_DeepPotGetDimFParam(dp), 1); + EXPECT_EQ(DP_DeepPotGetDimAParam(dp), 1); + EXPECT_FALSE(DP_DeepPotHasDefaultFParam(dp)); +} + +TEST_P(FParamAParamDeepPotCTest, ComputeDouble) { + check_fparam_compute_double(dp, *ref, GetParam().double_tol); +} + +TEST_P(FParamAParamDeepPotCTest, ComputeFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_fparam_compute_float(dp, *ref, GetParam().float_tol); +} + INSTANTIATE_TEST_SUITE_P( AvailableBackends, UniversalDeepPotCTest, @@ -349,4 +528,11 @@ INSTANTIATE_TEST_SUITE_P( return info.param.name; }); +INSTANTIATE_TEST_SUITE_P( + FParamAParamBackends, + FParamAParamDeepPotCTest, + ::testing::ValuesIn(fparam_aparam_cases()), + [](const ::testing::TestParamInfo& + info) { return info.param.name; }); + } // namespace diff --git a/source/api_cc/tests/test_deeppot_a.cc b/source/api_cc/tests/test_deeppot_a.cc deleted file mode 100644 index ffd2a25a5d..0000000000 --- a/source/api_cc/tests/test_deeppot_a.cc +++ /dev/null @@ -1,668 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "neighbor_list.h" -#include "test_utils.h" - -template -class TestInferDeepPotA : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e = { - -9.275780747115504710e+01, -1.863501786584258468e+02, - -1.863392472863538103e+02, -9.279281325486221021e+01, - -1.863671545232153903e+02, -1.863619822847602165e+02}; - std::vector expected_f = { - -3.034045420701179663e-01, 8.405844663871177014e-01, - 7.696947487118485642e-02, 7.662001266663505117e-01, - -1.880601391333554251e-01, -6.183333871091722944e-01, - -5.036172391059643427e-01, -6.529525836149027151e-01, - 5.432962643022043459e-01, 6.382357912332115024e-01, - -1.748518296794561167e-01, 3.457363524891907125e-01, - 1.286482986991941552e-03, 3.757251165286925043e-01, - -5.972588700887541124e-01, -5.987006197104716154e-01, - -2.004450304880958100e-01, 2.495901655353461868e-01}; - std::vector expected_v = { - -2.912234126853306959e-01, -3.800610846612756388e-02, - 2.776624987489437202e-01, -5.053761003913598976e-02, - -3.152373041953385746e-01, 1.060894290092162379e-01, - 2.826389131596073745e-01, 1.039129970665329250e-01, - -2.584378792325942586e-01, -3.121722367954994914e-01, - 8.483275876786681990e-02, 2.524662342344257682e-01, - 4.142176771106586414e-02, -3.820285230785245428e-02, - -2.727311173065460545e-02, 2.668859789777112135e-01, - -6.448243569420382404e-02, -2.121731470426218846e-01, - -8.624335220278558922e-02, -1.809695356746038597e-01, - 1.529875294531883312e-01, -1.283658185172031341e-01, - -1.992682279795223999e-01, 1.409924999632362341e-01, - 1.398322735274434292e-01, 1.804318474574856390e-01, - -1.470309318999652726e-01, -2.593983661598450730e-01, - -4.236536279233147489e-02, 3.386387920184946720e-02, - -4.174017537818433543e-02, -1.003500282164128260e-01, - 1.525690815194478966e-01, 3.398976109910181037e-02, - 1.522253908435125536e-01, -2.349125581341701963e-01, - 9.515545977581392825e-04, -1.643218849228543846e-02, - 1.993234765412972564e-02, 6.027265332209678569e-04, - -9.563256398907417355e-02, 1.510815124001868293e-01, - -7.738094816888557714e-03, 1.502832772532304295e-01, - -2.380965783745832010e-01, -2.309456719810296654e-01, - -6.666961081213038098e-02, 7.955566551234216632e-02, - -8.099093777937517447e-02, -3.386641099800401927e-02, - 4.447884755740908608e-02, 1.008593228579038742e-01, - 4.556718179228393811e-02, -6.078081273849572641e-02}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_TENSORFLOW - GTEST_SKIP() << "Skip because TensorFlow support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot.pbtxt"; - deepmd::convert_pbtxt_to_pb("../../tests/infer/deeppot.pbtxt", - "deeppot.pb"); - - dp.init("deeppot.pb"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { remove("deeppot.pb"); }; -}; - -TYPED_TEST_SUITE(TestInferDeepPotA, ValueTypes); - -TYPED_TEST(TestInferDeepPotA, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotA, cpu_build_nlist_numfv) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - class MyModel : public EnergyModelTest { - deepmd::DeepPot& mydp; - const std::vector atype; - - public: - MyModel(deepmd::DeepPot& dp_, const std::vector& atype_) - : mydp(dp_), atype(atype_) {}; - virtual void compute(double& ener, - std::vector& force, - std::vector& virial, - const std::vector& coord, - const std::vector& box) { - mydp.compute(ener, force, virial, coord, atype, box); - } - }; - MyModel model(dp, atype); - model.test_f(coord, box); - model.test_v(coord, box); - std::vector box_(box); - box_[1] -= 0.4; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[2] += 0.5; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[4] += 0.2; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[3] -= 0.3; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[6] -= 0.7; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[7] += 0.6; - model.test_f(coord, box_); - model.test_v(coord, box_); -} - -TYPED_TEST(TestInferDeepPotA, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotA, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotA, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0); - std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0); - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotA, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotA, cpu_lmp_nlist_type_sel) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotA, cpu_lmp_nlist_type_sel_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0), atomic_energy, - atomic_virial; - dp.compute(ener, force_, virial, atomic_energy, atomic_virial, coord_cpy, - atype_cpy, box, nall - nloc, inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotA, print_summary) { - deepmd::DeepPot& dp = this->dp; - dp.print_summary(""); -} - -template -class TestInferDeepPotANoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e = { - -9.255934839310273787e+01, -1.863253376736990106e+02, - -1.857237299341402945e+02, -9.279308539717486326e+01, - -1.863708105823244239e+02, -1.863635196514972563e+02}; - std::vector expected_f = { - -2.161037360255332107e+00, 9.052994347015581589e-01, - 1.635379623977007979e+00, 2.161037360255332107e+00, - -9.052994347015581589e-01, -1.635379623977007979e+00, - -1.167128117249453811e-02, 1.371975700096064992e-03, - -1.575265180249604477e-03, 6.226508593971802341e-01, - -1.816734122009256991e-01, 3.561766019664774907e-01, - -1.406075393906316626e-02, 3.789140061530929526e-01, - -6.018777878642909140e-01, -5.969188242856223736e-01, - -1.986125696522633155e-01, 2.472764510780630642e-01}; - std::vector expected_v = { - -7.042445481792056761e-01, 2.950213647777754078e-01, - 5.329418202437231633e-01, 2.950213647777752968e-01, - -1.235900311906896754e-01, -2.232594111831812944e-01, - 5.329418202437232743e-01, -2.232594111831813499e-01, - -4.033073234276823849e-01, -8.949230984097404917e-01, - 3.749002169013777030e-01, 6.772391014992630298e-01, - 3.749002169013777586e-01, -1.570527935667933583e-01, - -2.837082722496912512e-01, 6.772391014992631408e-01, - -2.837082722496912512e-01, -5.125052659994422388e-01, - 4.858210330291591605e-02, -6.902596153269104431e-03, - 6.682612642430500391e-03, -5.612247004554610057e-03, - 9.767795567660207592e-04, -9.773758942738038254e-04, - 5.638322117219018645e-03, -9.483806049779926932e-04, - 8.493873281881353637e-04, -2.941738570564985666e-01, - -4.482529909499673171e-02, 4.091569840186781021e-02, - -4.509020615859140463e-02, -1.013919988807244071e-01, - 1.551440772665269030e-01, 4.181857726606644232e-02, - 1.547200233064863484e-01, -2.398213304685777592e-01, - -3.218625798524068354e-02, -1.012438450438508421e-02, - 1.271639330380921855e-02, 3.072814938490859779e-03, - -9.556241797915024372e-02, 1.512251983492413077e-01, - -8.277872384009607454e-03, 1.505412040827929787e-01, - -2.386150620881526407e-01, -2.312295470054945568e-01, - -6.631490213524345034e-02, 7.932427266386249398e-02, - -8.053754366323923053e-02, -3.294595881137418747e-02, - 4.342495071150231922e-02, 1.004599500126941436e-01, - 4.450400364869536163e-02, -5.951077548033092968e-02}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_TENSORFLOW - GTEST_SKIP() << "Skip because TensorFlow support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot.pbtxt"; - deepmd::convert_pbtxt_to_pb(file_name, "deeppot.pb"); - - dp.init("deeppot.pb"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { remove("deeppot.pb"); }; -}; - -TYPED_TEST_SUITE(TestInferDeepPotANoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotANoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_a_fparam_aparam.cc b/source/api_cc/tests/test_deeppot_a_fparam_aparam.cc deleted file mode 100644 index 93efee28fe..0000000000 --- a/source/api_cc/tests/test_deeppot_a_fparam_aparam.cc +++ /dev/null @@ -1,386 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "neighbor_list.h" -#include "test_utils.h" - -template -class TestInferDeepPotAFParamAParam : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 0, 0, 0, 0, 0}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector fparam = {0.25852028}; - std::vector aparam = {0.25852028, 0.25852028, 0.25852028, - 0.25852028, 0.25852028, 0.25852028}; - std::vector expected_e = { - -1.038271183039953804e-01, -7.285433575272914908e-02, - -9.467600174099155552e-02, -1.467050086239614082e-01, - -7.660561620618722145e-02, -7.277295998502930630e-02}; - std::vector expected_f = { - 6.622266817497907132e-02, 5.278739055693523058e-02, - 2.265727495541422845e-02, -2.606047850915838363e-02, - -4.538811686410718776e-02, 1.058247569147072187e-02, - 1.679392490937766935e-01, -2.257828022687320690e-03, - -4.490145670355452645e-02, -1.148364103573685929e-01, - -1.169790466695089237e-02, 6.140402504113953025e-02, - -8.078778132132799494e-02, -5.838878056243369807e-02, - 6.773639989682191109e-02, -1.247724708090079161e-02, - 6.494523955924384750e-02, -1.174787188812918687e-01}; - std::vector expected_v = { - -1.589185553287162656e-01, 2.586163333170100279e-03, - -1.575127933809472624e-04, -1.855360380105876630e-02, - 1.949822090859933826e-02, -1.006552056166355388e-02, - 3.177029853276916449e-02, 1.714349636720383010e-03, - -1.290389175187874483e-03, -8.553510339477603253e-02, - -5.654637257232508415e-03, -1.286954833787038420e-02, - 2.464156457499515687e-02, -2.398202886026797043e-02, - -1.957110465239037672e-02, 2.233492928605742764e-02, - 6.107843207824020099e-03, 1.707078295947736047e-03, - -1.653994088976195043e-01, 3.894358678172111371e-02, - -2.169595969759342477e-02, 6.819704294738503786e-03, - -5.018242039618424008e-03, 2.640664428663210429e-03, - -1.985298275686078057e-03, -3.638421609610945767e-02, - 2.342932331075030239e-02, -8.501331914753691710e-02, - -2.181253413538992297e-03, 4.311300069651782287e-03, - -1.910329328333908129e-03, -1.808810159508548836e-03, - -1.540075281450827612e-03, -1.173703213175551763e-02, - -2.596306629910121507e-03, 6.705025662372287101e-03, - -9.038455005073858795e-02, 3.011717773578577451e-02, - -5.083054073419784880e-02, -2.951210292616929069e-03, - 2.342445652898489383e-02, -4.091207474993674431e-02, - -1.648470649301832236e-02, -2.872261885460645689e-02, - 4.763924972552112391e-02, -8.300036532764677732e-02, - 1.020429228955421243e-03, -1.026734151199098881e-03, - 5.678534096113684732e-02, 1.273635718045938205e-02, - -1.530143225195957322e-02, -1.061671865629566225e-01, - -2.486859433265622629e-02, 2.875323131744185121e-02}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_TENSORFLOW - GTEST_SKIP() << "Skip because TensorFlow support is not enabled."; -#endif - std::string file_name = "../../tests/infer/fparam_aparam.pbtxt"; - deepmd::convert_pbtxt_to_pb(file_name, "fparam_aparam.pb"); - - dp.init("fparam_aparam.pb"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { remove("fparam_aparam.pb"); }; -}; - -TYPED_TEST_SUITE(TestInferDeepPotAFParamAParam, ValueTypes); - -TYPED_TEST(TestInferDeepPotAFParamAParam, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box, fparam, aparam); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParam, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box, - fparam, aparam); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParam, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0, fparam, aparam); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParam, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0); - std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0); - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 1, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParam, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0, fparam, aparam); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_a_fparam_aparam_pt.cc b/source/api_cc/tests/test_deeppot_a_fparam_aparam_pt.cc deleted file mode 100644 index 442a2c1b6d..0000000000 --- a/source/api_cc/tests/test_deeppot_a_fparam_aparam_pt.cc +++ /dev/null @@ -1,359 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -// 1e-10 cannot pass; unclear bug or not -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-7 : 1e-4) - -namespace { -constexpr const char* kRefPath = "../../tests/infer/fparam_aparam.expected"; -constexpr const char* kModelPath = "../../tests/infer/fparam_aparam.pth"; -} // namespace - -template -class TestInferDeepPotAFParamAParamPt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 0, 0, 0, 0, 0}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector fparam = {0.25852028}; - std::vector aparam = {0.25852028, 0.25852028, 0.25852028, - 0.25852028, 0.25852028, 0.25852028}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("default", "expected_e"); - expected_f = ref.get("default", "expected_f"); - expected_v = ref.get("default", "expected_v"); - - dp.init(kModelPath); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotAFParamAParamPt, ValueTypes); - -TYPED_TEST(TestInferDeepPotAFParamAParamPt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box, fparam, aparam); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParamPt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box, - fparam, aparam); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParamPt, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0, fparam, aparam); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParamPt, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0); - std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0); - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 1, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParamPt, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0, fparam, aparam); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_a_fparam_aparam_ptexpt.cc b/source/api_cc/tests/test_deeppot_a_fparam_aparam_ptexpt.cc deleted file mode 100644 index 8b07cbd90e..0000000000 --- a/source/api_cc/tests/test_deeppot_a_fparam_aparam_ptexpt.cc +++ /dev/null @@ -1,341 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C++ inference for pt_expt (.pt2) backend with fparam and aparam. -// Uses a model created with type_one_side=True (required for make_fx tracing). -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "DeepPotPTExpt.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -// 1e-10 cannot pass; unclear bug or not -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-7 : 1e-4) - -namespace { -constexpr const char* kRefPath = "../../tests/infer/fparam_aparam.expected"; -constexpr const char* kModelPath = "../../tests/infer/fparam_aparam.pt2"; -} // namespace - -template -class TestInferDeepPotAFParamAParamPtExpt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 0, 0, 0, 0, 0}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector fparam = {0.25852028}; - std::vector aparam = {0.25852028, 0.25852028, 0.25852028, - 0.25852028, 0.25852028, 0.25852028}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("default", "expected_e"); - expected_f = ref.get("default", "expected_f"); - expected_v = ref.get("default", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotAFParamAParamPtExpt::dp; - -TYPED_TEST_SUITE(TestInferDeepPotAFParamAParamPtExpt, ValueTypes); - -TYPED_TEST(TestInferDeepPotAFParamAParamPtExpt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box, fparam, aparam); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParamPtExpt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box, - fparam, aparam); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParamPtExpt, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0, fparam, aparam); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAFParamAParamPtExpt, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0); - std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0); - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 1, fparam, aparam); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -// Test that a .pt2 model without default_fparam reports false -template -class TestInferDeepPotNoDefaultFParamPtExpt : public ::testing::Test { - protected: - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init("../../tests/infer/fparam_aparam.pt2"); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotNoDefaultFParamPtExpt::dp; - -TYPED_TEST_SUITE(TestInferDeepPotNoDefaultFParamPtExpt, ValueTypes); - -TYPED_TEST(TestInferDeepPotNoDefaultFParamPtExpt, no_default_fparam) { - using VALUETYPE = TypeParam; - deepmd::DeepPot& dp = this->dp; - EXPECT_EQ(dp.dim_fparam(), 1); - EXPECT_FALSE(dp.has_default_fparam()); -} -// DefaultFParam tests with expected values are in -// test_deeppot_default_fparam_ptexpt.cc (from upstream #5343). diff --git a/source/api_cc/tests/test_deeppot_a_nframes.cc b/source/api_cc/tests/test_deeppot_a_nframes.cc deleted file mode 100644 index 1e7c160437..0000000000 --- a/source/api_cc/tests/test_deeppot_a_nframes.cc +++ /dev/null @@ -1,792 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "neighbor_list.h" -#include "test_utils.h" - -template -class TestInferDeepPotANFrames : public ::testing::Test { - protected: - std::vector coord = { - 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56, - 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13., - 13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e = { - -9.275780747115504710e+01, -1.863501786584258468e+02, - -1.863392472863538103e+02, -9.279281325486221021e+01, - -1.863671545232153903e+02, -1.863619822847602165e+02, - -9.275780747115504710e+01, -1.863501786584258468e+02, - -1.863392472863538103e+02, -9.279281325486221021e+01, - -1.863671545232153903e+02, -1.863619822847602165e+02}; - std::vector expected_f = { - -3.034045420701179663e-01, 8.405844663871177014e-01, - 7.696947487118485642e-02, 7.662001266663505117e-01, - -1.880601391333554251e-01, -6.183333871091722944e-01, - -5.036172391059643427e-01, -6.529525836149027151e-01, - 5.432962643022043459e-01, 6.382357912332115024e-01, - -1.748518296794561167e-01, 3.457363524891907125e-01, - 1.286482986991941552e-03, 3.757251165286925043e-01, - -5.972588700887541124e-01, -5.987006197104716154e-01, - -2.004450304880958100e-01, 2.495901655353461868e-01, - -3.034045420701179663e-01, 8.405844663871177014e-01, - 7.696947487118485642e-02, 7.662001266663505117e-01, - -1.880601391333554251e-01, -6.183333871091722944e-01, - -5.036172391059643427e-01, -6.529525836149027151e-01, - 5.432962643022043459e-01, 6.382357912332115024e-01, - -1.748518296794561167e-01, 3.457363524891907125e-01, - 1.286482986991941552e-03, 3.757251165286925043e-01, - -5.972588700887541124e-01, -5.987006197104716154e-01, - -2.004450304880958100e-01, 2.495901655353461868e-01}; - std::vector expected_v = { - -2.912234126853306959e-01, -3.800610846612756388e-02, - 2.776624987489437202e-01, -5.053761003913598976e-02, - -3.152373041953385746e-01, 1.060894290092162379e-01, - 2.826389131596073745e-01, 1.039129970665329250e-01, - -2.584378792325942586e-01, -3.121722367954994914e-01, - 8.483275876786681990e-02, 2.524662342344257682e-01, - 4.142176771106586414e-02, -3.820285230785245428e-02, - -2.727311173065460545e-02, 2.668859789777112135e-01, - -6.448243569420382404e-02, -2.121731470426218846e-01, - -8.624335220278558922e-02, -1.809695356746038597e-01, - 1.529875294531883312e-01, -1.283658185172031341e-01, - -1.992682279795223999e-01, 1.409924999632362341e-01, - 1.398322735274434292e-01, 1.804318474574856390e-01, - -1.470309318999652726e-01, -2.593983661598450730e-01, - -4.236536279233147489e-02, 3.386387920184946720e-02, - -4.174017537818433543e-02, -1.003500282164128260e-01, - 1.525690815194478966e-01, 3.398976109910181037e-02, - 1.522253908435125536e-01, -2.349125581341701963e-01, - 9.515545977581392825e-04, -1.643218849228543846e-02, - 1.993234765412972564e-02, 6.027265332209678569e-04, - -9.563256398907417355e-02, 1.510815124001868293e-01, - -7.738094816888557714e-03, 1.502832772532304295e-01, - -2.380965783745832010e-01, -2.309456719810296654e-01, - -6.666961081213038098e-02, 7.955566551234216632e-02, - -8.099093777937517447e-02, -3.386641099800401927e-02, - 4.447884755740908608e-02, 1.008593228579038742e-01, - 4.556718179228393811e-02, -6.078081273849572641e-02, - -2.912234126853306959e-01, -3.800610846612756388e-02, - 2.776624987489437202e-01, -5.053761003913598976e-02, - -3.152373041953385746e-01, 1.060894290092162379e-01, - 2.826389131596073745e-01, 1.039129970665329250e-01, - -2.584378792325942586e-01, -3.121722367954994914e-01, - 8.483275876786681990e-02, 2.524662342344257682e-01, - 4.142176771106586414e-02, -3.820285230785245428e-02, - -2.727311173065460545e-02, 2.668859789777112135e-01, - -6.448243569420382404e-02, -2.121731470426218846e-01, - -8.624335220278558922e-02, -1.809695356746038597e-01, - 1.529875294531883312e-01, -1.283658185172031341e-01, - -1.992682279795223999e-01, 1.409924999632362341e-01, - 1.398322735274434292e-01, 1.804318474574856390e-01, - -1.470309318999652726e-01, -2.593983661598450730e-01, - -4.236536279233147489e-02, 3.386387920184946720e-02, - -4.174017537818433543e-02, -1.003500282164128260e-01, - 1.525690815194478966e-01, 3.398976109910181037e-02, - 1.522253908435125536e-01, -2.349125581341701963e-01, - 9.515545977581392825e-04, -1.643218849228543846e-02, - 1.993234765412972564e-02, 6.027265332209678569e-04, - -9.563256398907417355e-02, 1.510815124001868293e-01, - -7.738094816888557714e-03, 1.502832772532304295e-01, - -2.380965783745832010e-01, -2.309456719810296654e-01, - -6.666961081213038098e-02, 7.955566551234216632e-02, - -8.099093777937517447e-02, -3.386641099800401927e-02, - 4.447884755740908608e-02, 1.008593228579038742e-01, - 4.556718179228393811e-02, -6.078081273849572641e-02}; - int natoms; - int nframes = 2; - std::vector expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_TENSORFLOW - GTEST_SKIP() << "Skip because TensorFlow support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot.pbtxt"; - deepmd::convert_pbtxt_to_pb("../../tests/infer/deeppot.pbtxt", - "deeppot.pb"); - - dp.init("deeppot.pb"); - - natoms = expected_e.size() / nframes; - EXPECT_EQ(nframes * natoms * 3, expected_f.size()); - EXPECT_EQ(nframes * natoms * 9, expected_v.size()); - expected_tot_e.resize(nframes); - expected_tot_v.resize(static_cast(nframes) * 9); - std::fill(expected_tot_e.begin(), expected_tot_e.end(), 0.); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int kk = 0; kk < nframes; ++kk) { - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e[kk] += expected_e[kk * natoms + ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[kk * 9 + dd] += - expected_v[kk * natoms * 9 + ii * 9 + dd]; - } - } - } - }; - - void TearDown() override { remove("deeppot.pb"); }; -}; - -TYPED_TEST_SUITE(TestInferDeepPotANFrames, ValueTypes); - -TYPED_TEST(TestInferDeepPotANFrames, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - int& nframes = this->nframes; - std::vector& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - std::vector ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotANFrames, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - int& nframes = this->nframes; - std::vector& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - std::vector ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - EXPECT_EQ(atom_ener.size(), nframes * natoms); - EXPECT_EQ(atom_vir.size(), nframes * natoms * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotANFrames, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - int& nframes = this->nframes; - std::vector& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - std::vector coord_first(coord.begin(), coord.begin() + 3 * natoms); - std::vector box_first(box.begin(), box.begin() + 9); - int nloc = coord_first.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, - coord_first, atype, box_first, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - std::vector coord_cpy2(nframes * nall * 3); - for (int ii = 0; ii < nframes; ++ii) { - for (int jj = 0; jj < nall * 3; ++jj) { - coord_cpy2[ii * nall * 3 + jj] = coord_cpy[jj]; - } - } - - std::vector ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy2, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3, nframes); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - std::fill(ener.begin(), ener.end(), 0.0); - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy2, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3, nframes); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotANFrames, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - int& nframes = this->nframes; - std::vector& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - std::vector coord_first(coord.begin(), coord.begin() + 3 * natoms); - std::vector box_first(box.begin(), box.begin() + 9); - int nloc = coord_first.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, - coord_first, atype, box_first, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - std::vector coord_cpy2(nframes * nall * 3); - for (int ii = 0; ii < nframes; ++ii) { - for (int jj = 0; jj < nall * 3; ++jj) { - coord_cpy2[ii * nall * 3 + jj] = coord_cpy[jj]; - } - } - - std::vector ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy2, atype_cpy, - box, nall - nloc, inlist, 0); - _fold_back(force, force_, mapping, nloc, nall, 3, nframes); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1, nframes); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9, nframes); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - EXPECT_EQ(atom_ener.size(), nframes * natoms); - EXPECT_EQ(atom_vir.size(), nframes * natoms * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } - - std::fill(ener.begin(), ener.end(), 0.0); - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0); - std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0); - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy2, atype_cpy, - box, nall - nloc, inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3, nframes); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1, nframes); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9, nframes); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - EXPECT_EQ(atom_ener.size(), nframes * natoms); - EXPECT_EQ(atom_vir.size(), nframes * natoms * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotANFrames, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - int& nframes = this->nframes; - std::vector& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - std::vector coord_first(coord.begin(), coord.begin() + 3 * natoms); - std::vector box_first(box.begin(), box.begin() + 9); - int nloc = coord_first.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, - coord_first, atype, box_first, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - std::vector coord_cpy2(nframes * nall * 3); - for (int ii = 0; ii < nframes; ++ii) { - for (int jj = 0; jj < nall * 3; ++jj) { - coord_cpy2[ii * nall * 3 + jj] = coord_cpy[jj]; - } - } - - std::vector ener; - std::vector force_(nall * 3, 0.0), virial(nframes * 9, 0.0); - dp.compute(ener, force_, virial, coord_cpy2, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3, nframes); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - std::fill(ener.begin(), ener.end(), 0.0); - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy2, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3, nframes); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotANFrames, cpu_lmp_nlist_type_sel) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - int& nframes = this->nframes; - std::vector& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - // two frames - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - expected_f.insert(expected_f.begin() + natoms * 3, expected_f_vir.begin(), - expected_f_vir.end()); - std::vector coord_first(coord.begin(), coord.begin() + 3 * natoms); - std::vector box_first(box.begin(), box.begin() + 9); - - // build nlist - int nloc = coord_first.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, - coord_first, atype, box_first, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - std::vector coord_cpy2(nframes * nall * 3); - for (int ii = 0; ii < nframes; ++ii) { - for (int jj = 0; jj < nall * 3; ++jj) { - coord_cpy2[ii * nall * 3 + jj] = coord_cpy[jj]; - } - } - - // dp compute - std::vector ener; - std::vector force_(nall * 3, 0.0), virial(nframes * 9, 0.0); - dp.compute(ener, force_, virial, coord_cpy2, atype_cpy, box, nall - nloc, - inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3, nframes); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotANFrames, cpu_lmp_nlist_type_sel_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - int& nframes = this->nframes; - std::vector& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - // two frames - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - expected_f.insert(expected_f.begin() + natoms * 3, expected_f_vir.begin(), - expected_f_vir.end()); - std::vector coord_first(coord.begin(), coord.begin() + 3 * natoms); - std::vector box_first(box.begin(), box.begin() + 9); - - // build nlist - int nloc = coord_first.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, - coord_first, atype, box_first, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - std::vector coord_cpy2(nframes * nall * 3); - for (int ii = 0; ii < nframes; ++ii) { - for (int jj = 0; jj < nall * 3; ++jj) { - coord_cpy2[ii * nall * 3 + jj] = coord_cpy[jj]; - } - } - - // dp compute - std::vector ener; - std::vector force_(nall * 3, 0.0), virial(nframes * 9, 0.0), - atomic_energy, atomic_virial; - dp.compute(ener, force_, virial, atomic_energy, atomic_virial, coord_cpy2, - atype_cpy, box, nall - nloc, inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3, nframes); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -template -class TestInferDeepPotANFramesNoPbc : public ::testing::Test { - protected: - std::vector coord = { - 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56, - 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, - 3.36, 3.00, 1.81, 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e = { - -9.255934839310273787e+01, -1.863253376736990106e+02, - -1.857237299341402945e+02, -9.279308539717486326e+01, - -1.863708105823244239e+02, -1.863635196514972563e+02, - -9.255934839310273787e+01, -1.863253376736990106e+02, - -1.857237299341402945e+02, -9.279308539717486326e+01, - -1.863708105823244239e+02, -1.863635196514972563e+02}; - std::vector expected_f = { - -2.161037360255332107e+00, 9.052994347015581589e-01, - 1.635379623977007979e+00, 2.161037360255332107e+00, - -9.052994347015581589e-01, -1.635379623977007979e+00, - -1.167128117249453811e-02, 1.371975700096064992e-03, - -1.575265180249604477e-03, 6.226508593971802341e-01, - -1.816734122009256991e-01, 3.561766019664774907e-01, - -1.406075393906316626e-02, 3.789140061530929526e-01, - -6.018777878642909140e-01, -5.969188242856223736e-01, - -1.986125696522633155e-01, 2.472764510780630642e-01, - -2.161037360255332107e+00, 9.052994347015581589e-01, - 1.635379623977007979e+00, 2.161037360255332107e+00, - -9.052994347015581589e-01, -1.635379623977007979e+00, - -1.167128117249453811e-02, 1.371975700096064992e-03, - -1.575265180249604477e-03, 6.226508593971802341e-01, - -1.816734122009256991e-01, 3.561766019664774907e-01, - -1.406075393906316626e-02, 3.789140061530929526e-01, - -6.018777878642909140e-01, -5.969188242856223736e-01, - -1.986125696522633155e-01, 2.472764510780630642e-01}; - std::vector expected_v = { - -7.042445481792056761e-01, 2.950213647777754078e-01, - 5.329418202437231633e-01, 2.950213647777752968e-01, - -1.235900311906896754e-01, -2.232594111831812944e-01, - 5.329418202437232743e-01, -2.232594111831813499e-01, - -4.033073234276823849e-01, -8.949230984097404917e-01, - 3.749002169013777030e-01, 6.772391014992630298e-01, - 3.749002169013777586e-01, -1.570527935667933583e-01, - -2.837082722496912512e-01, 6.772391014992631408e-01, - -2.837082722496912512e-01, -5.125052659994422388e-01, - 4.858210330291591605e-02, -6.902596153269104431e-03, - 6.682612642430500391e-03, -5.612247004554610057e-03, - 9.767795567660207592e-04, -9.773758942738038254e-04, - 5.638322117219018645e-03, -9.483806049779926932e-04, - 8.493873281881353637e-04, -2.941738570564985666e-01, - -4.482529909499673171e-02, 4.091569840186781021e-02, - -4.509020615859140463e-02, -1.013919988807244071e-01, - 1.551440772665269030e-01, 4.181857726606644232e-02, - 1.547200233064863484e-01, -2.398213304685777592e-01, - -3.218625798524068354e-02, -1.012438450438508421e-02, - 1.271639330380921855e-02, 3.072814938490859779e-03, - -9.556241797915024372e-02, 1.512251983492413077e-01, - -8.277872384009607454e-03, 1.505412040827929787e-01, - -2.386150620881526407e-01, -2.312295470054945568e-01, - -6.631490213524345034e-02, 7.932427266386249398e-02, - -8.053754366323923053e-02, -3.294595881137418747e-02, - 4.342495071150231922e-02, 1.004599500126941436e-01, - 4.450400364869536163e-02, -5.951077548033092968e-02, - -7.042445481792056761e-01, 2.950213647777754078e-01, - 5.329418202437231633e-01, 2.950213647777752968e-01, - -1.235900311906896754e-01, -2.232594111831812944e-01, - 5.329418202437232743e-01, -2.232594111831813499e-01, - -4.033073234276823849e-01, -8.949230984097404917e-01, - 3.749002169013777030e-01, 6.772391014992630298e-01, - 3.749002169013777586e-01, -1.570527935667933583e-01, - -2.837082722496912512e-01, 6.772391014992631408e-01, - -2.837082722496912512e-01, -5.125052659994422388e-01, - 4.858210330291591605e-02, -6.902596153269104431e-03, - 6.682612642430500391e-03, -5.612247004554610057e-03, - 9.767795567660207592e-04, -9.773758942738038254e-04, - 5.638322117219018645e-03, -9.483806049779926932e-04, - 8.493873281881353637e-04, -2.941738570564985666e-01, - -4.482529909499673171e-02, 4.091569840186781021e-02, - -4.509020615859140463e-02, -1.013919988807244071e-01, - 1.551440772665269030e-01, 4.181857726606644232e-02, - 1.547200233064863484e-01, -2.398213304685777592e-01, - -3.218625798524068354e-02, -1.012438450438508421e-02, - 1.271639330380921855e-02, 3.072814938490859779e-03, - -9.556241797915024372e-02, 1.512251983492413077e-01, - -8.277872384009607454e-03, 1.505412040827929787e-01, - -2.386150620881526407e-01, -2.312295470054945568e-01, - -6.631490213524345034e-02, 7.932427266386249398e-02, - -8.053754366323923053e-02, -3.294595881137418747e-02, - 4.342495071150231922e-02, 1.004599500126941436e-01, - 4.450400364869536163e-02, -5.951077548033092968e-02}; - int natoms; - int nframes = 2; - std::vector expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_TENSORFLOW - GTEST_SKIP() << "Skip because TensorFlow support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot.pbtxt"; - deepmd::convert_pbtxt_to_pb(file_name, "deeppot.pb"); - - dp.init("deeppot.pb"); - - natoms = expected_e.size() / nframes; - EXPECT_EQ(nframes * natoms * 3, expected_f.size()); - EXPECT_EQ(nframes * natoms * 9, expected_v.size()); - expected_tot_e.resize(nframes); - expected_tot_v.resize(static_cast(nframes) * 9); - std::fill(expected_tot_e.begin(), expected_tot_e.end(), 0.); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int kk = 0; kk < nframes; ++kk) { - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e[kk] += expected_e[kk * natoms + ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[kk * 9 + dd] += - expected_v[kk * natoms * 9 + ii * 9 + dd]; - } - } - } - }; - - void TearDown() override { remove("deeppot.pb"); }; -}; - -TYPED_TEST_SUITE(TestInferDeepPotANFramesNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotANFramesNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - int& nframes = this->nframes; - std::vector& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - std::vector ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(ener.size(), nframes); - EXPECT_EQ(force.size(), nframes * natoms * 3); - EXPECT_EQ(virial.size(), nframes * 9); - - for (int ii = 0; ii < nframes; ++ii) { - EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < nframes * 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_default_fparam_pt.cc b/source/api_cc/tests/test_deeppot_default_fparam_pt.cc deleted file mode 100644 index fb83151ef5..0000000000 --- a/source/api_cc/tests/test_deeppot_default_fparam_pt.cc +++ /dev/null @@ -1,217 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -// 1e-10 cannot pass; unclear bug or not -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-7 : 1e-4) - -namespace { -constexpr const char* kRefPath = - "../../tests/infer/fparam_aparam_default.expected"; -constexpr const char* kModelPath = - "../../tests/infer/fparam_aparam_default.pth"; -} // namespace - -template -class TestInferDeepPotDefaultFParamPt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 0, 0, 0, 0, 0}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - // aparam is still provided explicitly - std::vector aparam = {0.25852028, 0.25852028, 0.25852028, - 0.25852028, 0.25852028, 0.25852028}; - // explicit fparam for backward compat test - std::vector fparam = {0.25852028}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("default", "expected_e"); - expected_f = ref.get("default", "expected_f"); - expected_v = ref.get("default", "expected_v"); - - dp.init(kModelPath); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotDefaultFParamPt, ValueTypes); - -TYPED_TEST(TestInferDeepPotDefaultFParamPt, attrs) { - using VALUETYPE = TypeParam; - deepmd::DeepPot& dp = this->dp; - EXPECT_EQ(dp.dim_fparam(), 1); - EXPECT_EQ(dp.dim_aparam(), 1); - EXPECT_TRUE(dp.has_default_fparam()); -} - -TYPED_TEST(TestInferDeepPotDefaultFParamPt, cpu_build_nlist_empty_fparam) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - // Empty fparam — model should use default - std::vector empty_fparam; - dp.compute(ener, force, virial, coord, atype, box, empty_fparam, aparam); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDefaultFParamPt, cpu_build_nlist_explicit_fparam) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - // Explicit fparam — backward compat - dp.compute(ener, force, virial, coord, atype, box, fparam, aparam); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDefaultFParamPt, cpu_lmp_nlist_empty_fparam) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& aparam = this->aparam; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - std::vector empty_fparam; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0, empty_fparam, aparam); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -// Test that a model without default_fparam reports false -template -class TestInferDeepPotNoDefaultFParamPt : public ::testing::Test { - protected: - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - dp.init("../../tests/infer/fparam_aparam.pth"); - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotNoDefaultFParamPt, ValueTypes); - -TYPED_TEST(TestInferDeepPotNoDefaultFParamPt, no_default_fparam) { - using VALUETYPE = TypeParam; - deepmd::DeepPot& dp = this->dp; - EXPECT_EQ(dp.dim_fparam(), 1); - EXPECT_FALSE(dp.has_default_fparam()); -} diff --git a/source/api_cc/tests/test_deeppot_default_fparam_ptexpt.cc b/source/api_cc/tests/test_deeppot_default_fparam_ptexpt.cc deleted file mode 100644 index 72ac55c2c3..0000000000 --- a/source/api_cc/tests/test_deeppot_default_fparam_ptexpt.cc +++ /dev/null @@ -1,203 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C++ inference for pt_expt (.pt2) backend with default_fparam. -// Uses fparam_aparam_default.pt2: has_default_fparam=true, -// default=[0.25852028]. -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "DeepPotPTExpt.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -// 1e-10 cannot pass; unclear bug or not -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-7 : 1e-4) - -namespace { -constexpr const char* kRefPath = - "../../tests/infer/fparam_aparam_default.expected"; -constexpr const char* kModelPath = - "../../tests/infer/fparam_aparam_default.pt2"; -} // namespace - -template -class TestInferDeepPotDefaultFParamPtExpt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 0, 0, 0, 0, 0}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - // aparam is still provided explicitly - std::vector aparam = {0.25852028, 0.25852028, 0.25852028, - 0.25852028, 0.25852028, 0.25852028}; - // explicit fparam for backward compat test - std::vector fparam = {0.25852028}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("default", "expected_e"); - expected_f = ref.get("default", "expected_f"); - expected_v = ref.get("default", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDefaultFParamPtExpt::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDefaultFParamPtExpt, ValueTypes); - -TYPED_TEST(TestInferDeepPotDefaultFParamPtExpt, attrs) { - using VALUETYPE = TypeParam; - deepmd::DeepPot& dp = this->dp; - EXPECT_EQ(dp.dim_fparam(), 1); - EXPECT_EQ(dp.dim_aparam(), 1); - EXPECT_TRUE(dp.has_default_fparam()); -} - -TYPED_TEST(TestInferDeepPotDefaultFParamPtExpt, cpu_build_nlist_empty_fparam) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - // Empty fparam — model should use default - std::vector empty_fparam; - dp.compute(ener, force, virial, coord, atype, box, empty_fparam, aparam); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDefaultFParamPtExpt, - cpu_build_nlist_explicit_fparam) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& fparam = this->fparam; - std::vector& aparam = this->aparam; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - // Explicit fparam — backward compat - dp.compute(ener, force, virial, coord, atype, box, fparam, aparam); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDefaultFParamPtExpt, cpu_lmp_nlist_empty_fparam) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& aparam = this->aparam; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - std::vector empty_fparam; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0, empty_fparam, aparam); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_jax.cc b/source/api_cc/tests/test_deeppot_jax.cc deleted file mode 100644 index 80ddf00860..0000000000 --- a/source/api_cc/tests/test_deeppot_jax.cc +++ /dev/null @@ -1,557 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "neighbor_list.h" -#include "test_utils.h" - -template -class TestInferDeepPotAJAX : public ::testing::Test { - protected: - // import numpy as np - // from deepmd.infer import DeepPot - // coord = np.array([ - // 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - // 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - // 3.51, 2.51, 2.60, 4.27, 3.22, 1.56 - // ]).reshape(1, -1) - // atype = np.array([0, 1, 1, 0, 1, 1]) - // box = np.array([13., 0., 0., 0., 13., 0., 0., 0., 13.]).reshape(1, -1) - // dp = DeepPot("deeppot_sea.savedmodel") - // e, f, v, ae, av = dp.eval(coord, box, atype, atomic=True) - // np.set_printoptions(precision=16) - // print(f"{e.ravel()=} {v.ravel()=} {f.ravel()=} {ae.ravel()=} - // {av.ravel()=}") - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - // the data in this file is just copied from PT - std::vector expected_e = { - - -93.016873944029, -185.923296645958, -185.927096544970, - -93.019371018039, -185.926179995548, -185.924351901852}; - std::vector expected_f = { - - 0.006277522211, -0.001117962774, 0.000618580445, 0.009928999655, - 0.003026035654, -0.006941982227, 0.000667853212, -0.002449963843, - 0.006506463508, -0.007284129115, 0.000530662205, -0.000028806821, - 0.000068097781, 0.006121331983, -0.009019754602, -0.009658343745, - -0.006110103225, 0.008865499697}; - std::vector expected_v = { - -0.000155238009, 0.000116605516, -0.007869862476, 0.000465578340, - 0.008182547185, -0.002398713212, -0.008112887338, -0.002423738425, - 0.007210716605, -0.019203504012, 0.001724938709, 0.009909211091, - 0.001153857542, -0.001600015103, -0.000560024090, 0.010727836276, - -0.001034836404, -0.007973454377, -0.021517399106, -0.004064359664, - 0.004866398692, -0.003360038617, -0.007241406162, 0.005920941051, - 0.004899151657, 0.006290788591, -0.006478820311, 0.001921504710, - 0.001313470921, -0.000304091236, 0.001684345981, 0.004124109256, - -0.006396084465, -0.000701095618, -0.006356507032, 0.009818550859, - -0.015230664587, -0.000110244376, 0.000690319396, 0.000045953023, - -0.005726548770, 0.008769818495, -0.000572380210, 0.008860603423, - -0.013819348050, -0.021227082558, -0.004977781343, 0.006646239696, - -0.005987066507, -0.002767831232, 0.003746502525, 0.007697590397, - 0.003746130152, -0.005172634748}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_JAX - GTEST_SKIP() << "Skip because JAX support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot_sea.savedmodel"; - - dp.init(file_name); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - } - - void TearDown() override {} -}; - -TYPED_TEST_SUITE(TestInferDeepPotAJAX, ValueTypes); - -TYPED_TEST(TestInferDeepPotAJAX, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAJAX, cpu_build_nlist_numfv) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - class MyModel : public EnergyModelTest { - deepmd::DeepPot& mydp; - const std::vector atype; - - public: - MyModel(deepmd::DeepPot& dp_, const std::vector& atype_) - : mydp(dp_), atype(atype_) {}; - virtual void compute(double& ener, - std::vector& force, - std::vector& virial, - const std::vector& coord, - const std::vector& box) { - mydp.compute(ener, force, virial, coord, atype, box); - } - }; - MyModel model(dp, atype); - model.test_f(coord, box); - model.test_v(coord, box); - std::vector box_(box); - box_[1] -= 0.4; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[2] += 0.5; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[4] += 0.2; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[3] -= 0.3; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[6] -= 0.7; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[7] += 0.6; - model.test_f(coord, box_); - model.test_v(coord, box_); -} - -TYPED_TEST(TestInferDeepPotAJAX, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAJAX, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAJAX, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0); - std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0); - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAJAX, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAJAX, cpu_lmp_nlist_type_sel) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAJAX, cpu_lmp_nlist_type_sel_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0), atomic_energy, - atomic_virial; - dp.compute(ener, force_, virial, atomic_energy, atomic_virial, coord_cpy, - atype_cpy, box, nall - nloc, inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAJAX, print_summary) { - deepmd::DeepPot& dp = this->dp; - dp.print_summary(""); -} - -TYPED_TEST(TestInferDeepPotAJAX, get_type_map) { - deepmd::DeepPot& dp = this->dp; - std::string type_map; - dp.get_type_map(type_map); - EXPECT_EQ(type_map, "O H"); -} diff --git a/source/api_cc/tests/test_deeppot_pd.cc b/source/api_cc/tests/test_deeppot_pd.cc deleted file mode 100644 index bede9b11aa..0000000000 --- a/source/api_cc/tests/test_deeppot_pd.cc +++ /dev/null @@ -1,648 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include "DeepPot.h" -#include "neighbor_list.h" -#include "test_utils.h" - -#ifdef EPSILON -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-7 : 1e-4) -#endif - -typedef testing::Types PDValueTypes; - -template -class TestInferDeepPotAPd : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e = { - - -93.016873944029, -185.923296645958, -185.927096544970, - -93.019371018039, -185.926179995548, -185.924351901852}; - std::vector expected_f = { - - 0.006277522211, -0.001117962774, 0.000618580445, 0.009928999655, - 0.003026035654, -0.006941982227, 0.000667853212, -0.002449963843, - 0.006506463508, -0.007284129115, 0.000530662205, -0.000028806821, - 0.000068097781, 0.006121331983, -0.009019754602, -0.009658343745, - -0.006110103225, 0.008865499697}; - std::vector expected_v = { - -0.000155238009, 0.000116605516, -0.007869862476, 0.000465578340, - 0.008182547185, -0.002398713212, -0.008112887338, -0.002423738425, - 0.007210716605, -0.019203504012, 0.001724938709, 0.009909211091, - 0.001153857542, -0.001600015103, -0.000560024090, 0.010727836276, - -0.001034836404, -0.007973454377, -0.021517399106, -0.004064359664, - 0.004866398692, -0.003360038617, -0.007241406162, 0.005920941051, - 0.004899151657, 0.006290788591, -0.006478820311, 0.001921504710, - 0.001313470921, -0.000304091236, 0.001684345981, 0.004124109256, - -0.006396084465, -0.000701095618, -0.006356507032, 0.009818550859, - -0.015230664587, -0.000110244376, 0.000690319396, 0.000045953023, - -0.005726548770, 0.008769818495, -0.000572380210, 0.008860603423, - -0.013819348050, -0.021227082558, -0.004977781343, 0.006646239696, - -0.005987066507, -0.002767831232, 0.003746502525, 0.007697590397, - 0.003746130152, -0.005172634748}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PADDLE - GTEST_SKIP() << "Skip because Paddle support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot_sea.json"; - - dp.init(file_name); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotAPd, PDValueTypes); - -TYPED_TEST(TestInferDeepPotAPd, type_map) { - std::string type_map = "stale"; - this->dp.get_type_map(type_map); - EXPECT_EQ(type_map, "O H"); -} - -TYPED_TEST(TestInferDeepPotAPd, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPd, cpu_build_nlist_numfv) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - class MyModel : public EnergyModelTest { - deepmd::DeepPot& mydp; - const std::vector atype; - - public: - MyModel(deepmd::DeepPot& dp_, const std::vector& atype_) - : mydp(dp_), atype(atype_) {}; - virtual void compute(double& ener, - std::vector& force, - std::vector& virial, - const std::vector& coord, - const std::vector& box) { - mydp.compute(ener, force, virial, coord, atype, box); - } - }; - MyModel model(dp, atype); - model.test_f(coord, box); - model.test_v(coord, box); - std::vector box_(box); - box_[1] -= 0.4; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[2] += 0.5; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[4] += 0.2; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[3] -= 0.3; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[6] -= 0.7; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[7] += 0.6; - model.test_f(coord, box_); - model.test_v(coord, box_); -} - -TYPED_TEST(TestInferDeepPotAPd, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPd, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPd, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0); - std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0); - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPd, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPd, cpu_lmp_nlist_type_sel) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPd, cpu_lmp_nlist_type_sel_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0), atomic_energy, - atomic_virial; - dp.compute(ener, force_, virial, atomic_energy, atomic_virial, coord_cpy, - atype_cpy, box, nall - nloc, inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPd, print_summary) { - deepmd::DeepPot& dp = this->dp; - dp.print_summary(""); -} - -template -class TestInferDeepPotAPdNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = - {}; // 0-size input will be supported in the future - std::vector expected_e = {-93.003304908874, -185.915806542480, - -185.928116717624, -93.017934934346, - -185.924393412278, -185.923906740801}; - std::vector expected_f = { - 0.000868182637, -0.000363698132, -0.000657003077, -0.000868182637, - 0.000363698132, 0.000657003077, 0.007932614680, -0.001003609844, - 0.000737731722, -0.003883788858, 0.000686896282, -0.000578400682, - 0.004064895086, 0.006115547962, -0.008747097814, -0.008113720908, - -0.005798834400, 0.008587766774}; - std::vector expected_v = { - 0.007762485364, -0.003251851977, -0.005874313248, -0.003251851977, - 0.001362262315, 0.002460860955, -0.005874313248, 0.002460860955, - 0.004445426242, -0.007120030212, 0.002982715359, 0.005388130971, - 0.002982715359, -0.001249515894, -0.002257190002, 0.005388130971, - -0.002257190002, -0.004077504519, -0.015805863589, 0.001952684835, - -0.001522876482, 0.001796574704, -0.000358803950, 0.000369710813, - -0.001108943040, 0.000332585300, -0.000395481309, 0.008873525623, - 0.001919112114, -0.001486235522, 0.002002929532, 0.004222469272, - -0.006517211126, -0.001656192522, -0.006501210045, 0.010118622295, - -0.006548889778, -0.000465126991, 0.001002876603, 0.000240398734, - -0.005794489784, 0.008940685179, -0.000121727685, 0.008931999051, - -0.013852797563, -0.017962955675, -0.004645050453, 0.006214692837, - -0.005278283465, -0.002662692758, 0.003618275905, 0.007095320684, - 0.003648086464, -0.005023397513}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PADDLE - GTEST_SKIP() << "Skip because Paddle support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot_sea.json"; - dp.init(file_name); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { remove("deeppot.pb"); }; -}; - -/* -NOTE: Disable TestInferDeepPotAPdNoPbc cuerrently for box is a 0-size Tensor, -which is not fully supported in paddle yet -*/ -// TYPED_TEST_SUITE(TestInferDeepPotAPdNoPbc, PDValueTypes); - -// TYPED_TEST(TestInferDeepPotAPdNoPbc, cpu_build_nlist) { -// using VALUETYPE = TypeParam; -// std::vector& coord = this->coord; -// std::vector& atype = this->atype; -// std::vector& box = this->box; -// std::vector& expected_e = this->expected_e; -// std::vector& expected_f = this->expected_f; -// std::vector& expected_v = this->expected_v; -// int& natoms = this->natoms; -// double& expected_tot_e = this->expected_tot_e; -// std::vector& expected_tot_v = this->expected_tot_v; -// deepmd::DeepPot& dp = this->dp; -// double ener; -// std::vector force, virial; -// dp.compute(ener, force, virial, coord, atype, box); - -// EXPECT_EQ(force.size(), natoms * 3); -// EXPECT_EQ(virial.size(), 9); - -// EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); -// for (int ii = 0; ii < natoms * 3; ++ii) { -// EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); -// } -// for (int ii = 0; ii < 3 * 3; ++ii) { -// EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); -// } -// } diff --git a/source/api_cc/tests/test_deeppot_pt.cc b/source/api_cc/tests/test_deeppot_pt.cc deleted file mode 100644 index 7f527296b1..0000000000 --- a/source/api_cc/tests/test_deeppot_pt.cc +++ /dev/null @@ -1,636 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include "DeepPot.h" -#include "neighbor_list.h" -#include "test_utils.h" - -template -class TestInferDeepPotAPt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e = { - - -93.016873944029, -185.923296645958, -185.927096544970, - -93.019371018039, -185.926179995548, -185.924351901852}; - std::vector expected_f = { - - 0.006277522211, -0.001117962774, 0.000618580445, 0.009928999655, - 0.003026035654, -0.006941982227, 0.000667853212, -0.002449963843, - 0.006506463508, -0.007284129115, 0.000530662205, -0.000028806821, - 0.000068097781, 0.006121331983, -0.009019754602, -0.009658343745, - -0.006110103225, 0.008865499697}; - std::vector expected_v = { - -0.000155238009, 0.000116605516, -0.007869862476, 0.000465578340, - 0.008182547185, -0.002398713212, -0.008112887338, -0.002423738425, - 0.007210716605, -0.019203504012, 0.001724938709, 0.009909211091, - 0.001153857542, -0.001600015103, -0.000560024090, 0.010727836276, - -0.001034836404, -0.007973454377, -0.021517399106, -0.004064359664, - 0.004866398692, -0.003360038617, -0.007241406162, 0.005920941051, - 0.004899151657, 0.006290788591, -0.006478820311, 0.001921504710, - 0.001313470921, -0.000304091236, 0.001684345981, 0.004124109256, - -0.006396084465, -0.000701095618, -0.006356507032, 0.009818550859, - -0.015230664587, -0.000110244376, 0.000690319396, 0.000045953023, - -0.005726548770, 0.008769818495, -0.000572380210, 0.008860603423, - -0.013819348050, -0.021227082558, -0.004977781343, 0.006646239696, - -0.005987066507, -0.002767831232, 0.003746502525, 0.007697590397, - 0.003746130152, -0.005172634748}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot_sea.pth"; - - dp.init(file_name); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotAPt, ValueTypes); - -TYPED_TEST(TestInferDeepPotAPt, type_map) { - std::string type_map; - this->dp.get_type_map(type_map); - EXPECT_EQ(type_map, "O H"); -} - -TYPED_TEST(TestInferDeepPotAPt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPt, cpu_build_nlist_numfv) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - class MyModel : public EnergyModelTest { - deepmd::DeepPot& mydp; - const std::vector atype; - - public: - MyModel(deepmd::DeepPot& dp_, const std::vector& atype_) - : mydp(dp_), atype(atype_) {}; - virtual void compute(double& ener, - std::vector& force, - std::vector& virial, - const std::vector& coord, - const std::vector& box) { - mydp.compute(ener, force, virial, coord, atype, box); - } - }; - MyModel model(dp, atype); - model.test_f(coord, box); - model.test_v(coord, box); - std::vector box_(box); - box_[1] -= 0.4; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[2] += 0.5; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[4] += 0.2; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[3] -= 0.3; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[6] -= 0.7; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[7] += 0.6; - model.test_f(coord, box_); - model.test_v(coord, box_); -} - -TYPED_TEST(TestInferDeepPotAPt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0); - std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0); - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist_type_sel) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist_type_sel_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0), atomic_energy, - atomic_virial; - dp.compute(ener, force_, virial, atomic_energy, atomic_virial, coord_cpy, - atype_cpy, box, nall - nloc, inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotAPt, print_summary) { - deepmd::DeepPot& dp = this->dp; - dp.print_summary(""); -} - -template -class TestInferDeepPotAPtNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e = {-93.003304908874, -185.915806542480, - -185.928116717624, -93.017934934346, - -185.924393412278, -185.923906740801}; - std::vector expected_f = { - 0.000868182637, -0.000363698132, -0.000657003077, -0.000868182637, - 0.000363698132, 0.000657003077, 0.007932614680, -0.001003609844, - 0.000737731722, -0.003883788858, 0.000686896282, -0.000578400682, - 0.004064895086, 0.006115547962, -0.008747097814, -0.008113720908, - -0.005798834400, 0.008587766774}; - std::vector expected_v = { - 0.007762485364, -0.003251851977, -0.005874313248, -0.003251851977, - 0.001362262315, 0.002460860955, -0.005874313248, 0.002460860955, - 0.004445426242, -0.007120030212, 0.002982715359, 0.005388130971, - 0.002982715359, -0.001249515894, -0.002257190002, 0.005388130971, - -0.002257190002, -0.004077504519, -0.015805863589, 0.001952684835, - -0.001522876482, 0.001796574704, -0.000358803950, 0.000369710813, - -0.001108943040, 0.000332585300, -0.000395481309, 0.008873525623, - 0.001919112114, -0.001486235522, 0.002002929532, 0.004222469272, - -0.006517211126, -0.001656192522, -0.006501210045, 0.010118622295, - -0.006548889778, -0.000465126991, 0.001002876603, 0.000240398734, - -0.005794489784, 0.008940685179, -0.000121727685, 0.008931999051, - -0.013852797563, -0.017962955675, -0.004645050453, 0.006214692837, - -0.005278283465, -0.002662692758, 0.003618275905, 0.007095320684, - 0.003648086464, -0.005023397513}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot_sea.pth"; - dp.init(file_name); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { remove("deeppot.pb"); }; -}; - -TYPED_TEST_SUITE(TestInferDeepPotAPtNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotAPtNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_ptexpt.cc b/source/api_cc/tests/test_deeppot_ptexpt.cc index 41afb2eb2e..82ed27bcd6 100644 --- a/source/api_cc/tests/test_deeppot_ptexpt.cc +++ b/source/api_cc/tests/test_deeppot_ptexpt.cc @@ -1,7 +1,7 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // Test C++ inference for pt_expt (.pt2) backend. -// Uses the same model (converted from deeppot_sea.pth) and reference values -// as test_deeppot_pt.cc to verify cross-backend consistency. +// Uses the same model (converted from deeppot_sea.pth) and shared universal +// DeepPot reference values to verify PTExpt-specific behavior. #include #include @@ -29,7 +29,7 @@ class TestInferDeepPotAPtExpt : public ::testing::Test { 8.37, 10.70, 5.76, 2.95, 7.21, 0.83}; std::vector atype = {0, 1, 1, 0, 1, 1}; std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - // Same reference values as test_deeppot_pt.cc (model converted from .pth) + // Same reference values as deeppot_universal_data.h. std::vector expected_e = {-93.016873944029, -185.923296645958, -185.927096544970, -93.019371018039, -185.926179995548, -185.924351901852}; @@ -634,7 +634,7 @@ class TestInferDeepPotAPtExptNoPbc : public ::testing::Test { 8.37, 10.70, 5.76, 2.95, 7.21, 0.83}; std::vector atype = {0, 1, 1, 0, 1, 1}; std::vector box = {}; - // Same reference values as TestInferDeepPotAPtNoPbc in test_deeppot_pt.cc + // Same NoPBC reference values as deeppot_universal_data.h. std::vector expected_e = {-93.003304908874, -185.915806542480, -185.928116717624, -93.017934934346, -185.924393412278, -185.923906740801}; diff --git a/source/api_cc/tests/test_deeppot_universal.cc b/source/api_cc/tests/test_deeppot_universal.cc index daf8285a54..967006375b 100644 --- a/source/api_cc/tests/test_deeppot_universal.cc +++ b/source/api_cc/tests/test_deeppot_universal.cc @@ -2,14 +2,17 @@ #include #include +#include #include #include #include +#include #include #include "../../tests/infer/deeppot_universal_data.h" #include "DeepPot.h" #include "DeepPotPTExpt.h" +#include "expected_ref.h" #include "test_utils.h" namespace { @@ -26,6 +29,29 @@ struct ModelCase { double double_tol; double float_tol; bool supports_float; + bool supports_nframes; +}; + +struct FParamAParamCase { + std::string name; + Backend backend; + std::string model_path; + bool convert_pbtxt; + const deepmd_test::DeepPotRef* builtin_ref; + std::string ref_path; + double double_tol; + double float_tol; + bool supports_float; +}; + +struct DefaultFParamCase { + std::string name; + Backend backend; + std::string model_path; + std::string ref_path; + double double_tol; + double float_tol; + bool supports_float; }; bool path_exists(const std::string& path) { @@ -89,18 +115,55 @@ std::vector model_cases() { return { {"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/deeppot.pbtxt", true, &deepmd_test::tf_deeppot_ref(), - &deepmd_test::tf_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, + &deepmd_test::tf_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, true}, {"pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_sea.pth", false, &deepmd_test::sea_deeppot_ref(), - &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, + &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, false}, {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_sea.pt2", false, &deepmd_test::sea_deeppot_ref(), - &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, + &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, false}, {"jax_savedmodel", Backend::JAX, "../../tests/infer/deeppot_sea.savedmodel", false, - &deepmd_test::sea_deeppot_ref(), nullptr, 1e-10, 1e-4, true}, + &deepmd_test::sea_deeppot_ref(), nullptr, 1e-10, 1e-4, true, false}, {"paddle_json", Backend::Paddle, "../../tests/infer/deeppot_sea.json", - false, &deepmd_test::sea_deeppot_ref(), nullptr, 1e-7, 1e-4, false}}; + false, &deepmd_test::sea_deeppot_ref(), nullptr, 1e-7, 1e-4, false, + false}}; +} + +std::vector fparam_aparam_cases() { + return {{"tensorflow_pb", Backend::TensorFlow, + "../../tests/infer/fparam_aparam.pbtxt", true, + &deepmd_test::tf_fparam_aparam_ref(), "", 1e-10, 1e-4, true}, + {"pytorch_pth", Backend::PyTorch, + "../../tests/infer/fparam_aparam.pth", false, nullptr, + "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4, true}, + {"pytorch_pt2", Backend::PTExpt, + "../../tests/infer/fparam_aparam.pt2", false, nullptr, + "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4, true}}; +} + +std::vector default_fparam_cases() { + return { + {"pytorch_pth", Backend::PyTorch, + "../../tests/infer/fparam_aparam_default.pth", + "../../tests/infer/fparam_aparam_default.expected", 1e-7, 1e-4, true}, + {"pytorch_pt2", Backend::PTExpt, + "../../tests/infer/fparam_aparam_default.pt2", + "../../tests/infer/fparam_aparam_default.expected", 1e-7, 1e-4, true}}; +} + +deepmd_test::DeepPotRef load_fparam_ref(const std::string& ref_path) { + deepmd_test::ExpectedRef ref_file; + ref_file.load(ref_path); + deepmd_test::DeepPotRef ref; + ref.atomic_energy = ref_file.get("default", "expected_e"); + ref.force = ref_file.get("default", "expected_f"); + ref.atomic_virial = ref_file.get("default", "expected_v"); + ref.numb_types = 1; + ref.dim_fparam = 1; + ref.dim_aparam = 1; + ref.type_map = "O"; + return ref; } class UniversalDeepPotTest : public ::testing::TestWithParam { @@ -113,9 +176,8 @@ class UniversalDeepPotTest : public ::testing::TestWithParam { if (!backend_enabled(param.backend)) { GTEST_SKIP() << backend_name(param.backend) << " support is not enabled."; } - if (!path_exists(param.model_path)) { - GTEST_SKIP() << "Model artifact is not available: " << param.model_path; - } + ASSERT_TRUE(path_exists(param.model_path)) + << "Model artifact is not available: " << param.model_path; std::string model_path = param.model_path; if (param.convert_pbtxt) { @@ -133,6 +195,67 @@ class UniversalDeepPotTest : public ::testing::TestWithParam { } }; +class FParamAParamDeepPotTest + : public ::testing::TestWithParam { + protected: + deepmd::DeepPot dp; + std::string converted_model; + deepmd_test::DeepPotRef loaded_ref; + const deepmd_test::DeepPotRef* ref = nullptr; + + void SetUp() override { + const auto& param = GetParam(); + if (!backend_enabled(param.backend)) { + GTEST_SKIP() << backend_name(param.backend) << " support is not enabled."; + } + ASSERT_TRUE(path_exists(param.model_path)) + << "Model artifact is not available: " << param.model_path; + if (param.builtin_ref != nullptr) { + ref = param.builtin_ref; + } else { + ASSERT_TRUE(path_exists(param.ref_path)) + << "Reference artifact is not available: " << param.ref_path; + loaded_ref = load_fparam_ref(param.ref_path); + ref = &loaded_ref; + } + + std::string model_path = param.model_path; + if (param.convert_pbtxt) { + converted_model = "deeppot_fparam_aparam_" + param.name + ".pb"; + deepmd::convert_pbtxt_to_pb(param.model_path, converted_model); + model_path = converted_model; + } + dp.init(model_path); + } + + void TearDown() override { + if (!converted_model.empty()) { + remove(converted_model.c_str()); + } + } +}; + +class DefaultFParamDeepPotTest + : public ::testing::TestWithParam { + protected: + deepmd::DeepPot dp; + deepmd_test::DeepPotRef ref; + + void SetUp() override { + const auto& param = GetParam(); + if (!backend_enabled(param.backend)) { + GTEST_SKIP() << backend_name(param.backend) << " support is not enabled."; + } + ASSERT_TRUE(path_exists(param.model_path)) + << "Model artifact is not available: " << param.model_path; + ASSERT_TRUE(path_exists(param.ref_path)) + << "Reference artifact is not available: " << param.ref_path; + ref = load_fparam_ref(param.ref_path); + ref.has_default_fparam = true; + dp.init(param.model_path); + } +}; + TEST_P(UniversalDeepPotTest, Metadata) { const auto& ref = *GetParam().ref; std::string type_map; @@ -149,11 +272,75 @@ TEST_P(UniversalDeepPotTest, Metadata) { } template -void check_compute(deepmd::DeepPot& dp, - const deepmd_test::DeepPotRef& ref, - const double tol, - const bool use_box = true) { +void expect_reference(const double energy, + const std::vector& force, + const std::vector& virial, + const deepmd_test::DeepPotRef& ref, + const double tol) { + const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const std::vector expected_virial = deepmd_test::total_virial(ref); + + ASSERT_EQ(force.size(), static_cast(natoms * 3)); + ASSERT_EQ(virial.size(), 9U); + + EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol); + for (int ii = 0; ii < natoms * 3; ++ii) { + EXPECT_NEAR(force[ii], ref.force[ii], tol); + } + for (size_t ii = 0; ii < 9; ++ii) { + EXPECT_NEAR(virial[ii], expected_virial[ii], tol); + } +} + +template +void expect_atomic_reference(const double energy, + const std::vector& force, + const std::vector& virial, + const std::vector& atomic_energy, + const std::vector& atomic_virial, + const deepmd_test::DeepPotRef& ref, + const double tol) { const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + + expect_reference(energy, force, virial, ref, tol); + ASSERT_EQ(atomic_energy.size(), static_cast(natoms)); + ASSERT_EQ(atomic_virial.size(), static_cast(natoms * 9)); + + for (int ii = 0; ii < natoms; ++ii) { + EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol); + } + for (int ii = 0; ii < natoms * 9; ++ii) { + EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol); + } +} + +template +void check_compute_simple(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const bool use_box = true) { + const std::vector coord(deepmd_test::deeppot_coord().begin(), + deepmd_test::deeppot_coord().end()); + std::vector box; + if (use_box) { + box.assign(deepmd_test::deeppot_box().begin(), + deepmd_test::deeppot_box().end()); + } + const std::vector atype = deepmd_test::deeppot_atype(); + + double energy = 0.0; + std::vector force; + std::vector virial; + dp.compute(energy, force, virial, coord, atype, box); + + expect_reference(energy, force, virial, ref, tol); +} + +template +void check_compute_atomic(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const bool use_box = true) { const std::vector coord(deepmd_test::deeppot_coord().begin(), deepmd_test::deeppot_coord().end()); std::vector box; @@ -162,7 +349,6 @@ void check_compute(deepmd::DeepPot& dp, deepmd_test::deeppot_box().end()); } const std::vector atype = deepmd_test::deeppot_atype(); - const std::vector expected_virial = deepmd_test::total_virial(ref); double energy = 0.0; std::vector force; @@ -172,28 +358,555 @@ void check_compute(deepmd::DeepPot& dp, dp.compute(energy, force, virial, atomic_energy, atomic_virial, coord, atype, box); - ASSERT_EQ(force.size(), static_cast(natoms * 3)); - ASSERT_EQ(virial.size(), 9U); - ASSERT_EQ(atomic_energy.size(), static_cast(natoms)); - ASSERT_EQ(atomic_virial.size(), static_cast(natoms * 9)); + expect_atomic_reference(energy, force, virial, atomic_energy, atomic_virial, + ref, tol); +} + +template +void check_finite_difference(deepmd::DeepPot& dp) { + class Model : public EnergyModelTest { + deepmd::DeepPot& dp_; + const std::vector atype_; + + public: + Model(deepmd::DeepPot& dp, const std::vector& atype) + : dp_(dp), atype_(atype) {} + + void compute(double& energy, + std::vector& force, + std::vector& virial, + const std::vector& coord, + const std::vector& box) override { + dp_.compute(energy, force, virial, coord, atype_, box); + } + }; + + const std::vector coord(deepmd_test::deeppot_coord().begin(), + deepmd_test::deeppot_coord().end()); + const std::vector atype = deepmd_test::deeppot_atype(); + std::vector box(deepmd_test::deeppot_box().begin(), + deepmd_test::deeppot_box().end()); + Model model(dp, atype); + model.test_f(coord, box); + model.test_v(coord, box); + box[1] -= 0.4; + model.test_f(coord, box); + model.test_v(coord, box); + box[2] += 0.5; + model.test_f(coord, box); + model.test_v(coord, box); + box[4] += 0.2; + model.test_f(coord, box); + model.test_v(coord, box); + box[3] -= 0.3; + model.test_f(coord, box); + model.test_v(coord, box); + box[6] -= 0.7; + model.test_f(coord, box); + model.test_v(coord, box); + box[7] += 0.6; + model.test_f(coord, box); + model.test_v(coord, box); +} + +template +void check_lmp_nlist(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const double cutoff_scale = 1.0) { + const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const std::vector coord(deepmd_test::deeppot_coord().begin(), + deepmd_test::deeppot_coord().end()); + const std::vector atype = deepmd_test::deeppot_atype(); + const std::vector box(deepmd_test::deeppot_box().begin(), + deepmd_test::deeppot_box().end()); + const float rc = static_cast(dp.cutoff() * cutoff_scale); + const int nloc = natoms; + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector> nlist_data; + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, + atype, box, rc); + const int nall = static_cast(coord_cpy.size() / 3); + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + + for (int ago = 0; ago < 2; ++ago) { + double energy = 0.0; + std::vector force_all(nall * 3, 0.0); + std::vector virial(9, 0.0); + dp.compute(energy, force_all, virial, coord_cpy, atype_cpy, box, + nall - nloc, inlist, ago); + + std::vector force; + _fold_back(force, force_all, mapping, nloc, nall, 3); + expect_reference(energy, force, virial, ref, tol); + } +} + +template +void check_lmp_nlist_atomic(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol) { + const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const std::vector coord(deepmd_test::deeppot_coord().begin(), + deepmd_test::deeppot_coord().end()); + const std::vector atype = deepmd_test::deeppot_atype(); + const std::vector box(deepmd_test::deeppot_box().begin(), + deepmd_test::deeppot_box().end()); + const float rc = static_cast(dp.cutoff()); + const int nloc = natoms; + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector> nlist_data; + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, + atype, box, rc); + const int nall = static_cast(coord_cpy.size() / 3); + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + + for (int ago = 0; ago < 2; ++ago) { + double energy = 0.0; + std::vector force_all(nall * 3, 0.0), virial(9, 0.0); + std::vector atomic_energy_all(nall, 0.0); + std::vector atomic_virial_all(nall * 9, 0.0); + dp.compute(energy, force_all, virial, atomic_energy_all, atomic_virial_all, + coord_cpy, atype_cpy, box, nall - nloc, inlist, ago); + + std::vector force, atomic_energy, atomic_virial; + _fold_back(force, force_all, mapping, nloc, nall, 3); + _fold_back(atomic_energy, atomic_energy_all, mapping, nloc, nall, + 1); + _fold_back(atomic_virial, atomic_virial_all, mapping, nloc, nall, + 9); + expect_atomic_reference(energy, force, virial, atomic_energy, atomic_virial, + ref, tol); + } +} + +template +void check_lmp_nlist_type_sel(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const bool atomic) { + constexpr int nvir = 2; + std::vector coord(deepmd_test::deeppot_coord().begin(), + deepmd_test::deeppot_coord().end()); + std::vector atype = deepmd_test::deeppot_atype(); + const std::vector box(deepmd_test::deeppot_box().begin(), + deepmd_test::deeppot_box().end()); + std::vector expected_force(ref.force.begin(), ref.force.end()); + std::vector coord_vir(nvir * 3); + std::copy(coord.begin(), coord.begin() + nvir * 3, coord_vir.begin()); + coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); + atype.insert(atype.begin(), nvir, 2); + expected_force.insert(expected_force.begin(), nvir * 3, 0.0); + + const int natoms = static_cast(atype.size()); + const int nloc = natoms; + const float rc = static_cast(dp.cutoff()); + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector> nlist_data; + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, + atype, box, rc); + const int nall = static_cast(coord_cpy.size() / 3); + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + double energy = 0.0; + std::vector force_all(nall * 3, 0.0), virial(9, 0.0); + if (atomic) { + std::vector atomic_energy, atomic_virial; + dp.compute(energy, force_all, virial, atomic_energy, atomic_virial, + coord_cpy, atype_cpy, box, nall - nloc, inlist, 0); + } else { + dp.compute(energy, force_all, virial, coord_cpy, atype_cpy, box, + nall - nloc, inlist, 0); + } + + std::vector force; + _fold_back(force, force_all, mapping, nloc, nall, 3); + const std::vector expected_virial = deepmd_test::total_virial(ref); + ASSERT_EQ(force.size(), expected_force.size()); EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_NEAR(force[ii], ref.force[ii], tol); + for (size_t ii = 0; ii < expected_force.size(); ++ii) { + EXPECT_NEAR(force[ii], expected_force[ii], tol); } for (size_t ii = 0; ii < 9; ++ii) { EXPECT_NEAR(virial[ii], expected_virial[ii], tol); } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol); +} + +template +std::vector cast_values(const std::vector& values) { + return std::vector(values.begin(), values.end()); +} + +template +std::vector repeat_values(const std::vector& values, + const int nframes) { + std::vector repeated; + repeated.reserve(static_cast(nframes) * values.size()); + for (int kk = 0; kk < nframes; ++kk) { + repeated.insert(repeated.end(), values.begin(), values.end()); } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol); + return repeated; +} + +template +void expect_reference_frames(const std::vector& energy, + const std::vector& force, + const std::vector& virial, + const deepmd_test::DeepPotRef& ref, + const double tol, + const int nframes) { + const int natoms = static_cast(ref.atomic_energy.size()); + const std::vector expected_virial = deepmd_test::total_virial(ref); + + ASSERT_EQ(energy.size(), static_cast(nframes)); + ASSERT_EQ(force.size(), static_cast(nframes * natoms * 3)); + ASSERT_EQ(virial.size(), static_cast(nframes * 9)); + + for (int kk = 0; kk < nframes; ++kk) { + EXPECT_NEAR(energy[kk], deepmd_test::total_energy(ref), tol); + for (int ii = 0; ii < natoms * 3; ++ii) { + EXPECT_NEAR(force[kk * natoms * 3 + ii], ref.force[ii], tol); + } + for (int ii = 0; ii < 9; ++ii) { + EXPECT_NEAR(virial[kk * 9 + ii], expected_virial[ii], tol); + } + } +} + +template +void expect_atomic_reference_frames(const std::vector& energy, + const std::vector& force, + const std::vector& virial, + const std::vector& atomic_energy, + const std::vector& atomic_virial, + const deepmd_test::DeepPotRef& ref, + const double tol, + const int nframes) { + const int natoms = static_cast(ref.atomic_energy.size()); + + expect_reference_frames(energy, force, virial, ref, tol, nframes); + ASSERT_EQ(atomic_energy.size(), static_cast(nframes * natoms)); + ASSERT_EQ(atomic_virial.size(), static_cast(nframes * natoms * 9)); + + for (int kk = 0; kk < nframes; ++kk) { + for (int ii = 0; ii < natoms; ++ii) { + EXPECT_NEAR(atomic_energy[kk * natoms + ii], ref.atomic_energy[ii], tol); + } + for (int ii = 0; ii < natoms * 9; ++ii) { + EXPECT_NEAR(atomic_virial[kk * natoms * 9 + ii], ref.atomic_virial[ii], + tol); + } + } +} + +template +void check_compute_frames_simple(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const int nframes, + const bool use_box = true) { + const std::vector coord = repeat_values( + cast_values(deepmd_test::deeppot_coord()), nframes); + std::vector box; + if (use_box) { + box = repeat_values(cast_values(deepmd_test::deeppot_box()), + nframes); + } + const std::vector atype = deepmd_test::deeppot_atype(); + + std::vector energy; + std::vector force; + std::vector virial; + dp.compute(energy, force, virial, coord, atype, box); + + expect_reference_frames(energy, force, virial, ref, tol, nframes); +} + +template +void check_compute_frames_atomic(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const int nframes) { + const std::vector coord = repeat_values( + cast_values(deepmd_test::deeppot_coord()), nframes); + const std::vector box = repeat_values( + cast_values(deepmd_test::deeppot_box()), nframes); + const std::vector atype = deepmd_test::deeppot_atype(); + + std::vector energy; + std::vector force; + std::vector virial; + std::vector atomic_energy; + std::vector atomic_virial; + dp.compute(energy, force, virial, atomic_energy, atomic_virial, coord, atype, + box); + + expect_atomic_reference_frames(energy, force, virial, atomic_energy, + atomic_virial, ref, tol, nframes); +} + +template +void check_lmp_nlist_frames(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const int nframes, + const bool atomic, + const double cutoff_scale = 1.0) { + const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const std::vector coord = + cast_values(deepmd_test::deeppot_coord()); + const std::vector atype = deepmd_test::deeppot_atype(); + const std::vector box_frame = + cast_values(deepmd_test::deeppot_box()); + const std::vector box = repeat_values(box_frame, nframes); + const float rc = static_cast(dp.cutoff() * cutoff_scale); + const int nloc = natoms; + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector> nlist_data; + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, + atype, box_frame, rc); + const int nall = static_cast(coord_cpy.size() / 3); + const std::vector coord_cpy_frames = + repeat_values(coord_cpy, nframes); + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + + for (int ago = 0; ago < 2; ++ago) { + std::vector energy; + std::vector force_all; + std::vector virial; + if (atomic) { + std::vector atomic_energy_all; + std::vector atomic_virial_all; + dp.compute(energy, force_all, virial, atomic_energy_all, + atomic_virial_all, coord_cpy_frames, atype_cpy, box, + nall - nloc, inlist, ago); + + std::vector force, atomic_energy, atomic_virial; + _fold_back(force, force_all, mapping, nloc, nall, 3, nframes); + _fold_back(atomic_energy, atomic_energy_all, mapping, nloc, + nall, 1, nframes); + _fold_back(atomic_virial, atomic_virial_all, mapping, nloc, + nall, 9, nframes); + expect_atomic_reference_frames(energy, force, virial, atomic_energy, + atomic_virial, ref, tol, nframes); + } else { + dp.compute(energy, force_all, virial, coord_cpy_frames, atype_cpy, box, + nall - nloc, inlist, ago); + + std::vector force; + _fold_back(force, force_all, mapping, nloc, nall, 3, nframes); + expect_reference_frames(energy, force, virial, ref, tol, nframes); + } + } +} + +template +void check_lmp_nlist_type_sel_frames(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const int nframes, + const bool atomic) { + constexpr int nvir = 2; + const std::vector base_coord = + cast_values(deepmd_test::deeppot_coord()); + std::vector coord_vir(nvir * 3); + std::copy(base_coord.begin(), base_coord.begin() + nvir * 3, + coord_vir.begin()); + + std::vector coord = base_coord; + coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); + std::vector atype = deepmd_test::deeppot_atype(); + atype.insert(atype.begin(), nvir, 2); + const std::vector box_frame = + cast_values(deepmd_test::deeppot_box()); + const std::vector box = repeat_values(box_frame, nframes); + + const int natoms = static_cast(atype.size()); + const int nloc = natoms; + const float rc = static_cast(dp.cutoff()); + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector> nlist_data; + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, + atype, box_frame, rc); + const int nall = static_cast(coord_cpy.size() / 3); + const std::vector coord_cpy_frames = + repeat_values(coord_cpy, nframes); + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + + std::vector energy; + std::vector force_all; + std::vector virial; + if (atomic) { + std::vector atomic_energy, atomic_virial; + dp.compute(energy, force_all, virial, atomic_energy, atomic_virial, + coord_cpy_frames, atype_cpy, box, nall - nloc, inlist, 0); + } else { + dp.compute(energy, force_all, virial, coord_cpy_frames, atype_cpy, box, + nall - nloc, inlist, 0); + } + + std::vector force; + _fold_back(force, force_all, mapping, nloc, nall, 3, nframes); + + const std::vector expected_virial = deepmd_test::total_virial(ref); + std::vector expected_force_frame(ref.force.begin(), + ref.force.end()); + expected_force_frame.insert(expected_force_frame.begin(), nvir * 3, 0.0); + const std::vector expected_force = + repeat_values(expected_force_frame, nframes); + + ASSERT_EQ(energy.size(), static_cast(nframes)); + ASSERT_EQ(force.size(), expected_force.size()); + ASSERT_EQ(virial.size(), static_cast(nframes * 9)); + for (int kk = 0; kk < nframes; ++kk) { + EXPECT_NEAR(energy[kk], deepmd_test::total_energy(ref), tol); + for (size_t ii = 0; ii < expected_force_frame.size(); ++ii) { + EXPECT_NEAR(force[kk * expected_force_frame.size() + ii], + expected_force_frame[ii], tol); + } + for (size_t ii = 0; ii < 9; ++ii) { + EXPECT_NEAR(virial[kk * 9 + ii], expected_virial[ii], tol); + } + } +} + +template +void check_fparam_compute_simple(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const std::vector& fparam_values) { + const std::vector coord = + cast_values(deepmd_test::deeppot_coord()); + const std::vector atype = deepmd_test::fparam_aparam_atype(); + const std::vector box = + cast_values(deepmd_test::deeppot_box()); + const std::vector fparam = cast_values(fparam_values); + const std::vector aparam = + cast_values(deepmd_test::aparam_value()); + + double energy = 0.0; + std::vector force; + std::vector virial; + dp.compute(energy, force, virial, coord, atype, box, fparam, aparam); + + expect_reference(energy, force, virial, ref, tol); +} + +template +void check_fparam_compute_atomic(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const std::vector& fparam_values) { + const std::vector coord = + cast_values(deepmd_test::deeppot_coord()); + const std::vector atype = deepmd_test::fparam_aparam_atype(); + const std::vector box = + cast_values(deepmd_test::deeppot_box()); + const std::vector fparam = cast_values(fparam_values); + const std::vector aparam = + cast_values(deepmd_test::aparam_value()); + + double energy = 0.0; + std::vector force; + std::vector virial; + std::vector atomic_energy; + std::vector atomic_virial; + dp.compute(energy, force, virial, atomic_energy, atomic_virial, coord, atype, + box, fparam, aparam); + + expect_atomic_reference(energy, force, virial, atomic_energy, atomic_virial, + ref, tol); +} + +template +void check_fparam_lmp_nlist(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const std::vector& fparam_values, + const bool atomic, + const double cutoff_scale = 1.0, + const int ago_count = 2) { + const int natoms = + static_cast(deepmd_test::fparam_aparam_atype().size()); + const std::vector coord = + cast_values(deepmd_test::deeppot_coord()); + const std::vector atype = deepmd_test::fparam_aparam_atype(); + const std::vector box = + cast_values(deepmd_test::deeppot_box()); + const std::vector fparam = cast_values(fparam_values); + const std::vector aparam = + cast_values(deepmd_test::aparam_value()); + const float rc = static_cast(dp.cutoff() * cutoff_scale); + const int nloc = natoms; + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector> nlist_data; + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, + atype, box, rc); + const int nall = static_cast(coord_cpy.size() / 3); + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + + for (int ago = 0; ago < ago_count; ++ago) { + double energy = 0.0; + std::vector force_all(nall * 3, 0.0); + std::vector virial(9, 0.0); + if (atomic) { + std::vector atomic_energy_all(nall, 0.0); + std::vector atomic_virial_all(nall * 9, 0.0); + dp.compute(energy, force_all, virial, atomic_energy_all, + atomic_virial_all, coord_cpy, atype_cpy, box, nall - nloc, + inlist, ago, fparam, aparam); + + std::vector force, atomic_energy, atomic_virial; + _fold_back(force, force_all, mapping, nloc, nall, 3); + _fold_back(atomic_energy, atomic_energy_all, mapping, nloc, + nall, 1); + _fold_back(atomic_virial, atomic_virial_all, mapping, nloc, + nall, 9); + expect_atomic_reference(energy, force, virial, atomic_energy, + atomic_virial, ref, tol); + } else { + dp.compute(energy, force_all, virial, coord_cpy, atype_cpy, box, + nall - nloc, inlist, ago, fparam, aparam); + + std::vector force; + _fold_back(force, force_all, mapping, nloc, nall, 3); + expect_reference(energy, force, virial, ref, tol); + } } } TEST_P(UniversalDeepPotTest, ComputeDouble) { - check_compute(dp, *GetParam().ref, GetParam().double_tol); + check_compute_atomic(dp, *GetParam().ref, GetParam().double_tol); } TEST_P(UniversalDeepPotTest, ComputeFloat) { @@ -201,7 +914,95 @@ TEST_P(UniversalDeepPotTest, ComputeFloat) { GTEST_SKIP() << backend_name(GetParam().backend) << " does not provide float inference coverage."; } - check_compute(dp, *GetParam().ref, GetParam().float_tol); + check_compute_atomic(dp, *GetParam().ref, GetParam().float_tol); +} + +TEST_P(UniversalDeepPotTest, ComputeSimpleDouble) { + check_compute_simple(dp, *GetParam().ref, GetParam().double_tol); +} + +TEST_P(UniversalDeepPotTest, ComputeSimpleFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_compute_simple(dp, *GetParam().ref, GetParam().float_tol); +} + +TEST_P(UniversalDeepPotTest, FiniteDifferenceDouble) { + check_finite_difference(dp); +} + +TEST_P(UniversalDeepPotTest, FiniteDifferenceFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_finite_difference(dp); +} + +TEST_P(UniversalDeepPotTest, LmpNlistDouble) { + check_lmp_nlist(dp, *GetParam().ref, GetParam().double_tol); +} + +TEST_P(UniversalDeepPotTest, LmpNlistFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_lmp_nlist(dp, *GetParam().ref, GetParam().float_tol); +} + +TEST_P(UniversalDeepPotTest, LmpNlistAtomicDouble) { + check_lmp_nlist_atomic(dp, *GetParam().ref, GetParam().double_tol); +} + +TEST_P(UniversalDeepPotTest, LmpNlistAtomicFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_lmp_nlist_atomic(dp, *GetParam().ref, GetParam().float_tol); +} + +TEST_P(UniversalDeepPotTest, LmpNlistDoubleCutoffTwice) { + check_lmp_nlist(dp, *GetParam().ref, GetParam().double_tol, 2.0); +} + +TEST_P(UniversalDeepPotTest, LmpNlistFloatCutoffTwice) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_lmp_nlist(dp, *GetParam().ref, GetParam().float_tol, 2.0); +} + +TEST_P(UniversalDeepPotTest, LmpNlistTypeSelDouble) { + check_lmp_nlist_type_sel(dp, *GetParam().ref, GetParam().double_tol, + false); +} + +TEST_P(UniversalDeepPotTest, LmpNlistTypeSelFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_lmp_nlist_type_sel(dp, *GetParam().ref, GetParam().float_tol, + false); +} + +TEST_P(UniversalDeepPotTest, LmpNlistTypeSelAtomicDouble) { + check_lmp_nlist_type_sel(dp, *GetParam().ref, GetParam().double_tol, + true); +} + +TEST_P(UniversalDeepPotTest, LmpNlistTypeSelAtomicFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_lmp_nlist_type_sel(dp, *GetParam().ref, GetParam().float_tol, + true); } TEST_P(UniversalDeepPotTest, ComputeNoPbcDouble) { @@ -209,8 +1010,8 @@ TEST_P(UniversalDeepPotTest, ComputeNoPbcDouble) { GTEST_SKIP() << backend_name(GetParam().backend) << " NoPBC reference is not available."; } - check_compute(dp, *GetParam().no_pbc_ref, GetParam().double_tol, - false); + check_compute_atomic(dp, *GetParam().no_pbc_ref, + GetParam().double_tol, false); } TEST_P(UniversalDeepPotTest, ComputeNoPbcFloat) { @@ -222,7 +1023,338 @@ TEST_P(UniversalDeepPotTest, ComputeNoPbcFloat) { GTEST_SKIP() << backend_name(GetParam().backend) << " NoPBC reference is not available."; } - check_compute(dp, *GetParam().no_pbc_ref, GetParam().float_tol, false); + check_compute_atomic(dp, *GetParam().no_pbc_ref, GetParam().float_tol, + false); +} + +TEST_P(UniversalDeepPotTest, ComputeSimpleNoPbcDouble) { + if (GetParam().no_pbc_ref == nullptr) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " NoPBC reference is not available."; + } + check_compute_simple(dp, *GetParam().no_pbc_ref, + GetParam().double_tol, false); +} + +TEST_P(UniversalDeepPotTest, ComputeSimpleNoPbcFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (GetParam().no_pbc_ref == nullptr) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " NoPBC reference is not available."; + } + check_compute_simple(dp, *GetParam().no_pbc_ref, GetParam().float_tol, + false); +} + +TEST_P(UniversalDeepPotTest, PrintSummary) { dp.print_summary(""); } + +TEST_P(UniversalDeepPotTest, NFramesComputeDouble) { + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_compute_frames_simple(dp, *GetParam().ref, + GetParam().double_tol, 2); +} + +TEST_P(UniversalDeepPotTest, NFramesComputeFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_compute_frames_simple(dp, *GetParam().ref, GetParam().float_tol, + 2); +} + +TEST_P(UniversalDeepPotTest, NFramesComputeAtomicDouble) { + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_compute_frames_atomic(dp, *GetParam().ref, + GetParam().double_tol, 2); +} + +TEST_P(UniversalDeepPotTest, NFramesComputeAtomicFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_compute_frames_atomic(dp, *GetParam().ref, GetParam().float_tol, + 2); +} + +TEST_P(UniversalDeepPotTest, NFramesLmpNlistDouble) { + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().double_tol, 2, + false); +} + +TEST_P(UniversalDeepPotTest, NFramesLmpNlistFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().float_tol, 2, + false); +} + +TEST_P(UniversalDeepPotTest, NFramesLmpNlistAtomicDouble) { + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().double_tol, 2, + true); +} + +TEST_P(UniversalDeepPotTest, NFramesLmpNlistAtomicFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().float_tol, 2, + true); +} + +TEST_P(UniversalDeepPotTest, NFramesLmpNlistDoubleCutoffTwice) { + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().double_tol, 2, + false, 2.0); +} + +TEST_P(UniversalDeepPotTest, NFramesLmpNlistFloatCutoffTwice) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().float_tol, 2, + false, 2.0); +} + +TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelDouble) { + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_lmp_nlist_type_sel_frames(dp, *GetParam().ref, + GetParam().double_tol, 2, false); +} + +TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_lmp_nlist_type_sel_frames(dp, *GetParam().ref, + GetParam().float_tol, 2, false); +} + +TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelAtomicDouble) { + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_lmp_nlist_type_sel_frames(dp, *GetParam().ref, + GetParam().double_tol, 2, true); +} + +TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelAtomicFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + check_lmp_nlist_type_sel_frames(dp, *GetParam().ref, + GetParam().float_tol, 2, true); +} + +TEST_P(UniversalDeepPotTest, NFramesComputeNoPbcDouble) { + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + if (GetParam().no_pbc_ref == nullptr) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " NoPBC reference is not available."; + } + check_compute_frames_simple(dp, *GetParam().no_pbc_ref, + GetParam().double_tol, 2, false); +} + +TEST_P(UniversalDeepPotTest, NFramesComputeNoPbcFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_nframes) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " nframes coverage is not enabled."; + } + if (GetParam().no_pbc_ref == nullptr) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " NoPBC reference is not available."; + } + check_compute_frames_simple(dp, *GetParam().no_pbc_ref, + GetParam().float_tol, 2, false); +} + +TEST_P(FParamAParamDeepPotTest, Metadata) { + EXPECT_EQ(dp.dim_fparam(), 1); + EXPECT_EQ(dp.dim_aparam(), 1); + EXPECT_FALSE(dp.has_default_fparam()); +} + +TEST_P(FParamAParamDeepPotTest, ComputeDouble) { + check_fparam_compute_atomic(dp, *ref, GetParam().double_tol, + deepmd_test::fparam_value()); +} + +TEST_P(FParamAParamDeepPotTest, ComputeFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_fparam_compute_atomic(dp, *ref, GetParam().float_tol, + deepmd_test::fparam_value()); +} + +TEST_P(FParamAParamDeepPotTest, ComputeSimpleDouble) { + check_fparam_compute_simple(dp, *ref, GetParam().double_tol, + deepmd_test::fparam_value()); +} + +TEST_P(FParamAParamDeepPotTest, ComputeSimpleFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_fparam_compute_simple(dp, *ref, GetParam().float_tol, + deepmd_test::fparam_value()); +} + +TEST_P(FParamAParamDeepPotTest, LmpNlistDouble) { + check_fparam_lmp_nlist(dp, *ref, GetParam().double_tol, + deepmd_test::fparam_value(), false); +} + +TEST_P(FParamAParamDeepPotTest, LmpNlistFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_fparam_lmp_nlist(dp, *ref, GetParam().float_tol, + deepmd_test::fparam_value(), false); +} + +TEST_P(FParamAParamDeepPotTest, LmpNlistAtomicDouble) { + check_fparam_lmp_nlist(dp, *ref, GetParam().double_tol, + deepmd_test::fparam_value(), true); +} + +TEST_P(FParamAParamDeepPotTest, LmpNlistAtomicFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_fparam_lmp_nlist(dp, *ref, GetParam().float_tol, + deepmd_test::fparam_value(), true); +} + +TEST_P(FParamAParamDeepPotTest, LmpNlistDoubleCutoffTwice) { + check_fparam_lmp_nlist(dp, *ref, GetParam().double_tol, + deepmd_test::fparam_value(), false, 2.0); +} + +TEST_P(FParamAParamDeepPotTest, LmpNlistFloatCutoffTwice) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_fparam_lmp_nlist(dp, *ref, GetParam().float_tol, + deepmd_test::fparam_value(), false, 2.0); +} + +TEST_P(DefaultFParamDeepPotTest, Metadata) { + EXPECT_EQ(dp.dim_fparam(), 1); + EXPECT_EQ(dp.dim_aparam(), 1); + EXPECT_TRUE(dp.has_default_fparam()); +} + +TEST_P(DefaultFParamDeepPotTest, ComputeWithEmptyFParamDouble) { + check_fparam_compute_simple(dp, ref, GetParam().double_tol, {}); +} + +TEST_P(DefaultFParamDeepPotTest, ComputeWithEmptyFParamFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_fparam_compute_simple(dp, ref, GetParam().float_tol, {}); +} + +TEST_P(DefaultFParamDeepPotTest, ComputeWithExplicitFParamDouble) { + check_fparam_compute_simple(dp, ref, GetParam().double_tol, + deepmd_test::fparam_value()); +} + +TEST_P(DefaultFParamDeepPotTest, ComputeWithExplicitFParamFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_fparam_compute_simple(dp, ref, GetParam().float_tol, + deepmd_test::fparam_value()); +} + +TEST_P(DefaultFParamDeepPotTest, LmpNlistWithEmptyFParamDouble) { + check_fparam_lmp_nlist(dp, ref, GetParam().double_tol, {}, false, 1.0, + 1); +} + +TEST_P(DefaultFParamDeepPotTest, LmpNlistWithEmptyFParamFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_fparam_lmp_nlist(dp, ref, GetParam().float_tol, {}, false, 1.0, + 1); } INSTANTIATE_TEST_SUITE_P( @@ -233,4 +1365,18 @@ INSTANTIATE_TEST_SUITE_P( return info.param.name; }); +INSTANTIATE_TEST_SUITE_P( + FParamAParamBackends, + FParamAParamDeepPotTest, + ::testing::ValuesIn(fparam_aparam_cases()), + [](const ::testing::TestParamInfo& + info) { return info.param.name; }); + +INSTANTIATE_TEST_SUITE_P( + DefaultFParamBackends, + DefaultFParamDeepPotTest, + ::testing::ValuesIn(default_fparam_cases()), + [](const ::testing::TestParamInfo& + info) { return info.param.name; }); + } // namespace diff --git a/source/lmp/tests/test_lammps_faparam.py b/source/lmp/tests/test_lammps_faparam.py index c40fb9bdb0..857acc9f17 100644 --- a/source/lmp/tests/test_lammps_faparam.py +++ b/source/lmp/tests/test_lammps_faparam.py @@ -27,7 +27,7 @@ data_file = Path(__file__).parent / "data.lmp" md_file = Path(__file__).parent / "md.out" -# from api_cc/tests/test_deeppot_a_fparam_aparam.cc +# Same reference values as source/tests/infer/deeppot_universal_data.h. expected_ae = np.array( [ -1.038271183039953804e-01, diff --git a/source/tests/infer/deeppot_universal_data.h b/source/tests/infer/deeppot_universal_data.h index 0c9db4e97d..ea464005f3 100644 --- a/source/tests/infer/deeppot_universal_data.h +++ b/source/tests/infer/deeppot_universal_data.h @@ -39,6 +39,22 @@ inline const std::vector& deeppot_box() { return box; } +inline const std::vector& fparam_aparam_atype() { + static const std::vector atype = {0, 0, 0, 0, 0, 0}; + return atype; +} + +inline const std::vector& fparam_value() { + static const std::vector fparam = {0.25852028}; + return fparam; +} + +inline const std::vector& aparam_value() { + static const std::vector aparam = { + 0.25852028, 0.25852028, 0.25852028, 0.25852028, 0.25852028, 0.25852028}; + return aparam; +} + inline const DeepPotRef& tf_deeppot_ref() { static const DeepPotRef ref = { {-9.275780747115504710e+01, -1.863501786584258468e+02, @@ -153,6 +169,56 @@ inline const DeepPotRef& sea_deeppot_ref() { return ref; } +inline const DeepPotRef& tf_fparam_aparam_ref() { + static const DeepPotRef ref = [] { + DeepPotRef ref = {{-1.038271183039953804e-01, -7.285433575272914908e-02, + -9.467600174099155552e-02, -1.467050086239614082e-01, + -7.660561620618722145e-02, -7.277295998502930630e-02}, + {6.622266817497907132e-02, 5.278739055693523058e-02, + 2.265727495541422845e-02, -2.606047850915838363e-02, + -4.538811686410718776e-02, 1.058247569147072187e-02, + 1.679392490937766935e-01, -2.257828022687320690e-03, + -4.490145670355452645e-02, -1.148364103573685929e-01, + -1.169790466695089237e-02, 6.140402504113953025e-02, + -8.078778132132799494e-02, -5.838878056243369807e-02, + 6.773639989682191109e-02, -1.247724708090079161e-02, + 6.494523955924384750e-02, -1.174787188812918687e-01}, + {-1.589185553287162656e-01, 2.586163333170100279e-03, + -1.575127933809472624e-04, -1.855360380105876630e-02, + 1.949822090859933826e-02, -1.006552056166355388e-02, + 3.177029853276916449e-02, 1.714349636720383010e-03, + -1.290389175187874483e-03, -8.553510339477603253e-02, + -5.654637257232508415e-03, -1.286954833787038420e-02, + 2.464156457499515687e-02, -2.398202886026797043e-02, + -1.957110465239037672e-02, 2.233492928605742764e-02, + 6.107843207824020099e-03, 1.707078295947736047e-03, + -1.653994088976195043e-01, 3.894358678172111371e-02, + -2.169595969759342477e-02, 6.819704294738503786e-03, + -5.018242039618424008e-03, 2.640664428663210429e-03, + -1.985298275686078057e-03, -3.638421609610945767e-02, + 2.342932331075030239e-02, -8.501331914753691710e-02, + -2.181253413538992297e-03, 4.311300069651782287e-03, + -1.910329328333908129e-03, -1.808810159508548836e-03, + -1.540075281450827612e-03, -1.173703213175551763e-02, + -2.596306629910121507e-03, 6.705025662372287101e-03, + -9.038455005073858795e-02, 3.011717773578577451e-02, + -5.083054073419784880e-02, -2.951210292616929069e-03, + 2.342445652898489383e-02, -4.091207474993674431e-02, + -1.648470649301832236e-02, -2.872261885460645689e-02, + 4.763924972552112391e-02, -8.300036532764677732e-02, + 1.020429228955421243e-03, -1.026734151199098881e-03, + 5.678534096113684732e-02, 1.273635718045938205e-02, + -1.530143225195957322e-02, -1.061671865629566225e-01, + -2.486859433265622629e-02, 2.875323131744185121e-02}}; + ref.numb_types = 1; + ref.dim_fparam = 1; + ref.dim_aparam = 1; + ref.type_map = "O"; + return ref; + }(); + return ref; +} + inline const DeepPotRef& sea_deeppot_no_pbc_ref() { static const DeepPotRef ref = { {-93.003304908874, -185.915806542480, -185.928116717624, -93.017934934346, diff --git a/source/tests/infer/gen_fparam_aparam.py b/source/tests/infer/gen_fparam_aparam.py index 79f165e147..2445b8b304 100644 --- a/source/tests/infer/gen_fparam_aparam.py +++ b/source/tests/infer/gen_fparam_aparam.py @@ -147,7 +147,8 @@ def main(): ) # ---- 4a. Write sidecar for fparam_aparam.pt2/.pth tests ---- - # Consumers: test_deeppot_a_fparam_aparam_{pt,ptexpt,nframes_ptexpt}.cc + # Consumers: api_cc/api_c test_deeppot_universal.cc and + # api_cc test_deeppot_a_fparam_aparam_nframes_ptexpt.cc # Note: test_deeppot_ptexpt.cc also loads fparam_aparam.pt2 but only for # JSON-metadata checks; it does not consume these reference values. ref_path = os.path.join(base_dir, "fparam_aparam.expected") From eca95587a62ae615bef211e76c8394c8e73d4d32 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 20 Jun 2026 00:54:23 +0800 Subject: [PATCH 05/11] test(api): consolidate deeppot variant tests --- source/api_cc/tests/test_deeppot_dpa1_pt.cc | 245 ------- .../api_cc/tests/test_deeppot_dpa1_ptexpt.cc | 262 -------- source/api_cc/tests/test_deeppot_dpa2_pt.cc | 325 ---------- .../api_cc/tests/test_deeppot_dpa2_ptexpt.cc | 537 ---------------- source/api_cc/tests/test_deeppot_dpa3_pt.cc | 244 ------- .../api_cc/tests/test_deeppot_dpa3_ptexpt.cc | 537 ---------------- .../api_cc/tests/test_deeppot_dpa4_ptexpt.cc | 537 ---------------- source/api_cc/tests/test_deeppot_dpa_jax.cc | 399 ------------ .../api_cc/tests/test_deeppot_dpa_ptexpt.cc | 527 --------------- .../tests/test_deeppot_dpa_ptexpt_spin.cc | 20 +- source/api_cc/tests/test_deeppot_r.cc | 601 ------------------ source/api_cc/tests/test_deeppot_universal.cc | 560 +++++++++++++++- .../tests/test_deepspin_model_devi_ptexpt.cc | 16 +- .../test_with_comm_load_failure_ptexpt.cc | 18 +- source/tests/infer/deeppot_universal_data.h | 159 +++++ 15 files changed, 738 insertions(+), 4249 deletions(-) delete mode 100644 source/api_cc/tests/test_deeppot_dpa1_pt.cc delete mode 100644 source/api_cc/tests/test_deeppot_dpa1_ptexpt.cc delete mode 100644 source/api_cc/tests/test_deeppot_dpa2_pt.cc delete mode 100644 source/api_cc/tests/test_deeppot_dpa2_ptexpt.cc delete mode 100644 source/api_cc/tests/test_deeppot_dpa3_pt.cc delete mode 100644 source/api_cc/tests/test_deeppot_dpa3_ptexpt.cc delete mode 100644 source/api_cc/tests/test_deeppot_dpa4_ptexpt.cc delete mode 100644 source/api_cc/tests/test_deeppot_dpa_jax.cc delete mode 100644 source/api_cc/tests/test_deeppot_dpa_ptexpt.cc delete mode 100644 source/api_cc/tests/test_deeppot_r.cc diff --git a/source/api_cc/tests/test_deeppot_dpa1_pt.cc b/source/api_cc/tests/test_deeppot_dpa1_pt.cc deleted file mode 100644 index 6fd24451e0..0000000000 --- a/source/api_cc/tests/test_deeppot_dpa1_pt.cc +++ /dev/null @@ -1,245 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C++ inference for PT (.pth) backend with DPA1 (mixed-type) model. -// Uses the same model weights as test_deeppot_dpa_ptexpt.cc (generated from -// dpmodel with type_one_side=True via gen_dpa1.py). -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-10 : 1e-4) - -namespace { -// Reference values come from source/tests/infer/deeppot_dpa1.expected, which -// gen_dpa1.py regenerates at CI time alongside the .pth/.pt2 model files. -constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa1.expected"; -constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa1.pth"; -} // namespace - -template -class TestInferDeepPotDpa1Pt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("pbc", "expected_e"); - expected_f = ref.get("pbc", "expected_f"); - expected_v = ref.get("pbc", "expected_v"); - - dp.init(kModelPath); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotDpa1Pt, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa1Pt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa1Pt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -template -class TestInferDeepPotDpa1PtNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("nopbc", "expected_e"); - expected_f = ref.get("nopbc", "expected_f"); - expected_v = ref.get("nopbc", "expected_v"); - - dp.init(kModelPath); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotDpa1PtNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa1PtNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa1PtNoPbc, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_dpa1_ptexpt.cc b/source/api_cc/tests/test_deeppot_dpa1_ptexpt.cc deleted file mode 100644 index d42f56b9d0..0000000000 --- a/source/api_cc/tests/test_deeppot_dpa1_ptexpt.cc +++ /dev/null @@ -1,262 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C++ inference for pt_expt (.pt2) backend with DPA1 (mixed-type) model. -// Uses the same model weights as test_deeppot_dpa1_pt.cc (generated from -// dpmodel with type_one_side=True via gen_dpa1.py). -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "DeepPotPTExpt.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-10 : 1e-4) - -namespace { -constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa1.expected"; -constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa1.pt2"; -} // namespace - -template -class TestInferDeepPotDpa1PtExpt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("pbc", "expected_e"); - expected_f = ref.get("pbc", "expected_f"); - expected_v = ref.get("pbc", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDpa1PtExpt::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDpa1PtExpt, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa1PtExpt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa1PtExpt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -template -class TestInferDeepPotDpa1PtExptNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("nopbc", "expected_e"); - expected_f = ref.get("nopbc", "expected_f"); - expected_v = ref.get("nopbc", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDpa1PtExptNoPbc::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDpa1PtExptNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa1PtExptNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa1PtExptNoPbc, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_dpa2_pt.cc b/source/api_cc/tests/test_deeppot_dpa2_pt.cc deleted file mode 100644 index 951d88e018..0000000000 --- a/source/api_cc/tests/test_deeppot_dpa2_pt.cc +++ /dev/null @@ -1,325 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C++ inference for PT (.pth) backend with DPA2 (mixed-type) model. -// Reference values generated by source/tests/infer/gen_dpa2.py. -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-10 : 1e-4) - -namespace { -// Reference values come from source/tests/infer/deeppot_dpa2.expected, which -// gen_dpa2.py regenerates at CI time alongside the .pth/.pt2 model files. -constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa2.expected"; -constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa2.pth"; -} // namespace - -template -class TestInferDeepPotDpa2Pt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("pbc", "expected_e"); - expected_f = ref.get("pbc", "expected_f"); - expected_v = ref.get("pbc", "expected_v"); - - dp.init(kModelPath); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotDpa2Pt, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa2Pt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2Pt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -template -class TestInferDeepPotDpa2PtNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("nopbc", "expected_e"); - expected_f = ref.get("nopbc", "expected_f"); - expected_v = ref.get("nopbc", "expected_v"); - - dp.init(kModelPath); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotDpa2PtNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa2PtNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2PtNoPbc, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2PtNoPbc, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2PtNoPbc, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box, 0, - inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_dpa2_ptexpt.cc b/source/api_cc/tests/test_deeppot_dpa2_ptexpt.cc deleted file mode 100644 index 5814f65f1b..0000000000 --- a/source/api_cc/tests/test_deeppot_dpa2_ptexpt.cc +++ /dev/null @@ -1,537 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C++ inference for pt_expt (.pt2) backend with DPA2 (mixed-type) model. -// Reference values generated by source/tests/infer/gen_dpa2.py. -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "DeepPotPTExpt.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -// DPA2 models need relaxed epsilon (same as test_deeppot_dpa2_pt.cc) -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-10 : 1e-4) - -namespace { -constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa2.expected"; -constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa2.pt2"; -} // namespace - -template -class TestInferDeepPotDpa2PtExpt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("pbc", "expected_e"); - expected_f = ref.get("pbc", "expected_f"); - expected_v = ref.get("pbc", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDpa2PtExpt::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDpa2PtExpt, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_build_nlist_numfv) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - deepmd::DeepPot& dp = this->dp; - class MyModel : public EnergyModelTest { - deepmd::DeepPot& mydp; - const std::vector atype; - - public: - MyModel(deepmd::DeepPot& dp_, const std::vector& atype_) - : mydp(dp_), atype(atype_) { - // DPA2 needs relaxed numfv tolerance (consistent with Python places=5) - this->level = std::is_same::value ? 1e-3 : 1e-1; - }; - virtual void compute(double& ener, - std::vector& force, - std::vector& virial, - const std::vector& coord, - const std::vector& box) { - mydp.compute(ener, force, virial, coord, atype, box); - } - }; - MyModel model(dp, atype); - model.test_f(coord, box); - model.test_v(coord, box); - std::vector box_(box); - box_[1] -= 0.4; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[2] += 0.5; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[4] += 0.2; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[3] -= 0.3; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[6] -= 0.7; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[7] += 0.6; - model.test_f(coord, box_); - model.test_v(coord, box_); -} - -TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - // DPA2 repformer uses mapping; pass it so the C++ backend can - // correctly map ghost atoms back to local atoms. - inlist.mapping = mapping.data(); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_lmp_nlist_type_sel) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2PtExpt, print_summary) { - deepmd::DeepPot& dp = this->dp; - dp.print_summary(""); -} - -// ---- NoPbc fixture (box = {}) ---- -template -class TestInferDeepPotDpa2PtExptNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("nopbc", "expected_e"); - expected_f = ref.get("nopbc", "expected_f"); - expected_v = ref.get("nopbc", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDpa2PtExptNoPbc::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDpa2PtExptNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa2PtExptNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa2PtExptNoPbc, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_dpa3_pt.cc b/source/api_cc/tests/test_deeppot_dpa3_pt.cc deleted file mode 100644 index 4457c5e1fb..0000000000 --- a/source/api_cc/tests/test_deeppot_dpa3_pt.cc +++ /dev/null @@ -1,244 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C++ inference for PT (.pth) backend with DPA3 (mixed-type) model. -// Reference values generated by source/tests/infer/gen_dpa3.py. -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-10 : 1e-4) - -namespace { -// Reference values come from source/tests/infer/deeppot_dpa3.expected, which -// gen_dpa3.py regenerates at CI time alongside the .pth/.pt2 model files. -constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa3.expected"; -constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa3.pth"; -} // namespace - -template -class TestInferDeepPotDpa3Pt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("pbc", "expected_e"); - expected_f = ref.get("pbc", "expected_f"); - expected_v = ref.get("pbc", "expected_v"); - - dp.init(kModelPath); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotDpa3Pt, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa3Pt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa3Pt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -template -class TestInferDeepPotDpa3PtNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_PYTORCH - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("nopbc", "expected_e"); - expected_f = ref.get("nopbc", "expected_f"); - expected_v = ref.get("nopbc", "expected_v"); - - dp.init(kModelPath); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotDpa3PtNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa3PtNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa3PtNoPbc, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_dpa3_ptexpt.cc b/source/api_cc/tests/test_deeppot_dpa3_ptexpt.cc deleted file mode 100644 index 66c9235613..0000000000 --- a/source/api_cc/tests/test_deeppot_dpa3_ptexpt.cc +++ /dev/null @@ -1,537 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C++ inference for pt_expt (.pt2) backend with DPA3 (mixed-type) model. -// Reference values generated by source/tests/infer/gen_dpa3.py. -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "DeepPotPTExpt.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -// DPA3 models need relaxed epsilon (same as test_deeppot_dpa3_pt.cc) -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-10 : 1e-4) - -namespace { -constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa3.expected"; -constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa3.pt2"; -} // namespace - -template -class TestInferDeepPotDpa3PtExpt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("pbc", "expected_e"); - expected_f = ref.get("pbc", "expected_f"); - expected_v = ref.get("pbc", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDpa3PtExpt::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDpa3PtExpt, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_build_nlist_numfv) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - deepmd::DeepPot& dp = this->dp; - class MyModel : public EnergyModelTest { - deepmd::DeepPot& mydp; - const std::vector atype; - - public: - MyModel(deepmd::DeepPot& dp_, const std::vector& atype_) - : mydp(dp_), atype(atype_) { - // DPA3 needs relaxed numfv tolerance (consistent with Python places=5) - this->level = std::is_same::value ? 1e-3 : 1e-1; - }; - virtual void compute(double& ener, - std::vector& force, - std::vector& virial, - const std::vector& coord, - const std::vector& box) { - mydp.compute(ener, force, virial, coord, atype, box); - } - }; - MyModel model(dp, atype); - model.test_f(coord, box); - model.test_v(coord, box); - std::vector box_(box); - box_[1] -= 0.4; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[2] += 0.5; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[4] += 0.2; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[3] -= 0.3; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[6] -= 0.7; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[7] += 0.6; - model.test_f(coord, box_); - model.test_v(coord, box_); -} - -TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - // DPA3 repflows uses mapping; pass it so the C++ backend can - // correctly map ghost atoms back to local atoms. - inlist.mapping = mapping.data(); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_lmp_nlist_type_sel) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir * 3; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa3PtExpt, print_summary) { - deepmd::DeepPot& dp = this->dp; - dp.print_summary(""); -} - -// ---- NoPbc fixture (box = {}) ---- -template -class TestInferDeepPotDpa3PtExptNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("nopbc", "expected_e"); - expected_f = ref.get("nopbc", "expected_f"); - expected_v = ref.get("nopbc", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDpa3PtExptNoPbc::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDpa3PtExptNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa3PtExptNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa3PtExptNoPbc, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_dpa4_ptexpt.cc b/source/api_cc/tests/test_deeppot_dpa4_ptexpt.cc deleted file mode 100644 index 77200c9508..0000000000 --- a/source/api_cc/tests/test_deeppot_dpa4_ptexpt.cc +++ /dev/null @@ -1,537 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C++ inference for pt_expt (.pt2) backend with DPA4 (mixed-type) model. -// Reference values generated by source/tests/infer/gen_dpa4.py. -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "DeepPotPTExpt.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -// DPA4 models need relaxed epsilon (same as test_deeppot_dpa3_ptexpt.cc) -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-10 : 1e-4) - -namespace { -constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa4.expected"; -constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa4.pt2"; -} // namespace - -template -class TestInferDeepPotDpa4PtExpt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("pbc", "expected_e"); - expected_f = ref.get("pbc", "expected_f"); - expected_v = ref.get("pbc", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDpa4PtExpt::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDpa4PtExpt, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_build_nlist_numfv) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - deepmd::DeepPot& dp = this->dp; - class MyModel : public EnergyModelTest { - deepmd::DeepPot& mydp; - const std::vector atype; - - public: - MyModel(deepmd::DeepPot& dp_, const std::vector& atype_) - : mydp(dp_), atype(atype_) { - // DPA4 needs relaxed numfv tolerance (consistent with Python places=5) - this->level = std::is_same::value ? 1e-3 : 1e-1; - }; - virtual void compute(double& ener, - std::vector& force, - std::vector& virial, - const std::vector& coord, - const std::vector& box) { - mydp.compute(ener, force, virial, coord, atype, box); - } - }; - MyModel model(dp, atype); - model.test_f(coord, box); - model.test_v(coord, box); - std::vector box_(box); - box_[1] -= 0.4; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[2] += 0.5; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[4] += 0.2; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[3] -= 0.3; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[6] -= 0.7; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[7] += 0.6; - model.test_f(coord, box_); - model.test_v(coord, box_); -} - -TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - // DPA4 is a message-passing descriptor; pass mapping so the C++ backend can - // correctly map ghost atoms back to local atoms. - inlist.mapping = mapping.data(); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_lmp_nlist_type_sel) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir * 3; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa4PtExpt, print_summary) { - deepmd::DeepPot& dp = this->dp; - dp.print_summary(""); -} - -// ---- NoPbc fixture (box = {}) ---- -template -class TestInferDeepPotDpa4PtExptNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("nopbc", "expected_e"); - expected_f = ref.get("nopbc", "expected_f"); - expected_v = ref.get("nopbc", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDpa4PtExptNoPbc::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDpa4PtExptNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpa4PtExptNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpa4PtExptNoPbc, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_dpa_jax.cc b/source/api_cc/tests/test_deeppot_dpa_jax.cc deleted file mode 100644 index 2e857450b7..0000000000 --- a/source/api_cc/tests/test_deeppot_dpa_jax.cc +++ /dev/null @@ -1,399 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "neighbor_list.h" -#include "test_utils.h" - -// 1e-10 cannot pass; unclear bug or not -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-7 : 1e-1) - -template -class TestInferDeepPotDpaJAX : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - // Generated by the following Python code: - // import numpy as np - // from deepmd.infer import DeepPot - // coord = np.array([ - // 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - // 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - // 3.51, 2.51, 2.60, 4.27, 3.22, 1.56 - // ]).reshape(1, -1) - // atype = np.array([0, 1, 1, 0, 1, 1]) - // box = np.array([13., 0., 0., 0., 13., 0., 0., 0., 13.]).reshape(1, -1) - // dp = DeepPot("deeppot_dpa.savedmodel") - // e, f, v, ae, av = dp.eval(coord, box, atype, atomic=True) - // np.set_printoptions(precision=16) - // print(f"{e.ravel()=} {v.ravel()=} {f.ravel()=} {ae.ravel()=} - // {av.ravel()=}") - - std::vector expected_e = {-94.24098099691867, -187.8049502787117, - -187.80486052083617, -94.24059525229518, - -187.80366985846246, -187.8042377490619}; - std::vector expected_f = { - -0.0020150115442053, -0.0133389255924977, -0.0014347177433057, - -0.0140757358179293, 0.0031373814221557, 0.0098594354314677, - 0.004755683505073, 0.0099471082374397, -0.0080868184532793, - -0.0086166721574536, 0.0037803939137322, -0.0075733131286482, - 0.0037437603038209, -0.008452527996008, 0.0134837461840424, - 0.0162079757106944, 0.0049265700151781, -0.0062483322902769}; - std::vector expected_v = { - 0.0133534319524089, 0.0013445914938337, -0.0029370551651952, - 0.0002611806151294, 0.004662662211533, -0.0002717443796319, - -0.0027779798869954, -0.0003277976466339, 0.0018284972283065, - 0.0085710118978246, 0.0003865036653608, -0.0057964032875089, - -0.0014358330222619, 0.0002912625128908, 0.001212630641674, - -0.0050582608957046, -0.0001087907763249, 0.0040068757134429, - 0.0116736349373084, 0.0007055477968445, -0.0019544933708784, - 0.0032997459258512, 0.0037887116116712, -0.0043140890650835, - -0.0034418738401156, -0.0029420616852742, 0.0038219676716965, - 0.0147134944025738, 0.0005214313829998, -0.0006524136175906, - 0.0003656980996363, 0.0010046161607714, -0.0017279359476254, - 0.000111127036911, -0.0017063190420654, 0.0030174567965904, - 0.0104435705455107, -0.0008704394438241, 0.0012354202650812, - 0.0009397615830053, 0.0029105236407293, -0.0044188897903449, - -0.0011461513500477, -0.0045759080125852, 0.0070310883421107, - 0.0089818851995049, 0.0038819466696704, -0.005443705549253, - 0.0025390283635246, 0.0012121502955869, -0.0016998728971157, - -0.0032355117893925, -0.0015590242752438, 0.0021980725909838}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_JAX - GTEST_SKIP() << "Skip because JAX support is not enabled."; -#endif - dp.init("../../tests/infer/deeppot_dpa.savedmodel"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotDpaJAX, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpaJAX, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaJAX, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -template -class TestInferDeepPotDpaJAXNopbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - // Generated by the following Python code: - // import numpy as np - // from deepmd.infer import DeepPot - // coord = np.array([ - // 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - // 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - // 3.51, 2.51, 2.60, 4.27, 3.22, 1.56 - // ]).reshape(1, -1) - // atype = np.array([0, 1, 1, 0, 1, 1]) - // box = None - // dp = DeepPot("deeppot_dpa.savedmodel") - // e, f, v, ae, av = dp.eval(coord, box, atype, atomic=True) - // np.set_printoptions(precision=16) - // print(f"{e.ravel()=} {v.ravel()=} {f.ravel()=} {ae.ravel()=} - // {av.ravel()=}") - - std::vector expected_e = { - -94.24457967995595, -187.81100287606412, -187.81417300904738, - -94.24110552426328, -187.80431436838532, -187.80457222464983}; - std::vector expected_f = { - 0.0051417559595313, -0.0021539788479118, -0.0038910585639696, - -0.0051417559595313, 0.0021539788479118, 0.0038910585639696, - -0.0035470615733886, 0.0003602503965239, -0.0001895679272905, - -0.0117361352793328, 0.0034252835112125, -0.0071824017939095, - 0.0005398894945495, -0.0084330745423862, 0.013284532676939, - 0.0147433073581718, 0.0046475406346498, -0.005912562955739}; - std::vector expected_v = { - 1.8756488030620411e-03, -7.8574476885035112e-04, -1.4194099050199721e-03, - -7.8574476885031816e-04, 3.2916334911298369e-04, 5.9461766291377029e-04, - -1.4194099050199305e-03, 5.9461766291377637e-04, 1.0741480362313257e-03, - 1.9292506069911106e-03, -8.0819957860435269e-04, -1.4599734323175548e-03, - -8.0819957860438912e-04, 3.3857009373966171e-04, 6.1161049191681572e-04, - -1.4599734323175878e-03, 6.1161049191681138e-04, 1.1048447595916697e-03, - 7.6085550162737362e-03, -9.6772620145935649e-04, 8.3466357433496438e-04, - -6.0870001592646837e-04, 7.8216372819095133e-05, -6.6454748650881927e-05, - 1.6484218595781155e-04, -1.4860654308892986e-05, 9.1346879754941710e-06, - 7.3496442591020616e-03, -4.4351638231197171e-04, 1.0048648094020743e-03, - -6.7678341212752506e-04, 1.0347359647873023e-03, -1.6645682233463639e-03, - 1.4376416549492857e-03, -1.7116654329527997e-03, 2.8516307661164836e-03, - 1.7683913600324828e-03, -2.6945055858769765e-04, 3.0381043714224000e-04, - 9.9317892494769217e-04, 2.9343081937224687e-03, -4.4381349285303948e-03, - -1.6684804850477311e-03, -4.5760063242183471e-03, 6.9407432349694147e-03, - 7.8021639779489171e-03, 3.5246152053432442e-03, -4.9415349551876243e-03, - 2.1362265660905197e-03, 1.2226850609509659e-03, -1.7016886981679963e-03, - -2.7321994901677166e-03, -1.5683141872155984e-03, 2.1960566952029213e-03}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_JAX - GTEST_SKIP() << "Skip because JAX support is not enabled."; -#endif - dp.init("../../tests/infer/deeppot_dpa.savedmodel"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; -}; - -TYPED_TEST_SUITE(TestInferDeepPotDpaJAXNopbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpaJAXNopbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaJAXNopbc, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaJAXNopbc, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaJAXNopbc, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box, 0, - inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_dpa_ptexpt.cc b/source/api_cc/tests/test_deeppot_dpa_ptexpt.cc deleted file mode 100644 index 4a1b0d45df..0000000000 --- a/source/api_cc/tests/test_deeppot_dpa_ptexpt.cc +++ /dev/null @@ -1,527 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Test C++ inference for pt_expt (.pt2) backend with DPA1 (mixed-type) model. -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "DeepPotPTExpt.h" -#include "expected_ref.h" -#include "neighbor_list.h" -#include "test_utils.h" - -// DPA1 models need relaxed epsilon (same as test_deeppot_dpa_pt.cc) -#undef EPSILON -#define EPSILON (std::is_same::value ? 1e-10 : 1e-4) - -namespace { -constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa1.expected"; -constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa1.pt2"; -} // namespace - -template -class TestInferDeepPotDpaPtExpt : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("pbc", "expected_e"); - expected_f = ref.get("pbc", "expected_f"); - expected_v = ref.get("pbc", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDpaPtExpt::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDpaPtExpt, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_build_nlist_numfv) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - deepmd::DeepPot& dp = this->dp; - class MyModel : public EnergyModelTest { - deepmd::DeepPot& mydp; - const std::vector atype; - - public: - MyModel(deepmd::DeepPot& dp_, const std::vector& atype_) - : mydp(dp_), atype(atype_) {}; - virtual void compute(double& ener, - std::vector& force, - std::vector& virial, - const std::vector& coord, - const std::vector& box) { - mydp.compute(ener, force, virial, coord, atype, box); - } - }; - MyModel model(dp, atype); - model.test_f(coord, box); - model.test_v(coord, box); - std::vector box_(box); - box_[1] -= 0.4; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[2] += 0.5; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[4] += 0.2; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[3] -= 0.3; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[6] -= 0.7; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[7] += 0.6; - model.test_f(coord, box_); - model.test_v(coord, box_); -} - -TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_lmp_nlist_type_sel) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir * 3; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaPtExpt, print_summary) { - deepmd::DeepPot& dp = this->dp; - dp.print_summary(""); -} - -// ---- NoPbc fixture (box = {}) ---- -template -class TestInferDeepPotDpaPtExptNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e; - std::vector expected_f; - std::vector expected_v; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - static deepmd::DeepPot dp; - - static void SetUpTestSuite() { -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - dp.init(kModelPath); -#endif - } - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif - deepmd_test::ExpectedRef ref; - ref.load(kRefPath); - expected_e = ref.get("nopbc", "expected_e"); - expected_f = ref.get("nopbc", "expected_f"); - expected_v = ref.get("nopbc", "expected_v"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.assign(9, 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override {}; - - static void TearDownTestSuite() { dp = deepmd::DeepPot(); } -}; - -template -deepmd::DeepPot TestInferDeepPotDpaPtExptNoPbc::dp; - -TYPED_TEST_SUITE(TestInferDeepPotDpaPtExptNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotDpaPtExptNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotDpaPtExptNoPbc, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_f = this->expected_f; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - - std::vector > nlist_data = { - {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5}, - {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_dpa_ptexpt_spin.cc b/source/api_cc/tests/test_deeppot_dpa_ptexpt_spin.cc index a356151c76..dc43cb3719 100644 --- a/source/api_cc/tests/test_deeppot_dpa_ptexpt_spin.cc +++ b/source/api_cc/tests/test_deeppot_dpa_ptexpt_spin.cc @@ -51,17 +51,12 @@ class TestInferDeepSpinDpaPtExpt : public ::testing::Test { deepmd::DeepSpin dp; void SetUp() override { - // The .pt2 spin model requires the BUILD_PT_EXPT guard from the header. - // If AOTInductor headers are missing, skip. - { - std::ifstream f(kModelPath); - if (!f.good()) { - GTEST_SKIP() << "Skipping: " << kModelPath << " not found."; - } - } #if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT_SPIN GTEST_SKIP() << "Skip because PyTorch support is not enabled."; #endif + std::ifstream model_file(kModelPath); + ASSERT_TRUE(model_file.good()) + << "Model artifact is not available: " << kModelPath; dp.init(kModelPath); deepmd_test::ExpectedRef ref; @@ -205,15 +200,12 @@ class TestInferDeepSpinDpaPtExptNopbc : public ::testing::Test { deepmd::DeepSpin dp; void SetUp() override { - { - std::ifstream f(kModelPath); - if (!f.good()) { - GTEST_SKIP() << "Skipping: " << kModelPath << " not found."; - } - } #if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT_SPIN GTEST_SKIP() << "Skip because PyTorch support is not enabled."; #endif + std::ifstream model_file(kModelPath); + ASSERT_TRUE(model_file.good()) + << "Model artifact is not available: " << kModelPath; dp.init(kModelPath); deepmd_test::ExpectedRef ref; diff --git a/source/api_cc/tests/test_deeppot_r.cc b/source/api_cc/tests/test_deeppot_r.cc deleted file mode 100644 index 99c5eca6e5..0000000000 --- a/source/api_cc/tests/test_deeppot_r.cc +++ /dev/null @@ -1,601 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "DeepPot.h" -#include "neighbor_list.h" -#include "test_utils.h" - -template -class TestInferDeepPotR : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - std::vector expected_e = { - -9.320909762801588272e+01, -1.868020345400987878e+02, - -1.868011172371355997e+02, -9.320868430396934912e+01, - -1.868010398844378415e+02, -1.868016706555875999e+02}; - std::vector expected_f = { - 6.385312846474267391e-04, -6.460452911141417731e-03, - -5.652405655332678417e-04, -7.516468794343579736e-03, - 1.128804614240160216e-03, 5.531937784564192051e-03, - 1.914138124904981664e-03, 5.601819906021693503e-03, - -5.131359585752605541e-03, -4.847104424804288617e-03, - 1.992071550328819614e-03, -4.028159855157302516e-03, - 1.236340684486603517e-03, -5.373955841338794344e-03, - 8.312829460571366513e-03, 8.574563125108854156e-03, - 3.111712681889538742e-03, -4.120007238692381148e-03}; - std::vector expected_v = { - 5.844056241889131371e-03, 4.663973497239899614e-04, - -2.268382127762904633e-03, 4.663973497239897988e-04, - 2.349338784202595950e-03, -6.908546513234039253e-04, - -2.268382127762904633e-03, -6.908546513234039253e-04, - 2.040499248150800561e-03, 4.238130266437327605e-03, - -1.539867187443782223e-04, -2.393101333240631613e-03, - -1.539867187443782223e-04, 4.410341945447907377e-04, - 9.544239698119633068e-06, -2.393101333240631613e-03, - 9.544239698119578858e-06, 1.877785959095269654e-03, - 5.798992562057291543e-03, 6.943392552230453693e-04, - -1.180376879311998773e-03, 6.943392552230453693e-04, - 1.686725132156275536e-03, -1.461632060145726542e-03, - -1.180376879311998556e-03, -1.461632060145726325e-03, - 1.749543733794208444e-03, 7.173915604192910439e-03, - 3.903218041111061569e-04, -5.747400467123527524e-04, - 3.903218041111061569e-04, 1.208289706621179949e-03, - -1.826828914132010932e-03, -5.747400467123527524e-04, - -1.826828914132011148e-03, 2.856960586657185906e-03, - 4.067553030177322240e-03, -3.267469855253819430e-05, - -6.980667859103454904e-05, -3.267469855253830272e-05, - 1.387653029234650918e-03, -2.096820720698671855e-03, - -6.980667859103444062e-05, -2.096820720698671855e-03, - 3.218305506720191278e-03, 4.753992590355240674e-03, - 1.224911338353675992e-03, -1.683421934571502484e-03, - 1.224911338353676209e-03, 7.332113564901583539e-04, - -1.025577052190138451e-03, -1.683421934571502484e-03, - -1.025577052190138234e-03, 1.456681925652047018e-03}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_TENSORFLOW - GTEST_SKIP() << "Skip because TensorFlow support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot-r.pbtxt"; - deepmd::convert_pbtxt_to_pb("../../tests/infer/deeppot-r.pbtxt", - "deeppot.pb"); - - dp.init("deeppot.pb"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { remove("deeppot.pb"); }; -}; - -TYPED_TEST_SUITE(TestInferDeepPotR, ValueTypes); - -TYPED_TEST(TestInferDeepPotR, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotR, cpu_build_nlist_numfv) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - class MyModel : public EnergyModelTest { - deepmd::DeepPot& mydp; - const std::vector& atype; - - public: - MyModel(deepmd::DeepPot& dp_, const std::vector& atype_) - : mydp(dp_), atype(atype_) {}; - virtual void compute(double& ener, - std::vector& force, - std::vector& virial, - const std::vector& coord, - const std::vector& box) { - mydp.compute(ener, force, virial, coord, atype, box); - } - }; - MyModel model(dp, atype); - model.test_f(coord, box); - model.test_v(coord, box); - std::vector box_(box); - box_[1] -= 0.4; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[2] += 0.5; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[4] += 0.2; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[3] -= 0.3; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[6] -= 0.7; - model.test_f(coord, box_); - model.test_v(coord, box_); - box_[7] += 0.6; - model.test_f(coord, box_); - model.test_v(coord, box_); -} - -TYPED_TEST(TestInferDeepPotR, cpu_build_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial, atom_ener, atom_vir; - dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotR, cpu_lmp_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, virial; - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotR, cpu_lmp_nlist_atomic) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 0); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0); - std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0); - dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy, - box, nall - nloc, inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - _fold_back(atom_ener, atom_ener_, mapping, nloc, nall, 1); - _fold_back(atom_vir, atom_vir_, mapping, nloc, nall, 9); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - EXPECT_EQ(atom_ener.size(), natoms); - EXPECT_EQ(atom_vir.size(), natoms * 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - for (int ii = 0; ii < natoms; ++ii) { - EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON); - } - for (int ii = 0; ii < natoms * 9; ++ii) { - EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotR, cpu_lmp_nlist_2rc) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc * 2); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } - - ener = 0.; - std::fill(force_.begin(), force_.end(), 0.0); - std::fill(virial.begin(), virial.end(), 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 1); - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -TYPED_TEST(TestInferDeepPotR, cpu_lmp_nlist_type_sel) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - float rc = dp.cutoff(); - - // add vir atoms - int nvir = 2; - std::vector coord_vir(nvir * 3); - std::vector atype_vir(nvir, 2); - for (int ii = 0; ii < nvir; ++ii) { - coord_vir[ii] = coord[ii]; - } - coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end()); - atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end()); - natoms += nvir; - std::vector expected_f_vir(nvir * 3, 0.0); - expected_f.insert(expected_f.begin(), expected_f_vir.begin(), - expected_f_vir.end()); - - // build nlist - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector > nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, - atype, box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); - convert_nlist(inlist, nlist_data); - - // dp compute - double ener; - std::vector force_(nall * 3, 0.0), virial(9, 0.0); - dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc, - inlist, 0); - // fold back - std::vector force; - _fold_back(force, force_, mapping, nloc, nall, 3); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} - -template -class TestInferDeepPotRNoPbc : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {}; - std::vector expected_e = { - -9.321213823508108476e+01, -1.868044102481340758e+02, - -1.868067983858651075e+02, -9.320899631301440991e+01, - -1.868014559732615112e+02, -1.868017660713088617e+02}; - std::vector expected_f = { - 4.578151103701261042e-03, -1.917874111009987628e-03, - -3.464546781179331930e-03, -4.578151103701261042e-03, - 1.917874111009987628e-03, 3.464546781179331930e-03, - -2.624402581721222913e-03, 3.566275128489623933e-04, - -2.859315986763691776e-04, -5.767787273464367384e-03, - 1.907053583551196647e-03, -3.889064429673861831e-03, - 1.786820066350549132e-04, -5.327197473636275694e-03, - 8.236236182834734409e-03, 8.213507848550535492e-03, - 3.063516377236116545e-03, -4.061240154484504865e-03}; - std::vector expected_v = { - 1.984979026299632174e-03, -8.315452677741701822e-04, - -1.502146290172694243e-03, -8.315452677741700738e-04, - 3.483500446080982317e-04, 6.292774999372096039e-04, - -1.502146290172694243e-03, 6.292774999372097123e-04, - 1.136759354725281907e-03, 1.402852790439301908e-03, - -5.876815743732210226e-04, -1.061618327900012114e-03, - -5.876815743732211311e-04, 2.461909298049979960e-04, - 4.447320022283834766e-04, -1.061618327900012331e-03, - 4.447320022283834766e-04, 8.033868427351443728e-04, - 4.143606961846296385e-03, -5.511382161123719835e-04, - 4.465413399437045397e-04, -5.511382161123719835e-04, - 1.082271054025323839e-04, -1.097918001262628728e-04, - 4.465413399437046481e-04, -1.097918001262628728e-04, - 1.220966982358671871e-04, 5.263952004497593831e-03, - 2.395243710938091842e-04, -2.830378939414603329e-04, - 2.395243710938094010e-04, 1.189969706598244898e-03, - -1.805627331015851201e-03, -2.830378939414602245e-04, - -1.805627331015851635e-03, 2.801996513751836820e-03, - 2.208413501170402270e-03, 5.331756287635716889e-05, - -1.664423506603235218e-04, 5.331756287635695205e-05, - 1.379626072862918072e-03, -2.094132943741625064e-03, - -1.664423506603234133e-04, -2.094132943741625064e-03, - 3.199787996743366607e-03, 4.047014004814953811e-03, - 1.137904999421357000e-03, -1.568106936614101698e-03, - 1.137904999421357217e-03, 7.205982843216952307e-04, - -1.011174600268313238e-03, -1.568106936614101698e-03, - -1.011174600268313238e-03, 1.435226522157425754e-03}; - int natoms; - double expected_tot_e; - std::vector expected_tot_v; - - deepmd::DeepPot dp; - - void SetUp() override { -#ifndef BUILD_TENSORFLOW - GTEST_SKIP() << "Skip because TensorFlow support is not enabled."; -#endif - std::string file_name = "../../tests/infer/deeppot-r.pbtxt"; - deepmd::convert_pbtxt_to_pb("../../tests/infer/deeppot-r.pbtxt", - "deeppot.pb"); - - dp.init("deeppot.pb"); - - natoms = expected_e.size(); - EXPECT_EQ(natoms * 3, expected_f.size()); - EXPECT_EQ(natoms * 9, expected_v.size()); - expected_tot_e = 0.; - expected_tot_v.resize(9); - std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.); - for (int ii = 0; ii < natoms; ++ii) { - expected_tot_e += expected_e[ii]; - } - for (int ii = 0; ii < natoms; ++ii) { - for (int dd = 0; dd < 9; ++dd) { - expected_tot_v[dd] += expected_v[ii * 9 + dd]; - } - } - }; - - void TearDown() override { remove("deeppot.pb"); }; -}; - -TYPED_TEST_SUITE(TestInferDeepPotRNoPbc, ValueTypes); - -TYPED_TEST(TestInferDeepPotRNoPbc, cpu_build_nlist) { - using VALUETYPE = TypeParam; - std::vector& coord = this->coord; - std::vector& atype = this->atype; - std::vector& box = this->box; - std::vector& expected_e = this->expected_e; - std::vector& expected_f = this->expected_f; - std::vector& expected_v = this->expected_v; - int& natoms = this->natoms; - double& expected_tot_e = this->expected_tot_e; - std::vector& expected_tot_v = this->expected_tot_v; - deepmd::DeepPot& dp = this->dp; - double ener; - std::vector force, virial; - dp.compute(ener, force, virial, coord, atype, box); - - EXPECT_EQ(force.size(), natoms * 3); - EXPECT_EQ(virial.size(), 9); - - EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); - for (int ii = 0; ii < natoms * 3; ++ii) { - EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON); - } - for (int ii = 0; ii < 3 * 3; ++ii) { - EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); - } -} diff --git a/source/api_cc/tests/test_deeppot_universal.cc b/source/api_cc/tests/test_deeppot_universal.cc index 967006375b..626345301a 100644 --- a/source/api_cc/tests/test_deeppot_universal.cc +++ b/source/api_cc/tests/test_deeppot_universal.cc @@ -32,6 +32,31 @@ struct ModelCase { bool supports_nframes; }; +struct VariantDeepPotCase { + std::string name; + Backend backend; + std::string model_path; + bool convert_pbtxt; + const deepmd_test::DeepPotRef* builtin_ref; + const deepmd_test::DeepPotRef* builtin_no_pbc_ref; + std::string ref_path; + std::string ref_section; + std::string no_pbc_ref_section; + double double_tol; + double float_tol; + bool supports_float; + bool supports_finite_difference; + bool supports_lmp_nlist; + bool supports_lmp_nlist_atomic; + bool supports_lmp_nlist_cutoff_twice; + bool supports_lmp_nlist_type_sel; + bool supports_print_summary; + bool supports_no_pbc_simple; + bool supports_no_pbc_atomic; + bool supports_no_pbc_lmp_nlist; + bool supports_no_pbc_lmp_nlist_atomic; +}; + struct FParamAParamCase { std::string name; Backend backend; @@ -130,6 +155,207 @@ std::vector model_cases() { false}}; } +std::vector variant_deeppot_cases() { + return {{"tensorflow_r", + Backend::TensorFlow, + "../../tests/infer/deeppot-r.pbtxt", + true, + &deepmd_test::tf_deeppot_r_ref(), + &deepmd_test::tf_deeppot_r_no_pbc_ref(), + "", + "", + "", + 1e-10, + 1e-4, + true, + true, + true, + true, + true, + true, + false, + true, + false, + false, + false}, + {"dpa_jax_savedmodel", + Backend::JAX, + "../../tests/infer/deeppot_dpa.savedmodel", + false, + &deepmd_test::jax_dpa_deeppot_ref(), + &deepmd_test::jax_dpa_deeppot_no_pbc_ref(), + "", + "", + "", + 1e-7, + 1e-1, + true, + false, + false, + false, + false, + false, + false, + true, + true, + true, + true}, + {"dpa1_pytorch_pth", + Backend::PyTorch, + "../../tests/infer/deeppot_dpa1.pth", + false, + nullptr, + nullptr, + "../../tests/infer/deeppot_dpa1.expected", + "pbc", + "nopbc", + 1e-10, + 1e-4, + true, + false, + false, + false, + false, + false, + false, + true, + false, + true, + false}, + {"dpa1_pytorch_pt2", + Backend::PTExpt, + "../../tests/infer/deeppot_dpa1.pt2", + false, + nullptr, + nullptr, + "../../tests/infer/deeppot_dpa1.expected", + "pbc", + "nopbc", + 1e-10, + 1e-4, + true, + true, + true, + true, + true, + true, + true, + true, + false, + true, + false}, + {"dpa2_pytorch_pth", + Backend::PyTorch, + "../../tests/infer/deeppot_dpa2.pth", + false, + nullptr, + nullptr, + "../../tests/infer/deeppot_dpa2.expected", + "pbc", + "nopbc", + 1e-10, + 1e-4, + true, + false, + false, + false, + false, + false, + false, + true, + true, + true, + true}, + {"dpa2_pytorch_pt2", + Backend::PTExpt, + "../../tests/infer/deeppot_dpa2.pt2", + false, + nullptr, + nullptr, + "../../tests/infer/deeppot_dpa2.expected", + "pbc", + "nopbc", + 1e-10, + 1e-4, + true, + true, + true, + true, + true, + true, + true, + true, + false, + true, + false}, + {"dpa3_pytorch_pth", + Backend::PyTorch, + "../../tests/infer/deeppot_dpa3.pth", + false, + nullptr, + nullptr, + "../../tests/infer/deeppot_dpa3.expected", + "pbc", + "nopbc", + 1e-10, + 1e-4, + true, + false, + false, + false, + false, + false, + false, + true, + false, + true, + false}, + {"dpa3_pytorch_pt2", + Backend::PTExpt, + "../../tests/infer/deeppot_dpa3.pt2", + false, + nullptr, + nullptr, + "../../tests/infer/deeppot_dpa3.expected", + "pbc", + "nopbc", + 1e-10, + 1e-4, + true, + true, + true, + true, + true, + true, + true, + true, + false, + true, + false}, + {"dpa4_pytorch_pt2", + Backend::PTExpt, + "../../tests/infer/deeppot_dpa4.pt2", + false, + nullptr, + nullptr, + "../../tests/infer/deeppot_dpa4.expected", + "pbc", + "nopbc", + 1e-10, + 1e-4, + true, + true, + true, + true, + true, + true, + true, + true, + false, + true, + false}}; +} + std::vector fparam_aparam_cases() { return {{"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/fparam_aparam.pbtxt", true, @@ -166,6 +392,17 @@ deepmd_test::DeepPotRef load_fparam_ref(const std::string& ref_path) { return ref; } +deepmd_test::DeepPotRef load_expected_ref(const std::string& ref_path, + const std::string& section) { + deepmd_test::ExpectedRef ref_file; + ref_file.load(ref_path); + deepmd_test::DeepPotRef ref; + ref.atomic_energy = ref_file.get(section, "expected_e"); + ref.force = ref_file.get(section, "expected_f"); + ref.atomic_virial = ref_file.get(section, "expected_v"); + return ref; +} + class UniversalDeepPotTest : public ::testing::TestWithParam { protected: deepmd::DeepPot dp; @@ -195,6 +432,64 @@ class UniversalDeepPotTest : public ::testing::TestWithParam { } }; +class VariantDeepPotTest : public ::testing::TestWithParam { + protected: + deepmd::DeepPot dp; + std::string converted_model; + deepmd_test::DeepPotRef loaded_ref; + deepmd_test::DeepPotRef loaded_no_pbc_ref; + const deepmd_test::DeepPotRef* ref = nullptr; + const deepmd_test::DeepPotRef* no_pbc_ref = nullptr; + + void SetUp() override { + const auto& param = GetParam(); + if (!backend_enabled(param.backend)) { + GTEST_SKIP() << backend_name(param.backend) << " support is not enabled."; + } + ASSERT_TRUE(path_exists(param.model_path)) + << "Model artifact is not available: " << param.model_path; + + if (param.builtin_ref != nullptr) { + ref = param.builtin_ref; + } else { + ASSERT_TRUE(path_exists(param.ref_path)) + << "Reference artifact is not available: " << param.ref_path; + loaded_ref = load_expected_ref(param.ref_path, param.ref_section); + ref = &loaded_ref; + } + + const bool needs_no_pbc_ref = param.supports_no_pbc_simple || + param.supports_no_pbc_atomic || + param.supports_no_pbc_lmp_nlist || + param.supports_no_pbc_lmp_nlist_atomic; + if (needs_no_pbc_ref) { + if (param.builtin_no_pbc_ref != nullptr) { + no_pbc_ref = param.builtin_no_pbc_ref; + } else { + ASSERT_TRUE(path_exists(param.ref_path)) + << "Reference artifact is not available: " << param.ref_path; + loaded_no_pbc_ref = + load_expected_ref(param.ref_path, param.no_pbc_ref_section); + no_pbc_ref = &loaded_no_pbc_ref; + } + } + + std::string model_path = param.model_path; + if (param.convert_pbtxt) { + converted_model = "deeppot_variant_" + param.name + ".pb"; + deepmd::convert_pbtxt_to_pb(param.model_path, converted_model); + model_path = converted_model; + } + dp.init(model_path); + } + + void TearDown() override { + if (!converted_model.empty()) { + remove(converted_model.c_str()); + } + } +}; + class FParamAParamDeepPotTest : public ::testing::TestWithParam { protected: @@ -277,11 +572,13 @@ void expect_reference(const double energy, const std::vector& virial, const deepmd_test::DeepPotRef& ref, const double tol) { - const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const int natoms = static_cast(ref.atomic_energy.size()); const std::vector expected_virial = deepmd_test::total_virial(ref); ASSERT_EQ(force.size(), static_cast(natoms * 3)); ASSERT_EQ(virial.size(), 9U); + ASSERT_EQ(ref.force.size(), static_cast(natoms * 3)); + ASSERT_EQ(ref.atomic_virial.size(), static_cast(natoms * 9)); EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol); for (int ii = 0; ii < natoms * 3; ++ii) { @@ -300,7 +597,7 @@ void expect_atomic_reference(const double energy, const std::vector& atomic_virial, const deepmd_test::DeepPotRef& ref, const double tol) { - const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const int natoms = static_cast(ref.atomic_energy.size()); expect_reference(energy, force, virial, ref, tol); ASSERT_EQ(atomic_energy.size(), static_cast(natoms)); @@ -490,6 +787,52 @@ void check_lmp_nlist_atomic(deepmd::DeepPot& dp, } } +std::vector> make_full_nlist_data(const int natoms) { + std::vector> nlist_data(natoms); + for (int ii = 0; ii < natoms; ++ii) { + nlist_data[ii].reserve(natoms - 1); + for (int jj = 0; jj < natoms; ++jj) { + if (ii != jj) { + nlist_data[ii].push_back(jj); + } + } + } + return nlist_data; +} + +template +void check_no_pbc_lmp_nlist(deepmd::DeepPot& dp, + const deepmd_test::DeepPotRef& ref, + const double tol, + const bool atomic) { + const int natoms = static_cast(deepmd_test::deeppot_atype().size()); + const std::vector coord(deepmd_test::deeppot_coord().begin(), + deepmd_test::deeppot_coord().end()); + const std::vector atype = deepmd_test::deeppot_atype(); + const std::vector box; + std::vector> nlist_data = make_full_nlist_data(natoms); + std::vector ilist(natoms), numneigh(natoms); + std::vector firstneigh(natoms); + deepmd::InputNlist inlist(natoms, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + + double energy = 0.0; + std::vector force; + std::vector virial; + if (atomic) { + std::vector atomic_energy; + std::vector atomic_virial; + dp.compute(energy, force, virial, atomic_energy, atomic_virial, coord, + atype, box, 0, inlist, 0); + expect_atomic_reference(energy, force, virial, atomic_energy, atomic_virial, + ref, tol); + } else { + dp.compute(energy, force, virial, coord, atype, box, 0, inlist, 0); + expect_reference(energy, force, virial, ref, tol); + } +} + template void check_lmp_nlist_type_sel(deepmd::DeepPot& dp, const deepmd_test::DeepPotRef& ref, @@ -1235,6 +1578,211 @@ TEST_P(UniversalDeepPotTest, NFramesComputeNoPbcFloat) { GetParam().float_tol, 2, false); } +TEST_P(VariantDeepPotTest, ComputeDouble) { + check_compute_atomic(dp, *ref, GetParam().double_tol); +} + +TEST_P(VariantDeepPotTest, ComputeFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_compute_atomic(dp, *ref, GetParam().float_tol); +} + +TEST_P(VariantDeepPotTest, ComputeSimpleDouble) { + check_compute_simple(dp, *ref, GetParam().double_tol); +} + +TEST_P(VariantDeepPotTest, ComputeSimpleFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + check_compute_simple(dp, *ref, GetParam().float_tol); +} + +TEST_P(VariantDeepPotTest, FiniteDifferenceDouble) { + if (!GetParam().supports_finite_difference) { + GTEST_SKIP() << GetParam().name + << " finite-difference coverage is not enabled."; + } + check_finite_difference(dp); +} + +TEST_P(VariantDeepPotTest, FiniteDifferenceFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_finite_difference) { + GTEST_SKIP() << GetParam().name + << " finite-difference coverage is not enabled."; + } + check_finite_difference(dp); +} + +TEST_P(VariantDeepPotTest, LmpNlistDouble) { + if (!GetParam().supports_lmp_nlist) { + GTEST_SKIP() << GetParam().name << " LAMMPS nlist coverage is not enabled."; + } + check_lmp_nlist(dp, *ref, GetParam().double_tol); +} + +TEST_P(VariantDeepPotTest, LmpNlistFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_lmp_nlist) { + GTEST_SKIP() << GetParam().name << " LAMMPS nlist coverage is not enabled."; + } + check_lmp_nlist(dp, *ref, GetParam().float_tol); +} + +TEST_P(VariantDeepPotTest, LmpNlistAtomicDouble) { + if (!GetParam().supports_lmp_nlist_atomic) { + GTEST_SKIP() << GetParam().name + << " atomic LAMMPS nlist coverage is not enabled."; + } + check_lmp_nlist_atomic(dp, *ref, GetParam().double_tol); +} + +TEST_P(VariantDeepPotTest, LmpNlistAtomicFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_lmp_nlist_atomic) { + GTEST_SKIP() << GetParam().name + << " atomic LAMMPS nlist coverage is not enabled."; + } + check_lmp_nlist_atomic(dp, *ref, GetParam().float_tol); +} + +TEST_P(VariantDeepPotTest, LmpNlistDoubleCutoffTwice) { + if (!GetParam().supports_lmp_nlist_cutoff_twice) { + GTEST_SKIP() << GetParam().name + << " doubled-cutoff LAMMPS nlist coverage is not enabled."; + } + check_lmp_nlist(dp, *ref, GetParam().double_tol, 2.0); +} + +TEST_P(VariantDeepPotTest, LmpNlistFloatCutoffTwice) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_lmp_nlist_cutoff_twice) { + GTEST_SKIP() << GetParam().name + << " doubled-cutoff LAMMPS nlist coverage is not enabled."; + } + check_lmp_nlist(dp, *ref, GetParam().float_tol, 2.0); +} + +TEST_P(VariantDeepPotTest, LmpNlistTypeSelDouble) { + if (!GetParam().supports_lmp_nlist_type_sel) { + GTEST_SKIP() << GetParam().name + << " type-selected LAMMPS nlist coverage is not enabled."; + } + check_lmp_nlist_type_sel(dp, *ref, GetParam().double_tol, false); +} + +TEST_P(VariantDeepPotTest, LmpNlistTypeSelFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_lmp_nlist_type_sel) { + GTEST_SKIP() << GetParam().name + << " type-selected LAMMPS nlist coverage is not enabled."; + } + check_lmp_nlist_type_sel(dp, *ref, GetParam().float_tol, false); +} + +TEST_P(VariantDeepPotTest, PrintSummary) { + if (!GetParam().supports_print_summary) { + GTEST_SKIP() << GetParam().name << " summary coverage is not enabled."; + } + dp.print_summary(""); +} + +TEST_P(VariantDeepPotTest, ComputeSimpleNoPbcDouble) { + if (!GetParam().supports_no_pbc_simple) { + GTEST_SKIP() << GetParam().name << " NoPBC coverage is not enabled."; + } + check_compute_simple(dp, *no_pbc_ref, GetParam().double_tol, false); +} + +TEST_P(VariantDeepPotTest, ComputeSimpleNoPbcFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_no_pbc_simple) { + GTEST_SKIP() << GetParam().name << " NoPBC coverage is not enabled."; + } + check_compute_simple(dp, *no_pbc_ref, GetParam().float_tol, false); +} + +TEST_P(VariantDeepPotTest, ComputeNoPbcDouble) { + if (!GetParam().supports_no_pbc_atomic) { + GTEST_SKIP() << GetParam().name << " atomic NoPBC coverage is not enabled."; + } + check_compute_atomic(dp, *no_pbc_ref, GetParam().double_tol, false); +} + +TEST_P(VariantDeepPotTest, ComputeNoPbcFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_no_pbc_atomic) { + GTEST_SKIP() << GetParam().name << " atomic NoPBC coverage is not enabled."; + } + check_compute_atomic(dp, *no_pbc_ref, GetParam().float_tol, false); +} + +TEST_P(VariantDeepPotTest, NoPbcLmpNlistDouble) { + if (!GetParam().supports_no_pbc_lmp_nlist) { + GTEST_SKIP() << GetParam().name + << " NoPBC LAMMPS nlist coverage is not enabled."; + } + check_no_pbc_lmp_nlist(dp, *no_pbc_ref, GetParam().double_tol, false); +} + +TEST_P(VariantDeepPotTest, NoPbcLmpNlistFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_no_pbc_lmp_nlist) { + GTEST_SKIP() << GetParam().name + << " NoPBC LAMMPS nlist coverage is not enabled."; + } + check_no_pbc_lmp_nlist(dp, *no_pbc_ref, GetParam().float_tol, false); +} + +TEST_P(VariantDeepPotTest, NoPbcLmpNlistAtomicDouble) { + if (!GetParam().supports_no_pbc_lmp_nlist_atomic) { + GTEST_SKIP() << GetParam().name + << " atomic NoPBC LAMMPS nlist coverage is not enabled."; + } + check_no_pbc_lmp_nlist(dp, *no_pbc_ref, GetParam().double_tol, true); +} + +TEST_P(VariantDeepPotTest, NoPbcLmpNlistAtomicFloat) { + if (!GetParam().supports_float) { + GTEST_SKIP() << backend_name(GetParam().backend) + << " does not provide float inference coverage."; + } + if (!GetParam().supports_no_pbc_lmp_nlist_atomic) { + GTEST_SKIP() << GetParam().name + << " atomic NoPBC LAMMPS nlist coverage is not enabled."; + } + check_no_pbc_lmp_nlist(dp, *no_pbc_ref, GetParam().float_tol, true); +} + TEST_P(FParamAParamDeepPotTest, Metadata) { EXPECT_EQ(dp.dim_fparam(), 1); EXPECT_EQ(dp.dim_aparam(), 1); @@ -1365,6 +1913,14 @@ INSTANTIATE_TEST_SUITE_P( return info.param.name; }); +INSTANTIATE_TEST_SUITE_P( + ModelVariants, + VariantDeepPotTest, + ::testing::ValuesIn(variant_deeppot_cases()), + [](const ::testing::TestParamInfo& info) { + return info.param.name; + }); + INSTANTIATE_TEST_SUITE_P( FParamAParamBackends, FParamAParamDeepPotTest, diff --git a/source/api_cc/tests/test_deepspin_model_devi_ptexpt.cc b/source/api_cc/tests/test_deepspin_model_devi_ptexpt.cc index ada7c2eba7..07836f4d6e 100644 --- a/source/api_cc/tests/test_deepspin_model_devi_ptexpt.cc +++ b/source/api_cc/tests/test_deepspin_model_devi_ptexpt.cc @@ -35,21 +35,19 @@ class TestInferDeepSpinModeDeviPtExpt : public ::testing::Test { void SetUp() override { std::string model0_path = "../../tests/infer/deeppot_dpa_spin_md0.pt2"; std::string model1_path = "../../tests/infer/deeppot_dpa_spin_md1.pt2"; +#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT_SPIN + GTEST_SKIP() << "Skip because PyTorch support is not enabled."; +#endif { std::ifstream f(model0_path); - if (!f.good()) { - GTEST_SKIP() << "Skipping: " << model0_path << " not found."; - } + ASSERT_TRUE(f.good()) + << "Model artifact is not available: " << model0_path; } { std::ifstream f(model1_path); - if (!f.good()) { - GTEST_SKIP() << "Skipping: " << model1_path << " not found."; - } + ASSERT_TRUE(f.good()) + << "Model artifact is not available: " << model1_path; } -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT_SPIN - GTEST_SKIP() << "Skip because PyTorch support is not enabled."; -#endif dp0.init(model0_path); dp1.init(model1_path); dp_md.init({model0_path, model1_path}); diff --git a/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc b/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc index 768c1947bf..031903a32f 100644 --- a/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc +++ b/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc @@ -60,11 +60,10 @@ class TestDeepPotPTExptWithCommLoadFailure : public ::testing::Test { #if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT GTEST_SKIP() << "Skip because PyTorch / pt_expt support is not enabled."; #endif - if (!file_exists(kPotCorrupt)) { - GTEST_SKIP() << "Skipping: " << kPotCorrupt - << " not found. Run source/tests/infer/" - "gen_corrupt_with_comm.py first."; - } + ASSERT_TRUE(file_exists(kPotCorrupt)) + << kPotCorrupt + << " not found. Run source/tests/infer/" + "gen_corrupt_with_comm.py first."; // Init must succeed: the with-comm loader fails internally and the // catch block keeps the regular single-rank artifact usable. ASSERT_NO_THROW(dp.init(kPotCorrupt)); @@ -150,11 +149,10 @@ class TestDeepSpinPTExptWithCommLoadFailure : public ::testing::Test { GTEST_SKIP() << "Skip because PyTorch / pt_expt spin support is not " "enabled."; #endif - if (!file_exists(kSpinCorrupt)) { - GTEST_SKIP() << "Skipping: " << kSpinCorrupt - << " not found. Run source/tests/infer/" - "gen_corrupt_with_comm.py first."; - } + ASSERT_TRUE(file_exists(kSpinCorrupt)) + << kSpinCorrupt + << " not found. Run source/tests/infer/" + "gen_corrupt_with_comm.py first."; ASSERT_NO_THROW(dp.init(kSpinCorrupt)); } }; diff --git a/source/tests/infer/deeppot_universal_data.h b/source/tests/infer/deeppot_universal_data.h index ea464005f3..fdb64e2c72 100644 --- a/source/tests/infer/deeppot_universal_data.h +++ b/source/tests/infer/deeppot_universal_data.h @@ -245,6 +245,165 @@ inline const DeepPotRef& sea_deeppot_no_pbc_ref() { return ref; } +inline const DeepPotRef& tf_deeppot_r_ref() { + static const DeepPotRef ref = { + {-9.320909762801588272e+01, -1.868020345400987878e+02, + -1.868011172371355997e+02, -9.320868430396934912e+01, + -1.868010398844378415e+02, -1.868016706555875999e+02}, + {6.385312846474267391e-04, -6.460452911141417731e-03, + -5.652405655332678417e-04, -7.516468794343579736e-03, + 1.128804614240160216e-03, 5.531937784564192051e-03, + 1.914138124904981664e-03, 5.601819906021693503e-03, + -5.131359585752605541e-03, -4.847104424804288617e-03, + 1.992071550328819614e-03, -4.028159855157302516e-03, + 1.236340684486603517e-03, -5.373955841338794344e-03, + 8.312829460571366513e-03, 8.574563125108854156e-03, + 3.111712681889538742e-03, -4.120007238692381148e-03}, + {5.844056241889131371e-03, 4.663973497239899614e-04, + -2.268382127762904633e-03, 4.663973497239897988e-04, + 2.349338784202595950e-03, -6.908546513234039253e-04, + -2.268382127762904633e-03, -6.908546513234039253e-04, + 2.040499248150800561e-03, 4.238130266437327605e-03, + -1.539867187443782223e-04, -2.393101333240631613e-03, + -1.539867187443782223e-04, 4.410341945447907377e-04, + 9.544239698119633068e-06, -2.393101333240631613e-03, + 9.544239698119578858e-06, 1.877785959095269654e-03, + 5.798992562057291543e-03, 6.943392552230453693e-04, + -1.180376879311998773e-03, 6.943392552230453693e-04, + 1.686725132156275536e-03, -1.461632060145726542e-03, + -1.180376879311998556e-03, -1.461632060145726325e-03, + 1.749543733794208444e-03, 7.173915604192910439e-03, + 3.903218041111061569e-04, -5.747400467123527524e-04, + 3.903218041111061569e-04, 1.208289706621179949e-03, + -1.826828914132010932e-03, -5.747400467123527524e-04, + -1.826828914132011148e-03, 2.856960586657185906e-03, + 4.067553030177322240e-03, -3.267469855253819430e-05, + -6.980667859103454904e-05, -3.267469855253830272e-05, + 1.387653029234650918e-03, -2.096820720698671855e-03, + -6.980667859103444062e-05, -2.096820720698671855e-03, + 3.218305506720191278e-03, 4.753992590355240674e-03, + 1.224911338353675992e-03, -1.683421934571502484e-03, + 1.224911338353676209e-03, 7.332113564901583539e-04, + -1.025577052190138451e-03, -1.683421934571502484e-03, + -1.025577052190138234e-03, 1.456681925652047018e-03}}; + return ref; +} + +inline const DeepPotRef& tf_deeppot_r_no_pbc_ref() { + static const DeepPotRef ref = { + {-9.321213823508108476e+01, -1.868044102481340758e+02, + -1.868067983858651075e+02, -9.320899631301440991e+01, + -1.868014559732615112e+02, -1.868017660713088617e+02}, + {4.578151103701261042e-03, -1.917874111009987628e-03, + -3.464546781179331930e-03, -4.578151103701261042e-03, + 1.917874111009987628e-03, 3.464546781179331930e-03, + -2.624402581721222913e-03, 3.566275128489623933e-04, + -2.859315986763691776e-04, -5.767787273464367384e-03, + 1.907053583551196647e-03, -3.889064429673861831e-03, + 1.786820066350549132e-04, -5.327197473636275694e-03, + 8.236236182834734409e-03, 8.213507848550535492e-03, + 3.063516377236116545e-03, -4.061240154484504865e-03}, + {1.984979026299632174e-03, -8.315452677741701822e-04, + -1.502146290172694243e-03, -8.315452677741700738e-04, + 3.483500446080982317e-04, 6.292774999372096039e-04, + -1.502146290172694243e-03, 6.292774999372097123e-04, + 1.136759354725281907e-03, 1.402852790439301908e-03, + -5.876815743732210226e-04, -1.061618327900012114e-03, + -5.876815743732211311e-04, 2.461909298049979960e-04, + 4.447320022283834766e-04, -1.061618327900012331e-03, + 4.447320022283834766e-04, 8.033868427351443728e-04, + 4.143606961846296385e-03, -5.511382161123719835e-04, + 4.465413399437045397e-04, -5.511382161123719835e-04, + 1.082271054025323839e-04, -1.097918001262628728e-04, + 4.465413399437046481e-04, -1.097918001262628728e-04, + 1.220966982358671871e-04, 5.263952004497593831e-03, + 2.395243710938091842e-04, -2.830378939414603329e-04, + 2.395243710938094010e-04, 1.189969706598244898e-03, + -1.805627331015851201e-03, -2.830378939414602245e-04, + -1.805627331015851635e-03, 2.801996513751836820e-03, + 2.208413501170402270e-03, 5.331756287635716889e-05, + -1.664423506603235218e-04, 5.331756287635695205e-05, + 1.379626072862918072e-03, -2.094132943741625064e-03, + -1.664423506603234133e-04, -2.094132943741625064e-03, + 3.199787996743366607e-03, 4.047014004814953811e-03, + 1.137904999421357000e-03, -1.568106936614101698e-03, + 1.137904999421357217e-03, 7.205982843216952307e-04, + -1.011174600268313238e-03, -1.568106936614101698e-03, + -1.011174600268313238e-03, 1.435226522157425754e-03}}; + return ref; +} + +inline const DeepPotRef& jax_dpa_deeppot_ref() { + static const DeepPotRef ref = { + {-94.24098099691867, -187.8049502787117, -187.80486052083617, + -94.24059525229518, -187.80366985846246, -187.8042377490619}, + {-0.0020150115442053, -0.0133389255924977, -0.0014347177433057, + -0.0140757358179293, 0.0031373814221557, 0.0098594354314677, + 0.004755683505073, 0.0099471082374397, -0.0080868184532793, + -0.0086166721574536, 0.0037803939137322, -0.0075733131286482, + 0.0037437603038209, -0.008452527996008, 0.0134837461840424, + 0.0162079757106944, 0.0049265700151781, -0.0062483322902769}, + {0.0133534319524089, 0.0013445914938337, -0.0029370551651952, + 0.0002611806151294, 0.004662662211533, -0.0002717443796319, + -0.0027779798869954, -0.0003277976466339, 0.0018284972283065, + 0.0085710118978246, 0.0003865036653608, -0.0057964032875089, + -0.0014358330222619, 0.0002912625128908, 0.001212630641674, + -0.0050582608957046, -0.0001087907763249, 0.0040068757134429, + 0.0116736349373084, 0.0007055477968445, -0.0019544933708784, + 0.0032997459258512, 0.0037887116116712, -0.0043140890650835, + -0.0034418738401156, -0.0029420616852742, 0.0038219676716965, + 0.0147134944025738, 0.0005214313829998, -0.0006524136175906, + 0.0003656980996363, 0.0010046161607714, -0.0017279359476254, + 0.000111127036911, -0.0017063190420654, 0.0030174567965904, + 0.0104435705455107, -0.0008704394438241, 0.0012354202650812, + 0.0009397615830053, 0.0029105236407293, -0.0044188897903449, + -0.0011461513500477, -0.0045759080125852, 0.0070310883421107, + 0.0089818851995049, 0.0038819466696704, -0.005443705549253, + 0.0025390283635246, 0.0012121502955869, -0.0016998728971157, + -0.0032355117893925, -0.0015590242752438, 0.0021980725909838}}; + return ref; +} + +inline const DeepPotRef& jax_dpa_deeppot_no_pbc_ref() { + static const DeepPotRef ref = { + {-94.24457967995595, -187.81100287606412, -187.81417300904738, + -94.24110552426328, -187.80431436838532, -187.80457222464983}, + {0.0051417559595313, -0.0021539788479118, -0.0038910585639696, + -0.0051417559595313, 0.0021539788479118, 0.0038910585639696, + -0.0035470615733886, 0.0003602503965239, -0.0001895679272905, + -0.0117361352793328, 0.0034252835112125, -0.0071824017939095, + 0.0005398894945495, -0.0084330745423862, 0.013284532676939, + 0.0147433073581718, 0.0046475406346498, -0.005912562955739}, + {1.8756488030620411e-03, -7.8574476885035112e-04, + -1.4194099050199721e-03, -7.8574476885031816e-04, + 3.2916334911298369e-04, 5.9461766291377029e-04, + -1.4194099050199305e-03, 5.9461766291377637e-04, + 1.0741480362313257e-03, 1.9292506069911106e-03, + -8.0819957860435269e-04, -1.4599734323175548e-03, + -8.0819957860438912e-04, 3.3857009373966171e-04, + 6.1161049191681572e-04, -1.4599734323175878e-03, + 6.1161049191681138e-04, 1.1048447595916697e-03, + 7.6085550162737362e-03, -9.6772620145935649e-04, + 8.3466357433496438e-04, -6.0870001592646837e-04, + 7.8216372819095133e-05, -6.6454748650881927e-05, + 1.6484218595781155e-04, -1.4860654308892986e-05, + 9.1346879754941710e-06, 7.3496442591020616e-03, + -4.4351638231197171e-04, 1.0048648094020743e-03, + -6.7678341212752506e-04, 1.0347359647873023e-03, + -1.6645682233463639e-03, 1.4376416549492857e-03, + -1.7116654329527997e-03, 2.8516307661164836e-03, + 1.7683913600324828e-03, -2.6945055858769765e-04, + 3.0381043714224000e-04, 9.9317892494769217e-04, + 2.9343081937224687e-03, -4.4381349285303948e-03, + -1.6684804850477311e-03, -4.5760063242183471e-03, + 6.9407432349694147e-03, 7.8021639779489171e-03, + 3.5246152053432442e-03, -4.9415349551876243e-03, + 2.1362265660905197e-03, 1.2226850609509659e-03, + -1.7016886981679963e-03, -2.7321994901677166e-03, + -1.5683141872155984e-03, 2.1960566952029213e-03}}; + return ref; +} + inline double total_energy(const DeepPotRef& ref) { return std::accumulate(ref.atomic_energy.begin(), ref.atomic_energy.end(), 0.0); From d367fabe028cfb58a04a7c42497da36d3d64da60 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 20 Jun 2026 03:10:34 +0800 Subject: [PATCH 06/11] test(api): fix universal DeepPot C++ CI coverage --- source/api_cc/tests/test_deeppot_universal.cc | 22 ++++++++++++++----- source/install/test_cc_local.sh | 2 ++ 2 files changed, 19 insertions(+), 5 deletions(-) diff --git a/source/api_cc/tests/test_deeppot_universal.cc b/source/api_cc/tests/test_deeppot_universal.cc index 626345301a..c571ae9b03 100644 --- a/source/api_cc/tests/test_deeppot_universal.cc +++ b/source/api_cc/tests/test_deeppot_universal.cc @@ -660,14 +660,18 @@ void check_compute_atomic(deepmd::DeepPot& dp, } template -void check_finite_difference(deepmd::DeepPot& dp) { +void check_finite_difference(deepmd::DeepPot& dp, const double level = -1.0) { class Model : public EnergyModelTest { deepmd::DeepPot& dp_; const std::vector atype_; public: - Model(deepmd::DeepPot& dp, const std::vector& atype) - : dp_(dp), atype_(atype) {} + Model(deepmd::DeepPot& dp, const std::vector& atype, double level) + : dp_(dp), atype_(atype) { + if (level > 0.0) { + this->level = level; + } + } void compute(double& energy, std::vector& force, @@ -683,7 +687,7 @@ void check_finite_difference(deepmd::DeepPot& dp) { const std::vector atype = deepmd_test::deeppot_atype(); std::vector box(deepmd_test::deeppot_box().begin(), deepmd_test::deeppot_box().end()); - Model model(dp, atype); + Model model(dp, atype, level); model.test_f(coord, box); model.test_v(coord, box); box[1] -= 0.4; @@ -730,6 +734,7 @@ void check_lmp_nlist(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); + inlist.mapping = mapping.data(); for (int ago = 0; ago < 2; ++ago) { double energy = 0.0; @@ -767,6 +772,7 @@ void check_lmp_nlist_atomic(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); + inlist.mapping = mapping.data(); for (int ago = 0; ago < 2; ++ago) { double energy = 0.0; @@ -865,6 +871,7 @@ void check_lmp_nlist_type_sel(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); + inlist.mapping = mapping.data(); double energy = 0.0; std::vector force_all(nall * 3, 0.0), virial(9, 0.0); @@ -1032,6 +1039,7 @@ void check_lmp_nlist_frames(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); + inlist.mapping = mapping.data(); for (int ago = 0; ago < 2; ++ago) { std::vector energy; @@ -1100,6 +1108,7 @@ void check_lmp_nlist_type_sel_frames(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); + inlist.mapping = mapping.data(); std::vector energy; std::vector force_all; @@ -1217,6 +1226,7 @@ void check_fparam_lmp_nlist(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); + inlist.mapping = mapping.data(); for (int ago = 0; ago < ago_count; ++ago) { double energy = 0.0; @@ -1619,7 +1629,9 @@ TEST_P(VariantDeepPotTest, FiniteDifferenceFloat) { GTEST_SKIP() << GetParam().name << " finite-difference coverage is not enabled."; } - check_finite_difference(dp); + const double finite_difference_tol = + GetParam().name == "dpa4_pytorch_pt2" ? 3e-2 : -1.0; + check_finite_difference(dp, finite_difference_tol); } TEST_P(VariantDeepPotTest, LmpNlistDouble) { diff --git a/source/install/test_cc_local.sh b/source/install/test_cc_local.sh index 2247dcb46c..3a27459c3d 100755 --- a/source/install/test_cc_local.sh +++ b/source/install/test_cc_local.sh @@ -104,6 +104,8 @@ else: PID8=$! wait $PID7 wait $PID8 + + env ${_GEN_ENV} python ${INFER_SCRIPT_PATH}/gen_corrupt_with_comm.py fi if [ "${ENABLE_PADDLE:-TRUE}" == "TRUE" ]; then PADDLE_INFERENCE_DIR=${BUILD_TMP_DIR}/paddle_inference_install_dir From a6ef1189eac7f0f46146631b55b5cc5bd5d40e12 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 20 Jun 2026 03:36:00 +0800 Subject: [PATCH 07/11] test(api): avoid Paddle LAMMPS mapping input --- source/api_cc/tests/test_deeppot_universal.cc | 112 ++++++++++++------ 1 file changed, 73 insertions(+), 39 deletions(-) diff --git a/source/api_cc/tests/test_deeppot_universal.cc b/source/api_cc/tests/test_deeppot_universal.cc index c571ae9b03..e510626882 100644 --- a/source/api_cc/tests/test_deeppot_universal.cc +++ b/source/api_cc/tests/test_deeppot_universal.cc @@ -30,6 +30,7 @@ struct ModelCase { double float_tol; bool supports_float; bool supports_nframes; + bool supports_lmp_nlist_mapping; }; struct VariantDeepPotCase { @@ -140,19 +141,20 @@ std::vector model_cases() { return { {"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/deeppot.pbtxt", true, &deepmd_test::tf_deeppot_ref(), - &deepmd_test::tf_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, true}, + &deepmd_test::tf_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, true, true}, {"pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_sea.pth", false, &deepmd_test::sea_deeppot_ref(), - &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, false}, + &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, false, true}, {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_sea.pt2", false, &deepmd_test::sea_deeppot_ref(), - &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, false}, + &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, false, true}, {"jax_savedmodel", Backend::JAX, "../../tests/infer/deeppot_sea.savedmodel", false, - &deepmd_test::sea_deeppot_ref(), nullptr, 1e-10, 1e-4, true, false}, + &deepmd_test::sea_deeppot_ref(), nullptr, 1e-10, 1e-4, true, false, + true}, {"paddle_json", Backend::Paddle, "../../tests/infer/deeppot_sea.json", false, &deepmd_test::sea_deeppot_ref(), nullptr, 1e-7, 1e-4, false, - false}}; + false, false}}; } std::vector variant_deeppot_cases() { @@ -714,7 +716,8 @@ template void check_lmp_nlist(deepmd::DeepPot& dp, const deepmd_test::DeepPotRef& ref, const double tol, - const double cutoff_scale = 1.0) { + const double cutoff_scale = 1.0, + const bool set_mapping = true) { const int natoms = static_cast(deepmd_test::deeppot_atype().size()); const std::vector coord(deepmd_test::deeppot_coord().begin(), deepmd_test::deeppot_coord().end()); @@ -734,7 +737,9 @@ void check_lmp_nlist(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); + if (set_mapping) { + inlist.mapping = mapping.data(); + } for (int ago = 0; ago < 2; ++ago) { double energy = 0.0; @@ -752,7 +757,8 @@ void check_lmp_nlist(deepmd::DeepPot& dp, template void check_lmp_nlist_atomic(deepmd::DeepPot& dp, const deepmd_test::DeepPotRef& ref, - const double tol) { + const double tol, + const bool set_mapping = true) { const int natoms = static_cast(deepmd_test::deeppot_atype().size()); const std::vector coord(deepmd_test::deeppot_coord().begin(), deepmd_test::deeppot_coord().end()); @@ -772,7 +778,9 @@ void check_lmp_nlist_atomic(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); + if (set_mapping) { + inlist.mapping = mapping.data(); + } for (int ago = 0; ago < 2; ++ago) { double energy = 0.0; @@ -843,7 +851,8 @@ template void check_lmp_nlist_type_sel(deepmd::DeepPot& dp, const deepmd_test::DeepPotRef& ref, const double tol, - const bool atomic) { + const bool atomic, + const bool set_mapping = true) { constexpr int nvir = 2; std::vector coord(deepmd_test::deeppot_coord().begin(), deepmd_test::deeppot_coord().end()); @@ -871,7 +880,9 @@ void check_lmp_nlist_type_sel(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); + if (set_mapping) { + inlist.mapping = mapping.data(); + } double energy = 0.0; std::vector force_all(nall * 3, 0.0), virial(9, 0.0); @@ -1016,7 +1027,8 @@ void check_lmp_nlist_frames(deepmd::DeepPot& dp, const double tol, const int nframes, const bool atomic, - const double cutoff_scale = 1.0) { + const double cutoff_scale = 1.0, + const bool set_mapping = true) { const int natoms = static_cast(deepmd_test::deeppot_atype().size()); const std::vector coord = cast_values(deepmd_test::deeppot_coord()); @@ -1039,7 +1051,9 @@ void check_lmp_nlist_frames(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); + if (set_mapping) { + inlist.mapping = mapping.data(); + } for (int ago = 0; ago < 2; ++ago) { std::vector energy; @@ -1076,7 +1090,8 @@ void check_lmp_nlist_type_sel_frames(deepmd::DeepPot& dp, const deepmd_test::DeepPotRef& ref, const double tol, const int nframes, - const bool atomic) { + const bool atomic, + const bool set_mapping = true) { constexpr int nvir = 2; const std::vector base_coord = cast_values(deepmd_test::deeppot_coord()); @@ -1108,7 +1123,9 @@ void check_lmp_nlist_type_sel_frames(deepmd::DeepPot& dp, deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), firstneigh.data()); convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); + if (set_mapping) { + inlist.mapping = mapping.data(); + } std::vector energy; std::vector force_all; @@ -1295,7 +1312,8 @@ TEST_P(UniversalDeepPotTest, FiniteDifferenceFloat) { } TEST_P(UniversalDeepPotTest, LmpNlistDouble) { - check_lmp_nlist(dp, *GetParam().ref, GetParam().double_tol); + check_lmp_nlist(dp, *GetParam().ref, GetParam().double_tol, 1.0, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, LmpNlistFloat) { @@ -1303,11 +1321,13 @@ TEST_P(UniversalDeepPotTest, LmpNlistFloat) { GTEST_SKIP() << backend_name(GetParam().backend) << " does not provide float inference coverage."; } - check_lmp_nlist(dp, *GetParam().ref, GetParam().float_tol); + check_lmp_nlist(dp, *GetParam().ref, GetParam().float_tol, 1.0, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, LmpNlistAtomicDouble) { - check_lmp_nlist_atomic(dp, *GetParam().ref, GetParam().double_tol); + check_lmp_nlist_atomic(dp, *GetParam().ref, GetParam().double_tol, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, LmpNlistAtomicFloat) { @@ -1315,11 +1335,13 @@ TEST_P(UniversalDeepPotTest, LmpNlistAtomicFloat) { GTEST_SKIP() << backend_name(GetParam().backend) << " does not provide float inference coverage."; } - check_lmp_nlist_atomic(dp, *GetParam().ref, GetParam().float_tol); + check_lmp_nlist_atomic(dp, *GetParam().ref, GetParam().float_tol, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, LmpNlistDoubleCutoffTwice) { - check_lmp_nlist(dp, *GetParam().ref, GetParam().double_tol, 2.0); + check_lmp_nlist(dp, *GetParam().ref, GetParam().double_tol, 2.0, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, LmpNlistFloatCutoffTwice) { @@ -1327,12 +1349,14 @@ TEST_P(UniversalDeepPotTest, LmpNlistFloatCutoffTwice) { GTEST_SKIP() << backend_name(GetParam().backend) << " does not provide float inference coverage."; } - check_lmp_nlist(dp, *GetParam().ref, GetParam().float_tol, 2.0); + check_lmp_nlist(dp, *GetParam().ref, GetParam().float_tol, 2.0, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, LmpNlistTypeSelDouble) { check_lmp_nlist_type_sel(dp, *GetParam().ref, GetParam().double_tol, - false); + false, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, LmpNlistTypeSelFloat) { @@ -1341,12 +1365,12 @@ TEST_P(UniversalDeepPotTest, LmpNlistTypeSelFloat) { << " does not provide float inference coverage."; } check_lmp_nlist_type_sel(dp, *GetParam().ref, GetParam().float_tol, - false); + false, GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, LmpNlistTypeSelAtomicDouble) { check_lmp_nlist_type_sel(dp, *GetParam().ref, GetParam().double_tol, - true); + true, GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, LmpNlistTypeSelAtomicFloat) { @@ -1355,7 +1379,7 @@ TEST_P(UniversalDeepPotTest, LmpNlistTypeSelAtomicFloat) { << " does not provide float inference coverage."; } check_lmp_nlist_type_sel(dp, *GetParam().ref, GetParam().float_tol, - true); + true, GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, ComputeNoPbcDouble) { @@ -1454,7 +1478,8 @@ TEST_P(UniversalDeepPotTest, NFramesLmpNlistDouble) { << " nframes coverage is not enabled."; } check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().double_tol, 2, - false); + false, 1.0, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, NFramesLmpNlistFloat) { @@ -1467,7 +1492,8 @@ TEST_P(UniversalDeepPotTest, NFramesLmpNlistFloat) { << " nframes coverage is not enabled."; } check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().float_tol, 2, - false); + false, 1.0, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, NFramesLmpNlistAtomicDouble) { @@ -1476,7 +1502,8 @@ TEST_P(UniversalDeepPotTest, NFramesLmpNlistAtomicDouble) { << " nframes coverage is not enabled."; } check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().double_tol, 2, - true); + true, 1.0, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, NFramesLmpNlistAtomicFloat) { @@ -1489,7 +1516,8 @@ TEST_P(UniversalDeepPotTest, NFramesLmpNlistAtomicFloat) { << " nframes coverage is not enabled."; } check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().float_tol, 2, - true); + true, 1.0, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, NFramesLmpNlistDoubleCutoffTwice) { @@ -1498,7 +1526,8 @@ TEST_P(UniversalDeepPotTest, NFramesLmpNlistDoubleCutoffTwice) { << " nframes coverage is not enabled."; } check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().double_tol, 2, - false, 2.0); + false, 2.0, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, NFramesLmpNlistFloatCutoffTwice) { @@ -1511,7 +1540,8 @@ TEST_P(UniversalDeepPotTest, NFramesLmpNlistFloatCutoffTwice) { << " nframes coverage is not enabled."; } check_lmp_nlist_frames(dp, *GetParam().ref, GetParam().float_tol, 2, - false, 2.0); + false, 2.0, + GetParam().supports_lmp_nlist_mapping); } TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelDouble) { @@ -1519,8 +1549,9 @@ TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelDouble) { GTEST_SKIP() << backend_name(GetParam().backend) << " nframes coverage is not enabled."; } - check_lmp_nlist_type_sel_frames(dp, *GetParam().ref, - GetParam().double_tol, 2, false); + const bool set_mapping = GetParam().supports_lmp_nlist_mapping; + check_lmp_nlist_type_sel_frames( + dp, *GetParam().ref, GetParam().double_tol, 2, false, set_mapping); } TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelFloat) { @@ -1532,8 +1563,9 @@ TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelFloat) { GTEST_SKIP() << backend_name(GetParam().backend) << " nframes coverage is not enabled."; } - check_lmp_nlist_type_sel_frames(dp, *GetParam().ref, - GetParam().float_tol, 2, false); + const bool set_mapping = GetParam().supports_lmp_nlist_mapping; + check_lmp_nlist_type_sel_frames( + dp, *GetParam().ref, GetParam().float_tol, 2, false, set_mapping); } TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelAtomicDouble) { @@ -1541,8 +1573,9 @@ TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelAtomicDouble) { GTEST_SKIP() << backend_name(GetParam().backend) << " nframes coverage is not enabled."; } - check_lmp_nlist_type_sel_frames(dp, *GetParam().ref, - GetParam().double_tol, 2, true); + const bool set_mapping = GetParam().supports_lmp_nlist_mapping; + check_lmp_nlist_type_sel_frames( + dp, *GetParam().ref, GetParam().double_tol, 2, true, set_mapping); } TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelAtomicFloat) { @@ -1554,8 +1587,9 @@ TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelAtomicFloat) { GTEST_SKIP() << backend_name(GetParam().backend) << " nframes coverage is not enabled."; } - check_lmp_nlist_type_sel_frames(dp, *GetParam().ref, - GetParam().float_tol, 2, true); + const bool set_mapping = GetParam().supports_lmp_nlist_mapping; + check_lmp_nlist_type_sel_frames( + dp, *GetParam().ref, GetParam().float_tol, 2, true, set_mapping); } TEST_P(UniversalDeepPotTest, NFramesComputeNoPbcDouble) { From e9565ee25d75049a7fb8fcec0c51bbc229783880 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 20 Jun 2026 04:48:35 +0800 Subject: [PATCH 08/11] test(api): drop corrupt with-comm pt2 coverage --- .../test_with_comm_load_failure_ptexpt.cc | 208 ------------------ source/install/test_cc_local.sh | 2 - source/tests/infer/gen_corrupt_with_comm.py | 67 ------ 3 files changed, 277 deletions(-) delete mode 100644 source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc delete mode 100644 source/tests/infer/gen_corrupt_with_comm.py diff --git a/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc b/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc deleted file mode 100644 index 031903a32f..0000000000 --- a/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc +++ /dev/null @@ -1,208 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-or-later -// Tests for the dispatch-site fail-fast guard when the with-comm AOTI -// artifact failed to load at init time. The fixtures are produced by -// source/tests/infer/gen_corrupt_with_comm.py: copies of the valid -// multi-rank .pt2 archives whose nested -// ``model/extra/forward_lower_with_comm.pt2`` entry has been replaced -// with garbage bytes. The outer metadata still claims -// ``has_comm_artifact: true`` so the loader exercises the catch path. -// -// Expectations: -// * init() succeeds (the loader logs and falls back instead of aborting). -// * Single-rank dispatch (nswap == 0) keeps working through the regular -// forward_lower artifact. -// * Multi-rank dispatch (nswap > 0) throws a deepmd::deepmd_exception -// instead of silently dropping the MPI ghost-embedding exchange. -#include - -#include -#include - -#include "DeepPot.h" -// Include the PT_Expt headers so BUILD_PT_EXPT / BUILD_PT_EXPT_SPIN are -// visible to the GTEST_SKIP guard below. -#include "DeepPotPTExpt.h" -#include "DeepSpin.h" -#include "DeepSpinPTExpt.h" -#include "common.h" -#include "neighbor_list.h" -#include "test_utils.h" - -namespace { -constexpr const char* kPotCorrupt = - "../../tests/infer/deeppot_dpa3_mpi_corrupt_with_comm.pt2"; -constexpr const char* kSpinCorrupt = - "../../tests/infer/deeppot_dpa3_spin_mpi_corrupt_with_comm.pt2"; - -bool file_exists(const char* path) { - std::ifstream f(path); - return f.good(); -} -} // namespace - -// ============================================================================ -// DeepPot (non-spin) — corrupted with-comm artifact -// ============================================================================ - -class TestDeepPotPTExptWithCommLoadFailure : public ::testing::Test { - protected: - // Coordinates / atype / box copied from gen_dpa3.py so the regular - // forward_lower artifact has well-formed inputs to evaluate. - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - - deepmd::DeepPot dp; - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT - GTEST_SKIP() << "Skip because PyTorch / pt_expt support is not enabled."; -#endif - ASSERT_TRUE(file_exists(kPotCorrupt)) - << kPotCorrupt - << " not found. Run source/tests/infer/" - "gen_corrupt_with_comm.py first."; - // Init must succeed: the with-comm loader fails internally and the - // catch block keeps the regular single-rank artifact usable. - ASSERT_NO_THROW(dp.init(kPotCorrupt)); - } -}; - -TEST_F(TestDeepPotPTExptWithCommLoadFailure, single_rank_compute_succeeds) { - // nswap == 0 (default InputNlist) routes through the regular - // forward_lower artifact; the broken with-comm artifact is not - // consulted, so compute must succeed. - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector> nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, atype, - box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), - firstneigh.data()); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - ASSERT_EQ(inlist.nswap, 0); // pre-condition: single-rank dispatch - - double ener; - std::vector force_, virial; - EXPECT_NO_THROW(dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, - nall - nloc, inlist, 0)); - EXPECT_EQ(force_.size(), nall * 3); - EXPECT_EQ(virial.size(), 9); -} - -TEST_F(TestDeepPotPTExptWithCommLoadFailure, multi_rank_compute_throws) { - // nswap > 0 forces the dispatch site to ``run_model_with_comm``; the - // load-failure guard added by PR #5430 must throw rather than silently - // falling back to the single-rank path. The send/recv arrays remain - // null — the guard fires before any of them are dereferenced. - float rc = dp.cutoff(); - int nloc = coord.size() / 3; - std::vector coord_cpy; - std::vector atype_cpy, mapping; - std::vector> nlist_data; - _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, atype, - box, rc); - int nall = coord_cpy.size() / 3; - std::vector ilist(nloc), numneigh(nloc); - std::vector firstneigh(nloc); - deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), - firstneigh.data()); - convert_nlist(inlist, nlist_data); - inlist.mapping = mapping.data(); - inlist.nswap = 1; // simulate multi-rank without populating send/recv - - double ener; - std::vector force_, virial; - EXPECT_THROW(dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, - nall - nloc, inlist, 0), - deepmd::deepmd_exception); -} - -// ============================================================================ -// DeepSpin — corrupted with-comm artifact -// ============================================================================ - -class TestDeepSpinPTExptWithCommLoadFailure : public ::testing::Test { - protected: - std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, - 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, - 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; - // Match deeppot_dpa3_spin_mpi.pt2 spin layout (type 0 has spin, types - // 1+ do not) — spin vector packed alongside coord. - std::vector spin = {0.13, 0.02, 0.03, 0., 0., 0., 0., 0., 0., - 0.14, 0.10, 0.12, 0., 0., 0., 0., 0., 0.}; - std::vector atype = {0, 1, 1, 0, 1, 1}; - std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; - - deepmd::DeepSpin dp; - - void SetUp() override { -#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT_SPIN - GTEST_SKIP() << "Skip because PyTorch / pt_expt spin support is not " - "enabled."; -#endif - ASSERT_TRUE(file_exists(kSpinCorrupt)) - << kSpinCorrupt - << " not found. Run source/tests/infer/" - "gen_corrupt_with_comm.py first."; - ASSERT_NO_THROW(dp.init(kSpinCorrupt)); - } -}; - -TEST_F(TestDeepSpinPTExptWithCommLoadFailure, single_rank_compute_succeeds) { - // NoPBC + hardcoded all-pairs nlist mirrors the - // ``cpu_lmp_nlist`` pattern in test_deeppot_dpa_ptexpt_spin.cc: - // nloc == natoms == nall, no ghost atoms. - const int natoms = static_cast(atype.size()); - std::vector empty_box; - std::vector> nlist_data = {{1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, - {0, 1, 3, 4, 5}, {0, 1, 2, 4, 5}, - {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, ilist.data(), numneigh.data(), - firstneigh.data()); - convert_nlist(inlist, nlist_data); - ASSERT_EQ(inlist.nswap, 0); - - double ener; - std::vector force_, force_mag, virial; - // The fixture is built with numb_aparam=1; supply a uniform per-atom aparam. - std::vector fparam, aparam(natoms, 1.0); - EXPECT_NO_THROW(dp.compute(ener, force_, force_mag, virial, coord, spin, - atype, empty_box, 0, inlist, 0, fparam, aparam)); -} - -TEST_F(TestDeepSpinPTExptWithCommLoadFailure, multi_rank_compute_throws) { - const int natoms = static_cast(atype.size()); - std::vector empty_box; - std::vector> nlist_data = {{1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, - {0, 1, 3, 4, 5}, {0, 1, 2, 4, 5}, - {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; - std::vector ilist(natoms), numneigh(natoms); - std::vector firstneigh(natoms); - deepmd::InputNlist inlist(natoms, ilist.data(), numneigh.data(), - firstneigh.data()); - convert_nlist(inlist, nlist_data); - // Multi-rank is keyed on nprocs (DeepSpinPTExpt.cc), not nswap; with - // has_comm_artifact_ true but the with-comm loader failed to load, the - // dispatch must throw. - inlist.nprocs = 2; - - double ener; - std::vector force_, force_mag, virial; - // The fixture is built with numb_aparam=1; supply a uniform per-atom aparam - // so the throw comes from the multi-rank dispatch, not a missing aparam. - std::vector fparam, aparam(natoms, 1.0); - EXPECT_THROW(dp.compute(ener, force_, force_mag, virial, coord, spin, atype, - empty_box, 0, inlist, 0, fparam, aparam), - deepmd::deepmd_exception); -} diff --git a/source/install/test_cc_local.sh b/source/install/test_cc_local.sh index 3a27459c3d..2247dcb46c 100755 --- a/source/install/test_cc_local.sh +++ b/source/install/test_cc_local.sh @@ -104,8 +104,6 @@ else: PID8=$! wait $PID7 wait $PID8 - - env ${_GEN_ENV} python ${INFER_SCRIPT_PATH}/gen_corrupt_with_comm.py fi if [ "${ENABLE_PADDLE:-TRUE}" == "TRUE" ]; then PADDLE_INFERENCE_DIR=${BUILD_TMP_DIR}/paddle_inference_install_dir diff --git a/source/tests/infer/gen_corrupt_with_comm.py b/source/tests/infer/gen_corrupt_with_comm.py deleted file mode 100644 index ff0d16158c..0000000000 --- a/source/tests/infer/gen_corrupt_with_comm.py +++ /dev/null @@ -1,67 +0,0 @@ -#!/usr/bin/env python3 -# SPDX-License-Identifier: LGPL-3.0-or-later -"""Generate ``deeppot_*_corrupt_with_comm.pt2`` fixtures. - -The fixtures are copies of the corresponding multi-rank ``.pt2`` archives -in which the nested ``model/extra/forward_lower_with_comm.pt2`` entry has -been overwritten with garbage bytes. The outer metadata still claims -``has_comm_artifact: true``, so: - -- ``DeepPotPTExpt::init`` / ``DeepSpinPTExpt::init`` exercise the - try/catch fallback path on the with-comm AOTI loader. -- Single-rank dispatch (``nswap == 0``) keeps working via the regular - artifact. -- Multi-rank dispatch (``nswap > 0``) hits the explicit dispatch-site - throw added in PR #5430, instead of silently dropping the MPI - ghost-embedding exchange. - -Consumed by ``source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc``. -""" - -import os -import zipfile - -WITH_COMM_ENTRY = "model/extra/forward_lower_with_comm.pt2" -GARBAGE = b"NOT_A_VALID_AOTI_ARCHIVE_" * 32 - - -def corrupt_with_comm(src: str, dst: str) -> None: - """Copy ``src`` to ``dst`` with the nested with-comm entry replaced.""" - with ( - zipfile.ZipFile(src, "r") as zin, - zipfile.ZipFile(dst, "w", compression=zipfile.ZIP_STORED) as zout, - ): - replaced = False - for info in zin.infolist(): - data = zin.read(info.filename) - if info.filename == WITH_COMM_ENTRY: - data = GARBAGE - replaced = True - zout.writestr(info, data) - if not replaced: - raise RuntimeError( - f"{src} does not contain {WITH_COMM_ENTRY}; cannot corrupt." - ) - - -def main() -> None: - base_dir = os.path.dirname(__file__) - pairs = [ - ("deeppot_dpa3_mpi.pt2", "deeppot_dpa3_mpi_corrupt_with_comm.pt2"), - ( - "deeppot_dpa3_spin_mpi.pt2", - "deeppot_dpa3_spin_mpi_corrupt_with_comm.pt2", - ), - ] - for src_name, dst_name in pairs: - src = os.path.join(base_dir, src_name) - dst = os.path.join(base_dir, dst_name) - if not os.path.exists(src): - print(f"Skipping {dst_name}: source {src_name} not found.") # noqa: T201 - continue - corrupt_with_comm(src, dst) - print(f"Wrote {dst}") # noqa: T201 - - -if __name__ == "__main__": - main() From 85455c9748bcb366a0b4aed0559250881ad59628 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 20 Jun 2026 04:54:15 +0800 Subject: [PATCH 09/11] Revert "test(api): drop corrupt with-comm pt2 coverage" This reverts commit e9565ee25d75049a7fb8fcec0c51bbc229783880. --- .../test_with_comm_load_failure_ptexpt.cc | 208 ++++++++++++++++++ source/install/test_cc_local.sh | 2 + source/tests/infer/gen_corrupt_with_comm.py | 67 ++++++ 3 files changed, 277 insertions(+) create mode 100644 source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc create mode 100644 source/tests/infer/gen_corrupt_with_comm.py diff --git a/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc b/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc new file mode 100644 index 0000000000..031903a32f --- /dev/null +++ b/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc @@ -0,0 +1,208 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later +// Tests for the dispatch-site fail-fast guard when the with-comm AOTI +// artifact failed to load at init time. The fixtures are produced by +// source/tests/infer/gen_corrupt_with_comm.py: copies of the valid +// multi-rank .pt2 archives whose nested +// ``model/extra/forward_lower_with_comm.pt2`` entry has been replaced +// with garbage bytes. The outer metadata still claims +// ``has_comm_artifact: true`` so the loader exercises the catch path. +// +// Expectations: +// * init() succeeds (the loader logs and falls back instead of aborting). +// * Single-rank dispatch (nswap == 0) keeps working through the regular +// forward_lower artifact. +// * Multi-rank dispatch (nswap > 0) throws a deepmd::deepmd_exception +// instead of silently dropping the MPI ghost-embedding exchange. +#include + +#include +#include + +#include "DeepPot.h" +// Include the PT_Expt headers so BUILD_PT_EXPT / BUILD_PT_EXPT_SPIN are +// visible to the GTEST_SKIP guard below. +#include "DeepPotPTExpt.h" +#include "DeepSpin.h" +#include "DeepSpinPTExpt.h" +#include "common.h" +#include "neighbor_list.h" +#include "test_utils.h" + +namespace { +constexpr const char* kPotCorrupt = + "../../tests/infer/deeppot_dpa3_mpi_corrupt_with_comm.pt2"; +constexpr const char* kSpinCorrupt = + "../../tests/infer/deeppot_dpa3_spin_mpi_corrupt_with_comm.pt2"; + +bool file_exists(const char* path) { + std::ifstream f(path); + return f.good(); +} +} // namespace + +// ============================================================================ +// DeepPot (non-spin) — corrupted with-comm artifact +// ============================================================================ + +class TestDeepPotPTExptWithCommLoadFailure : public ::testing::Test { + protected: + // Coordinates / atype / box copied from gen_dpa3.py so the regular + // forward_lower artifact has well-formed inputs to evaluate. + std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, + 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, + 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; + std::vector atype = {0, 1, 1, 0, 1, 1}; + std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; + + deepmd::DeepPot dp; + + void SetUp() override { +#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT + GTEST_SKIP() << "Skip because PyTorch / pt_expt support is not enabled."; +#endif + ASSERT_TRUE(file_exists(kPotCorrupt)) + << kPotCorrupt + << " not found. Run source/tests/infer/" + "gen_corrupt_with_comm.py first."; + // Init must succeed: the with-comm loader fails internally and the + // catch block keeps the regular single-rank artifact usable. + ASSERT_NO_THROW(dp.init(kPotCorrupt)); + } +}; + +TEST_F(TestDeepPotPTExptWithCommLoadFailure, single_rank_compute_succeeds) { + // nswap == 0 (default InputNlist) routes through the regular + // forward_lower artifact; the broken with-comm artifact is not + // consulted, so compute must succeed. + float rc = dp.cutoff(); + int nloc = coord.size() / 3; + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector> nlist_data; + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, atype, + box, rc); + int nall = coord_cpy.size() / 3; + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + inlist.mapping = mapping.data(); + ASSERT_EQ(inlist.nswap, 0); // pre-condition: single-rank dispatch + + double ener; + std::vector force_, virial; + EXPECT_NO_THROW(dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, + nall - nloc, inlist, 0)); + EXPECT_EQ(force_.size(), nall * 3); + EXPECT_EQ(virial.size(), 9); +} + +TEST_F(TestDeepPotPTExptWithCommLoadFailure, multi_rank_compute_throws) { + // nswap > 0 forces the dispatch site to ``run_model_with_comm``; the + // load-failure guard added by PR #5430 must throw rather than silently + // falling back to the single-rank path. The send/recv arrays remain + // null — the guard fires before any of them are dereferenced. + float rc = dp.cutoff(); + int nloc = coord.size() / 3; + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector> nlist_data; + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, coord, atype, + box, rc); + int nall = coord_cpy.size() / 3; + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + inlist.mapping = mapping.data(); + inlist.nswap = 1; // simulate multi-rank without populating send/recv + + double ener; + std::vector force_, virial; + EXPECT_THROW(dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, + nall - nloc, inlist, 0), + deepmd::deepmd_exception); +} + +// ============================================================================ +// DeepSpin — corrupted with-comm artifact +// ============================================================================ + +class TestDeepSpinPTExptWithCommLoadFailure : public ::testing::Test { + protected: + std::vector coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, + 00.25, 3.32, 1.68, 3.36, 3.00, 1.81, + 3.51, 2.51, 2.60, 4.27, 3.22, 1.56}; + // Match deeppot_dpa3_spin_mpi.pt2 spin layout (type 0 has spin, types + // 1+ do not) — spin vector packed alongside coord. + std::vector spin = {0.13, 0.02, 0.03, 0., 0., 0., 0., 0., 0., + 0.14, 0.10, 0.12, 0., 0., 0., 0., 0., 0.}; + std::vector atype = {0, 1, 1, 0, 1, 1}; + std::vector box = {13., 0., 0., 0., 13., 0., 0., 0., 13.}; + + deepmd::DeepSpin dp; + + void SetUp() override { +#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT_SPIN + GTEST_SKIP() << "Skip because PyTorch / pt_expt spin support is not " + "enabled."; +#endif + ASSERT_TRUE(file_exists(kSpinCorrupt)) + << kSpinCorrupt + << " not found. Run source/tests/infer/" + "gen_corrupt_with_comm.py first."; + ASSERT_NO_THROW(dp.init(kSpinCorrupt)); + } +}; + +TEST_F(TestDeepSpinPTExptWithCommLoadFailure, single_rank_compute_succeeds) { + // NoPBC + hardcoded all-pairs nlist mirrors the + // ``cpu_lmp_nlist`` pattern in test_deeppot_dpa_ptexpt_spin.cc: + // nloc == natoms == nall, no ghost atoms. + const int natoms = static_cast(atype.size()); + std::vector empty_box; + std::vector> nlist_data = {{1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, + {0, 1, 3, 4, 5}, {0, 1, 2, 4, 5}, + {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; + std::vector ilist(natoms), numneigh(natoms); + std::vector firstneigh(natoms); + deepmd::InputNlist inlist(natoms, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + ASSERT_EQ(inlist.nswap, 0); + + double ener; + std::vector force_, force_mag, virial; + // The fixture is built with numb_aparam=1; supply a uniform per-atom aparam. + std::vector fparam, aparam(natoms, 1.0); + EXPECT_NO_THROW(dp.compute(ener, force_, force_mag, virial, coord, spin, + atype, empty_box, 0, inlist, 0, fparam, aparam)); +} + +TEST_F(TestDeepSpinPTExptWithCommLoadFailure, multi_rank_compute_throws) { + const int natoms = static_cast(atype.size()); + std::vector empty_box; + std::vector> nlist_data = {{1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, + {0, 1, 3, 4, 5}, {0, 1, 2, 4, 5}, + {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}}; + std::vector ilist(natoms), numneigh(natoms); + std::vector firstneigh(natoms); + deepmd::InputNlist inlist(natoms, ilist.data(), numneigh.data(), + firstneigh.data()); + convert_nlist(inlist, nlist_data); + // Multi-rank is keyed on nprocs (DeepSpinPTExpt.cc), not nswap; with + // has_comm_artifact_ true but the with-comm loader failed to load, the + // dispatch must throw. + inlist.nprocs = 2; + + double ener; + std::vector force_, force_mag, virial; + // The fixture is built with numb_aparam=1; supply a uniform per-atom aparam + // so the throw comes from the multi-rank dispatch, not a missing aparam. + std::vector fparam, aparam(natoms, 1.0); + EXPECT_THROW(dp.compute(ener, force_, force_mag, virial, coord, spin, atype, + empty_box, 0, inlist, 0, fparam, aparam), + deepmd::deepmd_exception); +} diff --git a/source/install/test_cc_local.sh b/source/install/test_cc_local.sh index 2247dcb46c..3a27459c3d 100755 --- a/source/install/test_cc_local.sh +++ b/source/install/test_cc_local.sh @@ -104,6 +104,8 @@ else: PID8=$! wait $PID7 wait $PID8 + + env ${_GEN_ENV} python ${INFER_SCRIPT_PATH}/gen_corrupt_with_comm.py fi if [ "${ENABLE_PADDLE:-TRUE}" == "TRUE" ]; then PADDLE_INFERENCE_DIR=${BUILD_TMP_DIR}/paddle_inference_install_dir diff --git a/source/tests/infer/gen_corrupt_with_comm.py b/source/tests/infer/gen_corrupt_with_comm.py new file mode 100644 index 0000000000..ff0d16158c --- /dev/null +++ b/source/tests/infer/gen_corrupt_with_comm.py @@ -0,0 +1,67 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: LGPL-3.0-or-later +"""Generate ``deeppot_*_corrupt_with_comm.pt2`` fixtures. + +The fixtures are copies of the corresponding multi-rank ``.pt2`` archives +in which the nested ``model/extra/forward_lower_with_comm.pt2`` entry has +been overwritten with garbage bytes. The outer metadata still claims +``has_comm_artifact: true``, so: + +- ``DeepPotPTExpt::init`` / ``DeepSpinPTExpt::init`` exercise the + try/catch fallback path on the with-comm AOTI loader. +- Single-rank dispatch (``nswap == 0``) keeps working via the regular + artifact. +- Multi-rank dispatch (``nswap > 0``) hits the explicit dispatch-site + throw added in PR #5430, instead of silently dropping the MPI + ghost-embedding exchange. + +Consumed by ``source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc``. +""" + +import os +import zipfile + +WITH_COMM_ENTRY = "model/extra/forward_lower_with_comm.pt2" +GARBAGE = b"NOT_A_VALID_AOTI_ARCHIVE_" * 32 + + +def corrupt_with_comm(src: str, dst: str) -> None: + """Copy ``src`` to ``dst`` with the nested with-comm entry replaced.""" + with ( + zipfile.ZipFile(src, "r") as zin, + zipfile.ZipFile(dst, "w", compression=zipfile.ZIP_STORED) as zout, + ): + replaced = False + for info in zin.infolist(): + data = zin.read(info.filename) + if info.filename == WITH_COMM_ENTRY: + data = GARBAGE + replaced = True + zout.writestr(info, data) + if not replaced: + raise RuntimeError( + f"{src} does not contain {WITH_COMM_ENTRY}; cannot corrupt." + ) + + +def main() -> None: + base_dir = os.path.dirname(__file__) + pairs = [ + ("deeppot_dpa3_mpi.pt2", "deeppot_dpa3_mpi_corrupt_with_comm.pt2"), + ( + "deeppot_dpa3_spin_mpi.pt2", + "deeppot_dpa3_spin_mpi_corrupt_with_comm.pt2", + ), + ] + for src_name, dst_name in pairs: + src = os.path.join(base_dir, src_name) + dst = os.path.join(base_dir, dst_name) + if not os.path.exists(src): + print(f"Skipping {dst_name}: source {src_name} not found.") # noqa: T201 + continue + corrupt_with_comm(src, dst) + print(f"Wrote {dst}") # noqa: T201 + + +if __name__ == "__main__": + main() From 943634b439fe2b68c9204e3c32470fe38a0c9d83 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 20 Jun 2026 04:57:37 +0800 Subject: [PATCH 10/11] test(api): restore corrupt with-comm skip behavior --- .../test_with_comm_load_failure_ptexpt.cc | 18 ++++++++++-------- source/install/test_cc_local.sh | 2 -- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc b/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc index 031903a32f..768c1947bf 100644 --- a/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc +++ b/source/api_cc/tests/test_with_comm_load_failure_ptexpt.cc @@ -60,10 +60,11 @@ class TestDeepPotPTExptWithCommLoadFailure : public ::testing::Test { #if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT GTEST_SKIP() << "Skip because PyTorch / pt_expt support is not enabled."; #endif - ASSERT_TRUE(file_exists(kPotCorrupt)) - << kPotCorrupt - << " not found. Run source/tests/infer/" - "gen_corrupt_with_comm.py first."; + if (!file_exists(kPotCorrupt)) { + GTEST_SKIP() << "Skipping: " << kPotCorrupt + << " not found. Run source/tests/infer/" + "gen_corrupt_with_comm.py first."; + } // Init must succeed: the with-comm loader fails internally and the // catch block keeps the regular single-rank artifact usable. ASSERT_NO_THROW(dp.init(kPotCorrupt)); @@ -149,10 +150,11 @@ class TestDeepSpinPTExptWithCommLoadFailure : public ::testing::Test { GTEST_SKIP() << "Skip because PyTorch / pt_expt spin support is not " "enabled."; #endif - ASSERT_TRUE(file_exists(kSpinCorrupt)) - << kSpinCorrupt - << " not found. Run source/tests/infer/" - "gen_corrupt_with_comm.py first."; + if (!file_exists(kSpinCorrupt)) { + GTEST_SKIP() << "Skipping: " << kSpinCorrupt + << " not found. Run source/tests/infer/" + "gen_corrupt_with_comm.py first."; + } ASSERT_NO_THROW(dp.init(kSpinCorrupt)); } }; diff --git a/source/install/test_cc_local.sh b/source/install/test_cc_local.sh index 3a27459c3d..2247dcb46c 100755 --- a/source/install/test_cc_local.sh +++ b/source/install/test_cc_local.sh @@ -104,8 +104,6 @@ else: PID8=$! wait $PID7 wait $PID8 - - env ${_GEN_ENV} python ${INFER_SCRIPT_PATH}/gen_corrupt_with_comm.py fi if [ "${ENABLE_PADDLE:-TRUE}" == "TRUE" ]; then PADDLE_INFERENCE_DIR=${BUILD_TMP_DIR}/paddle_inference_install_dir From c98e2fe408eb5283bc5da0cb78bca7bd64e6a009 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sun, 21 Jun 2026 02:28:57 +0800 Subject: [PATCH 11/11] test(api): address universal deeppot review comments --- source/api_c/tests/test_deeppot_universal.cc | 152 +------ .../tests/deeppot_universal_test_common.h | 165 ++++++++ source/api_cc/tests/test_deeppot_universal.cc | 392 +++++++----------- 3 files changed, 329 insertions(+), 380 deletions(-) create mode 100644 source/api_cc/tests/deeppot_universal_test_common.h diff --git a/source/api_c/tests/test_deeppot_universal.cc b/source/api_c/tests/test_deeppot_universal.cc index d7d6841382..d79c831295 100644 --- a/source/api_c/tests/test_deeppot_universal.cc +++ b/source/api_c/tests/test_deeppot_universal.cc @@ -1,145 +1,37 @@ // SPDX-License-Identifier: LGPL-3.0-or-later #include -#include #include #include -#include +#include #include #include -#include "../../api_cc/tests/expected_ref.h" -#include "../../tests/infer/deeppot_universal_data.h" -#include "DeepPotPTExpt.h" +#include "../../api_cc/tests/deeppot_universal_test_common.h" #include "c_api.h" namespace { -enum class Backend { TensorFlow, PyTorch, PTExpt, JAX, Paddle }; - -struct ModelCase { - std::string name; - Backend backend; - std::string model_path; - bool convert_pbtxt; - const deepmd_test::DeepPotRef* ref; - const deepmd_test::DeepPotRef* no_pbc_ref; - double double_tol; - double float_tol; - bool supports_float; -}; - -struct FParamAParamCase { - std::string name; - Backend backend; - std::string model_path; - bool convert_pbtxt; - const deepmd_test::DeepPotRef* builtin_ref; - std::string ref_path; - double double_tol; - double float_tol; - bool supports_float; -}; - -bool path_exists(const std::string& path) { - struct stat statbuf; - return stat(path.c_str(), &statbuf) == 0; -} - -bool backend_enabled(Backend backend) { - switch (backend) { - case Backend::TensorFlow: -#ifdef BUILD_TENSORFLOW - return true; -#else - return false; -#endif - case Backend::PyTorch: -#ifdef BUILD_PYTORCH - return true; -#else - return false; -#endif - case Backend::PTExpt: -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - return true; -#else - return false; -#endif - case Backend::JAX: -#ifdef BUILD_JAX - return true; -#else - return false; -#endif - case Backend::Paddle: -#ifdef BUILD_PADDLE - return true; -#else - return false; -#endif - } - return false; -} +using namespace deepmd_test::universal; -std::string backend_name(Backend backend) { - switch (backend) { - case Backend::TensorFlow: - return "TensorFlow"; - case Backend::PyTorch: - return "PyTorch"; - case Backend::PTExpt: - return "PTExpt"; - case Backend::JAX: - return "JAX"; - case Backend::Paddle: - return "Paddle"; - } - return "Unknown"; -} - -std::vector model_cases() { - return { - {"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/deeppot.pbtxt", - true, &deepmd_test::tf_deeppot_ref(), - &deepmd_test::tf_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, - {"pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_sea.pth", - false, &deepmd_test::sea_deeppot_ref(), - &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, - {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_sea.pt2", - false, &deepmd_test::sea_deeppot_ref(), - &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true}, - {"jax_savedmodel", Backend::JAX, - "../../tests/infer/deeppot_sea.savedmodel", false, - &deepmd_test::sea_deeppot_ref(), nullptr, 1e-10, 1e-4, true}, - {"paddle_json", Backend::Paddle, "../../tests/infer/deeppot_sea.json", - false, &deepmd_test::sea_deeppot_ref(), nullptr, 1e-7, 1e-4, false}}; -} - -std::vector fparam_aparam_cases() { - return {{"tensorflow_pb", Backend::TensorFlow, - "../../tests/infer/fparam_aparam.pbtxt", true, - &deepmd_test::tf_fparam_aparam_ref(), "", 1e-10, 1e-4, true}, - {"pytorch_pth", Backend::PyTorch, - "../../tests/infer/fparam_aparam.pth", false, nullptr, - "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4, true}, - {"pytorch_pt2", Backend::PTExpt, - "../../tests/infer/fparam_aparam.pt2", false, nullptr, - "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4, true}}; -} +::testing::AssertionResult convert_pbtxt_model(const std::string& source, + const std::string& target) { + try { + DP_ConvertPbtxtToPb(source.c_str(), target.c_str()); + } catch (const std::exception& e) { + return ::testing::AssertionFailure() << "pbtxt-to-pb conversion failed for " + << source << ": " << e.what(); + } catch (...) { + return ::testing::AssertionFailure() << "pbtxt-to-pb conversion failed for " + << source << ": unknown exception"; + } -deepmd_test::DeepPotRef load_fparam_ref(const std::string& ref_path) { - deepmd_test::ExpectedRef ref_file; - ref_file.load(ref_path); - deepmd_test::DeepPotRef ref; - ref.atomic_energy = ref_file.get("default", "expected_e"); - ref.force = ref_file.get("default", "expected_f"); - ref.atomic_virial = ref_file.get("default", "expected_v"); - ref.numb_types = 1; - ref.dim_fparam = 1; - ref.dim_aparam = 1; - ref.type_map = "O"; - return ref; + if (!path_exists(target)) { + return ::testing::AssertionFailure() + << "pbtxt-to-pb conversion failed for " << source + << ": output was not created: " << target; + } + return ::testing::AssertionSuccess(); } class UniversalDeepPotCTest : public ::testing::TestWithParam { @@ -158,7 +50,7 @@ class UniversalDeepPotCTest : public ::testing::TestWithParam { std::string model_path = param.model_path; if (param.convert_pbtxt) { converted_model = "deeppot_c_universal_" + param.name + ".pb"; - DP_ConvertPbtxtToPb(param.model_path.c_str(), converted_model.c_str()); + ASSERT_TRUE(convert_pbtxt_model(param.model_path, converted_model)); model_path = converted_model; } dp = DP_NewDeepPot(model_path.c_str()); @@ -204,7 +96,7 @@ class FParamAParamDeepPotCTest std::string model_path = param.model_path; if (param.convert_pbtxt) { converted_model = "deeppot_c_fparam_aparam_" + param.name + ".pb"; - DP_ConvertPbtxtToPb(param.model_path.c_str(), converted_model.c_str()); + ASSERT_TRUE(convert_pbtxt_model(param.model_path, converted_model)); model_path = converted_model; } dp = DP_NewDeepPot(model_path.c_str()); diff --git a/source/api_cc/tests/deeppot_universal_test_common.h b/source/api_cc/tests/deeppot_universal_test_common.h new file mode 100644 index 0000000000..565a151760 --- /dev/null +++ b/source/api_cc/tests/deeppot_universal_test_common.h @@ -0,0 +1,165 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later +#pragma once + +#include + +#include +#include + +#include "../../tests/infer/deeppot_universal_data.h" +#include "DeepPotPTExpt.h" +#include "expected_ref.h" + +namespace deepmd_test { +namespace universal { + +enum class Backend { TensorFlow, PyTorch, PTExpt, JAX, Paddle }; + +struct ModelCase { + std::string name; + Backend backend; + std::string model_path; + bool convert_pbtxt; + const DeepPotRef* ref; + const DeepPotRef* no_pbc_ref; + double double_tol; + double float_tol; + bool supports_float; + bool supports_nframes; + bool supports_lmp_nlist_mapping; +}; + +struct FParamAParamCase { + std::string name; + Backend backend; + std::string model_path; + bool convert_pbtxt; + const DeepPotRef* builtin_ref; + std::string ref_path; + double double_tol; + double float_tol; + bool supports_float; +}; + +inline bool path_exists(const std::string& path) { + struct stat statbuf; + return stat(path.c_str(), &statbuf) == 0; +} + +inline bool backend_enabled(Backend backend) { + switch (backend) { + case Backend::TensorFlow: +#ifdef BUILD_TENSORFLOW + return true; +#else + return false; +#endif + case Backend::PyTorch: +#ifdef BUILD_PYTORCH + return true; +#else + return false; +#endif + case Backend::PTExpt: +#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT + return true; +#else + return false; +#endif + case Backend::JAX: +#ifdef BUILD_JAX + return true; +#else + return false; +#endif + case Backend::Paddle: +#ifdef BUILD_PADDLE + return true; +#else + return false; +#endif + } + return false; +} + +inline std::string backend_name(Backend backend) { + switch (backend) { + case Backend::TensorFlow: + return "TensorFlow"; + case Backend::PyTorch: + return "PyTorch"; + case Backend::PTExpt: + return "PTExpt"; + case Backend::JAX: + return "JAX"; + case Backend::Paddle: + return "Paddle"; + } + return "Unknown"; +} + +inline std::vector model_cases() { + return { + {"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/deeppot.pbtxt", + /*convert_pbtxt=*/true, &tf_deeppot_ref(), &tf_deeppot_no_pbc_ref(), + 1e-10, 1e-4, + /*supports_float=*/true, + /*supports_nframes=*/true, + /*supports_lmp_nlist_mapping=*/true}, + {"pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_sea.pth", + /*convert_pbtxt=*/false, &sea_deeppot_ref(), &sea_deeppot_no_pbc_ref(), + 1e-10, 1e-4, + /*supports_float=*/true, + /*supports_nframes=*/false, + /*supports_lmp_nlist_mapping=*/true}, + {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_sea.pt2", + /*convert_pbtxt=*/false, &sea_deeppot_ref(), &sea_deeppot_no_pbc_ref(), + 1e-10, 1e-4, + /*supports_float=*/true, + /*supports_nframes=*/false, + /*supports_lmp_nlist_mapping=*/true}, + {"jax_savedmodel", Backend::JAX, + "../../tests/infer/deeppot_sea.savedmodel", + /*convert_pbtxt=*/false, &sea_deeppot_ref(), nullptr, 1e-10, 1e-4, + /*supports_float=*/true, + /*supports_nframes=*/false, + /*supports_lmp_nlist_mapping=*/true}, + {"paddle_json", Backend::Paddle, "../../tests/infer/deeppot_sea.json", + /*convert_pbtxt=*/false, &sea_deeppot_ref(), nullptr, 1e-7, 1e-4, + /*supports_float=*/false, + /*supports_nframes=*/false, + /*supports_lmp_nlist_mapping=*/false}}; +} + +inline std::vector fparam_aparam_cases() { + return { + {"tensorflow_pb", Backend::TensorFlow, + "../../tests/infer/fparam_aparam.pbtxt", + /*convert_pbtxt=*/true, &tf_fparam_aparam_ref(), "", 1e-10, 1e-4, + /*supports_float=*/true}, + {"pytorch_pth", Backend::PyTorch, "../../tests/infer/fparam_aparam.pth", + /*convert_pbtxt=*/false, nullptr, + "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4, + /*supports_float=*/true}, + {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/fparam_aparam.pt2", + /*convert_pbtxt=*/false, nullptr, + "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4, + /*supports_float=*/true}}; +} + +inline DeepPotRef load_fparam_ref(const std::string& ref_path) { + ExpectedRef ref_file; + ref_file.load(ref_path); + DeepPotRef ref; + ref.atomic_energy = ref_file.get("default", "expected_e"); + ref.force = ref_file.get("default", "expected_f"); + ref.atomic_virial = ref_file.get("default", "expected_v"); + ref.numb_types = 1; + ref.dim_fparam = 1; + ref.dim_aparam = 1; + ref.type_map = "O"; + return ref; +} + +} // namespace universal +} // namespace deepmd_test diff --git a/source/api_cc/tests/test_deeppot_universal.cc b/source/api_cc/tests/test_deeppot_universal.cc index e510626882..bcde5424e4 100644 --- a/source/api_cc/tests/test_deeppot_universal.cc +++ b/source/api_cc/tests/test_deeppot_universal.cc @@ -1,37 +1,23 @@ // SPDX-License-Identifier: LGPL-3.0-or-later #include -#include #include #include #include +#include #include #include #include -#include "../../tests/infer/deeppot_universal_data.h" #include "DeepPot.h" #include "DeepPotPTExpt.h" +#include "deeppot_universal_test_common.h" #include "expected_ref.h" #include "test_utils.h" namespace { -enum class Backend { TensorFlow, PyTorch, PTExpt, JAX, Paddle }; - -struct ModelCase { - std::string name; - Backend backend; - std::string model_path; - bool convert_pbtxt; - const deepmd_test::DeepPotRef* ref; - const deepmd_test::DeepPotRef* no_pbc_ref; - double double_tol; - double float_tol; - bool supports_float; - bool supports_nframes; - bool supports_lmp_nlist_mapping; -}; +using namespace deepmd_test::universal; struct VariantDeepPotCase { std::string name; @@ -58,18 +44,6 @@ struct VariantDeepPotCase { bool supports_no_pbc_lmp_nlist_atomic; }; -struct FParamAParamCase { - std::string name; - Backend backend; - std::string model_path; - bool convert_pbtxt; - const deepmd_test::DeepPotRef* builtin_ref; - std::string ref_path; - double double_tol; - double float_tol; - bool supports_float; -}; - struct DefaultFParamCase { std::string name; Backend backend; @@ -80,88 +54,11 @@ struct DefaultFParamCase { bool supports_float; }; -bool path_exists(const std::string& path) { - struct stat statbuf; - return stat(path.c_str(), &statbuf) == 0; -} - -bool backend_enabled(Backend backend) { - switch (backend) { - case Backend::TensorFlow: -#ifdef BUILD_TENSORFLOW - return true; -#else - return false; -#endif - case Backend::PyTorch: -#ifdef BUILD_PYTORCH - return true; -#else - return false; -#endif - case Backend::PTExpt: -#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT - return true; -#else - return false; -#endif - case Backend::JAX: -#ifdef BUILD_JAX - return true; -#else - return false; -#endif - case Backend::Paddle: -#ifdef BUILD_PADDLE - return true; -#else - return false; -#endif - } - return false; -} - -std::string backend_name(Backend backend) { - switch (backend) { - case Backend::TensorFlow: - return "TensorFlow"; - case Backend::PyTorch: - return "PyTorch"; - case Backend::PTExpt: - return "PTExpt"; - case Backend::JAX: - return "JAX"; - case Backend::Paddle: - return "Paddle"; - } - return "Unknown"; -} - -std::vector model_cases() { - return { - {"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/deeppot.pbtxt", - true, &deepmd_test::tf_deeppot_ref(), - &deepmd_test::tf_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, true, true}, - {"pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_sea.pth", - false, &deepmd_test::sea_deeppot_ref(), - &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, false, true}, - {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_sea.pt2", - false, &deepmd_test::sea_deeppot_ref(), - &deepmd_test::sea_deeppot_no_pbc_ref(), 1e-10, 1e-4, true, false, true}, - {"jax_savedmodel", Backend::JAX, - "../../tests/infer/deeppot_sea.savedmodel", false, - &deepmd_test::sea_deeppot_ref(), nullptr, 1e-10, 1e-4, true, false, - true}, - {"paddle_json", Backend::Paddle, "../../tests/infer/deeppot_sea.json", - false, &deepmd_test::sea_deeppot_ref(), nullptr, 1e-7, 1e-4, false, - false, false}}; -} - std::vector variant_deeppot_cases() { return {{"tensorflow_r", Backend::TensorFlow, "../../tests/infer/deeppot-r.pbtxt", - true, + /*convert_pbtxt=*/true, &deepmd_test::tf_deeppot_r_ref(), &deepmd_test::tf_deeppot_r_no_pbc_ref(), "", @@ -169,21 +66,21 @@ std::vector variant_deeppot_cases() { "", 1e-10, 1e-4, - true, - true, - true, - true, - true, - true, - false, - true, - false, - false, - false}, + /*supports_float=*/true, + /*supports_finite_difference=*/true, + /*supports_lmp_nlist=*/true, + /*supports_lmp_nlist_atomic=*/true, + /*supports_lmp_nlist_cutoff_twice=*/true, + /*supports_lmp_nlist_type_sel=*/true, + /*supports_print_summary=*/false, + /*supports_no_pbc_simple=*/true, + /*supports_no_pbc_atomic=*/false, + /*supports_no_pbc_lmp_nlist=*/false, + /*supports_no_pbc_lmp_nlist_atomic=*/false}, {"dpa_jax_savedmodel", Backend::JAX, "../../tests/infer/deeppot_dpa.savedmodel", - false, + /*convert_pbtxt=*/false, &deepmd_test::jax_dpa_deeppot_ref(), &deepmd_test::jax_dpa_deeppot_no_pbc_ref(), "", @@ -191,21 +88,21 @@ std::vector variant_deeppot_cases() { "", 1e-7, 1e-1, - true, - false, - false, - false, - false, - false, - false, - true, - true, - true, - true}, + /*supports_float=*/true, + /*supports_finite_difference=*/false, + /*supports_lmp_nlist=*/false, + /*supports_lmp_nlist_atomic=*/false, + /*supports_lmp_nlist_cutoff_twice=*/false, + /*supports_lmp_nlist_type_sel=*/false, + /*supports_print_summary=*/false, + /*supports_no_pbc_simple=*/true, + /*supports_no_pbc_atomic=*/true, + /*supports_no_pbc_lmp_nlist=*/true, + /*supports_no_pbc_lmp_nlist_atomic=*/true}, {"dpa1_pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_dpa1.pth", - false, + /*convert_pbtxt=*/false, nullptr, nullptr, "../../tests/infer/deeppot_dpa1.expected", @@ -213,21 +110,21 @@ std::vector variant_deeppot_cases() { "nopbc", 1e-10, 1e-4, - true, - false, - false, - false, - false, - false, - false, - true, - false, - true, - false}, + /*supports_float=*/true, + /*supports_finite_difference=*/false, + /*supports_lmp_nlist=*/false, + /*supports_lmp_nlist_atomic=*/false, + /*supports_lmp_nlist_cutoff_twice=*/false, + /*supports_lmp_nlist_type_sel=*/false, + /*supports_print_summary=*/false, + /*supports_no_pbc_simple=*/true, + /*supports_no_pbc_atomic=*/false, + /*supports_no_pbc_lmp_nlist=*/true, + /*supports_no_pbc_lmp_nlist_atomic=*/false}, {"dpa1_pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_dpa1.pt2", - false, + /*convert_pbtxt=*/false, nullptr, nullptr, "../../tests/infer/deeppot_dpa1.expected", @@ -235,21 +132,21 @@ std::vector variant_deeppot_cases() { "nopbc", 1e-10, 1e-4, - true, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false}, + /*supports_float=*/true, + /*supports_finite_difference=*/true, + /*supports_lmp_nlist=*/true, + /*supports_lmp_nlist_atomic=*/true, + /*supports_lmp_nlist_cutoff_twice=*/true, + /*supports_lmp_nlist_type_sel=*/true, + /*supports_print_summary=*/true, + /*supports_no_pbc_simple=*/true, + /*supports_no_pbc_atomic=*/false, + /*supports_no_pbc_lmp_nlist=*/true, + /*supports_no_pbc_lmp_nlist_atomic=*/false}, {"dpa2_pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_dpa2.pth", - false, + /*convert_pbtxt=*/false, nullptr, nullptr, "../../tests/infer/deeppot_dpa2.expected", @@ -257,21 +154,21 @@ std::vector variant_deeppot_cases() { "nopbc", 1e-10, 1e-4, - true, - false, - false, - false, - false, - false, - false, - true, - true, - true, - true}, + /*supports_float=*/true, + /*supports_finite_difference=*/false, + /*supports_lmp_nlist=*/false, + /*supports_lmp_nlist_atomic=*/false, + /*supports_lmp_nlist_cutoff_twice=*/false, + /*supports_lmp_nlist_type_sel=*/false, + /*supports_print_summary=*/false, + /*supports_no_pbc_simple=*/true, + /*supports_no_pbc_atomic=*/true, + /*supports_no_pbc_lmp_nlist=*/true, + /*supports_no_pbc_lmp_nlist_atomic=*/true}, {"dpa2_pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_dpa2.pt2", - false, + /*convert_pbtxt=*/false, nullptr, nullptr, "../../tests/infer/deeppot_dpa2.expected", @@ -279,21 +176,21 @@ std::vector variant_deeppot_cases() { "nopbc", 1e-10, 1e-4, - true, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false}, + /*supports_float=*/true, + /*supports_finite_difference=*/true, + /*supports_lmp_nlist=*/true, + /*supports_lmp_nlist_atomic=*/true, + /*supports_lmp_nlist_cutoff_twice=*/true, + /*supports_lmp_nlist_type_sel=*/true, + /*supports_print_summary=*/true, + /*supports_no_pbc_simple=*/true, + /*supports_no_pbc_atomic=*/false, + /*supports_no_pbc_lmp_nlist=*/true, + /*supports_no_pbc_lmp_nlist_atomic=*/false}, {"dpa3_pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_dpa3.pth", - false, + /*convert_pbtxt=*/false, nullptr, nullptr, "../../tests/infer/deeppot_dpa3.expected", @@ -301,21 +198,21 @@ std::vector variant_deeppot_cases() { "nopbc", 1e-10, 1e-4, - true, - false, - false, - false, - false, - false, - false, - true, - false, - true, - false}, + /*supports_float=*/true, + /*supports_finite_difference=*/false, + /*supports_lmp_nlist=*/false, + /*supports_lmp_nlist_atomic=*/false, + /*supports_lmp_nlist_cutoff_twice=*/false, + /*supports_lmp_nlist_type_sel=*/false, + /*supports_print_summary=*/false, + /*supports_no_pbc_simple=*/true, + /*supports_no_pbc_atomic=*/false, + /*supports_no_pbc_lmp_nlist=*/true, + /*supports_no_pbc_lmp_nlist_atomic=*/false}, {"dpa3_pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_dpa3.pt2", - false, + /*convert_pbtxt=*/false, nullptr, nullptr, "../../tests/infer/deeppot_dpa3.expected", @@ -323,21 +220,21 @@ std::vector variant_deeppot_cases() { "nopbc", 1e-10, 1e-4, - true, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false}, + /*supports_float=*/true, + /*supports_finite_difference=*/true, + /*supports_lmp_nlist=*/true, + /*supports_lmp_nlist_atomic=*/true, + /*supports_lmp_nlist_cutoff_twice=*/true, + /*supports_lmp_nlist_type_sel=*/true, + /*supports_print_summary=*/true, + /*supports_no_pbc_simple=*/true, + /*supports_no_pbc_atomic=*/false, + /*supports_no_pbc_lmp_nlist=*/true, + /*supports_no_pbc_lmp_nlist_atomic=*/false}, {"dpa4_pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_dpa4.pt2", - false, + /*convert_pbtxt=*/false, nullptr, nullptr, "../../tests/infer/deeppot_dpa4.expected", @@ -345,53 +242,28 @@ std::vector variant_deeppot_cases() { "nopbc", 1e-10, 1e-4, - true, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false}}; -} - -std::vector fparam_aparam_cases() { - return {{"tensorflow_pb", Backend::TensorFlow, - "../../tests/infer/fparam_aparam.pbtxt", true, - &deepmd_test::tf_fparam_aparam_ref(), "", 1e-10, 1e-4, true}, - {"pytorch_pth", Backend::PyTorch, - "../../tests/infer/fparam_aparam.pth", false, nullptr, - "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4, true}, - {"pytorch_pt2", Backend::PTExpt, - "../../tests/infer/fparam_aparam.pt2", false, nullptr, - "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4, true}}; + /*supports_float=*/true, + /*supports_finite_difference=*/true, + /*supports_lmp_nlist=*/true, + /*supports_lmp_nlist_atomic=*/true, + /*supports_lmp_nlist_cutoff_twice=*/true, + /*supports_lmp_nlist_type_sel=*/true, + /*supports_print_summary=*/true, + /*supports_no_pbc_simple=*/true, + /*supports_no_pbc_atomic=*/false, + /*supports_no_pbc_lmp_nlist=*/true, + /*supports_no_pbc_lmp_nlist_atomic=*/false}}; } std::vector default_fparam_cases() { - return { - {"pytorch_pth", Backend::PyTorch, - "../../tests/infer/fparam_aparam_default.pth", - "../../tests/infer/fparam_aparam_default.expected", 1e-7, 1e-4, true}, - {"pytorch_pt2", Backend::PTExpt, - "../../tests/infer/fparam_aparam_default.pt2", - "../../tests/infer/fparam_aparam_default.expected", 1e-7, 1e-4, true}}; -} - -deepmd_test::DeepPotRef load_fparam_ref(const std::string& ref_path) { - deepmd_test::ExpectedRef ref_file; - ref_file.load(ref_path); - deepmd_test::DeepPotRef ref; - ref.atomic_energy = ref_file.get("default", "expected_e"); - ref.force = ref_file.get("default", "expected_f"); - ref.atomic_virial = ref_file.get("default", "expected_v"); - ref.numb_types = 1; - ref.dim_fparam = 1; - ref.dim_aparam = 1; - ref.type_map = "O"; - return ref; + return {{"pytorch_pth", Backend::PyTorch, + "../../tests/infer/fparam_aparam_default.pth", + "../../tests/infer/fparam_aparam_default.expected", 1e-7, 1e-4, + /*supports_float=*/true}, + {"pytorch_pt2", Backend::PTExpt, + "../../tests/infer/fparam_aparam_default.pt2", + "../../tests/infer/fparam_aparam_default.expected", 1e-7, 1e-4, + /*supports_float=*/true}}; } deepmd_test::DeepPotRef load_expected_ref(const std::string& ref_path, @@ -405,6 +277,26 @@ deepmd_test::DeepPotRef load_expected_ref(const std::string& ref_path, return ref; } +::testing::AssertionResult convert_pbtxt_model(const std::string& source, + const std::string& target) { + try { + deepmd::convert_pbtxt_to_pb(source, target); + } catch (const std::exception& e) { + return ::testing::AssertionFailure() << "pbtxt-to-pb conversion failed for " + << source << ": " << e.what(); + } catch (...) { + return ::testing::AssertionFailure() << "pbtxt-to-pb conversion failed for " + << source << ": unknown exception"; + } + + if (!path_exists(target)) { + return ::testing::AssertionFailure() + << "pbtxt-to-pb conversion failed for " << source + << ": output was not created: " << target; + } + return ::testing::AssertionSuccess(); +} + class UniversalDeepPotTest : public ::testing::TestWithParam { protected: deepmd::DeepPot dp; @@ -421,7 +313,7 @@ class UniversalDeepPotTest : public ::testing::TestWithParam { std::string model_path = param.model_path; if (param.convert_pbtxt) { converted_model = "deeppot_universal_" + param.name + ".pb"; - deepmd::convert_pbtxt_to_pb(param.model_path, converted_model); + ASSERT_TRUE(convert_pbtxt_model(param.model_path, converted_model)); model_path = converted_model; } dp.init(model_path); @@ -479,7 +371,7 @@ class VariantDeepPotTest : public ::testing::TestWithParam { std::string model_path = param.model_path; if (param.convert_pbtxt) { converted_model = "deeppot_variant_" + param.name + ".pb"; - deepmd::convert_pbtxt_to_pb(param.model_path, converted_model); + ASSERT_TRUE(convert_pbtxt_model(param.model_path, converted_model)); model_path = converted_model; } dp.init(model_path); @@ -519,7 +411,7 @@ class FParamAParamDeepPotTest std::string model_path = param.model_path; if (param.convert_pbtxt) { converted_model = "deeppot_fparam_aparam_" + param.name + ".pb"; - deepmd::convert_pbtxt_to_pb(param.model_path, converted_model); + ASSERT_TRUE(convert_pbtxt_model(param.model_path, converted_model)); model_path = converted_model; } dp.init(model_path);