From b9b5d51dcfd885ea422ecd69087523deb9ac370a Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Fri, 28 Oct 2022 02:31:08 -0400 Subject: [PATCH 1/8] uncouple model precision and interface precision This commit allows loading float models using double interface, or the other way around. The model precision is perceived from the type of `descrpt_attr/rcut`. All `run_model` and `session_input_tensors` are rewritten as templates. This is an important step of #1948. Next functions in the whole module can be migrated to templates. --- source/api_cc/include/DataModifier.h | 3 +- source/api_cc/include/DeepPot.h | 2 + source/api_cc/include/DeepTensor.h | 5 +- source/api_cc/include/common.h | 8 ++ source/api_cc/src/DataModifier.cc | 51 ++++++++-- source/api_cc/src/DeepPot.cc | 94 ++++++++++++----- source/api_cc/src/DeepTensor.cc | 112 ++++++++++++++++---- source/api_cc/src/common.cc | 146 +++++++++++++++++++++------ 8 files changed, 336 insertions(+), 85 deletions(-) diff --git a/source/api_cc/include/DataModifier.h b/source/api_cc/include/DataModifier.h index 6637ebb522..bc752a8948 100644 --- a/source/api_cc/include/DataModifier.h +++ b/source/api_cc/include/DataModifier.h @@ -35,13 +35,14 @@ class DipoleChargeModifier tensorflow::GraphDef* graph_def; bool inited; VALUETYPE rcut; + int dtype; VALUETYPE cell_size; int ntypes; std::string model_type; std::vector sel_type; template VT get_scalar(const std::string & name) const; template void get_vector(std::vector & vec, const std::string & name) const; - void run_model (std::vector & dforce, + template void run_model (std::vector & dforce, std::vector & dvirial, tensorflow::Session * session, const std::vector> & input_tensors, diff --git a/source/api_cc/include/DeepPot.h b/source/api_cc/include/DeepPot.h index 48d2a3cd7f..cfccf19426 100644 --- a/source/api_cc/include/DeepPot.h +++ b/source/api_cc/include/DeepPot.h @@ -185,6 +185,7 @@ class DeepPot // VALUETYPE get_rcut () const; // int get_ntypes () const; VALUETYPE rcut; + int dtype; VALUETYPE cell_size; std::string model_type; std::string model_version; @@ -408,6 +409,7 @@ class DeepPotModelDevi // int get_ntypes () const; VALUETYPE rcut; VALUETYPE cell_size; + int dtype; std::string model_type; std::string model_version; int ntypes; diff --git a/source/api_cc/include/DeepTensor.h b/source/api_cc/include/DeepTensor.h index 02f579e04a..05ceb764d4 100644 --- a/source/api_cc/include/DeepTensor.h +++ b/source/api_cc/include/DeepTensor.h @@ -164,6 +164,7 @@ class DeepTensor tensorflow::GraphDef* graph_def; bool inited; VALUETYPE rcut; + int dtype; VALUETYPE cell_size; int ntypes; std::string model_type; @@ -172,13 +173,13 @@ class DeepTensor std::vector sel_type; template VT get_scalar(const std::string & name) const; template void get_vector (std::vector & vec, const std::string & name) const; - void run_model (std::vector & d_tensor_, + template void run_model (std::vector & d_tensor_, tensorflow::Session * session, const std::vector> & input_tensors, const AtomMap & atommap, const std::vector & sel_fwd, const int nghost = 0); - void run_model (std::vector & dglobal_tensor_, + template void run_model (std::vector & dglobal_tensor_, std::vector & dforce_, std::vector & dvirial_, std::vector & datom_tensor_, diff --git a/source/api_cc/include/common.h b/source/api_cc/include/common.h index 4d82e5cf8b..b93b7c2d03 100644 --- a/source/api_cc/include/common.h +++ b/source/api_cc/include/common.h @@ -155,6 +155,13 @@ session_get_vector( const std::string name_, const std::string scope = ""); +int +session_get_dtype( + tensorflow::Session* session, + const std::string name, + const std::string scope = ""); + +template int session_input_tensors (std::vector> & input_tensors, const std::vector & dcoord_, @@ -167,6 +174,7 @@ session_input_tensors (std::vector> & const deepmd::AtomMap&atommap, const std::string scope = ""); +template int session_input_tensors (std::vector> & input_tensors, const std::vector & dcoord_, diff --git a/source/api_cc/src/DataModifier.cc b/source/api_cc/src/DataModifier.cc index 98fee6d230..902b9f8bb6 100644 --- a/source/api_cc/src/DataModifier.cc +++ b/source/api_cc/src/DataModifier.cc @@ -48,7 +48,12 @@ init (const std::string & model, // for (int ii = 0; ii < nnodes; ++ii){ // cout << ii << " \t " << graph_def.node(ii).name() << endl; // } - rcut = get_scalar("descrpt_attr/rcut"); + dtype = session_get_dtype(session, "descrpt_attr/rcut"); + if (dtype == tensorflow::DT_DOUBLE) { + rcut = get_scalar("descrpt_attr/rcut"); + } else { + rcut = get_scalar("descrpt_attr/rcut"); + } cell_size = rcut; ntypes = get_scalar("descrpt_attr/ntypes"); model_type = get_scalar("model_attr/model_type"); @@ -73,6 +78,7 @@ get_vector (std::vector & vec, const std::string & name) const session_get_vector(vec, session, name, name_scope); } +template void DipoleChargeModifier:: run_model (std::vector & dforce, @@ -111,8 +117,8 @@ run_model (std::vector & dforce, assert (output_av.dim_size(0) == nframes), "nframes should match"; assert (output_av.dim_size(1) == natoms * 9), "dof of atom virial should be 9 * natoms"; - auto of = output_f.flat (); - auto ov = output_v.flat (); + auto of = output_f.flat (); + auto ov = output_v.flat (); dforce.resize(nall*3); dvirial.resize(9); @@ -124,7 +130,25 @@ run_model (std::vector & dforce, } } +template +void +DipoleChargeModifier:: +run_model (std::vector & dforce, + std::vector & dvirial, + Session * session, + const std::vector> & input_tensors, + const AtomMap & atommap, + const int nghost); +template +void +DipoleChargeModifier:: +run_model (std::vector & dforce, + std::vector & dvirial, + Session * session, + const std::vector> & input_tensors, + const AtomMap & atommap, + const int nghost); void DipoleChargeModifier:: @@ -179,8 +203,13 @@ compute (std::vector & dfcorr_, nlist_data.make_inlist(nlist); // make input tensors std::vector> input_tensors; - int ret = session_input_tensors (input_tensors, dcoord_real, ntypes, datype_real, dbox, nlist, std::vector(), std::vector(), atommap, nghost_real, 0, name_scope); - assert (nloc_real == ret); + if (dtype == tensorflow::DT_DOUBLE) { + int ret = session_input_tensors (input_tensors, dcoord_real, ntypes, datype_real, dbox, nlist, std::vector(), std::vector(), atommap, nghost_real, 0, name_scope); + assert (nloc_real == ret); + } else { + int ret = session_input_tensors (input_tensors, dcoord_real, ntypes, datype_real, dbox, nlist, std::vector(), std::vector(), atommap, nghost_real, 0, name_scope); + assert (nloc_real == ret); + } // make bond idx map std::vector bd_idx(nall, -1); for (int ii = 0; ii < pairs.size(); ++ii){ @@ -207,11 +236,7 @@ compute (std::vector & dfcorr_, TensorShape extf_shape ; extf_shape.AddDim (nframes); extf_shape.AddDim (dextf.size()); -#ifdef HIGH_PREC - Tensor extf_tensor (DT_DOUBLE, extf_shape); -#else - Tensor extf_tensor (DT_FLOAT, extf_shape); -#endif + Tensor extf_tensor ((tensorflow::DataType) dtype, extf_shape); auto extf = extf_tensor.matrix (); for (int ii = 0; ii < nframes; ++ii){ for (int jj = 0; jj < extf.size(); ++jj){ @@ -222,7 +247,11 @@ compute (std::vector & dfcorr_, input_tensors.push_back({"t_ef", extf_tensor}); // run model std::vector dfcorr, dvcorr; - run_model (dfcorr, dvcorr, session, input_tensors, atommap, nghost_real); + if (dtype == tensorflow::DT_DOUBLE) { + run_model (dfcorr, dvcorr, session, input_tensors, atommap, nghost_real); + } else { + run_model (dfcorr, dvcorr, session, input_tensors, atommap, nghost_real); + } assert(dfcorr.size() == nall_real * 3); // back map force std::vector dfcorr_1 = dfcorr; diff --git a/source/api_cc/src/DeepPot.cc b/source/api_cc/src/DeepPot.cc index 0dda00cb27..2d7ad84e89 100644 --- a/source/api_cc/src/DeepPot.cc +++ b/source/api_cc/src/DeepPot.cc @@ -18,6 +18,7 @@ std::vector cum_sum (const std::vector & n_sel) { } +template static void run_model (ENERGYTYPE & dener, std::vector & dforce_, @@ -52,8 +53,8 @@ run_model (ENERGYTYPE & dener, Tensor output_av = output_tensors[3]; auto oe = output_e.flat (); - auto of = output_f.flat (); - auto oav = output_av.flat (); + auto of = output_f.flat (); + auto oav = output_av.flat (); dener = oe(0); std::vector dforce (3 * nall); @@ -78,6 +79,7 @@ run_model (ENERGYTYPE & dener, atommap.backward (dforce_.begin(), dforce.begin(), 3); } +template static void run_model (ENERGYTYPE & dener, std::vector& dforce_, std::vector& dvirial, @@ -120,9 +122,9 @@ static void run_model (ENERGYTYPE & dener, Tensor output_av = output_tensors[3]; auto oe = output_e.flat (); - auto of = output_f.flat (); - auto oae = output_ae.flat (); - auto oav = output_av.flat (); + auto of = output_f.flat (); + auto oae = output_ae.flat (); + auto oav = output_av.flat (); dener = oe(0); std::vector dforce (3 * nall); @@ -212,7 +214,12 @@ init (const std::string & model, const int & gpu_rank, const std::string & file_ #endif // GOOGLE_CUDA || TENSORFLOW_USE_ROCM check_status (NewSession(options, &session)); check_status (session->Create(*graph_def)); - rcut = get_scalar("descrpt_attr/rcut"); + dtype = session_get_dtype(session, "descrpt_attr/rcut"); + if (dtype == tensorflow::DT_DOUBLE) { + rcut = get_scalar("descrpt_attr/rcut"); + } else { + rcut = get_scalar("descrpt_attr/rcut"); + } cell_size = rcut; ntypes = get_scalar("descrpt_attr/ntypes"); dfparam = get_scalar("fitting_attr/dfparam"); @@ -346,10 +353,16 @@ compute (ENERGYTYPE & dener, validate_fparam_aparam(nloc, fparam, aparam); std::vector> input_tensors; - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, fparam, aparam, atommap); - assert (ret == nloc); - run_model (dener, dforce_, dvirial, session, input_tensors, atommap); + if (dtype == tensorflow::DT_DOUBLE) { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, fparam, aparam, atommap); + assert (ret == nloc); + run_model (dener, dforce_, dvirial, session, input_tensors, atommap); + } else { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, fparam, aparam, atommap); + assert (ret == nloc); + run_model (dener, dforce_, dvirial, session, input_tensors, atommap); + } } void @@ -418,9 +431,15 @@ compute_inner (ENERGYTYPE & dener, nlist_data.shuffle(atommap); nlist_data.make_inlist(nlist); } - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); - assert (nloc == ret); - run_model (dener, dforce_, dvirial, session, input_tensors, atommap, nghost); + if (dtype == tensorflow::DT_DOUBLE) { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); + assert (nloc == ret); + run_model (dener, dforce_, dvirial, session, input_tensors, atommap, nghost); + } else { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); + assert (nloc == ret); + run_model (dener, dforce_, dvirial, session, input_tensors, atommap, nghost); + } } @@ -441,9 +460,14 @@ compute (ENERGYTYPE & dener, validate_fparam_aparam(atommap.get_type().size(), fparam, aparam); std::vector> input_tensors; - int nloc = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, fparam, aparam, atommap); - run_model (dener, dforce_, dvirial, datom_energy_, datom_virial_, session, input_tensors, atommap); + if (dtype == tensorflow::DT_DOUBLE) { + int nloc = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, fparam, aparam, atommap); + run_model (dener, dforce_, dvirial, datom_energy_, datom_virial_, session, input_tensors, atommap); + } else { + int nloc = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, fparam, aparam, atommap); + run_model (dener, dforce_, dvirial, datom_energy_, datom_virial_, session, input_tensors, atommap); + } } @@ -497,9 +521,14 @@ compute (ENERGYTYPE & dener, nlist_data.make_inlist(nlist); } - int ret = session_input_tensors (input_tensors, dcoord, ntypes, datype, dbox, nlist, fparam, aparam, atommap, nghost_real, ago); assert (nloc_real == ret); - run_model (dener, dforce, dvirial, datom_energy, datom_virial, session, input_tensors, atommap, nghost_real); + if (dtype == tensorflow::DT_DOUBLE) { + int ret = session_input_tensors (input_tensors, dcoord, ntypes, datype, dbox, nlist, fparam, aparam, atommap, nghost_real, ago); + run_model (dener, dforce, dvirial, datom_energy, datom_virial, session, input_tensors, atommap, nghost_real); + } else { + int ret = session_input_tensors (input_tensors, dcoord, ntypes, datype, dbox, nlist, fparam, aparam, atommap, nghost_real, ago); + run_model (dener, dforce, dvirial, datom_energy, datom_virial, session, input_tensors, atommap, nghost_real); + } // bkw map dforce_.resize(fwd_map.size() * 3); @@ -587,7 +616,12 @@ init (const std::vector & models, const int & gpu_rank, const std:: check_status (NewSession(options, &(sessions[ii]))); check_status (sessions[ii]->Create(*graph_defs[ii])); } - rcut = get_scalar("descrpt_attr/rcut"); + dtype = session_get_dtype(sessions[0], "descrpt_attr/rcut"); + if (dtype == tensorflow::DT_DOUBLE) { + rcut = get_scalar("descrpt_attr/rcut"); + } else { + rcut = get_scalar("descrpt_attr/rcut"); + } cell_size = rcut; ntypes = get_scalar("descrpt_attr/ntypes"); dfparam = get_scalar("fitting_attr/dfparam"); @@ -750,14 +784,21 @@ compute (std::vector & all_energy, nlist_data.shuffle(atommap); nlist_data.make_inlist(nlist); } - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); all_energy.resize (numb_models); all_force.resize (numb_models); all_virial.resize (numb_models); - assert (nloc == ret); + for (unsigned ii = 0; ii < numb_models; ++ii) { - run_model (all_energy[ii], all_force[ii], all_virial[ii], sessions[ii], input_tensors, atommap, nghost); + if (dtype == tensorflow::DT_DOUBLE) { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); + assert (nloc == ret); + run_model (all_energy[ii], all_force[ii], all_virial[ii], sessions[ii], input_tensors, atommap, nghost); + } else { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); + assert (nloc == ret); + run_model (all_energy[ii], all_force[ii], all_virial[ii], sessions[ii], input_tensors, atommap, nghost); + } } } @@ -792,16 +833,23 @@ compute (std::vector & all_energy, nlist_data.shuffle(atommap); nlist_data.make_inlist(nlist); } - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); all_energy.resize (numb_models); all_force .resize (numb_models); all_virial.resize (numb_models); all_atom_energy.resize (numb_models); all_atom_virial.resize (numb_models); - assert (nloc == ret); + for (unsigned ii = 0; ii < numb_models; ++ii) { - run_model (all_energy[ii], all_force[ii], all_virial[ii], all_atom_energy[ii], all_atom_virial[ii], sessions[ii], input_tensors, atommap, nghost); + if (dtype == tensorflow::DT_DOUBLE) { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); + assert (nloc == ret); + run_model (all_energy[ii], all_force[ii], all_virial[ii], all_atom_energy[ii], all_atom_virial[ii], sessions[ii], input_tensors, atommap, nghost); + } else { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); + assert (nloc == ret); + run_model (all_energy[ii], all_force[ii], all_virial[ii], all_atom_energy[ii], all_atom_virial[ii], sessions[ii], input_tensors, atommap, nghost); + } } } diff --git a/source/api_cc/src/DeepTensor.cc b/source/api_cc/src/DeepTensor.cc index 777dd6dc07..fa65d9e281 100644 --- a/source/api_cc/src/DeepTensor.cc +++ b/source/api_cc/src/DeepTensor.cc @@ -43,7 +43,12 @@ init (const std::string & model, deepmd::check_status (NewSession(options, &session)); deepmd::check_status (ReadBinaryProto(Env::Default(), model, graph_def)); deepmd::check_status (session->Create(*graph_def)); - rcut = get_scalar("descrpt_attr/rcut"); + dtype = session_get_dtype(session, "descrpt_attr/rcut"); + if (dtype == tensorflow::DT_DOUBLE) { + rcut = get_scalar("descrpt_attr/rcut"); + } else { + rcut = get_scalar("descrpt_attr/rcut"); + } cell_size = rcut; ntypes = get_scalar("descrpt_attr/ntypes"); odim = get_scalar("model_attr/output_dim"); @@ -92,6 +97,7 @@ get_vector (std::vector & vec, const std::string & name) const session_get_vector(vec, session, name, name_scope); } +template void DeepTensor:: run_model (std::vector & d_tensor_, @@ -118,7 +124,7 @@ run_model (std::vector & d_tensor_, Tensor output_t = output_tensors[0]; // Yixiao: newer model may output rank 2 tensor [nframes x (natoms x noutdim)] // assert (output_t.dims() == 1), "dim of output tensor should be 1"; - auto ot = output_t.flat (); + auto ot = output_t.flat (); // this is an Eigen Tensor int o_size = ot.size(); @@ -137,6 +143,26 @@ run_model (std::vector & d_tensor_, select_map(d_tensor_, d_tensor, sel_srt, odim); } +template +void +DeepTensor:: +run_model (std::vector & d_tensor_, + Session * session, + const std::vector> & input_tensors, + const AtomMap &atommap, + const std::vector & sel_fwd, + const int nghost); +template +void +DeepTensor:: +run_model (std::vector & d_tensor_, + Session * session, + const std::vector> & input_tensors, + const AtomMap &atommap, + const std::vector & sel_fwd, + const int nghost); + +template void DeepTensor:: run_model (std::vector & dglobal_tensor_, @@ -195,10 +221,10 @@ run_model (std::vector & dglobal_tensor_, assert (output_av.dim_size(1) == odim * nall * 9), "dof of atomic virial should be odim * nall * 9"; auto ogt = output_gt.flat (); - auto of = output_f.flat (); - auto ov = output_v.flat (); - auto oat = output_at.flat (); - auto oav = output_av.flat (); + auto of = output_f.flat (); + auto ov = output_v.flat (); + auto oat = output_at.flat (); + auto oav = output_av.flat (); // global tensor dglobal_tensor_.resize(odim); @@ -244,6 +270,32 @@ run_model (std::vector & dglobal_tensor_, } } +template +void +DeepTensor:: +run_model (std::vector & dglobal_tensor_, + std::vector & dforce_, + std::vector & dvirial_, + std::vector & datom_tensor_, + std::vector & datom_virial_, + tensorflow::Session * session, + const std::vector> & input_tensors, + const AtomMap & atommap, + const std::vector & sel_fwd, + const int nghost); +template +void +DeepTensor:: +run_model (std::vector & dglobal_tensor_, + std::vector & dforce_, + std::vector & dvirial_, + std::vector & datom_tensor_, + std::vector & datom_virial_, + tensorflow::Session * session, + const std::vector> & input_tensors, + const AtomMap & atommap, + const std::vector & sel_fwd, + const int nghost); void DeepTensor:: @@ -416,10 +468,16 @@ compute_inner (std::vector & dtensor_, select_by_type(sel_fwd, sel_bkw, nghost_sel, dcoord_, datype_, 0, sel_type); std::vector> input_tensors; - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, std::vector(), std::vector(), atommap, name_scope); - assert (ret == nloc); - run_model (dtensor_, session, input_tensors, atommap, sel_fwd); + if (dtype == tensorflow::DT_DOUBLE) { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, std::vector(), std::vector(), atommap, name_scope); + assert (ret == nloc); + run_model (dtensor_, session, input_tensors, atommap, sel_fwd); + } else { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, std::vector(), std::vector(), atommap, name_scope); + assert (ret == nloc); + run_model (dtensor_, session, input_tensors, atommap, sel_fwd); + } } void @@ -449,10 +507,16 @@ compute_inner (std::vector & dtensor_, nlist_data.make_inlist(nlist); std::vector> input_tensors; - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, std::vector(), std::vector(), atommap, nghost, 0, name_scope); - assert (nloc == ret); - run_model (dtensor_, session, input_tensors, atommap, sel_fwd, nghost); + if (dtype == tensorflow::DT_DOUBLE) { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, std::vector(), std::vector(), atommap, nghost, 0, name_scope); + assert (nloc == ret); + run_model (dtensor_, session, input_tensors, atommap, sel_fwd, nghost); + } else { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, std::vector(), std::vector(), atommap, nghost, 0, name_scope); + assert (nloc == ret); + run_model (dtensor_, session, input_tensors, atommap, sel_fwd, nghost); + } } void @@ -477,10 +541,16 @@ compute_inner (std::vector & dglobal_tensor_, select_by_type(sel_fwd, sel_bkw, nghost_sel, dcoord_, datype_, 0, sel_type); std::vector> input_tensors; - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, std::vector(), std::vector(), atommap, name_scope); - assert (ret == nloc); - run_model (dglobal_tensor_, dforce_, dvirial_, datom_tensor_, datom_virial_, session, input_tensors, atommap, sel_fwd); + if (dtype == tensorflow::DT_DOUBLE) { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, std::vector(), std::vector(), atommap, name_scope); + assert (ret == nloc); + run_model (dglobal_tensor_, dforce_, dvirial_, datom_tensor_, datom_virial_, session, input_tensors, atommap, sel_fwd); + } else { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, std::vector(), std::vector(), atommap, name_scope); + assert (ret == nloc); + run_model (dglobal_tensor_, dforce_, dvirial_, datom_tensor_, datom_virial_, session, input_tensors, atommap, sel_fwd); + } } void @@ -514,9 +584,15 @@ compute_inner (std::vector & dglobal_tensor_, nlist_data.make_inlist(nlist); std::vector> input_tensors; - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, std::vector(), std::vector(), atommap, nghost, 0, name_scope); - assert (nloc == ret); - run_model (dglobal_tensor_, dforce_, dvirial_, datom_tensor_, datom_virial_, session, input_tensors, atommap, sel_fwd, nghost); + if (dtype == tensorflow::DT_DOUBLE) { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, std::vector(), std::vector(), atommap, nghost, 0, name_scope); + assert (nloc == ret); + run_model (dglobal_tensor_, dforce_, dvirial_, datom_tensor_, datom_virial_, session, input_tensors, atommap, sel_fwd, nghost); + } else { + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, std::vector(), std::vector(), atommap, nghost, 0, name_scope); + assert (nloc == ret); + run_model (dglobal_tensor_, dforce_, dvirial_, datom_tensor_, datom_virial_, session, input_tensors, atommap, sel_fwd, nghost); + } } diff --git a/source/api_cc/src/common.cc b/source/api_cc/src/common.cc index 01c2dd5f8d..d16d60f4ad 100644 --- a/source/api_cc/src/common.cc +++ b/source/api_cc/src/common.cc @@ -274,6 +274,7 @@ name_prefix(const std::string & scope) return prefix; } +template int deepmd:: session_input_tensors ( @@ -327,28 +328,32 @@ session_input_tensors ( aparam_shape.AddDim (nframes); aparam_shape.AddDim (aparam_.size()); -#ifdef HIGH_PREC - Tensor coord_tensor (DT_DOUBLE, coord_shape); - Tensor box_tensor (DT_DOUBLE, box_shape); - Tensor fparam_tensor (DT_DOUBLE, fparam_shape); - Tensor aparam_tensor (DT_DOUBLE, aparam_shape); -#else - Tensor coord_tensor (DT_FLOAT, coord_shape); - Tensor box_tensor (DT_FLOAT, box_shape); - Tensor fparam_tensor (DT_FLOAT, fparam_shape); - Tensor aparam_tensor (DT_FLOAT, aparam_shape); -#endif + tensorflow::DataType model_type; + if(std::is_same::value){ + model_type = tensorflow::DT_DOUBLE; + } + else if(std::is_same::value){ + model_type = tensorflow::DT_FLOAT; + } + else{ + throw deepmd::deepmd_exception("unsupported data type"); + } + Tensor coord_tensor (model_type, coord_shape); + Tensor box_tensor (model_type, box_shape); + Tensor fparam_tensor (model_type, fparam_shape); + Tensor aparam_tensor (model_type, aparam_shape); + Tensor type_tensor (DT_INT32, type_shape); Tensor mesh_tensor (DT_INT32, mesh_shape); Tensor natoms_tensor (DT_INT32, natoms_shape); - auto coord = coord_tensor.matrix (); + auto coord = coord_tensor.matrix (); auto type = type_tensor.matrix (); - auto box = box_tensor.matrix (); + auto box = box_tensor.matrix (); auto mesh = mesh_tensor.flat (); auto natoms = natoms_tensor.flat (); - auto fparam = fparam_tensor.matrix (); - auto aparam = aparam_tensor.matrix (); + auto fparam = fparam_tensor.matrix (); + auto aparam = aparam_tensor.matrix (); std::vector dcoord (dcoord_); atommap.forward (dcoord.begin(), dcoord_.begin(), 3); @@ -409,6 +414,7 @@ session_input_tensors ( return nloc; } +template int deepmd:: session_input_tensors ( @@ -459,28 +465,32 @@ session_input_tensors ( aparam_shape.AddDim (nframes); aparam_shape.AddDim (aparam_.size()); -#ifdef HIGH_PREC - Tensor coord_tensor (DT_DOUBLE, coord_shape); - Tensor box_tensor (DT_DOUBLE, box_shape); - Tensor fparam_tensor (DT_DOUBLE, fparam_shape); - Tensor aparam_tensor (DT_DOUBLE, aparam_shape); -#else - Tensor coord_tensor (DT_FLOAT, coord_shape); - Tensor box_tensor (DT_FLOAT, box_shape); - Tensor fparam_tensor (DT_FLOAT, fparam_shape); - Tensor aparam_tensor (DT_FLOAT, aparam_shape); -#endif + tensorflow::DataType model_type; + if(std::is_same::value){ + model_type = tensorflow::DT_DOUBLE; + } + else if(std::is_same::value){ + model_type = tensorflow::DT_FLOAT; + } + else{ + throw deepmd::deepmd_exception("unsupported data type"); + } + Tensor coord_tensor (model_type, coord_shape); + Tensor box_tensor (model_type, box_shape); + Tensor fparam_tensor (model_type, fparam_shape); + Tensor aparam_tensor (model_type, aparam_shape); + Tensor type_tensor (DT_INT32, type_shape); Tensor mesh_tensor (DT_INT32, mesh_shape); Tensor natoms_tensor (DT_INT32, natoms_shape); - auto coord = coord_tensor.matrix (); + auto coord = coord_tensor.matrix (); auto type = type_tensor.matrix (); - auto box = box_tensor.matrix (); + auto box = box_tensor.matrix (); auto mesh = mesh_tensor.flat (); auto natoms = natoms_tensor.flat (); - auto fparam = fparam_tensor.matrix (); - auto aparam = aparam_tensor.matrix (); + auto fparam = fparam_tensor.matrix (); + auto aparam = aparam_tensor.matrix (); std::vector dcoord (dcoord_); atommap.forward (dcoord.begin(), dcoord_.begin(), 3); @@ -584,6 +594,25 @@ session_get_vector(std::vector & o_vec, Session* session, const std::string } +int +deepmd:: +session_get_dtype(tensorflow::Session* session, const std::string name_, const std::string scope) +{ + std::string name = name_; + if (scope != "") { + name = scope + "/" + name; + } + std::vector output_tensors; + deepmd::check_status (session->Run(std::vector> ({}), + {name.c_str()}, + {}, + &output_tensors)); + Tensor output_rc = output_tensors[0]; + // cast enum to int + return (int)output_rc.dtype(); +} + + template void deepmd:: @@ -880,3 +909,60 @@ convert_pbtxt_to_pb(std::string fn_pb_txt, std::string fn_pb) std::fstream output(fn_pb, std::ios::out | std::ios::trunc | std::ios::binary); graph_def.SerializeToOstream(&output); } + +template +int +deepmd:: +session_input_tensors (std::vector> & input_tensors, + const std::vector & dcoord_, + const int & ntypes, + const std::vector & datype_, + const std::vector & dbox, + const VALUETYPE & cell_size, + const std::vector & fparam_, + const std::vector & aparam_, + const deepmd::AtomMap&atommap, + const std::string scope); +template +int +deepmd:: +session_input_tensors (std::vector> & input_tensors, + const std::vector & dcoord_, + const int & ntypes, + const std::vector & datype_, + const std::vector & dbox, + const VALUETYPE & cell_size, + const std::vector & fparam_, + const std::vector & aparam_, + const deepmd::AtomMap&atommap, + const std::string scope); +template +int +deepmd:: +session_input_tensors (std::vector> & input_tensors, + const std::vector & dcoord_, + const int & ntypes, + const std::vector & datype_, + const std::vector & dbox, + InputNlist & dlist, + const std::vector & fparam_, + const std::vector & aparam_, + const deepmd::AtomMap&atommap, + const int nghost, + const int ago, + const std::string scope); +template +int +deepmd:: +session_input_tensors (std::vector> & input_tensors, + const std::vector & dcoord_, + const int & ntypes, + const std::vector & datype_, + const std::vector & dbox, + InputNlist & dlist, + const std::vector & fparam_, + const std::vector & aparam_, + const deepmd::AtomMap&atommap, + const int nghost, + const int ago, + const std::string scope); \ No newline at end of file From cab1361e9b6ea37d8b41360225c01fa9cbd83352 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Fri, 28 Oct 2022 02:40:07 -0400 Subject: [PATCH 2/8] fix errors; add comments --- source/api_cc/include/common.h | 48 ++++++++++++++++++++++++++++++++++ source/api_cc/src/DeepPot.cc | 3 ++- 2 files changed, 50 insertions(+), 1 deletion(-) diff --git a/source/api_cc/include/common.h b/source/api_cc/include/common.h index b93b7c2d03..9b1f7b77f1 100644 --- a/source/api_cc/include/common.h +++ b/source/api_cc/include/common.h @@ -140,6 +140,13 @@ std::string name_prefix( const std::string & name_scope); +/** +* @brief Get the value of a tensor. +* @param[in] session TensorFlow session. +* @param[in] name The name of the tensor. +* @param[in] scope The scope of the tensor. +* @return The value of the tensor. +**/ template VT session_get_scalar( @@ -147,6 +154,13 @@ session_get_scalar( const std::string name, const std::string scope = ""); +/** +* @brief Get the vector of a tensor. +* @param[out] o_vec The output vector. +* @param[in] session TensorFlow session. +* @param[in] name The name of the tensor. +* @param[in] scope The scope of the tensor. +**/ template void session_get_vector( @@ -155,12 +169,32 @@ session_get_vector( const std::string name_, const std::string scope = ""); +/** +* @brief Get the type of a tensor. +* @param[in] session TensorFlow session. +* @param[in] name The name of the tensor. +* @param[in] scope The scope of the tensor. +* @return The type of the tensor as int. +**/ int session_get_dtype( tensorflow::Session* session, const std::string name, const std::string scope = ""); +/** +* @brief Get input tensors. +* @param[out] input_tensors Input tensors. +* @param[in] dcoord_ Coordinates of atoms. +* @param[in] ntypes Number of atom types. +* @param[in] datype_ Atom types. +* @param[in] dbox Box matrix. +* @param[in] cell_size Cell size. +* @param[in] fparam_ Frame parameters. +* @param[in] aparam_ Atom parameters. +* @param[in] atommap Atom map. +* @param[in] scope The scope of the tensors. +*/ template int session_input_tensors (std::vector> & input_tensors, @@ -174,6 +208,20 @@ session_input_tensors (std::vector> & const deepmd::AtomMap&atommap, const std::string scope = ""); +/** +* @brief Get input tensors. +* @param[out] input_tensors Input tensors. +* @param[in] dcoord_ Coordinates of atoms. +* @param[in] ntypes Number of atom types. +* @param[in] datype_ Atom types. +* @param[in] dlist Neighbor list. +* @param[in] fparam_ Frame parameters. +* @param[in] aparam_ Atom parameters. +* @param[in] atommap Atom map. +* @param[in] nghost Number of ghost atoms. +* @param[in] ago Update the internal neighbour list if ago is 0. +* @param[in] scope The scope of the tensors. +*/ template int session_input_tensors (std::vector> & input_tensors, diff --git a/source/api_cc/src/DeepPot.cc b/source/api_cc/src/DeepPot.cc index 2d7ad84e89..3342c1cf72 100644 --- a/source/api_cc/src/DeepPot.cc +++ b/source/api_cc/src/DeepPot.cc @@ -521,12 +521,13 @@ compute (ENERGYTYPE & dener, nlist_data.make_inlist(nlist); } - assert (nloc_real == ret); if (dtype == tensorflow::DT_DOUBLE) { int ret = session_input_tensors (input_tensors, dcoord, ntypes, datype, dbox, nlist, fparam, aparam, atommap, nghost_real, ago); + assert (nloc_real == ret); run_model (dener, dforce, dvirial, datom_energy, datom_virial, session, input_tensors, atommap, nghost_real); } else { int ret = session_input_tensors (input_tensors, dcoord, ntypes, datype, dbox, nlist, fparam, aparam, atommap, nghost_real, ago); + assert (nloc_real == ret); run_model (dener, dforce, dvirial, datom_energy, datom_virial, session, input_tensors, atommap, nghost_real); } From bf702889d3aac1104c3ba87573e9beaaa62b292e Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 29 Oct 2022 07:32:48 -0400 Subject: [PATCH 3/8] apply suggestions --- source/api_cc/src/DataModifier.cc | 8 ++++---- source/api_cc/src/DeepPot.cc | 25 ++++++++++++++----------- 2 files changed, 18 insertions(+), 15 deletions(-) diff --git a/source/api_cc/src/DataModifier.cc b/source/api_cc/src/DataModifier.cc index 902b9f8bb6..70304aec44 100644 --- a/source/api_cc/src/DataModifier.cc +++ b/source/api_cc/src/DataModifier.cc @@ -203,13 +203,13 @@ compute (std::vector & dfcorr_, nlist_data.make_inlist(nlist); // make input tensors std::vector> input_tensors; + int ret; if (dtype == tensorflow::DT_DOUBLE) { - int ret = session_input_tensors (input_tensors, dcoord_real, ntypes, datype_real, dbox, nlist, std::vector(), std::vector(), atommap, nghost_real, 0, name_scope); - assert (nloc_real == ret); + ret = session_input_tensors (input_tensors, dcoord_real, ntypes, datype_real, dbox, nlist, std::vector(), std::vector(), atommap, nghost_real, 0, name_scope); } else { - int ret = session_input_tensors (input_tensors, dcoord_real, ntypes, datype_real, dbox, nlist, std::vector(), std::vector(), atommap, nghost_real, 0, name_scope); - assert (nloc_real == ret); + ret = session_input_tensors (input_tensors, dcoord_real, ntypes, datype_real, dbox, nlist, std::vector(), std::vector(), atommap, nghost_real, 0, name_scope); } + assert (nloc_real == ret); // make bond idx map std::vector bd_idx(nall, -1); for (int ii = 0; ii < pairs.size(); ++ii){ diff --git a/source/api_cc/src/DeepPot.cc b/source/api_cc/src/DeepPot.cc index 3342c1cf72..9cb0a3b16a 100644 --- a/source/api_cc/src/DeepPot.cc +++ b/source/api_cc/src/DeepPot.cc @@ -785,19 +785,20 @@ compute (std::vector & all_energy, nlist_data.shuffle(atommap); nlist_data.make_inlist(nlist); } - + int ret; + if (dtype == tensorflow::DT_DOUBLE) { + ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); + } else { + ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); + } all_energy.resize (numb_models); all_force.resize (numb_models); all_virial.resize (numb_models); - + assert (nloc == ret); for (unsigned ii = 0; ii < numb_models; ++ii) { if (dtype == tensorflow::DT_DOUBLE) { - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); - assert (nloc == ret); run_model (all_energy[ii], all_force[ii], all_virial[ii], sessions[ii], input_tensors, atommap, nghost); } else { - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); - assert (nloc == ret); run_model (all_energy[ii], all_force[ii], all_virial[ii], sessions[ii], input_tensors, atommap, nghost); } } @@ -834,21 +835,23 @@ compute (std::vector & all_energy, nlist_data.shuffle(atommap); nlist_data.make_inlist(nlist); } + int ret; + if (dtype == tensorflow::DT_DOUBLE) { + ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); + } else { + ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); + } all_energy.resize (numb_models); all_force .resize (numb_models); all_virial.resize (numb_models); all_atom_energy.resize (numb_models); all_atom_virial.resize (numb_models); - + assert (nloc == ret); for (unsigned ii = 0; ii < numb_models; ++ii) { if (dtype == tensorflow::DT_DOUBLE) { - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); - assert (nloc == ret); run_model (all_energy[ii], all_force[ii], all_virial[ii], all_atom_energy[ii], all_atom_virial[ii], sessions[ii], input_tensors, atommap, nghost); } else { - int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, fparam, aparam, atommap, nghost, ago); - assert (nloc == ret); run_model (all_energy[ii], all_force[ii], all_virial[ii], all_atom_energy[ii], all_atom_virial[ii], sessions[ii], input_tensors, atommap, nghost); } } From ac5db8f0eec0d1fdd382df74a7174baf5f4705c9 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 29 Oct 2022 07:35:28 -0400 Subject: [PATCH 4/8] pin googletest version --- source/cmake/googletest.cmake.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/cmake/googletest.cmake.in b/source/cmake/googletest.cmake.in index 4ccb3374fe..bcd432c449 100644 --- a/source/cmake/googletest.cmake.in +++ b/source/cmake/googletest.cmake.in @@ -11,7 +11,7 @@ endif() include(ExternalProject) ExternalProject_Add(googletest GIT_REPOSITORY ${GTEST_REPO_ADDRESS} - GIT_TAG main + GIT_TAG release-1.12.1 SOURCE_DIR "@CMAKE_CURRENT_BINARY_DIR@/googletest-src" BINARY_DIR "@CMAKE_CURRENT_BINARY_DIR@/googletest-build" CONFIGURE_COMMAND "" From 148adc25ff2964a3fb8ec431331fb2254264d05d Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 29 Oct 2022 08:10:08 -0400 Subject: [PATCH 5/8] add tests for float interface --- source/api_cc/src/DataModifier.cc | 17 +- source/api_cc/tests/CMakeLists.txt | 25 +-- source/api_cc/tests/test_deepdipole.cc | 92 +++++------ source/api_cc/tests/test_deeppolar.cc | 76 ++++----- source/api_cc/tests/test_deeppot_a.cc | 146 +++++++++--------- .../api_cc/tests/test_deeppot_model_devi.cc | 110 ++++++------- source/api_cc/tests/test_deeppot_r.cc | 146 +++++++++--------- source/api_cc/tests/test_dipolecharge.cc | 32 ++-- source/api_cc/tests/test_ewald.cc | 28 ++-- source/api_cc/tests/test_utils.h | 55 +++++-- source/install/test_cc.sh | 2 +- source/install/test_cc_local.sh | 1 + 12 files changed, 383 insertions(+), 347 deletions(-) diff --git a/source/api_cc/src/DataModifier.cc b/source/api_cc/src/DataModifier.cc index 70304aec44..226c80b82c 100644 --- a/source/api_cc/src/DataModifier.cc +++ b/source/api_cc/src/DataModifier.cc @@ -237,10 +237,19 @@ compute (std::vector & dfcorr_, extf_shape.AddDim (nframes); extf_shape.AddDim (dextf.size()); Tensor extf_tensor ((tensorflow::DataType) dtype, extf_shape); - auto extf = extf_tensor.matrix (); - for (int ii = 0; ii < nframes; ++ii){ - for (int jj = 0; jj < extf.size(); ++jj){ - extf(ii,jj) = dextf[jj]; + if (dtype == tensorflow::DT_DOUBLE) { + auto extf = extf_tensor.matrix (); + for (int ii = 0; ii < nframes; ++ii){ + for (int jj = 0; jj < extf.size(); ++jj){ + extf(ii,jj) = dextf[jj]; + } + } + } else { + auto extf = extf_tensor.matrix (); + for (int ii = 0; ii < nframes; ++ii){ + for (int jj = 0; jj < extf.size(); ++jj){ + extf(ii,jj) = dextf[jj]; + } } } // append extf to input tensor diff --git a/source/api_cc/tests/CMakeLists.txt b/source/api_cc/tests/CMakeLists.txt index abd55d0be4..82478a2d95 100644 --- a/source/api_cc/tests/CMakeLists.txt +++ b/source/api_cc/tests/CMakeLists.txt @@ -4,7 +4,6 @@ project(deepmd_api_test) if (NOT DEFINED BUILD_CPP_IF) set(BUILD_CPP_IF TRUE) endif (NOT DEFINED BUILD_CPP_IF) -add_definitions ("-DHIGH_PREC") enable_testing() add_subdirectory(${CMAKE_SOURCE_DIR}/../../cmake/coverage_config coverage_config) @@ -81,12 +80,6 @@ set(LIB_DEEPMD_OP ${opname}) add_subdirectory(${CMAKE_SOURCE_DIR}/../../op op) file(GLOB TEST_SRC test_*.cc) -add_executable( runUnitTests ${TEST_SRC} ) - - -target_link_libraries(runUnitTests gtest gtest_main ${apiname} rt coverage_config) - -add_test( runUnitTests runUnitTests ) find_package(GTest) if(NOT GTEST_LIBRARIES) @@ -109,14 +102,26 @@ else () include_directories(${GTEST_INCLUDE_DIRS}) endif () +function(_add_apicc_test_variant variant_name prec_def) +add_executable( runUnitTests${variant_name} ${TEST_SRC} ) +target_link_libraries(runUnitTests${variant_name} gtest gtest_main ${apiname}${variant_name} rt coverage_config) +add_test( runUnitTests${variant_name} runUnitTests${variant_name} ) set_target_properties( - runUnitTests + runUnitTests${variant_name} PROPERTIES INSTALL_RPATH "$ORIGIN/../lib" ) set_target_properties( - ${apiname} + ${apiname}${variant_name} PROPERTIES INSTALL_RPATH "$ORIGIN;${TensorFlow_LIBRARY_PATH}" ) -install(TARGETS runUnitTests DESTINATION bin/) +target_compile_definitions( + ${apiname}${variant_name} + PUBLIC ${prec_def} +) +install(TARGETS runUnitTests${variant_name} DESTINATION bin/) +endfunction() + +_add_apicc_test_variant("${HIGH_PREC_VARIANT}" "${HIGH_PREC_DEF}") +_add_apicc_test_variant("${LOW_PREC_VARIANT}" "${LOW_PREC_DEF}") diff --git a/source/api_cc/tests/test_deepdipole.cc b/source/api_cc/tests/test_deepdipole.cc index 23382f49df..fd0873bb45 100644 --- a/source/api_cc/tests/test_deepdipole.cc +++ b/source/api_cc/tests/test_deepdipole.cc @@ -14,7 +14,7 @@ class TestInferDeepDipole : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -25,10 +25,10 @@ class TestInferDeepDipole : public ::testing::Test std::vector atype = { 0, 1, 1, 0, 1, 1 }; - std::vector box = { + std::vector box = { 13., 0., 0., 0., 13., 0., 0., 0., 13. }; - std::vector expected_d = { + std::vector expected_d = { -9.274180565967479195e-01,2.698028341272042496e+00,2.521268387140979117e-01,2.927260638453461628e+00,-8.571926301526779923e-01,1.667785136187720063e+00 }; int natoms = 6; @@ -56,12 +56,12 @@ TEST_F(TestInferDeepDipole, cpu_build_nlist) EXPECT_EQ(sel_types.size(), 1); EXPECT_EQ(sel_types[0], 0); - std::vector value; + std::vector value; dp.compute(value, coord, atype, box); EXPECT_EQ(value.size(), expected_d.size()); for(int ii = 0; ii < expected_d.size(); ++ii){ - EXPECT_LT(fabs(value[ii] - expected_d[ii]), 1e-10); + EXPECT_LT(fabs(value[ii] - expected_d[ii]), EPSILON); } } @@ -70,7 +70,7 @@ TEST_F(TestInferDeepDipole, cpu_lmp_nlist) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector ilist(nloc), numneigh(nloc); std::vector firstneigh(nloc); @@ -81,12 +81,12 @@ TEST_F(TestInferDeepDipole, cpu_lmp_nlist) int nall = coord_cpy.size() / 3; convert_nlist(inlist, nlist_data); - std::vector value; + std::vector value; dp.compute(value, coord_cpy, atype_cpy, box, nall-nloc, inlist); EXPECT_EQ(value.size(), expected_d.size()); for(int ii = 0; ii < expected_d.size(); ++ii){ - EXPECT_LT(fabs(value[ii] - expected_d[ii]), 1e-10); + EXPECT_LT(fabs(value[ii] - expected_d[ii]), EPSILON); } } @@ -95,7 +95,7 @@ TEST_F(TestInferDeepDipole, cpu_lmp_nlist) class TestInferDeepDipoleNew : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -106,20 +106,20 @@ class TestInferDeepDipoleNew : public ::testing::Test std::vector atype = { 0, 1, 1, 0, 1, 1 }; - std::vector box = { + std::vector box = { 13., 0., 0., 0., 13., 0., 0., 0., 13. }; - std::vector expected_t = { + std::vector expected_t = { -1.128427726201255282e-01, 2.654103846999197880e-01, 2.625816377288122533e-02, 3.027556488877700680e-01, -7.475444785689989990e-02, 1.526291164572509684e-01 }; - std::vector expected_f = { + std::vector expected_f = { 8.424897862241968738e-02, -3.823566783202275721e-02, 3.570797165027734810e-01, 6.102563129736437997e-02, -1.351209759852018133e-01, -2.438224487466488510e-01, -1.403204771681088869e-01, 1.719596545791735875e-01, -1.136584427103610045e-01, 2.761686212947551955e-02, -7.247860200915196005e-02, 6.208831127377397591e-02, -2.605870723577520809e-01, -4.504074577536486268e-02, 7.340240097998475266e-02, 2.280160774766013809e-01, 1.189163370225677641e-01, -1.350895372995223886e-01, -4.294311497114180337e-02, 1.524802094783661577e-01, 1.070451777645946290e-01, -1.259336332521076574e-01, -2.087610788959351760e-01, 9.447141346538817652e-02, 1.668125597515543457e-01, 5.487037060760904805e-02, -2.014994036104674757e-01, -7.411985441205551361e-02, 3.614456658821710300e-01, 2.901174891391154476e-01, -4.871926969937838414e-02, -1.252747945819455699e-01, -2.555459318266457558e-01, 1.249033125831290059e-01, -2.347603724902655176e-01, -3.458874493198500766e-02, 3.563990394229877290e-01, 1.052342031228763047e-01, 1.907268232932498031e-01, -2.432737821373903708e-01, 1.016781829972335099e-01, -7.707616437996064884e-02, -1.139199805053340564e-01, -2.068592154909300040e-01, -1.156337826476897951e-01, 6.583817133933017596e-02, 2.902207490750204344e-01, 9.945482314729316153e-02, 7.986986504051810098e-02, -2.549975565538568079e-01, 1.275343199697696051e-01, -1.449133131601115787e-01, -3.527636315034351350e-02, -2.250060193826620980e-01 }; - std::vector expected_v = { + std::vector expected_v = { 3.479789535931299138e-02, 4.337414719007849292e-03, -3.647371468256610082e-03, 8.053492919528318708e-03, 1.003834811499279773e-03, -8.441338187607602033e-04, -6.695998268698949256e-03, -8.346286793845711892e-04, 7.018468440279366279e-04, -4.515896716004976635e-02, 1.891794570218296306e-02, 3.417435352652402336e-02, 9.998952222904963771e-02, -4.188750255541257711e-02, -7.566774655171297492e-02, 1.804286120725206444e-01, -7.558495911146115298e-02, -1.365405712981232755e-01, -1.002593446510361419e-01, -1.117945222697993429e-01, 7.449172735713084637e-02, 7.770237313970995707e-02, 1.313723119887387492e-01, -8.655414676270002661e-02, -4.973937467461287537e-02, -8.663006083493235421e-02, 5.703914957966123994e-02, -3.382231967662072125e-02, -4.215813217482468345e-03, 3.545115660155720612e-03, -8.247565860499378454e-03, -1.028025206407854253e-03, 8.644757417520612143e-04, 6.761330949063471332e-03, 8.427721296283078580e-04, -7.086947453692606178e-04, -1.622698090933780493e-02, 1.305372051650728060e-01, -2.082599910094798112e-01, -7.109985131471197733e-03, 2.202585658101286273e-02, -3.554509763049529952e-02, 1.436400379134906459e-02, -3.554915857551419617e-02, 5.763638171798115412e-02, 2.074946305037073946e-01, 5.016353704485233822e-02, -5.700401936915034523e-02, 1.082138666905367308e-01, 2.616159414496492877e-02, -2.972908425564194101e-02, -1.229314789425654392e-01, -2.971969820589494271e-02, 3.377238432488059716e-02, 7.622024445219390681e-03, 9.500540384976005961e-04, -7.989090778275298932e-04, -2.952148931042387209e-02, -3.679732378636401541e-03, 3.094320409307891630e-03, -9.534268115386618486e-04, -1.188407357158671420e-04, 9.993425503379762414e-05, 9.319088860655992679e-02, -3.903942630815338682e-02, -7.052283462118023871e-02, 1.544831983829924038e-01, -6.471593445773991815e-02, -1.169062041817236081e-01, -6.990884596438741438e-02, 2.928613817427033750e-02, 5.290399154061733306e-02, 7.491400658274136037e-02, 1.273824184577304897e-01, -8.391492311946648075e-02, 3.543872837542783732e-02, 4.324623973455964804e-02, -2.873418641045778418e-02, -8.444981234074398768e-02, -1.531171183141288306e-01, 1.007308415346981068e-01, -6.396885751015785743e-03, -7.973455327045167592e-04, 6.704951070469818575e-04, 2.915483242551994078e-02, 3.634030104030812076e-03, -3.055888951116827318e-03, 6.608747470375698129e-04, 8.237532257692081912e-05, -6.927015762150179410e-05, -6.099175331115514430e-03, 2.402310352789886402e-02, -3.861491558256636286e-02, -2.583867422346154685e-02, 6.050621302336450097e-02, -9.822840263095998503e-02, -3.827994718203701213e-02, 1.252239810257823327e-01, -2.018867305507059950e-01, 1.136620144506474833e-01, 2.747872876828840599e-02, -3.122582814578225147e-02, -2.136319389661417989e-01, -5.164728194785846160e-02, 5.869009312256637939e-02, -3.147575788810638014e-02, -7.609523885036708832e-03, 8.647186232996251914e-03, -5.990706138603461330e-03, -7.467169124604876177e-04, 6.279210400235934152e-04, -9.287887182821588476e-04, -1.157696985960763821e-04, 9.735179200124630735e-05, -2.966271471326579340e-02, -3.697335544996301071e-03, 3.109123071928715683e-03, 1.800225987816693740e-01, -7.541487246259104271e-02, -1.362333179969384966e-01, -7.524185541795300192e-02, 3.152023672914239238e-02, 5.693978247845072477e-02, 5.703636164117102669e-02, -2.389361095778780308e-02, -4.316265205277792366e-02, -4.915584336537091176e-02, -8.674240294138457763e-02, 5.709724154860432860e-02, -8.679070528401405804e-02, -1.572017650485294793e-01, 1.034201569997979520e-01, -3.557746655862283752e-02, -8.626268394893003844e-02, 5.645546718878535764e-02, 6.848075985139651621e-03, 8.535845420570665554e-04, -7.177870012752625602e-04, 8.266638576582277997e-04, 1.030402542123569647e-04, -8.664748649675494882e-05, 2.991751925173294011e-02, 3.729095884068693231e-03, -3.135830629785046203e-03, 1.523793442834292522e-02, -3.873020552543556677e-02, 6.275576045602117292e-02, -3.842536616563556329e-02, 1.249268983543572881e-01, -2.014296501045876875e-01, 1.288704808602599873e-02, -6.326999354443738066e-02, 1.014064886873057153e-01, -1.318711149757016143e-01, -3.188092889522457091e-02, 3.622832829002789468e-02, -3.210149046681261276e-02, -7.760799893075580151e-03, 8.819090787585878374e-03, -2.047554776382226327e-01, -4.950132426418570042e-02, 5.625150484566552450e-02 }; - std::vector expected_gt; - std::vector expected_gv; + std::vector expected_gt; + std::vector expected_gv; int natoms = 6; int nsel = 2; int odim; @@ -163,48 +163,48 @@ TEST_F(TestInferDeepDipoleNew, cpu_build_nlist) EXPECT_EQ(sel_types.size(), 1); EXPECT_EQ(sel_types[0], 0); - std::vector gt, ff, vv, at, av; + std::vector gt, ff, vv, at, av; dp.compute(at, coord, atype, box); EXPECT_EQ(at.size(), expected_t.size()); for(int ii = 0; ii < expected_t.size(); ++ii){ - EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + EXPECT_LT(fabs(at[ii] - expected_t[ii]), EPSILON); } dp.compute(gt, ff, vv, coord, atype, box); EXPECT_EQ(gt.size(), expected_gt.size()); for(int ii = 0; ii < expected_gt.size(); ++ii){ - EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), EPSILON); } EXPECT_EQ(ff.size(), expected_f.size()); for(int ii = 0; ii < expected_f.size(); ++ii){ - EXPECT_LT(fabs(ff[ii] - expected_f[ii]), 1e-10); + EXPECT_LT(fabs(ff[ii] - expected_f[ii]), EPSILON); } EXPECT_EQ(vv.size(), expected_gv.size()); for(int ii = 0; ii < expected_gv.size(); ++ii){ - EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), EPSILON); } dp.compute(gt, ff, vv, at, av, coord, atype, box); EXPECT_EQ(gt.size(), expected_gt.size()); for(int ii = 0; ii < expected_gt.size(); ++ii){ - EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), EPSILON); } EXPECT_EQ(ff.size(), expected_f.size()); for(int ii = 0; ii < expected_f.size(); ++ii){ - EXPECT_LT(fabs(ff[ii] - expected_f[ii]), 1e-10); + EXPECT_LT(fabs(ff[ii] - expected_f[ii]), EPSILON); } EXPECT_EQ(vv.size(), expected_gv.size()); for(int ii = 0; ii < expected_gv.size(); ++ii){ - EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), EPSILON); } EXPECT_EQ(at.size(), expected_t.size()); for(int ii = 0; ii < expected_t.size(); ++ii){ - EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + EXPECT_LT(fabs(at[ii] - expected_t[ii]), EPSILON); } EXPECT_EQ(av.size(), expected_v.size()); for(int ii = 0; ii < expected_v.size(); ++ii){ - EXPECT_LT(fabs(av[ii] - expected_v[ii]), 1e-10); + EXPECT_LT(fabs(av[ii] - expected_v[ii]), EPSILON); } } @@ -213,7 +213,7 @@ TEST_F(TestInferDeepDipoleNew, cpu_lmp_nlist) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector ilist(nloc), numneigh(nloc); std::vector firstneigh(nloc); @@ -224,13 +224,13 @@ TEST_F(TestInferDeepDipoleNew, cpu_lmp_nlist) int nall = coord_cpy.size() / 3; convert_nlist(inlist, nlist_data); - std::vector gt, ff, vv, at, av; + std::vector gt, ff, vv, at, av; dp.compute(at, coord_cpy, atype_cpy, box, nall-nloc, inlist); EXPECT_EQ(at.size(), expected_t.size()); for(int ii = 0; ii < expected_t.size(); ++ii){ - EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + EXPECT_LT(fabs(at[ii] - expected_t[ii]), EPSILON); } @@ -238,21 +238,21 @@ TEST_F(TestInferDeepDipoleNew, cpu_lmp_nlist) EXPECT_EQ(gt.size(), expected_gt.size()); for(int ii = 0; ii < expected_gt.size(); ++ii){ - EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), EPSILON); } // remove ghost atoms - std::vector rff (odim * nloc * 3); + std::vector rff (odim * nloc * 3); for(int kk = 0; kk < odim; ++kk){ _fold_back(rff.begin() + kk * nloc * 3, ff.begin() + kk * nall * 3, mapping, nloc, nall, 3); } EXPECT_EQ(rff.size(), expected_f.size()); for(int ii = 0; ii < expected_f.size(); ++ii){ - EXPECT_LT(fabs(rff[ii] - expected_f[ii]), 1e-10); + EXPECT_LT(fabs(rff[ii] - expected_f[ii]), EPSILON); } // virial EXPECT_EQ(vv.size(), expected_gv.size()); for(int ii = 0; ii < expected_gv.size(); ++ii){ - EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), EPSILON); } @@ -260,7 +260,7 @@ TEST_F(TestInferDeepDipoleNew, cpu_lmp_nlist) EXPECT_EQ(gt.size(), expected_gt.size()); for(int ii = 0; ii < expected_gt.size(); ++ii){ - EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), EPSILON); } // remove ghost atoms for(int kk = 0; kk < odim; ++kk){ @@ -268,26 +268,26 @@ TEST_F(TestInferDeepDipoleNew, cpu_lmp_nlist) } EXPECT_EQ(rff.size(), expected_f.size()); for(int ii = 0; ii < expected_f.size(); ++ii){ - EXPECT_LT(fabs(rff[ii] - expected_f[ii]), 1e-10); + EXPECT_LT(fabs(rff[ii] - expected_f[ii]), EPSILON); } // virial EXPECT_EQ(vv.size(), expected_gv.size()); for(int ii = 0; ii < expected_gv.size(); ++ii){ - EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), EPSILON); } // atom tensor EXPECT_EQ(at.size(), expected_t.size()); for(int ii = 0; ii < expected_t.size(); ++ii){ - EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + EXPECT_LT(fabs(at[ii] - expected_t[ii]), EPSILON); } // atom virial - std::vector rav (odim * nloc * 9); + std::vector rav (odim * nloc * 9); for(int kk = 0; kk < odim; ++kk){ _fold_back(rav.begin() + kk * nloc * 9, av.begin() + kk * nall * 9, mapping, nloc, nall, 9); } EXPECT_EQ(rav.size(), expected_v.size()); for(int ii = 0; ii < expected_v.size(); ++ii){ - EXPECT_LT(fabs(rav[ii] - expected_v[ii]), 1e-10); + EXPECT_LT(fabs(rav[ii] - expected_v[ii]), EPSILON); } } @@ -296,7 +296,7 @@ TEST_F(TestInferDeepDipoleNew, cpu_lmp_nlist) class TestInferDeepDipoleFake : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -307,10 +307,10 @@ class TestInferDeepDipoleFake : public ::testing::Test std::vector atype = { 0, 1, 1, 0, 1, 1 }; - std::vector box = { + std::vector box = { 13., 0., 0., 0., 13., 0., 0., 0., 13. }; - std::vector expected_d = { + std::vector expected_d = { -3.186217894664857830e-01, 1.082220317383403296e+00, 5.646623185237639730e-02, 7.426508038929955369e-01, -3.115996324658170114e-01, -5.619108089573777720e-01, -4.181578166874897473e-01, -7.579762930974662805e-01, 4.980618433125854616e-01, 1.059635561913792712e+00, -2.641989315855929332e-01, 5.307984468104405273e-01, -1.484512535335152095e-01, 4.978588497891502374e-01, -8.022467807199461509e-01, -9.165936539882671985e-01, -2.238112120606238209e-01, 2.553133145814526217e-01 }; int natoms = 6; @@ -339,12 +339,12 @@ TEST_F(TestInferDeepDipoleFake, cpu_build_nlist) EXPECT_EQ(sel_types[0], 0); EXPECT_EQ(sel_types[1], 1); - std::vector value; + std::vector value; dp.compute(value, coord, atype, box); EXPECT_EQ(value.size(), expected_d.size()); for(int ii = 0; ii < expected_d.size(); ++ii){ - EXPECT_LT(fabs(value[ii] - expected_d[ii]), 1e-10); + EXPECT_LT(fabs(value[ii] - expected_d[ii]), EPSILON); } } @@ -353,7 +353,7 @@ TEST_F(TestInferDeepDipoleFake, cpu_lmp_nlist) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector ilist(nloc), numneigh(nloc); std::vector firstneigh(nloc); @@ -364,12 +364,12 @@ TEST_F(TestInferDeepDipoleFake, cpu_lmp_nlist) int nall = coord_cpy.size() / 3; convert_nlist(inlist, nlist_data); - std::vector value; + std::vector value; dp.compute(value, coord_cpy, atype_cpy, box, nall-nloc, inlist); EXPECT_EQ(value.size(), expected_d.size()); for(int ii = 0; ii < expected_d.size(); ++ii){ - EXPECT_LT(fabs(value[ii] - expected_d[ii]), 1e-10); + EXPECT_LT(fabs(value[ii] - expected_d[ii]), EPSILON); } } diff --git a/source/api_cc/tests/test_deeppolar.cc b/source/api_cc/tests/test_deeppolar.cc index ad4ccdca5b..de0f3c2a36 100644 --- a/source/api_cc/tests/test_deeppolar.cc +++ b/source/api_cc/tests/test_deeppolar.cc @@ -14,7 +14,7 @@ class TestInferDeepPolar : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -25,10 +25,10 @@ class TestInferDeepPolar : public ::testing::Test std::vector atype = { 0, 1, 1, 0, 1, 1 }; - std::vector box = { + std::vector box = { 13., 0., 0., 0., 13., 0., 0., 0., 13. }; - std::vector expected_d = { + std::vector expected_d = { 1.061407927405987051e-01,-3.569013342133873778e-01,-2.862108976089940138e-02,-3.569013342133875444e-01,1.304367268874677244e+00,1.037647501453442256e-01,-2.862108976089940138e-02,1.037647501453441284e-01,8.100521520762453409e-03,1.236797829492216616e+00,-3.717307430531632262e-01,7.371515676976750919e-01,-3.717307430531630041e-01,1.127222682121889058e-01,-2.239181552775717510e-01,7.371515676976746478e-01,-2.239181552775717787e-01,4.448255365635306879e-01 }; int natoms; @@ -59,12 +59,12 @@ TEST_F(TestInferDeepPolar, cpu_build_nlist) EXPECT_EQ(sel_types.size(), 1); EXPECT_EQ(sel_types[0], 0); - std::vector value; + std::vector value; dp.compute(value, coord, atype, box); EXPECT_EQ(value.size(), expected_d.size()); for(int ii = 0; ii < expected_d.size(); ++ii){ - EXPECT_LT(fabs(value[ii] - expected_d[ii]), 1e-10); + EXPECT_LT(fabs(value[ii] - expected_d[ii]), EPSILON); } } @@ -73,7 +73,7 @@ TEST_F(TestInferDeepPolar, cpu_lmp_nlist) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector ilist(nloc), numneigh(nloc); std::vector firstneigh(nloc); @@ -84,12 +84,12 @@ TEST_F(TestInferDeepPolar, cpu_lmp_nlist) int nall = coord_cpy.size() / 3; convert_nlist(inlist, nlist_data); - std::vector value; + std::vector value; dp.compute(value, coord_cpy, atype_cpy, box, nall-nloc, inlist); EXPECT_EQ(value.size(), expected_d.size()); for(int ii = 0; ii < expected_d.size(); ++ii){ - EXPECT_LT(fabs(value[ii] - expected_d[ii]), 1e-10); + EXPECT_LT(fabs(value[ii] - expected_d[ii]), EPSILON); } } @@ -98,7 +98,7 @@ TEST_F(TestInferDeepPolar, cpu_lmp_nlist) class TestInferDeepPolarNew : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -109,20 +109,20 @@ class TestInferDeepPolarNew : public ::testing::Test std::vector atype = { 0, 1, 1, 0, 1, 1 }; - std::vector box = { + std::vector box = { 13., 0., 0., 0., 13., 0., 0., 0., 13. }; - std::vector expected_t = { + std::vector expected_t = { 1.936327241487292961e+00, 5.198696351735779264e-02, 3.888336625074450149e-03, 5.198696351735781346e-02, 1.764967784387830196e+00, -1.354658545697527347e-02, 3.888336625074451016e-03, -1.354658545697527000e-02, 1.939288409902199639e+00, 1.786740420980893029e+00, 4.868765294055640847e-02, -9.812132615180739481e-02, 4.868765294055640847e-02, 1.925999147066305373e+00, 2.895028407651457567e-02, -9.812132615180743644e-02, 2.895028407651457220e-02, 1.883109989034779996e+00 }; - std::vector expected_f = { + std::vector expected_f = { 5.305178446980116092e-02, -1.127314829623577049e-02, 1.136493514861047216e-01, 5.598130220328862322e-05, -4.352126938892845326e-02, -7.700608888887500170e-02, -1.050015668789053697e-01, 5.882396336737016895e-02, -3.723875897544067642e-02, -7.850322286760008650e-02, 7.279117637753844405e-02, -6.178451060078461732e-02, 3.404361490778949895e-01, 5.447934529195214842e-02, -8.698375128815737101e-02, -2.100391251033939810e-01, -1.313000673516965255e-01, 1.493637582671529240e-01, -9.589318874236771317e-02, 6.285887854370801608e-02, -1.824395427630142175e-01, -3.264267092869802683e-02, 3.637498661083633789e-02, 1.524859582123189172e-01, 1.442484990808054202e-01, -8.957992476622803069e-02, 3.076469140583825215e-02, 4.909822745881124717e-02, -2.559151672032903835e-01, -1.522830913546814324e-01, -2.885480042033320910e-02, 7.730841025065784966e-02, 1.553301391955271560e-01, -3.595606644821771475e-02, 1.689528165643162105e-01, -3.858154695988691516e-03, 5.018843026262573281e-02, 1.756005154318779349e-02, 3.489323893614350303e-02, -4.020411124876955428e-02, 2.218648284685413238e-02, -8.086177159691650476e-03, -2.222392408702593067e-02, -3.825892777133557687e-02, -1.689393838770965675e-02, -5.465804822761769627e-02, -1.398775875506316768e-01, -1.165702490994514756e-01, 5.449067849718619572e-02, 1.588580450812354106e-01, -8.209560373418453572e-02, 1.240697480360127003e-02, -2.046806414931008622e-02, 1.887527294448937965e-01, -9.589318874236771317e-02, 6.285887854370801608e-02, -1.824395427630142175e-01, -3.264267092869802683e-02, 3.637498661083633789e-02, 1.524859582123189172e-01, 1.442484990808054202e-01, -8.957992476622803069e-02, 3.076469140583825215e-02, 4.909822745881124717e-02, -2.559151672032903835e-01, -1.522830913546814324e-01, -2.885480042033320910e-02, 7.730841025065784966e-02, 1.553301391955271560e-01, -3.595606644821771475e-02, 1.689528165643162105e-01, -3.858154695988691516e-03, 4.038746042068122599e-02, -2.549213597407858356e-01, -1.131801705114504619e-01, 1.489732376295762606e-01, 2.734584831542113958e-01, -1.125511889088352951e-01, -1.908551011160136424e-01, -2.400995606986339528e-02, 2.255650484976146619e-01, -2.185213968874370055e-02, 1.475333123369945709e-01, 9.584417756169674729e-02, -1.576380405016522893e-02, -5.153693137796186430e-02, -8.489897831367294867e-02, 3.911034680466508873e-02, -9.052354830259493057e-02, -1.077888832535272776e-02, -1.970229486427777510e-01, -6.538978166042377915e-02, -1.570533119125729904e-01, 1.417940206277617798e-01, -4.684714285705613573e-02, 6.070882964241105378e-02, 5.715183445260185735e-02, 1.138024049318459713e-01, 9.374622673558237473e-02, 3.096927839536914306e-02, -9.232883741117139942e-02, -6.499836527010099951e-02, 2.839980861544661936e-02, 8.097497759757724123e-03, 1.006700103228213017e-01, -6.129199344840163821e-02, 8.266585923704758421e-02, -3.307338951814068478e-02, 5.018843026262574669e-02, 1.756005154318778308e-02, 3.489323893614350997e-02, -4.020411124876957509e-02, 2.218648284685414279e-02, -8.086177159691652211e-03, -2.222392408702593067e-02, -3.825892777133557687e-02, -1.689393838770965675e-02, -5.465804822761770321e-02, -1.398775875506316491e-01, -1.165702490994514756e-01, 5.449067849718619572e-02, 1.588580450812354106e-01, -8.209560373418453572e-02, 1.240697480360125615e-02, -2.046806414931009316e-02, 1.887527294448937965e-01, -1.970229486427777510e-01, -6.538978166042375140e-02, -1.570533119125729626e-01, 1.417940206277618076e-01, -4.684714285705613573e-02, 6.070882964241105378e-02, 5.715183445260184347e-02, 1.138024049318459713e-01, 9.374622673558236086e-02, 3.096927839536912919e-02, -9.232883741117139942e-02, -6.499836527010102727e-02, 2.839980861544661589e-02, 8.097497759757731062e-03, 1.006700103228213017e-01, -6.129199344840162433e-02, 8.266585923704758421e-02, -3.307338951814066397e-02, -3.078161564779093723e-02, -8.748776750553553111e-03, -2.162930108693108394e-02, 2.135313622214399243e-02, -8.845621737097757523e-03, 9.365293934359546560e-03, 8.562579091543631032e-03, 1.772751551871581607e-02, 1.573655414890783033e-02, -3.649820158632081230e-02, -1.904914900326310223e-01, -1.076542087674599024e-01, -5.186655049718805199e-02, 1.686765146765009937e-01, -6.620206332305828001e-02, 8.923065241761217459e-02, 2.168185832506550753e-02, 1.703837250941818704e-01 }; - std::vector expected_v = { + std::vector expected_v = { -2.123013313652813774e-03, -2.646248889538913257e-04, 2.225254748021367093e-04, 9.843593195853941446e-04, 1.226963457840150472e-04, -1.031764725911038809e-04, -8.467513732241481721e-04, -1.055440805151912256e-04, 8.875297679686559459e-05, 1.829118379697145316e-02, 2.302438731350108913e-03, -1.890198823577125386e-03, 3.300229266409118040e-02, -1.339230641165423293e-02, -2.445540228188634868e-02, 5.127826101331301595e-02, -2.458314752619149279e-02, -4.252530480245884925e-02, 9.733043787604266084e-02, -6.217238566516904152e-02, 3.767656091618994812e-02, 6.674680725588777973e-03, 4.245867422406505304e-02, -2.752200660186601699e-02, -8.318636634138946995e-03, -2.738884420387305285e-02, 1.785195524121836741e-02, -3.151218435289559073e-03, -3.927864338604547816e-04, 3.302976830190196104e-04, 1.387198082848713948e-06, 1.729085429046553641e-07, -1.454003656243721975e-07, -4.056191292896940703e-05, -5.055875832506090064e-06, 4.251531950061960394e-06, 7.087482338961141604e-02, -1.643445525800983908e-01, 2.668682182870234509e-01, 7.752581706917366366e-03, -2.674714571946596939e-02, 4.308263417785011123e-02, -9.385640612496094423e-03, 4.307848167667025635e-02, -6.910099104451945806e-02, -1.822493611414978121e-01, -4.510097387143227610e-02, 5.157836206906134952e-02, -1.170389534066011428e-01, -2.858136680923874240e-02, 3.256883555835647648e-02, 1.336331160725280354e-01, 3.257484898923947853e-02, -3.710113093740719653e-02, 3.343993600586595179e-03, 4.168150663620683060e-04, -3.505035785317401481e-04, -4.312491363797464269e-03, -5.375343342977005178e-04, 4.520175083867039156e-04, -5.045304632809267465e-04, -6.288764981405317546e-05, 5.288279643454484632e-05, 2.176577726533836937e-02, -1.041710664445027849e-02, -1.802940684978692962e-02, -3.097121964369356495e-02, 1.077096511204005125e-02, 2.079488766754130843e-02, -1.120464690158002596e-01, 4.736950869652114399e-02, 8.530900293808066359e-02, 3.029112757823893692e-02, 1.058529311156591879e-01, -6.894903720238335088e-02, -5.089618157121258979e-02, -6.973511953466600410e-02, 4.618114280030299196e-02, 1.143309394598741001e-02, 2.319568285212985151e-02, -1.522637168466081138e-02, -1.535733649675188493e-03, -1.914228911776438445e-04, 1.609692493993826663e-04, -2.603290366421702733e-03, -3.244894507721100851e-04, 2.728661290583660171e-04, 6.938458118266074663e-04, 8.648503036932213837e-05, -7.272604826511198082e-05, -2.609239945314979423e-02, 1.142603664459106681e-02, -2.051406106454568487e-02, 5.779549344910496142e-03, -3.860615030463052100e-02, 6.168332781226748551e-02, 2.068839156841529789e-02, -7.643723474881176927e-02, 1.229844977392647865e-01, -3.554667688747349674e-02, -8.262665730398828859e-03, 9.285295046969522723e-03, 1.497274901467501862e-01, 3.666859638982037511e-02, -4.181688913175674732e-02, -3.257377626487627069e-03, -8.171909213273372040e-04, 9.379633299917983094e-04, 5.408910405506226968e-04, 6.741984641424190365e-05, -5.669396175743082354e-05, 4.696290607396237790e-04, 5.853733334998140626e-05, -4.922457577157541143e-05, -5.350269144276139158e-03, -6.668890718077903363e-04, 5.607930831110977251e-04, 3.013271000130106694e-02, -1.241570117891089425e-02, -2.255430712666738058e-02, -1.643158253499693577e-02, 6.876116339617440766e-03, 1.242585434168311936e-02, 2.120265775977717496e-03, -2.988284987993197143e-03, -4.123302560925387432e-03, 3.528008965720315360e-02, -1.132921329184741026e-02, 6.435692645130823564e-03, -2.115291124444698342e-02, -2.971050496327276927e-02, 1.966236467455729359e-02, -2.194244461519655187e-02, -1.469000955331024871e-02, 1.000316933044766328e-02, -2.208576023807404254e-03, -2.752899293131040766e-04, 2.314938041951108548e-04, -5.840262773118632192e-04, -7.279647649213021596e-05, 6.121521886838239123e-05, -1.263538670848133802e-03, -1.574949051482092536e-04, 1.324388975109944740e-04, 8.955566031735841259e-03, -2.660296383100100095e-02, 4.296567375352825652e-02, 2.380373596470350059e-02, -7.784355459714024927e-02, 1.255004729498893912e-01, -1.824501349606120690e-02, 3.948761180940744964e-02, -6.423389834199008663e-02, 1.038606825469970407e-02, 2.616819816765628484e-03, -3.006960935423359793e-03, -1.864007491704058883e-02, -4.504736174636920880e-03, 5.118497771104377897e-03, 1.680266347982039554e-01, 4.105963063126880086e-02, -4.679634408112137711e-02, 3.343993600586595179e-03, 4.168150663620683060e-04, -3.505035785317401481e-04, -4.312491363797464269e-03, -5.375343342977005178e-04, 4.520175083867039156e-04, -5.045304632809267465e-04, -6.288764981405317546e-05, 5.288279643454484632e-05, 2.176577726533836937e-02, -1.041710664445027849e-02, -1.802940684978692962e-02, -3.097121964369356495e-02, 1.077096511204005125e-02, 2.079488766754130843e-02, -1.120464690158002596e-01, 4.736950869652114399e-02, 8.530900293808066359e-02, 3.029112757823893692e-02, 1.058529311156591879e-01, -6.894903720238335088e-02, -5.089618157121258979e-02, -6.973511953466600410e-02, 4.618114280030299196e-02, 1.143309394598741001e-02, 2.319568285212985151e-02, -1.522637168466081138e-02, -1.535733649675188493e-03, -1.914228911776438445e-04, 1.609692493993826663e-04, -2.603290366421702733e-03, -3.244894507721100851e-04, 2.728661290583660171e-04, 6.938458118266074663e-04, 8.648503036932213837e-05, -7.272604826511198082e-05, -2.609239945314979423e-02, 1.142603664459106681e-02, -2.051406106454568487e-02, 5.779549344910496142e-03, -3.860615030463052100e-02, 6.168332781226748551e-02, 2.068839156841529789e-02, -7.643723474881176927e-02, 1.229844977392647865e-01, -3.554667688747349674e-02, -8.262665730398828859e-03, 9.285295046969522723e-03, 1.497274901467501862e-01, 3.666859638982037511e-02, -4.181688913175674732e-02, -3.257377626487627069e-03, -8.171909213273372040e-04, 9.379633299917983094e-04, 1.097257666720985849e-03, 1.367686610077148478e-04, -1.150100103928514269e-04, -3.252401295559594844e-03, -4.053984617694676175e-04, 3.409032519425078027e-04, -1.217154259382106555e-04, -1.517132787898375553e-05, 1.275770753460001047e-05, -1.104423096905816498e-01, 4.615651100464009809e-02, 8.344619780982527601e-02, -1.998235369855275168e-01, 8.508819942125579738e-02, 1.528709647298205909e-01, 8.333302476347614896e-02, -3.488524142655123617e-02, -6.303339769808283255e-02, -7.468341447282240975e-02, -1.443673498458480642e-01, 9.485360739696327426e-02, -2.685004652445167612e-04, -1.702408228533323561e-02, 1.097613894113106531e-02, 9.496752299747332482e-02, 1.714581306702349373e-01, -1.128066531362114239e-01, -2.109671824413435984e-03, -2.629619271223545066e-04, 2.211270750801623281e-04, 1.011694656468142307e-02, 1.261035832424879221e-03, -1.060416495448196581e-03, 2.326027531269699879e-04, 2.899297772687444119e-05, -2.438045854305356789e-05, -9.775618976121780001e-04, 7.897148922927013995e-03, -1.259878571596698138e-02, -5.534571406250721713e-03, 2.552681480358522451e-02, -4.094434810336724379e-02, -1.258721457759937913e-02, 4.161890111720080443e-02, -6.708566706120022705e-02, 3.521744971093632853e-02, 8.557787631933998912e-03, -9.738493960065902622e-03, -8.446926488038911107e-02, -2.017604402799078392e-02, 2.285024948138817888e-02, -9.755577915095828626e-03, -2.364722966186930900e-03, 2.689144780896026744e-03, 8.392348196279006065e-05, 1.046071729847805219e-05, -8.796512273720217211e-06, -2.967282659264359589e-03, -3.698595949224694123e-04, 3.110182957302592738e-04, -1.688223115474902841e-03, -2.104300767164184042e-04, 1.769525645115341121e-04, -1.040849854787611189e-01, 4.406117175034113265e-02, 7.931633477513304331e-02, 3.539829580561168476e-02, -1.443144702217136026e-02, -2.631106338063535569e-02, -4.383990895980735547e-02, 1.895493123709470276e-02, 3.388325869579450478e-02, 1.809448338386955915e-02, 4.269882582195522885e-02, -2.795653019460052346e-02, 4.363124777259473619e-02, 8.597058258914810902e-02, -5.646456449126337207e-02, 4.431189331687027805e-02, 7.186269332716928304e-02, -4.739074421553418626e-02, 7.807665162715203382e-05, 9.731933913865978996e-06, -8.183671700296416994e-06, 2.525821455836478949e-03, 3.148332692827336839e-04, -2.647461582604813284e-04, 5.088778918832323993e-03, 6.342953893162101269e-04, -5.333847591977234877e-04, 1.765533347871811772e-03, -1.422682766506909793e-02, 2.269730547460076936e-02, 2.888222424864686153e-04, -4.083171371247279469e-03, 6.494062010930001794e-03, 1.594130471018519873e-02, -4.922350239779287734e-02, 7.944117864515577720e-02, -5.516443865142822006e-02, -1.340804559261108905e-02, 1.525892700429632917e-02, 7.450140187529649682e-02, 1.809617933997387934e-02, -2.059052256811338619e-02, -3.118940445306414219e-02, -7.412336287839308216e-03, 8.382871287998559101e-03, 5.408910405506207452e-04, 6.741984641424155129e-05, -5.669396175743063380e-05, 4.696290607396231285e-04, 5.853733334998132494e-05, -4.922457577157534367e-05, -5.350269144276134821e-03, -6.668890718077897942e-04, 5.607930831110975083e-04, 3.013271000130106694e-02, -1.241570117891090119e-02, -2.255430712666738752e-02, -1.643158253499694271e-02, 6.876116339617444236e-03, 1.242585434168312457e-02, 2.120265775977718363e-03, -2.988284987993198010e-03, -4.123302560925387432e-03, 3.528008965720314666e-02, -1.132921329184741026e-02, 6.435692645130823564e-03, -2.115291124444698342e-02, -2.971050496327276927e-02, 1.966236467455729012e-02, -2.194244461519655881e-02, -1.469000955331024871e-02, 1.000316933044766501e-02, -2.208576023807403820e-03, -2.752899293131040766e-04, 2.314938041951108548e-04, -5.840262773118632192e-04, -7.279647649213021596e-05, 6.121521886838239123e-05, -1.263538670848133802e-03, -1.574949051482092536e-04, 1.324388975109944740e-04, 8.955566031735841259e-03, -2.660296383100100095e-02, 4.296567375352825652e-02, 2.380373596470350059e-02, -7.784355459714024927e-02, 1.255004729498893912e-01, -1.824501349606121037e-02, 3.948761180940744964e-02, -6.423389834199008663e-02, 1.038606825469969019e-02, 2.616819816765625015e-03, -3.006960935423356324e-03, -1.864007491704059577e-02, -4.504736174636922615e-03, 5.118497771104379632e-03, 1.680266347982039554e-01, 4.105963063126880086e-02, -4.679634408112137711e-02, 8.392348196278930170e-05, 1.046071729847797087e-05, -8.796512273720142672e-06, -2.967282659264356987e-03, -3.698595949224691413e-04, 3.110182957302590027e-04, -1.688223115474903708e-03, -2.104300767164184855e-04, 1.769525645115341934e-04, -1.040849854787611189e-01, 4.406117175034113265e-02, 7.931633477513304331e-02, 3.539829580561167782e-02, -1.443144702217136026e-02, -2.631106338063535569e-02, -4.383990895980735547e-02, 1.895493123709470276e-02, 3.388325869579450478e-02, 1.809448338386955221e-02, 4.269882582195521498e-02, -2.795653019460051653e-02, 4.363124777259472925e-02, 8.597058258914809514e-02, -5.646456449126335819e-02, 4.431189331687027111e-02, 7.186269332716926916e-02, -4.739074421553417932e-02, 7.807665162715246750e-05, 9.731933913866019654e-06, -8.183671700296457651e-06, 2.525821455836478515e-03, 3.148332692827336297e-04, -2.647461582604812742e-04, 5.088778918832324860e-03, 6.342953893162102353e-04, -5.333847591977235961e-04, 1.765533347871809603e-03, -1.422682766506909793e-02, 2.269730547460076589e-02, 2.888222424864694826e-04, -4.083171371247282938e-03, 6.494062010930008733e-03, 1.594130471018519873e-02, -4.922350239779287040e-02, 7.944117864515577720e-02, -5.516443865142821312e-02, -1.340804559261108558e-02, 1.525892700429632570e-02, 7.450140187529649682e-02, 1.809617933997387934e-02, -2.059052256811338966e-02, -3.118940445306412831e-02, -7.412336287839304746e-03, 8.382871287998553897e-03, -9.575909105642434974e-04, -1.193597735547498307e-04, 1.003707186710399045e-04, -9.520061199010912585e-05, -1.186636523389461756e-05, 9.978534401229592523e-06, -5.876800709203859434e-03, -7.325190685693192200e-04, 6.159819440242017292e-04, -1.659431774532551043e-02, 6.520628417529478540e-03, 1.204087494393247214e-02, 6.518824051016284399e-03, -2.745500204548994606e-03, -4.950724849051978994e-03, -5.340810191179472081e-03, 3.101366677982481286e-03, 5.077959020099345744e-03, 7.727976016970144156e-03, 7.022558645366243878e-03, -4.714356496325102820e-03, 7.018017321145150929e-03, 1.341962078953426278e-02, -8.818944869050635710e-03, -2.755773236988961865e-03, 1.079245666846929096e-02, -6.886663303228377636e-03, 9.801230913130992879e-04, 1.221683173308112048e-04, -1.027324486645460452e-04, 1.233918620327190629e-04, 1.538028875195364422e-05, -1.293342463232469071e-05, 4.892751025155074075e-03, 6.098613175830685205e-04, -5.128379261493998297e-04, -7.792305682365031905e-03, 2.541307371885552502e-02, -4.097328323558844382e-02, 2.530143617608526449e-02, -8.265149730513186854e-02, 1.332544508945474881e-01, -1.184335640259520997e-02, 3.220055758982264676e-02, -5.209911236104310117e-02, 8.090761694886683397e-02, 1.959431243541279177e-02, -2.227702786419644143e-02, 1.968691296265078980e-02, 4.764576998712748319e-03, -5.415896903683155988e-03, 1.534638141861073557e-01, 3.728680895816388619e-02, -4.242975875503233324e-02 }; - std::vector expected_gt; - std::vector expected_gv; + std::vector expected_gt; + std::vector expected_gv; int natoms = 6; int nsel = 2; int odim; @@ -166,48 +166,48 @@ TEST_F(TestInferDeepPolarNew, cpu_build_nlist) EXPECT_EQ(sel_types.size(), 1); EXPECT_EQ(sel_types[0], 0); - std::vector gt, ff, vv, at, av; + std::vector gt, ff, vv, at, av; dp.compute(at, coord, atype, box); EXPECT_EQ(at.size(), expected_t.size()); for(int ii = 0; ii < expected_t.size(); ++ii){ - EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + EXPECT_LT(fabs(at[ii] - expected_t[ii]), EPSILON); } dp.compute(gt, ff, vv, coord, atype, box); EXPECT_EQ(gt.size(), expected_gt.size()); for(int ii = 0; ii < expected_gt.size(); ++ii){ - EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), EPSILON); } EXPECT_EQ(ff.size(), expected_f.size()); for(int ii = 0; ii < expected_f.size(); ++ii){ - EXPECT_LT(fabs(ff[ii] - expected_f[ii]), 1e-10); + EXPECT_LT(fabs(ff[ii] - expected_f[ii]), EPSILON); } EXPECT_EQ(vv.size(), expected_gv.size()); for(int ii = 0; ii < expected_gv.size(); ++ii){ - EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), EPSILON); } dp.compute(gt, ff, vv, at, av, coord, atype, box); EXPECT_EQ(gt.size(), expected_gt.size()); for(int ii = 0; ii < expected_gt.size(); ++ii){ - EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), EPSILON); } EXPECT_EQ(ff.size(), expected_f.size()); for(int ii = 0; ii < expected_f.size(); ++ii){ - EXPECT_LT(fabs(ff[ii] - expected_f[ii]), 1e-10); + EXPECT_LT(fabs(ff[ii] - expected_f[ii]), EPSILON); } EXPECT_EQ(vv.size(), expected_gv.size()); for(int ii = 0; ii < expected_gv.size(); ++ii){ - EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), EPSILON); } EXPECT_EQ(at.size(), expected_t.size()); for(int ii = 0; ii < expected_t.size(); ++ii){ - EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + EXPECT_LT(fabs(at[ii] - expected_t[ii]), EPSILON); } EXPECT_EQ(av.size(), expected_v.size()); for(int ii = 0; ii < expected_v.size(); ++ii){ - EXPECT_LT(fabs(av[ii] - expected_v[ii]), 1e-10); + EXPECT_LT(fabs(av[ii] - expected_v[ii]), EPSILON); } } @@ -216,7 +216,7 @@ TEST_F(TestInferDeepPolarNew, cpu_lmp_nlist) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector ilist(nloc), numneigh(nloc); std::vector firstneigh(nloc); @@ -227,13 +227,13 @@ TEST_F(TestInferDeepPolarNew, cpu_lmp_nlist) int nall = coord_cpy.size() / 3; convert_nlist(inlist, nlist_data); - std::vector gt, ff, vv, at, av; + std::vector gt, ff, vv, at, av; dp.compute(at, coord_cpy, atype_cpy, box, nall-nloc, inlist); EXPECT_EQ(at.size(), expected_t.size()); for(int ii = 0; ii < expected_t.size(); ++ii){ - EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + EXPECT_LT(fabs(at[ii] - expected_t[ii]), EPSILON); } @@ -241,21 +241,21 @@ TEST_F(TestInferDeepPolarNew, cpu_lmp_nlist) EXPECT_EQ(gt.size(), expected_gt.size()); for(int ii = 0; ii < expected_gt.size(); ++ii){ - EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), EPSILON); } // remove ghost atoms - std::vector rff (odim * nloc * 3); + std::vector rff (odim * nloc * 3); for(int kk = 0; kk < odim; ++kk){ _fold_back(rff.begin() + kk * nloc * 3, ff.begin() + kk * nall * 3, mapping, nloc, nall, 3); } EXPECT_EQ(rff.size(), expected_f.size()); for(int ii = 0; ii < expected_f.size(); ++ii){ - EXPECT_LT(fabs(rff[ii] - expected_f[ii]), 1e-10); + EXPECT_LT(fabs(rff[ii] - expected_f[ii]), EPSILON); } // virial EXPECT_EQ(vv.size(), expected_gv.size()); for(int ii = 0; ii < expected_gv.size(); ++ii){ - EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), EPSILON); } @@ -263,7 +263,7 @@ TEST_F(TestInferDeepPolarNew, cpu_lmp_nlist) EXPECT_EQ(gt.size(), expected_gt.size()); for(int ii = 0; ii < expected_gt.size(); ++ii){ - EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), EPSILON); } // remove ghost atoms for(int kk = 0; kk < odim; ++kk){ @@ -271,26 +271,26 @@ TEST_F(TestInferDeepPolarNew, cpu_lmp_nlist) } EXPECT_EQ(rff.size(), expected_f.size()); for(int ii = 0; ii < expected_f.size(); ++ii){ - EXPECT_LT(fabs(rff[ii] - expected_f[ii]), 1e-10); + EXPECT_LT(fabs(rff[ii] - expected_f[ii]), EPSILON); } // virial EXPECT_EQ(vv.size(), expected_gv.size()); for(int ii = 0; ii < expected_gv.size(); ++ii){ - EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), EPSILON); } // atom tensor EXPECT_EQ(at.size(), expected_t.size()); for(int ii = 0; ii < expected_t.size(); ++ii){ - EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + EXPECT_LT(fabs(at[ii] - expected_t[ii]), EPSILON); } // atom virial - std::vector rav (odim * nloc * 9); + std::vector rav (odim * nloc * 9); for(int kk = 0; kk < odim; ++kk){ _fold_back(rav.begin() + kk * nloc * 9, av.begin() + kk * nall * 9, mapping, nloc, nall, 9); } EXPECT_EQ(rav.size(), expected_v.size()); for(int ii = 0; ii < expected_v.size(); ++ii){ - EXPECT_LT(fabs(rav[ii] - expected_v[ii]), 1e-10); + EXPECT_LT(fabs(rav[ii] - expected_v[ii]), EPSILON); } } diff --git a/source/api_cc/tests/test_deeppot_a.cc b/source/api_cc/tests/test_deeppot_a.cc index d8082972f8..55fc2c4dd7 100644 --- a/source/api_cc/tests/test_deeppot_a.cc +++ b/source/api_cc/tests/test_deeppot_a.cc @@ -14,7 +14,7 @@ class TestInferDeepPotA : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -25,21 +25,21 @@ class TestInferDeepPotA : public ::testing::Test std::vector atype = { 0, 1, 1, 0, 1, 1 }; - std::vector box = { + std::vector box = { 13., 0., 0., 0., 13., 0., 0., 0., 13. }; - std::vector expected_e = { + 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 = { + 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 = { + 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::vectorexpected_tot_v; + VALUETYPE expected_tot_e; + std::vectorexpected_tot_v; deepmd::DeepPot dp; @@ -73,24 +73,24 @@ class TestInferDeepPotA : public ::testing::Test TEST_F(TestInferDeepPotA, cpu_build_nlist) { double ener; - std::vector force, virial; + 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), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } } TEST_F(TestInferDeepPotA, cpu_build_nlist_numfv) { - class MyModel : public EnergyModelTest + class MyModel : public EnergyModelTest { deepmd::DeepPot & mydp; const std::vector atype; @@ -101,17 +101,17 @@ TEST_F(TestInferDeepPotA, cpu_build_nlist_numfv) ) : mydp(dp_), atype(atype_) {}; virtual void compute ( double & ener, - std::vector & force, - std::vector & virial, - const std::vector & coord, - const std::vector & box) { + 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); + std::vector box_(box); box_[1] -= 0.4; model.test_f(coord, box_); model.test_v(coord, box_); @@ -136,7 +136,7 @@ TEST_F(TestInferDeepPotA, cpu_build_nlist_numfv) TEST_F(TestInferDeepPotA, cpu_build_nlist_atomic) { double ener; - std::vector force, virial, atom_ener, atom_vir; + 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); @@ -144,18 +144,18 @@ TEST_F(TestInferDeepPotA, cpu_build_nlist_atomic) EXPECT_EQ(atom_ener.size(), natoms); EXPECT_EQ(atom_vir.size(), natoms*9); - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); } } @@ -164,7 +164,7 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -176,20 +176,20 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist) convert_nlist(inlist, nlist_data); double ener; - std::vector force_, virial; + std::vector force_, virial; dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); - std::vector force; + 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), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } ener = 0.; @@ -201,12 +201,12 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist) EXPECT_EQ(force.size(), natoms*3); EXPECT_EQ(virial.size(), 9); - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } } @@ -215,7 +215,7 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_atomic) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -227,8 +227,8 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_atomic) convert_nlist(inlist, nlist_data); double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; + 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); @@ -239,18 +239,18 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_atomic) EXPECT_EQ(atom_ener.size(), natoms); EXPECT_EQ(atom_vir.size(), natoms*9); - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); } ener = 0.; @@ -268,18 +268,18 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_atomic) EXPECT_EQ(atom_ener.size(), natoms); EXPECT_EQ(atom_vir.size(), natoms*9); - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); } } @@ -288,7 +288,7 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_2rc) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -300,20 +300,20 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_2rc) convert_nlist(inlist, nlist_data); double ener; - std::vector force_(nall*3, 0.0), virial(9, 0.0); + 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; + 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), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } ener = 0.; @@ -325,12 +325,12 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_2rc) EXPECT_EQ(force.size(), natoms*3); EXPECT_EQ(virial.size(), 9); - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } } @@ -341,7 +341,7 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_type_sel) // add vir atoms int nvir = 2; - std::vector coord_vir(nvir*3); + std::vector coord_vir(nvir*3); std::vector atype_vir(nvir, 2); for(int ii = 0; ii < nvir; ++ii){ coord_vir[ii] = coord[ii]; @@ -349,12 +349,12 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_type_sel) 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); + 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 coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -367,21 +367,21 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_type_sel) // dp compute double ener; - std::vector force_(nall*3, 0.0), virial(9, 0.0); + 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; + 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), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } } @@ -390,7 +390,7 @@ TEST_F(TestInferDeepPotA, cpu_lmp_nlist_type_sel) class TestInferDeepPotANoPbc : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -401,19 +401,19 @@ class TestInferDeepPotANoPbc : public ::testing::Test std::vector atype = { 0, 1, 1, 0, 1, 1 }; - std::vector box = {}; - std::vector expected_e = { + 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 = { + 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 = { + 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::vectorexpected_tot_v; + VALUETYPE expected_tot_e; + std::vectorexpected_tot_v; deepmd::DeepPot dp; @@ -447,17 +447,17 @@ class TestInferDeepPotANoPbc : public ::testing::Test TEST_F(TestInferDeepPotANoPbc, cpu_build_nlist) { double ener; - std::vector force, virial; + 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), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } } diff --git a/source/api_cc/tests/test_deeppot_model_devi.cc b/source/api_cc/tests/test_deeppot_model_devi.cc index 2b532f098e..56ad67d176 100644 --- a/source/api_cc/tests/test_deeppot_model_devi.cc +++ b/source/api_cc/tests/test_deeppot_model_devi.cc @@ -14,7 +14,7 @@ class TestInferDeepPotModeDevi : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -25,7 +25,7 @@ class TestInferDeepPotModeDevi : public ::testing::Test std::vector atype = { 0, 1, 1, 0, 1, 1 }; - std::vector box = { + std::vector box = { 13., 0., 0., 0., 13., 0., 0., 0., 13. }; int natoms; @@ -58,7 +58,7 @@ class TestInferDeepPotModeDevi : public ::testing::Test class TestInferDeepPotModeDeviPython : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 4.170220047025740423e-02,7.203244934421580703e-02,1.000114374817344942e-01, 4.053881673400336005e+00,4.191945144032948461e-02,6.852195003967595510e-02, 1.130233257263184132e+00,1.467558908171130543e-02,1.092338594768797883e-01, @@ -69,14 +69,14 @@ class TestInferDeepPotModeDeviPython : public ::testing::Test std::vector atype = { 0, 0, 1, 1, 1, 1 }; - std::vector box = { + std::vector box = { 20., 0., 0., 0., 20., 0., 0., 0., 20. }; int natoms; - std::vector expected_md_f = { + std::vector expected_md_f = { 0.509504727653, 0.458424067748, 0.481978258466 }; // max min avg - std::vector expected_md_v = { + std::vector expected_md_v = { 0.167004837423,0.00041822790564,0.0804864867641 }; // max min avg @@ -121,7 +121,7 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list) { float rc = dp_md.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -134,7 +134,7 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list) int nmodel = 2; std::vector edir(nmodel), emd; - std::vector > fdir_(nmodel), fdir(nmodel), vdir(nmodel), fmd_, fmd(nmodel), vmd; + std::vector > fdir_(nmodel), fdir(nmodel), vdir(nmodel), fmd_, fmd(nmodel), vmd; dp0.compute(edir[0], fdir_[0], vdir[0], coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); dp1.compute(edir[1], fdir_[1], vdir[1], coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); dp_md.compute(emd, fmd_, vmd, coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); @@ -151,12 +151,12 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list) EXPECT_EQ(vdir[kk].size(), vmd[kk].size()); } for(int kk = 0; kk < nmodel; ++kk){ - EXPECT_LT(fabs(edir[kk] - emd[kk]), 1e-10); + EXPECT_LT(fabs(edir[kk] - emd[kk]), EPSILON); for(int ii = 0; ii < fdir[0].size(); ++ii){ - EXPECT_LT(fabs(fdir[kk][ii] - fmd[kk][ii]), 1e-10); + EXPECT_LT(fabs(fdir[kk][ii] - fmd[kk][ii]), EPSILON); } for(int ii = 0; ii < vdir[0].size(); ++ii){ - EXPECT_LT(fabs(vdir[kk][ii] - vmd[kk][ii]), 1e-10); + EXPECT_LT(fabs(vdir[kk][ii] - vmd[kk][ii]), EPSILON); } } } @@ -166,7 +166,7 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list_atomic) { float rc = dp_md.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -179,7 +179,7 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list_atomic) int nmodel = 2; std::vector edir(nmodel), emd; - std::vector > fdir_(nmodel), fdir(nmodel), vdir(nmodel), fmd_, fmd(nmodel), vmd, aedir(nmodel), aemd, avdir(nmodel), avdir_(nmodel), avmd(nmodel), avmd_; + std::vector > fdir_(nmodel), fdir(nmodel), vdir(nmodel), fmd_, fmd(nmodel), vmd, aedir(nmodel), aemd, avdir(nmodel), avdir_(nmodel), avmd(nmodel), avmd_; dp0.compute(edir[0], fdir_[0], vdir[0], aedir[0], avdir_[0], coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); dp1.compute(edir[1], fdir_[1], vdir[1], aedir[1], avdir_[1], coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); dp_md.compute(emd, fmd_, vmd, aemd, avmd_, coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); @@ -202,18 +202,18 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list_atomic) EXPECT_EQ(avdir[kk].size(), avmd[kk].size()); } for(int kk = 0; kk < nmodel; ++kk){ - EXPECT_LT(fabs(edir[kk] - emd[kk]), 1e-10); + EXPECT_LT(fabs(edir[kk] - emd[kk]), EPSILON); for(int ii = 0; ii < fdir[0].size(); ++ii){ - EXPECT_LT(fabs(fdir[kk][ii] - fmd[kk][ii]), 1e-10); + EXPECT_LT(fabs(fdir[kk][ii] - fmd[kk][ii]), EPSILON); } for(int ii = 0; ii < vdir[0].size(); ++ii){ - EXPECT_LT(fabs(vdir[kk][ii] - vmd[kk][ii]), 1e-10); + EXPECT_LT(fabs(vdir[kk][ii] - vmd[kk][ii]), EPSILON); } for(int ii = 0; ii < aedir[0].size(); ++ii){ - EXPECT_LT(fabs(aedir[kk][ii] - aemd[kk][ii]), 1e-10); + EXPECT_LT(fabs(aedir[kk][ii] - aemd[kk][ii]), EPSILON); } for(int ii = 0; ii < avdir[0].size(); ++ii){ - EXPECT_LT(fabs(avdir[kk][ii] - avmd[kk][ii]), 1e-10); + EXPECT_LT(fabs(avdir[kk][ii] - avmd[kk][ii]), EPSILON); } } } @@ -223,7 +223,7 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list_std) { float rc = dp_md.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -236,8 +236,8 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list_std) int nmodel = 2; std::vector edir(nmodel), emd; - std::vector > fdir_(nmodel), fdir(nmodel), vdir(nmodel), fmd_, fmd(nmodel), vmd; - std::vector > aemd(nmodel), aemd_, avmd(nmodel), avmd_; + std::vector > fdir_(nmodel), fdir(nmodel), vdir(nmodel), fmd_, fmd(nmodel), vmd; + std::vector > aemd(nmodel), aemd_, avmd(nmodel), avmd_; dp0.compute(edir[0], fdir_[0], vdir[0], coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); dp1.compute(edir[1], fdir_[1], vdir[1], coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); dp_md.compute(emd, fmd_, vmd, aemd_, avmd_, coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); @@ -252,7 +252,7 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list_std) } // dp compute std e - std::vector avg_e, std_e; + std::vector avg_e, std_e; dp_md.compute_avg(avg_e, aemd); dp_md.compute_std_e(std_e, avg_e, aemd); @@ -275,36 +275,36 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list_std) } EXPECT_EQ(manual_std_e.size(), std_e.size()); for(int ii = 0; ii < std_e.size(); ++ii){ - EXPECT_LT(fabs(manual_avg_e[ii] - avg_e[ii]), 1e-10); - EXPECT_LT(fabs(manual_std_e[ii] - std_e[ii]), 1e-10); + EXPECT_LT(fabs(manual_avg_e[ii] - avg_e[ii]), EPSILON); + EXPECT_LT(fabs(manual_std_e[ii] - std_e[ii]), EPSILON); } // dp compute std f - std::vector avg_f, std_f; + std::vector avg_f, std_f; dp_md.compute_avg(avg_f, fmd); dp_md.compute_std_f(std_f, avg_f, fmd); // manual compute std f - std::vector manual_std_f(nloc); - std::vector manual_rel_std_f(nloc); - double eps = 0.2; + std::vector manual_std_f(nloc); + std::vector manual_rel_std_f(nloc); + VALUETYPE eps = 0.2; EXPECT_EQ(fmd[0].size(), nloc * 3); for(int ii = 0; ii < nloc; ++ii){ - std::vector avg_f(3, 0.0); + std::vector avg_f(3, 0.0); for(int dd = 0; dd < 3; ++dd){ for(int kk = 0; kk < nmodel; ++kk){ avg_f[dd] += fmd[kk][ii*3+dd]; } avg_f[dd] /= (nmodel) * 1.0; } - double std = 0.; + VALUETYPE std = 0.; for(int kk = 0; kk < nmodel; ++kk){ for(int dd = 0; dd < 3; ++dd){ - double tmp = fmd[kk][ii*3+dd] - avg_f[dd]; + VALUETYPE tmp = fmd[kk][ii*3+dd] - avg_f[dd]; std += tmp * tmp; } } - double f_norm = 0; + VALUETYPE f_norm = 0; for (int dd = 0; dd < 3; ++dd){ f_norm += avg_f[dd] * avg_f[dd]; } @@ -316,18 +316,18 @@ TEST_F(TestInferDeepPotModeDevi, cpu_lmp_list_std) EXPECT_EQ(manual_std_f.size(), std_f.size()); for(int ii = 0; ii < std_f.size(); ++ii){ - EXPECT_LT(fabs(manual_std_f[ii] - std_f[ii]), 1e-10); + EXPECT_LT(fabs(manual_std_f[ii] - std_f[ii]), EPSILON); } dp_md.compute_relative_std_f(std_f, avg_f, eps); EXPECT_EQ(manual_std_f.size(), std_f.size()); for(int ii = 0; ii < std_f.size(); ++ii){ - EXPECT_LT(fabs(manual_rel_std_f[ii] - std_f[ii]), 1e-10); + EXPECT_LT(fabs(manual_rel_std_f[ii] - std_f[ii]), EPSILON); } } -inline double mymax(const std::vector & xx) +inline VALUETYPE mymax(const std::vector & xx) { - double ret = 0; + VALUETYPE ret = 0; for (int ii = 0; ii < xx.size(); ++ii){ if (xx[ii] > ret) { ret = xx[ii]; @@ -335,9 +335,9 @@ inline double mymax(const std::vector & xx) } return ret; }; -inline double mymin(const std::vector & xx) +inline VALUETYPE mymin(const std::vector & xx) { - double ret = 1e10; + VALUETYPE ret = 1e10; for (int ii = 0; ii < xx.size(); ++ii){ if (xx[ii] < ret) { ret = xx[ii]; @@ -345,17 +345,17 @@ inline double mymin(const std::vector & xx) } return ret; }; -inline double myavg(const std::vector & xx) +inline VALUETYPE myavg(const std::vector & xx) { - double ret = 0; + VALUETYPE ret = 0; for (int ii = 0; ii < xx.size(); ++ii){ ret += xx[ii]; } return (ret / xx.size()); }; -inline double mystd(const std::vector & xx) +inline VALUETYPE mystd(const std::vector & xx) { - double ret = 0; + VALUETYPE ret = 0; for (int ii = 0; ii < xx.size(); ++ii){ ret += xx[ii] * xx[ii]; } @@ -366,7 +366,7 @@ TEST_F(TestInferDeepPotModeDeviPython, cpu_lmp_list_std) { float rc = dp_md.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -379,8 +379,8 @@ TEST_F(TestInferDeepPotModeDeviPython, cpu_lmp_list_std) int nmodel = 2; std::vector edir(nmodel), emd; - std::vector > fdir_(nmodel), fdir(nmodel), vdir(nmodel), fmd_, fmd(nmodel), vmd; - std::vector > aemd(nmodel), aemd_, avmd(nmodel), avmd_; + std::vector > fdir_(nmodel), fdir(nmodel), vdir(nmodel), fmd_, fmd(nmodel), vmd; + std::vector > aemd(nmodel), aemd_, avmd(nmodel), avmd_; dp0.compute(edir[0], fdir_[0], vdir[0], coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); dp1.compute(edir[1], fdir_[1], vdir[1], coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); dp_md.compute(emd, fmd_, vmd, aemd_, avmd_, coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); @@ -395,29 +395,29 @@ TEST_F(TestInferDeepPotModeDeviPython, cpu_lmp_list_std) } // dp compute std e - std::vector avg_e, std_e; + std::vector avg_e, std_e; dp_md.compute_avg(avg_e, aemd); dp_md.compute_std_e(std_e, avg_e, aemd); // dp compute std f - std::vector avg_f, std_f; + std::vector avg_f, std_f; dp_md.compute_avg(avg_f, fmd); dp_md.compute_std_f(std_f, avg_f, fmd); - EXPECT_LT(fabs(mymax(std_f) - expected_md_f[0]), 1e-10); - EXPECT_LT(fabs(mymin(std_f) - expected_md_f[1]), 1e-10); - EXPECT_LT(fabs(myavg(std_f) - expected_md_f[2]), 1e-10); + EXPECT_LT(fabs(mymax(std_f) - expected_md_f[0]), EPSILON); + EXPECT_LT(fabs(mymin(std_f) - expected_md_f[1]), EPSILON); + EXPECT_LT(fabs(myavg(std_f) - expected_md_f[2]), EPSILON); // dp compute std v // we normalize v by number of atoms for (int ii = 0; ii < vmd.size(); ++ii){ for(int jj = 0; jj < vmd[ii].size(); ++jj){ - vmd[ii][jj] /= double(atype.size()); + vmd[ii][jj] /= VALUETYPE(atype.size()); } } - std::vector avg_v, std_v; + std::vector avg_v, std_v; dp_md.compute_avg(avg_v, vmd); dp_md.compute_std(std_v, avg_v, vmd, 1); - EXPECT_LT(fabs(mymax(std_v) - expected_md_v[0]), 1e-10); - EXPECT_LT(fabs(mymin(std_v) - expected_md_v[1]), 1e-10); - EXPECT_LT(fabs(mystd(std_v) - expected_md_v[2]), 1e-10); + EXPECT_LT(fabs(mymax(std_v) - expected_md_v[0]), EPSILON); + EXPECT_LT(fabs(mymin(std_v) - expected_md_v[1]), EPSILON); + EXPECT_LT(fabs(mystd(std_v) - expected_md_v[2]), EPSILON); } diff --git a/source/api_cc/tests/test_deeppot_r.cc b/source/api_cc/tests/test_deeppot_r.cc index 3bd34f398c..9fcc921e2f 100644 --- a/source/api_cc/tests/test_deeppot_r.cc +++ b/source/api_cc/tests/test_deeppot_r.cc @@ -14,7 +14,7 @@ class TestInferDeepPotR : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -25,21 +25,21 @@ class TestInferDeepPotR : public ::testing::Test std::vector atype = { 0, 1, 1, 0, 1, 1 }; - std::vector box = { + std::vector box = { 13., 0., 0., 0., 13., 0., 0., 0., 13. }; - std::vector expected_e = { + 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 = { + 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 = { + 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::vectorexpected_tot_v; + VALUETYPE expected_tot_e; + std::vectorexpected_tot_v; deepmd::DeepPot dp; @@ -74,24 +74,24 @@ class TestInferDeepPotR : public ::testing::Test TEST_F(TestInferDeepPotR, cpu_build_nlist) { double ener; - std::vector force, virial; + 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), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } } TEST_F(TestInferDeepPotR, cpu_build_nlist_numfv) { - class MyModel : public EnergyModelTest + class MyModel : public EnergyModelTest { deepmd::DeepPot & mydp; const std::vector & atype; @@ -102,17 +102,17 @@ TEST_F(TestInferDeepPotR, cpu_build_nlist_numfv) ) : mydp(dp_), atype(atype_) {}; virtual void compute ( double & ener, - std::vector & force, - std::vector & virial, - const std::vector & coord, - const std::vector & box) { + 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); + std::vector box_(box); box_[1] -= 0.4; model.test_f(coord, box_); model.test_v(coord, box_); @@ -136,7 +136,7 @@ TEST_F(TestInferDeepPotR, cpu_build_nlist_numfv) TEST_F(TestInferDeepPotR, cpu_build_nlist_atomic) { double ener; - std::vector force, virial, atom_ener, atom_vir; + 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); @@ -144,18 +144,18 @@ TEST_F(TestInferDeepPotR, cpu_build_nlist_atomic) EXPECT_EQ(atom_ener.size(), natoms); EXPECT_EQ(atom_vir.size(), natoms*9); - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); } } @@ -164,7 +164,7 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -176,20 +176,20 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist) convert_nlist(inlist, nlist_data); double ener; - std::vector force_, virial; + std::vector force_, virial; dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall-nloc, inlist, 0); - std::vector force; + 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), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } ener = 0.; @@ -201,12 +201,12 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist) EXPECT_EQ(force.size(), natoms*3); EXPECT_EQ(virial.size(), 9); - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } } @@ -215,7 +215,7 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_atomic) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -227,8 +227,8 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_atomic) convert_nlist(inlist, nlist_data); double ener; - std::vector force_, atom_ener_, atom_vir_, virial; - std::vector force, atom_ener, atom_vir; + 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); @@ -239,18 +239,18 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_atomic) EXPECT_EQ(atom_ener.size(), natoms); EXPECT_EQ(atom_vir.size(), natoms*9); - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); } ener = 0.; @@ -268,18 +268,18 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_atomic) EXPECT_EQ(atom_ener.size(), natoms); EXPECT_EQ(atom_vir.size(), natoms*9); - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON); } } @@ -288,7 +288,7 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_2rc) { float rc = dp.cutoff(); int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -300,20 +300,20 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_2rc) convert_nlist(inlist, nlist_data); double ener; - std::vector force_(nall*3, 0.0), virial(9, 0.0); + 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; + 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), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } ener = 0.; @@ -325,12 +325,12 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_2rc) EXPECT_EQ(force.size(), natoms*3); EXPECT_EQ(virial.size(), 9); - EXPECT_LT(fabs(ener - expected_tot_e), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } } @@ -341,7 +341,7 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_type_sel) // add vir atoms int nvir = 2; - std::vector coord_vir(nvir*3); + std::vector coord_vir(nvir*3); std::vector atype_vir(nvir, 2); for(int ii = 0; ii < nvir; ++ii){ coord_vir[ii] = coord[ii]; @@ -349,12 +349,12 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_type_sel) 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); + 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 coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -367,21 +367,21 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_type_sel) // dp compute double ener; - std::vector force_(nall*3, 0.0), virial(9, 0.0); + 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; + 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), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } } @@ -390,7 +390,7 @@ TEST_F(TestInferDeepPotR, cpu_lmp_nlist_type_sel) class TestInferDeepPotRNoPbc : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -401,19 +401,19 @@ class TestInferDeepPotRNoPbc : public ::testing::Test std::vector atype = { 0, 1, 1, 0, 1, 1 }; - std::vector box = {}; - std::vector expected_e = { + 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 = { + 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 = { + 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::vectorexpected_tot_v; + VALUETYPE expected_tot_e; + std::vectorexpected_tot_v; deepmd::DeepPot dp; @@ -447,17 +447,17 @@ class TestInferDeepPotRNoPbc : public ::testing::Test TEST_F(TestInferDeepPotRNoPbc, cpu_build_nlist) { double ener; - std::vector force, virial; + 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), 1e-10); + EXPECT_LT(fabs(ener - expected_tot_e), EPSILON); for(int ii = 0; ii < natoms*3; ++ii){ - EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10); + 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]), 1e-10); + EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON); } } diff --git a/source/api_cc/tests/test_dipolecharge.cc b/source/api_cc/tests/test_dipolecharge.cc index b75677f8f6..1fdd767c3b 100644 --- a/source/api_cc/tests/test_dipolecharge.cc +++ b/source/api_cc/tests/test_dipolecharge.cc @@ -17,7 +17,7 @@ class TestDipoleCharge : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 4.6067455554, 8.8719311819, 6.3886531197, 4.0044515745, 4.2449530507, 7.7902855220, 2.6453069446, 0.8772647726, 1.2804446790, @@ -30,26 +30,26 @@ class TestDipoleCharge : public ::testing::Test std::vector atype = { 0,3,2,1,3,4,1,4 }; - std::vector box = { + std::vector box = { 10., 0., 0., 0., 10., 0., 0., 0., 10. }; std::vector expected_e = { 3.671081837126222158e+00 }; - std::vector expected_f = { + std::vector expected_f = { 8.786854427753210128e-01,-1.590752486903602159e-01,-2.709225006303785932e-01,-4.449513960033193438e-01,-1.564291540964127813e-01,2.139031741772115178e-02,1.219699614140521193e+00,-5.580358618499958734e-02,-3.878662478349682585e-01,-1.286685244990778854e+00,1.886475802950296488e-01,3.904450515493615437e-01,1.605017382138404849e-02,2.138016869742287995e-01,-2.617514921203008965e-02,2.877081057057793712e-01,-3.846449683844421763e-01,3.048855616906603894e-02,-9.075632811311897807e-01,-6.509653472431625731e-03,2.302010972126376787e-01,2.370565856822822726e-01,3.600133435593881881e-01,1.243887532859055609e-02 }; - std::vector expected_v = { + std::vector expected_v = { 3.714071471995848417e-01,6.957130186032146613e-01,-1.158289779017217302e+00,6.957130186032139951e-01,-1.400130091653774933e+01,-3.631620234653316626e-01,-1.158289779017217302e+00,-3.631620234653316626e-01,3.805077486043773050e+00 }; - std::vector charge_map = { + std::vector charge_map = { 1., 1., 1., 1., 1., -1., -3. }; int natoms; int ntypes; std::vector type_asso; double expected_tot_e; - std::vectorexpected_tot_v; + std::vectorexpected_tot_v; deepmd::DeepTensor dp; deepmd::DipoleChargeModifier dm; @@ -93,7 +93,7 @@ TEST_F(TestDipoleCharge, cpu_lmp_nlist) // float rc = dp.cutoff(); float rc = 4.0; int nloc = coord.size() / 3; - std::vector coord_cpy; + std::vector coord_cpy; std::vector atype_cpy, mapping; std::vector > nlist_data; _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, @@ -106,7 +106,7 @@ TEST_F(TestDipoleCharge, cpu_lmp_nlist) convert_nlist(inlist, nlist_data); // evaluate dipole - std::vector dipole, dipole_recd(nloc*3, 0.0); + std::vector dipole, dipole_recd(nloc*3, 0.0); dp.compute(dipole, coord_cpy, atype_cpy, box, nall-nloc, inlist); // add virtual atoms to the system @@ -124,7 +124,7 @@ TEST_F(TestDipoleCharge, cpu_lmp_nlist) // const std::vector & sort_fwd_map(nnp_map.get_fwd_map()); // // add coords - std::vector add_coord; + std::vector add_coord; std::vector add_atype; std::vector> pairs; for(int ii = 0; ii < nloc; ++ii){ @@ -132,7 +132,7 @@ TEST_F(TestDipoleCharge, cpu_lmp_nlist) // Yixiao: the sort map is no longer needed // int res_idx = sort_fwd_map[sel_fwd[ii]]; int res_idx = sel_fwd[ii]; - std::vector tmp_coord(3); + std::vector tmp_coord(3); for(int dd = 0; dd < 3; ++dd){ tmp_coord[dd] = coord[ii*3+dd] + dipole[res_idx*3+dd]; dipole_recd[ii*3+dd] = dipole[res_idx*3+dd]; @@ -155,17 +155,17 @@ TEST_F(TestDipoleCharge, cpu_lmp_nlist) EXPECT_EQ(atype.size()*3, coord.size()); // get charge value - std::vector charge(nloc); + std::vector charge(nloc); for(int ii = 0; ii < nloc; ++ii){ charge[ii] = charge_map[atype[ii]]; } // compute the recp part of the ele interaction - double eener; - std::vector eforce, evirial; - deepmd::Region region; + VALUETYPE eener; + std::vector eforce, evirial; + deepmd::Region region; init_region_cpu(region, &box[0]); - deepmd::EwaldParameters eparam; + deepmd::EwaldParameters eparam; eparam.beta = 0.2; eparam.spacing = 4; ewald_recp(eener, eforce, evirial, coord, charge, region, eparam); @@ -189,7 +189,7 @@ TEST_F(TestDipoleCharge, cpu_lmp_nlist) convert_nlist(inlist, nlist_data); // compute force and virial - std::vector force_, force, virial; + std::vector force_, force, virial; dm.compute(force_, virial, coord_cpy, atype_cpy, box, pairs, eforce, nghost, inlist); // for(int ii = 0; ii < force_.size(); ++ii){ // std::cout << force_[ii] << " " ; diff --git a/source/api_cc/tests/test_ewald.cc b/source/api_cc/tests/test_ewald.cc index e27b1087e3..5b57aa9dc0 100644 --- a/source/api_cc/tests/test_ewald.cc +++ b/source/api_cc/tests/test_ewald.cc @@ -10,7 +10,7 @@ class TestInferEwald : public ::testing::Test { protected: - std::vector coord = { + std::vector coord = { 12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68, @@ -18,10 +18,10 @@ class TestInferEwald : public ::testing::Test 3.51, 2.51, 2.60, 4.27, 3.22, 1.56 }; - std::vector charge = { + std::vector charge = { -2, 1, 1, -2, 1, 1 }; - std::vector box = { + std::vector box = { 13., 0., 0., 0., 13., 0., 0., 0., 13. }; void SetUp() override { @@ -32,31 +32,31 @@ class TestInferEwald : public ::testing::Test TEST_F(TestInferEwald, cpu_numfv) { - class MyModel : public EnergyModelTest + class MyModel : public EnergyModelTest { - const std::vector & charge; - deepmd::EwaldParameters eparam; + const std::vector & charge; + deepmd::EwaldParameters eparam; public: MyModel( - const std::vector & charge_ + const std::vector & charge_ ) : charge(charge_) { eparam.beta = 0.4; }; virtual void compute ( double & ener, - std::vector & force, - std::vector & virial, - const std::vector & coord, - const std::vector & box) { - deepmd::Region region; + std::vector & force, + std::vector & virial, + const std::vector & coord, + const std::vector & box) { + deepmd::Region region; init_region_cpu(region, &box[0]); - ewald_recp(ener, force, virial, coord, charge, region, eparam); + ewald_recp((VALUETYPE &)ener, force, virial, coord, charge, region, eparam); } }; MyModel model(charge); model.test_f(coord, box); model.test_v(coord, box); - std::vector box_(box); + std::vector box_(box); box_[1] -= 0.2; model.test_f(coord, box_); model.test_v(coord, box_); diff --git a/source/api_cc/tests/test_utils.h b/source/api_cc/tests/test_utils.h index d2d9d6c261..6173dc5ec9 100644 --- a/source/api_cc/tests/test_utils.h +++ b/source/api_cc/tests/test_utils.h @@ -1,10 +1,18 @@ #pragma once #include +#ifdef HIGH_PREC +typedef double VALUETYPE; +#define EPSILON 1e-10 +#else +typedef float VALUETYPE; +#define EPSILON 1e-4 +#endif + inline void _fold_back( - typename std::vector::iterator out, - const typename std::vector::const_iterator in, + typename std::vector::iterator out, + const typename std::vector::const_iterator in, const std::vector &mapping, const int nloc, const int nall, @@ -23,8 +31,8 @@ _fold_back( inline void _fold_back( - std::vector &out, - const std::vector &in, + std::vector &out, + const std::vector &in, const std::vector &mapping, const int nloc, const int nall, @@ -37,18 +45,23 @@ _fold_back( inline void _build_nlist( std::vector> &nlist_data, - std::vector & coord_cpy, + std::vector & coord_cpy, std::vector & atype_cpy, std::vector & mapping, - const std::vector & coord, + const std::vector & coord, const std::vector & atype, - const std::vector & box, + const std::vector & box, const float & rc) { + // convert VALUETYPE to double, it looks like copy_coord only accepts double + std::vector coord_cpy_; + std::vector coord_(coord.begin(), coord.end()); + std::vector box_(box.begin(), box.end()); + SimulationRegion region; - region.reinitBox(&box[0]); + region.reinitBox(&box_[0]); std::vector ncell, ngcell; - copy_coord(coord_cpy, atype_cpy, mapping, ncell, ngcell, coord, atype, rc, region); + copy_coord(coord_cpy_, atype_cpy, mapping, ncell, ngcell, coord_, atype, rc, region); std::vector nat_stt, ext_stt, ext_end; nat_stt.resize(3); ext_stt.resize(3); @@ -57,20 +70,28 @@ _build_nlist( ext_stt[dd] = -ngcell[dd]; ext_end[dd] = ncell[dd] + ngcell[dd]; } - int nloc = coord.size() / 3; - int nall = coord_cpy.size() / 3; + int nloc = coord_.size() / 3; + int nall = coord_cpy_.size() / 3; std::vector> nlist_r_cpy; - build_nlist(nlist_data, nlist_r_cpy, coord_cpy, nloc, rc, rc, nat_stt, ncell, ext_stt, ext_end, region, ncell); + build_nlist(nlist_data, nlist_r_cpy, coord_cpy_, nloc, rc, rc, nat_stt, ncell, ext_stt, ext_end, region, ncell); + + // convert double to VALUETYPE + coord_cpy.assign(coord_cpy_.begin(), coord_cpy_.end()); } template class EnergyModelTest { +#ifdef HIGH_PREC double hh = 1e-5; double level = 1e-6; +#else + double hh = 1e-1; + double level = 2; // expected? +#endif public: virtual void compute ( - VALUETYPE & ener, + double & ener, std::vector & force, std::vector & virial, const std::vector & coord, @@ -80,12 +101,12 @@ class EnergyModelTest const std::vector & coord, const std::vector & box) { int ndof = coord.size(); - VALUETYPE ener; + double ener; std::vector force, virial; compute(ener, force, virial, coord, box); for(int ii = 0; ii < ndof; ++ii){ std::vector coord0(coord), coord1(coord); - VALUETYPE ener0, ener1; + double ener0, ener1; std::vector forcet, virialt; coord0[ii] += hh; coord1[ii] -= hh; @@ -100,7 +121,7 @@ class EnergyModelTest const std::vector & coord, const std::vector & box) { std::vector num_diff(9); - VALUETYPE ener; + double ener; std::vector force, virial; compute(ener, force, virial, coord, box); deepmd::Region region; @@ -124,7 +145,7 @@ class EnergyModelTest convert_to_inter_cpu(pi, region, &coord[ii*3]); convert_to_phys_cpu(&coord1[ii*3], region1, pi); } - VALUETYPE ener0, ener1; + double ener0, ener1; std::vector forcet, virialt; compute(ener0, forcet, virialt, coord0, box0); compute(ener1, forcet, virialt, coord1, box1); diff --git a/source/install/test_cc.sh b/source/install/test_cc.sh index 65582e2986..0abb432a61 100755 --- a/source/install/test_cc.sh +++ b/source/install/test_cc.sh @@ -33,5 +33,5 @@ make install #------------------ cd ${SCRIPT_PATH}/../api_cc/tests ${INSTALL_PREFIX}/bin/runUnitTests - +${INSTALL_PREFIX}/bin/runUnitTests_low diff --git a/source/install/test_cc_local.sh b/source/install/test_cc_local.sh index e5a1070186..8217e09ba9 100755 --- a/source/install/test_cc_local.sh +++ b/source/install/test_cc_local.sh @@ -32,3 +32,4 @@ make install #------------------ cd ${SCRIPT_PATH}/../api_cc/tests ${INSTALL_PREFIX}/bin/runUnitTests +${INSTALL_PREFIX}/bin/runUnitTests_low From 1afe3751c10c24395407c4ee2049c3448c1c6823 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 29 Oct 2022 12:04:18 -0400 Subject: [PATCH 6/8] fix EnergyModelTest --- source/api_cc/tests/test_ewald.cc | 4 +++- source/api_cc/tests/test_utils.h | 8 ++++++-- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/source/api_cc/tests/test_ewald.cc b/source/api_cc/tests/test_ewald.cc index 5b57aa9dc0..0ef3b27b21 100644 --- a/source/api_cc/tests/test_ewald.cc +++ b/source/api_cc/tests/test_ewald.cc @@ -50,7 +50,9 @@ TEST_F(TestInferEwald, cpu_numfv) const std::vector & box) { deepmd::Region region; init_region_cpu(region, &box[0]); - ewald_recp((VALUETYPE &)ener, force, virial, coord, charge, region, eparam); + VALUETYPE ener_; + ewald_recp(ener_, force, virial, coord, charge, region, eparam); + ener = ener_; } }; MyModel model(charge); diff --git a/source/api_cc/tests/test_utils.h b/source/api_cc/tests/test_utils.h index 6173dc5ec9..53c73ab9c4 100644 --- a/source/api_cc/tests/test_utils.h +++ b/source/api_cc/tests/test_utils.h @@ -86,8 +86,8 @@ class EnergyModelTest double hh = 1e-5; double level = 1e-6; #else - double hh = 1e-1; - double level = 2; // expected? + double hh = 1e-2; + double level = 1e-2; // expected? #endif public: virtual void compute ( @@ -161,7 +161,11 @@ class EnergyModelTest } } for(int ii = 0; ii < 9; ++ii){ +#ifdef HIGH_PREC EXPECT_LT(fabs(num_virial[ii] - virial[ii]), level); +#else + EXPECT_LT(fabs(num_virial[ii] - virial[ii]), 2); // expected? +#endif } } }; From 3a662de3450fed5b2fabade0e032acf947f8f477 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 29 Oct 2022 12:21:46 -0400 Subject: [PATCH 7/8] fix typo --- source/api_cc/src/DataModifier.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/api_cc/src/DataModifier.cc b/source/api_cc/src/DataModifier.cc index 226c80b82c..2848f94d0d 100644 --- a/source/api_cc/src/DataModifier.cc +++ b/source/api_cc/src/DataModifier.cc @@ -245,7 +245,7 @@ compute (std::vector & dfcorr_, } } } else { - auto extf = extf_tensor.matrix (); + auto extf = extf_tensor.matrix (); for (int ii = 0; ii < nframes; ++ii){ for (int jj = 0; jj < extf.size(); ++jj){ extf(ii,jj) = dextf[jj]; From 680f2ab87bd7c57cfbed650adf9d9a594e0969f6 Mon Sep 17 00:00:00 2001 From: Jinzhe Zeng Date: Sat, 29 Oct 2022 20:40:43 -0400 Subject: [PATCH 8/8] revert change to test_v --- source/api_cc/tests/test_utils.h | 4 ---- 1 file changed, 4 deletions(-) diff --git a/source/api_cc/tests/test_utils.h b/source/api_cc/tests/test_utils.h index 53c73ab9c4..ef44369821 100644 --- a/source/api_cc/tests/test_utils.h +++ b/source/api_cc/tests/test_utils.h @@ -161,11 +161,7 @@ class EnergyModelTest } } for(int ii = 0; ii < 9; ++ii){ -#ifdef HIGH_PREC EXPECT_LT(fabs(num_virial[ii] - virial[ii]), level); -#else - EXPECT_LT(fabs(num_virial[ii] - virial[ii]), 2); // expected? -#endif } } };