From 3db944deccad66ad5a75b1ae3c39843e5ce65541 Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Sat, 13 Jun 2020 01:54:58 -0400 Subject: [PATCH] apply clang-format settings to the c++ sources in the unittest tree --- unittest/force-styles/angle_style.cpp | 436 +++++------ unittest/force-styles/bond_style.cpp | 577 +++++++------- unittest/force-styles/error_stats.cpp | 27 +- unittest/force-styles/error_stats.h | 8 +- unittest/force-styles/pair_style.cpp | 741 ++++++++---------- unittest/force-styles/test_config.h | 39 +- unittest/force-styles/test_config_reader.cpp | 171 ++-- unittest/force-styles/test_config_reader.h | 56 +- unittest/force-styles/test_main.cpp | 29 +- unittest/force-styles/test_main.h | 14 +- unittest/force-styles/yaml_reader.h | 151 ++-- unittest/force-styles/yaml_writer.cpp | 94 +-- unittest/force-styles/yaml_writer.h | 8 +- .../test_eim_potential_file_reader.cpp | 80 +- .../formats/test_potential_file_reader.cpp | 66 +- unittest/utils/test_fmtlib.cpp | 73 +- unittest/utils/test_tokenizer.cpp | 55 +- unittest/utils/test_utils.cpp | 204 +++-- 18 files changed, 1400 insertions(+), 1429 deletions(-) diff --git a/unittest/force-styles/angle_style.cpp b/unittest/force-styles/angle_style.cpp index f1825d5a57..a1a618bbca 100644 --- a/unittest/force-styles/angle_style.cpp +++ b/unittest/force-styles/angle_style.cpp @@ -13,32 +13,32 @@ // unit tests for angle styles intended for molecular systems -#include "yaml_reader.h" -#include "yaml_writer.h" #include "error_stats.h" #include "test_config.h" #include "test_config_reader.h" #include "test_main.h" +#include "yaml_reader.h" +#include "yaml_writer.h" -#include "gtest/gtest.h" #include "gmock/gmock.h" +#include "gtest/gtest.h" -#include "lammps.h" +#include "angle.h" #include "atom.h" -#include "modify.h" #include "compute.h" #include "force.h" -#include "angle.h" #include "info.h" #include "input.h" +#include "lammps.h" +#include "modify.h" #include "universe.h" -#include -#include -#include -#include #include +#include +#include +#include #include +#include #include #include @@ -46,12 +46,13 @@ #include #include -using ::testing::StartsWith; using ::testing::HasSubstr; +using ::testing::StartsWith; using namespace LAMMPS_NS; -static void delete_file(const std::string & filename) { +static void delete_file(const std::string &filename) +{ remove(filename.c_str()); }; @@ -63,9 +64,7 @@ void cleanup_lammps(LAMMPS *lmp, const TestConfig &cfg) delete lmp; } -LAMMPS *init_lammps(int argc, char **argv, - const TestConfig &cfg, - const bool newton=true) +LAMMPS *init_lammps(int argc, char **argv, const TestConfig &cfg, const bool newton = true) { LAMMPS *lmp; @@ -74,7 +73,7 @@ LAMMPS *init_lammps(int argc, char **argv, // check if prerequisite styles are available Info *info = new Info(lmp); int nfail = 0; - for (auto& prerequisite : cfg.prerequisites) { + for (auto &prerequisite : cfg.prerequisites) { std::string style = prerequisite.second; // this is a test for angle styles, so if the suffixed @@ -86,19 +85,19 @@ LAMMPS *init_lammps(int argc, char **argv, } } - if (!info->has_style(prerequisite.first,style)) ++nfail; + if (!info->has_style(prerequisite.first, style)) ++nfail; } if (nfail > 0) { delete info; - cleanup_lammps(lmp,cfg); + cleanup_lammps(lmp, cfg); return nullptr; } // utility lambdas to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; - auto parse_input_script = [&](const std::string & filename) { + auto parse_input_script = [&](const std::string &filename) { lmp->input->file(filename.c_str()); }; @@ -110,7 +109,7 @@ LAMMPS *init_lammps(int argc, char **argv, command("variable input_dir index " + INPUT_FOLDER); - for (auto& pre_command : cfg.pre_commands) { + for (auto &pre_command : cfg.pre_commands) { command(pre_command); } @@ -119,11 +118,11 @@ LAMMPS *init_lammps(int argc, char **argv, command("angle_style " + cfg.angle_style); - for (auto& angle_coeff : cfg.angle_coeff) { + for (auto &angle_coeff : cfg.angle_coeff) { command("angle_coeff " + angle_coeff); } - for (auto& post_command : cfg.post_commands) { + for (auto &post_command : cfg.post_commands) { command(post_command); } @@ -138,7 +137,7 @@ LAMMPS *init_lammps(int argc, char **argv, void run_lammps(LAMMPS *lmp) { // utility lambda to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; @@ -153,7 +152,7 @@ void run_lammps(LAMMPS *lmp) void restart_lammps(LAMMPS *lmp, const TestConfig &cfg) { // utility lambda to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; @@ -164,14 +163,13 @@ void restart_lammps(LAMMPS *lmp, const TestConfig &cfg) command("angle_style " + cfg.angle_style); } - if ((cfg.angle_style.substr(0,6) == "hybrid") - || !lmp->force->angle->writedata) { - for (auto& angle_coeff : cfg.angle_coeff) { + if ((cfg.angle_style.substr(0, 6) == "hybrid") || !lmp->force->angle->writedata) { + for (auto &angle_coeff : cfg.angle_coeff) { command("angle_coeff " + angle_coeff); } } - for (auto& post_command : cfg.post_commands) { + for (auto &post_command : cfg.post_commands) { command(post_command); } @@ -181,10 +179,10 @@ void restart_lammps(LAMMPS *lmp, const TestConfig &cfg) void data_lammps(LAMMPS *lmp, const TestConfig &cfg) { // utility lambdas to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; - auto parse_input_script = [&](const std::string & filename) { + auto parse_input_script = [&](const std::string &filename) { lmp->input->file(filename.c_str()); }; @@ -194,7 +192,7 @@ void data_lammps(LAMMPS *lmp, const TestConfig &cfg) command("variable newton_bond delete"); command("variable newton_bond index on"); - for (auto& pre_command : cfg.pre_commands) { + for (auto &pre_command : cfg.pre_commands) { command(pre_command); } @@ -204,10 +202,10 @@ void data_lammps(LAMMPS *lmp, const TestConfig &cfg) std::string input_file = INPUT_FOLDER + PATH_SEP + cfg.input_file; parse_input_script(input_file); - for (auto& angle_coeff : cfg.angle_coeff) { + for (auto &angle_coeff : cfg.angle_coeff) { command("angle_coeff " + angle_coeff); } - for (auto& post_command : cfg.post_commands) { + for (auto &post_command : cfg.post_commands) { command(post_command); } command("run 0 post no"); @@ -218,16 +216,15 @@ void data_lammps(LAMMPS *lmp, const TestConfig &cfg) void generate_yaml_file(const char *outfile, const TestConfig &config) { // initialize system geometry - const char *args[] = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite" }; + const char *args[] = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); - LAMMPS *lmp = init_lammps(argc,argv,config); + int argc = sizeof(args) / sizeof(char *); + LAMMPS *lmp = init_lammps(argc, argv, config); if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; - for (auto& prerequisite : config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + "in this LAMMPS configuration:\n"; + for (auto &prerequisite : config.prerequisites) { + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } return; } @@ -245,7 +242,7 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // date_generated std::time_t now = time(NULL); block = ctime(&now); - block = block.substr(0,block.find("\n")-1); + block = block.substr(0, block.find("\n") - 1); writer.emit("date_generated", block); // epsilon @@ -253,21 +250,21 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // prerequisites block.clear(); - for (auto& prerequisite : config.prerequisites) { + for (auto &prerequisite : config.prerequisites) { block += prerequisite.first + " " + prerequisite.second + "\n"; } writer.emit_block("prerequisites", block); // pre_commands block.clear(); - for (auto& command : config.pre_commands) { + for (auto &command : config.pre_commands) { block += command + "\n"; } writer.emit_block("pre_commands", block); // post_commands block.clear(); - for (auto& command : config.post_commands) { + for (auto &command : config.post_commands) { block += command + "\n"; } writer.emit_block("post_commands", block); @@ -280,7 +277,7 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // angle_coeff block.clear(); - for (auto& angle_coeff : config.angle_coeff) { + for (auto &angle_coeff : config.angle_coeff) { block += angle_coeff + "\n"; } writer.emit_block("angle_coeff", block); @@ -288,15 +285,15 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // equilibrium angle std::stringstream eqstr; eqstr << lmp->atom->nangletypes; - for (int i=0; i < lmp->atom->nangletypes; ++i) { - eqstr << " " << lmp->force->angle->equilibrium_angle(i+1); + for (int i = 0; i < lmp->atom->nangletypes; ++i) { + eqstr << " " << lmp->force->angle->equilibrium_angle(i + 1); } writer.emit("equilibrium", eqstr.str()); // extract block.clear(); std::stringstream outstr; - for (auto& data : config.extract) { + for (auto &data : config.extract) { outstr << data.first << " " << data.second << std::endl; } writer.emit_block("extract", outstr.str()); @@ -309,17 +306,17 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // init_stress double *stress = lmp->force->angle->virial; - snprintf(buf,bufsize,"% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", - stress[0],stress[1],stress[2],stress[3],stress[4],stress[5]); + snprintf(buf, bufsize, "% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", stress[0], + stress[1], stress[2], stress[3], stress[4], stress[5]); writer.emit_block("init_stress", buf); // init_forces block.clear(); double **f = lmp->atom->f; tagint *tag = lmp->atom->tag; - for (int i=0; i < natoms; ++i) { - snprintf(buf,bufsize,"% 3d % 23.16e % 23.16e % 23.16e\n", - (int)tag[i], f[i][0], f[i][1], f[i][2]); + for (int i = 0; i < natoms; ++i) { + snprintf(buf, bufsize, "% 3d % 23.16e % 23.16e % 23.16e\n", (int)tag[i], f[i][0], f[i][1], + f[i][2]); block += buf; } writer.emit_block("init_forces", block); @@ -332,40 +329,40 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // run_stress stress = lmp->force->angle->virial; - snprintf(buf,bufsize,"% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", - stress[0],stress[1],stress[2],stress[3],stress[4],stress[5]); + snprintf(buf, bufsize, "% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", stress[0], + stress[1], stress[2], stress[3], stress[4], stress[5]); writer.emit_block("run_stress", buf); block.clear(); f = lmp->atom->f; tag = lmp->atom->tag; - for (int i=0; i < natoms; ++i) { - snprintf(buf,bufsize,"% 3d % 23.16e % 23.16e % 23.16e\n", - (int)tag[i], f[i][0], f[i][1], f[i][2]); + for (int i = 0; i < natoms; ++i) { + snprintf(buf, bufsize, "% 3d % 23.16e % 23.16e % 23.16e\n", (int)tag[i], f[i][0], f[i][1], + f[i][2]); block += buf; } writer.emit_block("run_forces", block); - cleanup_lammps(lmp,config); + cleanup_lammps(lmp, config); return; } -TEST(AngleStyle, plain) { - const char *args[] = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite" }; +TEST(AngleStyle, plain) +{ + const char *args[] = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config,true); + LAMMPS *lmp = init_lammps(argc, argv, test_config, true); std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; - for (auto& prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + "in this LAMMPS configuration:\n"; + for (auto &prerequisite : test_config.prerequisites) { + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -375,22 +372,21 @@ TEST(AngleStyle, plain) { // abort if running in parallel and not all atoms are local const int nlocal = lmp->atom->nlocal; - ASSERT_EQ(lmp->atom->natoms,nlocal); + ASSERT_EQ(lmp->atom->natoms, nlocal); double epsilon = test_config.epsilon; - double **f=lmp->atom->f; - tagint *tag=lmp->atom->tag; + double **f = lmp->atom->f; + tagint *tag = lmp->atom->tag; ErrorStats stats; stats.reset(); const std::vector &f_ref = test_config.init_forces; - ASSERT_EQ(nlocal+1,f_ref.size()); - for (int i=0; i < nlocal; ++i) { + ASSERT_EQ(nlocal + 1, f_ref.size()); + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton on: " << stats << std::endl; Angle *angle = lmp->force->angle; double *stress = angle->virial; @@ -401,13 +397,11 @@ TEST(AngleStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_stress stats, newton on: " << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(angle->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -416,15 +410,14 @@ TEST(AngleStyle, plain) { f = lmp->atom->f; stress = angle->virial; const std::vector &f_run = test_config.run_forces; - ASSERT_EQ(nlocal+1,f_run.size()); + ASSERT_EQ(nlocal + 1, f_run.size()); stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton on: " << stats << std::endl; stress = angle->virial; stats.reset(); @@ -434,52 +427,47 @@ TEST(AngleStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_stress stats, newton on: " << stats << std::endl; stats.reset(); int id = lmp->modify->find_compute("sum"); double energy = lmp->modify->compute[id]->compute_scalar(); EXPECT_FP_LE_WITH_EPS(angle->energy, test_config.run_energy, epsilon); EXPECT_FP_LE_WITH_EPS(angle->energy, energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); - lmp = init_lammps(argc,argv,test_config,false); + cleanup_lammps(lmp, test_config); + lmp = init_lammps(argc, argv, test_config, false); if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on if (lmp->force->newton_bond == 0) { - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton off:" << stats << std::endl; angle = lmp->force->angle; stress = angle->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 2*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 2*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 2*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 2*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 2*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 2*epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 2 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 2 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 2 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 2 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 2 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 2 * epsilon); + if (print_stats) std::cerr << "init_stress stats, newton off:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(angle->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton off:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -488,13 +476,12 @@ TEST(AngleStyle, plain) { f = lmp->atom->f; stress = angle->virial; stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton off:" << stats << std::endl; stress = angle->virial; stats.reset(); @@ -504,33 +491,30 @@ TEST(AngleStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_stress stats, newton off:" << stats << std::endl; stats.reset(); id = lmp->modify->find_compute("sum"); energy = lmp->modify->compute[id]->compute_scalar(); EXPECT_FP_LE_WITH_EPS(angle->energy, test_config.run_energy, epsilon); EXPECT_FP_LE_WITH_EPS(angle->energy, energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_energy stats, newton off:" << stats << std::endl; } if (!verbose) ::testing::internal::CaptureStdout(); restart_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - ASSERT_EQ(nlocal+1,f_ref.size()); - for (int i=0; i < nlocal; ++i) { + ASSERT_EQ(nlocal + 1, f_ref.size()); + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "restart_forces stats:" << stats << std::endl; + if (print_stats) std::cerr << "restart_forces stats:" << stats << std::endl; angle = lmp->force->angle; stress = angle->virial; @@ -541,29 +525,26 @@ TEST(AngleStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, epsilon); - if (print_stats) - std::cerr << "restart_stress stats:" << stats << std::endl; + if (print_stats) std::cerr << "restart_stress stats:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(angle->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "restart_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "restart_energy stats:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); data_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - ASSERT_EQ(nlocal+1,f_ref.size()); - for (int i=0; i < nlocal; ++i) { + ASSERT_EQ(nlocal + 1, f_ref.size()); + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "data_forces stats:" << stats << std::endl; + if (print_stats) std::cerr << "data_forces stats:" << stats << std::endl; angle = lmp->force->angle; stress = angle->virial; @@ -574,37 +555,35 @@ TEST(AngleStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, epsilon); - if (print_stats) - std::cerr << "data_stress stats:" << stats << std::endl; + if (print_stats) std::cerr << "data_stress stats:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(angle->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "data_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "data_energy stats:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); }; -TEST(AngleStyle, omp) { +TEST(AngleStyle, omp) +{ if (!LAMMPS::is_installed_pkg("USER-OMP")) GTEST_SKIP(); - const char *args[] = {"AngleStyle", "-log", "none", "-echo", "screen", - "-nocite", "-pk", "omp", "4", "-sf", "omp"}; + const char *args[] = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite", + "-pk", "omp", "4", "-sf", "omp"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config,true); + LAMMPS *lmp = init_lammps(argc, argv, test_config, true); std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; if (!lmp) { std::cerr << "One or more prerequisite styles with /omp suffix\n" - "are not available in this LAMMPS configuration:\n"; - for (auto& prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + "are not available in this LAMMPS configuration:\n"; + for (auto &prerequisite : test_config.prerequisites) { + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -614,40 +593,37 @@ TEST(AngleStyle, omp) { // abort if running in parallel and not all atoms are local const int nlocal = lmp->atom->nlocal; - ASSERT_EQ(lmp->atom->natoms,nlocal); + ASSERT_EQ(lmp->atom->natoms, nlocal); // relax error a bit for USER-OMP package - double epsilon = 5.0*test_config.epsilon; - double **f=lmp->atom->f; - tagint *tag=lmp->atom->tag; + double epsilon = 5.0 * test_config.epsilon; + double **f = lmp->atom->f; + tagint *tag = lmp->atom->tag; const std::vector &f_ref = test_config.init_forces; ErrorStats stats; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton on: " << stats << std::endl; Angle *angle = lmp->force->angle; double *stress = angle->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton on: " << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "init_stress stats, newton on: " << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(angle->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -656,26 +632,24 @@ TEST(AngleStyle, omp) { f = lmp->atom->f; stress = angle->virial; const std::vector &f_run = test_config.run_forces; - ASSERT_EQ(nlocal+1,f_run.size()); + ASSERT_EQ(nlocal + 1, f_run.size()); stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton on: " << stats << std::endl; stress = angle->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton on: " << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "run_stress stats, newton on: " << stats << std::endl; stats.reset(); int id = lmp->modify->find_compute("sum"); @@ -683,46 +657,42 @@ TEST(AngleStyle, omp) { EXPECT_FP_LE_WITH_EPS(angle->energy, test_config.run_energy, epsilon); // TODO: this is currently broken for USER-OMP with angle style hybrid // needs to be fixed in the main code somewhere. Not sure where, though. - if (test_config.angle_style.substr(0,6) != "hybrid") + if (test_config.angle_style.substr(0, 6) != "hybrid") EXPECT_FP_LE_WITH_EPS(angle->energy, energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); - lmp = init_lammps(argc,argv,test_config,false); + cleanup_lammps(lmp, test_config); + lmp = init_lammps(argc, argv, test_config, false); if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on if (lmp->force->newton_bond == 0) { - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton off:" << stats << std::endl; angle = lmp->force->angle; stress = angle->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "init_stress stats, newton off:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(angle->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton off:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -730,24 +700,22 @@ TEST(AngleStyle, omp) { f = lmp->atom->f; stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton off:" << stats << std::endl; stress = angle->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "run_stress stats, newton off:" << stats << std::endl; stats.reset(); id = lmp->modify->find_compute("sum"); @@ -755,33 +723,32 @@ TEST(AngleStyle, omp) { EXPECT_FP_LE_WITH_EPS(angle->energy, test_config.run_energy, epsilon); // TODO: this is currently broken for USER-OMP with angle style hybrid // needs to be fixed in the main code somewhere. Not sure where, though. - if (test_config.angle_style.substr(0,6) != "hybrid") + if (test_config.angle_style.substr(0, 6) != "hybrid") EXPECT_FP_LE_WITH_EPS(angle->energy, energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_energy stats, newton off:" << stats << std::endl; } if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); }; -TEST(AngleStyle, single) { - const char *args[] = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite" }; +TEST(AngleStyle, single) +{ + const char *args[] = {"AngleStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); // create a LAMMPS instance with standard settings to detect the number of atom types if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config); + LAMMPS *lmp = init_lammps(argc, argv, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; - for (auto& prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + "in this LAMMPS configuration:\n"; + for (auto &prerequisite : test_config.prerequisites) { + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -792,13 +759,13 @@ TEST(AngleStyle, single) { if (molecular != 1) { std::cerr << "Only simple molecular atom styles are supported\n"; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); GTEST_SKIP(); } // utility lambda to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; @@ -810,7 +777,7 @@ TEST(AngleStyle, single) { command("variable input_dir index " + INPUT_FOLDER); - for (auto& pre_command : test_config.pre_commands) { + for (auto &pre_command : test_config.pre_commands) { command(pre_command); } @@ -827,7 +794,7 @@ TEST(AngleStyle, single) { char buf[10]; std::string cmd("create_box 1 box"); cmd += " angle/types "; - snprintf(buf,10,"%d",nangletypes); + snprintf(buf, 10, "%d", nangletypes); cmd += buf; cmd += " extra/angle/per/atom 2"; cmd += " extra/special/per/atom 2"; @@ -839,7 +806,7 @@ TEST(AngleStyle, single) { command("angle_style " + test_config.angle_style); Angle *angle = lmp->force->angle; - for (auto& angle_coeff : test_config.angle_coeff) { + for (auto &angle_coeff : test_config.angle_coeff) { command("angle_coeff " + angle_coeff); } @@ -850,7 +817,7 @@ TEST(AngleStyle, single) { command("create_atoms 1 single 5.0 0.75 0.4 units box"); command("create_bonds single/angle 1 1 2 3"); - for (auto& post_command : test_config.post_commands) { + for (auto &post_command : test_config.post_commands) { command(post_command); } @@ -904,14 +871,13 @@ TEST(AngleStyle, single) { EXPECT_FP_LE_WITH_EPS(eangle[1], esingle[1], epsilon); EXPECT_FP_LE_WITH_EPS(eangle[2], esingle[2], epsilon); EXPECT_FP_LE_WITH_EPS(eangle[3], esingle[3], epsilon); - if (print_stats) - std::cerr << "single_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "single_energy stats:" << stats << std::endl; int i = 0; for (auto &dist : test_config.equilibrium) - EXPECT_NEAR(dist,angle->equilibrium_angle(++i),0.00001); + EXPECT_NEAR(dist, angle->equilibrium_angle(++i), 0.00001); if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); } diff --git a/unittest/force-styles/bond_style.cpp b/unittest/force-styles/bond_style.cpp index b87804ef4a..2ffd756fb7 100644 --- a/unittest/force-styles/bond_style.cpp +++ b/unittest/force-styles/bond_style.cpp @@ -13,32 +13,32 @@ // unit tests for bond styles intended for molecular systems -#include "yaml_reader.h" -#include "yaml_writer.h" #include "error_stats.h" #include "test_config.h" #include "test_config_reader.h" #include "test_main.h" +#include "yaml_reader.h" +#include "yaml_writer.h" -#include "gtest/gtest.h" #include "gmock/gmock.h" +#include "gtest/gtest.h" -#include "lammps.h" #include "atom.h" -#include "modify.h" +#include "bond.h" #include "compute.h" #include "force.h" -#include "bond.h" #include "info.h" #include "input.h" +#include "lammps.h" +#include "modify.h" #include "universe.h" -#include -#include -#include -#include #include +#include +#include +#include #include +#include #include #include @@ -46,12 +46,13 @@ #include #include -using ::testing::StartsWith; using ::testing::HasSubstr; +using ::testing::StartsWith; using namespace LAMMPS_NS; -static void delete_file(const std::string & filename) { +static void delete_file(const std::string &filename) +{ remove(filename.c_str()); }; @@ -63,9 +64,7 @@ void cleanup_lammps(LAMMPS *lmp, const TestConfig &cfg) delete lmp; } -LAMMPS *init_lammps(int argc, char **argv, - const TestConfig &cfg, - const bool newton=true) +LAMMPS *init_lammps(int argc, char **argv, const TestConfig &cfg, const bool newton = true) { LAMMPS *lmp; @@ -74,7 +73,7 @@ LAMMPS *init_lammps(int argc, char **argv, // check if prerequisite styles are available Info *info = new Info(lmp); int nfail = 0; - for (auto& prerequisite : cfg.prerequisites) { + for (auto &prerequisite : cfg.prerequisites) { std::string style = prerequisite.second; // this is a test for bond styles, so if the suffixed @@ -86,19 +85,19 @@ LAMMPS *init_lammps(int argc, char **argv, } } - if (!info->has_style(prerequisite.first,style)) ++nfail; + if (!info->has_style(prerequisite.first, style)) ++nfail; } if (nfail > 0) { delete info; - cleanup_lammps(lmp,cfg); + cleanup_lammps(lmp, cfg); return nullptr; } // utility lambdas to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; - auto parse_input_script = [&](const std::string & filename) { + auto parse_input_script = [&](const std::string &filename) { lmp->input->file(filename.c_str()); }; @@ -110,7 +109,7 @@ LAMMPS *init_lammps(int argc, char **argv, command("variable input_dir index " + INPUT_FOLDER); - for (auto& pre_command : cfg.pre_commands) { + for (auto &pre_command : cfg.pre_commands) { command(pre_command); } @@ -119,11 +118,11 @@ LAMMPS *init_lammps(int argc, char **argv, command("bond_style " + cfg.bond_style); - for (auto& bond_coeff : cfg.bond_coeff) { + for (auto &bond_coeff : cfg.bond_coeff) { command("bond_coeff " + bond_coeff); } - for (auto& post_command : cfg.post_commands) { + for (auto &post_command : cfg.post_commands) { command(post_command); } @@ -138,7 +137,7 @@ LAMMPS *init_lammps(int argc, char **argv, void run_lammps(LAMMPS *lmp) { // utility lambda to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; @@ -153,7 +152,7 @@ void run_lammps(LAMMPS *lmp) void restart_lammps(LAMMPS *lmp, const TestConfig &cfg) { // utility lambda to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; @@ -164,14 +163,13 @@ void restart_lammps(LAMMPS *lmp, const TestConfig &cfg) command("bond_style " + cfg.bond_style); } - if ((cfg.bond_style.substr(0,6) == "hybrid") - || !lmp->force->bond->writedata) { - for (auto& bond_coeff : cfg.bond_coeff) { + if ((cfg.bond_style.substr(0, 6) == "hybrid") || !lmp->force->bond->writedata) { + for (auto &bond_coeff : cfg.bond_coeff) { command("bond_coeff " + bond_coeff); } } - for (auto& post_command : cfg.post_commands) { + for (auto &post_command : cfg.post_commands) { command(post_command); } @@ -181,10 +179,10 @@ void restart_lammps(LAMMPS *lmp, const TestConfig &cfg) void data_lammps(LAMMPS *lmp, const TestConfig &cfg) { // utility lambdas to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; - auto parse_input_script = [&](const std::string & filename) { + auto parse_input_script = [&](const std::string &filename) { lmp->input->file(filename.c_str()); }; @@ -194,7 +192,7 @@ void data_lammps(LAMMPS *lmp, const TestConfig &cfg) command("variable newton_bond delete"); command("variable newton_bond index on"); - for (auto& pre_command : cfg.pre_commands) { + for (auto &pre_command : cfg.pre_commands) { command(pre_command); } @@ -204,10 +202,10 @@ void data_lammps(LAMMPS *lmp, const TestConfig &cfg) std::string input_file = INPUT_FOLDER + PATH_SEP + cfg.input_file; parse_input_script(input_file); - for (auto& bond_coeff : cfg.bond_coeff) { + for (auto &bond_coeff : cfg.bond_coeff) { command("bond_coeff " + bond_coeff); } - for (auto& post_command : cfg.post_commands) { + for (auto &post_command : cfg.post_commands) { command(post_command); } command("run 0 post no"); @@ -218,16 +216,15 @@ void data_lammps(LAMMPS *lmp, const TestConfig &cfg) void generate_yaml_file(const char *outfile, const TestConfig &config) { // initialize system geometry - const char *args[] = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite" }; + const char *args[] = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); - LAMMPS *lmp = init_lammps(argc,argv,config); + int argc = sizeof(args) / sizeof(char *); + LAMMPS *lmp = init_lammps(argc, argv, config); if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; - for (auto& prerequisite : config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + "in this LAMMPS configuration:\n"; + for (auto &prerequisite : config.prerequisites) { + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } return; } @@ -245,7 +242,7 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // date_generated std::time_t now = time(NULL); block = ctime(&now); - block = block.substr(0,block.find("\n")-1); + block = block.substr(0, block.find("\n") - 1); writer.emit("date_generated", block); // epsilon @@ -253,21 +250,21 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // prerequisites block.clear(); - for (auto& prerequisite : config.prerequisites) { + for (auto &prerequisite : config.prerequisites) { block += prerequisite.first + " " + prerequisite.second + "\n"; } writer.emit_block("prerequisites", block); // pre_commands block.clear(); - for (auto& command : config.pre_commands) { + for (auto &command : config.pre_commands) { block += command + "\n"; } writer.emit_block("pre_commands", block); // post_commands block.clear(); - for (auto& command : config.post_commands) { + for (auto &command : config.post_commands) { block += command + "\n"; } writer.emit_block("post_commands", block); @@ -280,7 +277,7 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // bond_coeff block.clear(); - for (auto& bond_coeff : config.bond_coeff) { + for (auto &bond_coeff : config.bond_coeff) { block += bond_coeff + "\n"; } writer.emit_block("bond_coeff", block); @@ -288,15 +285,15 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // equilibrium distance std::stringstream eqstr; eqstr << lmp->atom->nbondtypes; - for (int i=0; i < lmp->atom->nbondtypes; ++i) { - eqstr << " " << lmp->force->bond->equilibrium_distance(i+1); + for (int i = 0; i < lmp->atom->nbondtypes; ++i) { + eqstr << " " << lmp->force->bond->equilibrium_distance(i + 1); } writer.emit("equilibrium", eqstr.str()); // extract block.clear(); std::stringstream outstr; - for (auto& data : config.extract) { + for (auto &data : config.extract) { outstr << data.first << " " << data.second << std::endl; } writer.emit_block("extract", outstr.str()); @@ -309,17 +306,17 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // init_stress double *stress = lmp->force->bond->virial; - snprintf(buf,bufsize,"% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", - stress[0],stress[1],stress[2],stress[3],stress[4],stress[5]); + snprintf(buf, bufsize, "% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", stress[0], + stress[1], stress[2], stress[3], stress[4], stress[5]); writer.emit_block("init_stress", buf); // init_forces block.clear(); double **f = lmp->atom->f; tagint *tag = lmp->atom->tag; - for (int i=0; i < natoms; ++i) { - snprintf(buf,bufsize,"% 3d % 23.16e % 23.16e % 23.16e\n", - (int)tag[i], f[i][0], f[i][1], f[i][2]); + for (int i = 0; i < natoms; ++i) { + snprintf(buf, bufsize, "% 3d % 23.16e % 23.16e % 23.16e\n", (int)tag[i], f[i][0], f[i][1], + f[i][2]); block += buf; } writer.emit_block("init_forces", block); @@ -332,40 +329,40 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // run_stress stress = lmp->force->bond->virial; - snprintf(buf,bufsize,"% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", - stress[0],stress[1],stress[2],stress[3],stress[4],stress[5]); + snprintf(buf, bufsize, "% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", stress[0], + stress[1], stress[2], stress[3], stress[4], stress[5]); writer.emit_block("run_stress", buf); block.clear(); f = lmp->atom->f; tag = lmp->atom->tag; - for (int i=0; i < natoms; ++i) { - snprintf(buf,bufsize,"% 3d % 23.16e % 23.16e % 23.16e\n", - (int)tag[i], f[i][0], f[i][1], f[i][2]); + for (int i = 0; i < natoms; ++i) { + snprintf(buf, bufsize, "% 3d % 23.16e % 23.16e % 23.16e\n", (int)tag[i], f[i][0], f[i][1], + f[i][2]); block += buf; } writer.emit_block("run_forces", block); - cleanup_lammps(lmp,config); + cleanup_lammps(lmp, config); return; } -TEST(BondStyle, plain) { - const char *args[] = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite" }; +TEST(BondStyle, plain) +{ + const char *args[] = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config,true); + LAMMPS *lmp = init_lammps(argc, argv, test_config, true); std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; - for (auto& prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + "in this LAMMPS configuration:\n"; + for (auto &prerequisite : test_config.prerequisites) { + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -375,22 +372,21 @@ TEST(BondStyle, plain) { // abort if running in parallel and not all atoms are local const int nlocal = lmp->atom->nlocal; - ASSERT_EQ(lmp->atom->natoms,nlocal); + ASSERT_EQ(lmp->atom->natoms, nlocal); double epsilon = test_config.epsilon; - double **f=lmp->atom->f; - tagint *tag=lmp->atom->tag; + double **f = lmp->atom->f; + tagint *tag = lmp->atom->tag; ErrorStats stats; stats.reset(); const std::vector &f_ref = test_config.init_forces; - ASSERT_EQ(nlocal+1,f_ref.size()); - for (int i=0; i < nlocal; ++i) { + ASSERT_EQ(nlocal + 1, f_ref.size()); + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton on: " << stats << std::endl; Bond *bond = lmp->force->bond; double *stress = bond->virial; @@ -401,13 +397,11 @@ TEST(BondStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_stress stats, newton on: " << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(bond->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -416,15 +410,14 @@ TEST(BondStyle, plain) { f = lmp->atom->f; stress = bond->virial; const std::vector &f_run = test_config.run_forces; - ASSERT_EQ(nlocal+1,f_run.size()); + ASSERT_EQ(nlocal + 1, f_run.size()); stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton on: " << stats << std::endl; stress = bond->virial; stats.reset(); @@ -434,52 +427,47 @@ TEST(BondStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_stress stats, newton on: " << stats << std::endl; stats.reset(); int id = lmp->modify->find_compute("sum"); double energy = lmp->modify->compute[id]->compute_scalar(); EXPECT_FP_LE_WITH_EPS(bond->energy, test_config.run_energy, epsilon); EXPECT_FP_LE_WITH_EPS(bond->energy, energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); - lmp = init_lammps(argc,argv,test_config,false); + cleanup_lammps(lmp, test_config); + lmp = init_lammps(argc, argv, test_config, false); if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on if (lmp->force->newton_bond == 0) { - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton off:" << stats << std::endl; bond = lmp->force->bond; stress = bond->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 2*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 2*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 2*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 2*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 2*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 2*epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 2 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 2 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 2 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 2 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 2 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 2 * epsilon); + if (print_stats) std::cerr << "init_stress stats, newton off:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(bond->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton off:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -488,13 +476,12 @@ TEST(BondStyle, plain) { f = lmp->atom->f; stress = bond->virial; stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton off:" << stats << std::endl; stress = bond->virial; stats.reset(); @@ -504,33 +491,30 @@ TEST(BondStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_stress stats, newton off:" << stats << std::endl; stats.reset(); id = lmp->modify->find_compute("sum"); energy = lmp->modify->compute[id]->compute_scalar(); EXPECT_FP_LE_WITH_EPS(bond->energy, test_config.run_energy, epsilon); EXPECT_FP_LE_WITH_EPS(bond->energy, energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_energy stats, newton off:" << stats << std::endl; } if (!verbose) ::testing::internal::CaptureStdout(); restart_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - ASSERT_EQ(nlocal+1,f_ref.size()); - for (int i=0; i < nlocal; ++i) { + ASSERT_EQ(nlocal + 1, f_ref.size()); + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "restart_forces stats:" << stats << std::endl; + if (print_stats) std::cerr << "restart_forces stats:" << stats << std::endl; bond = lmp->force->bond; stress = bond->virial; @@ -541,29 +525,26 @@ TEST(BondStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, epsilon); - if (print_stats) - std::cerr << "restart_stress stats:" << stats << std::endl; + if (print_stats) std::cerr << "restart_stress stats:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(bond->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "restart_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "restart_energy stats:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); data_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - ASSERT_EQ(nlocal+1,f_ref.size()); - for (int i=0; i < nlocal; ++i) { + ASSERT_EQ(nlocal + 1, f_ref.size()); + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "data_forces stats:" << stats << std::endl; + if (print_stats) std::cerr << "data_forces stats:" << stats << std::endl; bond = lmp->force->bond; stress = bond->virial; @@ -574,37 +555,35 @@ TEST(BondStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, epsilon); - if (print_stats) - std::cerr << "data_stress stats:" << stats << std::endl; + if (print_stats) std::cerr << "data_stress stats:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(bond->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "data_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "data_energy stats:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); }; -TEST(BondStyle, omp) { +TEST(BondStyle, omp) +{ if (!LAMMPS::is_installed_pkg("USER-OMP")) GTEST_SKIP(); - const char *args[] = {"BondStyle", "-log", "none", "-echo", "screen", - "-nocite", "-pk", "omp", "4", "-sf", "omp"}; + const char *args[] = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite", + "-pk", "omp", "4", "-sf", "omp"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config,true); + LAMMPS *lmp = init_lammps(argc, argv, test_config, true); std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; if (!lmp) { std::cerr << "One or more prerequisite styles with /omp suffix\n" - "are not available in this LAMMPS configuration:\n"; - for (auto& prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + "are not available in this LAMMPS configuration:\n"; + for (auto &prerequisite : test_config.prerequisites) { + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -614,39 +593,36 @@ TEST(BondStyle, omp) { // abort if running in parallel and not all atoms are local const int nlocal = lmp->atom->nlocal; - ASSERT_EQ(lmp->atom->natoms,nlocal); + ASSERT_EQ(lmp->atom->natoms, nlocal); // relax error a bit for USER-OMP package - double epsilon = 5.0*test_config.epsilon; - double **f=lmp->atom->f; - tagint *tag=lmp->atom->tag; + double epsilon = 5.0 * test_config.epsilon; + double **f = lmp->atom->f; + tagint *tag = lmp->atom->tag; const std::vector &f_ref = test_config.init_forces; ErrorStats stats; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton on: " << stats << std::endl; Bond *bond = lmp->force->bond; double *stress = bond->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton on: " << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "init_stress stats, newton on: " << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(bond->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -655,26 +631,24 @@ TEST(BondStyle, omp) { f = lmp->atom->f; stress = bond->virial; const std::vector &f_run = test_config.run_forces; - ASSERT_EQ(nlocal+1,f_run.size()); + ASSERT_EQ(nlocal + 1, f_run.size()); stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton on: " << stats << std::endl; stress = bond->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton on: " << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "run_stress stats, newton on: " << stats << std::endl; stats.reset(); int id = lmp->modify->find_compute("sum"); @@ -682,46 +656,42 @@ TEST(BondStyle, omp) { EXPECT_FP_LE_WITH_EPS(bond->energy, test_config.run_energy, epsilon); // TODO: this is currently broken for USER-OMP with bond style hybrid // needs to be fixed in the main code somewhere. Not sure where, though. - if (test_config.bond_style.substr(0,6) != "hybrid") + if (test_config.bond_style.substr(0, 6) != "hybrid") EXPECT_FP_LE_WITH_EPS(bond->energy, energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); - lmp = init_lammps(argc,argv,test_config,false); + cleanup_lammps(lmp, test_config); + lmp = init_lammps(argc, argv, test_config, false); if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton bond is forced to be on if (lmp->force->newton_bond == 0) { - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton off:" << stats << std::endl; bond = lmp->force->bond; stress = bond->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "init_stress stats, newton off:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(bond->energy, test_config.init_energy, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton off:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -729,24 +699,22 @@ TEST(BondStyle, omp) { f = lmp->atom->f; stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 10 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton off:" << stats << std::endl; stress = bond->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "run_stress stats, newton off:" << stats << std::endl; stats.reset(); id = lmp->modify->find_compute("sum"); @@ -754,33 +722,32 @@ TEST(BondStyle, omp) { EXPECT_FP_LE_WITH_EPS(bond->energy, test_config.run_energy, epsilon); // TODO: this is currently broken for USER-OMP with bond style hybrid // needs to be fixed in the main code somewhere. Not sure where, though. - if (test_config.bond_style.substr(0,6) != "hybrid") + if (test_config.bond_style.substr(0, 6) != "hybrid") EXPECT_FP_LE_WITH_EPS(bond->energy, energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_energy stats, newton off:" << stats << std::endl; } if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); }; -TEST(BondStyle, single) { - const char *args[] = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite" }; +TEST(BondStyle, single) +{ + const char *args[] = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); // create a LAMMPS instance with standard settings to detect the number of atom types if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config); + LAMMPS *lmp = init_lammps(argc, argv, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; - for (auto& prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + "in this LAMMPS configuration:\n"; + for (auto &prerequisite : test_config.prerequisites) { + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -791,13 +758,13 @@ TEST(BondStyle, single) { if (molecular != 1) { std::cerr << "Only simple molecular atom styles are supported\n"; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); GTEST_SKIP(); } // utility lambda to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; @@ -809,7 +776,7 @@ TEST(BondStyle, single) { command("variable input_dir index " + INPUT_FOLDER); - for (auto& pre_command : test_config.pre_commands) { + for (auto &pre_command : test_config.pre_commands) { command(pre_command); } @@ -826,7 +793,7 @@ TEST(BondStyle, single) { char buf[10]; std::string cmd("create_box 1 box"); cmd += " bond/types "; - snprintf(buf,10,"%d",nbondtypes); + snprintf(buf, 10, "%d", nbondtypes); cmd += buf; cmd += " extra/bond/per/atom 2"; cmd += " extra/special/per/atom 2"; @@ -838,7 +805,7 @@ TEST(BondStyle, single) { command("bond_style " + test_config.bond_style); Bond *bond = lmp->force->bond; - for (auto& bond_coeff : test_config.bond_coeff) { + for (auto &bond_coeff : test_config.bond_coeff) { command("bond_coeff " + bond_coeff); } @@ -851,7 +818,7 @@ TEST(BondStyle, single) { command("create_bonds single/bond 1 1 2"); command("create_bonds single/bond 2 3 4"); - for (auto& post_command : test_config.post_commands) { + for (auto &post_command : test_config.post_commands) { command(post_command); } @@ -863,36 +830,36 @@ TEST(BondStyle, single) { int idx3 = lmp->atom->map(3); int idx4 = lmp->atom->map(4); double epsilon = test_config.epsilon; - double **f=lmp->atom->f; - double **x=lmp->atom->x; + double **f = lmp->atom->f; + double **x = lmp->atom->x; double delx1 = x[idx2][0] - x[idx1][0]; double dely1 = x[idx2][1] - x[idx1][1]; double delz1 = x[idx2][2] - x[idx1][2]; - double rsq1 = delx1*delx1+dely1*dely1+delz1*delz1; + double rsq1 = delx1 * delx1 + dely1 * dely1 + delz1 * delz1; double delx2 = x[idx4][0] - x[idx3][0]; double dely2 = x[idx4][1] - x[idx3][1]; double delz2 = x[idx4][2] - x[idx3][2]; - double rsq2 = delx2*delx2+dely2*dely2+delz2*delz2; + double rsq2 = delx2 * delx2 + dely2 * dely2 + delz2 * delz2; double fsingle = 0.0; double ebond[4], esngl[4]; ErrorStats stats; ebond[0] = bond->energy; esngl[0] = bond->single(1, rsq1, idx1, idx2, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx1][0],-fsingle*delx1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][1],-fsingle*dely1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][2],-fsingle*delz1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle*delx1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle*dely1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle*delz1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][0], -fsingle * delx1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][1], -fsingle * dely1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][2], -fsingle * delz1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle * delx1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle * dely1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle * delz1, epsilon); esngl[0] += bond->single(2, rsq2, idx3, idx4, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx3][0],-fsingle*delx2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx3][1],-fsingle*dely2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx3][2],-fsingle*delz2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][0], fsingle*delx2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][1], fsingle*dely2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][2], fsingle*delz2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][0], -fsingle * delx2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][1], -fsingle * dely2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][2], -fsingle * delz2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][0], fsingle * delx2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][1], fsingle * dely2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][2], fsingle * delz2, epsilon); if (!verbose) ::testing::internal::CaptureStdout(); command("displace_atoms all random 0.5 0.5 0.5 23456"); @@ -908,29 +875,29 @@ TEST(BondStyle, single) { delx1 = x[idx2][0] - x[idx1][0]; dely1 = x[idx2][1] - x[idx1][1]; delz1 = x[idx2][2] - x[idx1][2]; - rsq1 = delx1*delx1+dely1*dely1+delz1*delz1; + rsq1 = delx1 * delx1 + dely1 * dely1 + delz1 * delz1; delx2 = x[idx4][0] - x[idx3][0]; dely2 = x[idx4][1] - x[idx3][1]; delz2 = x[idx4][2] - x[idx3][2]; - rsq2 = delx2*delx2+dely2*dely2+delz2*delz2; + rsq2 = delx2 * delx2 + dely2 * dely2 + delz2 * delz2; fsingle = 0.0; ebond[1] = bond->energy; esngl[1] = bond->single(1, rsq1, idx1, idx2, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx1][0],-fsingle*delx1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][1],-fsingle*dely1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][2],-fsingle*delz1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle*delx1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle*dely1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle*delz1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][0], -fsingle * delx1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][1], -fsingle * dely1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][2], -fsingle * delz1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle * delx1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle * dely1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle * delz1, epsilon); esngl[1] += bond->single(2, rsq2, idx3, idx4, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx3][0],-fsingle*delx2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx3][1],-fsingle*dely2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx3][2],-fsingle*delz2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][0], fsingle*delx2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][1], fsingle*dely2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][2], fsingle*delz2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][0], -fsingle * delx2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][1], -fsingle * dely2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][2], -fsingle * delz2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][0], fsingle * delx2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][1], fsingle * dely2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][2], fsingle * delz2, epsilon); if (!verbose) ::testing::internal::CaptureStdout(); command("displace_atoms all random 0.5 0.5 0.5 456963"); @@ -946,29 +913,29 @@ TEST(BondStyle, single) { delx1 = x[idx2][0] - x[idx1][0]; dely1 = x[idx2][1] - x[idx1][1]; delz1 = x[idx2][2] - x[idx1][2]; - rsq1 = delx1*delx1+dely1*dely1+delz1*delz1; + rsq1 = delx1 * delx1 + dely1 * dely1 + delz1 * delz1; delx2 = x[idx4][0] - x[idx3][0]; dely2 = x[idx4][1] - x[idx3][1]; delz2 = x[idx4][2] - x[idx3][2]; - rsq2 = delx2*delx2+dely2*dely2+delz2*delz2; + rsq2 = delx2 * delx2 + dely2 * dely2 + delz2 * delz2; fsingle = 0.0; ebond[2] = bond->energy; esngl[2] = bond->single(1, rsq1, idx1, idx2, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx1][0],-fsingle*delx1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][1],-fsingle*dely1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][2],-fsingle*delz1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle*delx1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle*dely1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle*delz1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][0], -fsingle * delx1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][1], -fsingle * dely1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][2], -fsingle * delz1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle * delx1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle * dely1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle * delz1, epsilon); esngl[2] += bond->single(2, rsq2, idx3, idx4, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx3][0],-fsingle*delx2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx3][1],-fsingle*dely2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx3][2],-fsingle*delz2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][0], fsingle*delx2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][1], fsingle*dely2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][2], fsingle*delz2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][0], -fsingle * delx2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][1], -fsingle * dely2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][2], -fsingle * delz2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][0], fsingle * delx2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][1], fsingle * dely2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][2], fsingle * delz2, epsilon); if (!verbose) ::testing::internal::CaptureStdout(); command("displace_atoms all random 0.5 0.5 0.5 9726532"); @@ -984,64 +951,62 @@ TEST(BondStyle, single) { delx1 = x[idx2][0] - x[idx1][0]; dely1 = x[idx2][1] - x[idx1][1]; delz1 = x[idx2][2] - x[idx1][2]; - rsq1 = delx1*delx1+dely1*dely1+delz1*delz1; + rsq1 = delx1 * delx1 + dely1 * dely1 + delz1 * delz1; delx2 = x[idx4][0] - x[idx3][0]; dely2 = x[idx4][1] - x[idx3][1]; delz2 = x[idx4][2] - x[idx3][2]; - rsq2 = delx2*delx2+dely2*dely2+delz2*delz2; + rsq2 = delx2 * delx2 + dely2 * dely2 + delz2 * delz2; fsingle = 0.0; ebond[3] = bond->energy; esngl[3] = bond->single(1, rsq1, idx1, idx2, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx1][0],-fsingle*delx1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][1],-fsingle*dely1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][2],-fsingle*delz1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle*delx1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle*dely1, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle*delz1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][0], -fsingle * delx1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][1], -fsingle * dely1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][2], -fsingle * delz1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle * delx1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle * dely1, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle * delz1, epsilon); esngl[3] += bond->single(2, rsq2, idx3, idx4, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx3][0],-fsingle*delx2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx3][1],-fsingle*dely2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx3][2],-fsingle*delz2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][0], fsingle*delx2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][1], fsingle*dely2, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx4][2], fsingle*delz2, epsilon); - if (print_stats) - std::cerr << "single_force stats:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(f[idx3][0], -fsingle * delx2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][1], -fsingle * dely2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx3][2], -fsingle * delz2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][0], fsingle * delx2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][1], fsingle * dely2, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx4][2], fsingle * delz2, epsilon); + if (print_stats) std::cerr << "single_force stats:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(ebond[0], esngl[0], epsilon); EXPECT_FP_LE_WITH_EPS(ebond[1], esngl[1], epsilon); EXPECT_FP_LE_WITH_EPS(ebond[2], esngl[2], epsilon); EXPECT_FP_LE_WITH_EPS(ebond[3], esngl[3], epsilon); - if (print_stats) - std::cerr << "single_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "single_energy stats:" << stats << std::endl; int i = 0; for (auto &dist : test_config.equilibrium) - EXPECT_NEAR(dist,bond->equilibrium_distance(++i),0.00001); + EXPECT_NEAR(dist, bond->equilibrium_distance(++i), 0.00001); if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); } -TEST(BondStyle, extract) { - const char *args[] = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite" }; +TEST(BondStyle, extract) +{ + const char *args[] = {"BondStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config,true); + LAMMPS *lmp = init_lammps(argc, argv, test_config, true); if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; + "in this LAMMPS configuration:\n"; for (auto prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -1049,17 +1014,17 @@ TEST(BondStyle, extract) { void *ptr = nullptr; int dim = 0; for (auto extract : test_config.extract) { - ptr = bond->extract(extract.first.c_str(),dim); + ptr = bond->extract(extract.first.c_str(), dim); EXPECT_NE(ptr, nullptr); EXPECT_EQ(dim, extract.second); } - ptr = bond->extract("does_not_exist",dim); + ptr = bond->extract("does_not_exist", dim); EXPECT_EQ(ptr, nullptr); - for (int i=1; i <= lmp->atom->nbondtypes; ++i) + for (int i = 1; i <= lmp->atom->nbondtypes; ++i) EXPECT_GE(bond->equilibrium_distance(i), 0.0); if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); } diff --git a/unittest/force-styles/error_stats.cpp b/unittest/force-styles/error_stats.cpp index 9b4f538099..8ab8c5a627 100644 --- a/unittest/force-styles/error_stats.cpp +++ b/unittest/force-styles/error_stats.cpp @@ -12,32 +12,36 @@ ------------------------------------------------------------------------- */ #include "error_stats.h" +#include #include #include -#include -void ErrorStats::reset() { +void ErrorStats::reset() +{ num = 0; maxidx = -1; - sum = sumsq = maxerr =0.0; + sum = sumsq = maxerr = 0.0; } -void ErrorStats::add(const double &val) { +void ErrorStats::add(const double &val) +{ ++num; if (val > maxerr) { maxidx = num; maxerr = val; } sum += val; - sumsq += val*val; + sumsq += val * val; } -double ErrorStats::avg() const { - return (num > 0) ? sum/num : 0.0; +double ErrorStats::avg() const +{ + return (num > 0) ? sum / num : 0.0; } -double ErrorStats::dev() const { - return (num > 0) ? sqrt(sumsq/num - sum/num*sum/num) : 0.0; +double ErrorStats::dev() const +{ + return (num > 0) ? sqrt(sumsq / num - sum / num * sum / num) : 0.0; } std::ostream &operator<<(std::ostream &out, const ErrorStats &stats) @@ -46,9 +50,7 @@ std::ostream &operator<<(std::ostream &out, const ErrorStats &stats) const std::streamsize width = out.width(10); const std::streamsize prec = out.precision(3); - out << std::scientific - << "Average: " << stats.avg() - << " StdDev: " << stats.dev() + out << std::scientific << "Average: " << stats.avg() << " StdDev: " << stats.dev() << " MaxErr: " << stats.max(); out.precision(prec); @@ -57,4 +59,3 @@ std::ostream &operator<<(std::ostream &out, const ErrorStats &stats) return out << " @ item: " << stats.idx(); } - diff --git a/unittest/force-styles/error_stats.h b/unittest/force-styles/error_stats.h index 1304c07130..664a987907 100644 --- a/unittest/force-styles/error_stats.h +++ b/unittest/force-styles/error_stats.h @@ -20,9 +20,7 @@ class ErrorStats { public: friend std::ostream &operator<<(std::ostream &out, const ErrorStats &stats); - ErrorStats() { - reset(); - } + ErrorStats() { reset(); } virtual ~ErrorStats() {} void reset(); @@ -33,8 +31,8 @@ public: double idx() const { return maxidx; } private: - double sum,sumsq,maxerr; - int num,maxidx; + double sum, sumsq, maxerr; + int num, maxidx; }; extern std::ostream &operator<<(std::ostream &out, const ErrorStats &stats); diff --git a/unittest/force-styles/pair_style.cpp b/unittest/force-styles/pair_style.cpp index 0ef67de959..62e1181dab 100644 --- a/unittest/force-styles/pair_style.cpp +++ b/unittest/force-styles/pair_style.cpp @@ -13,32 +13,32 @@ // unit tests for pair styles intended for molecular systems -#include "yaml_reader.h" -#include "yaml_writer.h" #include "error_stats.h" #include "test_config.h" #include "test_config_reader.h" #include "test_main.h" +#include "yaml_reader.h" +#include "yaml_writer.h" -#include "gtest/gtest.h" #include "gmock/gmock.h" +#include "gtest/gtest.h" -#include "lammps.h" #include "atom.h" -#include "modify.h" #include "compute.h" #include "force.h" -#include "pair.h" #include "info.h" #include "input.h" +#include "lammps.h" +#include "modify.h" +#include "pair.h" #include "universe.h" -#include -#include -#include -#include #include +#include +#include +#include #include +#include #include #include @@ -46,12 +46,13 @@ #include #include -using ::testing::StartsWith; using ::testing::HasSubstr; +using ::testing::StartsWith; using namespace LAMMPS_NS; -static void delete_file(const std::string & filename) { +static void delete_file(const std::string &filename) +{ remove(filename.c_str()); }; @@ -63,9 +64,7 @@ void cleanup_lammps(LAMMPS *lmp, const TestConfig &cfg) delete lmp; } -LAMMPS *init_lammps(int argc, char **argv, - const TestConfig &cfg, - const bool newton=true) +LAMMPS *init_lammps(int argc, char **argv, const TestConfig &cfg, const bool newton = true) { LAMMPS *lmp; @@ -74,7 +73,7 @@ LAMMPS *init_lammps(int argc, char **argv, // check if prerequisite styles are available Info *info = new Info(lmp); int nfail = 0; - for (auto& prerequisite : cfg.prerequisites) { + for (auto &prerequisite : cfg.prerequisites) { std::string style = prerequisite.second; // this is a test for pair styles, so if the suffixed @@ -86,19 +85,19 @@ LAMMPS *init_lammps(int argc, char **argv, } } - if (!info->has_style(prerequisite.first,style)) ++nfail; + if (!info->has_style(prerequisite.first, style)) ++nfail; } if (nfail > 0) { delete info; - cleanup_lammps(lmp,cfg); + cleanup_lammps(lmp, cfg); return nullptr; } // utility lambdas to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; - auto parse_input_script = [&](const std::string & filename) { + auto parse_input_script = [&](const std::string &filename) { lmp->input->file(filename.c_str()); }; @@ -110,7 +109,7 @@ LAMMPS *init_lammps(int argc, char **argv, command("variable input_dir index " + INPUT_FOLDER); - for (auto& pre_command : cfg.pre_commands) { + for (auto &pre_command : cfg.pre_commands) { command(pre_command); } @@ -119,11 +118,11 @@ LAMMPS *init_lammps(int argc, char **argv, command("pair_style " + cfg.pair_style); - for (auto& pair_coeff : cfg.pair_coeff) { + for (auto &pair_coeff : cfg.pair_coeff) { command("pair_coeff " + pair_coeff); } - for (auto& post_command : cfg.post_commands) { + for (auto &post_command : cfg.post_commands) { command(post_command); } @@ -138,7 +137,7 @@ LAMMPS *init_lammps(int argc, char **argv, void run_lammps(LAMMPS *lmp) { // utility lambda to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; @@ -153,7 +152,7 @@ void run_lammps(LAMMPS *lmp) void restart_lammps(LAMMPS *lmp, const TestConfig &cfg) { // utility lambda to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; @@ -163,14 +162,13 @@ void restart_lammps(LAMMPS *lmp, const TestConfig &cfg) if (!lmp->force->pair) { command("pair_style " + cfg.pair_style); } - if (!lmp->force->pair->restartinfo - || !lmp->force->pair->writedata) { - for (auto& pair_coeff : cfg.pair_coeff) { + if (!lmp->force->pair->restartinfo || !lmp->force->pair->writedata) { + for (auto &pair_coeff : cfg.pair_coeff) { command("pair_coeff " + pair_coeff); } } - for (auto& post_command : cfg.post_commands) { + for (auto &post_command : cfg.post_commands) { command(post_command); } @@ -180,10 +178,10 @@ void restart_lammps(LAMMPS *lmp, const TestConfig &cfg) void data_lammps(LAMMPS *lmp, const TestConfig &cfg) { // utility lambdas to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; - auto parse_input_script = [&](const std::string & filename) { + auto parse_input_script = [&](const std::string &filename) { lmp->input->file(filename.c_str()); }; @@ -193,7 +191,7 @@ void data_lammps(LAMMPS *lmp, const TestConfig &cfg) command("variable newton_pair delete"); command("variable newton_pair index on"); - for (auto& pre_command : cfg.pre_commands) { + for (auto &pre_command : cfg.pre_commands) { command(pre_command); } @@ -203,10 +201,10 @@ void data_lammps(LAMMPS *lmp, const TestConfig &cfg) std::string input_file = INPUT_FOLDER + PATH_SEP + cfg.input_file; parse_input_script(input_file); - for (auto& pair_coeff : cfg.pair_coeff) { + for (auto &pair_coeff : cfg.pair_coeff) { command("pair_coeff " + pair_coeff); } - for (auto& post_command : cfg.post_commands) { + for (auto &post_command : cfg.post_commands) { command(post_command); } command("run 0 post no"); @@ -217,16 +215,15 @@ void data_lammps(LAMMPS *lmp, const TestConfig &cfg) void generate_yaml_file(const char *outfile, const TestConfig &config) { // initialize system geometry - const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite" }; + const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); - LAMMPS *lmp = init_lammps(argc,argv,config); + int argc = sizeof(args) / sizeof(char *); + LAMMPS *lmp = init_lammps(argc, argv, config); if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; + "in this LAMMPS configuration:\n"; for (auto prerequisite : config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } return; } @@ -244,7 +241,7 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // date_generated std::time_t now = time(NULL); block = ctime(&now); - block = block.substr(0,block.find("\n")-1); + block = block.substr(0, block.find("\n") - 1); writer.emit("date_generated", block); // epsilon @@ -252,14 +249,14 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // prerequisites block.clear(); - for (auto prerequisite : config.prerequisites) { + for (auto prerequisite : config.prerequisites) { block += prerequisite.first + " " + prerequisite.second + "\n"; } writer.emit_block("prerequisites", block); // pre_commands block.clear(); - for (auto command : config.pre_commands) { + for (auto command : config.pre_commands) { block += command + "\n"; } writer.emit_block("pre_commands", block); @@ -303,17 +300,17 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // init_stress double *stress = lmp->force->pair->virial; - snprintf(buf,bufsize,"% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", - stress[0],stress[1],stress[2],stress[3],stress[4],stress[5]); + snprintf(buf, bufsize, "% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", stress[0], + stress[1], stress[2], stress[3], stress[4], stress[5]); writer.emit_block("init_stress", buf); // init_forces block.clear(); double **f = lmp->atom->f; tagint *tag = lmp->atom->tag; - for (int i=0; i < natoms; ++i) { - snprintf(buf,bufsize,"% 3d % 23.16e % 23.16e % 23.16e\n", - (int)tag[i], f[i][0], f[i][1], f[i][2]); + for (int i = 0; i < natoms; ++i) { + snprintf(buf, bufsize, "% 3d % 23.16e % 23.16e % 23.16e\n", (int)tag[i], f[i][0], f[i][1], + f[i][2]); block += buf; } writer.emit_block("init_forces", block); @@ -329,40 +326,40 @@ void generate_yaml_file(const char *outfile, const TestConfig &config) // run_stress stress = lmp->force->pair->virial; - snprintf(buf,bufsize,"% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", - stress[0],stress[1],stress[2],stress[3],stress[4],stress[5]); + snprintf(buf, bufsize, "% 23.16e % 23.16e % 23.16e % 23.16e % 23.16e % 23.16e", stress[0], + stress[1], stress[2], stress[3], stress[4], stress[5]); writer.emit_block("run_stress", buf); block.clear(); f = lmp->atom->f; tag = lmp->atom->tag; - for (int i=0; i < natoms; ++i) { - snprintf(buf,bufsize,"% 3d % 23.16e % 23.16e % 23.16e\n", - (int)tag[i], f[i][0], f[i][1], f[i][2]); + for (int i = 0; i < natoms; ++i) { + snprintf(buf, bufsize, "% 3d % 23.16e % 23.16e % 23.16e\n", (int)tag[i], f[i][0], f[i][1], + f[i][2]); block += buf; } writer.emit_block("run_forces", block); - cleanup_lammps(lmp,config); + cleanup_lammps(lmp, config); return; } -TEST(PairStyle, plain) { - const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite" }; +TEST(PairStyle, plain) +{ + const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config,true); + LAMMPS *lmp = init_lammps(argc, argv, test_config, true); std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; + "in this LAMMPS configuration:\n"; for (auto prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -372,22 +369,21 @@ TEST(PairStyle, plain) { // abort if running in parallel and not all atoms are local const int nlocal = lmp->atom->nlocal; - ASSERT_EQ(lmp->atom->natoms,nlocal); + ASSERT_EQ(lmp->atom->natoms, nlocal); double epsilon = test_config.epsilon; - double **f=lmp->atom->f; - tagint *tag=lmp->atom->tag; + double **f = lmp->atom->f; + tagint *tag = lmp->atom->tag; ErrorStats stats; stats.reset(); const std::vector &f_ref = test_config.init_forces; - ASSERT_EQ(nlocal+1,f_ref.size()); - for (int i=0; i < nlocal; ++i) { + ASSERT_EQ(nlocal + 1, f_ref.size()); + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton on: " << stats << std::endl; Pair *pair = lmp->force->pair; double *stress = pair->virial; @@ -398,14 +394,12 @@ TEST(PairStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_stress stats, newton on: " << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.init_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.init_coul, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -414,15 +408,14 @@ TEST(PairStyle, plain) { f = lmp->atom->f; stress = pair->virial; const std::vector &f_run = test_config.run_forces; - ASSERT_EQ(nlocal+1,f_run.size()); + ASSERT_EQ(nlocal + 1, f_run.size()); stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton on: " << stats << std::endl; stress = pair->virial; stats.reset(); @@ -432,54 +425,49 @@ TEST(PairStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_stress stats, newton on: " << stats << std::endl; stats.reset(); int id = lmp->modify->find_compute("sum"); double energy = lmp->modify->compute[id]->compute_scalar(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.run_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.run_coul, epsilon); - EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl+pair->eng_coul),energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton on: " << stats << std::endl; + EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl + pair->eng_coul), energy, epsilon); + if (print_stats) std::cerr << "run_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); - lmp = init_lammps(argc,argv,test_config,false); + cleanup_lammps(lmp, test_config); + lmp = init_lammps(argc, argv, test_config, false); if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton pair is forced to be on if (lmp->force->newton_pair == 0) { - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton off:" << stats << std::endl; pair = lmp->force->pair; stress = pair->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 3*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 3*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 3*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 3*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 3*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 3*epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 3 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 3 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 3 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 3 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 3 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 3 * epsilon); + if (print_stats) std::cerr << "init_stress stats, newton off:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.init_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.init_coul, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton off:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -488,13 +476,12 @@ TEST(PairStyle, plain) { f = lmp->atom->f; stress = pair->virial; stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton off:" << stats << std::endl; stress = pair->virial; stats.reset(); @@ -504,34 +491,31 @@ TEST(PairStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_stress stats, newton off:" << stats << std::endl; stats.reset(); id = lmp->modify->find_compute("sum"); energy = lmp->modify->compute[id]->compute_scalar(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.run_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.run_coul, epsilon); - EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl+pair->eng_coul),energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl + pair->eng_coul), energy, epsilon); + if (print_stats) std::cerr << "run_energy stats, newton off:" << stats << std::endl; } if (!verbose) ::testing::internal::CaptureStdout(); restart_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - ASSERT_EQ(nlocal+1,f_ref.size()); - for (int i=0; i < nlocal; ++i) { + ASSERT_EQ(nlocal + 1, f_ref.size()); + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "restart_forces stats:" << stats << std::endl; + if (print_stats) std::cerr << "restart_forces stats:" << stats << std::endl; pair = lmp->force->pair; stress = pair->virial; @@ -542,30 +526,27 @@ TEST(PairStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, epsilon); - if (print_stats) - std::cerr << "restart_stress stats:" << stats << std::endl; + if (print_stats) std::cerr << "restart_stress stats:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.init_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.init_coul, epsilon); - if (print_stats) - std::cerr << "restart_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "restart_energy stats:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); data_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - ASSERT_EQ(nlocal+1,f_ref.size()); - for (int i=0; i < nlocal; ++i) { + ASSERT_EQ(nlocal + 1, f_ref.size()); + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "data_forces stats:" << stats << std::endl; + if (print_stats) std::cerr << "data_forces stats:" << stats << std::endl; pair = lmp->force->pair; stress = pair->virial; @@ -576,19 +557,17 @@ TEST(PairStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, epsilon); - if (print_stats) - std::cerr << "data_stress stats:" << stats << std::endl; + if (print_stats) std::cerr << "data_stress stats:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.init_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.init_coul, epsilon); - if (print_stats) - std::cerr << "data_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "data_energy stats:" << stats << std::endl; if (pair->respa_enable) { if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); - lmp = init_lammps(argc,argv,test_config,false); + cleanup_lammps(lmp, test_config); + lmp = init_lammps(argc, argv, test_config, false); lmp->input->one("run_style respa 2 1 inner 1 4.0 5.0 outer 2"); run_lammps(lmp); if (!verbose) ::testing::internal::GetCapturedStdout(); @@ -599,16 +578,15 @@ TEST(PairStyle, plain) { if (pair->ncoultablebits) epsilon *= 1.0e6; f = lmp->atom->f; - tag=lmp->atom->tag; + tag = lmp->atom->tag; pair = lmp->force->pair; stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, r-RESPA:" << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, r-RESPA:" << stats << std::endl; stress = pair->virial; stats.reset(); @@ -618,41 +596,39 @@ TEST(PairStyle, plain) { EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, epsilon); EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, epsilon); EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, epsilon); - if (print_stats) - std::cerr << "run_stress stats, r-RESPA:" << stats << std::endl; + if (print_stats) std::cerr << "run_stress stats, r-RESPA:" << stats << std::endl; stats.reset(); id = lmp->modify->find_compute("sum"); energy = lmp->modify->compute[id]->compute_scalar(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.run_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.run_coul, epsilon); - EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl+pair->eng_coul),energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, r-RESPA:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl + pair->eng_coul), energy, epsilon); + if (print_stats) std::cerr << "run_energy stats, r-RESPA:" << stats << std::endl; } if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); }; -TEST(PairStyle, omp) { +TEST(PairStyle, omp) +{ if (!LAMMPS::is_installed_pkg("USER-OMP")) GTEST_SKIP(); - const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", - "-nocite", "-pk", "omp", "4", "-sf", "omp"}; + const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite", + "-pk", "omp", "4", "-sf", "omp"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config,true); + LAMMPS *lmp = init_lammps(argc, argv, test_config, true); std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; if (!lmp) { std::cerr << "One or more prerequisite styles with /omp suffix\n" - "are not available in this LAMMPS configuration:\n"; + "are not available in this LAMMPS configuration:\n"; for (auto prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -662,40 +638,37 @@ TEST(PairStyle, omp) { // abort if running in parallel and not all atoms are local const int nlocal = lmp->atom->nlocal; - ASSERT_EQ(lmp->atom->natoms,nlocal); + ASSERT_EQ(lmp->atom->natoms, nlocal); // relax error a bit for USER-OMP package - double epsilon = 5.0*test_config.epsilon; - double **f=lmp->atom->f; - tagint *tag=lmp->atom->tag; + double epsilon = 5.0 * test_config.epsilon; + double **f = lmp->atom->f; + tagint *tag = lmp->atom->tag; const std::vector &f_ref = test_config.init_forces; ErrorStats stats; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton on: " << stats << std::endl; Pair *pair = lmp->force->pair; double *stress = pair->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton on: " << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "init_stress stats, newton on: " << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.init_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.init_coul, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -704,72 +677,66 @@ TEST(PairStyle, omp) { f = lmp->atom->f; stress = pair->virial; const std::vector &f_run = test_config.run_forces; - ASSERT_EQ(nlocal+1,f_run.size()); + ASSERT_EQ(nlocal + 1, f_run.size()); stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton on: " << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton on: " << stats << std::endl; stress = pair->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton on: " << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "run_stress stats, newton on: " << stats << std::endl; stats.reset(); int id = lmp->modify->find_compute("sum"); double energy = lmp->modify->compute[id]->compute_scalar(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.run_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.run_coul, epsilon); - EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl+pair->eng_coul),energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton on: " << stats << std::endl; + EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl + pair->eng_coul), energy, epsilon); + if (print_stats) std::cerr << "run_energy stats, newton on: " << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); - lmp = init_lammps(argc,argv,test_config,false); + cleanup_lammps(lmp, test_config); + lmp = init_lammps(argc, argv, test_config, false); if (!verbose) ::testing::internal::GetCapturedStdout(); // skip over these tests if newton pair is forced to be on if (lmp->force->newton_pair == 0) { - f=lmp->atom->f; - tag=lmp->atom->tag; + f = lmp->atom->f; + tag = lmp->atom->tag; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats, newton off:" << stats << std::endl; pair = lmp->force->pair; stress = pair->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "init_stress stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "init_stress stats, newton off:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.init_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.init_coul, epsilon); - if (print_stats) - std::cerr << "init_energy stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats, newton off:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -777,79 +744,75 @@ TEST(PairStyle, omp) { f = lmp->atom->f; stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats, newton off:" << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats, newton off:" << stats << std::endl; stress = pair->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "run_stress stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "run_stress stats, newton off:" << stats << std::endl; stats.reset(); id = lmp->modify->find_compute("sum"); energy = lmp->modify->compute[id]->compute_scalar(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.run_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.run_coul, epsilon); - EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl+pair->eng_coul),energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats, newton off:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl + pair->eng_coul), energy, epsilon); + if (print_stats) std::cerr << "run_energy stats, newton off:" << stats << std::endl; } if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); }; -TEST(PairStyle, intel) { +TEST(PairStyle, intel) +{ if (!LAMMPS::is_installed_pkg("USER-INTEL")) GTEST_SKIP(); - const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", - "-nocite", "-pk", "intel", "0", "mode", "double", - "omp", "4", "lrt", "no", "-sf", "intel"}; + const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite", + "-pk", "intel", "0", "mode", "double", "omp", + "4", "lrt", "no", "-sf", "intel"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config); + LAMMPS *lmp = init_lammps(argc, argv, test_config); std::string output = ::testing::internal::GetCapturedStdout(); if (verbose) std::cout << output; if (!lmp) { std::cerr << "One or more prerequisite styles with /intel suffix\n" - "are not available in this LAMMPS configuration:\n"; + "are not available in this LAMMPS configuration:\n"; for (auto prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } if (test_config.pair_style == "rebo") { - if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); - if (!verbose) ::testing::internal::GetCapturedStdout(); - std::cerr << "Skipping pair style rebo/intel\n"; - GTEST_SKIP(); + if (!verbose) ::testing::internal::CaptureStdout(); + cleanup_lammps(lmp, test_config); + if (!verbose) ::testing::internal::GetCapturedStdout(); + std::cerr << "Skipping pair style rebo/intel\n"; + GTEST_SKIP(); } // relax error a bit for USER-INTEL package - double epsilon = 7.5*test_config.epsilon; + double epsilon = 7.5 * test_config.epsilon; // we need to relax the epsilon a LOT for tests using long-range // coulomb with tabulation. seems more like mixed precision or a bug for (auto post_cmd : test_config.post_commands) { if (post_cmd.find("pair_modify table") != std::string::npos) { - if (post_cmd.find("pair_modify table 0") == std::string::npos) - epsilon *= 1000000.0; + if (post_cmd.find("pair_modify table 0") == std::string::npos) epsilon *= 1000000.0; } } @@ -858,38 +821,35 @@ TEST(PairStyle, intel) { // abort if running in parallel and not all atoms are local const int nlocal = lmp->atom->nlocal; - ASSERT_EQ(lmp->atom->natoms,nlocal); + ASSERT_EQ(lmp->atom->natoms, nlocal); - double **f=lmp->atom->f; - tagint *tag=lmp->atom->tag; + double **f = lmp->atom->f; + tagint *tag = lmp->atom->tag; const std::vector &f_ref = test_config.init_forces; ErrorStats stats; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats:" << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats:" << stats << std::endl; Pair *pair = lmp->force->pair; double *stress = pair->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "init_stress stats:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "init_stress stats:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.init_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.init_coul, epsilon); - if (print_stats) - std::cerr << "init_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -898,26 +858,24 @@ TEST(PairStyle, intel) { f = lmp->atom->f; stress = pair->virial; const std::vector &f_run = test_config.run_forces; - ASSERT_EQ(nlocal+1,f_run.size()); + ASSERT_EQ(nlocal + 1, f_run.size()); stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats:" << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats:" << stats << std::endl; stress = pair->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "run_stress stats:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "run_stress stats:" << stats << std::endl; stats.reset(); int id = lmp->modify->find_compute("sum"); @@ -926,36 +884,33 @@ TEST(PairStyle, intel) { EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.run_coul, epsilon); // rebo family of pair styles will have a large error in per-atom energy for USER-INTEL - if (test_config.pair_style.find("rebo") != std::string::npos) - epsilon *= 100000.0; + if (test_config.pair_style.find("rebo") != std::string::npos) epsilon *= 100000.0; - EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl+pair->eng_coul),energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl + pair->eng_coul), energy, epsilon); + if (print_stats) std::cerr << "run_energy stats:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); }; -TEST(PairStyle, opt) { +TEST(PairStyle, opt) +{ if (!LAMMPS::is_installed_pkg("OPT")) GTEST_SKIP(); - const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", - "-nocite", "-sf", "opt"}; + const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite", "-sf", "opt"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config); + LAMMPS *lmp = init_lammps(argc, argv, test_config); std::string output; if (!verbose) output = ::testing::internal::GetCapturedStdout(); if (!lmp) { std::cerr << "One or more prerequisite styles with /opt suffix\n" - "are not available in this LAMMPS configuration:\n"; + "are not available in this LAMMPS configuration:\n"; for (auto prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -965,40 +920,37 @@ TEST(PairStyle, opt) { // abort if running in parallel and not all atoms are local const int nlocal = lmp->atom->nlocal; - ASSERT_EQ(lmp->atom->natoms,nlocal); + ASSERT_EQ(lmp->atom->natoms, nlocal); // relax error a bit for OPT package - double epsilon = 2.0*test_config.epsilon; - double **f=lmp->atom->f; - tagint *tag=lmp->atom->tag; + double epsilon = 2.0 * test_config.epsilon; + double **f = lmp->atom->f; + tagint *tag = lmp->atom->tag; const std::vector &f_ref = test_config.init_forces; ErrorStats stats; stats.reset(); - for (int i=0; i < nlocal; ++i) { + for (int i = 0; i < nlocal; ++i) { EXPECT_FP_LE_WITH_EPS(f[i][0], f_ref[tag[i]].x, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][1], f_ref[tag[i]].y, epsilon); EXPECT_FP_LE_WITH_EPS(f[i][2], f_ref[tag[i]].z, epsilon); } - if (print_stats) - std::cerr << "init_forces stats:" << stats << std::endl; + if (print_stats) std::cerr << "init_forces stats:" << stats << std::endl; Pair *pair = lmp->force->pair; double *stress = pair->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "init_stress stats:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.init_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.init_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.init_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.init_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.init_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.init_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "init_stress stats:" << stats << std::endl; stats.reset(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.init_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.init_coul, epsilon); - if (print_stats) - std::cerr << "init_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "init_energy stats:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); run_lammps(lmp); @@ -1007,57 +959,54 @@ TEST(PairStyle, opt) { f = lmp->atom->f; stress = pair->virial; const std::vector &f_run = test_config.run_forces; - ASSERT_EQ(nlocal+1,f_run.size()); + ASSERT_EQ(nlocal + 1, f_run.size()); stats.reset(); - for (int i=0; i < nlocal; ++i) { - EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5*epsilon); - EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5*epsilon); + for (int i = 0; i < nlocal; ++i) { + EXPECT_FP_LE_WITH_EPS(f[i][0], f_run[tag[i]].x, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][1], f_run[tag[i]].y, 5 * epsilon); + EXPECT_FP_LE_WITH_EPS(f[i][2], f_run[tag[i]].z, 5 * epsilon); } - if (print_stats) - std::cerr << "run_forces stats:" << stats << std::endl; + if (print_stats) std::cerr << "run_forces stats:" << stats << std::endl; stress = pair->virial; stats.reset(); - EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10*epsilon); - EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10*epsilon); - if (print_stats) - std::cerr << "run_stress stats:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(stress[0], test_config.run_stress.xx, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[1], test_config.run_stress.yy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[2], test_config.run_stress.zz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[3], test_config.run_stress.xy, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[4], test_config.run_stress.xz, 10 * epsilon); + EXPECT_FP_LE_WITH_EPS(stress[5], test_config.run_stress.yz, 10 * epsilon); + if (print_stats) std::cerr << "run_stress stats:" << stats << std::endl; stats.reset(); int id = lmp->modify->find_compute("sum"); double energy = lmp->modify->compute[id]->compute_scalar(); EXPECT_FP_LE_WITH_EPS(pair->eng_vdwl, test_config.run_vdwl, epsilon); EXPECT_FP_LE_WITH_EPS(pair->eng_coul, test_config.run_coul, epsilon); - EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl+pair->eng_coul),energy, epsilon); - if (print_stats) - std::cerr << "run_energy stats:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS((pair->eng_vdwl + pair->eng_coul), energy, epsilon); + if (print_stats) std::cerr << "run_energy stats:" << stats << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); }; -TEST(PairStyle, single) { - const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite" }; +TEST(PairStyle, single) +{ + const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); // create a LAMMPS instance with standard settings to detect the number of atom types if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config); + LAMMPS *lmp = init_lammps(argc, argv, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; + "in this LAMMPS configuration:\n"; for (auto prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } @@ -1068,28 +1017,28 @@ TEST(PairStyle, single) { if (molecular > 1) { std::cerr << "Only atomic and simple molecular atom styles are supported\n"; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); GTEST_SKIP(); } Pair *pair = lmp->force->pair; if (!pair->single_enable) { - std::cerr << "Single method not available for pair style " - << test_config.pair_style << std::endl; + std::cerr << "Single method not available for pair style " << test_config.pair_style + << std::endl; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); GTEST_SKIP(); } // The single function in EAM is different from what we assume // here, therefore we have to skip testing those pair styles. - if ((test_config.pair_style.substr(0,3) == "eam") - || ((test_config.pair_style.substr(0,6) == "hybrid") - && (test_config.pair_style.find("eam") != std::string::npos))) { + if ((test_config.pair_style.substr(0, 3) == "eam") || + ((test_config.pair_style.substr(0, 6) == "hybrid") && + (test_config.pair_style.find("eam") != std::string::npos))) { if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); GTEST_SKIP(); } @@ -1098,7 +1047,7 @@ TEST(PairStyle, single) { if (!verbose) ::testing::internal::CaptureStdout(); // utility lambda to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; @@ -1108,7 +1057,7 @@ TEST(PairStyle, single) { command("variable input_dir index " + INPUT_FOLDER); - for (auto& pre_command : test_config.pre_commands) { + for (auto &pre_command : test_config.pre_commands) { command(pre_command); } @@ -1126,7 +1075,7 @@ TEST(PairStyle, single) { command("region box block -10.0 10.0 -10.0 10.0 -10.0 10.0 units box"); char buf[10]; - snprintf(buf,10,"%d",ntypes); + snprintf(buf, 10, "%d", ntypes); std::string cmd("create_box "); cmd += buf; cmd += " box"; @@ -1141,7 +1090,7 @@ TEST(PairStyle, single) { pair = lmp->force->pair; - for (auto& pair_coeff : test_config.pair_coeff) { + for (auto &pair_coeff : test_config.pair_coeff) { command("pair_coeff " + pair_coeff); } @@ -1159,7 +1108,7 @@ TEST(PairStyle, single) { command("bond_coeff 1 2.0"); } - for (auto& post_command : test_config.post_commands) { + for (auto &post_command : test_config.post_commands) { command(post_command); } @@ -1169,12 +1118,12 @@ TEST(PairStyle, single) { int idx1 = lmp->atom->map(1); int idx2 = lmp->atom->map(2); double epsilon = test_config.epsilon; - double **f=lmp->atom->f; - double **x=lmp->atom->x; + double **f = lmp->atom->f; + double **x = lmp->atom->x; double delx = x[idx2][0] - x[idx1][0]; double dely = x[idx2][1] - x[idx1][1]; double delz = x[idx2][2] - x[idx1][2]; - double rsq = delx*delx+dely*dely+delz*delz; + double rsq = delx * delx + dely * dely + delz * delz; double fsingle = 0.0; double epair[4], esngl[4]; double splj = lmp->force->special_lj[1]; @@ -1183,12 +1132,12 @@ TEST(PairStyle, single) { epair[0] = pair->eng_vdwl + pair->eng_coul; esngl[0] = pair->single(idx1, idx2, 1, 2, rsq, spcl, splj, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx1][0],-fsingle*delx, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][1],-fsingle*dely, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][2],-fsingle*delz, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle*delx, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle*dely, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle*delz, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][0], -fsingle * delx, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][1], -fsingle * dely, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][2], -fsingle * delz, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle * delx, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle * dely, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle * delz, epsilon); if (!verbose) ::testing::internal::CaptureStdout(); command("displace_atoms all random 0.5 0.5 0.5 723456"); @@ -1202,17 +1151,17 @@ TEST(PairStyle, single) { delx = x[idx2][0] - x[idx1][0]; dely = x[idx2][1] - x[idx1][1]; delz = x[idx2][2] - x[idx1][2]; - rsq = delx*delx+dely*dely+delz*delz; + rsq = delx * delx + dely * dely + delz * delz; fsingle = 0.0; epair[1] = pair->eng_vdwl + pair->eng_coul; esngl[1] = pair->single(idx1, idx2, 1, 2, rsq, spcl, splj, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx1][0],-fsingle*delx, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][1],-fsingle*dely, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][2],-fsingle*delz, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle*delx, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle*dely, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle*delz, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][0], -fsingle * delx, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][1], -fsingle * dely, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][2], -fsingle * delz, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle * delx, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle * dely, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle * delz, epsilon); if (!verbose) ::testing::internal::CaptureStdout(); command("displace_atoms all random 0.5 0.5 0.5 3456963"); @@ -1226,17 +1175,17 @@ TEST(PairStyle, single) { delx = x[idx2][0] - x[idx1][0]; dely = x[idx2][1] - x[idx1][1]; delz = x[idx2][2] - x[idx1][2]; - rsq = delx*delx+dely*dely+delz*delz; + rsq = delx * delx + dely * dely + delz * delz; fsingle = 0.0; epair[2] = pair->eng_vdwl + pair->eng_coul; esngl[2] = pair->single(idx1, idx2, 1, 2, rsq, spcl, splj, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx1][0],-fsingle*delx, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][1],-fsingle*dely, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][2],-fsingle*delz, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle*delx, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle*dely, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle*delz, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][0], -fsingle * delx, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][1], -fsingle * dely, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][2], -fsingle * delz, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle * delx, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle * dely, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle * delz, epsilon); if (!verbose) ::testing::internal::CaptureStdout(); command("displace_atoms all random 0.5 0.5 0.5 9726532"); @@ -1250,78 +1199,76 @@ TEST(PairStyle, single) { delx = x[idx2][0] - x[idx1][0]; dely = x[idx2][1] - x[idx1][1]; delz = x[idx2][2] - x[idx1][2]; - rsq = delx*delx+dely*dely+delz*delz; + rsq = delx * delx + dely * dely + delz * delz; fsingle = 0.0; epair[3] = pair->eng_vdwl + pair->eng_coul; esngl[3] = pair->single(idx1, idx2, 1, 2, rsq, spcl, splj, fsingle); - EXPECT_FP_LE_WITH_EPS(f[idx1][0],-fsingle*delx, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][1],-fsingle*dely, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx1][2],-fsingle*delz, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle*delx, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle*dely, epsilon); - EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle*delz, epsilon); - if (print_stats) - std::cerr << "single_force stats:" << stats << std::endl; + EXPECT_FP_LE_WITH_EPS(f[idx1][0], -fsingle * delx, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][1], -fsingle * dely, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx1][2], -fsingle * delz, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][0], fsingle * delx, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][1], fsingle * dely, epsilon); + EXPECT_FP_LE_WITH_EPS(f[idx2][2], fsingle * delz, epsilon); + if (print_stats) std::cerr << "single_force stats:" << stats << std::endl; - if ((test_config.pair_style.find("coul/dsf") != std::string::npos) - && (test_config.pair_style.find("coul/wolf") != std::string::npos)) { + if ((test_config.pair_style.find("coul/dsf") != std::string::npos) && + (test_config.pair_style.find("coul/wolf") != std::string::npos)) { stats.reset(); EXPECT_FP_LE_WITH_EPS(epair[0], esngl[0], epsilon); EXPECT_FP_LE_WITH_EPS(epair[1], esngl[1], epsilon); EXPECT_FP_LE_WITH_EPS(epair[2], esngl[2], epsilon); EXPECT_FP_LE_WITH_EPS(epair[3], esngl[3], epsilon); - if (print_stats) - std::cerr << "single_energy stats:" << stats << std::endl; + if (print_stats) std::cerr << "single_energy stats:" << stats << std::endl; } else if (print_stats) std::cerr << "skipping single_energy test due to self energy\n"; if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); } -TEST(PairStyle, extract) { - const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite" }; +TEST(PairStyle, extract) +{ + const char *args[] = {"PairStyle", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); if (!verbose) ::testing::internal::CaptureStdout(); - LAMMPS *lmp = init_lammps(argc,argv,test_config,true); + LAMMPS *lmp = init_lammps(argc, argv, test_config, true); if (!verbose) ::testing::internal::GetCapturedStdout(); if (!lmp) { std::cerr << "One or more prerequisite styles are not available " - "in this LAMMPS configuration:\n"; + "in this LAMMPS configuration:\n"; for (auto prerequisite : test_config.prerequisites) { - std::cerr << prerequisite.first << "_style " - << prerequisite.second << "\n"; + std::cerr << prerequisite.first << "_style " << prerequisite.second << "\n"; } GTEST_SKIP(); } Pair *pair = lmp->force->pair; void *ptr = nullptr; int dim = 0; - for (auto& extract : test_config.extract) { + for (auto &extract : test_config.extract) { ptr = pair->extract(extract.first.c_str(), dim); EXPECT_NE(ptr, nullptr); EXPECT_EQ(dim, extract.second); } - ptr = pair->extract("does_not_exist",dim); + ptr = pair->extract("does_not_exist", dim); EXPECT_EQ(ptr, nullptr); // replace pair style with the same. // should just update setting, but not create new style. int ntypes = lmp->atom->ntypes; - for (int i=1; i <= ntypes; ++i) { - for (int j=1; j <= ntypes; ++j) { + for (int i = 1; i <= ntypes; ++i) { + for (int j = 1; j <= ntypes; ++j) { pair->cutsq[i][j] = -1.0; } } // utility lambda to improve readability - auto command = [&](const std::string & line) { + auto command = [&](const std::string &line) { lmp->input->one(line.c_str()); }; @@ -1329,19 +1276,19 @@ TEST(PairStyle, extract) { command("pair_style " + test_config.pair_style); EXPECT_EQ(pair, lmp->force->pair); - for (auto& pair_coeff : test_config.pair_coeff) { + for (auto &pair_coeff : test_config.pair_coeff) { command("pair_coeff " + pair_coeff); } pair->init(); if (!verbose) ::testing::internal::GetCapturedStdout(); - for (int i=1; i <= ntypes; ++i) { - for (int j=1; j <= ntypes; ++j) { - EXPECT_GE(pair->cutsq[i][j],0.0); + for (int i = 1; i <= ntypes; ++i) { + for (int j = 1; j <= ntypes; ++j) { + EXPECT_GE(pair->cutsq[i][j], 0.0); } } if (!verbose) ::testing::internal::CaptureStdout(); - cleanup_lammps(lmp,test_config); + cleanup_lammps(lmp, test_config); if (!verbose) ::testing::internal::GetCapturedStdout(); } diff --git a/unittest/force-styles/test_config.h b/unittest/force-styles/test_config.h index e808a0301c..3ac838f635 100644 --- a/unittest/force-styles/test_config.h +++ b/unittest/force-styles/test_config.h @@ -19,11 +19,11 @@ #include struct coord_t { - double x,y,z; + double x, y, z; }; struct stress_t { - double xx,yy,zz,xy,xz,yz; + double xx, yy, zz, xy, xz, yz; }; class TestConfig { @@ -32,7 +32,7 @@ public: std::string date_generated; std::string basename; double epsilon; - std::vector> prerequisites; + std::vector> prerequisites; std::vector pre_commands; std::vector post_commands; std::string input_file; @@ -48,7 +48,7 @@ public: std::vector dihedral_coeff; std::vector improper_coeff; std::vector equilibrium; - std::vector> extract; + std::vector> extract; int natoms; double init_energy; double run_energy; @@ -61,26 +61,13 @@ public: std::vector init_forces; std::vector run_forces; - TestConfig() : lammps_version(""), - date_generated(""), - basename(""), - epsilon(1.0e-14), - input_file(""), - pair_style("zero"), - bond_style("zero"), - angle_style("zero"), - dihedral_style("zero"), - improper_style("zero"), - kspace_style("none"), - natoms(0), - init_energy(0), - run_energy(0), - init_vdwl(0), - run_vdwl(0), - init_coul(0), - run_coul(0), - init_stress({0,0,0,0,0,0}), - run_stress({0,0,0,0,0,0}) { + TestConfig() : + lammps_version(""), date_generated(""), basename(""), epsilon(1.0e-14), input_file(""), + pair_style("zero"), bond_style("zero"), angle_style("zero"), dihedral_style("zero"), + improper_style("zero"), kspace_style("none"), natoms(0), init_energy(0), run_energy(0), + init_vdwl(0), run_vdwl(0), init_coul(0), run_coul(0), init_stress({0, 0, 0, 0, 0, 0}), + run_stress({0, 0, 0, 0, 0, 0}) + { prerequisites.clear(); pre_commands.clear(); post_commands.clear(); @@ -93,10 +80,10 @@ public: init_forces.clear(); run_forces.clear(); } - virtual ~TestConfig() {}; + virtual ~TestConfig(){}; private: - TestConfig(const TestConfig &) {}; + TestConfig(const TestConfig &){}; }; #endif diff --git a/unittest/force-styles/test_config_reader.cpp b/unittest/force-styles/test_config_reader.cpp index 3473782a7e..4733190aad 100644 --- a/unittest/force-styles/test_config_reader.cpp +++ b/unittest/force-styles/test_config_reader.cpp @@ -11,75 +11,78 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "test_config.h" #include "test_config_reader.h" -#include "yaml_reader.h" +#include "test_config.h" #include "yaml.h" +#include "yaml_reader.h" -#include #include +#include -#include #include #include +#include #include #include -TestConfigReader::TestConfigReader(TestConfig & config) - : YamlReader(), config(config) { +TestConfigReader::TestConfigReader(TestConfig &config) : YamlReader(), config(config) +{ consumers["lammps_version"] = &TestConfigReader::lammps_version; consumers["date_generated"] = &TestConfigReader::date_generated; - consumers["epsilon"] = &TestConfigReader::epsilon; - consumers["prerequisites"] = &TestConfigReader::prerequisites; - consumers["pre_commands"] = &TestConfigReader::pre_commands; - consumers["post_commands"] = &TestConfigReader::post_commands; - consumers["input_file"] = &TestConfigReader::input_file; - consumers["extract"] = &TestConfigReader::extract; - consumers["natoms"] = &TestConfigReader::natoms; - consumers["init_stress"] = &TestConfigReader::init_stress; - consumers["run_stress"] = &TestConfigReader::run_stress; - consumers["init_forces"] = &TestConfigReader::init_forces; - consumers["run_forces"] = &TestConfigReader::run_forces; + consumers["epsilon"] = &TestConfigReader::epsilon; + consumers["prerequisites"] = &TestConfigReader::prerequisites; + consumers["pre_commands"] = &TestConfigReader::pre_commands; + consumers["post_commands"] = &TestConfigReader::post_commands; + consumers["input_file"] = &TestConfigReader::input_file; + consumers["extract"] = &TestConfigReader::extract; + consumers["natoms"] = &TestConfigReader::natoms; + consumers["init_stress"] = &TestConfigReader::init_stress; + consumers["run_stress"] = &TestConfigReader::run_stress; + consumers["init_forces"] = &TestConfigReader::init_forces; + consumers["run_forces"] = &TestConfigReader::run_forces; - consumers["pair_style"] = &TestConfigReader::pair_style; - consumers["pair_coeff"] = &TestConfigReader::pair_coeff; - consumers["init_vdwl"] = &TestConfigReader::init_vdwl; - consumers["init_coul"] = &TestConfigReader::init_coul; - consumers["run_vdwl"] = &TestConfigReader::run_vdwl; - consumers["run_coul"] = &TestConfigReader::run_coul; + consumers["pair_style"] = &TestConfigReader::pair_style; + consumers["pair_coeff"] = &TestConfigReader::pair_coeff; + consumers["init_vdwl"] = &TestConfigReader::init_vdwl; + consumers["init_coul"] = &TestConfigReader::init_coul; + consumers["run_vdwl"] = &TestConfigReader::run_vdwl; + consumers["run_coul"] = &TestConfigReader::run_coul; - consumers["bond_style"] = &TestConfigReader::bond_style; - consumers["bond_coeff"] = &TestConfigReader::bond_coeff; - consumers["angle_style"] = &TestConfigReader::angle_style; - consumers["angle_coeff"] = &TestConfigReader::angle_coeff; - consumers["init_energy"] = &TestConfigReader::init_energy; - consumers["run_energy"] = &TestConfigReader::run_energy; - consumers["equilibrium"] = &TestConfigReader::equilibrium; + consumers["bond_style"] = &TestConfigReader::bond_style; + consumers["bond_coeff"] = &TestConfigReader::bond_coeff; + consumers["angle_style"] = &TestConfigReader::angle_style; + consumers["angle_coeff"] = &TestConfigReader::angle_coeff; + consumers["init_energy"] = &TestConfigReader::init_energy; + consumers["run_energy"] = &TestConfigReader::run_energy; + consumers["equilibrium"] = &TestConfigReader::equilibrium; } -void TestConfigReader::prerequisites(const yaml_event_t & event) { +void TestConfigReader::prerequisites(const yaml_event_t &event) +{ config.prerequisites.clear(); std::stringstream data((char *)event.data.scalar.value); std::string key, value; - while(1) { + while (1) { data >> key >> value; if (data.eof()) break; - config.prerequisites.push_back(std::make_pair(key,value)); + config.prerequisites.push_back(std::make_pair(key, value)); } } -void TestConfigReader::pre_commands(const yaml_event_t & event) { +void TestConfigReader::pre_commands(const yaml_event_t &event) +{ config.pre_commands.clear(); std::stringstream data((char *)event.data.scalar.value); std::string line; - while(std::getline(data, line, '\n')) { + while (std::getline(data, line, '\n')) { config.pre_commands.push_back(line); } } -void TestConfigReader::post_commands(const yaml_event_t & event) { +void TestConfigReader::post_commands(const yaml_event_t &event) +{ config.post_commands.clear(); std::stringstream data((char *)event.data.scalar.value); std::string line; @@ -89,63 +92,68 @@ void TestConfigReader::post_commands(const yaml_event_t & event) { } } -void TestConfigReader::lammps_version(const yaml_event_t & event) { +void TestConfigReader::lammps_version(const yaml_event_t &event) +{ config.lammps_version = (char *)event.data.scalar.value; } -void TestConfigReader::date_generated(const yaml_event_t & event) { +void TestConfigReader::date_generated(const yaml_event_t &event) +{ config.date_generated = (char *)event.data.scalar.value; } -void TestConfigReader::epsilon(const yaml_event_t & event) { +void TestConfigReader::epsilon(const yaml_event_t &event) +{ config.epsilon = atof((char *)event.data.scalar.value); } -void TestConfigReader::input_file(const yaml_event_t & event) { +void TestConfigReader::input_file(const yaml_event_t &event) +{ config.input_file = (char *)event.data.scalar.value; } -void TestConfigReader::extract(const yaml_event_t & event) { +void TestConfigReader::extract(const yaml_event_t &event) +{ config.extract.clear(); std::stringstream data((char *)event.data.scalar.value); std::string name; int value; - while(1) { + while (1) { data >> name >> value; if (data.eof()) break; config.extract.push_back(make_pair(name, value)); } } -void TestConfigReader::natoms(const yaml_event_t & event) { +void TestConfigReader::natoms(const yaml_event_t &event) +{ config.natoms = atoi((char *)event.data.scalar.value); } -void TestConfigReader::init_stress(const yaml_event_t & event) { +void TestConfigReader::init_stress(const yaml_event_t &event) +{ stress_t stress; - sscanf((char *)event.data.scalar.value, - "%lg %lg %lg %lg %lg %lg", - &stress.xx, &stress.yy, &stress.zz, - &stress.xy, &stress.xz, &stress.yz); + sscanf((char *)event.data.scalar.value, "%lg %lg %lg %lg %lg %lg", &stress.xx, &stress.yy, + &stress.zz, &stress.xy, &stress.xz, &stress.yz); config.init_stress = stress; } -void TestConfigReader::run_stress(const yaml_event_t & event) { +void TestConfigReader::run_stress(const yaml_event_t &event) +{ stress_t stress; - sscanf((char *)event.data.scalar.value, - "%lg %lg %lg %lg %lg %lg", - &stress.xx, &stress.yy, &stress.zz, - &stress.xy, &stress.xz, &stress.yz); + sscanf((char *)event.data.scalar.value, "%lg %lg %lg %lg %lg %lg", &stress.xx, &stress.yy, + &stress.zz, &stress.xy, &stress.xz, &stress.yz); config.run_stress = stress; } -void TestConfigReader::init_forces(const yaml_event_t & event) { +void TestConfigReader::init_forces(const yaml_event_t &event) +{ config.init_forces.clear(); - config.init_forces.resize(config.natoms+1); - std::stringstream data((const char*)event.data.scalar.value); + config.init_forces.resize(config.natoms + 1); + std::stringstream data((const char *)event.data.scalar.value); std::string line; - while(std::getline(data, line, '\n')) { + while (std::getline(data, line, '\n')) { int tag = 0; coord_t xyz; sscanf(line.c_str(), "%d %lg %lg %lg", &tag, &xyz.x, &xyz.y, &xyz.z); @@ -153,13 +161,14 @@ void TestConfigReader::init_forces(const yaml_event_t & event) { } } -void TestConfigReader::run_forces(const yaml_event_t & event) { +void TestConfigReader::run_forces(const yaml_event_t &event) +{ config.run_forces.clear(); - config.run_forces.resize(config.natoms+1); + config.run_forces.resize(config.natoms + 1); std::stringstream data((char *)event.data.scalar.value); std::string line; - while(std::getline(data, line, '\n')) { + while (std::getline(data, line, '\n')) { int tag; coord_t xyz; sscanf(line.c_str(), "%d %lg %lg %lg", &tag, &xyz.x, &xyz.y, &xyz.z); @@ -167,11 +176,13 @@ void TestConfigReader::run_forces(const yaml_event_t & event) { } } -void TestConfigReader::pair_style(const yaml_event_t & event) { +void TestConfigReader::pair_style(const yaml_event_t &event) +{ config.pair_style = (char *)event.data.scalar.value; } -void TestConfigReader::pair_coeff(const yaml_event_t & event) { +void TestConfigReader::pair_coeff(const yaml_event_t &event) +{ config.pair_coeff.clear(); std::stringstream data((char *)event.data.scalar.value); std::string line; @@ -181,11 +192,13 @@ void TestConfigReader::pair_coeff(const yaml_event_t & event) { } } -void TestConfigReader::bond_style(const yaml_event_t & event) { +void TestConfigReader::bond_style(const yaml_event_t &event) +{ config.bond_style = (char *)event.data.scalar.value; } -void TestConfigReader::bond_coeff(const yaml_event_t & event) { +void TestConfigReader::bond_coeff(const yaml_event_t &event) +{ config.bond_coeff.clear(); std::stringstream data((char *)event.data.scalar.value); std::string line; @@ -195,11 +208,13 @@ void TestConfigReader::bond_coeff(const yaml_event_t & event) { } } -void TestConfigReader::angle_style(const yaml_event_t & event) { +void TestConfigReader::angle_style(const yaml_event_t &event) +{ config.angle_style = (char *)event.data.scalar.value; } -void TestConfigReader::angle_coeff(const yaml_event_t & event) { +void TestConfigReader::angle_coeff(const yaml_event_t &event) +{ config.angle_coeff.clear(); std::stringstream data((char *)event.data.scalar.value); std::string line; @@ -209,40 +224,46 @@ void TestConfigReader::angle_coeff(const yaml_event_t & event) { } } -void TestConfigReader::equilibrium(const yaml_event_t & event) { +void TestConfigReader::equilibrium(const yaml_event_t &event) +{ std::stringstream data((char *)event.data.scalar.value); config.equilibrium.clear(); double value; std::size_t num; data >> num; - for (std::size_t i=0; i < num; ++i) { + for (std::size_t i = 0; i < num; ++i) { data >> value; if (data.eof()) break; config.equilibrium.push_back(value); } } -void TestConfigReader::init_vdwl(const yaml_event_t & event) { +void TestConfigReader::init_vdwl(const yaml_event_t &event) +{ config.init_vdwl = atof((char *)event.data.scalar.value); } -void TestConfigReader::init_coul(const yaml_event_t & event) { +void TestConfigReader::init_coul(const yaml_event_t &event) +{ config.init_coul = atof((char *)event.data.scalar.value); } -void TestConfigReader::run_vdwl(const yaml_event_t & event) { +void TestConfigReader::run_vdwl(const yaml_event_t &event) +{ config.run_vdwl = atof((char *)event.data.scalar.value); } -void TestConfigReader::run_coul(const yaml_event_t & event) { +void TestConfigReader::run_coul(const yaml_event_t &event) +{ config.run_coul = atof((char *)event.data.scalar.value); } -void TestConfigReader::init_energy(const yaml_event_t & event) { +void TestConfigReader::init_energy(const yaml_event_t &event) +{ config.init_energy = atof((char *)event.data.scalar.value); } -void TestConfigReader::run_energy(const yaml_event_t & event) { +void TestConfigReader::run_energy(const yaml_event_t &event) +{ config.run_energy = atof((char *)event.data.scalar.value); } - diff --git a/unittest/force-styles/test_config_reader.h b/unittest/force-styles/test_config_reader.h index de960c81c6..1d7d9b6153 100644 --- a/unittest/force-styles/test_config_reader.h +++ b/unittest/force-styles/test_config_reader.h @@ -17,37 +17,37 @@ #include "yaml_reader.h" class TestConfigReader : public YamlReader { - TestConfig & config; + TestConfig &config; public: - TestConfigReader(TestConfig & config); + TestConfigReader(TestConfig &config); - void prerequisites(const yaml_event_t & event); - void pre_commands(const yaml_event_t & event); - void post_commands(const yaml_event_t & event); - void lammps_version(const yaml_event_t & event); - void date_generated(const yaml_event_t & event); - void epsilon(const yaml_event_t & event); - void input_file(const yaml_event_t & event); - void extract(const yaml_event_t & event); - void natoms(const yaml_event_t & event); - void init_stress(const yaml_event_t & event); - void run_stress(const yaml_event_t & event); - void init_forces(const yaml_event_t & event); - void run_forces(const yaml_event_t & event); - void pair_style(const yaml_event_t & event); - void pair_coeff(const yaml_event_t & event); - void bond_style(const yaml_event_t & event); - void bond_coeff(const yaml_event_t & event); - void angle_style(const yaml_event_t & event); - void angle_coeff(const yaml_event_t & event); - void equilibrium(const yaml_event_t & event); - void init_vdwl(const yaml_event_t & event); - void init_coul(const yaml_event_t & event); - void run_vdwl(const yaml_event_t & event); - void run_coul(const yaml_event_t & event); - void init_energy(const yaml_event_t & event); - void run_energy(const yaml_event_t & event); + void prerequisites(const yaml_event_t &event); + void pre_commands(const yaml_event_t &event); + void post_commands(const yaml_event_t &event); + void lammps_version(const yaml_event_t &event); + void date_generated(const yaml_event_t &event); + void epsilon(const yaml_event_t &event); + void input_file(const yaml_event_t &event); + void extract(const yaml_event_t &event); + void natoms(const yaml_event_t &event); + void init_stress(const yaml_event_t &event); + void run_stress(const yaml_event_t &event); + void init_forces(const yaml_event_t &event); + void run_forces(const yaml_event_t &event); + void pair_style(const yaml_event_t &event); + void pair_coeff(const yaml_event_t &event); + void bond_style(const yaml_event_t &event); + void bond_coeff(const yaml_event_t &event); + void angle_style(const yaml_event_t &event); + void angle_coeff(const yaml_event_t &event); + void equilibrium(const yaml_event_t &event); + void init_vdwl(const yaml_event_t &event); + void init_coul(const yaml_event_t &event); + void run_vdwl(const yaml_event_t &event); + void run_coul(const yaml_event_t &event); + void init_energy(const yaml_event_t &event); + void run_energy(const yaml_event_t &event); }; #endif diff --git a/unittest/force-styles/test_main.cpp b/unittest/force-styles/test_main.cpp index b7028e7d5e..fc59163a60 100644 --- a/unittest/force-styles/test_main.cpp +++ b/unittest/force-styles/test_main.cpp @@ -16,16 +16,15 @@ #include "test_config_reader.h" #include "gtest/gtest.h" -#include #include #include +#include // common read_yaml_file function bool read_yaml_file(const char *infile, TestConfig &config) { auto reader = TestConfigReader(config); - if (reader.parse_file(infile)) - return false; + if (reader.parse_file(infile)) return false; config.basename = reader.get_basename(); return true; @@ -76,32 +75,32 @@ int main(int argc, char **argv) return 2; } - int iarg=2; + int iarg = 2; while (iarg < argc) { - if (strcmp(argv[iarg],"-g") == 0) { - if (iarg+1 < argc) { - generate_yaml_file(argv[iarg+1], test_config); + if (strcmp(argv[iarg], "-g") == 0) { + if (iarg + 1 < argc) { + generate_yaml_file(argv[iarg + 1], test_config); return 0; } else { - usage(std::cerr,argv[0]); + usage(std::cerr, argv[0]); return 1; } - } else if (strcmp(argv[iarg],"-u") == 0) { + } else if (strcmp(argv[iarg], "-u") == 0) { generate_yaml_file(argv[1], test_config); return 0; - } else if (strcmp(argv[iarg],"-d") == 0) { - if (iarg+1 < argc) { - INPUT_FOLDER = argv[iarg+1]; + } else if (strcmp(argv[iarg], "-d") == 0) { + if (iarg + 1 < argc) { + INPUT_FOLDER = argv[iarg + 1]; iarg += 2; } else { - usage(std::cerr,argv[0]); + usage(std::cerr, argv[0]); return 1; } - } else if (strcmp(argv[iarg],"-s") == 0) { + } else if (strcmp(argv[iarg], "-s") == 0) { print_stats = true; ++iarg; - } else if (strcmp(argv[iarg],"-v") == 0) { + } else if (strcmp(argv[iarg], "-v") == 0) { verbose = true; ++iarg; } else { diff --git a/unittest/force-styles/test_main.h b/unittest/force-styles/test_main.h index 03ab9fc6f9..f541094122 100644 --- a/unittest/force-styles/test_main.h +++ b/unittest/force-styles/test_main.h @@ -22,13 +22,13 @@ extern bool print_stats; extern bool verbose; extern std::string INPUT_FOLDER; -#define EXPECT_FP_LE_WITH_EPS(val1,val2,eps) \ - do { \ - const double diff = fabs(val1-val2); \ - const double div = std::min(fabs(val1),fabs(val2)); \ - const double err = (div == 0.0) ? diff : diff/div; \ - stats.add(err); \ - EXPECT_PRED_FORMAT2(::testing::DoubleLE, err, eps); \ +#define EXPECT_FP_LE_WITH_EPS(val1, val2, eps) \ + do { \ + const double diff = fabs(val1 - val2); \ + const double div = std::min(fabs(val1), fabs(val2)); \ + const double err = (div == 0.0) ? diff : diff / div; \ + stats.add(err); \ + EXPECT_PRED_FORMAT2(::testing::DoubleLE, err, eps); \ } while (0); #endif diff --git a/unittest/force-styles/yaml_reader.h b/unittest/force-styles/yaml_reader.h index 90ac395055..7260a8cf9c 100644 --- a/unittest/force-styles/yaml_reader.h +++ b/unittest/force-styles/yaml_reader.h @@ -17,11 +17,11 @@ #include "yaml.h" #include +#include #include #include -#include -template class YamlReader { +template class YamlReader { private: enum StateValue { START, @@ -37,7 +37,7 @@ private: std::string basename; protected: - typedef void (ConsumerClass::*EventConsumer)(const yaml_event_t & event); + typedef void (ConsumerClass::*EventConsumer)(const yaml_event_t &event); std::map consumers; public: @@ -46,20 +46,21 @@ public: std::string get_basename() const { return basename; } - int parse_file(const std::string & infile) { + int parse_file(const std::string &infile) + { basename = infile; std::size_t found = basename.rfind(".yaml"); - if (found > 0) basename = basename.substr(0,found); + if (found > 0) basename = basename.substr(0, found); found = basename.find_last_of("/\\"); - if (found != std::string::npos) basename = basename.substr(found+1); + if (found != std::string::npos) basename = basename.substr(found + 1); - FILE *fp = fopen(infile.c_str(),"r"); + FILE *fp = fopen(infile.c_str(), "r"); yaml_parser_t parser; yaml_event_t event; if (!fp) { - std::cerr << "Cannot open yaml file '" << infile - << "': " << strerror(errno) << std::endl; + std::cerr << "Cannot open yaml file '" << infile << "': " << strerror(errno) + << std::endl; return 1; } yaml_parser_initialize(&parser); @@ -75,9 +76,9 @@ public: } if (accepted) { - if(!consume_key_value(key, event)) { - std::cerr << "Ignoring unknown key/value pair: " << key - << " = " << event.data.scalar.value << std::endl; + if (!consume_key_value(key, event)) { + std::cerr << "Ignoring unknown key/value pair: " << key << " = " + << event.data.scalar.value << std::endl; } } yaml_event_delete(&event); @@ -89,13 +90,14 @@ public: } protected: - bool consume_key_value(const std::string & key, const yaml_event_t & event) { + bool consume_key_value(const std::string &key, const yaml_event_t &event) + { auto it = consumers.find(key); - ConsumerClass *consumer = dynamic_cast(this); + ConsumerClass *consumer = dynamic_cast(this); - if(consumer) { - if(it != consumers.end()) { - //std::cerr << "Loading: " << key << std::endl; + if (consumer) { + if (it != consumers.end()) { + // std::cerr << "Loading: " << key << std::endl; (consumer->*(it->second))(event); return true; } @@ -106,69 +108,68 @@ protected: return false; } - bool consume_event(yaml_event_t & event) { + bool consume_event(yaml_event_t &event) + { accepted = false; switch (state) { - case START: - switch (event.type) { - case YAML_MAPPING_START_EVENT: - state = ACCEPT_KEY; - break; - case YAML_SCALAR_EVENT: - case YAML_SEQUENCE_START_EVENT: - state = ERROR; - break; - case YAML_STREAM_END_EVENT: - state = STOP; - break; - case YAML_STREAM_START_EVENT: - case YAML_DOCUMENT_START_EVENT: - case YAML_DOCUMENT_END_EVENT: - // ignore - break; - default: - std::cerr << "UNHANDLED YAML EVENT: " << event.type << std::endl; - state = ERROR; - break; - } - break; + case START: + switch (event.type) { + case YAML_MAPPING_START_EVENT: + state = ACCEPT_KEY; + break; + case YAML_SCALAR_EVENT: + case YAML_SEQUENCE_START_EVENT: + state = ERROR; + break; + case YAML_STREAM_END_EVENT: + state = STOP; + break; + case YAML_STREAM_START_EVENT: + case YAML_DOCUMENT_START_EVENT: + case YAML_DOCUMENT_END_EVENT: + // ignore + break; + default: + std::cerr << "UNHANDLED YAML EVENT: " << event.type << std::endl; + state = ERROR; + break; + } + break; - case ACCEPT_KEY: - switch (event.type) { - case YAML_SCALAR_EVENT: - key = (char *) event.data.scalar.value; - state = ACCEPT_VALUE; - break; - case YAML_MAPPING_END_EVENT: - state = STOP; - break; - default: - std::cerr << "UNHANDLED YAML EVENT (key): " << event.type - << "\nVALUE: " << event.data.scalar.value - << std::endl; - state = ERROR; - break; - } - break; + case ACCEPT_KEY: + switch (event.type) { + case YAML_SCALAR_EVENT: + key = (char *)event.data.scalar.value; + state = ACCEPT_VALUE; + break; + case YAML_MAPPING_END_EVENT: + state = STOP; + break; + default: + std::cerr << "UNHANDLED YAML EVENT (key): " << event.type + << "\nVALUE: " << event.data.scalar.value << std::endl; + state = ERROR; + break; + } + break; - case ACCEPT_VALUE: - switch (event.type) { - case YAML_SCALAR_EVENT: - accepted = true; - state = ACCEPT_KEY; - break; - default: - std::cerr << "UNHANDLED YAML EVENT (value): " << event.type - << "\nVALUE: " << event.data.scalar.value - << std::endl; - state = ERROR; - break; - } - break; + case ACCEPT_VALUE: + switch (event.type) { + case YAML_SCALAR_EVENT: + accepted = true; + state = ACCEPT_KEY; + break; + default: + std::cerr << "UNHANDLED YAML EVENT (value): " << event.type + << "\nVALUE: " << event.data.scalar.value << std::endl; + state = ERROR; + break; + } + break; - case ERROR: - case STOP: - break; + case ERROR: + case STOP: + break; } return (state != ERROR); } diff --git a/unittest/force-styles/yaml_writer.cpp b/unittest/force-styles/yaml_writer.cpp index 2581cd6acd..fca2ff092f 100644 --- a/unittest/force-styles/yaml_writer.cpp +++ b/unittest/force-styles/yaml_writer.cpp @@ -14,10 +14,11 @@ #include "yaml_writer.h" #include "yaml.h" -#include #include +#include -YamlWriter::YamlWriter(const char * outfile) { +YamlWriter::YamlWriter(const char *outfile) +{ yaml_emitter_initialize(&emitter); fp = fopen(outfile, "w"); if (!fp) { @@ -31,13 +32,13 @@ YamlWriter::YamlWriter(const char * outfile) { yaml_emitter_emit(&emitter, &event); yaml_document_start_event_initialize(&event, NULL, NULL, NULL, 0); yaml_emitter_emit(&emitter, &event); - yaml_mapping_start_event_initialize(&event, NULL, - (yaml_char_t *)YAML_MAP_TAG, - 1, YAML_ANY_MAPPING_STYLE); + yaml_mapping_start_event_initialize(&event, NULL, (yaml_char_t *)YAML_MAP_TAG, 1, + YAML_ANY_MAPPING_STYLE); yaml_emitter_emit(&emitter, &event); } -YamlWriter::~YamlWriter() { +YamlWriter::~YamlWriter() +{ yaml_mapping_end_event_initialize(&event); yaml_emitter_emit(&emitter, &event); yaml_document_end_event_initialize(&event, 0); @@ -48,84 +49,65 @@ YamlWriter::~YamlWriter() { fclose(fp); } -void YamlWriter::emit(const std::string &key, const double value) { - yaml_scalar_event_initialize(&event, NULL, - (yaml_char_t *)YAML_STR_TAG, - (yaml_char_t *) key.c_str(), - key.size(), 1, 0, +void YamlWriter::emit(const std::string &key, const double value) +{ + yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, + (yaml_char_t *)key.c_str(), key.size(), 1, 0, YAML_PLAIN_SCALAR_STYLE); yaml_emitter_emit(&emitter, &event); char buf[256]; - snprintf(buf,256,"%.15g",value); - yaml_scalar_event_initialize(&event, NULL, - (yaml_char_t *)YAML_STR_TAG, - (yaml_char_t *)buf, - strlen(buf), 1, 0, - YAML_PLAIN_SCALAR_STYLE); + snprintf(buf, 256, "%.15g", value); + yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, (yaml_char_t *)buf, + strlen(buf), 1, 0, YAML_PLAIN_SCALAR_STYLE); yaml_emitter_emit(&emitter, &event); } -void YamlWriter::emit(const std::string &key, const long value) { - yaml_scalar_event_initialize(&event, NULL, - (yaml_char_t *)YAML_STR_TAG, - (yaml_char_t *) key.c_str(), - key.size(), 1, 0, +void YamlWriter::emit(const std::string &key, const long value) +{ + yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, + (yaml_char_t *)key.c_str(), key.size(), 1, 0, YAML_PLAIN_SCALAR_STYLE); yaml_emitter_emit(&emitter, &event); char buf[256]; - snprintf(buf,256,"%ld",value); - yaml_scalar_event_initialize(&event, NULL, - (yaml_char_t *)YAML_STR_TAG, - (yaml_char_t *)buf, - strlen(buf), 1, 0, - YAML_PLAIN_SCALAR_STYLE); + snprintf(buf, 256, "%ld", value); + yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, (yaml_char_t *)buf, + strlen(buf), 1, 0, YAML_PLAIN_SCALAR_STYLE); yaml_emitter_emit(&emitter, &event); } -void YamlWriter::emit(const std::string &key, const int value) { - yaml_scalar_event_initialize(&event, NULL, - (yaml_char_t *)YAML_STR_TAG, - (yaml_char_t *) key.c_str(), - key.size(), 1, 0, +void YamlWriter::emit(const std::string &key, const int value) +{ + yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, + (yaml_char_t *)key.c_str(), key.size(), 1, 0, YAML_PLAIN_SCALAR_STYLE); yaml_emitter_emit(&emitter, &event); char buf[256]; - snprintf(buf,256,"%d",value); - yaml_scalar_event_initialize(&event, NULL, - (yaml_char_t *)YAML_STR_TAG, - (yaml_char_t *)buf, - strlen(buf), 1, 0, - YAML_PLAIN_SCALAR_STYLE); + snprintf(buf, 256, "%d", value); + yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, (yaml_char_t *)buf, + strlen(buf), 1, 0, YAML_PLAIN_SCALAR_STYLE); yaml_emitter_emit(&emitter, &event); } void YamlWriter::emit(const std::string &key, const std::string &value) { - yaml_scalar_event_initialize(&event, NULL, - (yaml_char_t *)YAML_STR_TAG, - (yaml_char_t *) key.c_str(), - key.size(), 1, 0, + yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, + (yaml_char_t *)key.c_str(), key.size(), 1, 0, YAML_PLAIN_SCALAR_STYLE); yaml_emitter_emit(&emitter, &event); - yaml_scalar_event_initialize(&event, NULL, - (yaml_char_t *)YAML_STR_TAG, - (yaml_char_t *)value.c_str(), - value.size(), 1, 0, + yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, + (yaml_char_t *)value.c_str(), value.size(), 1, 0, YAML_PLAIN_SCALAR_STYLE); yaml_emitter_emit(&emitter, &event); } -void YamlWriter::emit_block(const std::string &key, const std::string &value) { - yaml_scalar_event_initialize(&event, NULL, - (yaml_char_t *)YAML_STR_TAG, - (yaml_char_t *) key.c_str(), - key.size(), 1, 0, +void YamlWriter::emit_block(const std::string &key, const std::string &value) +{ + yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, + (yaml_char_t *)key.c_str(), key.size(), 1, 0, YAML_PLAIN_SCALAR_STYLE); yaml_emitter_emit(&emitter, &event); - yaml_scalar_event_initialize(&event, NULL, - (yaml_char_t *)YAML_STR_TAG, - (yaml_char_t *)value.c_str(), - value.size(), 1, 0, + yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, + (yaml_char_t *)value.c_str(), value.size(), 1, 0, YAML_LITERAL_SCALAR_STYLE); yaml_emitter_emit(&emitter, &event); } diff --git a/unittest/force-styles/yaml_writer.h b/unittest/force-styles/yaml_writer.h index cb2c7b97df..6cae7c2b24 100644 --- a/unittest/force-styles/yaml_writer.h +++ b/unittest/force-styles/yaml_writer.h @@ -20,7 +20,7 @@ class YamlWriter { public: - YamlWriter(const char * outfile); + YamlWriter(const char *outfile); virtual ~YamlWriter(); // emitters @@ -33,11 +33,11 @@ public: private: FILE *fp; yaml_emitter_t emitter; - yaml_event_t event; + yaml_event_t event; private: - YamlWriter() {}; - YamlWriter(const YamlWriter &) {}; + YamlWriter(){}; + YamlWriter(const YamlWriter &){}; }; #endif diff --git a/unittest/formats/test_eim_potential_file_reader.cpp b/unittest/formats/test_eim_potential_file_reader.cpp index eb13cee7cd..c8dcfd80e0 100644 --- a/unittest/formats/test_eim_potential_file_reader.cpp +++ b/unittest/formats/test_eim_potential_file_reader.cpp @@ -11,11 +11,11 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "gmock/gmock.h" -#include "gtest/gtest.h" +#include "MANYBODY/pair_eim.h" #include "lammps.h" #include "utils.h" -#include "MANYBODY/pair_eim.h" +#include "gmock/gmock.h" +#include "gtest/gtest.h" #include @@ -23,19 +23,21 @@ using namespace LAMMPS_NS; class EIMPotentialFileReaderTest : public ::testing::Test { protected: - LAMMPS * lmp; + LAMMPS *lmp; PairEIM::Setfl setfl; static const int nelements = 9; - void SetUp() override { - const char *args[] = {"PotentialFileReaderTest", "-log", "none", "-echo", "screen", "-nocite" }; + void SetUp() override + { + const char *args[] = { + "PotentialFileReaderTest", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); ::testing::internal::CaptureStdout(); lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD); ::testing::internal::GetCapturedStdout(); - int npair = nelements*(nelements+1)/2; + int npair = nelements * (nelements + 1) / 2; setfl.ielement = new int[nelements]; setfl.mass = new double[nelements]; setfl.negativity = new double[nelements]; @@ -59,28 +61,29 @@ protected: setfl.tp = new int[npair]; } - void TearDown() override { - delete [] setfl.ielement; - delete [] setfl.mass; - delete [] setfl.negativity; - delete [] setfl.ra; - delete [] setfl.ri; - delete [] setfl.Ec; - delete [] setfl.q0; - delete [] setfl.rcutphiA; - delete [] setfl.rcutphiR; - delete [] setfl.Eb; - delete [] setfl.r0; - delete [] setfl.alpha; - delete [] setfl.beta; - delete [] setfl.rcutq; - delete [] setfl.Asigma; - delete [] setfl.rq; - delete [] setfl.rcutsigma; - delete [] setfl.Ac; - delete [] setfl.zeta; - delete [] setfl.rs; - delete [] setfl.tp; + void TearDown() override + { + delete[] setfl.ielement; + delete[] setfl.mass; + delete[] setfl.negativity; + delete[] setfl.ra; + delete[] setfl.ri; + delete[] setfl.Ec; + delete[] setfl.q0; + delete[] setfl.rcutphiA; + delete[] setfl.rcutphiR; + delete[] setfl.Eb; + delete[] setfl.r0; + delete[] setfl.alpha; + delete[] setfl.beta; + delete[] setfl.rcutq; + delete[] setfl.Asigma; + delete[] setfl.rq; + delete[] setfl.rcutsigma; + delete[] setfl.Ac; + delete[] setfl.zeta; + delete[] setfl.rs; + delete[] setfl.tp; ::testing::internal::CaptureStdout(); delete lmp; @@ -88,7 +91,8 @@ protected: } }; -TEST_F(EIMPotentialFileReaderTest, global_line) { +TEST_F(EIMPotentialFileReaderTest, global_line) +{ ::testing::internal::CaptureStdout(); EIMPotentialFileReader reader(lmp, "ffield.eim"); ::testing::internal::GetCapturedStdout(); @@ -99,7 +103,8 @@ TEST_F(EIMPotentialFileReaderTest, global_line) { ASSERT_DOUBLE_EQ(setfl.rsmall, 1.645); } -TEST_F(EIMPotentialFileReaderTest, element_line_sequential) { +TEST_F(EIMPotentialFileReaderTest, element_line_sequential) +{ ::testing::internal::CaptureStdout(); EIMPotentialFileReader reader(lmp, "ffield.eim"); ::testing::internal::GetCapturedStdout(); @@ -123,7 +128,8 @@ TEST_F(EIMPotentialFileReaderTest, element_line_sequential) { ASSERT_DOUBLE_EQ(setfl.q0[1], 0.0000e+00); } -TEST_F(EIMPotentialFileReaderTest, element_line_random) { +TEST_F(EIMPotentialFileReaderTest, element_line_random) +{ ::testing::internal::CaptureStdout(); EIMPotentialFileReader reader(lmp, "ffield.eim"); ::testing::internal::GetCapturedStdout(); @@ -138,7 +144,8 @@ TEST_F(EIMPotentialFileReaderTest, element_line_random) { ASSERT_DOUBLE_EQ(setfl.q0[0], 0.0000e+00); } -TEST_F(EIMPotentialFileReaderTest, pair_line) { +TEST_F(EIMPotentialFileReaderTest, pair_line) +{ ::testing::internal::CaptureStdout(); EIMPotentialFileReader reader(lmp, "ffield.eim"); ::testing::internal::GetCapturedStdout(); @@ -147,7 +154,7 @@ TEST_F(EIMPotentialFileReaderTest, pair_line) { ASSERT_DOUBLE_EQ(setfl.rcutphiA[0], 6.0490e+00); ASSERT_DOUBLE_EQ(setfl.rcutphiR[0], 6.0490e+00); ASSERT_DOUBLE_EQ(setfl.Eb[0], -2.5330e-01); - ASSERT_DOUBLE_EQ(setfl.r0[0], 3.6176e+00); + ASSERT_DOUBLE_EQ(setfl.r0[0], 3.6176e+00); ASSERT_DOUBLE_EQ(setfl.alpha[0], 7.5536e+00); ASSERT_DOUBLE_EQ(setfl.beta[0], 3.5017e+00); ASSERT_DOUBLE_EQ(setfl.rcutq[0], 0.0000e+00); @@ -160,7 +167,8 @@ TEST_F(EIMPotentialFileReaderTest, pair_line) { ASSERT_EQ(setfl.tp[0], 1); } -TEST_F(EIMPotentialFileReaderTest, pair_identical) { +TEST_F(EIMPotentialFileReaderTest, pair_identical) +{ ::testing::internal::CaptureStdout(); EIMPotentialFileReader reader(lmp, "ffield.eim"); ::testing::internal::GetCapturedStdout(); diff --git a/unittest/formats/test_potential_file_reader.cpp b/unittest/formats/test_potential_file_reader.cpp index 3447dbb73f..dde2b27353 100644 --- a/unittest/formats/test_potential_file_reader.cpp +++ b/unittest/formats/test_potential_file_reader.cpp @@ -11,23 +11,23 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "gmock/gmock.h" -#include "gtest/gtest.h" -#include "potential_file_reader.h" -#include "lammps.h" -#include "utils.h" -#include "MANYBODY/pair_sw.h" #include "MANYBODY/pair_comb.h" #include "MANYBODY/pair_comb3.h" +#include "MANYBODY/pair_eim.h" +#include "MANYBODY/pair_gw.h" +#include "MANYBODY/pair_gw_zbl.h" +#include "MANYBODY/pair_nb3b_harmonic.h" +#include "MANYBODY/pair_sw.h" #include "MANYBODY/pair_tersoff.h" #include "MANYBODY/pair_tersoff_mod.h" #include "MANYBODY/pair_tersoff_mod_c.h" #include "MANYBODY/pair_tersoff_zbl.h" -#include "MANYBODY/pair_gw.h" -#include "MANYBODY/pair_gw_zbl.h" -#include "MANYBODY/pair_nb3b_harmonic.h" #include "MANYBODY/pair_vashishta.h" -#include "MANYBODY/pair_eim.h" +#include "lammps.h" +#include "potential_file_reader.h" +#include "utils.h" +#include "gmock/gmock.h" +#include "gtest/gtest.h" #include @@ -47,25 +47,29 @@ const int LAMMPS_NS::PairVashishta::NPARAMS_PER_LINE; class PotentialFileReaderTest : public ::testing::Test { protected: - LAMMPS * lmp; + LAMMPS *lmp; - void SetUp() override { - const char *args[] = {"PotentialFileReaderTest", "-log", "none", "-echo", "screen", "-nocite" }; + void SetUp() override + { + const char *args[] = { + "PotentialFileReaderTest", "-log", "none", "-echo", "screen", "-nocite"}; char **argv = (char **)args; - int argc = sizeof(args)/sizeof(char *); + int argc = sizeof(args) / sizeof(char *); ::testing::internal::CaptureStdout(); lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD); ::testing::internal::GetCapturedStdout(); } - void TearDown() override { + void TearDown() override + { ::testing::internal::CaptureStdout(); delete lmp; ::testing::internal::GetCapturedStdout(); } }; -TEST_F(PotentialFileReaderTest, Si) { +TEST_F(PotentialFileReaderTest, Si) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "Si.sw", "Stillinger-Weber"); ::testing::internal::GetCapturedStdout(); @@ -74,7 +78,8 @@ TEST_F(PotentialFileReaderTest, Si) { ASSERT_EQ(utils::count_words(line), PairSW::NPARAMS_PER_LINE); } -TEST_F(PotentialFileReaderTest, Comb) { +TEST_F(PotentialFileReaderTest, Comb) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "ffield.comb", "COMB"); ::testing::internal::GetCapturedStdout(); @@ -83,7 +88,8 @@ TEST_F(PotentialFileReaderTest, Comb) { ASSERT_EQ(utils::count_words(line), PairComb::NPARAMS_PER_LINE); } -TEST_F(PotentialFileReaderTest, Comb3) { +TEST_F(PotentialFileReaderTest, Comb3) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "ffield.comb3", "COMB3"); ::testing::internal::GetCapturedStdout(); @@ -92,7 +98,8 @@ TEST_F(PotentialFileReaderTest, Comb3) { ASSERT_EQ(utils::count_words(line), PairComb3::NPARAMS_PER_LINE); } -TEST_F(PotentialFileReaderTest, Tersoff) { +TEST_F(PotentialFileReaderTest, Tersoff) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "Si.tersoff", "Tersoff"); ::testing::internal::GetCapturedStdout(); @@ -101,7 +108,8 @@ TEST_F(PotentialFileReaderTest, Tersoff) { ASSERT_EQ(utils::count_words(line), PairTersoff::NPARAMS_PER_LINE); } -TEST_F(PotentialFileReaderTest, TersoffMod) { +TEST_F(PotentialFileReaderTest, TersoffMod) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "Si.tersoff.mod", "Tersoff/Mod"); ::testing::internal::GetCapturedStdout(); @@ -110,7 +118,8 @@ TEST_F(PotentialFileReaderTest, TersoffMod) { ASSERT_EQ(utils::count_words(line), PairTersoffMOD::NPARAMS_PER_LINE); } -TEST_F(PotentialFileReaderTest, TersoffModC) { +TEST_F(PotentialFileReaderTest, TersoffModC) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "Si.tersoff.modc", "Tersoff/ModC"); ::testing::internal::GetCapturedStdout(); @@ -119,7 +128,8 @@ TEST_F(PotentialFileReaderTest, TersoffModC) { ASSERT_EQ(utils::count_words(line), PairTersoffMODC::NPARAMS_PER_LINE); } -TEST_F(PotentialFileReaderTest, TersoffZBL) { +TEST_F(PotentialFileReaderTest, TersoffZBL) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "SiC.tersoff.zbl", "Tersoff/ZBL"); ::testing::internal::GetCapturedStdout(); @@ -128,7 +138,8 @@ TEST_F(PotentialFileReaderTest, TersoffZBL) { ASSERT_EQ(utils::count_words(line), PairTersoffZBL::NPARAMS_PER_LINE); } -TEST_F(PotentialFileReaderTest, GW) { +TEST_F(PotentialFileReaderTest, GW) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "SiC.gw", "GW"); ::testing::internal::GetCapturedStdout(); @@ -137,7 +148,8 @@ TEST_F(PotentialFileReaderTest, GW) { ASSERT_EQ(utils::count_words(line), PairGW::NPARAMS_PER_LINE); } -TEST_F(PotentialFileReaderTest, GWZBL) { +TEST_F(PotentialFileReaderTest, GWZBL) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "SiC.gw.zbl", "GW/ZBL"); ::testing::internal::GetCapturedStdout(); @@ -146,7 +158,8 @@ TEST_F(PotentialFileReaderTest, GWZBL) { ASSERT_EQ(utils::count_words(line), PairGWZBL::NPARAMS_PER_LINE); } -TEST_F(PotentialFileReaderTest, Nb3bHarmonic) { +TEST_F(PotentialFileReaderTest, Nb3bHarmonic) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "MOH.nb3b.harmonic", "NB3B Harmonic"); ::testing::internal::GetCapturedStdout(); @@ -155,7 +168,8 @@ TEST_F(PotentialFileReaderTest, Nb3bHarmonic) { ASSERT_EQ(utils::count_words(line), PairNb3bHarmonic::NPARAMS_PER_LINE); } -TEST_F(PotentialFileReaderTest, Vashishta) { +TEST_F(PotentialFileReaderTest, Vashishta) +{ ::testing::internal::CaptureStdout(); PotentialFileReader reader(lmp, "SiC.vashishta", "Vashishta"); ::testing::internal::GetCapturedStdout(); diff --git a/unittest/utils/test_fmtlib.cpp b/unittest/utils/test_fmtlib.cpp index 0b1ec16368..6d02707c4d 100644 --- a/unittest/utils/test_fmtlib.cpp +++ b/unittest/utils/test_fmtlib.cpp @@ -11,114 +11,127 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "lmptype.h" -#include "gtest/gtest.h" -#include "gmock/gmock.h" #include "fmt/format.h" -#include +#include "lmptype.h" +#include "gmock/gmock.h" +#include "gtest/gtest.h" #include +#include using namespace LAMMPS_NS; using ::testing::Eq; // this tests a subset of {fmt} that is most relevant to LAMMPS -TEST(FmtLib, insert_string) { +TEST(FmtLib, insert_string) +{ const char val[] = "word"; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word word")); } -TEST(FmtLib, insert_int) { +TEST(FmtLib, insert_int) +{ const int val = 333; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word 333")); } -TEST(FmtLib, insert_neg_int) { +TEST(FmtLib, insert_neg_int) +{ const int val = -333; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word -333")); } -TEST(FmtLib, insert_bigint) { +TEST(FmtLib, insert_bigint) +{ #if defined(LAMMPS_BIGBIG) || defined(LAMMPS_SMALLBIG) const bigint val = 9945234592L; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word 9945234592")); #else GTEST_SKIP(); #endif } -TEST(FmtLib, insert_neg_bigint) { +TEST(FmtLib, insert_neg_bigint) +{ #if defined(LAMMPS_BIGBIG) || defined(LAMMPS_SMALLBIG) const bigint val = -9945234592L; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word -9945234592")); #else GTEST_SKIP(); #endif } -TEST(FmtLib, insert_tagint) { +TEST(FmtLib, insert_tagint) +{ #if defined(LAMMPS_BIGBIG) const tagint val = 9945234592L; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word 9945234592")); #else GTEST_SKIP(); #endif } -TEST(FmtLib, insert_neg_tagint) { +TEST(FmtLib, insert_neg_tagint) +{ #if defined(LAMMPS_BIGBIG) const tagint val = -9945234592L; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word -9945234592")); #else GTEST_SKIP(); #endif } -TEST(FmtLib, insert_imageint) { +TEST(FmtLib, insert_imageint) +{ #if defined(LAMMPS_BIGBIG) const imageint val = 9945234592L; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word 9945234592")); #else GTEST_SKIP(); #endif } -TEST(FmtLib, insert_neg_imageint) { +TEST(FmtLib, insert_neg_imageint) +{ #if defined(LAMMPS_BIGBIG) const imageint val = -9945234592L; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word -9945234592")); #else GTEST_SKIP(); #endif } -TEST(FmtLib, insert_double) { +TEST(FmtLib, insert_double) +{ const double val = 1.5; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word 1.5")); } -TEST(FmtLib, insert_neg_double) { +TEST(FmtLib, insert_neg_double) +{ const double val = -1.5; - auto text = fmt::format("word {}",val); + auto text = fmt::format("word {}", val); ASSERT_THAT(text, Eq("word -1.5")); } -TEST(FmtLib, int_for_double) { +TEST(FmtLib, int_for_double) +{ const double val = -1.5; - ASSERT_THROW(fmt::format("word {:d}",val),std::exception); + ASSERT_THROW(fmt::format("word {:d}", val), std::exception); } -TEST(FmtLib, double_for_int) { +TEST(FmtLib, double_for_int) +{ const int val = 15; - ASSERT_THROW(fmt::format("word {:g}",val),std::exception); + ASSERT_THROW(fmt::format("word {:g}", val), std::exception); } diff --git a/unittest/utils/test_tokenizer.cpp b/unittest/utils/test_tokenizer.cpp index 903f660959..afe823acf8 100644 --- a/unittest/utils/test_tokenizer.cpp +++ b/unittest/utils/test_tokenizer.cpp @@ -11,100 +11,117 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "gtest/gtest.h" -#include "gmock/gmock.h" #include "tokenizer.h" +#include "gmock/gmock.h" +#include "gtest/gtest.h" using namespace LAMMPS_NS; using ::testing::Eq; -TEST(Tokenizer, empty_string) { +TEST(Tokenizer, empty_string) +{ Tokenizer t("", " "); ASSERT_EQ(t.count(), 0); } -TEST(Tokenizer, whitespace_only) { +TEST(Tokenizer, whitespace_only) +{ Tokenizer t(" ", " "); ASSERT_EQ(t.count(), 0); } -TEST(Tokenizer, single_word) { +TEST(Tokenizer, single_word) +{ Tokenizer t("test", " "); ASSERT_EQ(t.count(), 1); } -TEST(Tokenizer, two_words) { +TEST(Tokenizer, two_words) +{ Tokenizer t("test word", " "); ASSERT_EQ(t.count(), 2); } -TEST(Tokenizer, prefix_separators) { +TEST(Tokenizer, prefix_separators) +{ Tokenizer t(" test word", " "); ASSERT_EQ(t.count(), 2); } -TEST(Tokenizer, postfix_separators) { +TEST(Tokenizer, postfix_separators) +{ Tokenizer t("test word ", " "); ASSERT_EQ(t.count(), 2); } -TEST(Tokenizer, iterate_words) { +TEST(Tokenizer, iterate_words) +{ Tokenizer t(" test word ", " "); ASSERT_THAT(t.next(), Eq("test")); ASSERT_THAT(t.next(), Eq("word")); ASSERT_EQ(t.count(), 2); } -TEST(Tokenizer, default_separators) { +TEST(Tokenizer, default_separators) +{ Tokenizer t(" \r\n test \t word \f"); ASSERT_THAT(t.next(), Eq("test")); ASSERT_THAT(t.next(), Eq("word")); ASSERT_EQ(t.count(), 2); } -TEST(Tokenizer, as_vector) { +TEST(Tokenizer, as_vector) +{ Tokenizer t(" \r\n test \t word \f"); std::vector list = t.as_vector(); ASSERT_THAT(list[0], Eq("test")); ASSERT_THAT(list[1], Eq("word")); } -TEST(ValueTokenizer, empty_string) { +TEST(ValueTokenizer, empty_string) +{ ValueTokenizer values(""); ASSERT_FALSE(values.has_next()); } -TEST(ValueTokenizer, bad_integer) { +TEST(ValueTokenizer, bad_integer) +{ ValueTokenizer values("f10"); ASSERT_THROW(values.next_int(), InvalidIntegerException); } -TEST(ValueTokenizer, bad_double) { +TEST(ValueTokenizer, bad_double) +{ ValueTokenizer values("1a.0"); ASSERT_THROW(values.next_double(), InvalidFloatException); } -TEST(ValueTokenizer, valid_int) { +TEST(ValueTokenizer, valid_int) +{ ValueTokenizer values("10"); ASSERT_EQ(values.next_int(), 10); } -TEST(ValueTokenizer, valid_tagint) { +TEST(ValueTokenizer, valid_tagint) +{ ValueTokenizer values("42"); ASSERT_EQ(values.next_tagint(), 42); } -TEST(ValueTokenizer, valid_bigint) { +TEST(ValueTokenizer, valid_bigint) +{ ValueTokenizer values("42"); ASSERT_EQ(values.next_bigint(), 42); } -TEST(ValueTokenizer, valid_double) { +TEST(ValueTokenizer, valid_double) +{ ValueTokenizer values("3.14"); ASSERT_DOUBLE_EQ(values.next_double(), 3.14); } -TEST(ValueTokenizer, valid_double_with_exponential) { +TEST(ValueTokenizer, valid_double_with_exponential) +{ ValueTokenizer values("3.14e22"); ASSERT_DOUBLE_EQ(values.next_double(), 3.14e22); } diff --git a/unittest/utils/test_utils.cpp b/unittest/utils/test_utils.cpp index 317c77cf3f..ec29b58ccb 100644 --- a/unittest/utils/test_utils.cpp +++ b/unittest/utils/test_utils.cpp @@ -11,215 +11,265 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "gtest/gtest.h" -#include "gmock/gmock.h" #include "utils.h" -#include +#include "gmock/gmock.h" +#include "gtest/gtest.h" #include #include #include +#include using namespace LAMMPS_NS; using ::testing::Eq; -TEST(Utils, trim_comment) { +TEST(Utils, trim_comment) +{ auto trimmed = utils::trim_comment("some text # comment"); ASSERT_THAT(trimmed, Eq("some text ")); } -TEST(Utils, count_words) { +TEST(Utils, count_words) +{ ASSERT_EQ(utils::count_words("some text # comment"), 4); } -TEST(Utils, count_words_non_default) { +TEST(Utils, count_words_non_default) +{ ASSERT_EQ(utils::count_words("some text # comment", " #"), 3); } -TEST(Utils, trim_and_count_words) { +TEST(Utils, trim_and_count_words) +{ ASSERT_EQ(utils::trim_and_count_words("some text # comment"), 2); } -TEST(Utils, count_words_with_extra_spaces) { +TEST(Utils, count_words_with_extra_spaces) +{ ASSERT_EQ(utils::count_words(" some text # comment "), 4); } -TEST(Utils, valid_integer1) { +TEST(Utils, valid_integer1) +{ ASSERT_TRUE(utils::is_integer("10")); } -TEST(Utils, valid_integer2) { +TEST(Utils, valid_integer2) +{ ASSERT_TRUE(utils::is_integer("-10")); } -TEST(Utils, valid_integer3) { +TEST(Utils, valid_integer3) +{ ASSERT_TRUE(utils::is_integer("+10")); } -TEST(Utils, valid_double1) { +TEST(Utils, valid_double1) +{ ASSERT_TRUE(utils::is_double("10.0")); } -TEST(Utils, valid_double2) { +TEST(Utils, valid_double2) +{ ASSERT_TRUE(utils::is_double("1.")); } -TEST(Utils, valid_double3) { +TEST(Utils, valid_double3) +{ ASSERT_TRUE(utils::is_double(".0")); } -TEST(Utils, valid_double4) { +TEST(Utils, valid_double4) +{ ASSERT_TRUE(utils::is_double("-10.0")); } -TEST(Utils, valid_double5) { +TEST(Utils, valid_double5) +{ ASSERT_TRUE(utils::is_double("-1.")); } -TEST(Utils, valid_double6) { +TEST(Utils, valid_double6) +{ ASSERT_TRUE(utils::is_double("-.0")); } -TEST(Utils, valid_double7) { +TEST(Utils, valid_double7) +{ ASSERT_TRUE(utils::is_double("+10.0")); } -TEST(Utils, valid_double8) { +TEST(Utils, valid_double8) +{ ASSERT_TRUE(utils::is_double("+1.")); } -TEST(Utils, valid_double9) { +TEST(Utils, valid_double9) +{ ASSERT_TRUE(utils::is_double("+.0")); } -TEST(Utils, empty_not_an_integer) { +TEST(Utils, empty_not_an_integer) +{ ASSERT_FALSE(utils::is_integer("")); } -TEST(Utils, empty_not_a_double) { +TEST(Utils, empty_not_a_double) +{ ASSERT_FALSE(utils::is_double("")); } -TEST(Utils, text_not_an_integer) { +TEST(Utils, text_not_an_integer) +{ ASSERT_FALSE(utils::is_integer("one")); } -TEST(Utils, text_not_a_double) { +TEST(Utils, text_not_a_double) +{ ASSERT_FALSE(utils::is_double("half")); } -TEST(Utils, double_not_an_integer1) { +TEST(Utils, double_not_an_integer1) +{ ASSERT_FALSE(utils::is_integer("10.0")); } -TEST(Utils, double_not_an_integer2) { +TEST(Utils, double_not_an_integer2) +{ ASSERT_FALSE(utils::is_integer(".0")); } -TEST(Utils, double_not_an_integer3) { +TEST(Utils, double_not_an_integer3) +{ ASSERT_FALSE(utils::is_integer("1.")); } -TEST(Utils, integer_is_double1) { +TEST(Utils, integer_is_double1) +{ ASSERT_TRUE(utils::is_double("10")); } -TEST(Utils, integer_is_double2) { +TEST(Utils, integer_is_double2) +{ ASSERT_TRUE(utils::is_double("-10")); } -TEST(Utils, is_double_with_exponential) { +TEST(Utils, is_double_with_exponential) +{ ASSERT_TRUE(utils::is_double("+1e02")); } -TEST(Utils, is_double_with_neg_exponential) { +TEST(Utils, is_double_with_neg_exponential) +{ ASSERT_TRUE(utils::is_double("1.0e-22")); } -TEST(Utils, is_double_with_pos_exponential) { +TEST(Utils, is_double_with_pos_exponential) +{ ASSERT_TRUE(utils::is_double(".1e+22")); } -TEST(Utils, signed_double_and_exponential) { +TEST(Utils, signed_double_and_exponential) +{ ASSERT_TRUE(utils::is_double("-10E-22")); } -TEST(Utils, is_double_with_d_exponential) { +TEST(Utils, is_double_with_d_exponential) +{ ASSERT_FALSE(utils::is_double("10d22")); } -TEST(Utils, is_double_with_neg_d_exponential) { +TEST(Utils, is_double_with_neg_d_exponential) +{ ASSERT_FALSE(utils::is_double("10d-22")); } -TEST(Utils, signed_double_and_d_exponential) { +TEST(Utils, signed_double_and_d_exponential) +{ ASSERT_FALSE(utils::is_double("-10D-22")); } -TEST(Utils, strmatch_beg) { - ASSERT_TRUE(utils::strmatch("rigid/small/omp","^rigid")); +TEST(Utils, strmatch_beg) +{ + ASSERT_TRUE(utils::strmatch("rigid/small/omp", "^rigid")); } -TEST(Utils, strmatch_mid1) { - ASSERT_TRUE(utils::strmatch("rigid/small/omp","small")); +TEST(Utils, strmatch_mid1) +{ + ASSERT_TRUE(utils::strmatch("rigid/small/omp", "small")); } -TEST(Utils, strmatch_mid2) { - ASSERT_TRUE(utils::strmatch("rigid/small/omp","omp")); +TEST(Utils, strmatch_mid2) +{ + ASSERT_TRUE(utils::strmatch("rigid/small/omp", "omp")); } -TEST(Utils, strmatch_end) { - ASSERT_TRUE(utils::strmatch("rigid/small/omp","/omp$")); +TEST(Utils, strmatch_end) +{ + ASSERT_TRUE(utils::strmatch("rigid/small/omp", "/omp$")); } -TEST(Utils, no_strmatch_beg) { - ASSERT_FALSE(utils::strmatch("rigid/small/omp","^small")); +TEST(Utils, no_strmatch_beg) +{ + ASSERT_FALSE(utils::strmatch("rigid/small/omp", "^small")); } -TEST(Utils, no_strmatch_mid) { - ASSERT_FALSE(utils::strmatch("rigid/small/omp","none")); +TEST(Utils, no_strmatch_mid) +{ + ASSERT_FALSE(utils::strmatch("rigid/small/omp", "none")); } -TEST(Utils, no_strmatch_end) { - ASSERT_FALSE(utils::strmatch("rigid/small/omp","/opt$")); +TEST(Utils, no_strmatch_end) +{ + ASSERT_FALSE(utils::strmatch("rigid/small/omp", "/opt$")); } -TEST(Utils, strmatch_whole_line) { - ASSERT_TRUE(utils::strmatch("ITEM: UNITS\n","^\\s*ITEM: UNITS\\s*$")); +TEST(Utils, strmatch_whole_line) +{ + ASSERT_TRUE(utils::strmatch("ITEM: UNITS\n", "^\\s*ITEM: UNITS\\s*$")); } -TEST(Utils, no_strmatch_whole_line) { - ASSERT_FALSE(utils::strmatch("ITEM: UNITS\n","^\\s*ITEM: UNIT\\s*$")); +TEST(Utils, no_strmatch_whole_line) +{ + ASSERT_FALSE(utils::strmatch("ITEM: UNITS\n", "^\\s*ITEM: UNIT\\s*$")); } -TEST(Utils, strmatch_integer_in_line) { - ASSERT_TRUE(utils::strmatch(" 5 angles\n","^\\s*\\d+\\s+angles\\s")); +TEST(Utils, strmatch_integer_in_line) +{ + ASSERT_TRUE(utils::strmatch(" 5 angles\n", "^\\s*\\d+\\s+angles\\s")); } -TEST(Utils, strmatch_float_in_line) { - ASSERT_TRUE(utils::strmatch(" 5.0 angles\n","^\\s*\\f+\\s+angles\\s")); +TEST(Utils, strmatch_float_in_line) +{ + ASSERT_TRUE(utils::strmatch(" 5.0 angles\n", "^\\s*\\f+\\s+angles\\s")); } -TEST(Utils, strmatch_int_as_float_in_line) { - ASSERT_TRUE(utils::strmatch(" 5 angles\n","^\\s*\\f+\\s+angles\\s")); +TEST(Utils, strmatch_int_as_float_in_line) +{ + ASSERT_TRUE(utils::strmatch(" 5 angles\n", "^\\s*\\f+\\s+angles\\s")); } -TEST(Utils, strmatch_char_range) { - ASSERT_TRUE(utils::strmatch("rigid","^[ip-s]+gid")); +TEST(Utils, strmatch_char_range) +{ + ASSERT_TRUE(utils::strmatch("rigid", "^[ip-s]+gid")); } -TEST(Utils, strmatch_opt_range) { - ASSERT_TRUE(utils::strmatch("rigid","^[0-9]*[p-s]igid")); +TEST(Utils, strmatch_opt_range) +{ + ASSERT_TRUE(utils::strmatch("rigid", "^[0-9]*[p-s]igid")); } -TEST(Utils, path_join) { +TEST(Utils, path_join) +{ #if defined(_WIN32) - ASSERT_THAT(utils::path_join("c:\\parent\\folder", "filename"), Eq("c:\\parent\\folder\\filename")); + ASSERT_THAT(utils::path_join("c:\\parent\\folder", "filename"), + Eq("c:\\parent\\folder\\filename")); #else ASSERT_THAT(utils::path_join("/parent/folder", "filename"), Eq("/parent/folder/filename")); #endif } -TEST(Utils, path_basename) { +TEST(Utils, path_basename) +{ #if defined(_WIN32) ASSERT_THAT(utils::path_basename("c:\\parent\\folder\\filename"), Eq("filename")); #else @@ -227,7 +277,8 @@ TEST(Utils, path_basename) { #endif } -TEST(Utils, getsyserror) { +TEST(Utils, getsyserror) +{ #if defined(__linux__) errno = ENOENT; std::string errmesg = utils::getsyserror(); @@ -237,24 +288,25 @@ TEST(Utils, getsyserror) { #endif } -TEST(Utils, potential_file) { +TEST(Utils, potential_file) +{ FILE *fp; - fp = fopen("ctest.txt","w"); - ASSERT_NE(fp,nullptr); - fputs("# DATE: 2020-02-20 CONTRIBUTOR: Nessuno\n",fp); + fp = fopen("ctest.txt", "w"); + ASSERT_NE(fp, nullptr); + fputs("# DATE: 2020-02-20 CONTRIBUTOR: Nessuno\n", fp); fclose(fp); EXPECT_TRUE(utils::file_is_readable("ctest.txt")); EXPECT_FALSE(utils::file_is_readable("no_such_file.txt")); - EXPECT_THAT(utils::get_potential_file_path("ctest.txt"),Eq("ctest.txt")); + EXPECT_THAT(utils::get_potential_file_path("ctest.txt"), Eq("ctest.txt")); const char *folder = getenv("LAMMPS_POTENTIALS"); if (folder != nullptr) { - std::string path=utils::path_join(folder,"Cu_u3.eam"); - EXPECT_THAT(utils::get_potential_file_path("Cu_u3.eam"),Eq(path)); + std::string path = utils::path_join(folder, "Cu_u3.eam"); + EXPECT_THAT(utils::get_potential_file_path("Cu_u3.eam"), Eq(path)); } - EXPECT_THAT(utils::get_potential_date("ctest.txt","Test"),Eq("2020-02-20")); + EXPECT_THAT(utils::get_potential_date("ctest.txt", "Test"), Eq("2020-02-20")); remove("ctest.txt"); }