From af3d618f474349d68920c5f20daf1621bd604bda Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Mon, 3 Oct 2022 23:18:44 -0400 Subject: [PATCH 1/9] complete implementation of looking up last error message and include test --- fortran/lammps.f90 | 29 ++++++++++-------- unittest/fortran/CMakeLists.txt | 2 +- unittest/fortran/test_fortran_properties.f90 | 23 +++++++++++++++ unittest/fortran/wrap_properties.cpp | 31 +++++++++++++++++--- 4 files changed, 67 insertions(+), 18 deletions(-) diff --git a/fortran/lammps.f90 b/fortran/lammps.f90 index 2e552f22f0..2a4a16bdd0 100644 --- a/fortran/lammps.f90 +++ b/fortran/lammps.f90 @@ -1552,7 +1552,7 @@ CONTAINS TYPE(c_ptr) :: ptr INTEGER :: i - buffer = '' + buffer = ' ' ptr = C_LOC(Cbuffer(1)) buf_size = LEN(buffer) CALL lammps_get_os_info(ptr, buf_size) @@ -1699,25 +1699,28 @@ CONTAINS CLASS(lammps), INTENT(IN) :: self CHARACTER(LEN=*), INTENT(OUT) :: buffer INTEGER, INTENT(OUT), OPTIONAL :: status - INTEGER(c_int) :: length, Cstatus, i + INTEGER(c_int) :: buflen, Cstatus, i + INTEGER(c_size_t) :: length TYPE(c_ptr) :: Cptr - CHARACTER(KIND=c_char, LEN=1), DIMENSION(:), POINTER :: Cbuffer + CHARACTER(LEN=1, KIND=c_char), POINTER :: c_string(:) - buffer = '' + buffer = ' ' IF ( lmp_has_error(self) ) THEN - length = LEN(buffer) - Cptr = f2c_string(buffer) - Cstatus = lammps_get_last_error_message(self%handle, Cptr, length) - length = MIN(LEN(buffer, c_size_t), c_strlen(Cptr)) - CALL C_F_POINTER(Cptr, Cbuffer, [length]) - FORALL ( i=1:length ) - buffer(i:i) = Cbuffer(i) - END FORALL + buflen = LEN(buffer) + length = buflen + Cptr = lammps_malloc(length) + Cstatus = lammps_get_last_error_message(self%handle, Cptr, buflen) + CALL C_F_POINTER(Cptr, c_string, [1]) + DO i=1, length + buffer(i:i) = c_string(i) + IF (c_string(i) == c_null_char) EXIT + END DO IF ( PRESENT(status) ) THEN status = Cstatus END IF + CALL lammps_free(Cptr) ELSE - buffer = '' + buffer = ' ' IF ( PRESENT(status) ) THEN status = 0 END IF diff --git a/unittest/fortran/CMakeLists.txt b/unittest/fortran/CMakeLists.txt index d3c18c9941..70ab462053 100644 --- a/unittest/fortran/CMakeLists.txt +++ b/unittest/fortran/CMakeLists.txt @@ -50,7 +50,7 @@ if(CMAKE_Fortran_COMPILER) add_test(NAME FortranBox COMMAND test_fortran_box) add_executable(test_fortran_properties wrap_properties.cpp test_fortran_properties.f90 test_fortran_commands.f90) - target_link_libraries(test_fortran_properties PRIVATE flammps lammps MPI::MPI_Fortran GTest::GTestMain) + target_link_libraries(test_fortran_properties PRIVATE flammps lammps MPI::MPI_Fortran GTest::GMockMain) add_test(NAME FortranProperties COMMAND test_fortran_properties) add_executable(test_fortran_extract_global wrap_extract_global.cpp test_fortran_extract_global.f90) diff --git a/unittest/fortran/test_fortran_properties.f90 b/unittest/fortran/test_fortran_properties.f90 index 153cab8c77..e8ea330bd6 100644 --- a/unittest/fortran/test_fortran_properties.f90 +++ b/unittest/fortran/test_fortran_properties.f90 @@ -64,3 +64,26 @@ FUNCTION f_lammps_has_error () BIND(C) f_lammps_has_error = 0_C_int END IF END FUNCTION f_lammps_has_error + +FUNCTION f_lammps_get_last_error_message(errmesg, errlen) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int, C_char, C_ptr, C_F_POINTER + USE keepstuff, ONLY : lmp + USE LIBLAMMPS + IMPLICIT NONE + INTEGER(C_int) :: f_lammps_get_last_error_message + CHARACTER(KIND=c_char), DIMENSION(*) :: errmesg + INTEGER(C_int), VALUE, INTENT(IN) :: errlen + CHARACTER(LEN=:), ALLOCATABLE :: buffer + INTEGER :: status, i + + ! copy error message to buffer + ALLOCATE(CHARACTER(errlen) :: buffer) + CALL lmp%get_last_error_message(buffer, status) + f_lammps_get_last_error_message = status + ! and copy to C style string + DO i=1, errlen + errmesg(i) = buffer(i:i) + IF (buffer(i:i) == ACHAR(0)) EXIT + END DO + DEALLOCATE(buffer) +END FUNCTION f_lammps_get_last_error_message diff --git a/unittest/fortran/wrap_properties.cpp b/unittest/fortran/wrap_properties.cpp index d53aabb8fa..21c953a514 100644 --- a/unittest/fortran/wrap_properties.cpp +++ b/unittest/fortran/wrap_properties.cpp @@ -2,9 +2,10 @@ #include "lammps.h" #include "library.h" -#include + #include +#include "gmock/gmock.h" #include "gtest/gtest.h" // prototypes for fortran reverse wrapper functions @@ -16,8 +17,13 @@ void f_lammps_memory_usage(double*); int f_lammps_get_mpi_comm(); int f_lammps_extract_setting(const char*); int f_lammps_has_error(); +int f_lammps_get_last_error_message(char *, int); } +namespace LAMMPS_NS { + +using ::testing::ContainsRegex; + class LAMMPS_properties : public ::testing::Test { protected: LAMMPS_NS::LAMMPS *lmp; @@ -105,11 +111,28 @@ TEST_F(LAMMPS_properties, extract_setting) EXPECT_EQ(f_lammps_extract_setting("mu_flag"), 0); EXPECT_EQ(f_lammps_extract_setting("rmass_flag"), 0); EXPECT_EQ(f_lammps_extract_setting("UNKNOWN"), -1); - }; TEST_F(LAMMPS_properties, has_error) { - EXPECT_EQ(f_lammps_has_error(), lammps_has_error(lmp)); - // TODO: How to test the error message itself? + // need errors to throw exceptions to be able to intercept them. + if (!lammps_config_has_exceptions()) GTEST_SKIP(); + + EXPECT_EQ(f_lammps_has_error(), lammps_has_error(lmp)); + EXPECT_EQ(f_lammps_has_error(), 0); + + // trigger an error, but hide output + ::testing::internal::CaptureStdout(); + lammps_command(lmp, "this_is_not_a_known_command"); + ::testing::internal::GetCapturedStdout(); + + EXPECT_EQ(f_lammps_has_error(), lammps_has_error(lmp)); + EXPECT_EQ(f_lammps_has_error(), 1); + + // retrieve error message + char errmsg[1024]; + int err = f_lammps_get_last_error_message(errmsg, 1023); + EXPECT_EQ(err, 1); + EXPECT_THAT(errmsg, ContainsRegex(".*ERRORx: Unknown command: this_is_not_a_known_command.*")); }; +} // namespace LAMMPS_NS From 337443528180e452211f942feb6b050025a23f02 Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Mon, 3 Oct 2022 23:19:05 -0400 Subject: [PATCH 2/9] add note that integer sizes can be queried without a LAMMPS handle --- src/library.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/library.cpp b/src/library.cpp index bfa0fc803a..a2a632c244 100644 --- a/src/library.cpp +++ b/src/library.cpp @@ -949,7 +949,8 @@ int lammps_get_mpi_comm(void *handle) This function will retrieve or compute global properties. In contrast to :cpp:func:`lammps_get_thermo` this function returns an ``int``. The following tables list the currently supported keyword. If a keyword is -not recognized, the function returns -1. +not recognized, the function returns -1. The integer sizes functions may +be called without a valid LAMMPS object handle (it is ignored). * :ref:`Integer sizes ` * :ref:`System status ` From 647c5e3572fdc951f1b5f34f248360523cda9771 Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Mon, 3 Oct 2022 23:19:59 -0400 Subject: [PATCH 3/9] apply clang-format --- unittest/fortran/wrap_box.cpp | 6 +- unittest/fortran/wrap_extract_atom.cpp | 100 +++---- unittest/fortran/wrap_extract_compute.cpp | 202 +++++++------- unittest/fortran/wrap_extract_fix.cpp | 86 +++--- unittest/fortran/wrap_extract_global.cpp | 124 ++++----- unittest/fortran/wrap_extract_variable.cpp | 305 +++++++++++---------- unittest/fortran/wrap_gather_scatter.cpp | 278 +++++++++---------- unittest/fortran/wrap_properties.cpp | 30 +- 8 files changed, 563 insertions(+), 568 deletions(-) diff --git a/unittest/fortran/wrap_box.cpp b/unittest/fortran/wrap_box.cpp index 8678816658..5eb9a6b18d 100644 --- a/unittest/fortran/wrap_box.cpp +++ b/unittest/fortran/wrap_box.cpp @@ -55,10 +55,10 @@ TEST_F(LAMMPS_commands, get_thermo) EXPECT_DOUBLE_EQ(f_lammps_extract_box_zhi(), 2.0); f_lammps_delete_everything(); 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_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_zlo(),-1.0); + EXPECT_DOUBLE_EQ(f_lammps_extract_box_zlo(), -1.0); EXPECT_DOUBLE_EQ(f_lammps_extract_box_zhi(), 3.0); }; diff --git a/unittest/fortran/wrap_extract_atom.cpp b/unittest/fortran/wrap_extract_atom.cpp index 17116b11b9..2552d6a10f 100644 --- a/unittest/fortran/wrap_extract_atom.cpp +++ b/unittest/fortran/wrap_extract_atom.cpp @@ -3,10 +3,10 @@ #include "lammps.h" #include "library.h" +#include +#include #include #include -#include -#include #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); int f_lammps_extract_atom_type(int); int f_lammps_extract_atom_mask(int); -void f_lammps_extract_atom_x(int,double*); -void f_lammps_extract_atom_v(int,double*); +void f_lammps_extract_atom_x(int, double *); +void f_lammps_extract_atom_v(int, double *); } class LAMMPS_extract_atom : public ::testing::Test { @@ -49,72 +49,72 @@ protected: TEST_F(LAMMPS_extract_atom, mass) { - f_lammps_setup_extract_atom(); - EXPECT_DOUBLE_EQ(f_lammps_extract_atom_mass(), 2.0); + f_lammps_setup_extract_atom(); + EXPECT_DOUBLE_EQ(f_lammps_extract_atom_mass(), 2.0); }; TEST_F(LAMMPS_extract_atom, tag) { - f_lammps_setup_extract_atom(); -#ifdef LAMMPS_BIGBIG - EXPECT_EQ(f_lammps_extract_atom_tag_int64(1l), 1l); - EXPECT_EQ(f_lammps_extract_atom_tag_int64(2l), 2l); + f_lammps_setup_extract_atom(); +#if defined(LAMMPS_BIGBIG) + EXPECT_EQ(f_lammps_extract_atom_tag_int64(1l), 1l); + EXPECT_EQ(f_lammps_extract_atom_tag_int64(2l), 2l); #else - 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(1), 1); + EXPECT_EQ(f_lammps_extract_atom_tag_int(2), 2); #endif }; TEST_F(LAMMPS_extract_atom, type) { - f_lammps_setup_extract_atom(); - EXPECT_EQ(f_lammps_extract_atom_type(1), 1); - EXPECT_EQ(f_lammps_extract_atom_type(2), 1); + f_lammps_setup_extract_atom(); + EXPECT_EQ(f_lammps_extract_atom_type(1), 1); + EXPECT_EQ(f_lammps_extract_atom_type(2), 1); }; TEST_F(LAMMPS_extract_atom, mask) { - f_lammps_setup_extract_atom(); - EXPECT_EQ(f_lammps_extract_atom_mask(1), 1); - EXPECT_EQ(f_lammps_extract_atom_mask(2), 1); - lammps_command(lmp, "group 1 id 1"); - lammps_command(lmp, "group 2 id 2"); - EXPECT_EQ(f_lammps_extract_atom_mask(1), 3); - EXPECT_EQ(f_lammps_extract_atom_mask(2), 5); + f_lammps_setup_extract_atom(); + EXPECT_EQ(f_lammps_extract_atom_mask(1), 1); + EXPECT_EQ(f_lammps_extract_atom_mask(2), 1); + lammps_command(lmp, "group 1 id 1"); + lammps_command(lmp, "group 2 id 2"); + EXPECT_EQ(f_lammps_extract_atom_mask(1), 3); + EXPECT_EQ(f_lammps_extract_atom_mask(2), 5); }; TEST_F(LAMMPS_extract_atom, x) { - f_lammps_setup_extract_atom(); - double x1[3]; - double x2[3]; - f_lammps_extract_atom_x(1, x1); - EXPECT_DOUBLE_EQ(x1[0], 1.0); - EXPECT_DOUBLE_EQ(x1[1], 1.0); - EXPECT_DOUBLE_EQ(x1[2], 1.5); - f_lammps_extract_atom_x(2, x2); - EXPECT_DOUBLE_EQ(x2[0], 0.2); - EXPECT_DOUBLE_EQ(x2[1], 0.1); - EXPECT_DOUBLE_EQ(x2[2], 0.1); + f_lammps_setup_extract_atom(); + double x1[3]; + double x2[3]; + f_lammps_extract_atom_x(1, x1); + EXPECT_DOUBLE_EQ(x1[0], 1.0); + EXPECT_DOUBLE_EQ(x1[1], 1.0); + EXPECT_DOUBLE_EQ(x1[2], 1.5); + f_lammps_extract_atom_x(2, x2); + EXPECT_DOUBLE_EQ(x2[0], 0.2); + EXPECT_DOUBLE_EQ(x2[1], 0.1); + EXPECT_DOUBLE_EQ(x2[2], 0.1); } TEST_F(LAMMPS_extract_atom, v) { - f_lammps_setup_extract_atom(); - double v1[3]; - double v2[3]; - f_lammps_extract_atom_v(1, v1); - EXPECT_DOUBLE_EQ(v1[0], 0.0); - EXPECT_DOUBLE_EQ(v1[1], 0.0); - EXPECT_DOUBLE_EQ(v1[2], 0.0); - f_lammps_extract_atom_v(2, v2); - EXPECT_DOUBLE_EQ(v2[0], 0.0); - EXPECT_DOUBLE_EQ(v2[1], 0.0); - EXPECT_DOUBLE_EQ(v2[2], 0.0); - lammps_command(lmp, "group one id 1"); - lammps_command(lmp, "velocity one set 1 2 3"); - f_lammps_extract_atom_v(1, v1); - EXPECT_DOUBLE_EQ(v1[0], 1.0); - EXPECT_DOUBLE_EQ(v1[1], 2.0); - EXPECT_DOUBLE_EQ(v1[2], 3.0); + f_lammps_setup_extract_atom(); + double v1[3]; + double v2[3]; + f_lammps_extract_atom_v(1, v1); + EXPECT_DOUBLE_EQ(v1[0], 0.0); + EXPECT_DOUBLE_EQ(v1[1], 0.0); + EXPECT_DOUBLE_EQ(v1[2], 0.0); + f_lammps_extract_atom_v(2, v2); + EXPECT_DOUBLE_EQ(v2[0], 0.0); + EXPECT_DOUBLE_EQ(v2[1], 0.0); + EXPECT_DOUBLE_EQ(v2[2], 0.0); + lammps_command(lmp, "group one id 1"); + lammps_command(lmp, "velocity one set 1 2 3"); + f_lammps_extract_atom_v(1, v1); + EXPECT_DOUBLE_EQ(v1[0], 1.0); + EXPECT_DOUBLE_EQ(v1[1], 2.0); + EXPECT_DOUBLE_EQ(v1[2], 3.0); } diff --git a/unittest/fortran/wrap_extract_compute.cpp b/unittest/fortran/wrap_extract_compute.cpp index 2325b1540f..5d6e8b1978 100644 --- a/unittest/fortran/wrap_extract_compute.cpp +++ b/unittest/fortran/wrap_extract_compute.cpp @@ -3,10 +3,10 @@ #include "lammps.h" #include "library.h" +#include +#include #include #include -#include -#include #include "gtest/gtest.h" @@ -16,12 +16,12 @@ void *f_lammps_with_args(); void f_lammps_close(); void f_lammps_setup_extract_compute(); 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_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_array(int,int); +double f_lammps_extract_compute_local_array(int, int); } class LAMMPS_extract_compute : public ::testing::Test { @@ -49,126 +49,120 @@ protected: TEST_F(LAMMPS_extract_compute, peratom_vector) { - 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(2), 391.817623795857); - EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_vector(3), 391.430665759871); - + 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(2), 391.817623795857); + EXPECT_DOUBLE_EQ(f_lammps_extract_compute_peratom_vector(3), 391.430665759871); }; TEST_F(LAMMPS_extract_compute, peratom_array) { - 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(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(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(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(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(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(6,2), -1903.5971655908565); + 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(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(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(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(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(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(6, 2), -1903.5971655908565); }; TEST_F(LAMMPS_extract_compute, global_scalar) { - f_lammps_setup_extract_compute(); - double *scalar; - scalar = (double*) lammps_extract_compute(lmp, "totalpe", LMP_STYLE_GLOBAL, - LMP_TYPE_SCALAR); - //EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_scalar(), 782.64858645328); - EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_scalar(), *scalar); + f_lammps_setup_extract_compute(); + double *scalar; + scalar = (double *)lammps_extract_compute(lmp, "totalpe", LMP_STYLE_GLOBAL, LMP_TYPE_SCALAR); + // EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_scalar(), 782.64858645328); + EXPECT_DOUBLE_EQ(f_lammps_extract_compute_global_scalar(), *scalar); }; TEST_F(LAMMPS_extract_compute, global_vector) { - f_lammps_setup_extract_compute(); - double *vector; - vector = (double*) lammps_extract_compute(lmp, "COM", LMP_STYLE_GLOBAL, - LMP_TYPE_VECTOR); - 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(3), vector[2]); + f_lammps_setup_extract_compute(); + double *vector; + vector = (double *)lammps_extract_compute(lmp, "COM", LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR); + 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(3), vector[2]); }; TEST_F(LAMMPS_extract_compute, global_array) { - f_lammps_setup_extract_compute(); - double **array; - array = (double**) lammps_extract_compute(lmp, "RDF", LMP_STYLE_GLOBAL, - 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(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(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,4), array[3][0]); + f_lammps_setup_extract_compute(); + double **array; + array = (double **)lammps_extract_compute(lmp, "RDF", LMP_STYLE_GLOBAL, 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(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(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, 4), array[3][0]); }; TEST_F(LAMMPS_extract_compute, local_vector) { - f_lammps_setup_extract_compute(); - double *vector; - vector = (double*) lammps_extract_compute(lmp, "pairdist", LMP_STYLE_LOCAL, - LMP_TYPE_VECTOR); - 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(3), vector[2]); - 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(6), vector[5]); - 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(9), vector[8]); - EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(10), vector[9]); + f_lammps_setup_extract_compute(); + double *vector; + vector = (double *)lammps_extract_compute(lmp, "pairdist", LMP_STYLE_LOCAL, LMP_TYPE_VECTOR); + 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(3), vector[2]); + 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(6), vector[5]); + 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(9), vector[8]); + EXPECT_DOUBLE_EQ(f_lammps_extract_compute_local_vector(10), vector[9]); }; TEST_F(LAMMPS_extract_compute, local_array) { - f_lammps_setup_extract_compute(); - double **array; - array = (double**) lammps_extract_compute(lmp, "pairlocal", LMP_STYLE_LOCAL, - 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(4,10), array[9][3]); + f_lammps_setup_extract_compute(); + double **array; + array = (double **)lammps_extract_compute(lmp, "pairlocal", LMP_STYLE_LOCAL, 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(4, 10), array[9][3]); }; diff --git a/unittest/fortran/wrap_extract_fix.cpp b/unittest/fortran/wrap_extract_fix.cpp index d8f19c8b95..bbb535c1e7 100644 --- a/unittest/fortran/wrap_extract_fix.cpp +++ b/unittest/fortran/wrap_extract_fix.cpp @@ -4,10 +4,10 @@ #include "lammps.h" #include "library.h" +#include +#include #include #include -#include -#include #include "gtest/gtest.h" @@ -18,11 +18,11 @@ void f_lammps_close(); void f_lammps_setup_extract_fix(); double f_lammps_extract_fix_global_scalar(); 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_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_array(int,int); +double f_lammps_extract_fix_local_array(int, int); } class LAMMPS_extract_fix : public ::testing::Test { @@ -50,58 +50,58 @@ protected: TEST_F(LAMMPS_extract_fix, global_scalar) { - f_lammps_setup_extract_fix(); - double *scalar = (double*) lammps_extract_fix(lmp, "recenter", - LMP_STYLE_GLOBAL, LMP_TYPE_SCALAR, -1, -1); - EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_scalar(), *scalar); - lammps_free(scalar); + f_lammps_setup_extract_fix(); + double *scalar = + (double *)lammps_extract_fix(lmp, "recenter", LMP_STYLE_GLOBAL, LMP_TYPE_SCALAR, -1, -1); + EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_scalar(), *scalar); + lammps_free(scalar); }; TEST_F(LAMMPS_extract_fix, global_vector) { - f_lammps_setup_extract_fix(); - double *x = (double*) lammps_extract_fix(lmp, "recenter", - LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR, 0, -1); - double *y = (double*) lammps_extract_fix(lmp, "recenter", - LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR, 1, -1); - double *z = (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(2), *y); - EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_vector(3), *z); - lammps_free(x); - lammps_free(y); - lammps_free(z); + f_lammps_setup_extract_fix(); + double *x = + (double *)lammps_extract_fix(lmp, "recenter", LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR, 0, -1); + double *y = + (double *)lammps_extract_fix(lmp, "recenter", LMP_STYLE_GLOBAL, LMP_TYPE_VECTOR, 1, -1); + double *z = + (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(2), *y); + EXPECT_DOUBLE_EQ(f_lammps_extract_fix_global_vector(3), *z); + lammps_free(x); + lammps_free(y); + lammps_free(z); }; TEST_F(LAMMPS_extract_fix, global_array) { - f_lammps_setup_extract_fix(); - 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,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,2), 1.0); + f_lammps_setup_extract_fix(); + 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, 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, 2), 1.0); }; TEST_F(LAMMPS_extract_fix, peratom_vector) { - 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(2), 0.1); - EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_vector(3), 0.5); + 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(2), 0.1); + EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_vector(3), 0.5); }; TEST_F(LAMMPS_extract_fix, peratom_array) { - 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(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(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(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(2,3), 0.5); - EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(3,3), 0.5); + 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(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(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(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(2, 3), 0.5); + EXPECT_DOUBLE_EQ(f_lammps_extract_fix_peratom_array(3, 3), 0.5); }; diff --git a/unittest/fortran/wrap_extract_global.cpp b/unittest/fortran/wrap_extract_global.cpp index adf3986073..bf442279a1 100644 --- a/unittest/fortran/wrap_extract_global.cpp +++ b/unittest/fortran/wrap_extract_global.cpp @@ -3,10 +3,10 @@ #include "lammps.h" #include "library.h" +#include +#include #include #include -#include -#include #include "gtest/gtest.h" @@ -78,100 +78,100 @@ protected: TEST_F(LAMMPS_extract_global, units) { - f_lammps_setup_extract_global(); - EXPECT_EQ(f_lammps_extract_global_units(), 1); + f_lammps_setup_extract_global(); + EXPECT_EQ(f_lammps_extract_global_units(), 1); }; TEST_F(LAMMPS_extract_global, ntimestep) { - f_lammps_setup_extract_global(); + f_lammps_setup_extract_global(); #ifdef LAMMPS_SMALLSMALL - EXPECT_EQ(f_lammps_extract_global_ntimestep(), 0); + EXPECT_EQ(f_lammps_extract_global_ntimestep(), 0); #else - EXPECT_EQ(f_lammps_extract_global_ntimestep_big(), 0l); + EXPECT_EQ(f_lammps_extract_global_ntimestep_big(), 0l); #endif }; TEST_F(LAMMPS_extract_global, dt) { - f_lammps_setup_extract_global(); - EXPECT_DOUBLE_EQ(f_lammps_extract_global_dt(), 0.005); + f_lammps_setup_extract_global(); + EXPECT_DOUBLE_EQ(f_lammps_extract_global_dt(), 0.005); }; TEST_F(LAMMPS_extract_global, boxprops) { - f_lammps_setup_extract_global(); - double boxlo[3], boxhi[3]; - f_lammps_extract_global_boxlo(boxlo); - EXPECT_DOUBLE_EQ(boxlo[0], 0.0); - EXPECT_DOUBLE_EQ(boxlo[1], 0.0); - EXPECT_DOUBLE_EQ(boxlo[2], 0.0); - f_lammps_extract_global_boxhi(boxhi); - EXPECT_DOUBLE_EQ(boxhi[0], 2.0); - EXPECT_DOUBLE_EQ(boxhi[1], 3.0); - EXPECT_DOUBLE_EQ(boxhi[2], 4.0); + f_lammps_setup_extract_global(); + double boxlo[3], boxhi[3]; + f_lammps_extract_global_boxlo(boxlo); + EXPECT_DOUBLE_EQ(boxlo[0], 0.0); + EXPECT_DOUBLE_EQ(boxlo[1], 0.0); + EXPECT_DOUBLE_EQ(boxlo[2], 0.0); + f_lammps_extract_global_boxhi(boxhi); + EXPECT_DOUBLE_EQ(boxhi[0], 2.0); + EXPECT_DOUBLE_EQ(boxhi[1], 3.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_boxxhi(), 2.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_boxzlo(), 0.0); - EXPECT_DOUBLE_EQ(f_lammps_extract_global_boxzhi(), 4.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_boxylo(), 0.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_boxzhi(), 4.0); - int periodicity[3]; - f_lammps_extract_global_periodicity(periodicity); - EXPECT_EQ(periodicity[0], 1); - EXPECT_EQ(periodicity[1], 1); - EXPECT_EQ(periodicity[2], 1); + int periodicity[3]; + f_lammps_extract_global_periodicity(periodicity); + EXPECT_EQ(periodicity[0], 1); + EXPECT_EQ(periodicity[1], 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_yz(), 0.0); - EXPECT_DOUBLE_EQ(f_lammps_extract_global_xz(), 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_xz(), 0.0); }; TEST_F(LAMMPS_extract_global, atomprops) { - f_lammps_setup_extract_global(); + f_lammps_setup_extract_global(); #ifdef LAMMPS_SMALLSMALL - EXPECT_EQ(f_lammps_extract_global_natoms(), 2); - EXPECT_EQ(f_lammps_extract_global_nbonds(), 0); - EXPECT_EQ(f_lammps_extract_global_nangles(), 0); - EXPECT_EQ(f_lammps_extract_global_ndihedrals(), 0); + EXPECT_EQ(f_lammps_extract_global_natoms(), 2); + EXPECT_EQ(f_lammps_extract_global_nbonds(), 0); + EXPECT_EQ(f_lammps_extract_global_nangles(), 0); + EXPECT_EQ(f_lammps_extract_global_ndihedrals(), 0); #else - EXPECT_EQ(f_lammps_extract_global_natoms_big(), 2l); - EXPECT_EQ(f_lammps_extract_global_nbonds_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_natoms_big(), 2l); + EXPECT_EQ(f_lammps_extract_global_nbonds_big(), 0l); + EXPECT_EQ(f_lammps_extract_global_nangles_big(), 0l); + EXPECT_EQ(f_lammps_extract_global_ndihedrals_big(), 0l); #endif - EXPECT_EQ(f_lammps_extract_global_ntypes(), 1); - EXPECT_EQ(f_lammps_extract_global_nlocal(), 2); - EXPECT_EQ(f_lammps_extract_global_nghost(), 41); - EXPECT_EQ(f_lammps_extract_global_nmax(), 16384); + EXPECT_EQ(f_lammps_extract_global_ntypes(), 1); + EXPECT_EQ(f_lammps_extract_global_nlocal(), 2); + EXPECT_EQ(f_lammps_extract_global_nghost(), 41); + 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_hplanck(), 1.0); - EXPECT_DOUBLE_EQ(f_lammps_extract_global_angstrom(), 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_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) { - if (! lammps_has_style(lmp, "atom", "full")) GTEST_SKIP(); - // This is not currently the world's most convincing test.... - f_lammps_setup_full_extract_global(); + if (!lammps_has_style(lmp, "atom", "full")) GTEST_SKIP(); + // This is not currently the world's most convincing test.... + f_lammps_setup_full_extract_global(); #ifdef LAMMPS_SMALLSMALL - EXPECT_EQ(f_lammps_extract_global_natoms(), 2); - EXPECT_EQ(f_lammps_extract_global_nbonds(), 0); - EXPECT_EQ(f_lammps_extract_global_nangles(), 0); - EXPECT_EQ(f_lammps_extract_global_ndihedrals(), 0); + EXPECT_EQ(f_lammps_extract_global_natoms(), 2); + EXPECT_EQ(f_lammps_extract_global_nbonds(), 0); + EXPECT_EQ(f_lammps_extract_global_nangles(), 0); + EXPECT_EQ(f_lammps_extract_global_ndihedrals(), 0); #else - EXPECT_EQ(f_lammps_extract_global_natoms_big(), 2l); - EXPECT_EQ(f_lammps_extract_global_nbonds_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_natoms_big(), 2l); + EXPECT_EQ(f_lammps_extract_global_nbonds_big(), 0l); + EXPECT_EQ(f_lammps_extract_global_nangles_big(), 0l); + EXPECT_EQ(f_lammps_extract_global_ndihedrals_big(), 0l); #endif } diff --git a/unittest/fortran/wrap_extract_variable.cpp b/unittest/fortran/wrap_extract_variable.cpp index 095b0b3be7..0c1ffcc37e 100644 --- a/unittest/fortran/wrap_extract_variable.cpp +++ b/unittest/fortran/wrap_extract_variable.cpp @@ -5,15 +5,14 @@ #include "library.h" #include "platform.h" -#include -#include +#include +#include +#include #include #include -#include -#include -#include +#include +#include #include -#include #include "gtest/gtest.h" @@ -22,21 +21,21 @@ // prototypes for Fortran reverse wrapper functions 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_setup_extract_variable(); int f_lammps_extract_variable_index_1(); int f_lammps_extract_variable_index_2(); int f_lammps_extract_variable_loop(); -char* f_lammps_extract_variable_loop_pad(); -char* f_lammps_extract_variable_world(); -char* f_lammps_extract_variable_universe(); +char *f_lammps_extract_variable_loop_pad(); +char *f_lammps_extract_variable_world(); +char *f_lammps_extract_variable_universe(); int f_lammps_extract_variable_uloop(); -char* f_lammps_extract_variable_string(); -char* f_lammps_extract_variable_format(); -char* f_lammps_extract_variable_format_pad(); -char* f_lammps_extract_variable_getenv(); -char* f_lammps_extract_variable_file(); +char *f_lammps_extract_variable_string(); +char *f_lammps_extract_variable_format(); +char *f_lammps_extract_variable_format_pad(); +char *f_lammps_extract_variable_getenv(); +char *f_lammps_extract_variable_file(); double f_lammps_extract_variable_atomfile(int); double f_lammps_extract_variable_python(); 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_vector(int); 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 B = b; - std::string C = LAMMPS_NS::platform::path_join(A, B); - size_t length = C.length() + 1; - char *retval = (char*) malloc(length*sizeof(char)); - C.copy(retval, length); - retval[length-1] = '\0'; - return retval; + std::string A = a; + std::string B = b; + std::string C = LAMMPS_NS::platform::path_join(A, B); + size_t length = C.length() + 1; + char *retval = (char *)malloc(length * sizeof(char)); + C.copy(retval, length); + retval[length - 1] = '\0'; + return retval; } +constexpr char input_dir[] = STRINGIFY(TEST_INPUT_FOLDER); class LAMMPS_extract_variable : public ::testing::Test { protected: LAMMPS_NS::LAMMPS *lmp; @@ -68,17 +68,20 @@ protected: void SetUp() override { - const char *args[] = {"LAMMPS_Fortran_test", "-l", "none", - "-echo", "screen", "-nocite", "-var", - "input_dir", STRINGIFY(TEST_INPUT_FOLDER), - "-var", "zpos", "1.5", "-var", "x", "2"}; - char** argv = (char**) args; - int argc = sizeof(args) / sizeof(const char*); + // clang-format off + const char *args[] = + { "LAMMPS_Fortran_test", "-l", "none", "-echo", "screen", "-nocite", + "-var", "input_dir", input_dir, "-var", "zpos", "1.5", "-var", "x", "2" }; + // clang-format on + char **argv = (char **)args; + int argc = sizeof(args) / sizeof(const char *); ::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(); EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS ("); } + void TearDown() override { ::testing::internal::CaptureStdout(); @@ -91,192 +94,190 @@ protected: TEST_F(LAMMPS_extract_variable, index) { - f_lammps_setup_extract_variable(); - EXPECT_EQ(f_lammps_extract_variable_index_1(), 1); - EXPECT_EQ(f_lammps_extract_variable_index_2(), 0); - lammps_command(lmp, "next idx"); - EXPECT_EQ(f_lammps_extract_variable_index_1(), 0); - EXPECT_EQ(f_lammps_extract_variable_index_2(), 1); + f_lammps_setup_extract_variable(); + EXPECT_EQ(f_lammps_extract_variable_index_1(), 1); + EXPECT_EQ(f_lammps_extract_variable_index_2(), 0); + lammps_command(lmp, "next idx"); + EXPECT_EQ(f_lammps_extract_variable_index_1(), 0); + EXPECT_EQ(f_lammps_extract_variable_index_2(), 1); }; TEST_F(LAMMPS_extract_variable, loop) { - f_lammps_setup_extract_variable(); - int i; - for ( i = 1; i <= 10; i++ ) { - EXPECT_EQ(f_lammps_extract_variable_loop(), i); - lammps_command(lmp, "next lp"); - } + f_lammps_setup_extract_variable(); + int i; + for (i = 1; i <= 10; i++) { + EXPECT_EQ(f_lammps_extract_variable_loop(), i); + lammps_command(lmp, "next lp"); + } }; TEST_F(LAMMPS_extract_variable, loop_pad) { - f_lammps_setup_extract_variable(); - int i; - char str[10]; - char* fstr; - for ( i = 1; i <= 10; i++ ) { - std::sprintf(str,"%02d",i); - fstr = f_lammps_extract_variable_loop_pad(); - EXPECT_STREQ(fstr, str); - std::free(fstr); - lammps_command(lmp, "next lp_pad"); - } + f_lammps_setup_extract_variable(); + int i; + char str[10]; + char *fstr; + for (i = 1; i <= 10; i++) { + std::sprintf(str, "%02d", i); + fstr = f_lammps_extract_variable_loop_pad(); + EXPECT_STREQ(fstr, str); + std::free(fstr); + lammps_command(lmp, "next lp_pad"); + } }; TEST_F(LAMMPS_extract_variable, world) { - f_lammps_setup_extract_variable(); - char* fstr = f_lammps_extract_variable_world(); - EXPECT_STREQ(fstr, "group1"); - std::free(fstr); + f_lammps_setup_extract_variable(); + char *fstr = f_lammps_extract_variable_world(); + EXPECT_STREQ(fstr, "group1"); + std::free(fstr); }; TEST_F(LAMMPS_extract_variable, universe) { - f_lammps_setup_extract_variable(); - char* fstr = f_lammps_extract_variable_universe(); - EXPECT_STREQ(fstr, "universe1"); - std::free(fstr); + f_lammps_setup_extract_variable(); + char *fstr = f_lammps_extract_variable_universe(); + EXPECT_STREQ(fstr, "universe1"); + std::free(fstr); }; TEST_F(LAMMPS_extract_variable, uloop) { - f_lammps_setup_extract_variable(); - EXPECT_EQ(f_lammps_extract_variable_uloop(), 1); + f_lammps_setup_extract_variable(); + EXPECT_EQ(f_lammps_extract_variable_uloop(), 1); }; TEST_F(LAMMPS_extract_variable, string) { - f_lammps_setup_extract_variable(); - char* fstr = f_lammps_extract_variable_string(); - EXPECT_STREQ(fstr, "this is a string"); - std::free(fstr); - f_lammps_set_variable_string(); - fstr = f_lammps_extract_variable_string(); - EXPECT_STREQ(fstr, "this is the new string"); - std::free(fstr); + f_lammps_setup_extract_variable(); + char *fstr = f_lammps_extract_variable_string(); + EXPECT_STREQ(fstr, "this is a string"); + std::free(fstr); + f_lammps_set_variable_string(); + fstr = f_lammps_extract_variable_string(); + EXPECT_STREQ(fstr, "this is the new string"); + std::free(fstr); }; TEST_F(LAMMPS_extract_variable, format) { - f_lammps_setup_extract_variable(); - int i; - char str[10]; - char* fstr; - for ( i = 1; i <= 10; i++ ) { - std::sprintf(str,"%.6G",std::exp(i)); - fstr = f_lammps_extract_variable_format(); - EXPECT_STREQ(fstr, str); - std::free(fstr); - lammps_command(lmp, "next lp"); - } + f_lammps_setup_extract_variable(); + int i; + char str[10]; + char *fstr; + for (i = 1; i <= 10; i++) { + std::sprintf(str, "%.6G", std::exp(i)); + fstr = f_lammps_extract_variable_format(); + EXPECT_STREQ(fstr, str); + std::free(fstr); + lammps_command(lmp, "next lp"); + } }; TEST_F(LAMMPS_extract_variable, format_pad) { - f_lammps_setup_extract_variable(); - int i; - char str[10]; - char* fstr; - for ( i = 1; i <= 10; i++ ) { - std::sprintf(str,"%08.6G",std::exp(i)); - fstr = f_lammps_extract_variable_format_pad(); - EXPECT_STREQ(fstr, str); - std::free(fstr); - lammps_command(lmp, "next lp"); - } + f_lammps_setup_extract_variable(); + int i; + char str[10]; + char *fstr; + for (i = 1; i <= 10; i++) { + std::sprintf(str, "%08.6G", std::exp(i)); + fstr = f_lammps_extract_variable_format_pad(); + EXPECT_STREQ(fstr, str); + std::free(fstr); + lammps_command(lmp, "next lp"); + } }; TEST_F(LAMMPS_extract_variable, getenv) { - LAMMPS_NS::platform::putenv("FORTRAN_USER=myuser"); - f_lammps_setup_extract_variable(); - char *env = std::getenv("FORTRAN_USER"); - char *fenv = f_lammps_extract_variable_getenv(); - EXPECT_STREQ(fenv, env); - std::free(fenv); + LAMMPS_NS::platform::putenv("FORTRAN_USER=myuser"); + f_lammps_setup_extract_variable(); + char *env = std::getenv("FORTRAN_USER"); + char *fenv = f_lammps_extract_variable_getenv(); + EXPECT_STREQ(fenv, env); + std::free(fenv); }; TEST_F(LAMMPS_extract_variable, file) { - f_lammps_setup_extract_variable(); - int i; - const char* str[9] = {"hello","god_dag","hola","bonjour","guten_Tag", - "konnichiwa","shalom","salve","goedendag"}; - char* fstr; - for ( i = 0; i < 9; i++ ) { - fstr = f_lammps_extract_variable_file(); - EXPECT_STREQ(fstr, str[i]); - std::free(fstr); - lammps_command(lmp, "next greeting"); - } + f_lammps_setup_extract_variable(); + int i; + const char *str[9] = {"hello", "god_dag", "hola", "bonjour", "guten_Tag", + "konnichiwa", "shalom", "salve", "goedendag"}; + char *fstr; + for (i = 0; i < 9; i++) { + fstr = f_lammps_extract_variable_file(); + EXPECT_STREQ(fstr, str[i]); + std::free(fstr); + lammps_command(lmp, "next greeting"); + } }; TEST_F(LAMMPS_extract_variable, atomfile) { - f_lammps_setup_extract_variable(); - 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(3), -1.4); - lammps_command(lmp, "next atfile"); - 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(3), 2.5); + f_lammps_setup_extract_variable(); + 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(3), -1.4); + lammps_command(lmp, "next atfile"); + 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(3), 2.5); }; TEST_F(LAMMPS_extract_variable, python) { - if ( lammps_config_has_package("PYTHON") ) { - f_lammps_setup_extract_variable(); - for (int i = 1; i <= 10; i++) { - EXPECT_DOUBLE_EQ(f_lammps_extract_variable_python(), - static_cast(i*i)); - lammps_command(lmp, "next lp"); - } - } + if (lammps_config_has_package("PYTHON")) { + f_lammps_setup_extract_variable(); + for (int i = 1; i <= 10; i++) { + EXPECT_DOUBLE_EQ(f_lammps_extract_variable_python(), static_cast(i * i)); + lammps_command(lmp, "next lp"); + } + } }; TEST_F(LAMMPS_extract_variable, timer) { - f_lammps_setup_extract_variable(); - double initial_t, final_t; - initial_t = f_lammps_extract_variable_timer(); - std::this_thread::sleep_for(std::chrono::milliseconds(100)); - lammps_command(lmp,"variable time timer"); // update the time - final_t = f_lammps_extract_variable_timer(); - EXPECT_GT(final_t, initial_t + 0.1); + f_lammps_setup_extract_variable(); + double initial_t, final_t; + initial_t = f_lammps_extract_variable_timer(); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + lammps_command(lmp, "variable time timer"); // update the time + final_t = f_lammps_extract_variable_timer(); + EXPECT_GT(final_t, initial_t + 0.1); }; TEST_F(LAMMPS_extract_variable, internal) { - f_lammps_setup_extract_variable(); - EXPECT_DOUBLE_EQ(f_lammps_extract_variable_internal(), 4.0); + f_lammps_setup_extract_variable(); + EXPECT_DOUBLE_EQ(f_lammps_extract_variable_internal(), 4.0); }; TEST_F(LAMMPS_extract_variable, equal) { - f_lammps_setup_extract_variable(); - int i; - for ( i = 1; i <= 10; i++ ) { - EXPECT_DOUBLE_EQ(f_lammps_extract_variable_equal(), - std::exp(static_cast(i))); - lammps_command(lmp, "next lp"); - } + f_lammps_setup_extract_variable(); + int i; + for (i = 1; i <= 10; i++) { + EXPECT_DOUBLE_EQ(f_lammps_extract_variable_equal(), std::exp(static_cast(i))); + lammps_command(lmp, "next lp"); + } }; TEST_F(LAMMPS_extract_variable, atom) { - f_lammps_setup_extract_variable(); - 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(3), 0.5); + f_lammps_setup_extract_variable(); + 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(3), 0.5); }; TEST_F(LAMMPS_extract_variable, vector) { - 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(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); + 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(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); }; diff --git a/unittest/fortran/wrap_gather_scatter.cpp b/unittest/fortran/wrap_gather_scatter.cpp index efb33467d9..3b70c4393e 100644 --- a/unittest/fortran/wrap_gather_scatter.cpp +++ b/unittest/fortran/wrap_gather_scatter.cpp @@ -3,10 +3,10 @@ #include "lammps.h" #include "library.h" +#include +#include #include #include -#include -#include #include "gtest/gtest.h" @@ -18,185 +18,185 @@ void f_lammps_setup_gather_scatter(); int f_lammps_gather_atoms_mask(int); double f_lammps_gather_atoms_position(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); -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_positions(); } class LAMMPS_gather_scatter : public ::testing::Test { protected: - LAMMPS_NS::LAMMPS *lmp; - LAMMPS_gather_scatter() = default; - ~LAMMPS_gather_scatter() override = default; + LAMMPS_NS::LAMMPS *lmp; + LAMMPS_gather_scatter() = default; + ~LAMMPS_gather_scatter() override = default; - void SetUp() override - { - ::testing::internal::CaptureStdout(); - lmp = (LAMMPS_NS::LAMMPS *)f_lammps_with_args(); - std::string output = ::testing::internal::GetCapturedStdout(); - EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS ("); - } - void TearDown() override - { - ::testing::internal::CaptureStdout(); - f_lammps_close(); - std::string output = ::testing::internal::GetCapturedStdout(); - EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:"); - lmp = nullptr; - } + void SetUp() override + { + ::testing::internal::CaptureStdout(); + lmp = (LAMMPS_NS::LAMMPS *)f_lammps_with_args(); + std::string output = ::testing::internal::GetCapturedStdout(); + EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS ("); + } + void TearDown() override + { + ::testing::internal::CaptureStdout(); + f_lammps_close(); + std::string output = ::testing::internal::GetCapturedStdout(); + EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:"); + lmp = nullptr; + } }; TEST_F(LAMMPS_gather_scatter, gather_atoms_masks) { - if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); - f_lammps_setup_gather_scatter(); - 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(3), 1); - lammps_command(lmp, "group special id 1"); - lammps_command(lmp, "group other id 2"); - lammps_command(lmp, "group spiffy id 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(3), 9); - lammps_command(lmp, "group other id 1"); - 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(3), 9); + if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP(); + f_lammps_setup_gather_scatter(); + 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(3), 1); + lammps_command(lmp, "group special id 1"); + lammps_command(lmp, "group other id 2"); + lammps_command(lmp, "group spiffy id 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(3), 9); + lammps_command(lmp, "group other id 1"); + 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(3), 9); }; TEST_F(LAMMPS_gather_scatter, gather_atoms_positions) { - if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); - f_lammps_setup_gather_scatter(); - 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(3), 1.5); - 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(6), 0.1); - 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(9), 0.5); + if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP(); + f_lammps_setup_gather_scatter(); + 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(3), 1.5); + 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(6), 0.1); + 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(9), 0.5); }; TEST_F(LAMMPS_gather_scatter, gather_atoms_concat_masks) { - if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); - f_lammps_setup_gather_scatter(); - 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(3), 1); - lammps_command(lmp, "group special id 1"); - lammps_command(lmp, "group other id 2"); - 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(2), 5); - EXPECT_EQ(f_lammps_gather_atoms_concat_mask(3), 9); - 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(2), 5); - EXPECT_EQ(f_lammps_gather_atoms_concat_mask(3), 9); + if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP(); + f_lammps_setup_gather_scatter(); + 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(3), 1); + lammps_command(lmp, "group special id 1"); + lammps_command(lmp, "group other id 2"); + 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(2), 5); + EXPECT_EQ(f_lammps_gather_atoms_concat_mask(3), 9); + 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(2), 5); + EXPECT_EQ(f_lammps_gather_atoms_concat_mask(3), 9); }; TEST_F(LAMMPS_gather_scatter, gather_atoms_concat_positions) { - if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); - 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(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(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(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(2,3), 0.5); - EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,3), 0.5); + if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP(); + 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(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(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(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(2, 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) { - if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); - 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(3), 1); - lammps_command(lmp, "group special id 1"); - lammps_command(lmp, "group other id 2"); - 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(3), 9); - 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(3), 13); + if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP(); + 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(3), 1); + lammps_command(lmp, "group special id 1"); + lammps_command(lmp, "group other id 2"); + 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(3), 9); + 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(3), 13); }; TEST_F(LAMMPS_gather_scatter, gather_atoms_subset_positions) { - if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); - 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(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(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(3,3), 0.5); + if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP(); + 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(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(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(3, 3), 0.5); }; TEST_F(LAMMPS_gather_scatter, scatter_atoms_masks) { - if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); - f_lammps_setup_gather_scatter(); - lammps_command(lmp, "group special id 1"); - lammps_command(lmp, "group other id 2"); - 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(2), 5); - EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(3), 9); - 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(2), 5); - EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(3), 3); + if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP(); + f_lammps_setup_gather_scatter(); + lammps_command(lmp, "group special id 1"); + lammps_command(lmp, "group other id 2"); + 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(2), 5); + EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(3), 9); + 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(2), 5); + EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_mask(3), 3); }; TEST_F(LAMMPS_gather_scatter, scatter_atoms_positions) { - if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); - 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(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(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(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(2,3), 0.5); - EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,3), 0.5); - 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(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(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(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(2,1), 0.5); - EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3,1), 0.5); + if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP(); + 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(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(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(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(2, 3), 0.5); + EXPECT_DOUBLE_EQ(f_lammps_gather_atoms_concat_position(3, 3), 0.5); + 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(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(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(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(2, 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) { - if ( lammps_extract_setting(nullptr,"tagint") == 8 ) GTEST_SKIP(); - f_lammps_setup_gather_scatter(); - EXPECT_EQ(f_lammps_gather_atoms_mask(1), 1); - EXPECT_EQ(f_lammps_gather_atoms_mask(3), 1); - lammps_command(lmp, "group special id 1"); - lammps_command(lmp, "group other id 2"); - lammps_command(lmp, "group spiffy id 3"); - EXPECT_EQ(f_lammps_gather_atoms_mask(1), 3); - EXPECT_EQ(f_lammps_gather_atoms_mask(3), 9); - f_lammps_scatter_atoms_masks(); - EXPECT_EQ(f_lammps_gather_atoms_mask(1), 9); - EXPECT_EQ(f_lammps_gather_atoms_mask(3), 3); + if (lammps_extract_setting(nullptr, "tagint") == 8) GTEST_SKIP(); + f_lammps_setup_gather_scatter(); + EXPECT_EQ(f_lammps_gather_atoms_mask(1), 1); + EXPECT_EQ(f_lammps_gather_atoms_mask(3), 1); + lammps_command(lmp, "group special id 1"); + lammps_command(lmp, "group other id 2"); + lammps_command(lmp, "group spiffy id 3"); + EXPECT_EQ(f_lammps_gather_atoms_mask(1), 3); + EXPECT_EQ(f_lammps_gather_atoms_mask(3), 9); + f_lammps_scatter_atoms_masks(); + EXPECT_EQ(f_lammps_gather_atoms_mask(1), 9); + EXPECT_EQ(f_lammps_gather_atoms_mask(3), 3); }; diff --git a/unittest/fortran/wrap_properties.cpp b/unittest/fortran/wrap_properties.cpp index 21c953a514..d2daa22cf4 100644 --- a/unittest/fortran/wrap_properties.cpp +++ b/unittest/fortran/wrap_properties.cpp @@ -13,9 +13,9 @@ extern "C" { void *f_lammps_with_args(); void f_lammps_close(); 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_extract_setting(const char*); +int f_lammps_extract_setting(const char *); int f_lammps_has_error(); int f_lammps_get_last_error_message(char *, int); } @@ -26,17 +26,17 @@ using ::testing::ContainsRegex; class LAMMPS_properties : public ::testing::Test { protected: - LAMMPS_NS::LAMMPS *lmp; - LAMMPS_properties() = default; - ~LAMMPS_properties() override = default; + LAMMPS *lmp; void SetUp() override { ::testing::internal::CaptureStdout(); - lmp = (LAMMPS_NS::LAMMPS *)f_lammps_with_args(); + lmp = (LAMMPS *)f_lammps_with_args(); + std::string output = ::testing::internal::GetCapturedStdout(); EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS ("); } + void TearDown() override { ::testing::internal::CaptureStdout(); @@ -54,10 +54,10 @@ TEST_F(LAMMPS_properties, version) TEST_F(LAMMPS_properties, memory_usage) { -// copied from c-library, with a two-character modification - double meminfo[3]; - f_lammps_memory_usage(meminfo); - EXPECT_GT(meminfo[0], 0.0); + // copied from c-library, with a two-character modification + double meminfo[3]; + f_lammps_memory_usage(meminfo); + EXPECT_GT(meminfo[0], 0.0); #if defined(__linux__) || defined(_WIN32) EXPECT_GE(meminfo[1], 0.0); #endif @@ -68,11 +68,11 @@ TEST_F(LAMMPS_properties, memory_usage) TEST_F(LAMMPS_properties, get_mpi_comm) { - int f_comm = f_lammps_get_mpi_comm(); - if ( lammps_config_has_mpi_support() ) - EXPECT_GE(f_comm, 0); - else - EXPECT_EQ(f_comm, -1); + int f_comm = f_lammps_get_mpi_comm(); + if (lammps_config_has_mpi_support()) + EXPECT_GE(f_comm, 0); + else + EXPECT_EQ(f_comm, -1); }; TEST_F(LAMMPS_properties, extract_setting) From 4e9b97d5cba2a16b9770cb5172d6fa09afdb91c0 Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Mon, 3 Oct 2022 23:49:17 -0400 Subject: [PATCH 4/9] make capitalization and whitespace fortran coding style more consistent --- fortran/lammps.f90 | 211 ++++++------- unittest/fortran/test_fortran_box.f90 | 42 +-- .../fortran/test_fortran_extract_atom.f90 | 66 ++-- .../fortran/test_fortran_extract_compute.f90 | 62 ++-- unittest/fortran/test_fortran_extract_fix.f90 | 44 +-- .../fortran/test_fortran_extract_global.f90 | 298 +++++++++--------- .../fortran/test_fortran_extract_variable.f90 | 48 +-- .../fortran/test_fortran_gather_scatter.f90 | 22 +- unittest/fortran/test_fortran_get_thermo.f90 | 50 +-- unittest/fortran/test_fortran_properties.f90 | 50 +-- 10 files changed, 449 insertions(+), 444 deletions(-) diff --git a/fortran/lammps.f90 b/fortran/lammps.f90 index 2a4a16bdd0..d37b12c7db 100644 --- a/fortran/lammps.f90 +++ b/fortran/lammps.f90 @@ -483,10 +483,10 @@ MODULE LIBLAMMPS END FUNCTION lammps_version SUBROUTINE lammps_get_os_info(buffer, buf_size) BIND(C) - IMPORT :: C_ptr, C_int + IMPORT :: c_ptr, c_int IMPLICIT NONE - TYPE(C_ptr), VALUE :: buffer - INTEGER(C_int), VALUE :: buf_size + TYPE(c_ptr), VALUE :: buffer + INTEGER(c_int), VALUE :: buf_size END SUBROUTINE lammps_get_os_info FUNCTION lammps_config_has_mpi_support() BIND(C) @@ -526,24 +526,24 @@ MODULE LIBLAMMPS END FUNCTION lammps_config_has_exceptions FUNCTION lammps_config_has_package(name) BIND(C) - IMPORT :: C_int, C_ptr + IMPORT :: c_int, c_ptr IMPLICIT NONE - TYPE(C_ptr), VALUE :: name + TYPE(c_ptr), VALUE :: name INTEGER(c_int) :: lammps_config_has_package END FUNCTION lammps_config_has_package FUNCTION lammps_config_package_count() BIND(C) - IMPORT :: C_int + IMPORT :: c_int IMPLICIT NONE - INTEGER(C_int) :: lammps_config_package_count + INTEGER(c_int) :: lammps_config_package_count END FUNCTION lammps_config_package_count FUNCTION lammps_config_package_name(idx, buffer, buf_size) BIND(C) - IMPORT :: C_int, C_ptr + IMPORT :: c_int, c_ptr IMPLICIT NONE - INTEGER(C_int) :: lammps_config_package_name - INTEGER(C_int), VALUE :: idx, buf_size - TYPE(C_ptr), VALUE :: buffer + INTEGER(c_int) :: lammps_config_package_name + INTEGER(c_int), VALUE :: idx, buf_size + TYPE(c_ptr), VALUE :: buffer END FUNCTION lammps_config_package_name !LOGICAL FUNCTION lammps_config_accelerator @@ -551,10 +551,10 @@ MODULE LIBLAMMPS !SUBROUTINE lammps_get_gpu_device !LOGICAL FUNCTION lammps_has_id - !INTEGER(C_int) FUNCTION lammps_id_count + !INTEGER(c_int) FUNCTION lammps_id_count !SUBROUTINE lammps_id_name - !INTEGER(C_int) FUNCTION lammps_plugin_count + !INTEGER(c_int) FUNCTION lammps_plugin_count !SUBROUTINE lammps_plugin_name !Both of these use LAMMPS_BIGBIG @@ -572,9 +572,9 @@ MODULE LIBLAMMPS !SUBROUTINE lammps_fix_external_set_vector SUBROUTINE lammps_flush_buffers(handle) BIND(C) - IMPORT :: C_ptr + IMPORT :: c_ptr IMPLICIT NONE - TYPE(C_ptr), VALUE :: handle + TYPE(c_ptr), VALUE :: handle END SUBROUTINE lammps_flush_buffers FUNCTION lammps_malloc(size) BIND(C, name='malloc') @@ -602,7 +602,7 @@ MODULE LIBLAMMPS TYPE(c_ptr), VALUE :: handle END SUBROUTINE lammps_force_timeout - INTEGER(C_int) FUNCTION lammps_has_error(handle) BIND(C) + INTEGER(c_int) FUNCTION lammps_has_error(handle) BIND(C) IMPORT :: c_ptr, c_int IMPLICIT NONE TYPE(c_ptr), VALUE :: handle @@ -758,7 +758,7 @@ CONTAINS REAL(c_double) FUNCTION lmp_get_thermo(self,name) CLASS(lammps), INTENT(IN) :: self CHARACTER(LEN=*) :: name - TYPE(C_ptr) :: Cname + TYPE(c_ptr) :: Cname Cname = f2c_string(name) lmp_get_thermo = lammps_get_thermo(self%handle, Cname) @@ -771,27 +771,27 @@ CONTAINS REAL(c_double), INTENT(OUT), TARGET, OPTIONAL :: boxlo(3), boxhi(3) REAL(c_double), INTENT(OUT), TARGET, OPTIONAL :: xy, yz, xz LOGICAL, INTENT(OUT), OPTIONAL :: pflags(3), boxflag - INTEGER(c_int), TARGET :: C_pflags(3), C_boxflag + INTEGER(c_int), TARGET :: c_pflags(3), c_boxflag TYPE(c_ptr) :: ptr(7) ptr = c_null_ptr - IF ( PRESENT(boxlo) ) ptr(1) = C_LOC(boxlo(1)) - IF ( PRESENT(boxhi) ) ptr(2) = C_LOC(boxhi(1)) - IF ( PRESENT(xy) ) ptr(3) = C_LOC(xy) - IF ( PRESENT(yz) ) ptr(4) = C_LOC(yz) - IF ( PRESENT(xz) ) ptr(5) = C_LOC(xz) - IF ( PRESENT(pflags) ) ptr(6) = C_LOC(C_pflags(1)) - IF ( PRESENT(boxflag) ) ptr(7) = C_LOC(C_boxflag) + IF (PRESENT(boxlo)) ptr(1) = C_LOC(boxlo(1)) + IF (PRESENT(boxhi)) ptr(2) = C_LOC(boxhi(1)) + IF (PRESENT(xy)) ptr(3) = C_LOC(xy) + IF (PRESENT(yz)) ptr(4) = C_LOC(yz) + IF (PRESENT(xz)) ptr(5) = C_LOC(xz) + IF (PRESENT(pflags)) ptr(6) = C_LOC(c_pflags(1)) + IF (PRESENT(boxflag)) ptr(7) = C_LOC(c_boxflag) CALL lammps_extract_box(self%handle, ptr(1), ptr(2), ptr(3), ptr(4), & ptr(5), ptr(6), ptr(7)) - IF ( PRESENT(pflags) ) pflags = ( C_pflags /= 0_C_int ) - IF ( PRESENT(boxflag) ) boxflag = ( C_boxflag /= 0_C_int ) + IF (PRESENT(pflags)) pflags = (c_pflags /= 0_c_int) + IF (PRESENT(boxflag)) boxflag = (c_boxflag /= 0_c_int) END SUBROUTINE lmp_extract_box ! equivalent function to lammps_reset_box SUBROUTINE lmp_reset_box(self, boxlo, boxhi, xy, yz, xz) CLASS(lammps), INTENT(IN) :: self - REAL(C_double), INTENT(IN) :: boxlo(3), boxhi(3), xy, yz, xz + REAL(c_double), INTENT(IN) :: boxlo(3), boxhi(3), xy, yz, xz CALL lammps_reset_box(self%handle, boxlo, boxhi, xy, yz, xz) END SUBROUTINE lmp_reset_box @@ -857,7 +857,7 @@ CONTAINS global_data%lammps_instance => self SELECT CASE (datatype) CASE (LAMMPS_INT) - IF ( length == 1 ) THEN + IF (length == 1) THEN global_data%datatype = DATA_INT CALL C_F_POINTER(Cptr, global_data%i32) ELSE @@ -865,7 +865,7 @@ CONTAINS CALL C_F_POINTER(Cptr, global_data%i32_vec, [length]) END IF CASE (LAMMPS_INT64) - IF ( length == 1 ) THEN + IF (length == 1) THEN global_data%datatype = DATA_INT64 CALL C_F_POINTER(Cptr, global_data%i64) ELSE @@ -873,7 +873,7 @@ CONTAINS CALL C_F_POINTER(Cptr, global_data%i64_vec, [length]) END IF CASE (LAMMPS_DOUBLE) - IF ( length == 1 ) THEN + IF (length == 1) THEN global_data%datatype = DATA_DOUBLE CALL C_F_POINTER(Cptr, global_data%r64) ELSE @@ -884,8 +884,8 @@ CONTAINS global_data%datatype = DATA_STRING length = c_strlen(Cptr) CALL C_F_POINTER(Cptr, Fptr, [length]) - ALLOCATE ( CHARACTER(LEN=length) :: global_data%str ) - FORALL ( i=1:length ) + ALLOCATE(CHARACTER(LEN=length) :: global_data%str) + FORALL (i=1:length) global_data%str(i:i) = Fptr(i) END FORALL CASE DEFAULT @@ -939,7 +939,7 @@ CONTAINS CALL C_F_POINTER(Cptr, peratom_data%i64_vec, [ncols]) CASE (LAMMPS_DOUBLE) peratom_data%datatype = DATA_DOUBLE_1D - IF ( name == 'mass' ) THEN + IF (name == 'mass') THEN CALL C_F_POINTER(Cptr, dummy, [ncols]) peratom_data%r64_vec(0:) => dummy ELSE @@ -978,7 +978,7 @@ CONTAINS Cid = f2c_string(id) Cptr = lammps_extract_compute(self%handle, Cid, style, type) - IF ( .NOT. C_ASSOCIATED(Cptr) ) THEN + IF (.NOT. C_ASSOCIATED(Cptr)) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, & 'Pointer from LAMMPS is NULL [Fortran/extract_compute]') END IF @@ -1046,8 +1046,8 @@ CONTAINS ! global data, as it would be if we could access the C++ array directly Cnrow = -1 Cncol = -1 - IF ( PRESENT(nrow) ) THEN - IF ( .NOT. PRESENT(ncol) ) THEN + IF (PRESENT(nrow)) THEN + IF (.NOT. PRESENT(ncol)) THEN ! Presumably the argument that's there is the vector length Cnrow = nrow - 1_c_int Cncol = -1_c_int @@ -1057,11 +1057,11 @@ CONTAINS END IF END IF - IF ( PRESENT(ncol) ) Cnrow = ncol - 1_c_int + IF (PRESENT(ncol)) Cnrow = ncol - 1_c_int Cid = f2c_string(id) Cptr = lammps_extract_fix(self%handle, Cid, style, type, Cnrow, Cncol) - IF ( .NOT. C_ASSOCIATED(Cptr) ) THEN + IF (.NOT. C_ASSOCIATED(Cptr)) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, & 'Pointer from LAMMPS is NULL for fix id "' // id & // '" [Fortran/extract_fix]') @@ -1082,7 +1082,7 @@ CONTAINS & [Fortran/extract_fix]') CASE (LMP_TYPE_VECTOR) fix_data%datatype = DATA_DOUBLE_1D - IF ( STYLE == LMP_STYLE_ATOM ) THEN + IF (STYLE == LMP_STYLE_ATOM) THEN nrows = self%extract_setting('nmax') ELSE Ctemp = lammps_extract_fix(self%handle, Cid, style, & @@ -1093,7 +1093,7 @@ CONTAINS CALL C_F_POINTER(Cptr, fix_data%r64_vec, [nrows]) CASE (LMP_TYPE_ARRAY) fix_data%datatype = DATA_DOUBLE_2D - IF ( STYLE == LMP_STYLE_ATOM ) THEN + IF (STYLE == LMP_STYLE_ATOM) THEN ! Fortran array is transposed relative to C ncols = self%extract_setting('nmax') Ctemp = lammps_extract_fix(self%handle, Cid, style, & @@ -1142,7 +1142,7 @@ CONTAINS INTEGER(c_int), POINTER :: Clength => NULL() Cname = f2c_string(name) - IF ( PRESENT(group) ) THEN + IF (PRESENT(group)) THEN Cgroup = f2c_string(group) ELSE Cgroup = c_null_ptr @@ -1163,9 +1163,8 @@ CONTAINS variable_data%datatype = DATA_DOUBLE_1D length = lmp_extract_setting(self, 'nlocal') CALL C_F_POINTER(Cptr, double_vec, [length]) - IF ( ALLOCATED(variable_data%r64_vec) ) & - DEALLOCATE(variable_data%r64_vec) - ALLOCATE( variable_data%r64_vec(length) ) + IF (ALLOCATED(variable_data%r64_vec)) DEALLOCATE(variable_data%r64_vec) + ALLOCATE(variable_data%r64_vec(length)) variable_data%r64_vec = double_vec CALL lammps_free(Cptr) CASE (LMP_VAR_VECTOR) @@ -1179,17 +1178,17 @@ CONTAINS CALL lammps_free(Cname) CALL lammps_free(Cveclength) CALL C_F_POINTER(Cptr, double_vec, [length]) - IF ( ALLOCATED(variable_data%r64_vec) ) & + IF (ALLOCATED(variable_data%r64_vec)) & DEALLOCATE(variable_data%r64_vec) - ALLOCATE( variable_data%r64_vec(length) ) + ALLOCATE(variable_data%r64_vec(length)) variable_data%r64_vec = double_vec ! DO NOT deallocate the C pointer CASE (LMP_VAR_STRING) variable_data%datatype = DATA_STRING length = c_strlen(Cptr) CALL C_F_POINTER(Cptr, Cstring, [length]) - ALLOCATE ( CHARACTER(LEN=length) :: variable_data%str ) - FORALL ( i=1:length ) + ALLOCATE(CHARACTER(LEN=length) :: variable_data%str) + FORALL (i=1:length) variable_data%str(i:i) = Cstring(i) END FORALL ! DO NOT deallocate the C pointer @@ -1209,14 +1208,14 @@ CONTAINS CLASS(lammps), INTENT(IN) :: self CHARACTER(LEN=*), INTENT(IN) :: name, str INTEGER :: err - TYPE(C_ptr) :: Cstr, Cname + TYPE(c_ptr) :: Cstr, Cname Cstr = f2c_string(str) Cname = f2c_string(name) err = lammps_set_variable(self%handle, Cname, Cstr) CALL lammps_free(Cname) CALL lammps_free(Cstr) - IF ( err /= 0 ) THEN + IF (err /= 0) THEN CALL lmp_error(self, LMP_ERROR_WARNING + LMP_ERROR_WORLD, & 'WARNING: unable to set string variable "' // name & // '" [Fortran/set_variable]') @@ -1235,13 +1234,13 @@ CONTAINS REAL(c_double) :: dnatoms CHARACTER(LEN=100) :: error_msg - IF ( count /= 1 .AND. count /= 3 ) THEN + IF (count /= 1 .AND. count /= 3) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, 'gather_atoms& & requires "count" to be 1 or 3 [Fortran/gather_atoms]') END IF dnatoms = lmp_get_natoms(self) - IF ( dnatoms > HUGE(1_c_int) ) THEN + IF (dnatoms > HUGE(1_c_int)) THEN WRITE(error_msg,'(A,1X,I0,1X,A)') & 'Cannot use library function gather_atoms with more than', & HUGE(0_c_int), 'atoms [Fortran/gather_atoms]' @@ -1250,7 +1249,7 @@ CONTAINS natoms = NINT(dnatoms, c_int) Cname = f2c_string(name) - IF ( ALLOCATED(data) ) DEALLOCATE(data) + IF (ALLOCATED(data)) DEALLOCATE(data) ALLOCATE(data(natoms*count)) Cdata = C_LOC(data(1)) CALL lammps_gather_atoms(self%handle, Cname, Ctype, count, Cdata) @@ -1266,16 +1265,16 @@ CONTAINS TYPE(c_ptr) :: Cdata, Cname INTEGER(c_int) :: natoms INTEGER(c_int), PARAMETER :: Ctype = 1_c_int - REAL(C_double) :: dnatoms + REAL(c_double) :: dnatoms CHARACTER(LEN=100) :: error_msg - IF ( count /= 1 .AND. count /= 3 ) THEN + IF (count /= 1 .AND. count /= 3) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, 'gather_atoms& & requires "count" to be 1 or 3 [Fortran/gather_atoms]') END IF dnatoms = lmp_get_natoms(self) - IF ( dnatoms > HUGE(1_c_int) ) THEN + IF (dnatoms > HUGE(1_c_int)) THEN WRITE(error_msg,'(A,1X,I0,1X,A)') & 'Cannot use library function gather_atoms with more than', & HUGE(0_c_int), 'atoms [Fortran/gather_atoms]' @@ -1284,7 +1283,7 @@ CONTAINS natoms = NINT(dnatoms, c_int) Cname = f2c_string(name) - IF ( ALLOCATED(data) ) DEALLOCATE(data) + IF (ALLOCATED(data)) DEALLOCATE(data) ALLOCATE(data(natoms*count)) Cdata = C_LOC(data(1)) CALL lammps_gather_atoms(self%handle, Cname, Ctype, count, Cdata) @@ -1300,17 +1299,17 @@ CONTAINS TYPE(c_ptr) :: Cdata, Cname INTEGER(c_int) :: natoms INTEGER(c_int), PARAMETER :: Ctype = 0_c_int - REAL(C_double) :: dnatoms + REAL(c_double) :: dnatoms CHARACTER(LEN=100) :: error_msg - IF ( count /= 1 .AND. count /= 3 ) THEN + IF (count /= 1 .AND. count /= 3) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, & 'gather_atoms_concat requires "count" to be 1 or 3 & &[Fortran/gather_atoms_concat]') END IF dnatoms = lmp_get_natoms(self) - IF ( dnatoms > HUGE(1_c_int) ) THEN + IF (dnatoms > HUGE(1_c_int)) THEN WRITE(error_msg,'(A,1X,I0,1X,A)') & 'Cannot use library function gather_atoms_concat with more than', & HUGE(0_c_int), 'atoms [Fortran/gather_atoms_concat]' @@ -1319,7 +1318,7 @@ CONTAINS natoms = NINT(dnatoms, c_int) Cname = f2c_string(name) - IF ( ALLOCATED(data) ) DEALLOCATE(data) + IF (ALLOCATED(data)) DEALLOCATE(data) ALLOCATE(data(natoms*count)) Cdata = C_LOC(data(1)) CALL lammps_gather_atoms_concat(self%handle, Cname, Ctype, count, Cdata) @@ -1335,17 +1334,17 @@ CONTAINS TYPE(c_ptr) :: Cdata, Cname INTEGER(c_int) :: natoms INTEGER(c_int), PARAMETER :: Ctype = 1_c_int - REAL(C_double) :: dnatoms + REAL(c_double) :: dnatoms CHARACTER(LEN=100) :: error_msg - IF ( count /= 1 .AND. count /= 3 ) THEN + IF (count /= 1 .AND. count /= 3) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, & 'gather_atoms_concat requires "count" to be 1 or 3 & &[Fortran/gather_atoms_concat]') END IF dnatoms = lmp_get_natoms(self) - IF ( dnatoms > HUGE(1_c_int) ) THEN + IF (dnatoms > HUGE(1_c_int)) THEN WRITE(error_msg,'(A,1X,I0,1X,A)') & 'Cannot use library function gather_atoms_concat with more than', & HUGE(0_c_int), 'atoms [Fortran/gather_atoms_concat]' @@ -1354,7 +1353,7 @@ CONTAINS natoms = NINT(dnatoms, c_int) Cname = f2c_string(name) - IF ( ALLOCATED(data) ) DEALLOCATE(data) + IF (ALLOCATED(data)) DEALLOCATE(data) ALLOCATE(data(natoms*count)) Cdata = C_LOC(data(1)) CALL lammps_gather_atoms_concat(self%handle, Cname, Ctype, count, Cdata) @@ -1373,7 +1372,7 @@ CONTAINS INTEGER(c_int), PARAMETER :: Ctype = 0_c_int CHARACTER(LEN=100) :: error_msg - IF ( count /= 1 .AND. count /= 3 ) THEN + IF (count /= 1 .AND. count /= 3) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, & 'gather_atoms_subset requires "count" to be 1 or 3 & &[Fortran/gather_atoms]') @@ -1382,7 +1381,7 @@ CONTAINS ndata = SIZE(ids, KIND=c_int) Cname = f2c_string(name) - IF ( ALLOCATED(data) ) DEALLOCATE(data) + IF (ALLOCATED(data)) DEALLOCATE(data) ALLOCATE(data(ndata*count)) data = -1_c_int Cdata = C_LOC(data(1)) @@ -1404,7 +1403,7 @@ CONTAINS INTEGER(c_int), PARAMETER :: Ctype = 1_c_int CHARACTER(LEN=100) :: error_msg - IF ( count /= 1 .AND. count /= 3 ) THEN + IF (count /= 1 .AND. count /= 3) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, & 'gather_atoms_subset requires "count" to be 1 or 3 & &[Fortran/gather_atoms]') @@ -1413,7 +1412,7 @@ CONTAINS ndata = SIZE(ids, KIND=c_int) Cname = f2c_string(name) - IF ( ALLOCATED(data) ) DEALLOCATE(data) + IF (ALLOCATED(data)) DEALLOCATE(data) ALLOCATE(data(ndata*count)) Cdata = C_LOC(data(1)) Cids = C_LOC(ids(1)) @@ -1434,7 +1433,7 @@ CONTAINS CHARACTER(LEN=100) :: error_msg dnatoms = lmp_get_natoms(self) - IF ( dnatoms > HUGE(1_c_int) ) THEN + IF (dnatoms > HUGE(1_c_int)) THEN WRITE(error_msg,'(A,1X,I0,1X,A)') & 'Cannot use library function scatter_atoms with more than', & HUGE(0_c_int), 'atoms [Fortran/scatter_atoms]' @@ -1446,7 +1445,7 @@ CONTAINS Cdata = C_LOC(data(1)) Ccount = SIZE(data) / natoms - IF ( Ccount /= 1 .AND. Ccount /= 3 ) THEN + IF (Ccount /= 1 .AND. Ccount /= 3) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, & 'lammps_scatter_atoms requires either 1 or 3 data per atom') END IF @@ -1466,7 +1465,7 @@ CONTAINS CHARACTER(LEN=100) :: error_msg dnatoms = lmp_get_natoms(self) - IF ( dnatoms > HUGE(1_c_int) ) THEN + IF (dnatoms > HUGE(1_c_int)) THEN WRITE(error_msg,'(A,1X,I0,1X,A)') & 'Cannot use library function scatter_atoms with more than', & HUGE(0_c_int), 'atoms [Fortran/scatter_atoms]' @@ -1478,7 +1477,7 @@ CONTAINS Cdata = C_LOC(data(1)) Ccount = SIZE(data) / natoms - IF ( Ccount /= 1 .AND. Ccount /= 3 ) THEN + IF (Ccount /= 1 .AND. Ccount /= 3) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, & 'scatter_atoms requires either 1 or 3 data per atom & &[Fortran/scatter_atoms]') @@ -1499,7 +1498,7 @@ CONTAINS Cndata = SIZE(ids, KIND=c_int) Ccount = SIZE(data, KIND=c_int) / Cndata - IF ( Ccount /= 1 .AND. Ccount /= 3 ) THEN + IF (Ccount /= 1 .AND. Ccount /= 3) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, & 'scatter_atoms_subset requires either 1 or 3 data per atom') END IF @@ -1524,7 +1523,7 @@ CONTAINS Cndata = SIZE(ids, KIND=c_int) Ccount = SIZE(data, KIND=c_int) / Cndata - IF ( Ccount /= 1 .AND. Ccount /= 3 ) THEN + IF (Ccount /= 1 .AND. Ccount /= 3) THEN CALL lmp_error(self, LMP_ERROR_ALL + LMP_ERROR_WORLD, & 'scatter_atoms_subset requires either 1 or 3 data per atom') END IF @@ -1557,7 +1556,7 @@ CONTAINS buf_size = LEN(buffer) CALL lammps_get_os_info(ptr, buf_size) DO i=1,buf_size - IF ( Cbuffer(i) == C_NULL_CHAR ) EXIT + IF (Cbuffer(i) == c_null_char) EXIT buffer(i:i) = Cbuffer(i) END DO END SUBROUTINE lmp_get_os_info @@ -1580,7 +1579,7 @@ CONTAINS ! equivalent function to lammps_config_has_png_support LOGICAL FUNCTION lmp_config_has_png_support() - INTEGER(C_int) :: has_png_support + INTEGER(c_int) :: has_png_support has_png_support = lammps_config_has_png_support() lmp_config_has_png_support = (has_png_support /= 0_c_int) @@ -1634,10 +1633,10 @@ CONTAINS Cidx = idx - 1 Cptr = C_LOC(Cbuffer(1)) Csuccess = lammps_config_package_name(Cidx, Cptr, LEN(buffer)+1) - buffer = '' - IF ( Csuccess /= 0_c_int ) THEN + buffer = ' ' + IF (Csuccess /= 0_c_int) THEN strlen = c_strlen(Cptr) - FORALL ( i = 1:strlen ) + FORALL (i = 1:strlen) buffer(i:i) = Cbuffer(i) END FORALL END IF @@ -1650,15 +1649,15 @@ CONTAINS INTEGER, PARAMETER :: MAX_BUFFER_LENGTH = 31 INTEGER :: i, npackage, buf_length - IF ( PRESENT(length) ) THEN + IF (PRESENT(length)) THEN buf_length = length ELSE buf_length = MAX_BUFFER_LENGTH END IF - IF ( ALLOCATED(package) ) DEALLOCATE(package) + IF (ALLOCATED(package)) DEALLOCATE(package) npackage = lammps_config_package_count() - ALLOCATE( CHARACTER(LEN=MAX_BUFFER_LENGTH) :: package(npackage) ) + ALLOCATE(CHARACTER(LEN=MAX_BUFFER_LENGTH) :: package(npackage)) DO i=1, npackage CALL lmp_config_package_name(i, package(i)) END DO @@ -1675,7 +1674,7 @@ CONTAINS LOGICAL FUNCTION lmp_is_running(self) CLASS(lammps), INTENT(IN) :: self - lmp_is_running = ( lammps_is_running(self%handle) /= 0_C_int ) + lmp_is_running = (lammps_is_running(self%handle) /= 0_c_int) END FUNCTION lmp_is_running ! equivalent function to lammps_force_timeout @@ -1705,7 +1704,7 @@ CONTAINS CHARACTER(LEN=1, KIND=c_char), POINTER :: c_string(:) buffer = ' ' - IF ( lmp_has_error(self) ) THEN + IF (lmp_has_error(self)) THEN buflen = LEN(buffer) length = buflen Cptr = lammps_malloc(length) @@ -1715,13 +1714,13 @@ CONTAINS buffer(i:i) = c_string(i) IF (c_string(i) == c_null_char) EXIT END DO - IF ( PRESENT(status) ) THEN + IF (PRESENT(status)) THEN status = Cstatus END IF CALL lammps_free(Cptr) ELSE buffer = ' ' - IF ( PRESENT(status) ) THEN + IF (PRESENT(status)) THEN status = 0 END IF END IF @@ -1734,7 +1733,7 @@ CONTAINS INTEGER(c_int), INTENT(OUT), POINTER :: lhs CLASS(lammps_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_INT ) THEN + IF (rhs%datatype == DATA_INT) THEN lhs => rhs%i32 ELSE CALL assignment_error(rhs, 'scalar int') @@ -1745,7 +1744,7 @@ CONTAINS INTEGER(c_int64_t), INTENT(OUT), POINTER :: lhs CLASS(lammps_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_INT64 ) THEN + IF (rhs%datatype == DATA_INT64) THEN lhs => rhs%i64 ELSE CALL assignment_error(rhs, 'scalar long int') @@ -1756,7 +1755,7 @@ CONTAINS INTEGER(c_int), DIMENSION(:), INTENT(OUT), POINTER :: lhs CLASS(lammps_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_INT_1D ) THEN + IF (rhs%datatype == DATA_INT_1D) THEN lhs => rhs%i32_vec ELSE CALL assignment_error(rhs, 'vector of ints') @@ -1767,7 +1766,7 @@ CONTAINS INTEGER(c_int64_t), DIMENSION(:), INTENT(OUT), POINTER :: lhs CLASS(lammps_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_INT64_1D ) THEN + IF (rhs%datatype == DATA_INT64_1D) THEN lhs => rhs%i64_vec ELSE CALL assignment_error(rhs, 'vector of long ints') @@ -1778,7 +1777,7 @@ CONTAINS REAL(c_double), INTENT(OUT), POINTER :: lhs CLASS(lammps_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_DOUBLE ) THEN + IF (rhs%datatype == DATA_DOUBLE) THEN lhs => rhs%r64 ELSE CALL assignment_error(rhs, 'scalar double') @@ -1789,7 +1788,7 @@ CONTAINS REAL(c_double), DIMENSION(:), INTENT(OUT), POINTER :: lhs CLASS(lammps_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_DOUBLE_1D ) THEN + IF (rhs%datatype == DATA_DOUBLE_1D) THEN lhs => rhs%r64_vec ELSE CALL assignment_error(rhs, 'vector of doubles') @@ -1800,7 +1799,7 @@ CONTAINS REAL(c_double), DIMENSION(:,:), INTENT(OUT), POINTER :: lhs CLASS(lammps_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_DOUBLE_2D ) THEN + IF (rhs%datatype == DATA_DOUBLE_2D) THEN lhs => rhs%r64_mat ELSE CALL assignment_error(rhs, 'matrix of doubles') @@ -1811,9 +1810,9 @@ CONTAINS CHARACTER(LEN=*), INTENT(OUT) :: lhs CLASS(lammps_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_STRING ) THEN + IF (rhs%datatype == DATA_STRING) THEN lhs = rhs%str - IF ( LEN_TRIM(rhs%str) > LEN(lhs) ) THEN + IF (LEN_TRIM(rhs%str) > LEN(lhs)) THEN CALL lmp_error(rhs%lammps_instance, LMP_ERROR_WARNING, & 'String provided by user required truncation [Fortran API]') END IF @@ -1829,7 +1828,7 @@ CONTAINS REAL(c_double), INTENT(OUT) :: lhs CLASS(lammps_fix_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_DOUBLE ) THEN + IF (rhs%datatype == DATA_DOUBLE) THEN lhs = rhs%r64 ELSE CALL assignment_error(rhs, 'scalar double') @@ -1840,7 +1839,7 @@ CONTAINS REAL(c_double), DIMENSION(:), INTENT(OUT), POINTER :: lhs CLASS(lammps_fix_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_DOUBLE_1D ) THEN + IF (rhs%datatype == DATA_DOUBLE_1D) THEN lhs => rhs%r64_vec ELSE CALL assignment_error(rhs, 'vector of doubles') @@ -1851,7 +1850,7 @@ CONTAINS REAL(c_double), DIMENSION(:,:), INTENT(OUT), POINTER :: lhs CLASS(lammps_fix_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_DOUBLE_2D ) THEN + IF (rhs%datatype == DATA_DOUBLE_2D) THEN lhs => rhs%r64_mat ELSE CALL assignment_error(rhs, 'matrix of doubles') @@ -1865,7 +1864,7 @@ CONTAINS REAL(c_double), INTENT(OUT) :: lhs CLASS(lammps_variable_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_DOUBLE ) THEN + IF (rhs%datatype == DATA_DOUBLE) THEN lhs = rhs%r64 ELSE CALL assignment_error(rhs, 'scalar double') @@ -1876,9 +1875,9 @@ CONTAINS REAL(c_double), DIMENSION(:), ALLOCATABLE, INTENT(OUT) :: lhs CLASS(lammps_variable_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_DOUBLE_1D ) THEN - IF ( ALLOCATED(lhs) ) DEALLOCATE(lhs) - ALLOCATE( lhs(SIZE(rhs%r64_vec)) ) + IF (rhs%datatype == DATA_DOUBLE_1D) THEN + IF (ALLOCATED(lhs)) DEALLOCATE(lhs) + ALLOCATE(lhs(SIZE(rhs%r64_vec))) lhs = rhs%r64_vec ELSE CALL assignment_error(rhs, 'vector of doubles') @@ -1889,9 +1888,9 @@ CONTAINS CHARACTER(LEN=*), INTENT(OUT) :: lhs CLASS(lammps_variable_data), INTENT(IN) :: rhs - IF ( rhs%datatype == DATA_STRING ) THEN + IF (rhs%datatype == DATA_STRING) THEN lhs = rhs%str - IF ( LEN_TRIM(rhs%str) > LEN(lhs) ) THEN + IF (LEN_TRIM(rhs%str) > LEN(lhs)) THEN CALL lmp_error(rhs%lammps_instance, LMP_ERROR_WARNING, & 'String provided by user required truncation [Fortran API]') END IF diff --git a/unittest/fortran/test_fortran_box.f90 b/unittest/fortran/test_fortran_box.f90 index 2123ae0c15..164a8a97b1 100644 --- a/unittest/fortran/test_fortran_box.f90 +++ b/unittest/fortran/test_fortran_box.f90 @@ -23,7 +23,7 @@ SUBROUTINE f_lammps_close() BIND(C, name="f_lammps_close") lmp%handle = c_null_ptr END SUBROUTINE f_lammps_close -SUBROUTINE f_lammps_box_setup () BIND(C) +SUBROUTINE f_lammps_box_setup() BIND(C) USE liblammps USE keepstuff, ONLY : lmp, demo_input IMPLICIT NONE @@ -39,84 +39,84 @@ SUBROUTINE f_lammps_delete_everything() BIND(C) CALL lmp%command("delete_atoms group all"); END SUBROUTINE f_lammps_delete_everything -FUNCTION f_lammps_extract_box_xlo () BIND(C) +FUNCTION f_lammps_extract_box_xlo() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_extract_box_xlo - REAL (c_double) :: boxdim(3) + REAL(c_double) :: f_lammps_extract_box_xlo + REAL(c_double) :: boxdim(3) CALL lmp%extract_box(boxlo=boxdim) f_lammps_extract_box_xlo = boxdim(1) END FUNCTION f_lammps_extract_box_xlo -FUNCTION f_lammps_extract_box_xhi () BIND(C) +FUNCTION f_lammps_extract_box_xhi() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_extract_box_xhi - REAL (c_double) :: boxdim(3) + REAL(c_double) :: f_lammps_extract_box_xhi + REAL(c_double) :: boxdim(3) CALL lmp%extract_box(boxhi=boxdim) f_lammps_extract_box_xhi = boxdim(1) END FUNCTION f_lammps_extract_box_xhi -FUNCTION f_lammps_extract_box_ylo () BIND(C) +FUNCTION f_lammps_extract_box_ylo() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_extract_box_ylo - REAL (c_double) :: boxdim(3) + REAL(c_double) :: f_lammps_extract_box_ylo + REAL(c_double) :: boxdim(3) CALL lmp%extract_box(boxlo=boxdim) f_lammps_extract_box_ylo = boxdim(2) END FUNCTION f_lammps_extract_box_ylo -FUNCTION f_lammps_extract_box_yhi () BIND(C) +FUNCTION f_lammps_extract_box_yhi() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_extract_box_yhi - REAL (c_double) :: boxdim(3) + REAL(c_double) :: f_lammps_extract_box_yhi + REAL(c_double) :: boxdim(3) CALL lmp%extract_box(boxhi=boxdim) f_lammps_extract_box_yhi = boxdim(2) END FUNCTION f_lammps_extract_box_yhi -FUNCTION f_lammps_extract_box_zlo () BIND(C) +FUNCTION f_lammps_extract_box_zlo() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_extract_box_zlo - REAL (c_double) :: boxdim(3) + REAL(c_double) :: f_lammps_extract_box_zlo + REAL(c_double) :: boxdim(3) CALL lmp%extract_box(boxlo=boxdim) f_lammps_extract_box_zlo = boxdim(2) END FUNCTION f_lammps_extract_box_zlo -FUNCTION f_lammps_extract_box_zhi () BIND(C) +FUNCTION f_lammps_extract_box_zhi() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_extract_box_zhi - REAL (c_double) :: boxdim(3) + REAL(c_double) :: f_lammps_extract_box_zhi + REAL(c_double) :: boxdim(3) CALL lmp%extract_box(boxhi=boxdim) f_lammps_extract_box_zhi = boxdim(2) END FUNCTION f_lammps_extract_box_zhi -SUBROUTINE f_lammps_reset_box_2x () BIND(C) +SUBROUTINE f_lammps_reset_box_2x() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: newlo(3), newhi(3), xy, yz, xz + REAL(c_double) :: newlo(3), newhi(3), xy, yz, xz xy = 0.0_c_double yz = 0.0_c_double diff --git a/unittest/fortran/test_fortran_extract_atom.f90 b/unittest/fortran/test_fortran_extract_atom.f90 index eb55754561..262e5de47d 100644 --- a/unittest/fortran/test_fortran_extract_atom.f90 +++ b/unittest/fortran/test_fortran_extract_atom.f90 @@ -22,7 +22,7 @@ SUBROUTINE f_lammps_close() BIND(C, name="f_lammps_close") lmp%handle = c_null_ptr END SUBROUTINE f_lammps_close -SUBROUTINE f_lammps_setup_extract_atom () BIND(C) +SUBROUTINE f_lammps_setup_extract_atom() BIND(C) USE LIBLAMMPS USE keepstuff, ONLY : lmp, big_input, cont_input, pair_input IMPLICIT NONE @@ -32,91 +32,91 @@ SUBROUTINE f_lammps_setup_extract_atom () BIND(C) CALL lmp%commands_list(pair_input) END SUBROUTINE f_lammps_setup_extract_atom -FUNCTION f_lammps_extract_atom_mass () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_atom_mass() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL(C_double) :: f_lammps_extract_atom_mass - REAL(C_double), DIMENSION(:), POINTER :: mass => NULL() + REAL(c_double) :: f_lammps_extract_atom_mass + REAL(c_double), DIMENSION(:), POINTER :: mass => NULL() mass = lmp%extract_atom('mass') f_lammps_extract_atom_mass = mass(1) END FUNCTION f_lammps_extract_atom_mass -FUNCTION f_lammps_extract_atom_tag_int (i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_atom_tag_int(i) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i - INTEGER(C_int) :: f_lammps_extract_atom_tag_int - INTEGER(C_int), DIMENSION(:), POINTER :: tag => NULL() + INTEGER(c_int), INTENT(IN), VALUE :: i + INTEGER(c_int) :: f_lammps_extract_atom_tag_int + INTEGER(c_int), DIMENSION(:), POINTER :: tag => NULL() tag = lmp%extract_atom('id') f_lammps_extract_atom_tag_int = tag(i) END FUNCTION f_lammps_extract_atom_tag_int -FUNCTION f_lammps_extract_atom_tag_int64 (i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int64_t +FUNCTION f_lammps_extract_atom_tag_int64(i) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int64_t USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int64_t), INTENT(IN), VALUE :: i - INTEGER(C_int64_t) :: f_lammps_extract_atom_tag_int64 - INTEGER(C_int64_t), DIMENSION(:), POINTER :: tag => NULL() + INTEGER(c_int64_t), INTENT(IN), VALUE :: i + INTEGER(c_int64_t) :: f_lammps_extract_atom_tag_int64 + INTEGER(c_int64_t), DIMENSION(:), POINTER :: tag => NULL() tag = lmp%extract_atom('id') f_lammps_extract_atom_tag_int64 = tag(i) END FUNCTION f_lammps_extract_atom_tag_int64 FUNCTION f_lammps_extract_atom_type(i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i - INTEGER(C_int) :: f_lammps_extract_atom_type - INTEGER(C_int), DIMENSION(:), POINTER :: atype => NULL() + INTEGER(c_int), INTENT(IN), VALUE :: i + INTEGER(c_int) :: f_lammps_extract_atom_type + INTEGER(c_int), DIMENSION(:), POINTER :: atype => NULL() atype = lmp%extract_atom('type') f_lammps_extract_atom_type = atype(i) END FUNCTION f_lammps_extract_atom_type FUNCTION f_lammps_extract_atom_mask(i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i - INTEGER(C_int) :: f_lammps_extract_atom_mask - INTEGER(C_int), DIMENSION(:), POINTER :: mask => NULL() + INTEGER(c_int), INTENT(IN), VALUE :: i + INTEGER(c_int) :: f_lammps_extract_atom_mask + INTEGER(c_int), DIMENSION(:), POINTER :: mask => NULL() mask = lmp%extract_atom('mask') f_lammps_extract_atom_mask = mask(i) END FUNCTION f_lammps_extract_atom_mask -SUBROUTINE f_lammps_extract_atom_x (i, x) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +SUBROUTINE f_lammps_extract_atom_x(i, x) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i - REAL(C_double), DIMENSION(3) :: x - REAL(C_double), DIMENSION(:,:), POINTER :: xptr => NULL() + INTEGER(c_int), INTENT(IN), VALUE :: i + REAL(c_double), DIMENSION(3) :: x + REAL(c_double), DIMENSION(:,:), POINTER :: xptr => NULL() xptr = lmp%extract_atom('x') x = xptr(:,i) END SUBROUTINE f_lammps_extract_atom_x -SUBROUTINE f_lammps_extract_atom_v (i, v) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +SUBROUTINE f_lammps_extract_atom_v(i, v) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i - REAL(C_double), DIMENSION(3) :: v - REAL(C_double), DIMENSION(:,:), POINTER :: vptr => NULL() + INTEGER(c_int), INTENT(IN), VALUE :: i + REAL(c_double), DIMENSION(3) :: v + REAL(c_double), DIMENSION(:,:), POINTER :: vptr => NULL() vptr = lmp%extract_atom('v') v = vptr(:,i) diff --git a/unittest/fortran/test_fortran_extract_compute.f90 b/unittest/fortran/test_fortran_extract_compute.f90 index 8f5bbdfd51..e3515f2a7a 100644 --- a/unittest/fortran/test_fortran_extract_compute.f90 +++ b/unittest/fortran/test_fortran_extract_compute.f90 @@ -22,7 +22,7 @@ SUBROUTINE f_lammps_close() BIND(C) lmp%handle = c_null_ptr END SUBROUTINE f_lammps_close -SUBROUTINE f_lammps_setup_extract_compute () BIND(C) +SUBROUTINE f_lammps_setup_extract_compute() BIND(C) USE LIBLAMMPS USE keepstuff, ONLY : lmp, big_input, cont_input, more_input, pair_input IMPLICIT NONE @@ -42,91 +42,91 @@ SUBROUTINE f_lammps_setup_extract_compute () BIND(C) CALL lmp%command("run 0") ! must be here, otherwise will SEGFAULT END SUBROUTINE f_lammps_setup_extract_compute -FUNCTION f_lammps_extract_compute_peratom_vector (i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_compute_peratom_vector(i) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i - REAL(C_double) :: f_lammps_extract_compute_peratom_vector - REAL(C_double), DIMENSION(:), POINTER :: vector => NULL() + INTEGER(c_int), INTENT(IN), VALUE :: i + REAL(c_double) :: f_lammps_extract_compute_peratom_vector + REAL(c_double), DIMENSION(:), POINTER :: vector => NULL() vector = lmp%extract_compute('peratompe', lmp%style%atom, lmp%type%vector) f_lammps_extract_compute_peratom_vector = vector(i) END FUNCTION f_lammps_extract_compute_peratom_vector -FUNCTION f_lammps_extract_compute_peratom_array (i,j) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_compute_peratom_array(i,j) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i, j - REAL(C_double) :: f_lammps_extract_compute_peratom_array - REAL(C_double), DIMENSION(:,:), POINTER :: array => NULL() + INTEGER(c_int), INTENT(IN), VALUE :: i, j + REAL(c_double) :: f_lammps_extract_compute_peratom_array + REAL(c_double), DIMENSION(:,:), POINTER :: array => NULL() array = lmp%extract_compute('stress', lmp%style%atom, lmp%type%array) f_lammps_extract_compute_peratom_array = array(i,j) END FUNCTION f_lammps_extract_compute_peratom_array -FUNCTION f_lammps_extract_compute_global_scalar () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_compute_global_scalar() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL(C_double) :: f_lammps_extract_compute_global_scalar - REAL(C_double), POINTER :: scalar + REAL(c_double) :: f_lammps_extract_compute_global_scalar + REAL(c_double), POINTER :: scalar scalar = lmp%extract_compute('totalpe', lmp%style%global, lmp%type%scalar) f_lammps_extract_compute_global_scalar = scalar END FUNCTION f_lammps_extract_compute_global_scalar -FUNCTION f_lammps_extract_compute_global_vector (i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_compute_global_vector(i) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE INTEGER(c_int), INTENT(IN), VALUE :: i - REAL(C_double) :: f_lammps_extract_compute_global_vector - REAL(C_double), DIMENSION(:), POINTER :: vector + REAL(c_double) :: f_lammps_extract_compute_global_vector + REAL(c_double), DIMENSION(:), POINTER :: vector vector = lmp%extract_compute('COM', lmp%style%global, lmp%type%vector) f_lammps_extract_compute_global_vector = vector(i) END FUNCTION f_lammps_extract_compute_global_vector -FUNCTION f_lammps_extract_compute_global_array (i,j) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_compute_global_array(i,j) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE INTEGER(c_int), INTENT(IN), VALUE :: i, j - REAL(C_double) :: f_lammps_extract_compute_global_array - REAL(C_double), DIMENSION(:,:), POINTER :: array + REAL(c_double) :: f_lammps_extract_compute_global_array + REAL(c_double), DIMENSION(:,:), POINTER :: array array = lmp%extract_compute('RDF', lmp%style%global, lmp%type%array) f_lammps_extract_compute_global_array = array(i,j) END FUNCTION f_lammps_extract_compute_global_array -FUNCTION f_lammps_extract_compute_local_vector (i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_compute_local_vector(i) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE INTEGER(c_int), INTENT(IN), VALUE :: i - REAL(C_double) :: f_lammps_extract_compute_local_vector - REAL(C_double), DIMENSION(:), POINTER :: vector + REAL(c_double) :: f_lammps_extract_compute_local_vector + REAL(c_double), DIMENSION(:), POINTER :: vector vector = lmp%extract_compute('pairdist', lmp%style%local, lmp%type%vector) f_lammps_extract_compute_local_vector = vector(i) END FUNCTION f_lammps_extract_compute_local_vector -FUNCTION f_lammps_extract_compute_local_array (i, j) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_compute_local_array(i, j) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE INTEGER(c_int), INTENT(IN), VALUE :: i, j - REAL(C_double) :: f_lammps_extract_compute_local_array - REAL(C_double), DIMENSION(:,:), POINTER :: array + REAL(c_double) :: f_lammps_extract_compute_local_array + REAL(c_double), DIMENSION(:,:), POINTER :: array array = lmp%extract_compute('pairlocal', lmp%style%local, lmp%type%array) f_lammps_extract_compute_local_array = array(i,j) diff --git a/unittest/fortran/test_fortran_extract_fix.f90 b/unittest/fortran/test_fortran_extract_fix.f90 index 7d5e18016b..24f90553a5 100644 --- a/unittest/fortran/test_fortran_extract_fix.f90 +++ b/unittest/fortran/test_fortran_extract_fix.f90 @@ -22,7 +22,7 @@ SUBROUTINE f_lammps_close() BIND(C) lmp%handle = C_NULL_PTR END SUBROUTINE f_lammps_close -SUBROUTINE f_lammps_setup_extract_fix () BIND(C) +SUBROUTINE f_lammps_setup_extract_fix() BIND(C) USE LIBLAMMPS USE keepstuff, ONLY : lmp, big_input, cont_input, pair_input, more_input IMPLICIT NONE @@ -40,59 +40,59 @@ SUBROUTINE f_lammps_setup_extract_fix () BIND(C) CALL lmp%command("run 1") ! must be 1, otherwise move/recenter won't happen END SUBROUTINE f_lammps_setup_extract_fix -FUNCTION f_lammps_extract_fix_global_scalar () BIND(C) RESULT(scalar) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_fix_global_scalar() BIND(C) RESULT(scalar) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL(C_double) :: scalar + REAL(c_double) :: scalar scalar = lmp%extract_fix("recenter", lmp%style%global, lmp%type%scalar) END FUNCTION f_lammps_extract_fix_global_scalar -FUNCTION f_lammps_extract_fix_global_vector (i) BIND(C) RESULT(element) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_fix_global_vector(i) BIND(C) RESULT(element) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i - REAL(C_double) :: element + INTEGER(c_int), INTENT(IN), VALUE :: i + REAL(c_double) :: element element = lmp%extract_fix("recenter", lmp%style%global, lmp%type%vector, i) END FUNCTION f_lammps_extract_fix_global_vector -FUNCTION f_lammps_extract_fix_global_array (i,j) BIND(C) RESULT(element) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_fix_global_array(i,j) BIND(C) RESULT(element) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i, j - REAL(C_double) :: element + INTEGER(c_int), INTENT(IN), VALUE :: i, j + REAL(c_double) :: element element = lmp%extract_fix("vec", lmp%style%global, lmp%type%array, i, j) END FUNCTION f_lammps_extract_fix_global_array -FUNCTION f_lammps_extract_fix_peratom_vector (i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_fix_peratom_vector(i) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i - REAL(C_double) :: f_lammps_extract_fix_peratom_vector - REAL(C_double), DIMENSION(:), POINTER :: vector + INTEGER(c_int), INTENT(IN), VALUE :: i + REAL(c_double) :: f_lammps_extract_fix_peratom_vector + REAL(c_double), DIMENSION(:), POINTER :: vector vector = lmp%extract_fix("state", lmp%style%atom, lmp%type%vector, -1, -1) f_lammps_extract_fix_peratom_vector = vector(i) END FUNCTION f_lammps_extract_fix_peratom_vector -FUNCTION f_lammps_extract_fix_peratom_array (i,j) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int +FUNCTION f_lammps_extract_fix_peratom_array(i,j) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER(C_int), INTENT(IN), VALUE :: i, j - REAL(C_double) :: f_lammps_extract_fix_peratom_array - REAL(C_double), DIMENSION(:,:), POINTER :: array + INTEGER(c_int), INTENT(IN), VALUE :: i, j + REAL(c_double) :: f_lammps_extract_fix_peratom_array + REAL(c_double), DIMENSION(:,:), POINTER :: array array = lmp%extract_fix("move", lmp%style%atom, lmp%type%array, -1, -1) f_lammps_extract_fix_peratom_array = array(i,j) diff --git a/unittest/fortran/test_fortran_extract_global.f90 b/unittest/fortran/test_fortran_extract_global.f90 index f89087869c..5add92c1be 100644 --- a/unittest/fortran/test_fortran_extract_global.f90 +++ b/unittest/fortran/test_fortran_extract_global.f90 @@ -22,7 +22,7 @@ SUBROUTINE f_lammps_close() BIND(C, name="f_lammps_close") lmp%handle = c_null_ptr END SUBROUTINE f_lammps_close -SUBROUTINE f_lammps_setup_extract_global () BIND(C) +SUBROUTINE f_lammps_setup_extract_global() BIND(C) USE LIBLAMMPS USE keepstuff, ONLY : lmp, big_input, cont_input, pair_input IMPLICIT NONE @@ -33,12 +33,12 @@ SUBROUTINE f_lammps_setup_extract_global () BIND(C) CALL lmp%command('run 0') END SUBROUTINE f_lammps_setup_extract_global -SUBROUTINE f_lammps_setup_full_extract_global () BIND(C) +SUBROUTINE f_lammps_setup_full_extract_global() BIND(C) USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE INTERFACE - SUBROUTINE f_lammps_setup_extract_global () BIND(C) + SUBROUTINE f_lammps_setup_extract_global() BIND(C) END SUBROUTINE f_lammps_setup_extract_global END INTERFACE @@ -50,422 +50,428 @@ SUBROUTINE f_lammps_setup_full_extract_global () BIND(C) CALL lmp%command('run 0') END SUBROUTINE f_lammps_setup_full_extract_global -FUNCTION f_lammps_extract_global_units () BIND(C) RESULT(success) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_units() BIND(C) RESULT(success) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER (C_int) :: success - CHARACTER (LEN=16) :: units + INTEGER(c_int) :: success + CHARACTER(LEN=16) :: units ! passing strings from Fortran to C is icky, so we do the test here and ! report the result instead units = lmp%extract_global('units') - IF ( TRIM(units) == 'lj' ) THEN - success = 1_C_int + IF (TRIM(units) == 'lj') THEN + success = 1_c_int ELSE - success = 0_C_int + success = 0_c_int END IF END FUNCTION f_lammps_extract_global_units -FUNCTION f_lammps_extract_global_ntimestep () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_ntimestep() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: ntimestep - INTEGER (C_int) :: f_lammps_extract_global_ntimestep + INTEGER(c_int), POINTER :: ntimestep + INTEGER(c_int) :: f_lammps_extract_global_ntimestep ntimestep = lmp%extract_global("ntimestep") f_lammps_extract_global_ntimestep = ntimestep END FUNCTION f_lammps_extract_global_ntimestep -FUNCTION f_lammps_extract_global_ntimestep_big () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int64_t + +FUNCTION f_lammps_extract_global_ntimestep_big() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int64_t USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int64_t), POINTER :: ntimestep - INTEGER (C_int64_t) :: f_lammps_extract_global_ntimestep_big + INTEGER(c_int64_t), POINTER :: ntimestep + INTEGER(c_int64_t) :: f_lammps_extract_global_ntimestep_big ntimestep = lmp%extract_global("ntimestep") f_lammps_extract_global_ntimestep_big = ntimestep END FUNCTION f_lammps_extract_global_ntimestep_big -FUNCTION f_lammps_extract_global_dt () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_dt() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double), POINTER :: dt - REAL (C_double) :: f_lammps_extract_global_dt + REAL(c_double), POINTER :: dt + REAL(c_double) :: f_lammps_extract_global_dt dt = lmp%extract_global("dt") f_lammps_extract_global_dt = dt END FUNCTION f_lammps_extract_global_dt -SUBROUTINE f_lammps_extract_global_boxlo (C_boxlo) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +SUBROUTINE f_lammps_extract_global_boxlo(C_boxlo) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double), DIMENSION(3) :: C_boxlo - REAL (C_double), DIMENSION(:), POINTER :: boxlo + REAL(c_double), DIMENSION(3) :: C_boxlo + REAL(c_double), DIMENSION(:), POINTER :: boxlo boxlo = lmp%extract_global("boxlo") C_boxlo = boxlo END SUBROUTINE f_lammps_extract_global_boxlo -SUBROUTINE f_lammps_extract_global_boxhi (C_boxhi) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +SUBROUTINE f_lammps_extract_global_boxhi(C_boxhi) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double), DIMENSION(3) :: C_boxhi - REAL (C_double), DIMENSION(:), POINTER :: boxhi + REAL(c_double), DIMENSION(3) :: C_boxhi + REAL(c_double), DIMENSION(:), POINTER :: boxhi boxhi = lmp%extract_global("boxhi") C_boxhi = boxhi END SUBROUTINE f_lammps_extract_global_boxhi -FUNCTION f_lammps_extract_global_boxxlo () BIND(C) RESULT(C_boxxlo) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_boxxlo() BIND(C) RESULT(C_boxxlo) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_boxxlo - REAL (C_double), POINTER :: boxxlo + REAL(c_double) :: C_boxxlo + REAL(c_double), POINTER :: boxxlo boxxlo = lmp%extract_global("boxxlo") C_boxxlo = boxxlo END FUNCTION f_lammps_extract_global_boxxlo -FUNCTION f_lammps_extract_global_boxxhi () BIND(C) RESULT(C_boxxhi) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_boxxhi() BIND(C) RESULT(C_boxxhi) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_boxxhi - REAL (C_double), POINTER :: boxxhi + REAL(c_double) :: C_boxxhi + REAL(c_double), POINTER :: boxxhi boxxhi = lmp%extract_global("boxxhi") C_boxxhi = boxxhi END FUNCTION f_lammps_extract_global_boxxhi -FUNCTION f_lammps_extract_global_boxylo () BIND(C) RESULT(C_boxylo) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_boxylo() BIND(C) RESULT(C_boxylo) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_boxylo - REAL (C_double), POINTER :: boxylo + REAL(c_double) :: C_boxylo + REAL(c_double), POINTER :: boxylo boxylo = lmp%extract_global("boxylo") C_boxylo = boxylo END FUNCTION f_lammps_extract_global_boxylo -FUNCTION f_lammps_extract_global_boxyhi () BIND(C) RESULT(C_boxyhi) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_boxyhi() BIND(C) RESULT(C_boxyhi) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_boxyhi - REAL (C_double), POINTER :: boxyhi + REAL(c_double) :: C_boxyhi + REAL(c_double), POINTER :: boxyhi boxyhi = lmp%extract_global("boxyhi") C_boxyhi = boxyhi END FUNCTION f_lammps_extract_global_boxyhi -FUNCTION f_lammps_extract_global_boxzlo () BIND(C) RESULT(C_boxzlo) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_boxzlo() BIND(C) RESULT(C_boxzlo) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_boxzlo - REAL (C_double), POINTER :: boxzlo + REAL(c_double) :: C_boxzlo + REAL(c_double), POINTER :: boxzlo boxzlo = lmp%extract_global("boxzlo") C_boxzlo = boxzlo END FUNCTION f_lammps_extract_global_boxzlo -FUNCTION f_lammps_extract_global_boxzhi () BIND(C) RESULT(C_boxzhi) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_boxzhi() BIND(C) RESULT(C_boxzhi) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_boxzhi - REAL (C_double), POINTER :: boxzhi + REAL(c_double) :: C_boxzhi + REAL(c_double), POINTER :: boxzhi boxzhi = lmp%extract_global("boxzhi") C_boxzhi = boxzhi END FUNCTION f_lammps_extract_global_boxzhi -SUBROUTINE f_lammps_extract_global_periodicity (C_periodicity) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +SUBROUTINE f_lammps_extract_global_periodicity(C_periodicity) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), DIMENSION(3) :: C_periodicity - INTEGER (C_int), DIMENSION(:), POINTER :: periodicity + INTEGER(c_int), DIMENSION(3) :: C_periodicity + INTEGER(c_int), DIMENSION(:), POINTER :: periodicity periodicity = lmp%extract_global("periodicity") C_periodicity = periodicity END SUBROUTINE f_lammps_extract_global_periodicity -FUNCTION f_lammps_extract_global_triclinic () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_triclinic() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: triclinic - INTEGER (C_int) :: f_lammps_extract_global_triclinic + INTEGER(c_int), POINTER :: triclinic + INTEGER(c_int) :: f_lammps_extract_global_triclinic triclinic = lmp%extract_global("triclinic") f_lammps_extract_global_triclinic = triclinic END FUNCTION f_lammps_extract_global_triclinic -FUNCTION f_lammps_extract_global_xy () BIND(C) RESULT(C_xy) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_xy() BIND(C) RESULT(C_xy) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_xy - REAL (C_double), POINTER :: xy + REAL(c_double) :: C_xy + REAL(c_double), POINTER :: xy xy = lmp%extract_global("xy") C_xy = xy END FUNCTION f_lammps_extract_global_xy -FUNCTION f_lammps_extract_global_xz () BIND(C) RESULT(C_xz) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_xz() BIND(C) RESULT(C_xz) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_xz - REAL (C_double), POINTER :: xz + REAL(c_double) :: C_xz + REAL(c_double), POINTER :: xz xz = lmp%extract_global("xz") C_xz = xz END FUNCTION f_lammps_extract_global_xz -FUNCTION f_lammps_extract_global_yz () BIND(C) RESULT(C_yz) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_yz() BIND(C) RESULT(C_yz) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_yz - REAL (C_double), POINTER :: yz + REAL(c_double) :: C_yz + REAL(c_double), POINTER :: yz yz = lmp%extract_global("yz") C_yz = yz END FUNCTION f_lammps_extract_global_yz -FUNCTION f_lammps_extract_global_natoms () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_natoms() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: natoms - INTEGER (C_int) :: f_lammps_extract_global_natoms + INTEGER(c_int), POINTER :: natoms + INTEGER(c_int) :: f_lammps_extract_global_natoms natoms = lmp%extract_global("natoms") f_lammps_extract_global_natoms = natoms END FUNCTION f_lammps_extract_global_natoms -FUNCTION f_lammps_extract_global_natoms_big () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int64_t + +FUNCTION f_lammps_extract_global_natoms_big() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int64_t USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int64_t), POINTER :: natoms - INTEGER (C_int64_t) :: f_lammps_extract_global_natoms_big + INTEGER(c_int64_t), POINTER :: natoms + INTEGER(c_int64_t) :: f_lammps_extract_global_natoms_big natoms = lmp%extract_global("natoms") f_lammps_extract_global_natoms_big = natoms END FUNCTION f_lammps_extract_global_natoms_big -FUNCTION f_lammps_extract_global_nbonds () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_nbonds() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: nbonds - INTEGER (C_int) :: f_lammps_extract_global_nbonds + INTEGER(c_int), POINTER :: nbonds + INTEGER(c_int) :: f_lammps_extract_global_nbonds nbonds = lmp%extract_global("nbonds") f_lammps_extract_global_nbonds = nbonds END FUNCTION f_lammps_extract_global_nbonds -FUNCTION f_lammps_extract_global_nbonds_big () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int64_t + +FUNCTION f_lammps_extract_global_nbonds_big() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int64_t USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int64_t), POINTER :: nbonds - INTEGER (C_int64_t) :: f_lammps_extract_global_nbonds_big + INTEGER(c_int64_t), POINTER :: nbonds + INTEGER(c_int64_t) :: f_lammps_extract_global_nbonds_big nbonds = lmp%extract_global("nbonds") f_lammps_extract_global_nbonds_big = nbonds END FUNCTION f_lammps_extract_global_nbonds_big -FUNCTION f_lammps_extract_global_nangles () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_nangles() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: nangles - INTEGER (C_int) :: f_lammps_extract_global_nangles + INTEGER(c_int), POINTER :: nangles + INTEGER(c_int) :: f_lammps_extract_global_nangles nangles = lmp%extract_global("nangles") f_lammps_extract_global_nangles = nangles END FUNCTION f_lammps_extract_global_nangles -FUNCTION f_lammps_extract_global_nangles_big () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int64_t + +FUNCTION f_lammps_extract_global_nangles_big() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int64_t USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int64_t), POINTER :: nangles - INTEGER (C_int64_t) :: f_lammps_extract_global_nangles_big + INTEGER(c_int64_t), POINTER :: nangles + INTEGER(c_int64_t) :: f_lammps_extract_global_nangles_big nangles = lmp%extract_global("nangles") f_lammps_extract_global_nangles_big = nangles END FUNCTION f_lammps_extract_global_nangles_big -FUNCTION f_lammps_extract_global_ndihedrals () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_ndihedrals() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: ndihedrals - INTEGER (C_int) :: f_lammps_extract_global_ndihedrals + INTEGER(c_int), POINTER :: ndihedrals + INTEGER(c_int) :: f_lammps_extract_global_ndihedrals ndihedrals = lmp%extract_global("ndihedrals") f_lammps_extract_global_ndihedrals = ndihedrals END FUNCTION f_lammps_extract_global_ndihedrals -FUNCTION f_lammps_extract_global_ndihedrals_big () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int64_t + +FUNCTION f_lammps_extract_global_ndihedrals_big() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int64_t USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int64_t), POINTER :: ndihedrals - INTEGER (C_int64_t) :: f_lammps_extract_global_ndihedrals_big + INTEGER(c_int64_t), POINTER :: ndihedrals + INTEGER(c_int64_t) :: f_lammps_extract_global_ndihedrals_big ndihedrals = lmp%extract_global("ndihedrals") f_lammps_extract_global_ndihedrals_big = ndihedrals END FUNCTION f_lammps_extract_global_ndihedrals_big -FUNCTION f_lammps_extract_global_nimpropers () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_nimpropers() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: nimpropers - INTEGER (C_int) :: f_lammps_extract_global_nimpropers + INTEGER(c_int), POINTER :: nimpropers + INTEGER(c_int) :: f_lammps_extract_global_nimpropers nimpropers = lmp%extract_global("nimpropers") f_lammps_extract_global_nimpropers = nimpropers END FUNCTION f_lammps_extract_global_nimpropers -FUNCTION f_lammps_extract_global_nimpropers_big () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int64_t + +FUNCTION f_lammps_extract_global_nimpropers_big() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int64_t USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int64_t), POINTER :: nimpropers - INTEGER (C_int64_t) :: f_lammps_extract_global_nimpropers_big + INTEGER(c_int64_t), POINTER :: nimpropers + INTEGER(c_int64_t) :: f_lammps_extract_global_nimpropers_big nimpropers = lmp%extract_global("nimpropers") f_lammps_extract_global_nimpropers_big = nimpropers END FUNCTION f_lammps_extract_global_nimpropers_big -FUNCTION f_lammps_extract_global_ntypes () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_ntypes() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: ntypes - INTEGER (C_int) :: f_lammps_extract_global_ntypes + INTEGER(c_int), POINTER :: ntypes + INTEGER(c_int) :: f_lammps_extract_global_ntypes ntypes = lmp%extract_global("ntypes") f_lammps_extract_global_ntypes = ntypes END FUNCTION f_lammps_extract_global_ntypes -FUNCTION f_lammps_extract_global_nlocal () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_nlocal() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: nlocal - INTEGER (C_int) :: f_lammps_extract_global_nlocal + INTEGER(c_int), POINTER :: nlocal + INTEGER(c_int) :: f_lammps_extract_global_nlocal nlocal = lmp%extract_global("nlocal") f_lammps_extract_global_nlocal = nlocal END FUNCTION f_lammps_extract_global_nlocal -FUNCTION f_lammps_extract_global_nghost () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_nghost() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: nghost - INTEGER (C_int) :: f_lammps_extract_global_nghost + INTEGER(c_int), POINTER :: nghost + INTEGER(c_int) :: f_lammps_extract_global_nghost nghost = lmp%extract_global("nghost") f_lammps_extract_global_nghost = nghost END FUNCTION f_lammps_extract_global_nghost -FUNCTION f_lammps_extract_global_nmax () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_extract_global_nmax() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int), POINTER :: nmax - INTEGER (C_int) :: f_lammps_extract_global_nmax + INTEGER(c_int), POINTER :: nmax + INTEGER(c_int) :: f_lammps_extract_global_nmax nmax = lmp%extract_global("nmax") f_lammps_extract_global_nmax = nmax END FUNCTION f_lammps_extract_global_nmax -FUNCTION f_lammps_extract_global_boltz () BIND(C) RESULT(C_k_B) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_boltz() BIND(C) RESULT(C_k_B) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_k_B - REAL (C_double), POINTER :: k_B + REAL(c_double) :: C_k_B + REAL(c_double), POINTER :: k_B k_B = lmp%extract_global("boltz") C_k_B = k_B END FUNCTION f_lammps_extract_global_boltz -FUNCTION f_lammps_extract_global_hplanck () BIND(C) RESULT(C_h) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_hplanck() BIND(C) RESULT(C_h) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: C_h - REAL (C_double), POINTER :: h + REAL(c_double) :: C_h + REAL(c_double), POINTER :: h h = lmp%extract_global("boltz") C_h = h END FUNCTION f_lammps_extract_global_hplanck -FUNCTION f_lammps_extract_global_angstrom () BIND(C) RESULT(Angstrom) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_angstrom() BIND(C) RESULT(Angstrom) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: Angstrom - REAL (C_double), POINTER :: A + REAL(c_double) :: Angstrom + REAL(c_double), POINTER :: A A = lmp%extract_global("angstrom") Angstrom = A END FUNCTION f_lammps_extract_global_angstrom -FUNCTION f_lammps_extract_global_femtosecond () BIND(C) RESULT(fs) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +FUNCTION f_lammps_extract_global_femtosecond() BIND(C) RESULT(fs) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - REAL (C_double) :: fs - REAL (C_double), POINTER :: femtosecond + REAL(c_double) :: fs + REAL(c_double), POINTER :: femtosecond femtosecond = lmp%extract_global("femtosecond") fs = femtosecond diff --git a/unittest/fortran/test_fortran_extract_variable.f90 b/unittest/fortran/test_fortran_extract_variable.f90 index 1e05dd5a27..34ccb766de 100644 --- a/unittest/fortran/test_fortran_extract_variable.f90 +++ b/unittest/fortran/test_fortran_extract_variable.f90 @@ -42,7 +42,7 @@ CONTAINS c_absolute_path = c_path_join(c_test_input_directory, c_filename) length = c_strlen(c_absolute_path) CALL C_F_POINTER(c_absolute_path, F_absolute_path, [length]) - ALLOCATE( CHARACTER(LEN=length) :: absolute_path ) + ALLOCATE(CHARACTER(LEN=length) :: absolute_path) DO i = 1, length absolute_path(i:i) = F_absolute_path(i) END DO @@ -159,7 +159,7 @@ SUBROUTINE f_lammps_setup_extract_variable () BIND(C) CALL lmp%command('variable greeting file ' // absolute_path('greetings.txt')) CALL lmp%command('variable atfile atomfile ' & // absolute_path('atomdata.txt')) - IF ( lmp%config_has_package('PYTHON') ) THEN + IF (lmp%config_has_package('PYTHON')) THEN CALL lmp%command(py_input) CALL lmp%command('variable py python square_it') END IF @@ -174,7 +174,7 @@ SUBROUTINE f_lammps_setup_extract_variable () BIND(C) END SUBROUTINE f_lammps_setup_extract_variable FUNCTION f_lammps_extract_variable_index_1 () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -182,7 +182,7 @@ FUNCTION f_lammps_extract_variable_index_1 () BIND(C) CHARACTER(LEN=256) :: str str = lmp%extract_variable("idx") - IF ( trim(str) == 'hello' ) THEN + IF (trim(str) == 'hello') THEN f_lammps_extract_variable_index_1 = 1_c_int ELSE f_lammps_extract_variable_index_1 = 0_c_int @@ -190,7 +190,7 @@ FUNCTION f_lammps_extract_variable_index_1 () BIND(C) END FUNCTION f_lammps_extract_variable_index_1 FUNCTION f_lammps_extract_variable_index_2 () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -198,7 +198,7 @@ FUNCTION f_lammps_extract_variable_index_2 () BIND(C) CHARACTER(LEN=256) :: str str = lmp%extract_variable("idx") - IF ( trim(str) == 'goodbye' ) THEN + IF (trim(str) == 'goodbye') THEN f_lammps_extract_variable_index_2 = 1_c_int ELSE f_lammps_extract_variable_index_2 = 0_c_int @@ -206,7 +206,7 @@ FUNCTION f_lammps_extract_variable_index_2 () BIND(C) END FUNCTION f_lammps_extract_variable_index_2 FUNCTION f_lammps_extract_variable_loop () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int, C_double + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int, c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -218,7 +218,7 @@ FUNCTION f_lammps_extract_variable_loop () BIND(C) END FUNCTION f_lammps_extract_variable_loop FUNCTION f_lammps_extract_variable_loop_pad () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_ptr + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_ptr USE LIBLAMMPS USE keepstuff, ONLY : lmp USE keepvar, ONLY : f2c_string @@ -231,7 +231,7 @@ FUNCTION f_lammps_extract_variable_loop_pad () BIND(C) END FUNCTION f_lammps_extract_variable_loop_pad FUNCTION f_lammps_extract_variable_world () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_ptr + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_ptr USE LIBLAMMPS USE keepstuff, ONLY : lmp USE keepvar, ONLY : f2c_string @@ -244,7 +244,7 @@ FUNCTION f_lammps_extract_variable_world () BIND(C) END FUNCTION f_lammps_extract_variable_world FUNCTION f_lammps_extract_variable_universe () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_ptr + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_ptr USE LIBLAMMPS USE keepstuff, ONLY : lmp USE keepvar, ONLY : f2c_string @@ -257,7 +257,7 @@ FUNCTION f_lammps_extract_variable_universe () BIND(C) END FUNCTION f_lammps_extract_variable_universe FUNCTION f_lammps_extract_variable_uloop () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -269,7 +269,7 @@ FUNCTION f_lammps_extract_variable_uloop () BIND(C) END FUNCTION f_lammps_extract_variable_uloop FUNCTION f_lammps_extract_variable_string () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_ptr + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_ptr USE LIBLAMMPS USE keepstuff, ONLY : lmp USE keepvar, ONLY : f2c_string @@ -282,7 +282,7 @@ FUNCTION f_lammps_extract_variable_string () BIND(C) END FUNCTION f_lammps_extract_variable_string FUNCTION f_lammps_extract_variable_format () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_ptr + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_ptr USE LIBLAMMPS USE keepstuff, ONLY : lmp USE keepvar, ONLY : f2c_string @@ -295,7 +295,7 @@ FUNCTION f_lammps_extract_variable_format () BIND(C) END FUNCTION f_lammps_extract_variable_format FUNCTION f_lammps_extract_variable_format_pad () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_ptr + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_ptr USE LIBLAMMPS USE keepstuff, ONLY : lmp USE keepvar, ONLY : f2c_string @@ -308,7 +308,7 @@ FUNCTION f_lammps_extract_variable_format_pad () BIND(C) END FUNCTION f_lammps_extract_variable_format_pad FUNCTION f_lammps_extract_variable_getenv () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_ptr + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_ptr USE LIBLAMMPS USE keepstuff, ONLY : lmp USE keepvar, ONLY : f2c_string @@ -321,7 +321,7 @@ FUNCTION f_lammps_extract_variable_getenv () BIND(C) END FUNCTION f_lammps_extract_variable_getenv FUNCTION f_lammps_extract_variable_file () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_ptr + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_ptr USE LIBLAMMPS USE keepstuff, ONLY : lmp USE keepvar, ONLY : f2c_string @@ -334,7 +334,7 @@ FUNCTION f_lammps_extract_variable_file () BIND(C) END FUNCTION f_lammps_extract_variable_file FUNCTION f_lammps_extract_variable_atomfile(i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int, C_double + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int, c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -347,7 +347,7 @@ FUNCTION f_lammps_extract_variable_atomfile(i) BIND(C) END FUNCTION f_lammps_extract_variable_atomfile FUNCTION f_lammps_extract_variable_python(i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int, C_double + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int, c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -358,7 +358,7 @@ FUNCTION f_lammps_extract_variable_python(i) BIND(C) END FUNCTION f_lammps_extract_variable_python FUNCTION f_lammps_extract_variable_timer() BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -368,7 +368,7 @@ FUNCTION f_lammps_extract_variable_timer() BIND(C) END FUNCTION f_lammps_extract_variable_timer FUNCTION f_lammps_extract_variable_internal() BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -378,7 +378,7 @@ FUNCTION f_lammps_extract_variable_internal() BIND(C) END FUNCTION f_lammps_extract_variable_internal FUNCTION f_lammps_extract_variable_equal() BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -388,7 +388,7 @@ FUNCTION f_lammps_extract_variable_equal() BIND(C) END FUNCTION f_lammps_extract_variable_equal FUNCTION f_lammps_extract_variable_atom(i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -401,7 +401,7 @@ FUNCTION f_lammps_extract_variable_atom(i) BIND(C) END FUNCTION f_lammps_extract_variable_atom FUNCTION f_lammps_extract_variable_vector(i) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp IMPLICIT NONE @@ -414,7 +414,7 @@ FUNCTION f_lammps_extract_variable_vector(i) BIND(C) END FUNCTION f_lammps_extract_variable_vector SUBROUTINE f_lammps_set_variable_string() BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double, C_int + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double, c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp USE keepvar, ONLY : f2c_string diff --git a/unittest/fortran/test_fortran_gather_scatter.f90 b/unittest/fortran/test_fortran_gather_scatter.f90 index dd9182afaa..69bb0e030f 100644 --- a/unittest/fortran/test_fortran_gather_scatter.f90 +++ b/unittest/fortran/test_fortran_gather_scatter.f90 @@ -22,7 +22,7 @@ SUBROUTINE f_lammps_close() BIND(C) lmp%handle = c_null_ptr END SUBROUTINE f_lammps_close -SUBROUTINE f_lammps_setup_gather_scatter () BIND(C) +SUBROUTINE f_lammps_setup_gather_scatter() BIND(C) USE LIBLAMMPS USE keepstuff, ONLY : lmp, big_input, cont_input, more_input IMPLICIT NONE @@ -33,7 +33,7 @@ SUBROUTINE f_lammps_setup_gather_scatter () BIND(C) CALL lmp%commands_list(more_input) END SUBROUTINE f_lammps_setup_gather_scatter -FUNCTION f_lammps_gather_atoms_mask (i) BIND(C) +FUNCTION f_lammps_gather_atoms_mask(i) BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp @@ -46,7 +46,7 @@ FUNCTION f_lammps_gather_atoms_mask (i) BIND(C) f_lammps_gather_atoms_mask = mask(i) END FUNCTION f_lammps_gather_atoms_mask -FUNCTION f_lammps_gather_atoms_position (i) BIND(C) +FUNCTION f_lammps_gather_atoms_position(i) BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int, c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp @@ -59,7 +59,7 @@ FUNCTION f_lammps_gather_atoms_position (i) BIND(C) f_lammps_gather_atoms_position = positions(i) END FUNCTION f_lammps_gather_atoms_position -FUNCTION f_lammps_gather_atoms_concat_mask (i) BIND(C) +FUNCTION f_lammps_gather_atoms_concat_mask(i) BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp @@ -72,7 +72,7 @@ FUNCTION f_lammps_gather_atoms_concat_mask (i) BIND(C) CALL lmp%gather_atoms_concat('mask', 1_c_int, mask) CALL lmp%gather_atoms_concat('id', 1_c_int, tag) DO j = 1, SIZE(tag) - IF ( tag(j) == i ) THEN + IF (tag(j) == i) THEN f_lammps_gather_atoms_concat_mask = mask(j) RETURN END IF @@ -80,7 +80,7 @@ FUNCTION f_lammps_gather_atoms_concat_mask (i) BIND(C) f_lammps_gather_atoms_concat_mask = -1 END FUNCTION f_lammps_gather_atoms_concat_mask -FUNCTION f_lammps_gather_atoms_concat_position (xyz, id) BIND(C) +FUNCTION f_lammps_gather_atoms_concat_position(xyz, id) BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int, c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp @@ -94,13 +94,13 @@ FUNCTION f_lammps_gather_atoms_concat_position (xyz, id) BIND(C) CALL lmp%gather_atoms_concat('x', 3_c_int, positions) CALL lmp%gather_atoms_concat('id', 1_c_int, tag) DO j = 1, SIZE(tag) - IF ( tag(j) == id ) THEN + IF (tag(j) == id) THEN f_lammps_gather_atoms_concat_position = positions((j-1)*3 + xyz) END IF END DO END FUNCTION f_lammps_gather_atoms_concat_position -FUNCTION f_lammps_gather_atoms_subset_mask (i) BIND(C) +FUNCTION f_lammps_gather_atoms_subset_mask(i) BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE LIBLAMMPS USE keepstuff, ONLY : lmp @@ -113,7 +113,7 @@ FUNCTION f_lammps_gather_atoms_subset_mask (i) BIND(C) CALL lmp%gather_atoms_subset('mask', 1_c_int, tag, mask) DO j = 1, SIZE(tag) - IF ( tag(j) == i ) THEN + IF (tag(j) == i) THEN f_lammps_gather_atoms_subset_mask = mask(j) RETURN END IF @@ -121,7 +121,7 @@ FUNCTION f_lammps_gather_atoms_subset_mask (i) BIND(C) f_lammps_gather_atoms_subset_mask = -1 END FUNCTION f_lammps_gather_atoms_subset_mask -FUNCTION f_lammps_gather_atoms_subset_position (xyz,id) BIND(C) +FUNCTION f_lammps_gather_atoms_subset_position(xyz,id) BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int, c_double USE LIBLAMMPS USE keepstuff, ONLY : lmp @@ -134,7 +134,7 @@ FUNCTION f_lammps_gather_atoms_subset_position (xyz,id) BIND(C) CALL lmp%gather_atoms_subset('x', 3_c_int, tag, positions) DO j = 1, SIZE(tag) - IF ( tag(j) == id ) THEN + IF (tag(j) == id) THEN f_lammps_gather_atoms_subset_position = positions((j-1)*3 + xyz) RETURN END IF diff --git a/unittest/fortran/test_fortran_get_thermo.f90 b/unittest/fortran/test_fortran_get_thermo.f90 index d1b193e188..7911ab07d5 100644 --- a/unittest/fortran/test_fortran_get_thermo.f90 +++ b/unittest/fortran/test_fortran_get_thermo.f90 @@ -23,7 +23,7 @@ SUBROUTINE f_lammps_close() BIND(C) lmp%handle = c_null_ptr END SUBROUTINE f_lammps_close -SUBROUTINE f_lammps_get_thermo_setup () BIND(C) +SUBROUTINE f_lammps_get_thermo_setup() BIND(C) USE liblammps USE keepstuff, ONLY : lmp, big_input, cont_input, pair_input IMPLICIT NONE @@ -33,122 +33,122 @@ SUBROUTINE f_lammps_get_thermo_setup () BIND(C) CALL lmp%commands_list(pair_input) END SUBROUTINE f_lammps_get_thermo_setup -FUNCTION f_lammps_get_thermo_natoms () BIND(C) +FUNCTION f_lammps_get_thermo_natoms() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_natoms + REAL(c_double) :: f_lammps_get_thermo_natoms f_lammps_get_thermo_natoms = lmp%get_thermo('atoms') END FUNCTION f_lammps_get_thermo_natoms -FUNCTION f_lammps_get_thermo_dt () BIND (C) +FUNCTION f_lammps_get_thermo_dt() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_dt + REAL(c_double) :: f_lammps_get_thermo_dt f_lammps_get_thermo_dt = lmp%get_thermo('dt') END FUNCTION f_lammps_get_thermo_dt -FUNCTION f_lammps_get_thermo_vol () BIND (C) +FUNCTION f_lammps_get_thermo_vol() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_vol + REAL(c_double) :: f_lammps_get_thermo_vol f_lammps_get_thermo_vol = lmp%get_thermo('vol') END FUNCTION f_lammps_get_thermo_vol -FUNCTION f_lammps_get_thermo_lx () BIND (C) +FUNCTION f_lammps_get_thermo_lx() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_lx + REAL(c_double) :: f_lammps_get_thermo_lx f_lammps_get_thermo_lx = lmp%get_thermo('lx') END FUNCTION f_lammps_get_thermo_lx -FUNCTION f_lammps_get_thermo_ly () BIND (C) +FUNCTION f_lammps_get_thermo_ly() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_ly + REAL(c_double) :: f_lammps_get_thermo_ly f_lammps_get_thermo_ly = lmp%get_thermo('ly') END FUNCTION f_lammps_get_thermo_ly -FUNCTION f_lammps_get_thermo_lz () BIND (C) +FUNCTION f_lammps_get_thermo_lz() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_lz + REAL(c_double) :: f_lammps_get_thermo_lz f_lammps_get_thermo_lz = lmp%get_thermo('lz') END FUNCTION f_lammps_get_thermo_lz -FUNCTION f_lammps_get_thermo_xlo () BIND (C) +FUNCTION f_lammps_get_thermo_xlo() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_xlo + REAL(c_double) :: f_lammps_get_thermo_xlo f_lammps_get_thermo_xlo = lmp%get_thermo('xlo') END FUNCTION f_lammps_get_thermo_xlo -FUNCTION f_lammps_get_thermo_xhi () BIND (C) +FUNCTION f_lammps_get_thermo_xhi() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_xhi + REAL(c_double) :: f_lammps_get_thermo_xhi f_lammps_get_thermo_xhi = lmp%get_thermo('xhi') END FUNCTION f_lammps_get_thermo_xhi -FUNCTION f_lammps_get_thermo_ylo () BIND (C) +FUNCTION f_lammps_get_thermo_ylo() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_ylo + REAL(c_double) :: f_lammps_get_thermo_ylo f_lammps_get_thermo_ylo = lmp%get_thermo('ylo') END FUNCTION f_lammps_get_thermo_ylo -FUNCTION f_lammps_get_thermo_yhi () BIND (C) +FUNCTION f_lammps_get_thermo_yhi() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_yhi + REAL(c_double) :: f_lammps_get_thermo_yhi f_lammps_get_thermo_yhi = lmp%get_thermo('yhi') END FUNCTION f_lammps_get_thermo_yhi -FUNCTION f_lammps_get_thermo_zlo () BIND (C) +FUNCTION f_lammps_get_thermo_zlo() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_zlo + REAL(c_double) :: f_lammps_get_thermo_zlo f_lammps_get_thermo_zlo = lmp%get_thermo('zlo') END FUNCTION f_lammps_get_thermo_zlo -FUNCTION f_lammps_get_thermo_zhi () BIND (C) +FUNCTION f_lammps_get_thermo_zhi() BIND(C) USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (c_double) :: f_lammps_get_thermo_zhi + REAL(c_double) :: f_lammps_get_thermo_zhi f_lammps_get_thermo_zhi = lmp%get_thermo('zhi') END FUNCTION f_lammps_get_thermo_zhi diff --git a/unittest/fortran/test_fortran_properties.f90 b/unittest/fortran/test_fortran_properties.f90 index e8ea330bd6..32f02789af 100644 --- a/unittest/fortran/test_fortran_properties.f90 +++ b/unittest/fortran/test_fortran_properties.f90 @@ -1,78 +1,78 @@ -FUNCTION f_lammps_version () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_version() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER (C_int) :: f_lammps_version + INTEGER(c_int) :: f_lammps_version f_lammps_version = lmp%version() END FUNCTION f_lammps_version -SUBROUTINE f_lammps_memory_usage (meminfo) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_double +SUBROUTINE f_lammps_memory_usage(meminfo) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_double USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - REAL (C_double), DIMENSION(3), INTENT(OUT) :: meminfo + REAL(c_double), DIMENSION(3), INTENT(OUT) :: meminfo CALL lmp%memory_usage(meminfo) END SUBROUTINE f_lammps_memory_usage -FUNCTION f_lammps_get_mpi_comm () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_get_mpi_comm() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE liblammps USE keepstuff, ONLY : lmp IMPLICIT NONE - INTEGER (C_int) :: f_lammps_get_mpi_comm + INTEGER(c_int) :: f_lammps_get_mpi_comm f_lammps_get_mpi_comm = lmp%get_mpi_comm() END FUNCTION f_lammps_get_mpi_comm -FUNCTION f_lammps_extract_setting (Cstr) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int, C_char +FUNCTION f_lammps_extract_setting(Cstr) BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int, c_char USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER (C_int) :: f_lammps_extract_setting - CHARACTER (KIND=C_char, LEN=1), DIMENSION(*), INTENT(IN) :: Cstr + INTEGER(c_int) :: f_lammps_extract_setting + CHARACTER(KIND=c_char, LEN=1), DIMENSION(*), INTENT(IN) :: Cstr INTEGER :: strlen, i - CHARACTER (LEN=:), ALLOCATABLE :: Fstr + CHARACTER(LEN=:), ALLOCATABLE :: Fstr i = 1 DO WHILE (Cstr(i) /= ACHAR(0)) i = i + 1 END DO strlen = i - allocate ( CHARACTER(LEN=strlen) :: Fstr) + allocate (CHARACTER(LEN=strlen) :: Fstr) FORALL (i=1:strlen) Fstr(i:i) = Cstr(i) END FORALL f_lammps_extract_setting = lmp%extract_setting(Fstr) - deallocate (Fstr) + DEALLOCATE(Fstr) END FUNCTION f_lammps_extract_setting -FUNCTION f_lammps_has_error () BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int +FUNCTION f_lammps_has_error() BIND(C) + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER(C_int) :: f_lammps_has_error + INTEGER(c_int) :: f_lammps_has_error - IF ( lmp%has_error() ) THEN - f_lammps_has_error = 1_C_int + IF (lmp%has_error()) THEN + f_lammps_has_error = 1_c_int ELSE - f_lammps_has_error = 0_C_int + f_lammps_has_error = 0_c_int END IF END FUNCTION f_lammps_has_error FUNCTION f_lammps_get_last_error_message(errmesg, errlen) BIND(C) - USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_int, C_char, C_ptr, C_F_POINTER + USE, INTRINSIC :: ISO_C_BINDING, ONLY : c_int, c_char, c_ptr, C_F_POINTER USE keepstuff, ONLY : lmp USE LIBLAMMPS IMPLICIT NONE - INTEGER(C_int) :: f_lammps_get_last_error_message + INTEGER(c_int) :: f_lammps_get_last_error_message CHARACTER(KIND=c_char), DIMENSION(*) :: errmesg - INTEGER(C_int), VALUE, INTENT(IN) :: errlen + INTEGER(c_int), VALUE, INTENT(IN) :: errlen CHARACTER(LEN=:), ALLOCATABLE :: buffer INTEGER :: status, i From d7d2802061d47d77fb1af976c8337fc67d76a2f5 Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Mon, 3 Oct 2022 23:51:21 -0400 Subject: [PATCH 5/9] remove intentional false positive --- unittest/fortran/wrap_properties.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/unittest/fortran/wrap_properties.cpp b/unittest/fortran/wrap_properties.cpp index d2daa22cf4..59e98891c3 100644 --- a/unittest/fortran/wrap_properties.cpp +++ b/unittest/fortran/wrap_properties.cpp @@ -133,6 +133,6 @@ TEST_F(LAMMPS_properties, has_error) char errmsg[1024]; int err = f_lammps_get_last_error_message(errmsg, 1023); EXPECT_EQ(err, 1); - EXPECT_THAT(errmsg, ContainsRegex(".*ERRORx: Unknown command: this_is_not_a_known_command.*")); + EXPECT_THAT(errmsg, ContainsRegex(".*ERROR: Unknown command: this_is_not_a_known_command.*")); }; } // namespace LAMMPS_NS From bc6e42a6104999f5d35ca9a9997a275e7ca9854d Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Tue, 4 Oct 2022 04:11:39 -0400 Subject: [PATCH 6/9] add more extensive whitespace checking for fortran and unittests --- python/examples/mc.py | 4 +- python/examples/pizza/gl.py | 144 +++++++++--------- python/examples/pizza/vizinfo.py | 28 ++-- python/examples/pizza/vmd.py | 40 ++--- python/examples/pylammps/elastic/README | 2 +- python/examples/split.py | 6 +- python/examples/viz_gl.py | 2 +- python/examples/viz_pymol.py | 4 +- tools/coding_standard/whitespace.py | 4 +- .../fortran/test_fortran_extract_variable.f90 | 4 +- unittest/tools/test_lammps_shell.py | 2 +- unittest/utils/testshared.c | 4 +- 12 files changed, 123 insertions(+), 121 deletions(-) diff --git a/python/examples/mc.py b/python/examples/mc.py index fe7f6838c8..c12b4bd6bc 100755 --- a/python/examples/mc.py +++ b/python/examples/mc.py @@ -60,7 +60,7 @@ lmp.command("thermo_style custom step v_emin v_elast pe") lmp.command("run 0") x = lmp.extract_atom("x") lmp.command("variable elast equal $e") - + estart = lmp.extract_compute("thermo_pe", LMP_STYLE_GLOBAL, LAMMPS_INT) / natoms # loop over Monte Carlo moves @@ -92,7 +92,7 @@ for i in range(nloop): else: x[iatom][0] = x0 x[iatom][1] = y0 - + # final energy and stats lmp.command("variable nbuild equal nbuild") diff --git a/python/examples/pizza/gl.py b/python/examples/pizza/gl.py index 7c5633ac55..c567c0805f 100644 --- a/python/examples/pizza/gl.py +++ b/python/examples/pizza/gl.py @@ -3,7 +3,7 @@ # # Copyright (2005) 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 +# certain rights in this software. This software is distributed under # the GNU General Public License. # for python3 compatibility @@ -19,8 +19,8 @@ g = gl(d) create OpenGL display for data in d d = atom snapshot object (dump, data) g.bg("black") set background color (def = "black") -g.size(N) set image size to NxN -g.size(N,M) set image size to NxM +g.size(N) set image size to NxN +g.size(N,M) set image size to NxM g.rotate(60,135) view from z theta and azimuthal phi (def = 60,30) g.shift(x,y) translate by x,y pixels in view window (def = 0,0) g.zoom(0.5) scale image by factor (def = 1) @@ -30,7 +30,7 @@ g.box(0/1/2,"red",4) set box edge thickness g.file = "image" file prefix for created images (def = "image") g.show(N) show image of snapshot at timestep N - + g.all() make images of all selected snapshots g.all(P) images of all, start file label at P g.all(N,M,P) make M images of snapshot N, start label at P @@ -43,12 +43,12 @@ g.pan() no pan during all() (default) g.select = "$x > %g*3.0" string to pass to d.aselect.test() during all() g.select = "" no extra aselect (default) - + %g varies from 0.0 to 1.0 from beginning to end of all() - -g.acol(2,"green") set atom colors by atom type (1-N) -g.acol([2,4],["red","blue"]) 1st arg = one type or list of types -g.acol(0,"blue") 2nd arg = one color or list of colors + +g.acol(2,"green") set atom colors by atom type (1-N) +g.acol([2,4],["red","blue"]) 1st arg = one type or list of types +g.acol(0,"blue") 2nd arg = one color or list of colors g.acol(range(20),["red","blue"]) if list lengths unequal, interpolate g.acol(range(10),"loop") assign colors in loop, randomly ordered @@ -58,23 +58,23 @@ g.acol(range(10),"loop") assign colors in loop, randomly ordered g.arad([1,2],[0.5,0.3]) set atom radii, same rules as acol() -g.bcol() set bond color, same args as acol() -g.brad() set bond thickness, same args as arad() +g.bcol() set bond color, same args as acol() +g.brad() set bond thickness, same args as arad() -g.tcol() set triangle color, same args as acol() -g.tfill() set triangle fill, 0 fill, 1 line, 2 both +g.tcol() set triangle color, same args as acol() +g.tfill() set triangle fill, 0 fill, 1 line, 2 both g.lcol() set line color, same args as acol() g.lrad() set line thickness, same args as arad() g.adef() set atom/bond/tri/line properties to default -g.bdef() default = "loop" for colors, 0.45 for radii -g.tdef() default = 0.25 for bond/line thickness -g.ldef() default = 0 fill +g.bdef() default = "loop" for colors, 0.45 for radii +g.tdef() default = 0.25 for bond/line thickness +g.ldef() default = 0 fill by default 100 types are assigned if atom/bond/tri/line has type > # defined properties, is an error - + from vizinfo import colors access color list print(colors) list defined color names and RGB values colors["nickname"] = [R,G,B] set new RGB values from 0 to 255 @@ -148,7 +148,7 @@ class gl: self.azphi = 30 self.scale = 1.0 self.xshift = self.yshift = 0 - + self.file = "image" self.boxflag = 0 self.bxcol = [1,1,0] @@ -165,7 +165,7 @@ class gl: self.nsides = 10 self.theta_amplify = 2 self.shiny = 2 - + self.clipflag = 0 self.clipxlo = self.clipylo = self.clipzlo = 0.0 self.clipxhi = self.clipyhi = self.clipzhi = 1.0 @@ -189,7 +189,7 @@ class gl: self.bdef() self.tdef() self.ldef() - + self.center = 3*[0] self.view = 3*[0] self.up = 3*[0] @@ -211,7 +211,7 @@ class gl: if not ynew: self.ypixels = self.xpixels else: self.ypixels = ynew self.create_window() - + # -------------------------------------------------------------------- def axis(self,value): @@ -223,7 +223,7 @@ class gl: def create_window(self): if self.root: self.root.destroy() - + from __main__ import tkroot self.root = Toplevel(tkroot) self.root.title('Pizza.py gl tool') @@ -232,7 +232,7 @@ class gl: double=1,depth=1) self.w.pack(expand=YES) # self.w.pack(expand=YES,fill=BOTH) - + glViewport(0,0,self.xpixels,self.ypixels) glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); @@ -247,7 +247,7 @@ class gl: self.w.parent = self self.w.tkRedraw() tkroot.update_idletasks() # force window to appear - + # -------------------------------------------------------------------- def clip(self,which,value): @@ -314,7 +314,7 @@ class gl: self.up[1] = sin(pi*self.azphi/180) self.up[2] = 0.0 else: - dot = self.view[2] # dot = (0,0,1) . view + dot = self.view[2] # dot = (0,0,1) . view self.up[0] = -dot*self.view[0] # up projected onto v = dot * v self.up[1] = -dot*self.view[1] # up perp to v = up - dot * v self.up[2] = 1.0 - dot*self.view[2] @@ -325,7 +325,7 @@ class gl: # -------------------------------------------------------------------- # reset ztheta,azphi and thus view,up.right # called as function from Pizza.py - + def rotate(self,ztheta,azphi): self.ztheta = ztheta self.azphi = azphi @@ -366,11 +366,11 @@ class gl: # rotate view,up around axis of rotation = old x new # right = up x view # reset ztheta,azphi from view - + def mouse_rotate(self,xnew,ynew,xold,yold): # change y pixels to measure from bottom of window instead of top - + yold = self.ypixels - yold ynew = self.ypixels - ynew @@ -407,7 +407,7 @@ class gl: axis[1] = rot[0]*self.right[1] + rot[1]*self.up[1] + rot[2]*self.view[1] axis[2] = rot[0]*self.right[2] + rot[1]*self.up[2] + rot[2]*self.view[2] axis = vecnorm(axis) - + # view is changed by (axis x view) scaled by theta # up is changed by (axis x up) scaled by theta # force up to be perp to view via up_perp = up - (up . view) view @@ -468,14 +468,14 @@ class gl: # output: eye = distance to view scene from # xto,yto,zto = point to look to # xfrom,yfrom,zfrom = point to look from - + def setview(self): if not self.ready: return # no distance since no scene yet - + self.eye = 3 * self.distance / self.scale xfactor = 0.5*self.eye*self.xshift/self.xpixels yfactor = 0.5*self.eye*self.yshift/self.ypixels - + self.xto = self.center[0] - xfactor*self.right[0] - yfactor*self.up[0] self.yto = self.center[1] - xfactor*self.right[1] - yfactor*self.up[1] self.zto = self.center[2] - xfactor*self.right[2] - yfactor*self.up[2] @@ -486,7 +486,7 @@ class gl: # -------------------------------------------------------------------- # box attributes, also used for triangle lines - + def box(self,*args): self.boxflag = args[0] if len(args) > 1: @@ -500,7 +500,7 @@ class gl: # -------------------------------------------------------------------- # grab all selected snapshots from data object # add GL-specific info to each bond - + def reload(self): print("Loading data into gl tool ...") data = self.data @@ -529,7 +529,7 @@ class gl: self.bondframes.append(bonds) self.triframes.append(tris) self.lineframes.append(lines) - + print(time,end='') sys.stdout.flush() print() @@ -545,11 +545,11 @@ class gl: def nolabel(self): self.cachelist = -self.cachelist self.labels = [] - + # -------------------------------------------------------------------- # show a single snapshot # distance from snapshot box or max box for all selected steps - + def show(self,ntime): data = self.data which = data.findtime(ntime) @@ -571,7 +571,7 @@ class gl: self.cachelist = -self.cachelist self.w.tkRedraw() self.save() - + # -------------------------------------------------------------------- def pan(self,*list): @@ -584,7 +584,7 @@ class gl: self.ztheta_stop = list[3] self.azphi_stop = list[4] self.scale_stop = list[5] - + # -------------------------------------------------------------------- def all(self,*list): @@ -615,7 +615,7 @@ class gl: if flag == -1: break fraction = float(i) / (ncount-1) - + if self.select != "": newstr = self.select % fraction data.aselect.test(newstr,time) @@ -653,7 +653,7 @@ class gl: self.cachelist = -self.cachelist self.w.tkRedraw() self.save(file) - + print(time,end='') sys.stdout.flush() i += 1 @@ -731,19 +731,19 @@ class gl: # -------------------------------------------------------------------- # draw the GL scene - + def redraw(self,o): # clear window to background color - + glClearColor(self.bgcol[0],self.bgcol[1],self.bgcol[2],0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # not ready if no scene yet - + if not self.ready: return # set view from eye, distance, 3 lookat vectors (from,to,up) - + glMatrixMode(GL_PROJECTION) glLoadIdentity() if self.orthoflag: @@ -759,14 +759,14 @@ class gl: # draw scene from display list if caching allowed and list hasn't changed # else redraw and store as new display list if caching allowed - + if self.cache and self.cachelist > 0: glCallList(self.cachelist); else: if self.cache: if self.cachelist < 0: glDeleteLists(-self.cachelist,1) self.cachelist = glGenLists(1) glNewList(self.cachelist,GL_COMPILE_AND_EXECUTE) - + # draw box, clip-box, xyz axes, lines glDisable(GL_LIGHTING) @@ -842,7 +842,7 @@ class gl: if self.tridraw: fillflag = self.vizinfo.tfill[int(self.tridraw[0][1])] - + if fillflag != 1: if fillflag: glEnable(GL_POLYGON_OFFSET_FILL) @@ -921,7 +921,7 @@ class gl: gluCylinder(obj,rad,rad,bond[10],self.nsides,self.nsides) glPopMatrix() - if self.tridraw: + if self.tridraw: fillflag = self.vizinfo.tfill[int(self.tridraw[0][1])] if fillflag != 1: @@ -975,7 +975,7 @@ class gl: glEnd() glEnable(GL_LIGHTING) glPolygonMode(GL_FRONT_AND_BACK,GL_FILL) - + if self.cache: glEndList() glFlush() @@ -983,16 +983,16 @@ class gl: # -------------------------------------------------------------------- # make new call list for each atom type # called when atom color/rad/quality is changed - + def make_atom_calllist(self): # extend calllist array if necessary - + if self.vizinfo.nacolor > self.nclist: for i in range(self.vizinfo.nacolor-self.nclist): self.calllist.append(0) self.nclist = self.vizinfo.nacolor # create new calllist for each atom type - + for itype in xrange(1,self.vizinfo.nacolor+1): if self.calllist[itype]: glDeleteLists(self.calllist[itype],1) ilist = glGenLists(1) @@ -1001,12 +1001,12 @@ class gl: red,green,blue = self.vizinfo.acolor[itype] rad = self.vizinfo.arad[itype] glColor3f(red,green,blue); - + # glPointSize(10.0*rad) # glBegin(GL_POINTS) # glVertex3f(0.0,0.0,0.0) # glEnd() - + glMaterialfv(GL_FRONT,GL_EMISSION,[red,green,blue,1.0]); glMaterialf(GL_FRONT,GL_SHININESS,self.shiny); glutSolidSphere(rad,self.nslices,self.nstacks) @@ -1015,7 +1015,7 @@ class gl: # -------------------------------------------------------------------- # augment bond info returned by viz() with info needed for GL draw # info = length, theta, -dy, dx for bond orientation - + def bonds_augment(self,bonds): for bond in bonds: dx = bond[5] - bond[2] @@ -1046,7 +1046,7 @@ class gl: glLineWidth(self.bxthick) glColor3f(self.bxcol[0],self.bxcol[1],self.bxcol[2]) - + glBegin(GL_LINE_LOOP) glVertex3f(xlo,ylo,zlo) glVertex3f(xhi,ylo,zlo) @@ -1081,7 +1081,7 @@ class gl: if yhi-ylo > delta: delta = yhi-ylo if zhi-zlo > delta: delta = zhi-zlo delta *= 0.1 - + glLineWidth(self.bxthick) glBegin(GL_LINES) @@ -1100,7 +1100,7 @@ class gl: def save(self,file=None): self.w.update() # force image on screen to be current before saving it - + pstring = glReadPixels(0,0,self.xpixels,self.ypixels, GL_RGBA,GL_UNSIGNED_BYTE) snapshot = Image.fromstring("RGBA",(self.xpixels,self.ypixels),pstring) @@ -1110,14 +1110,14 @@ class gl: snapshot.save(file + ".png") # -------------------------------------------------------------------- - + def adef(self): self.vizinfo.setcolors("atom",range(100),"loop") self.vizinfo.setradii("atom",range(100),0.45) self.make_atom_calllist() self.cachelist = -self.cachelist self.w.tkRedraw() - + # -------------------------------------------------------------------- def bdef(self): @@ -1130,14 +1130,14 @@ class gl: def tdef(self): self.vizinfo.setcolors("tri",range(100),"loop") - self.vizinfo.setfills("tri",range(100),0) + self.vizinfo.setfills("tri",range(100),0) self.cachelist = -self.cachelist self.w.tkRedraw() # -------------------------------------------------------------------- def ldef(self): - self.vizinfo.setcolors("line",range(100),"loop") + self.vizinfo.setcolors("line",range(100),"loop") self.vizinfo.setradii("line",range(100),0.25) self.cachelist = -self.cachelist self.w.tkRedraw() @@ -1149,29 +1149,29 @@ class gl: self.make_atom_calllist() self.cachelist = -self.cachelist self.w.tkRedraw() - + # -------------------------------------------------------------------- def arad(self,atypes,radii): - self.vizinfo.setradii("atom",atypes,radii) + self.vizinfo.setradii("atom",atypes,radii) self.make_atom_calllist() self.cachelist = -self.cachelist self.w.tkRedraw() - + # -------------------------------------------------------------------- def bcol(self,btypes,colors): self.vizinfo.setcolors("bond",btypes,colors) self.cachelist = -self.cachelist self.w.tkRedraw() - + # -------------------------------------------------------------------- def brad(self,btypes,radii): self.vizinfo.setradii("bond",btypes,radii) self.cachelist = -self.cachelist self.w.tkRedraw() - + # -------------------------------------------------------------------- def tcol(self,ttypes,colors): @@ -1210,10 +1210,10 @@ class MyOpengl(Opengl): args = (self,master,cnf) Opengl.__init__(*args,**kw) Opengl.autospin_allowed = 0 - + # redraw Opengl scene # call parent redraw() method - + def tkRedraw(self,*dummy): if not self.initialised: return self.tk.call(self._w,'makecurrent') @@ -1222,7 +1222,7 @@ class MyOpengl(Opengl): # left button translate # access parent xshift/yshift and call parent trans() method - + def tkTranslate(self,event): dx = event.x - self.xmouse dy = event.y - self.ymouse @@ -1242,7 +1242,7 @@ class MyOpengl(Opengl): # right button zoom # access parent scale and call parent zoom() method - + def tkScale(self,event): scale = 1 - 0.01 * (event.y - self.ymouse) if scale < 0.001: scale = 0.001 diff --git a/python/examples/pizza/vizinfo.py b/python/examples/pizza/vizinfo.py index a150a9c84f..e3a05d71ce 100644 --- a/python/examples/pizza/vizinfo.py +++ b/python/examples/pizza/vizinfo.py @@ -3,7 +3,7 @@ # # Copyright (2005) 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 +# certain rights in this software. This software is distributed under # the GNU General Public License. # vizinfo class, not a top-level Pizza.py tool @@ -25,7 +25,7 @@ import types class vizinfo: """ Information holder for Pizza.py visualization tools - + acolor,bcolor,tcolor,lcolor = RGB values for each atom/bond/tri/line type arad = radius of each atom type brad,lrad = thickness of each bond/line type @@ -41,7 +41,7 @@ class vizinfo: setfill() = set triangle fill factor extend() = grow an array """ - + # -------------------------------------------------------------------- def __init__(self): @@ -57,15 +57,15 @@ class vizinfo: self.nbcolor = self.nbrad = 0 self.ntcolor = self.ntfill = 0 self.nlcolor = self.nlrad = 0 - + # -------------------------------------------------------------------- # set color RGB for which = atoms, bonds, triangles - + def setcolors(self,which,ids,rgbs): # convert args into lists if single values # if arg = 0, convert to full-range list - + if type(ids) is types.IntType and ids == 0: if which == "atom": ids = range(self.nacolor) if which == "bond": ids = range(self.nbcolor) @@ -101,11 +101,11 @@ class vizinfo: if max(ids) > self.nlcolor: self.nlcolor = self.extend(self.lcolor,max(ids)) self.nlcolor = self.extend(self.lrad,max(ids)) - + # set color for each type # if list lengths match, set directly, else interpolate # convert final color from 0-255 to 0.0-1.0 - + ntypes = len(ids) nrgbs = len(rgbs) @@ -135,7 +135,7 @@ class vizinfo: if which == "bond": self.bcolor[id] = color if which == "tri": self.tcolor[id] = color if which == "line": self.lcolor[id] = color - + # -------------------------------------------------------------------- # set radii for which = atoms, bonds, lines @@ -143,7 +143,7 @@ class vizinfo: # convert args into lists if single values # if arg = 0, convert to full-range list - + if type(ids) is types.IntType and ids == 0: if which == "atom": ids = range(self.narad) if which == "bond": ids = range(self.nbrad) @@ -199,16 +199,16 @@ class vizinfo: if which == "atom": self.arad[id] = rad if which == "bond": self.brad[id] = rad if which == "line": self.lrad[id] = rad - + # -------------------------------------------------------------------- # set triangle fill style # 0 = fill only, 1 = line only, 2 = fill and line - + def setfills(self,which,ids,fills): # convert args into lists if single values # if arg = 0, convert to full-range list - + if type(ids) is types.IntType and ids == 0: ids = range(self.ntfill) if type(ids) is not types.ListType and type(ids) is not types.TupleType: @@ -237,7 +237,7 @@ class vizinfo: for i in range(len(ids)): self.tfill[ids[i]] = int(fills[i]) else: for id in ids: self.tfill[id] = int(fills[0]) - + # -------------------------------------------------------------------- def extend(self,array,n): diff --git a/python/examples/pizza/vmd.py b/python/examples/pizza/vmd.py index 00b8615092..5c8461f6ca 100644 --- a/python/examples/pizza/vmd.py +++ b/python/examples/pizza/vmd.py @@ -3,7 +3,7 @@ # # Copyright (2005) 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 +# certain rights in this software. This software is distributed under # the GNU General Public License. # for python3 compatibility @@ -20,24 +20,24 @@ from __future__ import print_function oneline = "Control VMD from python" docstr = """ -v = vmd() start up VMD -v.stop() shut down VMD instance -v.clear() delete all visualizations +v = vmd() start up VMD +v.stop() shut down VMD instance +v.clear() delete all visualizations -v.rep(style) set default representation style. One of - (Lines|VDW|Licorice|DynamicBonds|Points|CPK) -v.new(file[,type]) load new file (default file type 'lammpstrj') +v.rep(style) set default representation style. One of + (Lines|VDW|Licorice|DynamicBonds|Points|CPK) +v.new(file[,type]) load new file (default file type 'lammpstrj') v.data(file[,atomstyle]) load new data file (default atom style 'full') -v.replace(file[,type]) replace current frames with new file -v.append(file[,type]) append file to current frame(s) +v.replace(file[,type]) replace current frames with new file +v.append(file[,type]) append file to current frame(s) v.set(snap,x,y,z,(True|False)) set coordinates from a pizza.py snapshot to new or current frame -v.frame(frame) set current frame -v.flush() flush pending input to VMD and update GUI -v.read(file) read Tcl script file (e.g. saved state) - -v.enter() enter interactive shell -v.debug([True|False]) display generated VMD script commands? +v.frame(frame) set current frame +v.flush() flush pending input to VMD and update GUI +v.read(file) read Tcl script file (e.g. saved state) + +v.enter() enter interactive shell +v.debug([True|False]) display generated VMD script commands? """ # History @@ -71,7 +71,7 @@ except ImportError: # Class definition class vmd: - + # -------------------------------------------------------------------- def __init__(self): @@ -103,7 +103,7 @@ class vmd: # open pipe to vmd and wait until we have a prompt self.VMD = pexpect.spawn(self.vmdexe) self.VMD.expect('vmd >') - + # -------------------------------------------------------------------- # post command to vmd and wait until the prompt returns. def __call__(self,command): @@ -113,7 +113,7 @@ class vmd: if self.debugme: print("call+result:"+self.VMD.before) return - + # -------------------------------------------------------------------- # exit VMD def stop(self): @@ -198,7 +198,7 @@ class vmd: self.__call__('mol addfile ' + filename + ' mol $tmol type ' + filetype + ' waitfor all') self.__call__('foreach mol [molinfo list] { molinfo $mol set {center_matrix rotate_matrix scale_matrix global_matrix} $viewpoints($mol)}') self.flush() - + # -------------------------------------------------------------------- # replace all frames of a molecule with those from a given file def update(self,filename,filetype='lammpstrj'): @@ -209,7 +209,7 @@ class vmd: self.__call__('mol addfile ' + filename + ' mol $tmol type ' + filetype + ' waitfor all') self.__call__('foreach mol [molinfo list] {molinfo $mol set {center_matrix rotate_matrix scale_matrix global_matrix} $viewpoints($mol)}') self.flush() - + # -------------------------------------------------------------------- # add or overwrite coordinates with coordinates in a snapshot def set(self,snap,x,y,z,append=True): diff --git a/python/examples/pylammps/elastic/README b/python/examples/pylammps/elastic/README index 8d1712cd10..40ba34fa62 100644 --- a/python/examples/pylammps/elastic/README +++ b/python/examples/pylammps/elastic/README @@ -1,4 +1,4 @@ conversion of lammps scripts to python code using PyLammps interface -Example for elastic.py +Example for elastic.py python elastic.py Au.data EAM_Dynamo_Ackland_1987_Au__MO_754413982908_000 Au diff --git a/python/examples/split.py b/python/examples/split.py index bd2896c004..2e63d57621 100755 --- a/python/examples/split.py +++ b/python/examples/split.py @@ -32,7 +32,7 @@ nprocs = comm.Get_size() if me < nprocs // 2: color = 0 else: color = 1 - + split = comm.Split(color,key=0) if color == 0: @@ -69,12 +69,12 @@ else: # could run a 2nd calculation on second partition # with different LAMMPS instance or another code # in this case, just sleep on second partition - + import time time.sleep(2) print("Calculation on partition 1 complete") # shutdown mpi4py - + comm.Barrier() MPI.Finalize() diff --git a/python/examples/viz_gl.py b/python/examples/viz_gl.py index 6266682b9c..ab527e0329 100755 --- a/python/examples/viz_gl.py +++ b/python/examples/viz_gl.py @@ -50,7 +50,7 @@ ntimestep = 0 if me == 0: tkroot = None - try: + try: import Tkinter except: import tkinter as Tkinter diff --git a/python/examples/viz_pymol.py b/python/examples/viz_pymol.py index b5061d4c20..1b139dc37e 100755 --- a/python/examples/viz_pymol.py +++ b/python/examples/viz_pymol.py @@ -63,7 +63,7 @@ if me == 0: p.single(ntimestep) pm.load("tmp.pdb") pm.show("spheres","tmp") - + # run nfreq steps at a time w/out pre/post, read dump snapshot, display it while ntimestep < nsteps: @@ -75,7 +75,7 @@ while ntimestep < nsteps: p.single(ntimestep) pm.load("tmp.pdb") pm.forward() - + lmp.command("run 0 pre no post yes") # uncomment if running in parallel via mpi4py diff --git a/tools/coding_standard/whitespace.py b/tools/coding_standard/whitespace.py index be53f60380..1c980717d6 100644 --- a/tools/coding_standard/whitespace.py +++ b/tools/coding_standard/whitespace.py @@ -24,11 +24,13 @@ include: - cmake/** - doc - doc/src/** - - python + - fortran/** + - python/** - src/** - lib/** - tools/coding_standard - tools/python + - unittest/** exclude: - lib/colvars/Install.py - lib/gpu/geryon/file_to_cstr.sh diff --git a/unittest/fortran/test_fortran_extract_variable.f90 b/unittest/fortran/test_fortran_extract_variable.f90 index 34ccb766de..ded3743409 100644 --- a/unittest/fortran/test_fortran_extract_variable.f90 +++ b/unittest/fortran/test_fortran_extract_variable.f90 @@ -100,7 +100,7 @@ FUNCTION f_lammps_with_C_args(argc, argv) BIND(C) TYPE(c_ptr), INTENT(IN), VALUE :: str INTEGER(c_size_t) :: c_strlen END FUNCTION c_strlen - END INTERFACE + END INTERFACE CALL C_F_POINTER(argv, Fargv, [argc]) DO i = 1, argc @@ -111,7 +111,7 @@ FUNCTION f_lammps_with_C_args(argc, argv) BIND(C) args(i)(j:j) = Cstr(j) END FORALL END DO - + lmp = lammps(args) f_lammps_with_C_args = lmp%handle END FUNCTION f_lammps_with_C_args diff --git a/unittest/tools/test_lammps_shell.py b/unittest/tools/test_lammps_shell.py index 15cb259f84..2a55be0a4e 100644 --- a/unittest/tools/test_lammps_shell.py +++ b/unittest/tools/test_lammps_shell.py @@ -138,7 +138,7 @@ class LammpsShell(unittest.TestCase): for line in lines: if line.startswith('LAMMPS Shell>'): break idx += 1 - + self.assertEqual(lines[idx+4],"dimension 2") self.assertEqual(lines[idx+6],"units real") self.assertEqual(lines[idx+8],"dimension 2") diff --git a/unittest/utils/testshared.c b/unittest/utils/testshared.c index 869be91c2a..12922dea91 100644 --- a/unittest/utils/testshared.c +++ b/unittest/utils/testshared.c @@ -16,5 +16,5 @@ double some_double_function(double arg1, int arg2) return sum; } - - + + From 90e820e8ec5b3bad110f4356c8c123e4874611a7 Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Tue, 4 Oct 2022 08:55:53 -0400 Subject: [PATCH 7/9] format mpirun/mpiexec consistently --- doc/src/Fortran.rst | 12 ++++++------ doc/src/Run_basics.rst | 9 +++++---- doc/src/Run_options.rst | 20 ++++++++++---------- doc/src/Speed_gpu.rst | 13 +++++++------ doc/src/Speed_kokkos.rst | 17 +++++++++-------- doc/src/Speed_omp.rst | 8 ++++---- 6 files changed, 41 insertions(+), 38 deletions(-) diff --git a/doc/src/Fortran.rst b/doc/src/Fortran.rst index e7b44c4686..28254e056c 100644 --- a/doc/src/Fortran.rst +++ b/doc/src/Fortran.rst @@ -29,12 +29,12 @@ or dynamic library `. If the LAMMPS library itself has been compiled with MPI support, the resulting executable will still be able to run LAMMPS in parallel with -``mpiexec`` or equivalent. Please also note that the order of the source -files matters: the ``lammps.f90`` file needs to be compiled first, since -it provides the ``LIBLAMMPS`` module that is imported by the Fortran -code that uses the interface. A working example can be found together -with equivalent examples in C and C++ in the ``examples/COUPLE/simple`` -folder of the LAMMPS distribution. +``mpirun``, ``mpiexec`` or equivalent. Please also note that the order +of the source files matters: the ``lammps.f90`` file needs to be +compiled first, since it provides the ``LIBLAMMPS`` module that is +imported by the Fortran code that uses the interface. A working example +can be found together with equivalent examples in C and C++ in the +``examples/COUPLE/simple`` folder of the LAMMPS distribution. .. versionadded:: 9Oct2020 diff --git a/doc/src/Run_basics.rst b/doc/src/Run_basics.rst index 5f1211d093..d2810f5986 100644 --- a/doc/src/Run_basics.rst +++ b/doc/src/Run_basics.rst @@ -30,12 +30,13 @@ executable itself can be placed elsewhere. .. note:: - The redirection operator "<" will not always work when running - in parallel with mpirun or mpiexec; for those systems the -in form is required. + The redirection operator "<" will not always work when running in + parallel with ``mpirun`` or ``mpiexec``; for those systems the -in + form is required. As LAMMPS runs it prints info to the screen and a logfile named -*log.lammps*\ . More info about output is given on the -:doc:`screen and logfile output ` page. +*log.lammps*\ . More info about output is given on the :doc:`screen and +logfile output ` page. If LAMMPS encounters errors in the input script or while running a simulation it will print an ERROR message and stop or a WARNING diff --git a/doc/src/Run_options.rst b/doc/src/Run_options.rst index f3c7973197..f7bb652ea9 100644 --- a/doc/src/Run_options.rst +++ b/doc/src/Run_options.rst @@ -93,13 +93,13 @@ switch is not set (the default), LAMMPS will operate as if the KOKKOS package were not installed; i.e. you can run standard LAMMPS or with the GPU or OPENMP packages, for testing or benchmarking purposes. -Additional optional keyword/value pairs can be specified which -determine how Kokkos will use the underlying hardware on your -platform. These settings apply to each MPI task you launch via the -"mpirun" or "mpiexec" command. You may choose to run one or more MPI -tasks per physical node. Note that if you are running on a desktop -machine, you typically have one physical node. On a cluster or -supercomputer there may be dozens or 1000s of physical nodes. +Additional optional keyword/value pairs can be specified which determine +how Kokkos will use the underlying hardware on your platform. These +settings apply to each MPI task you launch via the ``mpirun`` or +``mpiexec`` command. You may choose to run one or more MPI tasks per +physical node. Note that if you are running on a desktop machine, you +typically have one physical node. On a cluster or supercomputer there +may be dozens or 1000s of physical nodes. Either the full word or an abbreviation can be used for the keywords. Note that the keywords do not use a leading minus sign. I.e. the @@ -148,9 +148,9 @@ one of these 4 environment variables MV2_COMM_WORLD_LOCAL_RANK (Mvapich) OMPI_COMM_WORLD_LOCAL_RANK (OpenMPI) -which are initialized by the "srun", "mpirun" or "mpiexec" commands. -The environment variable setting for each MPI rank is used to assign a -unique GPU ID to the MPI task. +which are initialized by the ``srun``, ``mpirun``, or ``mpiexec`` +commands. The environment variable setting for each MPI rank is used to +assign a unique GPU ID to the MPI task. .. parsed-literal:: diff --git a/doc/src/Speed_gpu.rst b/doc/src/Speed_gpu.rst index 883bc9c7e3..e95787ebee 100644 --- a/doc/src/Speed_gpu.rst +++ b/doc/src/Speed_gpu.rst @@ -76,10 +76,11 @@ instructions. **Run with the GPU package from the command line:** -The mpirun or mpiexec command sets the total number of MPI tasks used -by LAMMPS (one or multiple per compute node) and the number of MPI -tasks used per node. E.g. the mpirun command in MPICH does this via -its -np and -ppn switches. Ditto for OpenMPI via -np and -npernode. +The ``mpirun`` or ``mpiexec`` command sets the total number of MPI tasks +used by LAMMPS (one or multiple per compute node) and the number of MPI +tasks used per node. E.g. the ``mpirun`` command in MPICH does this via +its ``-np`` and ``-ppn`` switches. Ditto for OpenMPI via ``-np`` and +``-npernode``. When using the GPU package, you cannot assign more than one GPU to a single MPI task. However multiple MPI tasks can share the same GPU, @@ -129,8 +130,8 @@ GPU package pair styles. **Or run with the GPU package by editing an input script:** -The discussion above for the mpirun/mpiexec command, MPI tasks/node, -and use of multiple MPI tasks/GPU is the same. +The discussion above for the ``mpirun`` or ``mpiexec`` command, MPI +tasks/node, and use of multiple MPI tasks/GPU is the same. Use the :doc:`suffix gpu ` command, or you can explicitly add an "gpu" suffix to individual styles in your input script, e.g. diff --git a/doc/src/Speed_kokkos.rst b/doc/src/Speed_kokkos.rst index 8b9b2e99af..73345b7e88 100644 --- a/doc/src/Speed_kokkos.rst +++ b/doc/src/Speed_kokkos.rst @@ -72,12 +72,12 @@ See the :ref:`Build extras ` page for instructions. Running LAMMPS with the KOKKOS package """""""""""""""""""""""""""""""""""""" -All Kokkos operations occur within the context of an individual MPI -task running on a single node of the machine. The total number of MPI -tasks used by LAMMPS (one or multiple per compute node) is set in the -usual manner via the mpirun or mpiexec commands, and is independent of -Kokkos. E.g. the mpirun command in OpenMPI does this via its -np and --npernode switches. Ditto for MPICH via -np and -ppn. +All Kokkos operations occur within the context of an individual MPI task +running on a single node of the machine. The total number of MPI tasks +used by LAMMPS (one or multiple per compute node) is set in the usual +manner via the ``mpirun`` or ``mpiexec`` commands, and is independent of +Kokkos. E.g. the mpirun command in OpenMPI does this via its ``-np`` and +``-npernode`` switches. Ditto for MPICH via ``-np`` and ``-ppn``. Running on a multi-core CPU ^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -168,7 +168,7 @@ for your MPI installation), binding can be forced with these flags: .. parsed-literal:: - OpenMPI 1.8: mpirun -np 2 --bind-to socket --map-by socket ./lmp_openmpi ... + OpenMPI 1.8: mpirun -np 2 --bind-to socket --map-by socket ./lmp_openmpi ... Mvapich2 2.0: mpiexec -np 2 --bind-to socket --map-by socket ./lmp_mvapich ... For binding threads with KOKKOS OpenMP, use thread affinity environment @@ -310,7 +310,8 @@ Alternatively the effect of the "-sf" or "-pk" switches can be duplicated by adding the :doc:`package kokkos ` or :doc:`suffix kk ` commands to your input script. The discussion above for building LAMMPS with the KOKKOS package, the -mpirun/mpiexec command, and setting appropriate thread are the same. +``mpirun`` or ``mpiexec`` command, and setting appropriate thread +properties are the same. You must still use the "-k on" :doc:`command-line switch ` to enable the KOKKOS package, and specify its additional arguments for diff --git a/doc/src/Speed_omp.rst b/doc/src/Speed_omp.rst index 29c55df62f..7f8913d20f 100644 --- a/doc/src/Speed_omp.rst +++ b/doc/src/Speed_omp.rst @@ -33,8 +33,8 @@ These examples assume one or more 16-core nodes. mpirun -np 4 lmp_omp -sf omp -pk omp 4 -in in.script # 4 MPI tasks, 4 threads/task mpirun -np 32 -ppn 4 lmp_omp -sf omp -pk omp 4 -in in.script # 8 nodes, 4 MPI tasks/node, 4 threads/task -The mpirun or mpiexec command sets the total number of MPI tasks used -by LAMMPS (one or multiple per compute node) and the number of MPI +The ``mpirun`` or ``mpiexec`` command sets the total number of MPI tasks +used by LAMMPS (one or multiple per compute node) and the number of MPI tasks used per node. E.g. the mpirun command in MPICH does this via its -np and -ppn switches. Ditto for OpenMPI via -np and -npernode. @@ -58,8 +58,8 @@ OMP_NUM_THREADS environment variable. Or run with the OPENMP package by editing an input script """"""""""""""""""""""""""""""""""""""""""""""""""""""""""" -The discussion above for the mpirun/mpiexec command, MPI tasks/node, -and threads/MPI task is the same. +The discussion above for the ``mpirun`` or ``mpiexec`` command, MPI +tasks/node, and threads/MPI task is the same. Use the :doc:`suffix omp ` command, or you can explicitly add an "omp" suffix to individual styles in your input script, e.g. From b0e3c2a440c0ce2978bd1f0cc502c41f67e67957 Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Tue, 4 Oct 2022 09:16:15 -0400 Subject: [PATCH 8/9] retrieving the error message clears the error status --- unittest/fortran/wrap_properties.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/unittest/fortran/wrap_properties.cpp b/unittest/fortran/wrap_properties.cpp index 59e98891c3..5268548d48 100644 --- a/unittest/fortran/wrap_properties.cpp +++ b/unittest/fortran/wrap_properties.cpp @@ -134,5 +134,11 @@ TEST_F(LAMMPS_properties, has_error) int err = f_lammps_get_last_error_message(errmsg, 1023); EXPECT_EQ(err, 1); EXPECT_THAT(errmsg, ContainsRegex(".*ERROR: Unknown command: this_is_not_a_known_command.*")); + + // retrieving the error message clear the error status + EXPECT_EQ(f_lammps_has_error(), 0); + err = f_lammps_get_last_error_message(errmsg, 1023); + EXPECT_EQ(err, 0); + EXPECT_THAT(errmsg, ContainsRegex(" ")); }; } // namespace LAMMPS_NS From 74705c811107ebc036bf519e973c8ebb0e3bb28d Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Tue, 4 Oct 2022 09:27:52 -0400 Subject: [PATCH 9/9] port error check test from fortran wrapper to c-library interface test --- .../c-library/test_library_properties.cpp | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/unittest/c-library/test_library_properties.cpp b/unittest/c-library/test_library_properties.cpp index 56c89a6c13..bbb363dfab 100644 --- a/unittest/c-library/test_library_properties.cpp +++ b/unittest/c-library/test_library_properties.cpp @@ -434,6 +434,33 @@ TEST_F(LibraryProperties, neighlist) } }; +TEST_F(LibraryProperties, has_error) +{ + // need errors to throw exceptions to be able to intercept them. + if (!lammps_config_has_exceptions()) GTEST_SKIP(); + + EXPECT_EQ(lammps_has_error(lmp), 0); + + // trigger an error, but hide output + ::testing::internal::CaptureStdout(); + lammps_command(lmp, "this_is_not_a_known_command"); + ::testing::internal::GetCapturedStdout(); + + EXPECT_EQ(lammps_has_error(lmp), 1); + + // retrieve error message + char errmsg[1024]; + int err = lammps_get_last_error_message(lmp, errmsg, 1024); + EXPECT_EQ(err, 1); + EXPECT_THAT(errmsg, HasSubstr("ERROR: Unknown command: this_is_not_a_known_command")); + + // retrieving the error message clear the error status + EXPECT_EQ(lammps_has_error(lmp), 0); + err = lammps_get_last_error_message(lmp, errmsg, 1024); + EXPECT_EQ(err, 0); + EXPECT_THAT(errmsg, StrEq("")); +}; + class AtomProperties : public ::testing::Test { protected: void *lmp;