ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

apply clang-format

Browse Source
This commit is contained in:
Axel Kohlmeyer
2022-10-03 23:19:59 -04:00
parent 3374435281
commit 647c5e3572
8 changed files with 563 additions and 568 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
unittest/fortran/wrap_box.cpp
View File

@ -55,10 +55,10 @@ TEST_F(LAMMPS_commands, get_thermo)
EXPECT_DOUBLE_EQ(f_lammps_extract_box_zhi(), 2.0); EXPECT_DOUBLE_EQ(f_lammps_extract_box_zhi(), 2.0);
f_lammps_delete_everything(); f_lammps_delete_everything();
f_lammps_reset_box_2x(); f_lammps_reset_box_2x();
EXPECT_DOUBLE_EQ(f_lammps_extract_box_xlo(),-1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_box_xlo(), -1.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_box_xhi(), 3.0); EXPECT_DOUBLE_EQ(f_lammps_extract_box_xhi(), 3.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_box_ylo(),-1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_box_ylo(), -1.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_box_yhi(), 3.0); EXPECT_DOUBLE_EQ(f_lammps_extract_box_yhi(), 3.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_box_zlo(),-1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_box_zlo(), -1.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_box_zhi(), 3.0); EXPECT_DOUBLE_EQ(f_lammps_extract_box_zhi(), 3.0);
}; };

100
unittest/fortran/wrap_extract_atom.cpp
View File

@ -3,10 +3,10 @@
#include "lammps.h" #include "lammps.h"
#include "library.h" #include "library.h"
#include <cstdint>
#include <cstdlib>
#include <mpi.h> #include <mpi.h>
#include <string> #include <string>
#include <cstdlib>
#include <cstdint>
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -20,8 +20,8 @@ int f_lammps_extract_atom_tag_int(int);
int64_t f_lammps_extract_atom_tag_int64(int64_t); int64_t f_lammps_extract_atom_tag_int64(int64_t);
int f_lammps_extract_atom_type(int); int f_lammps_extract_atom_type(int);
int f_lammps_extract_atom_mask(int); int f_lammps_extract_atom_mask(int);
void f_lammps_extract_atom_x(int,double*); void f_lammps_extract_atom_x(int, double *);
void f_lammps_extract_atom_v(int,double*); void f_lammps_extract_atom_v(int, double *);
} }
class LAMMPS_extract_atom : public ::testing::Test { class LAMMPS_extract_atom : public ::testing::Test {
@ -49,72 +49,72 @@ protected:
TEST_F(LAMMPS_extract_atom, mass) TEST_F(LAMMPS_extract_atom, mass)
{ {
f_lammps_setup_extract_atom(); f_lammps_setup_extract_atom();
EXPECT_DOUBLE_EQ(f_lammps_extract_atom_mass(), 2.0); EXPECT_DOUBLE_EQ(f_lammps_extract_atom_mass(), 2.0);
}; };
TEST_F(LAMMPS_extract_atom, tag) TEST_F(LAMMPS_extract_atom, tag)
{ {
f_lammps_setup_extract_atom(); f_lammps_setup_extract_atom();
#ifdef LAMMPS_BIGBIG #if defined(LAMMPS_BIGBIG)
EXPECT_EQ(f_lammps_extract_atom_tag_int64(1l), 1l); EXPECT_EQ(f_lammps_extract_atom_tag_int64(1l), 1l);
EXPECT_EQ(f_lammps_extract_atom_tag_int64(2l), 2l); EXPECT_EQ(f_lammps_extract_atom_tag_int64(2l), 2l);
#else #else
EXPECT_EQ(f_lammps_extract_atom_tag_int(1), 1); EXPECT_EQ(f_lammps_extract_atom_tag_int(1), 1);
EXPECT_EQ(f_lammps_extract_atom_tag_int(2), 2); EXPECT_EQ(f_lammps_extract_atom_tag_int(2), 2);
#endif #endif
}; };
TEST_F(LAMMPS_extract_atom, type) TEST_F(LAMMPS_extract_atom, type)
{ {
f_lammps_setup_extract_atom(); f_lammps_setup_extract_atom();
EXPECT_EQ(f_lammps_extract_atom_type(1), 1); EXPECT_EQ(f_lammps_extract_atom_type(1), 1);
EXPECT_EQ(f_lammps_extract_atom_type(2), 1); EXPECT_EQ(f_lammps_extract_atom_type(2), 1);
}; };
TEST_F(LAMMPS_extract_atom, mask) TEST_F(LAMMPS_extract_atom, mask)
{ {
f_lammps_setup_extract_atom(); f_lammps_setup_extract_atom();
EXPECT_EQ(f_lammps_extract_atom_mask(1), 1); EXPECT_EQ(f_lammps_extract_atom_mask(1), 1);
EXPECT_EQ(f_lammps_extract_atom_mask(2), 1); EXPECT_EQ(f_lammps_extract_atom_mask(2), 1);
lammps_command(lmp, "group 1 id 1"); lammps_command(lmp, "group 1 id 1");
lammps_command(lmp, "group 2 id 2"); lammps_command(lmp, "group 2 id 2");
EXPECT_EQ(f_lammps_extract_atom_mask(1), 3); EXPECT_EQ(f_lammps_extract_atom_mask(1), 3);
EXPECT_EQ(f_lammps_extract_atom_mask(2), 5); EXPECT_EQ(f_lammps_extract_atom_mask(2), 5);
}; };
TEST_F(LAMMPS_extract_atom, x) TEST_F(LAMMPS_extract_atom, x)
{ {
f_lammps_setup_extract_atom(); f_lammps_setup_extract_atom();
double x1[3]; double x1[3];
double x2[3]; double x2[3];
f_lammps_extract_atom_x(1, x1); f_lammps_extract_atom_x(1, x1);
EXPECT_DOUBLE_EQ(x1[0], 1.0); EXPECT_DOUBLE_EQ(x1[0], 1.0);
EXPECT_DOUBLE_EQ(x1[1], 1.0); EXPECT_DOUBLE_EQ(x1[1], 1.0);
EXPECT_DOUBLE_EQ(x1[2], 1.5); EXPECT_DOUBLE_EQ(x1[2], 1.5);
f_lammps_extract_atom_x(2, x2); f_lammps_extract_atom_x(2, x2);
EXPECT_DOUBLE_EQ(x2[0], 0.2); EXPECT_DOUBLE_EQ(x2[0], 0.2);
EXPECT_DOUBLE_EQ(x2[1], 0.1); EXPECT_DOUBLE_EQ(x2[1], 0.1);
EXPECT_DOUBLE_EQ(x2[2], 0.1); EXPECT_DOUBLE_EQ(x2[2], 0.1);
} }
TEST_F(LAMMPS_extract_atom, v) TEST_F(LAMMPS_extract_atom, v)
{ {
f_lammps_setup_extract_atom(); f_lammps_setup_extract_atom();
double v1[3]; double v1[3];
double v2[3]; double v2[3];
f_lammps_extract_atom_v(1, v1); f_lammps_extract_atom_v(1, v1);
EXPECT_DOUBLE_EQ(v1[0], 0.0); EXPECT_DOUBLE_EQ(v1[0], 0.0);
EXPECT_DOUBLE_EQ(v1[1], 0.0); EXPECT_DOUBLE_EQ(v1[1], 0.0);
EXPECT_DOUBLE_EQ(v1[2], 0.0); EXPECT_DOUBLE_EQ(v1[2], 0.0);
f_lammps_extract_atom_v(2, v2); f_lammps_extract_atom_v(2, v2);
EXPECT_DOUBLE_EQ(v2[0], 0.0); EXPECT_DOUBLE_EQ(v2[0], 0.0);
EXPECT_DOUBLE_EQ(v2[1], 0.0); EXPECT_DOUBLE_EQ(v2[1], 0.0);
EXPECT_DOUBLE_EQ(v2[2], 0.0); EXPECT_DOUBLE_EQ(v2[2], 0.0);
lammps_command(lmp, "group one id 1"); lammps_command(lmp, "group one id 1");
lammps_command(lmp, "velocity one set 1 2 3"); lammps_command(lmp, "velocity one set 1 2 3");
f_lammps_extract_atom_v(1, v1); f_lammps_extract_atom_v(1, v1);
EXPECT_DOUBLE_EQ(v1[0], 1.0); EXPECT_DOUBLE_EQ(v1[0], 1.0);
EXPECT_DOUBLE_EQ(v1[1], 2.0); EXPECT_DOUBLE_EQ(v1[1], 2.0);
EXPECT_DOUBLE_EQ(v1[2], 3.0); EXPECT_DOUBLE_EQ(v1[2], 3.0);
} }

202
unittest/fortran/wrap_extract_compute.cpp
View File

@ -3,10 +3,10 @@
#include "lammps.h" #include "lammps.h"
#include "library.h" #include "library.h"
#include <cstdint>
#include <cstdlib>
#include <mpi.h> #include <mpi.h>
#include <string> #include <string>
#include <cstdlib>
#include <cstdint>
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -16,12 +16,12 @@ void *f_lammps_with_args();
void f_lammps_close(); void f_lammps_close();
void f_lammps_setup_extract_compute(); void f_lammps_setup_extract_compute();
double f_lammps_extract_compute_peratom_vector(int); double f_lammps_extract_compute_peratom_vector(int);
double f_lammps_extract_compute_peratom_array(int,int); double f_lammps_extract_compute_peratom_array(int, int);
double f_lammps_extract_compute_global_scalar(); double f_lammps_extract_compute_global_scalar();
double f_lammps_extract_compute_global_vector(int); double f_lammps_extract_compute_global_vector(int);
double f_lammps_extract_compute_global_array(int,int); double f_lammps_extract_compute_global_array(int, int);
double f_lammps_extract_compute_local_vector(int); double f_lammps_extract_compute_local_vector(int);
double f_lammps_extract_compute_local_array(int,int); double f_lammps_extract_compute_local_array(int, int);
} }
class LAMMPS_extract_compute : public ::testing::Test { class LAMMPS_extract_compute : public ::testing::Test {
@ -49,126 +49,120 @@ protected:
TEST_F(LAMMPS_extract_compute, peratom_vector) TEST_F(LAMMPS_extract_compute, peratom_vector)
{ {
f_lammps_setup_extract_compute(); f_lammps_setup_extract_compute();
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_vector(1), -0.599703102447981); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_vector(1), -0.599703102447981);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_vector(2), 391.817623795857); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_vector(2), 391.817623795857);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_vector(3), 391.430665759871); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_vector(3), 391.430665759871);
}; };
TEST_F(LAMMPS_extract_compute, peratom_array) TEST_F(LAMMPS_extract_compute, peratom_array)
{ {
f_lammps_setup_extract_compute(); f_lammps_setup_extract_compute();
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(1,1), 0.8837067009319107); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(1, 1), 0.8837067009319107);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(2,1), 0.3588584939803668); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(2, 1), 0.3588584939803668);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(3,1), 1.2799807127711049); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(3, 1), 1.2799807127711049);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(4,1), 0.20477632346642258); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(4, 1), 0.20477632346642258);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(5,1), 0.400429511840588); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(5, 1), 0.400429511840588);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(6,1), 0.673995757699694); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(6, 1), 0.673995757699694);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(1,2), -1070.0291234709418); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(1, 2), -1070.0291234709418);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(2,2), -1903.651817128683); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(2, 2), -1903.651817128683);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(3,2), -1903.5121520875714); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(3, 2), -1903.5121520875714);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(4,2), -1427.867483013); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(4, 2), -1427.867483013);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(5,2), -1427.8560790941347); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(5, 2), -1427.8560790941347);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(6,2), -1903.5971655908565); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_array(6, 2), -1903.5971655908565);
}; };
TEST_F(LAMMPS_extract_compute, global_scalar) TEST_F(LAMMPS_extract_compute, global_scalar)
{ {
f_lammps_setup_extract_compute(); f_lammps_setup_extract_compute();
double *scalar; double *scalar;
scalar = (double*) lammps_extract_compute(lmp, "totalpe", LMP_STYLE_GLOBAL, scalar = (double *)lammps_extract_compute(lmp, "totalpe", LMP_STYLE_GLOBAL, LMP_TYPE_SCALAR);
LMP_TYPE_SCALAR); // EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_scalar(), 782.64858645328);
//EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_scalar(), 782.64858645328); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_scalar(), *scalar);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_scalar(), *scalar);
}; };
TEST_F(LAMMPS_extract_compute, global_vector) TEST_F(LAMMPS_extract_compute, global_vector)
{ {
f_lammps_setup_extract_compute(); f_lammps_setup_extract_compute();
double *vector; double *vector;
vector = (double*) lammps_extract_compute(lmp, "COM", LMP_STYLE_GLOBAL, vector = (double *)lammps_extract_compute(lmp, "COM", LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR);
LMP_TYPE_VECTOR); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_vector(1), vector[0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_vector(1), vector[0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_vector(2), vector[1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_vector(2), vector[1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_vector(3), vector[2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_vector(3), vector[2]);
}; };
TEST_F(LAMMPS_extract_compute, global_array) TEST_F(LAMMPS_extract_compute, global_array)
{ {
f_lammps_setup_extract_compute(); f_lammps_setup_extract_compute();
double **array; double **array;
array = (double**) lammps_extract_compute(lmp, "RDF", LMP_STYLE_GLOBAL, array = (double **)lammps_extract_compute(lmp, "RDF", LMP_STYLE_GLOBAL, LMP_TYPE_ARRAY);
LMP_TYPE_ARRAY); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(1, 1), array[0][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(1,1), array[0][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(2, 1), array[0][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(2,1), array[0][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(1, 2), array[1][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(1,2), array[1][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(2, 2), array[1][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(2,2), array[1][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(1, 3), array[2][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(1,3), array[2][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(1, 4), array[3][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_array(1,4), array[3][0]);
}; };
TEST_F(LAMMPS_extract_compute, local_vector) TEST_F(LAMMPS_extract_compute, local_vector)
{ {
f_lammps_setup_extract_compute(); f_lammps_setup_extract_compute();
double *vector; double *vector;
vector = (double*) lammps_extract_compute(lmp, "pairdist", LMP_STYLE_LOCAL, vector = (double *)lammps_extract_compute(lmp, "pairdist", LMP_STYLE_LOCAL, LMP_TYPE_VECTOR);
LMP_TYPE_VECTOR); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(1), vector[0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(1), vector[0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(2), vector[1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(2), vector[1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(3), vector[2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(3), vector[2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(4), vector[3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(4), vector[3]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(5), vector[4]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(5), vector[4]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(6), vector[5]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(6), vector[5]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(7), vector[6]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(7), vector[6]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(8), vector[7]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(8), vector[7]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(9), vector[8]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(9), vector[8]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(10), vector[9]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(10), vector[9]);
}; };
TEST_F(LAMMPS_extract_compute, local_array) TEST_F(LAMMPS_extract_compute, local_array)
{ {
f_lammps_setup_extract_compute(); f_lammps_setup_extract_compute();
double **array; double **array;
array = (double**) lammps_extract_compute(lmp, "pairlocal", LMP_STYLE_LOCAL, array = (double **)lammps_extract_compute(lmp, "pairlocal", LMP_STYLE_LOCAL, LMP_TYPE_ARRAY);
LMP_TYPE_ARRAY); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1, 1), array[0][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1,1), array[0][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2, 1), array[0][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2,1), array[0][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3, 1), array[0][2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3,1), array[0][2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4, 1), array[0][3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4,1), array[0][3]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1, 2), array[1][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1,2), array[1][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2, 2), array[1][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2,2), array[1][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3, 2), array[1][2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3,2), array[1][2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4, 2), array[1][3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4,2), array[1][3]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1, 3), array[2][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1,3), array[2][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2, 3), array[2][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2,3), array[2][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3, 3), array[2][2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3,3), array[2][2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4, 3), array[2][3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4,3), array[2][3]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1, 4), array[3][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1,4), array[3][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2, 4), array[3][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2,4), array[3][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3, 4), array[3][2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3,4), array[3][2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4, 4), array[3][3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4,4), array[3][3]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1, 5), array[4][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1,5), array[4][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2, 5), array[4][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2,5), array[4][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3, 5), array[4][2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3,5), array[4][2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4, 5), array[4][3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4,5), array[4][3]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1, 6), array[5][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1,6), array[5][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2, 6), array[5][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2,6), array[5][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3, 6), array[5][2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3,6), array[5][2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4, 6), array[5][3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4,6), array[5][3]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1, 7), array[6][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1,7), array[6][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2, 7), array[6][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2,7), array[6][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3, 7), array[6][2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3,7), array[6][2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4, 7), array[6][3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4,7), array[6][3]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1, 8), array[7][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1,8), array[7][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2, 8), array[7][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2,8), array[7][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3, 8), array[7][2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3,8), array[7][2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4, 8), array[7][3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4,8), array[7][3]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1, 9), array[8][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1,9), array[8][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2, 9), array[8][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2,9), array[8][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3, 9), array[8][2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3,9), array[8][2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4, 9), array[8][3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4,9), array[8][3]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1, 10), array[9][0]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(1,10), array[9][0]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2, 10), array[9][1]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(2,10), array[9][1]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3, 10), array[9][2]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(3,10), array[9][2]); EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4, 10), array[9][3]);
EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_array(4,10), array[9][3]);
}; };

86
unittest/fortran/wrap_extract_fix.cpp
View File

@ -4,10 +4,10 @@
#include "lammps.h" #include "lammps.h"
#include "library.h" #include "library.h"
#include <cstdint>
#include <cstdlib>
#include <mpi.h> #include <mpi.h>
#include <string> #include <string>
#include <cstdlib>
#include <cstdint>
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -18,11 +18,11 @@ void f_lammps_close();
void f_lammps_setup_extract_fix(); void f_lammps_setup_extract_fix();
double f_lammps_extract_fix_global_scalar(); double f_lammps_extract_fix_global_scalar();
double f_lammps_extract_fix_global_vector(int); double f_lammps_extract_fix_global_vector(int);
double f_lammps_extract_fix_global_array(int,int); double f_lammps_extract_fix_global_array(int, int);
double f_lammps_extract_fix_peratom_vector(int); double f_lammps_extract_fix_peratom_vector(int);
double f_lammps_extract_fix_peratom_array(int,int); double f_lammps_extract_fix_peratom_array(int, int);
double f_lammps_extract_fix_local_vector(int); double f_lammps_extract_fix_local_vector(int);
double f_lammps_extract_fix_local_array(int,int); double f_lammps_extract_fix_local_array(int, int);
} }
class LAMMPS_extract_fix : public ::testing::Test { class LAMMPS_extract_fix : public ::testing::Test {
@ -50,58 +50,58 @@ protected:
TEST_F(LAMMPS_extract_fix, global_scalar) TEST_F(LAMMPS_extract_fix, global_scalar)
{ {
f_lammps_setup_extract_fix(); f_lammps_setup_extract_fix();
double *scalar = (double*) lammps_extract_fix(lmp, "recenter", double *scalar =
LMP_STYLE_GLOBAL, LMP_TYPE_SCALAR, -1, -1); (double *)lammps_extract_fix(lmp, "recenter", LMP_STYLE_GLOBAL, LMP_TYPE_SCALAR, -1, -1);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_scalar(), *scalar); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_scalar(), *scalar);
lammps_free(scalar); lammps_free(scalar);
}; };
TEST_F(LAMMPS_extract_fix, global_vector) TEST_F(LAMMPS_extract_fix, global_vector)
{ {
f_lammps_setup_extract_fix(); f_lammps_setup_extract_fix();
double *x = (double*) lammps_extract_fix(lmp, "recenter", double *x =
LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR, 0, -1); (double *)lammps_extract_fix(lmp, "recenter", LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR, 0, -1);
double *y = (double*) lammps_extract_fix(lmp, "recenter", double *y =
LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR, 1, -1); (double *)lammps_extract_fix(lmp, "recenter", LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR, 1, -1);
double *z = (double*) lammps_extract_fix(lmp, "recenter", double *z =
LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR, 2, -1); (double *)lammps_extract_fix(lmp, "recenter", LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR, 2, -1);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_vector(1), *x); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_vector(1), *x);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_vector(2), *y); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_vector(2), *y);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_vector(3), *z); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_vector(3), *z);
lammps_free(x); lammps_free(x);
lammps_free(y); lammps_free(y);
lammps_free(z); lammps_free(z);
}; };
TEST_F(LAMMPS_extract_fix, global_array) TEST_F(LAMMPS_extract_fix, global_array)
{ {
f_lammps_setup_extract_fix(); f_lammps_setup_extract_fix();
double natoms = lammps_get_natoms(lmp); double natoms = lammps_get_natoms(lmp);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_array(1,1), natoms); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_array(1, 1), natoms);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_array(1,2), natoms); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_array(1, 2), natoms);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_array(2,1), 0.0); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_array(2, 1), 0.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_array(2,2), 1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_array(2, 2), 1.0);
}; };
TEST_F(LAMMPS_extract_fix, peratom_vector) TEST_F(LAMMPS_extract_fix, peratom_vector)
{ {
f_lammps_setup_extract_fix(); f_lammps_setup_extract_fix();
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_vector(1), 1.5); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_vector(1), 1.5);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_vector(2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_vector(2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_vector(3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_vector(3), 0.5);
}; };
TEST_F(LAMMPS_extract_fix, peratom_array) TEST_F(LAMMPS_extract_fix, peratom_array)
{ {
f_lammps_setup_extract_fix(); f_lammps_setup_extract_fix();
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(1,1), 1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(1, 1), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(2,1), 1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(2, 1), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(3,1), 1.5); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(3, 1), 1.5);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(1,2), 0.2); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(1, 2), 0.2);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(2,2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(2, 2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(3,2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(3, 2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(1,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(1, 3), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(2,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(2, 3), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(3,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(3, 3), 0.5);
}; };

124
unittest/fortran/wrap_extract_global.cpp
View File

@ -3,10 +3,10 @@
#include "lammps.h" #include "lammps.h"
#include "library.h" #include "library.h"
#include <cstdint>
#include <cstdlib>
#include <mpi.h> #include <mpi.h>
#include <string> #include <string>
#include <cstdlib>
#include <cstdint>
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -78,100 +78,100 @@ protected:
TEST_F(LAMMPS_extract_global, units) TEST_F(LAMMPS_extract_global, units)
{ {
f_lammps_setup_extract_global(); f_lammps_setup_extract_global();
EXPECT_EQ(f_lammps_extract_global_units(), 1); EXPECT_EQ(f_lammps_extract_global_units(), 1);
}; };
TEST_F(LAMMPS_extract_global, ntimestep) TEST_F(LAMMPS_extract_global, ntimestep)
{ {
f_lammps_setup_extract_global(); f_lammps_setup_extract_global();
#ifdef LAMMPS_SMALLSMALL #ifdef LAMMPS_SMALLSMALL
EXPECT_EQ(f_lammps_extract_global_ntimestep(), 0); EXPECT_EQ(f_lammps_extract_global_ntimestep(), 0);
#else #else
EXPECT_EQ(f_lammps_extract_global_ntimestep_big(), 0l); EXPECT_EQ(f_lammps_extract_global_ntimestep_big(), 0l);
#endif #endif
}; };
TEST_F(LAMMPS_extract_global, dt) TEST_F(LAMMPS_extract_global, dt)
{ {
f_lammps_setup_extract_global(); f_lammps_setup_extract_global();
EXPECT_DOUBLE_EQ(f_lammps_extract_global_dt(), 0.005); EXPECT_DOUBLE_EQ(f_lammps_extract_global_dt(), 0.005);
}; };
TEST_F(LAMMPS_extract_global, boxprops) TEST_F(LAMMPS_extract_global, boxprops)
{ {
f_lammps_setup_extract_global(); f_lammps_setup_extract_global();
double boxlo[3], boxhi[3]; double boxlo[3], boxhi[3];
f_lammps_extract_global_boxlo(boxlo); f_lammps_extract_global_boxlo(boxlo);
EXPECT_DOUBLE_EQ(boxlo[0], 0.0); EXPECT_DOUBLE_EQ(boxlo[0], 0.0);
EXPECT_DOUBLE_EQ(boxlo[1], 0.0); EXPECT_DOUBLE_EQ(boxlo[1], 0.0);
EXPECT_DOUBLE_EQ(boxlo[2], 0.0); EXPECT_DOUBLE_EQ(boxlo[2], 0.0);
f_lammps_extract_global_boxhi(boxhi); f_lammps_extract_global_boxhi(boxhi);
EXPECT_DOUBLE_EQ(boxhi[0], 2.0); EXPECT_DOUBLE_EQ(boxhi[0], 2.0);
EXPECT_DOUBLE_EQ(boxhi[1], 3.0); EXPECT_DOUBLE_EQ(boxhi[1], 3.0);
EXPECT_DOUBLE_EQ(boxhi[2], 4.0); EXPECT_DOUBLE_EQ(boxhi[2], 4.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxxlo(), 0.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxxlo(), 0.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxxhi(), 2.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxxhi(), 2.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxylo(), 0.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxylo(), 0.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxyhi(), 3.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxyhi(), 3.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxzlo(), 0.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxzlo(), 0.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxzhi(), 4.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxzhi(), 4.0);
int periodicity[3]; int periodicity[3];
f_lammps_extract_global_periodicity(periodicity); f_lammps_extract_global_periodicity(periodicity);
EXPECT_EQ(periodicity[0], 1); EXPECT_EQ(periodicity[0], 1);
EXPECT_EQ(periodicity[1], 1); EXPECT_EQ(periodicity[1], 1);
EXPECT_EQ(periodicity[2], 1); EXPECT_EQ(periodicity[2], 1);
EXPECT_EQ(f_lammps_extract_global_triclinic(), 0); EXPECT_EQ(f_lammps_extract_global_triclinic(), 0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_xy(), 0.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_xy(), 0.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_yz(), 0.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_yz(), 0.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_xz(), 0.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_xz(), 0.0);
}; };
TEST_F(LAMMPS_extract_global, atomprops) TEST_F(LAMMPS_extract_global, atomprops)
{ {
f_lammps_setup_extract_global(); f_lammps_setup_extract_global();
#ifdef LAMMPS_SMALLSMALL #ifdef LAMMPS_SMALLSMALL
EXPECT_EQ(f_lammps_extract_global_natoms(), 2); EXPECT_EQ(f_lammps_extract_global_natoms(), 2);
EXPECT_EQ(f_lammps_extract_global_nbonds(), 0); EXPECT_EQ(f_lammps_extract_global_nbonds(), 0);
EXPECT_EQ(f_lammps_extract_global_nangles(), 0); EXPECT_EQ(f_lammps_extract_global_nangles(), 0);
EXPECT_EQ(f_lammps_extract_global_ndihedrals(), 0); EXPECT_EQ(f_lammps_extract_global_ndihedrals(), 0);
#else #else
EXPECT_EQ(f_lammps_extract_global_natoms_big(), 2l); EXPECT_EQ(f_lammps_extract_global_natoms_big(), 2l);
EXPECT_EQ(f_lammps_extract_global_nbonds_big(), 0l); EXPECT_EQ(f_lammps_extract_global_nbonds_big(), 0l);
EXPECT_EQ(f_lammps_extract_global_nangles_big(), 0l); EXPECT_EQ(f_lammps_extract_global_nangles_big(), 0l);
EXPECT_EQ(f_lammps_extract_global_ndihedrals_big(), 0l); EXPECT_EQ(f_lammps_extract_global_ndihedrals_big(), 0l);
#endif #endif
EXPECT_EQ(f_lammps_extract_global_ntypes(), 1); EXPECT_EQ(f_lammps_extract_global_ntypes(), 1);
EXPECT_EQ(f_lammps_extract_global_nlocal(), 2); EXPECT_EQ(f_lammps_extract_global_nlocal(), 2);
EXPECT_EQ(f_lammps_extract_global_nghost(), 41); EXPECT_EQ(f_lammps_extract_global_nghost(), 41);
EXPECT_EQ(f_lammps_extract_global_nmax(), 16384); EXPECT_EQ(f_lammps_extract_global_nmax(), 16384);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_boltz(), 1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_boltz(), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_hplanck(), 1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_hplanck(), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_angstrom(), 1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_angstrom(), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_global_femtosecond(), 1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_global_femtosecond(), 1.0);
}; };
TEST_F(LAMMPS_extract_global, fullprops) TEST_F(LAMMPS_extract_global, fullprops)
{ {
if (! lammps_has_style(lmp, "atom", "full")) GTEST_SKIP(); if (!lammps_has_style(lmp, "atom", "full")) GTEST_SKIP();
// This is not currently the world's most convincing test.... // This is not currently the world's most convincing test....
f_lammps_setup_full_extract_global(); f_lammps_setup_full_extract_global();
#ifdef LAMMPS_SMALLSMALL #ifdef LAMMPS_SMALLSMALL
EXPECT_EQ(f_lammps_extract_global_natoms(), 2); EXPECT_EQ(f_lammps_extract_global_natoms(), 2);
EXPECT_EQ(f_lammps_extract_global_nbonds(), 0); EXPECT_EQ(f_lammps_extract_global_nbonds(), 0);
EXPECT_EQ(f_lammps_extract_global_nangles(), 0); EXPECT_EQ(f_lammps_extract_global_nangles(), 0);
EXPECT_EQ(f_lammps_extract_global_ndihedrals(), 0); EXPECT_EQ(f_lammps_extract_global_ndihedrals(), 0);
#else #else
EXPECT_EQ(f_lammps_extract_global_natoms_big(), 2l); EXPECT_EQ(f_lammps_extract_global_natoms_big(), 2l);
EXPECT_EQ(f_lammps_extract_global_nbonds_big(), 0l); EXPECT_EQ(f_lammps_extract_global_nbonds_big(), 0l);
EXPECT_EQ(f_lammps_extract_global_nangles_big(), 0l); EXPECT_EQ(f_lammps_extract_global_nangles_big(), 0l);
EXPECT_EQ(f_lammps_extract_global_ndihedrals_big(), 0l); EXPECT_EQ(f_lammps_extract_global_ndihedrals_big(), 0l);
#endif #endif
} }

305
unittest/fortran/wrap_extract_variable.cpp
View File

@ -5,15 +5,14 @@
#include "library.h" #include "library.h"
#include "platform.h" #include "platform.h"
#include <mpi.h> #include <chrono>
#include <string> #include <cmath>
#include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstdint> #include <mpi.h>
#include <cmath> #include <string>
#include <chrono>
#include <thread> #include <thread>
#include <cmath>
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -22,21 +21,21 @@
// prototypes for Fortran reverse wrapper functions // prototypes for Fortran reverse wrapper functions
extern "C" { extern "C" {
void *f_lammps_with_c_args(int,char**); void *f_lammps_with_c_args(int, char **);
void f_lammps_close(); void f_lammps_close();
void f_lammps_setup_extract_variable(); void f_lammps_setup_extract_variable();
int f_lammps_extract_variable_index_1(); int f_lammps_extract_variable_index_1();
int f_lammps_extract_variable_index_2(); int f_lammps_extract_variable_index_2();
int f_lammps_extract_variable_loop(); int f_lammps_extract_variable_loop();
char* f_lammps_extract_variable_loop_pad(); char *f_lammps_extract_variable_loop_pad();
char* f_lammps_extract_variable_world(); char *f_lammps_extract_variable_world();
char* f_lammps_extract_variable_universe(); char *f_lammps_extract_variable_universe();
int f_lammps_extract_variable_uloop(); int f_lammps_extract_variable_uloop();
char* f_lammps_extract_variable_string(); char *f_lammps_extract_variable_string();
char* f_lammps_extract_variable_format(); char *f_lammps_extract_variable_format();
char* f_lammps_extract_variable_format_pad(); char *f_lammps_extract_variable_format_pad();
char* f_lammps_extract_variable_getenv(); char *f_lammps_extract_variable_getenv();
char* f_lammps_extract_variable_file(); char *f_lammps_extract_variable_file();
double f_lammps_extract_variable_atomfile(int); double f_lammps_extract_variable_atomfile(int);
double f_lammps_extract_variable_python(); double f_lammps_extract_variable_python();
double f_lammps_extract_variable_timer(); double f_lammps_extract_variable_timer();
@ -45,21 +44,22 @@ double f_lammps_extract_variable_equal();
double f_lammps_extract_variable_atom(int); double f_lammps_extract_variable_atom(int);
double f_lammps_extract_variable_vector(int); double f_lammps_extract_variable_vector(int);
void f_lammps_set_variable_string(); void f_lammps_set_variable_string();
char* c_path_join(const char*, const char*); char *c_path_join(const char *, const char *);
} }
char* c_path_join(const char* a, const char* b) char *c_path_join(const char *a, const char *b)
{ {
std::string A = a; std::string A = a;
std::string B = b; std::string B = b;
std::string C = LAMMPS_NS::platform::path_join(A, B); std::string C = LAMMPS_NS::platform::path_join(A, B);
size_t length = C.length() + 1; size_t length = C.length() + 1;
char *retval = (char*) malloc(length*sizeof(char)); char *retval = (char *)malloc(length * sizeof(char));
C.copy(retval, length); C.copy(retval, length);
retval[length-1] = '\0'; retval[length - 1] = '\0';
return retval; return retval;
} }
constexpr char input_dir[] = STRINGIFY(TEST_INPUT_FOLDER);
class LAMMPS_extract_variable : public ::testing::Test { class LAMMPS_extract_variable : public ::testing::Test {
protected: protected:
LAMMPS_NS::LAMMPS *lmp; LAMMPS_NS::LAMMPS *lmp;
@ -68,17 +68,20 @@ protected:
void SetUp() override void SetUp() override
{ {
const char *args[] = {"LAMMPS_Fortran_test", "-l", "none", // clang-format off
"-echo", "screen", "-nocite", "-var", const char *args[] =
"input_dir", STRINGIFY(TEST_INPUT_FOLDER), { "LAMMPS_Fortran_test", "-l", "none", "-echo", "screen", "-nocite",
"-var", "zpos", "1.5", "-var", "x", "2"}; "-var", "input_dir", input_dir, "-var", "zpos", "1.5", "-var", "x", "2" };
char** argv = (char**) args; // clang-format on
int argc = sizeof(args) / sizeof(const char*); char **argv = (char **)args;
int argc = sizeof(args) / sizeof(const char *);
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
lmp = (LAMMPS_NS::LAMMPS*)f_lammps_with_c_args(argc, argv); lmp = (LAMMPS_NS::LAMMPS *)f_lammps_with_c_args(argc, argv);
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS ("); EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS (");
} }
void TearDown() override void TearDown() override
{ {
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
@ -91,192 +94,190 @@ protected:
TEST_F(LAMMPS_extract_variable, index) TEST_F(LAMMPS_extract_variable, index)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
EXPECT_EQ(f_lammps_extract_variable_index_1(), 1); EXPECT_EQ(f_lammps_extract_variable_index_1(), 1);
EXPECT_EQ(f_lammps_extract_variable_index_2(), 0); EXPECT_EQ(f_lammps_extract_variable_index_2(), 0);
lammps_command(lmp, "next idx"); lammps_command(lmp, "next idx");
EXPECT_EQ(f_lammps_extract_variable_index_1(), 0); EXPECT_EQ(f_lammps_extract_variable_index_1(), 0);
EXPECT_EQ(f_lammps_extract_variable_index_2(), 1); EXPECT_EQ(f_lammps_extract_variable_index_2(), 1);
}; };
TEST_F(LAMMPS_extract_variable, loop) TEST_F(LAMMPS_extract_variable, loop)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
int i; int i;
for ( i = 1; i <= 10; i++ ) { for (i = 1; i <= 10; i++) {
EXPECT_EQ(f_lammps_extract_variable_loop(), i); EXPECT_EQ(f_lammps_extract_variable_loop(), i);
lammps_command(lmp, "next lp"); lammps_command(lmp, "next lp");
} }
}; };
TEST_F(LAMMPS_extract_variable, loop_pad) TEST_F(LAMMPS_extract_variable, loop_pad)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
int i; int i;
char str[10]; char str[10];
char* fstr; char *fstr;
for ( i = 1; i <= 10; i++ ) { for (i = 1; i <= 10; i++) {
std::sprintf(str,"%02d",i); std::sprintf(str, "%02d", i);
fstr = f_lammps_extract_variable_loop_pad(); fstr = f_lammps_extract_variable_loop_pad();
EXPECT_STREQ(fstr, str); EXPECT_STREQ(fstr, str);
std::free(fstr); std::free(fstr);
lammps_command(lmp, "next lp_pad"); lammps_command(lmp, "next lp_pad");
} }
}; };
TEST_F(LAMMPS_extract_variable, world) TEST_F(LAMMPS_extract_variable, world)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
char* fstr = f_lammps_extract_variable_world(); char *fstr = f_lammps_extract_variable_world();
EXPECT_STREQ(fstr, "group1"); EXPECT_STREQ(fstr, "group1");
std::free(fstr); std::free(fstr);
}; };
TEST_F(LAMMPS_extract_variable, universe) TEST_F(LAMMPS_extract_variable, universe)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
char* fstr = f_lammps_extract_variable_universe(); char *fstr = f_lammps_extract_variable_universe();
EXPECT_STREQ(fstr, "universe1"); EXPECT_STREQ(fstr, "universe1");
std::free(fstr); std::free(fstr);
}; };
TEST_F(LAMMPS_extract_variable, uloop) TEST_F(LAMMPS_extract_variable, uloop)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
EXPECT_EQ(f_lammps_extract_variable_uloop(), 1); EXPECT_EQ(f_lammps_extract_variable_uloop(), 1);
}; };
TEST_F(LAMMPS_extract_variable, string) TEST_F(LAMMPS_extract_variable, string)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
char* fstr = f_lammps_extract_variable_string(); char *fstr = f_lammps_extract_variable_string();
EXPECT_STREQ(fstr, "this is a string"); EXPECT_STREQ(fstr, "this is a string");
std::free(fstr); std::free(fstr);
f_lammps_set_variable_string(); f_lammps_set_variable_string();
fstr = f_lammps_extract_variable_string(); fstr = f_lammps_extract_variable_string();
EXPECT_STREQ(fstr, "this is the new string"); EXPECT_STREQ(fstr, "this is the new string");
std::free(fstr); std::free(fstr);
}; };
TEST_F(LAMMPS_extract_variable, format) TEST_F(LAMMPS_extract_variable, format)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
int i; int i;
char str[10]; char str[10];
char* fstr; char *fstr;
for ( i = 1; i <= 10; i++ ) { for (i = 1; i <= 10; i++) {
std::sprintf(str,"%.6G",std::exp(i)); std::sprintf(str, "%.6G", std::exp(i));
fstr = f_lammps_extract_variable_format(); fstr = f_lammps_extract_variable_format();
EXPECT_STREQ(fstr, str); EXPECT_STREQ(fstr, str);
std::free(fstr); std::free(fstr);
lammps_command(lmp, "next lp"); lammps_command(lmp, "next lp");
} }
}; };
TEST_F(LAMMPS_extract_variable, format_pad) TEST_F(LAMMPS_extract_variable, format_pad)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
int i; int i;
char str[10]; char str[10];
char* fstr; char *fstr;
for ( i = 1; i <= 10; i++ ) { for (i = 1; i <= 10; i++) {
std::sprintf(str,"%08.6G",std::exp(i)); std::sprintf(str, "%08.6G", std::exp(i));
fstr = f_lammps_extract_variable_format_pad(); fstr = f_lammps_extract_variable_format_pad();
EXPECT_STREQ(fstr, str); EXPECT_STREQ(fstr, str);
std::free(fstr); std::free(fstr);
lammps_command(lmp, "next lp"); lammps_command(lmp, "next lp");
} }
}; };
TEST_F(LAMMPS_extract_variable, getenv) TEST_F(LAMMPS_extract_variable, getenv)
{ {
LAMMPS_NS::platform::putenv("FORTRAN_USER=myuser"); LAMMPS_NS::platform::putenv("FORTRAN_USER=myuser");
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
char *env = std::getenv("FORTRAN_USER"); char *env = std::getenv("FORTRAN_USER");
char *fenv = f_lammps_extract_variable_getenv(); char *fenv = f_lammps_extract_variable_getenv();
EXPECT_STREQ(fenv, env); EXPECT_STREQ(fenv, env);
std::free(fenv); std::free(fenv);
}; };
TEST_F(LAMMPS_extract_variable, file) TEST_F(LAMMPS_extract_variable, file)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
int i; int i;
const char* str[9] = {"hello","god_dag","hola","bonjour","guten_Tag", const char *str[9] = {"hello", "god_dag", "hola", "bonjour", "guten_Tag",
"konnichiwa","shalom","salve","goedendag"}; "konnichiwa", "shalom", "salve", "goedendag"};
char* fstr; char *fstr;
for ( i = 0; i < 9; i++ ) { for (i = 0; i < 9; i++) {
fstr = f_lammps_extract_variable_file(); fstr = f_lammps_extract_variable_file();
EXPECT_STREQ(fstr, str[i]); EXPECT_STREQ(fstr, str[i]);
std::free(fstr); std::free(fstr);
lammps_command(lmp, "next greeting"); lammps_command(lmp, "next greeting");
} }
}; };
TEST_F(LAMMPS_extract_variable, atomfile) TEST_F(LAMMPS_extract_variable, atomfile)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(1), 5.2); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(1), 5.2);
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(2), 1.6); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(2), 1.6);
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(3), -1.4); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(3), -1.4);
lammps_command(lmp, "next atfile"); lammps_command(lmp, "next atfile");
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(1), -1.1); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(1), -1.1);
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(2), 0.0); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(2), 0.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(3), 2.5); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atomfile(3), 2.5);
}; };
TEST_F(LAMMPS_extract_variable, python) TEST_F(LAMMPS_extract_variable, python)
{ {
if ( lammps_config_has_package("PYTHON") ) { if (lammps_config_has_package("PYTHON")) {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
for (int i = 1; i <= 10; i++) { for (int i = 1; i <= 10; i++) {
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_python(), EXPECT_DOUBLE_EQ(f_lammps_extract_variable_python(), static_cast<double>(i * i));
static_cast<double>(i*i)); lammps_command(lmp, "next lp");
lammps_command(lmp, "next lp"); }
} }
}
}; };
TEST_F(LAMMPS_extract_variable, timer) TEST_F(LAMMPS_extract_variable, timer)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
double initial_t, final_t; double initial_t, final_t;
initial_t = f_lammps_extract_variable_timer(); initial_t = f_lammps_extract_variable_timer();
std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::this_thread::sleep_for(std::chrono::milliseconds(100));
lammps_command(lmp,"variable time timer"); // update the time lammps_command(lmp, "variable time timer"); // update the time
final_t = f_lammps_extract_variable_timer(); final_t = f_lammps_extract_variable_timer();
EXPECT_GT(final_t, initial_t + 0.1); EXPECT_GT(final_t, initial_t + 0.1);
}; };
TEST_F(LAMMPS_extract_variable, internal) TEST_F(LAMMPS_extract_variable, internal)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_internal(), 4.0); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_internal(), 4.0);
}; };
TEST_F(LAMMPS_extract_variable, equal) TEST_F(LAMMPS_extract_variable, equal)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
int i; int i;
for ( i = 1; i <= 10; i++ ) { for (i = 1; i <= 10; i++) {
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_equal(), EXPECT_DOUBLE_EQ(f_lammps_extract_variable_equal(), std::exp(static_cast<double>(i)));
std::exp(static_cast<double>(i))); lammps_command(lmp, "next lp");
lammps_command(lmp, "next lp"); }
}
}; };
TEST_F(LAMMPS_extract_variable, atom) TEST_F(LAMMPS_extract_variable, atom)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atom(1), 1.5); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atom(1), 1.5);
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atom(2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atom(2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atom(3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_atom(3), 0.5);
}; };
TEST_F(LAMMPS_extract_variable, vector) TEST_F(LAMMPS_extract_variable, vector)
{ {
f_lammps_setup_extract_variable(); f_lammps_setup_extract_variable();
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_vector(1), (1+0.2+0.5)/3.0); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_vector(1), (1 + 0.2 + 0.5) / 3.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_vector(2), (1+0.1+0.5)/3.0); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_vector(2), (1 + 0.1 + 0.5) / 3.0);
EXPECT_DOUBLE_EQ(f_lammps_extract_variable_vector(3), (1.5+0.1+0.5)/3.0); EXPECT_DOUBLE_EQ(f_lammps_extract_variable_vector(3), (1.5 + 0.1 + 0.5) / 3.0);
}; };

278
unittest/fortran/wrap_gather_scatter.cpp
View File

@ -3,10 +3,10 @@
#include "lammps.h" #include "lammps.h"
#include "library.h" #include "library.h"
#include <cstdint>
#include <cstdlib>
#include <mpi.h> #include <mpi.h>
#include <string> #include <string>
#include <cstdlib>
#include <cstdint>
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -18,185 +18,185 @@ void f_lammps_setup_gather_scatter();
int f_lammps_gather_atoms_mask(int); int f_lammps_gather_atoms_mask(int);
double f_lammps_gather_atoms_position(int); double f_lammps_gather_atoms_position(int);
int f_lammps_gather_atoms_concat_mask(int); int f_lammps_gather_atoms_concat_mask(int);
double f_lammps_gather_atoms_concat_position(int,int); double f_lammps_gather_atoms_concat_position(int, int);
int f_lammps_gather_atoms_subset_mask(int); int f_lammps_gather_atoms_subset_mask(int);
double f_lammps_gather_atoms_subset_position(int,int); double f_lammps_gather_atoms_subset_position(int, int);
void f_lammps_scatter_atoms_masks(); void f_lammps_scatter_atoms_masks();
void f_lammps_scatter_atoms_positions(); void f_lammps_scatter_atoms_positions();
} }
class LAMMPS_gather_scatter : public ::testing::Test { class LAMMPS_gather_scatter : public ::testing::Test {
protected: protected:
LAMMPS_NS::LAMMPS *lmp; LAMMPS_NS::LAMMPS *lmp;
LAMMPS_gather_scatter() = default; LAMMPS_gather_scatter() = default;
~LAMMPS_gather_scatter() override = default; ~LAMMPS_gather_scatter() override = default;
void SetUp() override void SetUp() override
{ {
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
lmp = (LAMMPS_NS::LAMMPS *)f_lammps_with_args(); lmp = (LAMMPS_NS::LAMMPS *)f_lammps_with_args();
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS ("); EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS (");
} }
void TearDown() override void TearDown() override
{ {
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
f_lammps_close(); f_lammps_close();
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:"); EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:");
lmp = nullptr; lmp = nullptr;
} }
}; };
TEST_F(LAMMPS_gather_scatter, gather_atoms_masks) TEST_F(LAMMPS_gather_scatter, gather_atoms_masks)
{ {
if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP();
f_lammps_setup_gather_scatter(); f_lammps_setup_gather_scatter();
EXPECT_EQ(f_lammps_gather_atoms_mask(1), 1); EXPECT_EQ(f_lammps_gather_atoms_mask(1), 1);
EXPECT_EQ(f_lammps_gather_atoms_mask(2), 1); EXPECT_EQ(f_lammps_gather_atoms_mask(2), 1);
EXPECT_EQ(f_lammps_gather_atoms_mask(3), 1); EXPECT_EQ(f_lammps_gather_atoms_mask(3), 1);
lammps_command(lmp, "group special id 1"); lammps_command(lmp, "group special id 1");
lammps_command(lmp, "group other id 2"); lammps_command(lmp, "group other id 2");
lammps_command(lmp, "group spiffy id 3"); lammps_command(lmp, "group spiffy id 3");
EXPECT_EQ(f_lammps_gather_atoms_mask(1), 3); EXPECT_EQ(f_lammps_gather_atoms_mask(1), 3);
EXPECT_EQ(f_lammps_gather_atoms_mask(2), 5); EXPECT_EQ(f_lammps_gather_atoms_mask(2), 5);
EXPECT_EQ(f_lammps_gather_atoms_mask(3), 9); EXPECT_EQ(f_lammps_gather_atoms_mask(3), 9);
lammps_command(lmp, "group other id 1"); lammps_command(lmp, "group other id 1");
EXPECT_EQ(f_lammps_gather_atoms_mask(1), 7); EXPECT_EQ(f_lammps_gather_atoms_mask(1), 7);
EXPECT_EQ(f_lammps_gather_atoms_mask(2), 5); EXPECT_EQ(f_lammps_gather_atoms_mask(2), 5);
EXPECT_EQ(f_lammps_gather_atoms_mask(3), 9); EXPECT_EQ(f_lammps_gather_atoms_mask(3), 9);
}; };
TEST_F(LAMMPS_gather_scatter, gather_atoms_positions) TEST_F(LAMMPS_gather_scatter, gather_atoms_positions)
{ {
if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP();
f_lammps_setup_gather_scatter(); f_lammps_setup_gather_scatter();
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(1), 1.0); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(1), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(2), 1.0); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(2), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(3), 1.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(3), 1.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(4), 0.2); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(4), 0.2);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(5), 0.1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(5), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(6), 0.1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(6), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(7), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(7), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(8), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(8), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(9), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_position(9), 0.5);
}; };
TEST_F(LAMMPS_gather_scatter, gather_atoms_concat_masks) TEST_F(LAMMPS_gather_scatter, gather_atoms_concat_masks)
{ {
if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP();
f_lammps_setup_gather_scatter(); f_lammps_setup_gather_scatter();
EXPECT_EQ(f_lammps_gather_atoms_concat_mask(1), 1); EXPECT_EQ(f_lammps_gather_atoms_concat_mask(1), 1);
EXPECT_EQ(f_lammps_gather_atoms_concat_mask(2), 1); EXPECT_EQ(f_lammps_gather_atoms_concat_mask(2), 1);
EXPECT_EQ(f_lammps_gather_atoms_concat_mask(3), 1); EXPECT_EQ(f_lammps_gather_atoms_concat_mask(3), 1);
lammps_command(lmp, "group special id 1"); lammps_command(lmp, "group special id 1");
lammps_command(lmp, "group other id 2"); lammps_command(lmp, "group other id 2");
lammps_command(lmp, "group spiffy id 3"); lammps_command(lmp, "group spiffy id 3");
EXPECT_EQ(f_lammps_gather_atoms_concat_mask(1), 3); EXPECT_EQ(f_lammps_gather_atoms_concat_mask(1), 3);
EXPECT_EQ(f_lammps_gather_atoms_concat_mask(2), 5); EXPECT_EQ(f_lammps_gather_atoms_concat_mask(2), 5);
EXPECT_EQ(f_lammps_gather_atoms_concat_mask(3), 9); EXPECT_EQ(f_lammps_gather_atoms_concat_mask(3), 9);
lammps_command(lmp, "group other id 1"); lammps_command(lmp, "group other id 1");
EXPECT_EQ(f_lammps_gather_atoms_concat_mask(1), 7); EXPECT_EQ(f_lammps_gather_atoms_concat_mask(1), 7);
EXPECT_EQ(f_lammps_gather_atoms_concat_mask(2), 5); EXPECT_EQ(f_lammps_gather_atoms_concat_mask(2), 5);
EXPECT_EQ(f_lammps_gather_atoms_concat_mask(3), 9); EXPECT_EQ(f_lammps_gather_atoms_concat_mask(3), 9);
}; };
TEST_F(LAMMPS_gather_scatter, gather_atoms_concat_positions) TEST_F(LAMMPS_gather_scatter, gather_atoms_concat_positions)
{ {
if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP();
f_lammps_setup_gather_scatter(); f_lammps_setup_gather_scatter();
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1,1), 1.0); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1, 1), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2,1), 1.0); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2, 1), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,1), 1.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3, 1), 1.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1,2), 0.2); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1, 2), 0.2);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2,2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2, 2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3, 2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1, 3), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2, 3), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3, 3), 0.5);
}; };
TEST_F(LAMMPS_gather_scatter, gather_atoms_subset_masks) TEST_F(LAMMPS_gather_scatter, gather_atoms_subset_masks)
{ {
if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP();
f_lammps_setup_gather_scatter(); f_lammps_setup_gather_scatter();
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(2), 1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(2), 1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(3), 1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(3), 1);
lammps_command(lmp, "group special id 1"); lammps_command(lmp, "group special id 1");
lammps_command(lmp, "group other id 2"); lammps_command(lmp, "group other id 2");
lammps_command(lmp, "group spiffy id 3"); lammps_command(lmp, "group spiffy id 3");
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(2), 5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(2), 5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(3), 9); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(3), 9);
lammps_command(lmp, "group other id 3"); lammps_command(lmp, "group other id 3");
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(2), 5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(2), 5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(3), 13); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_mask(3), 13);
}; };
TEST_F(LAMMPS_gather_scatter, gather_atoms_subset_positions) TEST_F(LAMMPS_gather_scatter, gather_atoms_subset_positions)
{ {
if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP();
f_lammps_setup_gather_scatter(); f_lammps_setup_gather_scatter();
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(1,2), 0.2); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(1, 2), 0.2);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(2,2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(2, 2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(3,2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(3, 2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(1,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(1, 3), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(2,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(2, 3), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(3,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_subset_position(3, 3), 0.5);
}; };
TEST_F(LAMMPS_gather_scatter, scatter_atoms_masks) TEST_F(LAMMPS_gather_scatter, scatter_atoms_masks)
{ {
if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP();
f_lammps_setup_gather_scatter(); f_lammps_setup_gather_scatter();
lammps_command(lmp, "group special id 1"); lammps_command(lmp, "group special id 1");
lammps_command(lmp, "group other id 2"); lammps_command(lmp, "group other id 2");
lammps_command(lmp, "group spiffy id 3"); lammps_command(lmp, "group spiffy id 3");
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(1), 3); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(1), 3);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(2), 5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(2), 5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(3), 9); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(3), 9);
f_lammps_scatter_atoms_masks(); f_lammps_scatter_atoms_masks();
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(1), 9); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(1), 9);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(2), 5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(2), 5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(3), 3); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(3), 3);
}; };
TEST_F(LAMMPS_gather_scatter, scatter_atoms_positions) TEST_F(LAMMPS_gather_scatter, scatter_atoms_positions)
{ {
if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP();
f_lammps_setup_gather_scatter(); f_lammps_setup_gather_scatter();
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1,1), 1.0); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1, 1), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2,1), 1.0); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2, 1), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,1), 1.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3, 1), 1.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1,2), 0.2); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1, 2), 0.2);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2,2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2, 2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3, 2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1, 3), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2, 3), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,3), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3, 3), 0.5);
f_lammps_scatter_atoms_positions(); f_lammps_scatter_atoms_positions();
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1,3), 1.0); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1, 3), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2,3), 1.0); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2, 3), 1.0);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,3), 1.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3, 3), 1.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1,2), 0.2); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1, 2), 0.2);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2,2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2, 2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,2), 0.1); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3, 2), 0.1);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1,1), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(1, 1), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2,1), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(2, 1), 0.5);
EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,1), 0.5); EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3, 1), 0.5);
}; };
TEST_F(LAMMPS_gather_scatter, scatter_atoms_subset_mask) TEST_F(LAMMPS_gather_scatter, scatter_atoms_subset_mask)
{ {
if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP();
f_lammps_setup_gather_scatter(); f_lammps_setup_gather_scatter();
EXPECT_EQ(f_lammps_gather_atoms_mask(1), 1); EXPECT_EQ(f_lammps_gather_atoms_mask(1), 1);
EXPECT_EQ(f_lammps_gather_atoms_mask(3), 1); EXPECT_EQ(f_lammps_gather_atoms_mask(3), 1);
lammps_command(lmp, "group special id 1"); lammps_command(lmp, "group special id 1");
lammps_command(lmp, "group other id 2"); lammps_command(lmp, "group other id 2");
lammps_command(lmp, "group spiffy id 3"); lammps_command(lmp, "group spiffy id 3");
EXPECT_EQ(f_lammps_gather_atoms_mask(1), 3); EXPECT_EQ(f_lammps_gather_atoms_mask(1), 3);
EXPECT_EQ(f_lammps_gather_atoms_mask(3), 9); EXPECT_EQ(f_lammps_gather_atoms_mask(3), 9);
f_lammps_scatter_atoms_masks(); f_lammps_scatter_atoms_masks();
EXPECT_EQ(f_lammps_gather_atoms_mask(1), 9); EXPECT_EQ(f_lammps_gather_atoms_mask(1), 9);
EXPECT_EQ(f_lammps_gather_atoms_mask(3), 3); EXPECT_EQ(f_lammps_gather_atoms_mask(3), 3);
}; };

30
unittest/fortran/wrap_properties.cpp
View File

@ -13,9 +13,9 @@ extern "C" {
void *f_lammps_with_args(); void *f_lammps_with_args();
void f_lammps_close(); void f_lammps_close();
int f_lammps_version(); int f_lammps_version();
void f_lammps_memory_usage(double*); void f_lammps_memory_usage(double *);
int f_lammps_get_mpi_comm(); int f_lammps_get_mpi_comm();
int f_lammps_extract_setting(const char*); int f_lammps_extract_setting(const char *);
int f_lammps_has_error(); int f_lammps_has_error();
int f_lammps_get_last_error_message(char *, int); int f_lammps_get_last_error_message(char *, int);
} }
@ -26,17 +26,17 @@ using ::testing::ContainsRegex;
class LAMMPS_properties : public ::testing::Test { class LAMMPS_properties : public ::testing::Test {
protected: protected:
LAMMPS_NS::LAMMPS *lmp; LAMMPS *lmp;
LAMMPS_properties() = default;
~LAMMPS_properties() override = default;
void SetUp() override void SetUp() override
{ {
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
lmp = (LAMMPS_NS::LAMMPS *)f_lammps_with_args(); lmp = (LAMMPS *)f_lammps_with_args();
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS ("); EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS (");
} }
void TearDown() override void TearDown() override
{ {
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
@ -54,10 +54,10 @@ TEST_F(LAMMPS_properties, version)
TEST_F(LAMMPS_properties, memory_usage) TEST_F(LAMMPS_properties, memory_usage)
{ {
// copied from c-library, with a two-character modification // copied from c-library, with a two-character modification
double meminfo[3]; double meminfo[3];
f_lammps_memory_usage(meminfo); f_lammps_memory_usage(meminfo);
EXPECT_GT(meminfo[0], 0.0); EXPECT_GT(meminfo[0], 0.0);
#if defined(__linux__) || defined(_WIN32) #if defined(__linux__) || defined(_WIN32)
EXPECT_GE(meminfo[1], 0.0); EXPECT_GE(meminfo[1], 0.0);
#endif #endif
@ -68,11 +68,11 @@ TEST_F(LAMMPS_properties, memory_usage)
TEST_F(LAMMPS_properties, get_mpi_comm) TEST_F(LAMMPS_properties, get_mpi_comm)
{ {
int f_comm = f_lammps_get_mpi_comm(); int f_comm = f_lammps_get_mpi_comm();
if ( lammps_config_has_mpi_support() ) if (lammps_config_has_mpi_support())
EXPECT_GE(f_comm, 0); EXPECT_GE(f_comm, 0);
else else
EXPECT_EQ(f_comm, -1); EXPECT_EQ(f_comm, -1);
}; };
TEST_F(LAMMPS_properties, extract_setting) TEST_F(LAMMPS_properties, extract_setting)