lijiext
/
lammps
mirror of https://github.com/lammps/lammps.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2362 from akohlmey/library-progguide 

Updates to C-Library interface progammer guide and reference
This commit is contained in:
Axel Kohlmeyer 2020-09-15 11:51:02 -04:00 committed by GitHub
parent c6bc21febf 39681acfa4
commit 165444004e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 959 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
doc/src/pg_lib_config.rst
View File

@ -1,9 +1,51 @@
Retrieving LAMMPS configuration information
===========================================
The following library functions can be used to query the
LAMMPS library about compile time settings and included
packages and styles.
The following library functions can be used to query the LAMMPS library
about compile time settings and included packages and styles. This
enables programs that use the library interface to run LAMMPS
simulations to determine, whether the linked LAMMPS library is compatible
with the requirements of the application without crashing during the
LAMMPS functions (e.g. due to missing pair styles from packages) or to
choose between different options (e.g. whether to use ``lj/cut``,
``lj/cut/opt``, ``lj/cut/omp`` or ``lj/cut/intel``). Most of the
functions can be called directly without first creating a LAMMPS
instance. While crashes within LAMMPS may be recovered from through
enabling :ref:`exceptions <exceptions>`, avoiding them proactively is
a safer approach.
.. code-block:: C
:caption: Example for using configuration settings functions
#include "library.h"
#include <stdio.h>
int main(int argc, char **argv)
{
void *handle;
handle = lammps_open_no_mpi(0, NULL, NULL);
lammps_file(handle, "in.missing");
if (lammps_has_error(handle)) {
char errmsg[256];
int errtype;
errtype = lammps_get_last_error_message(handle, errmsg, 256);
fprintf(stderr, "LAMMPS failed with error: %s\n", errmsg);
return 1;
}
/* write compressed dump file depending on available of options */
if (lammps_has_style(handle, "dump", "atom/zstd")) {
lammps_command(handle, "dump d1 all atom/zstd 100 dump.zst");
} else if (lammps_has_style(handle, "dump", "atom/gz")) {
lammps_command(handle, "dump d1 all atom/gz 100 dump.gz");
} else if (lammps_config_has_gzip_support()) {
lammps_command(handle, "dump d1 all atom 100 dump.gz");
} else {
lammps_command(handle, "dump d1 all atom 100 dump");
}
lammps_close(handle);
return 0;
}
-----------------------

32
doc/src/pg_lib_properties.rst
View File

@ -2,8 +2,8 @@ Retrieving or setting LAMMPS system properties
==============================================
The library interface allows to extract different kinds of information
about the active simulation instance and also to modify some of them.
This allows to combine MD simulation steps with other processing and
about the active simulation instance and also to modify some of it.
This enables combining MD simulation steps with other processing and
simulation methods computed in the calling code or another code that is
coupled to LAMMPS via the library interface. In some cases the data
returned is direct reference to the original data inside LAMMPS cast
@ -14,6 +14,34 @@ is the per-processor **local** data and indexed accordingly. These arrays
can change sizes and order at every neighbor list rebuild and atom sort
event as atoms are migrating between sub-domains.
.. code-block:: C
#include "library.h"
#include <stdio.h>
int main(int argc, char **argv)
{
void *handle;
int i;
handle = lammps_open_no_mpi(0, NULL, NULL);
lammps_file(handle,"in.sysinit");
printf("running simulation with %g atoms\n",
lammps_get_natoms(handle));
lammps_command(handle,"run 1000 post no");
for (i=0; i < 10; ++i) {
lammps_command(handle,"run 100 pre no post no");
printf("PE = %g\nKE = %g\n",
lammps_get_thermo(handle,"pe"),
lammps_get_thermo(handle,"ke"));
}
lammps_close(handle);
return 0;
}
-----------------------
.. doxygenfunction:: lammps_version

2
src/atom.cpp
View File

@ -2508,7 +2508,7 @@ length of the data area, and a short description.
Typically the name of the pointer variable returned
* \return pointer to the requested data cast to ``void *`` or NULL */
void *Atom::extract(char *name)
void *Atom::extract(const char *name)
{
// --------------------------------------------------------------------
// 4th customization section: customize by adding new variable name

2
src/atom.h
View File

@ -331,7 +331,7 @@ class Atom : protected Pointers {
virtual void sync_modify(ExecutionSpace, unsigned int, unsigned int) {}
void *extract(char *);
void *extract(const char *);
inline int* get_map_array() {return map_array;};
inline int get_map_size() {return map_tag_max+1;};

22
src/library.cpp
View File

@ -616,7 +616,7 @@ a double, so it can also return information that is computed on-the-fly.
* \param keyword string with the name of the thermo keyword
* \return value of the requested thermo property or 0.0 */
double lammps_get_thermo(void *handle, char *keyword)
double lammps_get_thermo(void *handle, const char *keyword)
{
LAMMPS *lmp = (LAMMPS *) handle;
double dval = 0.0;
@ -807,7 +807,7 @@ recognized, the function returns -1. Please also see :cpp:func:`lammps_extract_
* \param keyword string with the name of the thermo keyword
* \return value of the queried setting or -1 if unknown */
int lammps_extract_setting(void * handle, char *keyword)
int lammps_extract_setting(void *handle, const char *keyword)
{
LAMMPS *lmp = (LAMMPS *) handle;
@ -865,7 +865,8 @@ Please also see :cpp:func:`lammps_extract_setting`,
This table lists the supported names, their data types, length of the
data area, and a short description. The ``bigint`` type may be defined
to be either an ``int`` or an ``int64_t``. This is selected at
:ref:`compile time <size>`.
:ref:`compile time <size>` and can be queried through calling
:cpp:func:`lammps_extract_setting`.
.. list-table::
:header-rows: 1
@ -1073,7 +1074,7 @@ to be either an ``int`` or an ``int64_t``. This is selected at
* \return pointer (cast to ``void *``) to the location of the
requested property. NULL if name is not known. */
void *lammps_extract_global(void *handle, char *name)
void *lammps_extract_global(void *handle, const char *name)
{
LAMMPS *lmp = (LAMMPS *) handle;
@ -1165,7 +1166,7 @@ of the :cpp:func:`Atom::extract() <LAMMPS_NS::Atom::extract>` function.
* \return pointer (cast to ``void *``) to the location of the
* requested data or ``NULL`` if not found. */
void *lammps_extract_atom(void *handle, char *name)
void *lammps_extract_atom(void *handle, const char *name)
{
LAMMPS *lmp = (LAMMPS *) handle;
return lmp->atom->extract(name);
@ -3724,7 +3725,7 @@ specific :doc:`LAMMPS package <Packages>` provided as argument.
* \param name string with the name of the package
* \return 1 if included, 0 if not.
*/
int lammps_config_has_package(char * name) {
int lammps_config_has_package(const char *name) {
return Info::has_package(name) ? 1 : 0;
}
@ -3792,10 +3793,10 @@ Valid categories are: *atom*\ , *integrate*\ , *minimize*\ ,
* \param name name of the style
* \return 1 if included, 0 if not.
*/
int lammps_has_style(void * handle, char * category, char * name) {
int lammps_has_style(void *handle, const char *category, const char *name) {
LAMMPS *lmp = (LAMMPS *) handle;
Info info(lmp);
return info.has_style(category, name) ? 0 : 1;
return info.has_style(category, name) ? 1 : 0;
}
/* ---------------------------------------------------------------------- */
@ -3813,7 +3814,7 @@ categories.
* \param category category of styles
* \return number of styles in category
*/
int lammps_style_count(void * handle, char * category) {
int lammps_style_count(void *handle, const char *category) {
LAMMPS *lmp = (LAMMPS *) handle;
Info info(lmp);
return info.get_available_styles(category).size();
@ -3839,7 +3840,8 @@ Please see :cpp:func:`lammps_has_style` for a list of valid categories.
* \param buf_size size of the provided string buffer
* \return 1 if successful, otherwise 0
*/
int lammps_style_name(void* handle, char * category, int idx, char * buffer, int buf_size) {
int lammps_style_name(void *handle, const char *category, int idx,
char *buffer, int buf_size) {
LAMMPS *lmp = (LAMMPS *) handle;
Info info(lmp);
auto styles = info.get_available_styles(category);

16
src/library.h
View File

@ -100,7 +100,7 @@ void lammps_commands_string(void *handle, const char *str);
int lammps_version(void *handle);
int lammps_get_mpi_comm(void* handle);
double lammps_get_natoms(void *handle);
double lammps_get_thermo(void *handle, char *keyword);
double lammps_get_thermo(void *handle, const char *keyword);
void lammps_extract_box(void *handle, double *boxlo, double *boxhi,
double *xy, double *yz, double *xz,
@ -108,9 +108,9 @@ void lammps_extract_box(void *handle, double *boxlo, double *boxhi,
void lammps_reset_box(void *handle, double *boxlo, double *boxhi,
double xy, double yz, double xz);
int lammps_extract_setting(void *handle, char *keyword);
void *lammps_extract_global(void *handle, char *name);
void *lammps_extract_atom(void *handle, char *name);
int lammps_extract_setting(void *handle, const char *keyword);
void *lammps_extract_global(void *handle, const char *name);
void *lammps_extract_atom(void *handle, const char *name);
#if !defined(LAMMPS_BIGBIG)
int lammps_create_atoms(void *handle, int n, int *id, int *type,
@ -152,7 +152,7 @@ void lammps_scatter_atoms_subset(void *, char *, int, int, int, int *, void *);
* ---------------------------------------------------------------------- */
int lammps_config_has_mpi_support();
int lammps_config_has_package(char *);
int lammps_config_has_package(const char *);
int lammps_config_package_count();
int lammps_config_package_name(int, char *, int);
int lammps_config_has_gzip_support();
@ -161,9 +161,9 @@ int lammps_config_has_jpeg_support();
int lammps_config_has_ffmpeg_support();
int lammps_config_has_exceptions();
int lammps_has_style(void *, char *, char *);
int lammps_style_count(void *, char *);
int lammps_style_name(void *, char *, int, char *, int);
int lammps_has_style(void *, const char *, const char *);
int lammps_style_count(void *, const char *);
int lammps_style_name(void *, const char *, int, char *, int);
/* ----------------------------------------------------------------------
* Library functions for accessing neighbor lists

56
unittest/c-library/CMakeLists.txt
View File

@ -1,13 +1,57 @@
add_executable(test_library_open test_library_open.cpp)
target_link_libraries(test_library_open PRIVATE lammps GTest::GTest GTest::GTestMain)
add_executable(test_library_open test_library_open.cpp test_main.cpp)
target_link_libraries(test_library_open PRIVATE lammps GTest::GTest GTest::GMock)
add_test(LibraryOpen test_library_open)
add_executable(test_library_commands test_library_commands.cpp)
target_link_libraries(test_library_commands PRIVATE lammps GTest::GTest GTest::GTestMain)
add_executable(test_library_commands test_library_commands.cpp test_main.cpp)
target_link_libraries(test_library_commands PRIVATE lammps GTest::GTest GTest::GMock)
add_test(LibraryCommands test_library_commands)
add_executable(test_library_properties test_library_properties.cpp)
target_link_libraries(test_library_properties PRIVATE lammps GTest::GTest GTest::GTestMain)
add_executable(test_library_properties test_library_properties.cpp test_main.cpp)
target_link_libraries(test_library_properties PRIVATE lammps GTest::GTest GTest::GMock)
target_compile_definitions(test_library_properties PRIVATE -DTEST_INPUT_FOLDER=${CMAKE_CURRENT_SOURCE_DIR})
add_test(LibraryProperties test_library_properties)
set(TEST_CONFIG_DEFS "-DTEST_INPUT_FOLDER=${CMAKE_CURRENT_SOURCE_DIR};-DLAMMPS_${LAMMPS_SIZES}")
set(PKG_COUNT 0)
foreach(PKG ${STANDARD_PACKAGES} ${SUFFIX_PACKAGES})
if(PKG_${PKG})
MATH(EXPR PKG_COUNT "${PKG_COUNT}+1")
endif()
endforeach()
list(APPEND TEST_CONFIG_DEFS -DNUM_LAMMPS_PACKAGES=${PKG_COUNT})
if(PKG_MANYBODY)
set(HAS_MANYBODY 1)
else()
set(HAS_MANYBODY 0)
endif()
list(APPEND TEST_CONFIG_DEFS -DLAMMPS_HAS_MANYBODY=${HAS_MANYBODY})
if(BUILD_MPI)
set(HAS_MPI 1)
else()
set(HAS_MPI 0)
endif()
list(APPEND TEST_CONFIG_DEFS -DLAMMPS_HAS_MPI=${HAS_MPI})
if(LAMMPS_EXCEPTIONS)
set(HAS_EXCEPTIONS 1)
else()
set(HAS_EXCEPTIONS 0)
endif()
list(APPEND TEST_CONFIG_DEFS -DLAMMPS_HAS_EXCEPTIONS=${HAS_EXCEPTIONS})
foreach(WITH "JPEG" "PNG" "GZIP" "FFMPEG")
if(WITH_${WITH})
set(HAS_${WITH} 1)
else()
set(HAS_${WITH} 0)
endif()
list(APPEND TEST_CONFIG_DEFS -DLAMMPS_HAS_${WITH}=${HAS_${WITH}})
endforeach()
add_executable(test_library_config test_library_config.cpp test_main.cpp)
target_link_libraries(test_library_config PRIVATE lammps GTest::GTest GTest::GMock)
target_compile_definitions(test_library_config PRIVATE ${TEST_CONFIG_DEFS})
add_test(LibraryConfig test_library_config)

210
unittest/c-library/data.fourmol Normal file
View File

@ -0,0 +1,210 @@
LAMMPS data file via write_data, version 5 May 2020, timestep = 0
29 atoms
5 atom types
24 bonds
5 bond types
30 angles
4 angle types
31 dihedrals
5 dihedral types
2 impropers
2 improper types
-6.024572 8.975428 xlo xhi
-7.692866 7.307134 ylo yhi
-8.086924 6.913076 zlo zhi
Masses
1 12.0107
2 4.00794
3 14.0067
4 15.9994
5 15.9994
Pair Coeffs # zero
1
2
3
4
5
Bond Coeffs # zero
1 1.5
2 1.1
3 1.3
4 1.2
5 1
Angle Coeffs # zero
1 110.1
2 111
3 120
4 108.5
Atoms # full
10 2 1 7.0000000000000007e-02 2.0185283555536988e+00 -1.4283966846517357e+00 -9.6733527271133024e-01 0 0 0
11 2 2 8.9999999999999997e-02 1.7929780509347666e+00 -1.9871047540768743e+00 -1.8840626643185674e+00 0 0 0
12 2 1 -2.7000000000000002e-01 3.0030247876861225e+00 -4.8923319967572748e-01 -1.6188658531537248e+00 0 0 0
13 2 2 8.9999999999999997e-02 4.0447273787895934e+00 -9.0131998547446246e-01 -1.6384447268320836e+00 0 0 0
14 2 2 8.9999999999999997e-02 2.6033152817257075e+00 -4.0789761505963579e-01 -2.6554413538823063e+00 0 0 0
2 1 2 3.1000000000000000e-01 3.0197083955402204e-01 2.9515239068888608e+00 -8.5689735572907566e-01 0 0 0
3 1 1 -2.0000000000000000e-02 -6.9435377880558602e-01 1.2440473127136711e+00 -6.2233801468892025e-01 0 0 0
4 1 2 8.9999999999999997e-02 -1.5771614164685133e+00 1.4915333140468066e+00 -1.2487126845040522e+00 0 0 0
6 1 1 5.1000000000000001e-01 2.9412607937706009e-01 2.2719282656652909e-01 -1.2843094067857870e+00 0 0 0
7 1 4 -5.1000000000000001e-01 3.4019871062879609e-01 -9.1277350075786561e-03 -2.4633113224304561e+00 0 0 0
19 3 2 4.2359999999999998e-01 1.5349125211132961e+00 2.6315969880333707e+00 -4.2472859440220647e+00 0 0 0
15 2 2 8.9999999999999997e-02 2.9756315249791303e+00 5.6334269722969288e-01 -1.2437650754599008e+00 0 0 0
18 3 4 -8.4719999999999995e-01 2.1384791188033843e+00 3.0177261773770208e+00 -3.5160827596876225e+00 0 0 0
20 3 2 4.2359999999999998e-01 2.7641167828863153e+00 3.6833419064000221e+00 -3.9380850623312638e+00 0 0 0
8 2 3 -4.6999999999999997e-01 1.1641187171852805e+00 -4.8375305955385234e-01 -6.7659823767368688e-01 0 0 0
9 2 2 3.1000000000000000e-01 1.3777459838125838e+00 -2.5366338669522998e-01 2.6877644730326306e-01 0 0 0
16 2 1 5.1000000000000001e-01 2.6517554244980306e+00 -2.3957110424978438e+00 3.2908335999178327e-02 0 0 0
17 2 4 -5.1000000000000001e-01 2.2309964792710639e+00 -2.1022918943319384e+00 1.1491948328949437e+00 0 0 0
1 1 3 -4.6999999999999997e-01 -2.7993683669226832e-01 2.4726588069312840e+00 -1.7200860244148433e-01 0 0 0
5 1 2 8.9999999999999997e-02 -8.9501761359359255e-01 9.3568128743071344e-01 4.0227731871484346e-01 0 0 0
21 4 5 -8.4719999999999995e-01 4.9064454390208301e+00 -4.0751205255383196e+00 -3.6215576073601046e+00 0 0 0
22 4 2 4.2359999999999998e-01 4.3687453488627543e+00 -4.2054270536772504e+00 -4.4651491269372565e+00 0 0 0
23 4 2 4.2359999999999998e-01 5.7374928154769504e+00 -3.5763355905184966e+00 -3.8820297194230728e+00 0 0 0
24 5 5 -8.4719999999999995e-01 2.0684115301174013e+00 3.1518221747664397e+00 3.1554242678474576e+00 0 0 0
25 5 2 4.2359999999999998e-01 1.2998381073113014e+00 3.2755513587518097e+00 2.5092990173114837e+00 0 0 0
26 5 2 4.2359999999999998e-01 2.5807438597688113e+00 4.0120175892854135e+00 3.2133398379059099e+00 0 0 0
27 6 5 -8.4719999999999995e-01 -1.9613581876744359e+00 -4.3556300596085160e+00 2.1101467673534788e+00 0 0 0
28 6 2 4.2359999999999998e-01 -2.7406520384725965e+00 -4.0207251278130975e+00 1.5828689861678511e+00 0 0 0
29 6 2 4.2359999999999998e-01 -1.3108232656499081e+00 -3.5992986322410760e+00 2.2680459788743503e+00 0 0 0
Velocities
1 7.7867804888392077e-04 5.8970331623292821e-04 -2.2179517633030531e-04
2 2.7129529964126462e-03 4.6286427111164284e-03 3.5805549693846352e-03
3 -1.2736791029204805e-03 1.6108674226414498e-03 -3.3618185901550799e-04
4 -9.2828595122009308e-04 -1.2537885319521818e-03 -4.1204974953432108e-03
5 -1.1800848061603740e-03 7.5424401975844038e-04 6.9023177964912290e-05
6 -3.0914004879905335e-04 1.2755385764678133e-03 7.9574303350202582e-04
7 -1.1037894966874103e-04 -7.6764845099077425e-04 -7.7217630460203659e-04
8 3.9060281273221989e-04 -8.1444231918053418e-04 1.5134641148324972e-04
9 1.2475530960659720e-03 -2.6608454451432528e-03 1.1117602907112732e-03
10 4.5008983776042893e-04 4.9530197647538077e-04 -2.3336234361093645e-04
11 -3.6977669078869707e-04 -1.5289071951960539e-03 -2.9176389881837113e-03
12 1.0850834530183159e-03 -6.4965897903201833e-04 -1.2971152622619948e-03
13 4.0754559196230639e-03 3.5043502394946119e-03 -7.8324487687854666e-04
14 -1.3837220448746613e-04 -4.0656048637594394e-03 -3.9333461173944500e-03
15 -4.3301707382721859e-03 -3.1802661664634938e-03 3.2037919043360571e-03
16 -9.6715751018414326e-05 -5.0016572678960377e-04 1.4945658875149626e-03
17 6.5692180538157174e-04 3.6635779995305095e-04 8.3495414466050911e-04
18 -6.0936815808025862e-04 -9.3774557532468582e-04 -3.3558072507805731e-04
19 -6.9919768291957119e-04 -3.6060777270430031e-03 4.2833405289822791e-03
20 4.7777805013736515e-03 5.1003745845520452e-03 1.8002873923729241e-03
21 -9.5568188553430398e-04 1.6594630943762931e-04 -1.8199788009966615e-04
22 -3.3137518957653462e-03 -2.8683968287936054e-03 3.6384389958326871e-03
23 2.4209481134686401e-04 -4.5457709985051130e-03 2.7663581642115042e-03
24 2.5447450568861086e-04 4.8412447786110117e-04 -4.8021914527341357e-04
25 4.3722771097312743e-03 -4.5184411669545515e-03 2.5200952006556795e-03
26 -1.9250110555001179e-03 -3.0342169883610837e-03 3.5062814567984532e-03
27 -2.6510179146429716e-04 3.6306203629019116e-04 -5.6235585400647747e-04
28 -2.3068708109787484e-04 -8.5663070212203200e-04 2.1302563179109169e-03
29 -2.5054744388303732e-03 -1.6773997805290820e-04 2.8436699761004796e-03
Bonds
1 5 1 2
2 3 1 3
3 2 3 4
4 2 3 5
5 1 3 6
6 3 6 8
7 4 6 7
8 5 8 9
9 3 8 10
10 2 10 11
11 1 10 12
12 1 10 16
13 2 12 13
14 2 12 14
15 2 12 15
16 4 16 17
17 5 18 19
18 5 18 20
19 5 21 22
20 5 21 23
21 5 24 25
22 5 24 26
23 5 27 28
24 5 27 29
Angles
1 4 2 1 3
2 4 1 3 5
3 4 1 3 4
4 4 1 3 6
5 4 4 3 5
6 2 5 3 6
7 2 4 3 6
8 3 3 6 7
9 3 3 6 8
10 3 7 6 8
11 2 6 8 9
12 2 9 8 10
13 3 6 8 10
14 2 8 10 11
15 3 8 10 16
16 2 11 10 12
17 1 12 10 16
18 1 8 10 12
19 2 11 10 16
20 2 10 12 15
21 2 10 12 14
22 2 10 12 13
23 4 13 12 15
24 4 13 12 14
25 4 14 12 15
26 4 10 16 17
27 1 19 18 20
28 1 22 21 23
29 1 25 24 26
30 1 28 27 29
Dihedrals
1 2 2 1 3 6
2 2 2 1 3 4
3 3 2 1 3 5
4 1 1 3 6 8
5 1 1 3 6 7
6 5 4 3 6 8
7 5 4 3 6 7
8 5 5 3 6 8
9 5 5 3 6 7
10 4 3 6 8 9
11 3 3 6 8 10
12 3 7 6 8 9
13 4 7 6 8 10
14 2 6 8 10 12
15 2 6 8 10 16
16 2 6 8 10 11
17 2 9 8 10 12
18 4 9 8 10 16
19 5 9 8 10 11
20 5 8 10 12 13
21 1 8 10 12 14
22 5 8 10 12 15
23 4 8 10 16 17
24 5 11 10 12 13
25 5 11 10 12 14
26 5 11 10 12 15
27 2 11 10 16 17
28 2 12 10 16 17
29 5 16 10 12 13
30 5 16 10 12 14
31 5 16 10 12 15
Impropers
1 1 6 3 8 7
2 2 8 6 10 9

25
unittest/c-library/in.fourmol Normal file
View File

@ -0,0 +1,25 @@
variable units index real
variable input_dir index .
variable data_file index ${input_dir}/data.fourmol
variable pair_style index 'zero 8.0'
variable bond_style index zero
variable angle_style index zero
variable dihedral_style index zero
variable improper_style index zero
atom_style full
atom_modify map array
neigh_modify delay 2 every 2 check no
timestep 0.1
units ${units}
pair_style ${pair_style}
bond_style ${bond_style}
angle_style ${angle_style}
dihedral_style ${dihedral_style}
improper_style ${improper_style}
read_data ${data_file}
dihedral_coeff *
improper_coeff *

68
unittest/c-library/test_library_commands.cpp
View File

@ -1,50 +1,54 @@
// unit tests for issuing command to a LAMMPS instance through the library interface
#include "library.h"
#include "lammps.h"
#include "library.h"
#include <string>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
const char *demo_input[] = {
"region box block 0 $x 0 2 0 2",
"create_box 1 box",
"create_atoms 1 single 1.0 1.0 ${zpos}" };
const char *cont_input[] = {
"create_atoms 1 single &",
"0.2 0.1 0.1" };
#include "test_main.h"
class LAMMPS_commands : public ::testing::Test
{
using ::testing::HasSubstr;
using ::testing::StartsWith;
const char *demo_input[] = {"region box block 0 $x 0 2 0 2", "create_box 1 box",
"create_atoms 1 single 1.0 1.0 ${zpos}"};
const char *cont_input[] = {"create_atoms 1 single &", "0.2 0.1 0.1"};
class LibraryCommands : public ::testing::Test {
protected:
void *lmp;
LAMMPS_commands() {};
~LAMMPS_commands() override {};
LibraryCommands(){};
~LibraryCommands() override{};
void SetUp() override
{
const char *args[] = {"LAMMPS_test", "-log", "none", "-echo", "screen", "-nocite",
"-var", "x", "2", "-var", "zpos", "1.5"};
void SetUp() override {
const char *args[] = {"LAMMPS_test",
"-log", "none",
"-echo", "screen",
"-nocite", "-var","x","2",
"-var", "zpos", "1.5"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
::testing::internal::CaptureStdout();
lmp = lammps_open_no_mpi(argc, argv, NULL);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,8).c_str(), "LAMMPS (");
if (verbose) std::cout << output;
EXPECT_THAT(output, StartsWith("LAMMPS ("));
}
void TearDown() override {
void TearDown() override
{
::testing::internal::CaptureStdout();
lammps_close(lmp);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:");
EXPECT_THAT(output, HasSubstr("Total wall time:"));
if (verbose) std::cout << output;
lmp = nullptr;
}
};
TEST_F(LAMMPS_commands, from_file) {
TEST_F(LibraryCommands, from_file)
{
FILE *fp;
const char demo_file[] = "in.test";
const char cont_file[] = "in.cont";
@ -63,30 +67,42 @@ TEST_F(LAMMPS_commands, from_file) {
fclose(fp);
EXPECT_EQ(lammps_get_natoms(lmp), 0);
if (!verbose) ::testing::internal::CaptureStdout();
lammps_file(lmp, demo_file);
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_get_natoms(lmp), 1);
if (!verbose) ::testing::internal::CaptureStdout();
lammps_file(lmp, cont_file);
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_get_natoms(lmp), 2);
unlink(demo_file);
unlink(cont_file);
};
TEST_F(LAMMPS_commands, from_line) {
TEST_F(LibraryCommands, from_line)
{
EXPECT_EQ(lammps_get_natoms(lmp), 0);
if (!verbose) ::testing::internal::CaptureStdout();
for (unsigned int i = 0; i < sizeof(demo_input) / sizeof(char *); ++i) {
lammps_command(lmp, demo_input[i]);
}
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_get_natoms(lmp), 1);
};
TEST_F(LAMMPS_commands, from_list) {
TEST_F(LibraryCommands, from_list)
{
EXPECT_EQ(lammps_get_natoms(lmp), 0);
if (!verbose) ::testing::internal::CaptureStdout();
lammps_commands_list(lmp, sizeof(demo_input) / sizeof(char *), demo_input);
lammps_commands_list(lmp, sizeof(cont_input) / sizeof(char *), cont_input);
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_get_natoms(lmp), 2);
};
TEST_F(LAMMPS_commands, from_string) {
TEST_F(LibraryCommands, from_string)
{
std::string cmds("");
for (unsigned int i = 0; i < sizeof(demo_input) / sizeof(char *); ++i) {
@ -98,6 +114,8 @@ TEST_F(LAMMPS_commands, from_string) {
cmds += "\n";
}
EXPECT_EQ(lammps_get_natoms(lmp), 0);
if (!verbose) ::testing::internal::CaptureStdout();
lammps_commands_string(lmp, cmds.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_get_natoms(lmp), 2);
};

149
unittest/c-library/test_library_config.cpp Normal file
View File

@ -0,0 +1,149 @@
// unit tests for checking LAMMPS configuration settings through the library interface
#include "lammps.h"
#include "library.h"
#include <string>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "test_main.h"
#define STRINGIFY(val) XSTR(val)
#define XSTR(val) #val
using ::testing::HasSubstr;
using ::testing::StartsWith;
using ::testing::StrEq;
class LibraryConfig : public ::testing::Test {
protected:
void *lmp;
std::string INPUT_DIR = STRINGIFY(TEST_INPUT_FOLDER);
LibraryConfig(){};
~LibraryConfig() override{};
void SetUp() override
{
const char *args[] = {"LAMMPS_test", "-log", "none",
"-echo", "screen", "-nocite",
"-var", "input_dir", STRINGIFY(TEST_INPUT_FOLDER)};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
::testing::internal::CaptureStdout();
lmp = lammps_open_no_mpi(argc, argv, NULL);
std::string output = ::testing::internal::GetCapturedStdout();
if (verbose) std::cout << output;
EXPECT_THAT(output, StartsWith("LAMMPS ("));
}
void TearDown() override
{
::testing::internal::CaptureStdout();
lammps_close(lmp);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_THAT(output, HasSubstr("Total wall time:"));
if (verbose) std::cout << output;
lmp = nullptr;
}
};
TEST(LAMMPSConfig, package_count)
{
EXPECT_EQ(lammps_config_package_count(), NUM_LAMMPS_PACKAGES);
};
TEST(LAMMPSConfig, has_package)
{
EXPECT_EQ(lammps_config_has_package("MANYBODY"), LAMMPS_HAS_MANYBODY);
};
TEST(LAMMPSConfig, package_name)
{
char buf[128];
int numpkgs = lammps_config_package_count();
if (numpkgs > 0) {
EXPECT_EQ(lammps_config_package_name(0, buf, 128), 1);
EXPECT_EQ(lammps_config_package_name(numpkgs + 10, buf, 128), 0);
EXPECT_THAT(buf, StrEq(""));
} else {
EXPECT_EQ(lammps_config_package_name(0, buf, 128), 1);
EXPECT_THAT(buf, StrEq(""));
}
};
TEST_F(LibraryConfig, has_style)
{
EXPECT_EQ(lammps_has_style(lmp, "atom", "atomic"), 1);
EXPECT_EQ(lammps_has_style(lmp, "compute", "temp"), 1);
EXPECT_EQ(lammps_has_style(lmp, "fix", "nve"), 1);
EXPECT_EQ(lammps_has_style(lmp, "pair", "lj/cut"), 1);
EXPECT_EQ(lammps_has_style(lmp, "bond", "zero"), 1);
EXPECT_EQ(lammps_has_style(lmp, "dump", "custom"), 1);
EXPECT_EQ(lammps_has_style(lmp, "region", "sphere"), 1);
EXPECT_EQ(lammps_has_style(lmp, "xxxxx", "lj/cut"), 0);
EXPECT_EQ(lammps_has_style(lmp, "pair", "xxxxxx"), 0);
#if LAMMPS_HAS_MANYBODY
EXPECT_EQ(lammps_has_style(lmp, "pair", "sw"), 1);
#else
EXPECT_EQ(lammps_has_style(lmp, "pair", "sw"), 0);
#endif
};
TEST_F(LibraryConfig, style_count)
{
EXPECT_GT(lammps_style_count(lmp, "atom"), 1);
EXPECT_GT(lammps_style_count(lmp, "bond"), 1);
EXPECT_GT(lammps_style_count(lmp, "angle"), 1);
EXPECT_GT(lammps_style_count(lmp, "dihedral"), 1);
EXPECT_GT(lammps_style_count(lmp, "improper"), 1);
EXPECT_GT(lammps_style_count(lmp, "pair"), 1);
EXPECT_GT(lammps_style_count(lmp, "kspace"), 1);
EXPECT_GT(lammps_style_count(lmp, "compute"), 1);
EXPECT_GT(lammps_style_count(lmp, "fix"), 1);
EXPECT_GT(lammps_style_count(lmp, "region"), 1);
EXPECT_GT(lammps_style_count(lmp, "dump"), 1);
EXPECT_GT(lammps_style_count(lmp, "integrate"), 1);
EXPECT_GT(lammps_style_count(lmp, "minimize"), 1);
};
TEST_F(LibraryConfig, style_name)
{
char buf[128];
int numstyles = lammps_style_count(lmp, "atom");
EXPECT_EQ(lammps_style_name(lmp, "atom", 0, buf, 128), 1);
EXPECT_EQ(lammps_style_name(lmp, "atom", numstyles + 10, buf, 128), 0);
EXPECT_THAT(buf, StrEq(""));
};
TEST(LAMMPSConfig, exceptions)
{
EXPECT_EQ(lammps_config_has_exceptions(), LAMMPS_HAS_EXCEPTIONS);
};
TEST(LAMMPSConfig, mpi_support)
{
EXPECT_EQ(lammps_config_has_mpi_support(), LAMMPS_HAS_MPI);
};
TEST(LAMMPSConfig, png_support)
{
EXPECT_EQ(lammps_config_has_png_support(), LAMMPS_HAS_PNG);
};
TEST(LAMMPSConfig, jpeg_support)
{
EXPECT_EQ(lammps_config_has_jpeg_support(), LAMMPS_HAS_JPEG);
};
TEST(LAMMPSConfig, gzip_support)
{
EXPECT_EQ(lammps_config_has_gzip_support(), LAMMPS_HAS_GZIP);
};
TEST(LAMMPSConfig, ffmpeg_support)
{
EXPECT_EQ(lammps_config_has_ffmpeg_support(), LAMMPS_HAS_FFMPEG);
};

81
unittest/c-library/test_library_open.cpp
View File

@ -1,18 +1,26 @@
// unit tests for the LAMMPS base class
// unit tests creating LAMMPS instances via the library interface
#include "library.h"
#include "lammps.h"
#include <mpi.h>
#include "library.h"
#include <cstdio> // for stdin, stdout
#include <mpi.h>
#include <string>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
TEST(lammps_open, null_args) {
#include "test_main.h"
using ::testing::HasSubstr;
using ::testing::StartsWith;
TEST(lammps_open, null_args)
{
::testing::internal::CaptureStdout();
void *handle = lammps_open(0, NULL, MPI_COMM_WORLD, NULL);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,6).c_str(),"LAMMPS");
EXPECT_THAT(output, StartsWith("LAMMPS ("));
if (verbose) std::cout << output;
int mpi_init = 0;
MPI_Initialized(&mpi_init);
EXPECT_GT(mpi_init, 0);
@ -24,13 +32,13 @@ TEST(lammps_open, null_args) {
::testing::internal::CaptureStdout();
lammps_close(handle);
output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:");
EXPECT_THAT(output, HasSubstr("Total wall time:"));
if (verbose) std::cout << output;
}
TEST(lammps_open, with_args) {
const char *args[] = {"liblammps",
"-log", "none",
"-nocite"};
TEST(lammps_open, with_args)
{
const char *args[] = {"liblammps", "-log", "none", "-nocite"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
@ -41,7 +49,8 @@ TEST(lammps_open, with_args) {
void *alt_ptr;
void *handle = lammps_open(argc, argv, mycomm, &alt_ptr);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,6).c_str(),"LAMMPS");
EXPECT_THAT(output, StartsWith("LAMMPS ("));
if (verbose) std::cout << output;
EXPECT_EQ(handle, alt_ptr);
LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle;
@ -60,15 +69,14 @@ TEST(lammps_open, with_args) {
::testing::internal::CaptureStdout();
lammps_close(handle);
output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:");
EXPECT_THAT(output, HasSubstr("Total wall time:"));
if (verbose) std::cout << output;
}
TEST(lammps_open, with_kokkos) {
TEST(lammps_open, with_kokkos)
{
if (!LAMMPS_NS::LAMMPS::is_installed_pkg("KOKKOS")) GTEST_SKIP();
const char *args[] = {"liblammps",
"-k", "on", "t", "2",
"-sf", "kk",
"-log", "none" };
const char *args[] = {"liblammps", "-k", "on", "t", "2", "-sf", "kk", "-log", "none"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
@ -76,7 +84,8 @@ TEST(lammps_open, with_kokkos) {
void *alt_ptr;
void *handle = lammps_open(argc, argv, MPI_COMM_WORLD, &alt_ptr);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,6).c_str(),"LAMMPS");
EXPECT_THAT(output, StartsWith("LAMMPS ("));
if (verbose) std::cout << output;
EXPECT_EQ(handle, alt_ptr);
LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle;
@ -91,14 +100,13 @@ TEST(lammps_open, with_kokkos) {
::testing::internal::CaptureStdout();
lammps_close(handle);
output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:");
EXPECT_THAT(output, HasSubstr("Total wall time:"));
if (verbose) std::cout << output;
}
TEST(lammps_open_no_mpi, no_screen) {
const char *args[] = {"liblammps",
"-log", "none",
"-screen", "none",
"-nocite"};
TEST(lammps_open_no_mpi, no_screen)
{
const char *args[] = {"liblammps", "-log", "none", "-screen", "none", "-nocite"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
@ -125,13 +133,11 @@ TEST(lammps_open_no_mpi, no_screen) {
EXPECT_STREQ(output.c_str(), "");
}
TEST(lammps_open_no_mpi, with_omp) {
TEST(lammps_open_no_mpi, with_omp)
{
if (!LAMMPS_NS::LAMMPS::is_installed_pkg("USER-OMP")) GTEST_SKIP();
const char *args[] = {"liblammps",
"-pk", "omp", "2", "neigh", "no",
"-sf", "omp",
"-log", "none",
"-nocite"};
const char *args[] = {"liblammps", "-pk", "omp", "2", "neigh", "no",
"-sf", "omp", "-log", "none", "-nocite"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
@ -139,7 +145,8 @@ TEST(lammps_open_no_mpi, with_omp) {
void *alt_ptr;
void *handle = lammps_open_no_mpi(argc, argv, &alt_ptr);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,6).c_str(),"LAMMPS");
EXPECT_THAT(output, StartsWith("LAMMPS ("));
if (verbose) std::cout << output;
EXPECT_EQ(handle, alt_ptr);
LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle;
@ -155,10 +162,12 @@ TEST(lammps_open_no_mpi, with_omp) {
::testing::internal::CaptureStdout();
lammps_close(handle);
output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:");
EXPECT_THAT(output, HasSubstr("Total wall time:"));
if (verbose) std::cout << output;
}
TEST(lammps_open_fortran, no_args) {
TEST(lammps_open_fortran, no_args)
{
// MPI is already initialized
MPI_Comm mycomm;
MPI_Comm_split(MPI_COMM_WORLD, 0, 1, &mycomm);
@ -166,7 +175,8 @@ TEST(lammps_open_fortran, no_args) {
::testing::internal::CaptureStdout();
void *handle = lammps_open_fortran(0, NULL, fcomm);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,6).c_str(),"LAMMPS");
EXPECT_THAT(output, StartsWith("LAMMPS ("));
if (verbose) std::cout << output;
LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle;
// MPI STUBS uses no real communicators
@ -182,5 +192,6 @@ TEST(lammps_open_fortran, no_args) {
::testing::internal::CaptureStdout();
lammps_close(handle);
output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:");
EXPECT_THAT(output, HasSubstr("Total wall time:"));
if (verbose) std::cout << output;
}

201
unittest/c-library/test_library_properties.cpp
View File

@ -1,47 +1,61 @@
// unit tests for checking and changing simulation properties through the library interface
#include "library.h"
#include "lammps.h"
#include "library.h"
#include <string>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
const char *demo_input[] = {
"region box block 0 $x 0 2 0 2",
"create_box 1 box",
"create_atoms 1 single 1.0 1.0 ${zpos}" };
const char *cont_input[] = {
"create_atoms 1 single &",
"0.2 0.1 0.1" };
#include "test_main.h"
class LAMMPS_properties : public ::testing::Test
{
#define STRINGIFY(val) XSTR(val)
#define XSTR(val) #val
using ::testing::HasSubstr;
using ::testing::StartsWith;
class LibraryProperties : public ::testing::Test {
protected:
void *lmp;
LAMMPS_properties() {};
~LAMMPS_properties() override {};
std::string INPUT_DIR = STRINGIFY(TEST_INPUT_FOLDER);
void SetUp() override {
LibraryProperties(){};
~LibraryProperties() override{};
void SetUp() override
{
const char *args[] = {"LAMMPS_test", "-log", "none",
"-echo", "screen", "-nocite" };
"-echo", "screen", "-nocite",
"-var", "input_dir", STRINGIFY(TEST_INPUT_FOLDER)};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
::testing::internal::CaptureStdout();
lmp = lammps_open_no_mpi(argc, argv, NULL);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,8).c_str(), "LAMMPS (");
if (verbose) std::cout << output;
EXPECT_THAT(output, StartsWith("LAMMPS ("));
}
void TearDown() override {
void TearDown() override
{
::testing::internal::CaptureStdout();
lammps_close(lmp);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:");
EXPECT_THAT(output, HasSubstr("Total wall time:"));
if (verbose) std::cout << output;
lmp = nullptr;
}
};
TEST_F(LAMMPS_properties, get_mpi_comm) {
TEST_F(LibraryProperties, version)
{
EXPECT_GE(20200824, lammps_version(lmp));
};
TEST_F(LibraryProperties, get_mpi_comm)
{
int f_comm = lammps_get_mpi_comm(lmp);
if (lammps_config_has_mpi_support())
EXPECT_GE(f_comm, 0);
@ -49,5 +63,154 @@ TEST_F(LAMMPS_properties, get_mpi_comm) {
EXPECT_EQ(f_comm, -1);
};
TEST_F(LAMMPS_properties, box) {
TEST_F(LibraryProperties, natoms)
{
if (!lammps_has_style(lmp, "atom", "full")) GTEST_SKIP();
std::string input = INPUT_DIR + PATH_SEP + "in.fourmol";
if (!verbose) ::testing::internal::CaptureStdout();
lammps_file(lmp, input.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_get_natoms(lmp), 29);
};
TEST_F(LibraryProperties, thermo)
{
if (!lammps_has_style(lmp, "atom", "full")) GTEST_SKIP();
std::string input = INPUT_DIR + PATH_SEP + "in.fourmol";
if (!verbose) ::testing::internal::CaptureStdout();
lammps_file(lmp, input.c_str());
lammps_command(lmp, "run 2 post no");
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_get_thermo(lmp, "step"), 2);
EXPECT_EQ(lammps_get_thermo(lmp, "atoms"), 29);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "vol"), 3375.0);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "density"), 0.12211250945013695);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "cellalpha"), 90.0);
};
TEST_F(LibraryProperties, box)
{
if (!lammps_has_style(lmp, "atom", "full")) GTEST_SKIP();
std::string input = INPUT_DIR + PATH_SEP + "in.fourmol";
if (!verbose) ::testing::internal::CaptureStdout();
lammps_file(lmp, input.c_str());
lammps_command(lmp, "run 2 post no");
if (!verbose) ::testing::internal::GetCapturedStdout();
double boxlo[3], boxhi[3], xy, yz, xz;
int pflags[3], boxflag;
lammps_extract_box(lmp, boxlo, boxhi, &xy, &yz, &xz, pflags, &boxflag);
EXPECT_DOUBLE_EQ(boxlo[0], -6.024572);
EXPECT_DOUBLE_EQ(boxlo[1], -7.692866);
EXPECT_DOUBLE_EQ(boxlo[2], -8.086924);
EXPECT_DOUBLE_EQ(boxhi[0], 8.975428);
EXPECT_DOUBLE_EQ(boxhi[1], 7.307134);
EXPECT_DOUBLE_EQ(boxhi[2], 6.913076);
EXPECT_DOUBLE_EQ(xy, 0.0);
EXPECT_DOUBLE_EQ(yz, 0.0);
EXPECT_DOUBLE_EQ(xz, 0.0);
EXPECT_EQ(pflags[0], 1);
EXPECT_EQ(pflags[1], 1);
EXPECT_EQ(pflags[2], 1);
EXPECT_EQ(boxflag, 0);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "vol"), 3375.0);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "density"), 0.12211250945013695);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "cellalpha"), 90.0);
if (!verbose) ::testing::internal::CaptureStdout();
lammps_command(lmp, "change_box all boundary p p f triclinic xy final 0.5");
lammps_command(lmp, "fix box all box/relax x 0.0 y 0.0");
if (!verbose) ::testing::internal::GetCapturedStdout();
lammps_extract_box(lmp, boxlo, boxhi, &xy, &yz, &xz, pflags, &boxflag);
EXPECT_DOUBLE_EQ(boxlo[0], -6.024572);
EXPECT_DOUBLE_EQ(boxlo[1], -7.692866);
EXPECT_DOUBLE_EQ(boxlo[2], -8.086924);
EXPECT_DOUBLE_EQ(boxhi[0], 8.975428);
EXPECT_DOUBLE_EQ(boxhi[1], 7.307134);
EXPECT_DOUBLE_EQ(boxhi[2], 6.913076);
EXPECT_DOUBLE_EQ(xy, 0.5);
EXPECT_DOUBLE_EQ(yz, 0.0);
EXPECT_DOUBLE_EQ(xz, 0.0);
EXPECT_EQ(pflags[0], 1);
EXPECT_EQ(pflags[1], 1);
EXPECT_EQ(pflags[2], 0);
EXPECT_EQ(boxflag, 1);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "vol"), 3375.0);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "density"), 0.12211250945013695);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "cellalpha"), 90.0);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "cellbeta"), 90.0);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "cellgamma"), 88.090847567003621);
boxlo[0] = -6.1;
boxhi[1] = 7.3;
xy = 0.1;
lammps_reset_box(lmp, boxlo, boxhi, xy, yz, xz);
lammps_extract_box(lmp, boxlo, boxhi, &xy, &yz, &xz, pflags, &boxflag);
EXPECT_DOUBLE_EQ(boxlo[0], -6.1);
EXPECT_DOUBLE_EQ(boxlo[1], -7.692866);
EXPECT_DOUBLE_EQ(boxlo[2], -8.086924);
EXPECT_DOUBLE_EQ(boxhi[0], 8.975428);
EXPECT_DOUBLE_EQ(boxhi[1], 7.3);
EXPECT_DOUBLE_EQ(boxhi[2], 6.913076);
EXPECT_DOUBLE_EQ(xy, 0.1);
EXPECT_DOUBLE_EQ(yz, 0.0);
EXPECT_DOUBLE_EQ(xz, 0.0);
EXPECT_EQ(pflags[0], 1);
EXPECT_EQ(pflags[1], 1);
EXPECT_EQ(pflags[2], 0);
EXPECT_EQ(boxflag, 1);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "vol"), 3390.3580784497199);
EXPECT_DOUBLE_EQ(lammps_get_thermo(lmp, "cellgamma"), 89.61785205109274);
};
TEST_F(LibraryProperties, setting)
{
#if defined(LAMMPS_SMALLSMALL)
EXPECT_EQ(lammps_extract_setting(lmp, "bigint"), 4);
#else
EXPECT_EQ(lammps_extract_setting(lmp, "bigint"), 8);
#endif
#if defined(LAMMPS_BIGBIG)
EXPECT_EQ(lammps_extract_setting(lmp, "tagint"), 8);
EXPECT_EQ(lammps_extract_setting(lmp, "imageint"), 8);
#else
EXPECT_EQ(lammps_extract_setting(lmp, "tagint"), 4);
EXPECT_EQ(lammps_extract_setting(lmp, "imageint"), 4);
#endif
EXPECT_EQ(lammps_extract_setting(lmp, "box_exist"), 0);
if (!verbose) ::testing::internal::CaptureStdout();
lammps_command(lmp, "dimension 2");
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_extract_setting(lmp, "dimension"), 2);
if (!verbose) ::testing::internal::CaptureStdout();
lammps_command(lmp, "dimension 3");
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_extract_setting(lmp, "molecule_flag"), 0);
EXPECT_EQ(lammps_extract_setting(lmp, "q_flag"), 0);
EXPECT_EQ(lammps_extract_setting(lmp, "mu_flag"), 0);
EXPECT_EQ(lammps_extract_setting(lmp, "rmass_flag"), 0);
EXPECT_EQ(lammps_extract_setting(lmp, "UNKNOWN"), -1);
if (lammps_has_style(lmp, "atom", "full")) {
std::string input = INPUT_DIR + PATH_SEP + "in.fourmol";
if (!verbose) ::testing::internal::CaptureStdout();
lammps_file(lmp, input.c_str());
lammps_command(lmp, "run 2 post no");
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_extract_setting(lmp, "triclinic"), 0);
EXPECT_EQ(lammps_extract_setting(lmp, "box_exist"), 1);
EXPECT_EQ(lammps_extract_setting(lmp, "dimension"), 3);
EXPECT_EQ(lammps_extract_setting(lmp, "nlocal"), 29);
EXPECT_EQ(lammps_extract_setting(lmp, "nghost"), 518);
EXPECT_EQ(lammps_extract_setting(lmp, "nall"), 547);
EXPECT_EQ(lammps_extract_setting(lmp, "nmax"), 16384);
EXPECT_EQ(lammps_extract_setting(lmp, "molecule_flag"), 1);
EXPECT_EQ(lammps_extract_setting(lmp, "q_flag"), 1);
EXPECT_EQ(lammps_extract_setting(lmp, "mu_flag"), 0);
EXPECT_EQ(lammps_extract_setting(lmp, "rmass_flag"), 0);
if (!verbose) ::testing::internal::CaptureStdout();
lammps_command(lmp, "change_box all triclinic");
lammps_command(lmp, "fix rmass all property/atom rmass ghost yes");
if (!verbose) ::testing::internal::GetCapturedStdout();
EXPECT_EQ(lammps_extract_setting(lmp, "triclinic"), 1);
EXPECT_EQ(lammps_extract_setting(lmp, "rmass_flag"), 1);
}
};

59
unittest/c-library/test_main.cpp Normal file
View File

@ -0,0 +1,59 @@
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "test_main.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <iostream>
#include <mpi.h>
// whether to print verbose output (i.e. not capturing LAMMPS screen output).
bool verbose = false;
int main(int argc, char **argv)
{
MPI_Init(&argc, &argv);
::testing::InitGoogleMock(&argc, argv);
if (argc < 1) {
return 1;
}
// handle arguments passed via environment variable
if (const char *var = getenv("TEST_ARGS")) {
std::vector<std::string> env = LAMMPS_NS::utils::split_words(var);
for (auto arg : env) {
if (arg == "-v") {
verbose = true;
}
}
}
int iarg = 1;
while (iarg < argc) {
if (strcmp(argv[iarg], "-v") == 0) {
verbose = true;
++iarg;
} else {
std::cerr << "unknown option: " << argv[iarg] << "\n\n";
MPI_Finalize();
return 1;
}
}
int rv = RUN_ALL_TESTS();
MPI_Finalize();
return rv;
}

33
unittest/c-library/test_main.h Normal file
View File

@ -0,0 +1,33 @@
/* -*- c++ -*- ----------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#ifndef TEST_MAIN_H
#define TEST_MAIN_H
extern bool verbose;
#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; \
EXPECT_PRED_FORMAT2(::testing::DoubleLE, err, eps); \
} while (0);
#endif
#if defined _WIN32
static const char PATH_SEP = '\\';
#else
static const char PATH_SEP = '/';
#endif