Merge pull request #4380 from rbberger/python_computes

Python and library API changes for computes

doc/src/Fortran.rst

@@ -323,6 +323,12 @@ of the contents of the :f:mod:`LIBLAMMPS` Fortran interface to LAMMPS.
    :ftype set_internal_variable: subroutine
    :f eval: :f:func:`eval`
    :ftype eval: function
+   :f clearstep_compute: :f:subr:`clearstep_compute`
+   :ftype clearstep_compute: subroutine
+   :f addstep_compute: :f:subr:`addstep_compute`
+   :ftype addstep_compute: subroutine
+   :f addstep_compute_all: :f:subr:`addstep_compute_all`
+   :ftype addstep_compute_all: subroutine
    :f gather_atoms: :f:subr:`gather_atoms`
    :ftype gather_atoms: subroutine
    :f gather_atoms_concat: :f:subr:`gather_atoms_concat`
@@ -1453,11 +1459,62 @@ Procedures Bound to the :f:type:`lammps` Derived Type
    an internal-style variable, an error is generated.
 
    :p character(len=*) name: name of the variable
-   :p read(c_double) val:  new value to assign to the variable
+   :p real(c_double) val:  new value to assign to the variable
    :to: :cpp:func:`lammps_set_internal_variable`
 
 --------
 
+.. f:function:: eval(expr)
+
+   This function is a wrapper around :cpp:func:`lammps_eval` that takes a
+   LAMMPS equal style variable string, evaluates it and returns the resulting
+   scalar value as a floating-point number.
+
+   .. versionadded:: TBD
+
+   :p character(len=\*) expr: string to be evaluated
+   :to: :cpp:func:`lammps_eval`
+   :r value [real(c_double)]: result of the evaluated string
+
+--------
+
+.. f:subroutine:: clearstep_compute()
+
+   Clear whether a compute has been invoked
+
+   .. versionadded:: TBD
+
+   :to: :cpp:func:`lammps_clearstep_compute`
+
+--------
+
+.. f:subroutine:: addstep_compute(nextstep)
+
+   Add timestep to list of future compute invocations
+   if the compute has been invoked on the current timestep
+
+   .. versionadded:: TBD
+
+   overloaded for 32-bit and 64-bit integer arguments
+
+   :p integer(kind=8 or kind=4) nextstep: next timestep
+   :to: :cpp:func:`lammps_addstep_compute`
+
+--------
+
+.. f:subroutine:: addstep_compute_all(nextstep)
+
+   Add timestep to list of future compute invocations
+
+   .. versionadded:: TBD
+
+   overloaded for 32-bit and 64-bit integer arguments
+
+   :p integer(kind=8 or kind=4) nextstep: next timestep
+   :to: :cpp:func:`lammps_addstep_compute_all`
+
+--------
+
 .. f:subroutine:: gather_atoms(name, count, data)
 
    This function calls :cpp:func:`lammps_gather_atoms` to gather the named

doc/src/Library_objects.rst

@@ -13,6 +13,9 @@ fixes, or variables in LAMMPS using the following functions:
 - :cpp:func:`lammps_set_internal_variable`
 - :cpp:func:`lammps_variable_info`
 - :cpp:func:`lammps_eval`
+- :cpp:func:`lammps_clearstep_compute`
+- :cpp:func:`lammps_addstep_compute_all`
+- :cpp:func:`lammps_addstep_compute`
 
 -----------------------
 
@@ -61,6 +64,21 @@ fixes, or variables in LAMMPS using the following functions:
 
 -----------------------
 
+.. doxygenfunction:: lammps_clearstep_compute
+   :project: progguide
+
+-----------------------
+
+.. doxygenfunction:: lammps_addstep_compute_all
+   :project: progguide
+
+-----------------------
+
+.. doxygenfunction:: lammps_addstep_compute
+   :project: progguide
+
+-----------------------
+
 .. doxygenenum:: _LMP_DATATYPE_CONST
 
 .. doxygenenum:: _LMP_STYLE_CONST

doc/src/fix_python_invoke.rst

@@ -66,6 +66,15 @@ gives access to the LAMMPS state from Python.
    from these callbacks, trying to execute input script commands will in the best
    case not work or in the worst case result in undefined behavior.
 
+Restart, fix_modify, output, run start/stop, minimize info
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+No information about this fix is written to :doc:`binary restart files <restart>`.  None of the :doc:`fix_modify <fix_modify>` options
+are relevant to this fix.  No global or per-atom quantities are stored
+by this fix for access by various :doc:`output commands <Howto_output>`.
+No parameter of this fix can be used with the *start/stop* keywords of
+the :doc:`run <run>` command.  This fix is not invoked during :doc:`energy minimization <minimize>`.
+
 Restrictions
 """"""""""""
 

doc/utils/sphinx-config/false_positives.txt

@@ -2535,6 +2535,7 @@ Nevery
 Nevins
 newfile
 Newns
+newstep
 newtype
 nextsort
 Neyts
@@ -3773,6 +3774,7 @@ Tigran
 Tij
 Tildesley
 Timan
+timeflag
 timeI
 timespan
 timestamp

examples/COUPLE/plugin/liblammpsplugin.c

@@ -118,6 +118,9 @@ liblammpsplugin_t *liblammpsplugin_load(const char *lib)
   ADDSYM(set_internal_variable);
   ADDSYM(variable_info);
   ADDSYM(eval);
+  ADDSYM(clearstep_compute);
+  ADDSYM(addstep_compute);
+  ADDSYM(addstep_compute_all);
 
   ADDSYM(gather_atoms);
   ADDSYM(gather_atoms_concat);

examples/COUPLE/plugin/liblammpsplugin.h

@@ -164,6 +164,9 @@ struct _liblammpsplugin {
   int (*set_internal_variable)(void *, const char *, double);
   int (*variable_info)(void *, int, char *, int);
   double (*eval)(void *, const char *);
+  void (*clearstep_compute)(void *);
+  void (*addstep_compute)(void *, void *);
+  void (*addstep_compute_all)(void *, void *);
 
   void (*gather_atoms)(void *, const char *, int, int, void *);
   void (*gather_atoms_concat)(void *, const char *, int, int, void *);

fortran/lammps.f90

@@ -127,6 +127,16 @@ MODULE LIBLAMMPS
     PROCEDURE :: set_string_variable    => lmp_set_string_variable
     PROCEDURE :: set_internal_variable  => lmp_set_internal_variable
     PROCEDURE :: eval                   => lmp_eval
+
+    PROCEDURE :: clearstep_compute      => lmp_clearstep_compute
+    PROCEDURE, PRIVATE :: lmp_addstep_compute_smallint
+    PROCEDURE, PRIVATE :: lmp_addstep_compute_bigint
+    GENERIC :: addstep_compute          => lmp_addstep_compute_smallint, lmp_addstep_compute_bigint
+    PROCEDURE, PRIVATE :: lmp_addstep_compute_all_smallint
+    PROCEDURE, PRIVATE :: lmp_addstep_compute_all_bigint
+    GENERIC :: addstep_compute_all      => lmp_addstep_compute_all_smallint, &
+                                           lmp_addstep_compute_all_bigint
+
     PROCEDURE, PRIVATE :: lmp_gather_atoms_int
     PROCEDURE, PRIVATE :: lmp_gather_atoms_double
     GENERIC   :: gather_atoms           => lmp_gather_atoms_int, &
@@ -626,6 +636,24 @@ MODULE LIBLAMMPS
       REAL(c_double) :: lammps_eval
     END FUNCTION lammps_eval
 
+    SUBROUTINE lammps_clearstep_compute(handle) BIND(C)
+      IMPORT :: c_ptr
+      IMPLICIT NONE
+      TYPE(c_ptr), VALUE :: handle
+    END SUBROUTINE lammps_clearstep_compute
+
+    SUBROUTINE lammps_addstep_compute(handle, step) BIND(C)
+      IMPORT :: c_ptr
+      IMPLICIT NONE
+      TYPE(c_ptr), VALUE :: handle, step
+    END SUBROUTINE lammps_addstep_compute
+
+    SUBROUTINE lammps_addstep_compute_all(handle, step) BIND(C)
+      IMPORT :: c_ptr
+      IMPLICIT NONE
+      TYPE(c_ptr), VALUE :: handle, step
+    END SUBROUTINE lammps_addstep_compute_all
+
     SUBROUTINE lammps_gather_atoms(handle, name, TYPE, count, DATA) BIND(C)
       IMPORT :: c_int, c_ptr
       IMPLICIT NONE
@@ -1846,6 +1874,80 @@ CONTAINS
     CALL lammps_free(Cexpr)
   END FUNCTION lmp_eval
 
+  ! equivalent subroutine to lammps_clearstep_compute
+  SUBROUTINE lmp_clearstep_compute(self)
+    CLASS(lammps), INTENT(IN) :: self
+    CALL lammps_clearstep_compute(self%handle)
+  END SUBROUTINE lmp_clearstep_compute
+
+  ! equivalent subroutine to lammps_addstep_compute
+  SUBROUTINE lmp_addstep_compute_bigint(self, nextstep)
+    CLASS(lammps), INTENT(IN) :: self
+    INTEGER(kind=8), INTENT(IN) :: nextstep
+    INTEGER(c_int), TARGET :: smallstep
+    INTEGER(c_int64_t), TARGET :: bigstep
+    TYPE(c_ptr) :: ptrstep
+    IF (SIZE_BIGINT == 4_c_int) THEN
+        smallstep = INT(nextstep,kind=c_int)
+        ptrstep = C_LOC(smallstep)
+    ELSE
+        bigstep = nextstep
+        ptrstep = C_LOC(bigstep)
+    END IF
+    CALL lammps_addstep_compute(self%handle, ptrstep)
+  END SUBROUTINE lmp_addstep_compute_bigint
+
+  ! equivalent subroutine to lammps_addstep_compute
+  SUBROUTINE lmp_addstep_compute_smallint(self, nextstep)
+    CLASS(lammps), INTENT(IN) :: self
+    INTEGER(kind=4), INTENT(IN) :: nextstep
+    INTEGER(c_int), TARGET :: smallstep
+    INTEGER(c_int64_t), TARGET :: bigstep
+    TYPE(c_ptr) :: ptrstep
+    IF (SIZE_BIGINT == 4_c_int) THEN
+        smallstep = nextstep
+        ptrstep = C_LOC(smallstep)
+    ELSE
+        bigstep = nextstep
+        ptrstep = C_LOC(bigstep)
+    END IF
+    CALL lammps_addstep_compute(self%handle, ptrstep)
+  END SUBROUTINE lmp_addstep_compute_smallint
+
+  ! equivalent subroutine to lammps_addstep_compute_all
+  SUBROUTINE lmp_addstep_compute_all_bigint(self, nextstep)
+    CLASS(lammps), INTENT(IN) :: self
+    INTEGER(kind=8), INTENT(IN) :: nextstep
+    INTEGER(c_int), TARGET :: smallstep
+    INTEGER(c_int64_t), TARGET :: bigstep
+    TYPE(c_ptr) :: ptrstep
+    IF (SIZE_BIGINT == 4_c_int) THEN
+        smallstep = INT(nextstep,kind=c_int)
+        ptrstep = C_LOC(smallstep)
+    ELSE
+        bigstep = nextstep
+        ptrstep = C_LOC(bigstep)
+    END IF
+    CALL lammps_addstep_compute_all(self%handle, ptrstep)
+  END SUBROUTINE lmp_addstep_compute_all_bigint
+
+  ! equivalent subroutine to lammps_addstep_compute_all
+  SUBROUTINE lmp_addstep_compute_all_smallint(self, nextstep)
+    CLASS(lammps), INTENT(IN) :: self
+    INTEGER(kind=4), INTENT(IN) :: nextstep
+    INTEGER(c_int), TARGET :: smallstep
+    INTEGER(c_int64_t), TARGET :: bigstep
+    TYPE(c_ptr) :: ptrstep
+    IF (SIZE_BIGINT == 4_c_int) THEN
+        smallstep = nextstep
+        ptrstep = C_LOC(smallstep)
+    ELSE
+        bigstep = nextstep
+        ptrstep = C_LOC(bigstep)
+    END IF
+    CALL lammps_addstep_compute_all(self%handle, ptrstep)
+  END SUBROUTINE lmp_addstep_compute_all_smallint
+
   ! equivalent function to lammps_gather_atoms (for integers)
   SUBROUTINE lmp_gather_atoms_int(self, name, count, data)
     CLASS(lammps), INTENT(IN) :: self

python/lammps/core.py

@@ -422,6 +422,10 @@ class lammps(object):
     self.lib.lammps_extract_variable_datatype.argtypes = [c_void_p, c_char_p]
     self.lib.lammps_extract_variable_datatype.restype = c_int
 
+    self.lib.lammps_clearstep_compute.argtype = [c_void_p]
+    self.lib.lammps_addstep_compute.argtype = [c_void_p, c_void_p]
+    self.lib.lammps_addstep_compute_all.argtype = [c_void_p, c_void_p]
+
     self.lib.lammps_eval.argtypes = [c_void_p, c_char_p]
     self.lib.lammps_eval.restype = c_double
 
@@ -1594,6 +1598,26 @@ class lammps(object):
 
   # -------------------------------------------------------------------------
 
+  def clearstep_compute(self, nextstep):
+    with ExceptionCheck(self):
+      return self.lib.lammps_clearstep_compute(self.lmp)
+
+  # -------------------------------------------------------------------------
+
+  def addstep_compute(self, nextstep):
+    with ExceptionCheck(self):
+      nextstep = self.c_bigint(nextstep)
+      return self.lib.lammps_addstep_compute(self.lmp, POINTER(nextstep))
+
+  # -------------------------------------------------------------------------
+
+  def addstep_compute_all(self, nextstep):
+    with ExceptionCheck(self):
+      nextstep = self.c_bigint(nextstep)
+      return self.lib.lammps_addstep_compute_all(self.lmp, POINTER(nextstep))
+
+  # -------------------------------------------------------------------------
+
   def flush_buffers(self):
     """Flush output buffers
 

src/PYTHON/fix_python_invoke.cpp

@@ -22,6 +22,7 @@
 #include "lmppython.h"
 #include "python_compat.h"
 #include "python_utils.h"
+#include "modify.h"
 #include "update.h"
 
 #include <cstring>
@@ -70,6 +71,12 @@ FixPythonInvoke::FixPythonInvoke(LAMMPS *lmp, int narg, char **arg) :
   }
 
   lmpPtr = PY_VOID_POINTER(lmp);
+
+  // nvalid = next step on which end_of_step or post_force does something
+  // add nextvalid() to all computes that store invocation times
+  // since we don't know a priori which are invoked by python code
+  nvalid = nextvalid();
+  modify->addstep_compute_all(nvalid);
 }
 
 /* ---------------------------------------------------------------------- */
@@ -89,8 +96,23 @@ int FixPythonInvoke::setmask()
 
 /* ---------------------------------------------------------------------- */
 
+void FixPythonInvoke::init()
+{
+  // need to reset nvalid if nvalid < ntimestep b/c minimize was performed
+
+  if (nvalid < update->ntimestep) {
+    nvalid = nextvalid();
+    modify->addstep_compute_all(nvalid);
+  }
+}
+
+/* ---------------------------------------------------------------------- */
+
 void FixPythonInvoke::end_of_step()
 {
+  // python code may invoke computes so wrap with clear/add
+  modify->clearstep_compute();
+
   PyUtils::GIL lock;
 
   PyObject * result = PyObject_CallFunction((PyObject*)pFunc, (char *)"O", (PyObject*)lmpPtr);
@@ -101,6 +123,9 @@ void FixPythonInvoke::end_of_step()
   }
 
   Py_CLEAR(result);
+
+  nvalid = nextvalid();
+  modify->addstep_compute(nvalid);
 }
 
 /* ---------------------------------------------------------------------- */
@@ -116,6 +141,9 @@ void FixPythonInvoke::post_force(int vflag)
 {
   if (update->ntimestep % nevery != 0) return;
 
+  // python code may invoke computes so wrap with clear/add
+  modify->clearstep_compute();
+
   PyUtils::GIL lock;
   char fmt[] = "Oi";
 
@@ -127,4 +155,14 @@ void FixPythonInvoke::post_force(int vflag)
   }
 
   Py_CLEAR(result);
+
+  nvalid = nextvalid();
+  modify->addstep_compute(nvalid);
+}
+
+/* ---------------------------------------------------------------------- */
+
+bigint FixPythonInvoke::nextvalid()
+{
+  return (update->ntimestep/nevery + 1)*nevery;
 }

src/PYTHON/fix_python_invoke.h

@@ -31,6 +31,7 @@ class FixPythonInvoke : public Fix {
   ~FixPythonInvoke() override;
   int setmask() override;
   void setup(int) override;
+  void init() override;
   void end_of_step() override;
   void post_force(int) override;
 
@@ -38,6 +39,8 @@ class FixPythonInvoke : public Fix {
   void *lmpPtr;
   void *pFunc;
   int selected_callback;
+  bigint nextvalid();
+  bigint nvalid;
 };
 
 }    // namespace LAMMPS_NS

src/library.cpp

@@ -2925,6 +2925,8 @@ int lammps_variable_info(void *handle, int idx, char *buffer, int buf_size) {
   return 0;
 }
 
+/* ---------------------------------------------------------------------- */
+
 /** Evaluate an immediate variable expression
  *
 \verbatim embed:rst
@@ -2958,6 +2960,86 @@ double lammps_eval(void *handle, const char *expr)
   return result;
 }
 
+/* ---------------------------------------------------------------------- */
+
+/** Clear whether a compute has been invoked.
+ *
+\verbatim embed:rst
+
+.. versionadded:: TBD
+
+   This function clears the invoked flag of all computes.
+   Called everywhere that computes are used, before computes are invoked.
+   The invoked flag is used to avoid re-invoking same compute multiple times
+   and to flag computes that store invocation times as having been invoked
+
+*See also*
+    :cpp:func:`lammps_addstep_compute_all`
+    :cpp:func:`lammps_addstep_compute`
+
+\endverbatim
+
+ * \param handle   pointer to a previously created LAMMPS instance cast to ``void *``.
+ */
+void lammps_clearstep_compute(void *handle) {
+  auto lmp = (LAMMPS *) handle;
+  lmp->modify->clearstep_compute();
+}
+
+/* ---------------------------------------------------------------------- */
+
+/** Add next timestep to all computes
+ *
+\verbatim embed:rst
+
+.. versionadded:: TBD
+
+   loop over all computes
+   schedule next invocation for those that store invocation times
+   called when not sure what computes will be needed on newstep
+   do not loop only over n_timeflag, since may not be set yet
+
+*See also*
+    :cpp:func:`lammps_clearstep_compute`
+    :cpp:func:`lammps_addstep_compute`
+
+\endverbatim
+
+ * \param handle   pointer to a previously created LAMMPS instance cast to ``void *``.
+ * \param newstep  pointer to bigint of next timestep the compute will be invoked
+ */
+void lammps_addstep_compute_all(void *handle, void *newstep) {
+  auto lmp = (LAMMPS *) handle;
+  auto ns = (bigint *) newstep;
+  if (lmp && lmp->modify && ns) lmp->modify->addstep_compute_all(*ns);
+}
+/* ---------------------------------------------------------------------- */
+
+/** Add next timestep to compute if it has been invoked in the current timestep
+ *
+\verbatim embed:rst
+
+.. versionadded:: TBD
+
+   loop over computes that store invocation times
+   if its invoked flag set on this timestep, schedule next invocation
+   called everywhere that computes are used, after computes are invoked
+
+*See also*
+    :cpp:func:`lammps_addstep_compute_all`
+    :cpp:func:`lammps_clearstep_compute`
+
+\endverbatim
+
+ * \param handle   pointer to a previously created LAMMPS instance cast to ``void *``.
+ * \param newstep  next timestep the compute will be invoked
+ */
+void lammps_addstep_compute(void *handle, void *newstep) {
+  auto lmp = (LAMMPS *) handle;
+  auto ns = (bigint *) newstep;
+  if (lmp && lmp->modify && ns) lmp->modify->addstep_compute(*ns);
+}
+
 // ----------------------------------------------------------------------
 // Library functions for scatter/gather operations of data
 // ----------------------------------------------------------------------

src/library.h

@@ -191,6 +191,10 @@ int lammps_set_internal_variable(void *handle, const char *name, double value);
 int lammps_variable_info(void *handle, int idx, char *buf, int bufsize);
 double lammps_eval(void *handle, const char *expr);
 
+void lammps_clearstep_compute(void *handle);
+void lammps_addstep_compute_all(void *handle, void * nextstep);
+void lammps_addstep_compute(void *handle, void * nextstep);
+
 /* ----------------------------------------------------------------------
  * Library functions for scatter/gather operations of data
  * ---------------------------------------------------------------------- */

tools/swig/lammps.i

@@ -143,6 +143,9 @@ extern int    lammps_set_string_variable(void *, const char *, const char *);
 extern int    lammps_set_internal_variable(void *, const char *, double);
 extern int    lammps_variable_info(void *handle, int idx, char *buf, int bufsize);
 extern double lammps_eval(void *handle, const char *expr);
+extern void   lammps_clearstep_compute(void *handle);
+extern void   lammps_addstep_compute(void *handle, void *nstep);
+extern void   lammps_addstep_compute_all(void *handle, void *nstep);
 
 extern void   lammps_gather_atoms(void *, char *, int, int, void *);
 extern void   lammps_gather_atoms_concat(void *, char *, int, int, void *);
@@ -336,6 +339,9 @@ extern int    lammps_set_string_variable(void *, const char *, const char *);
 extern int    lammps_set_internal_variable(void *, const char *, double);
 extern int    lammps_variable_info(void *handle, int idx, char *buf, int bufsize);
 extern double lammps_eval(void *handle, const char *expr);
+extern void   lammps_clearstep_compute(void *handle);
+extern void   lammps_addstep_compute(void *handle, void *nstep);
+extern void   lammps_addstep_compute_all(void *handle, void *nstep);
 
 extern void   lammps_gather_atoms(void *, char *, int, int, void *);
 extern void   lammps_gather_atoms_concat(void *, char *, int, int, void *);

unittest/c-library/test_library_properties.cpp

@@ -3,9 +3,12 @@
 #include "library.h"
 
 #include "atom.h"
+#include "compute.h"
 #include "lammps.h"
 #include "lmptype.h"
+#include "modify.h"
 #include "platform.h"
+
 #include <string>
 #include <vector>
 
@@ -668,6 +671,77 @@ TEST_F(LibraryProperties, neighlist)
     }
 };
 
+static constexpr char lj_setup[] = "lattice         fcc 0.8442\n"
+                                   "region          box block 0 10 0 10 0 10\n"
+                                   "create_box      1 box\n"
+                                   "create_atoms    1 box\n"
+                                   "mass            1 1.0\n"
+                                   "pair_style      lj/cut 2.5\n"
+                                   "pair_coeff      1 1 1.0 1.0\n"
+                                   "fix             1 all nve\n";
+
+TEST_F(LibraryProperties, step_compute)
+{
+    ::testing::internal::CaptureStdout();
+    lammps_commands_string(lmp, lj_setup);
+    lammps_command(lmp, "compute pr all pressure thermo_temp");
+    lammps_command(lmp, "fix av all ave/time 2 1 2 c_pr mode scalar");
+    lammps_command(lmp, "run 2 post no");
+    std::string output = ::testing::internal::GetCapturedStdout();
+    if (verbose) std::cout << output;
+    if (lammps_has_error(lmp)) {
+        char buf[2048];
+        lammps_get_last_error_message(lmp, buf, 2048);
+        FAIL() << buf << "\n";
+    }
+    auto lammps = (LAMMPS_NS::LAMMPS *)lmp;
+    auto icomp  = lammps->modify->get_compute_by_id("pr");
+    EXPECT_EQ(icomp->ntime, 2);
+    EXPECT_EQ(icomp->tlist[0], 4);
+    EXPECT_EQ(icomp->tlist[1], 2);
+    EXPECT_EQ(icomp->invoked_flag, 0);
+    EXPECT_EQ(icomp->invoked_scalar, 2);
+    EXPECT_EQ(icomp->invoked_vector, -1);
+    lammps_clearstep_compute(lmp);
+    EXPECT_EQ(icomp->invoked_flag, 0);
+    EXPECT_EQ(icomp->invoked_scalar, 2);
+    EXPECT_EQ(icomp->invoked_vector, -1);
+    bigint nextstep = 6;
+    lammps_addstep_compute(lmp, (void *)&nextstep);
+    EXPECT_EQ(icomp->ntime, 3);
+    EXPECT_EQ(icomp->tlist[0], 6);
+    EXPECT_EQ(icomp->tlist[1], 4);
+    EXPECT_EQ(icomp->tlist[2], 2);
+    EXPECT_EQ(icomp->invoked_flag, 0);
+    EXPECT_EQ(icomp->invoked_scalar, 2);
+    EXPECT_EQ(icomp->invoked_vector, -1);
+    lammps_command(lmp, "run 4 post no");
+    EXPECT_EQ(icomp->ntime, 2);
+    EXPECT_EQ(icomp->tlist[0], 8);
+    EXPECT_EQ(icomp->tlist[1], 6);
+    EXPECT_EQ(icomp->invoked_flag, 0);
+    EXPECT_EQ(icomp->invoked_scalar, 6);
+    EXPECT_EQ(icomp->invoked_vector, -1);
+    lammps_command(lmp, "run 2 post no");
+    EXPECT_EQ(icomp->ntime, 2);
+    EXPECT_EQ(icomp->tlist[0], 10);
+    EXPECT_EQ(icomp->tlist[1], 8);
+    EXPECT_EQ(icomp->invoked_flag, 0);
+    EXPECT_EQ(icomp->invoked_scalar, 8);
+    EXPECT_EQ(icomp->invoked_vector, -1);
+    nextstep = 9;
+    lammps_addstep_compute(lmp, (void *)&nextstep);
+    lammps_command(lmp, "run 1 post no");
+    EXPECT_EQ(icomp->ntime, 2);
+    EXPECT_EQ(icomp->tlist[0], 10);
+    EXPECT_EQ(icomp->tlist[1], 9);
+    EXPECT_EQ(icomp->invoked_flag, 0);
+    EXPECT_EQ(icomp->invoked_scalar, -1);
+    EXPECT_EQ(icomp->invoked_vector, -1);
+    icomp->compute_scalar();
+    EXPECT_EQ(icomp->invoked_scalar, 9);
+}
+
 TEST_F(LibraryProperties, has_error)
 {
     EXPECT_EQ(lammps_has_error(lmp), 0);