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

Merge remote-tracking branch 'github/master' into arg-info-class

Browse Source 
# Conflicts:
#	src/compute_chunk_atom.cpp
#	src/compute_chunk_spread_atom.cpp
#	src/compute_reduce.cpp
#	src/compute_reduce_region.cpp
#	src/compute_slice.cpp
#	src/fix_ave_atom.cpp
This commit is contained in:
Axel Kohlmeyer
2021-02-02 11:33:01 -05:00
parent 4d98d9f6aa f2479e7d05
commit c2c8c5e493
52 changed files with 487 additions and 381 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
.github/workflows/codeql-analysis.yml vendored Normal file
View File

@ -0,0 +1,49 @@
# GitHub action to run static code analysis on C++ and Python code
name: "CodeQL Code Analysis"
on:
push:
branches: [master]
pull_request:
branches: [master]
jobs:
analyze:
name: Analyze
if: ${{ github.repository == 'lammps/lammps' }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
language: ['cpp', 'python']
steps:
- name: Checkout repository
uses: actions/checkout@v2
with:
fetch-depth: 2
- name: Setup Python
uses: actions/setup-python@v2
with:
python-version: '3.x'
- name: Initialize CodeQL
uses: github/codeql-action/init@v1
with:
languages: ${{ matrix.language }}
- name: Create Build Environment
run: cmake -E make_directory ${{github.workspace}}/build
- name: Building LAMMPS via CMake
if: ${{ matrix.language == 'cpp' }}
shell: bash
working-directory: ${{github.workspace}}/build
run: |
cmake -C $GITHUB_WORKSPACE/cmake/presets/most.cmake $GITHUB_WORKSPACE/cmake
cmake --build . --parallel 2
- name: Perform CodeQL Analysis
uses: github/codeql-action/analyze@v1

36
.github/workflows/unittest-macos.yml vendored Normal file
View File

@ -0,0 +1,36 @@
# GitHub action to build LAMMPS on MacOS and run unit tests
name: "Unittest for MacOS"
on:
push:
branches: [master]
pull_request:
branches: [master]
jobs:
build:
name: MacOS Unit Test
if: ${{ github.repository == 'lammps/lammps' }}
runs-on: macos-latest
steps:
- name: Checkout repository
uses: actions/checkout@v2
with:
fetch-depth: 2
- name: Create Build Environment
run: cmake -E make_directory ${{github.workspace}}/build
- name: Building LAMMPS via CMake
shell: bash
working-directory: ${{github.workspace}}/build
run: |
cmake -C $GITHUB_WORKSPACE/cmake/presets/most.cmake $GITHUB_WORKSPACE/cmake \
-DENABLE_TESTING=ON -DBUILD_SHARED_LIBS=ON -DLAMMPS_EXCEPTIONS=ON
cmake --build . --parallel 2
- name: Run Tests
working-directory: ${{github.workspace}}/build
shell: bash
run: ctest -V

4
doc/Makefile
View File

@ -94,7 +94,7 @@ $(SPHINXCONFIG)/conf.py: $(SPHINXCONFIG)/conf.py.in
-e 's,@LAMMPS_PYTHON_DIR@,$(BUILDDIR)/../python,g' \
-e 's,@LAMMPS_DOC_DIR@,$(BUILDDIR),g' $< > $@
html: xmlgen $(SPHINXCONFIG)/conf.py $(ANCHORCHECK) $(MATHJAX)
html: xmlgen $(VENV) $(SPHINXCONFIG)/conf.py $(ANCHORCHECK) $(MATHJAX)
@if [ "$(HAS_BASH)" == "NO" ] ; then echo "bash was not found at $(OSHELL)! Please use: $(MAKE) SHELL=/path/to/bash" 1>&2; exit 1; fi
@$(MAKE) $(MFLAGS) -C graphviz all
@(\
@ -118,7 +118,7 @@ html: xmlgen $(SPHINXCONFIG)/conf.py $(ANCHORCHECK) $(MATHJAX)
@rm -rf html/PDF/.[sg]*
@echo "Build finished. The HTML pages are in doc/html."
spelling: xmlgen $(VENV) $(SPHINXCONFIG)/false_positives.txt
spelling: xmlgen $(SPHINXCONFIG)/conf.py $(VENV) $(SPHINXCONFIG)/false_positives.txt
@if [ "$(HAS_BASH)" == "NO" ] ; then echo "bash was not found at $(OSHELL)! Please use: $(MAKE) SHELL=/path/to/bash" 1>&2; exit 1; fi
@(\
. $(VENV)/bin/activate ; env PYTHONWARNINGS= \

187
doc/src/Developer_org.rst
View File

@ -1,68 +1,75 @@
Source files
------------
The source files of the LAMMPS code are found in two
directories of the distribution: ``src`` and ``lib``.
Most of the code is C++ but there are small numbers of files
in several other languages.
The source files of the LAMMPS code are found in two directories of the
distribution: ``src`` and ``lib``. Most of the code is written in C++
but there are small a number of files in several other languages like C,
Fortran, Shell script, or Python.
The core of the code is located in the
``src`` folder and its sub-directories.
A sizable number of these files are in the ``src`` directory
itself, but there are plenty of :doc:`packages <Packages>`, which can be
included or excluded when LAMMPS is built. See the :doc:`Include
packages in build <Build_package>` section of the manual for more
information about that part of the build process. LAMMPS currently
supports building with :doc:`conventional makefiles <Build_make>` and
through :doc:`CMake <Build_cmake>` which differ in how packages are
enabled or disabled for a LAMMPS binary. The source files for each
The core of the code is located in the ``src`` folder and its
sub-directories. A sizable number of these files are in the ``src``
directory itself, but there are plenty of :doc:`packages <Packages>`,
which can be included or excluded when LAMMPS is built. See the
:doc:`Include packages in build <Build_package>` section of the manual
for more information about that part of the build process. LAMMPS
currently supports building with :doc:`conventional makefiles
<Build_make>` and through :doc:`CMake <Build_cmake>`. Those procedures
differ in how packages are enabled or disabled for inclusion into a
LAMMPS binary so they cannot be mixed. The source files for each
package are in all-uppercase sub-directories of the ``src`` folder, for
example ``src/MOLECULE`` or ``src/USER-MISC``. The ``src/STUBS``
sub-directory is not a package but contains a dummy MPI library, that is
used when building a serial version of the code. The ``src/MAKE``
directory contains makefiles with settings and flags for a variety of
configuration and machines for the build process with traditional
makefiles.
directory and its sub-directories contain makefiles with settings and
flags for a variety of configuration and machines for the build process
with traditional makefiles.
The ``lib`` directory contains the source code for several supporting
libraries or files with configuration settings to use globally installed
libraries, that are required by some of the optional packages.
Each sub-directory, like ``lib/poems`` or ``lib/gpu``, contains the
source files, some of which are in different languages such as Fortran
or CUDA. These libraries are linked to during a LAMMPS build, if the
corresponding package is installed.
libraries, that are required by some of the optional packages. They may
include python scripts that can transparently download additional source
code on request. Each sub-directory, like ``lib/poems`` or ``lib/gpu``,
contains the source files, some of which are in different languages such
as Fortran or CUDA. These libraries included in the LAMMPS build,
if the corresponding package is installed.
LAMMPS C++ source files almost always come in pairs, such as
``src/run.cpp`` (implementation file) and ``src/run.h`` (header file).
Each pair of files defines a C++
class, for example the :cpp:class:`LAMMPS_NS::Run` class which contains
the code invoked by the :doc:`run <run>` command in a LAMMPS input script.
As this example illustrates, source file and class names often have a
one-to-one correspondence with a command used in a LAMMPS input script.
Some source files and classes do not have a corresponding input script
Each pair of files defines a C++ class, for example the
:cpp:class:`LAMMPS_NS::Run` class which contains the code invoked by the
:doc:`run <run>` command in a LAMMPS input script. As this example
illustrates, source file and class names often have a one-to-one
correspondence with a command used in a LAMMPS input script. Some
source files and classes do not have a corresponding input script
command, e.g. ``src/force.cpp`` and the :cpp:class:`LAMMPS_NS::Force`
class. They are discussed in the next section.
A small number of C++ classes and utility functions are implemented with
only a ``.h`` file. Examples are the Pointer class or the MathVec functions.
The names of all source files are in lower case and may use the
underscore character '_' to separate words. Outside of bundled libraries
which may have different conventions, all C and C++ header files have a
``.h`` extension, all C++ files have a ``.cpp`` extension, and C files a
``.c`` extension. A small number of C++ classes and utility functions
are implemented with only a ``.h`` file. Examples are the Pointer class
or the MathVec functions.
Class topology
--------------
Though LAMMPS has a lot of source files and classes, its class topology
is relative flat, as outlined in the :ref:`class-topology` figure. Each
name refers to a class and has a pair of associated source files in the
``src`` folder, for example the class :cpp:class:`LAMMPS_NS::Memory`
corresponds to the files ``memory.cpp`` and ``memory.h``, or the class
:cpp:class:`LAMMPS_NS::AtomVec` corresponds to the files
``atom_vec.cpp`` and ``atom_vec.h``. Full lines in the figure represent
compositing: that is the class to the left holds a pointer to an
instance of the class to the right. Dashed lines instead represent
inheritance: the class to the right is derived from the class on the
left. Classes with a red boundary are not instantiated directly, but
they represent the base classes for "styles". Those "styles" make up
the bulk of the LAMMPS code and only a few typical examples are included
in the figure for demonstration purposes.
is not very deep, which can be seen from the :ref:`class-topology`
figure. In that figure, each name refers to a class and has a pair of
associated source files in the ``src`` folder, for example the class
:cpp:class:`LAMMPS_NS::Memory` corresponds to the files ``memory.cpp``
and ``memory.h``, or the class :cpp:class:`LAMMPS_NS::AtomVec`
corresponds to the files ``atom_vec.cpp`` and ``atom_vec.h``. Full
lines in the figure represent compositing: that is the class at the base
of the arrow holds a pointer to an instance of the class at the tip.
Dashed lines instead represent inheritance: the class to the tip of the
arrow is derived from the class at the base. Classes with a red boundary
are not instantiated directly, but they represent the base classes for
"styles". Those "styles" make up the bulk of the LAMMPS code and only
a few representative examples are included in the figure so it remains
readable.
.. _class-topology:
.. figure:: JPG/lammps-classes.png
@ -82,8 +89,8 @@ in the figure for demonstration purposes.
derived classes, which may also hold instances of other classes.
The :cpp:class:`LAMMPS_NS::LAMMPS` class is the topmost class and
represents what is referred to an "instance" of LAMMPS. It is a
composite holding references to instances of other core classes
represents what is generally referred to an "instance" of LAMMPS. It is
a composite holding pointers to instances of other core classes
providing the core functionality of the MD engine in LAMMPS and through
them abstractions of the required operations. The constructor of the
LAMMPS class will instantiate those instances, process the command line
@ -91,60 +98,67 @@ flags, initialize MPI (if not already done) and set up file pointers for
input and output. The destructor will shut everything down and free all
associated memory. Thus code for the standalone LAMMPS executable in
``main.cpp`` simply initializes MPI, instantiates a single instance of
LAMMPS, and passes it the command line flags and input script. It
LAMMPS while passing it the command line flags and input script. It
deletes the LAMMPS instance after the method reading the input returns
and shuts down the MPI environment before it exits the executable.
The :cpp:class:`LAMMPS_NS::Pointers` is not shown in the
:ref:`class-topology` figure, it holds references to members of the
`LAMMPS_NS::LAMMPS`, so that all classes derived from
:cpp:class:`LAMMPS_NS::Pointers` have direct access to those reference.
From the class topology all classes with blue boundary are referenced in
this class and all classes in the second and third columns, that are not
listed as derived classes are instead derived from
:cpp:class:`LAMMPS_NS::Pointers`.
:ref:`class-topology` figure for clarity. It holds references to many
of the members of the `LAMMPS_NS::LAMMPS`, so that all classes derived
from :cpp:class:`LAMMPS_NS::Pointers` have direct access to those
reference. From the class topology all classes with blue boundary are
referenced in the Pointers class and all classes in the second and third
columns, that are not listed as derived classes are instead derived from
:cpp:class:`LAMMPS_NS::Pointers`. To initialize the pointer references
in Pointers, a pointer to the LAMMPS class instance needs to be passed
to the constructor and thus all constructors for classes derived from it
must do so and pass this pointer to the constructor for Pointers.
Since all storage is encapsulated, the LAMMPS class can also be
instantiated multiple times by a calling code, and that can be either
simultaneously or consecutively. When running in parallel with MPI,
care has to be taken, that suitable communicators are used to not
create conflicts between different instances.
Since all storage is supposed to be encapsulated (there are a few
exceptions), the LAMMPS class can also be instantiated multiple times by
a calling code. Outside of the aforementioned exceptions, those LAMMPS
instances can be used alternately. As of the time of this writing
(early 2021) LAMMPS is not yet sufficiently thread-safe for concurrent
execution. When running in parallel with MPI, care has to be taken,
that suitable copies of communicators are used to not create conflicts
between different instances.
The LAMMPS class currently holds instances of 19 classes representing
different core functionalities There are a handful of virtual parent
classes in LAMMPS that define what LAMMPS calls ``styles``. They are
shaded red in the :ref:`class-topology` figure. Each of these are
The LAMMPS class currently (early 2021) holds instances of 19 classes
representing the core functionality. There are a handful of virtual
parent classes in LAMMPS that define what LAMMPS calls ``styles``. They
are shaded red in the :ref:`class-topology` figure. Each of these are
parents of a number of child classes that implement the interface
defined by the parent class. There are two main categories of these
``styles``: some may only have one instance active at a time (e.g. atom,
pair, bond, angle, dihedral, improper, kspace, comm) and there is a
dedicated pointer variable in the composite class that manages them.
dedicated pointer variable for each of them in the composite class.
Setups that require a mix of different such styles have to use a
*hybrid* class that manages and forwards calls to the corresponding
sub-styles for the designated subset of atoms or data. or the composite
class may have lists of class instances, e.g. Modify handles lists of
compute and fix styles, while Output handles dumps class instances.
*hybrid* class that takes the place of the one allowed instance and then
manages and forwards calls to the corresponding sub-styles for the
designated subset of atoms or data. The composite class may also have
lists of class instances, e.g. Modify handles lists of compute and fix
styles, while Output handles a list of dump class instances.
The exception to this scheme are the ``command`` style classes. These
implement specific commands that can be invoked before, after, or between
runs or are commands which launch a simulation. For these an instance
of the class is created, its command() method called and then, after
completion, the class instance deleted. Examples for this are the
create_box, create_atoms, minimize, run, or velocity command styles.
implement specific commands that can be invoked before, after, or in
between runs. For these an instance of the class is created, its
command() method called and then, after completion, the class instance
deleted. Examples for this are the create_box, create_atoms, minimize,
run, or velocity command styles.
For all those ``styles`` certain naming conventions are employed: for
the fix nve command the class is called FixNVE and the files are
the fix nve command the class is called FixNVE and the source files are
``fix_nve.h`` and ``fix_nve.cpp``. Similarly for fix ave/time we have
FixAveTime and ``fix_ave_time.h`` and ``fix_ave_time.cpp``. Style names
are lower case and without spaces or special characters. A suffix or
multiple appended with a forward slash '/' denotes a variant of the
corresponding class without the suffix. To connect the style name and
the class name, LAMMPS uses macros like the following ATOM\_CLASS,
PAIR\_CLASS, BOND\_CLASS, REGION\_CLASS, FIX\_CLASS, COMPUTE\_CLASS,
or DUMP\_CLASS in the corresponding header file. During compilation
files with the pattern ``style_name.h`` are created that contain include
statements including all headers of all styles of a given type that
are currently active (or "installed).
words are appended with a forward slash '/' which denotes a variant of
the corresponding class without the suffix. To connect the style name
and the class name, LAMMPS uses macros like: ``AtomStyle()``,
``PairStyle()``, ``BondStyle()``, ``RegionStyle()``, and so on in the
corresponding header file. During configuration or compilation files
with the pattern ``style_<name>.h`` are created that consist of a list
of include statements including all headers of all styles of a given
type that are currently active (or "installed).
More details on individual classes in the :ref:`class-topology` are as
@ -152,11 +166,11 @@ follows:
- The Memory class handles allocation of all large vectors and arrays.
- The Error class prints all error and warning messages.
- The Error class prints all (terminal) error and warning messages.
- The Universe class sets up partitions of processors so that multiple
simulations can be run, each on a subset of the processors allocated
for a run, e.g. by the mpirun command.
- The Universe class sets up one or more partitions of processors so
that one or multiple simulations can be run, on the processors
allocated for a run, e.g. by the mpirun command.
- The Input class reads and processes input input strings and files,
stores variables, and invokes :doc:`commands <Commands_all>`.
@ -241,7 +255,8 @@ follows:
.. TODO section on "Spatial decomposition and parallel operations"
.. diagram of 3d processor grid, brick vs. tiled. local vs. ghost
.. atoms, 6-way communication with pack/unpack functions,
.. PBC as part of the communication
.. PBC as part of the communication, forward and reverse communication
.. rendezvous communication, ring communication.
.. TODO section on "Fixes, Computes, and Variables"
.. how and when data is computed and provided and how it is

8
doc/src/Python_install.rst
View File

@ -69,7 +69,7 @@ this.
cd build
# configure LAMMPS compilation
cmake -C cmake/presets/minimal.cmake -D BUILD_SHARED_LIBS=on \
cmake -C ../cmake/presets/minimal.cmake -D BUILD_SHARED_LIBS=on \
-D LAMMPS_EXCEPTIONS=on -D PKG_PYTHON=on ../cmake
# compile LAMMPS
@ -97,10 +97,12 @@ this.
For a system-wide installation you need to set
``CMAKE_INSTALL_PREFIX`` to a system folder like ``/usr`` (or
``/usr/local``). The installation step (**not** the
``/usr/local``); the default is ``${HOME}/.local``. The
installation step for a system folder installation (**not** the
configuration/compilation) needs to be done with superuser
privilege, e.g. by using ``sudo cmake --install .``. The
installation folders will then by changed to:
installation folders will then be changed to (assuming ``/usr`` as
prefix):
+------------------------+---------------------------------------------------------+-------------------------------------------------------------+
| File | Location | Notes |

7
python/lammps/core.py
View File

@ -99,6 +99,7 @@ class lammps(object):
# so that LD_LIBRARY_PATH does not need to be set for regular install
# fall back to loading with a relative path,
# typically requires LD_LIBRARY_PATH to be set appropriately
# guess shared library extension based on OS, if not inferred from actual file
if any([f.startswith('liblammps') and f.endswith('.dylib')
for f in os.listdir(modpath)]):
@ -110,6 +111,12 @@ class lammps(object):
for f in os.listdir(winpath)]):
lib_ext = ".dll"
modpath = winpath
else:
import platform
if platform.system() == "Darwin":
lib_ext = ".dylib"
elif platform.system() == "Windows":
lib_ext = ".dll"
else:
lib_ext = ".so"

2
src/KOKKOS/atom_vec_dpd_kokkos.cpp
View File

@ -784,7 +784,7 @@ struct AtomVecDPDKokkos_PackBorder {
_uCond(uCond),
_uMech(uMech),
_uChem(uChem),
_uCG(uCGnew),
_uCG(uCG),
_uCGnew(uCGnew),
_dx(dx),_dy(dy),_dz(dz) {}

5
src/KOKKOS/compute_coord_atom_kokkos.cpp
View File

@ -27,7 +27,6 @@
using namespace LAMMPS_NS;
#define INVOKED_PERATOM 8
/* ---------------------------------------------------------------------- */
@ -113,9 +112,9 @@ void ComputeCoordAtomKokkos<DeviceType>::compute_peratom()
}
if (cstyle == ORIENT) {
if (!(c_orientorder->invoked_flag & INVOKED_PERATOM)) {
if (!(c_orientorder->invoked_flag & Compute::INVOKED_PERATOM)) {
c_orientorder->compute_peratom();
c_orientorder->invoked_flag |= INVOKED_PERATOM;
c_orientorder->invoked_flag |= Compute::INVOKED_PERATOM;
}
nqlist = c_orientorder->nqlist;
normv = c_orientorder->array_atom;

5
src/LATTE/fix_latte.cpp
View File

@ -49,7 +49,6 @@ extern "C" {
// difficult to debug crashes or memory corruption.
#define LATTE_ABIVERSION 20180622
#define INVOKED_PERATOM 8
/* ---------------------------------------------------------------------- */
@ -248,9 +247,9 @@ void FixLatte::post_force(int vflag)
if (coulomb) {
modify->clearstep_compute();
if (!(c_pe->invoked_flag & INVOKED_PERATOM)) {
if (!(c_pe->invoked_flag & Compute::INVOKED_PERATOM)) {
c_pe->compute_peratom();
c_pe->invoked_flag |= INVOKED_PERATOM;
c_pe->invoked_flag |= Compute::INVOKED_PERATOM;
}
modify->addstep_compute(update->ntimestep+1);

43
src/MLIAP/mliap_model.cpp
View File

@ -20,6 +20,7 @@
#include "comm.h"
#include "error.h"
#include "memory.h"
#include "tokenizer.h"
#include <cstring>
@ -30,7 +31,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
MLIAPModel::MLIAPModel(LAMMPS* lmp, char* coefffilename) : Pointers(lmp)
MLIAPModel::MLIAPModel(LAMMPS *lmp, char *) : Pointers(lmp)
{
nparams = 0;
nelements = 0;
@ -44,7 +45,6 @@ MLIAPModel::~MLIAPModel()
{
}
/* ----------------------------------------------------------------------
placeholder
------------------------------------------------------------------------- */
@ -74,7 +74,7 @@ void MLIAPModel::set_ndescriptors(int ndescriptors_in)
/* ---------------------------------------------------------------------- */
MLIAPModelSimple::MLIAPModelSimple(LAMMPS* lmp, char* coefffilename) : MLIAPModel(lmp, coefffilename)
MLIAPModelSimple::MLIAPModelSimple(LAMMPS *lmp, char *coefffilename) : MLIAPModel(lmp, coefffilename)
{
coeffelem = nullptr;
if (coefffilename) read_coeffs(coefffilename);
@ -87,6 +87,7 @@ MLIAPModelSimple::~MLIAPModelSimple()
memory->destroy(coeffelem);
}
/* ---------------------------------------------------------------------- */
void MLIAPModelSimple::read_coeffs(char *coefffilename)
{
@ -130,14 +131,14 @@ void MLIAPModelSimple::read_coeffs(char *coefffilename)
// words = ptrs to all words in line
// strip single and double quotes from words
char* words[MAXWORD];
int iword = 0;
words[iword] = strtok(line,"' \t\n\r\f");
iword = 1;
words[iword] = strtok(nullptr,"' \t\n\r\f");
nelements = atoi(words[0]);
nparams = atoi(words[1]);
try {
ValueTokenizer coeffs(line);
nelements = coeffs.next_int();
nparams = coeffs.next_int();
} catch (TokenizerException &e) {
error->all(FLERR,fmt::format("Incorrect format in MLIAPModel coefficient "
"file: {}",e.what()));
}
// set up coeff lists
@ -157,19 +158,19 @@ void MLIAPModelSimple::read_coeffs(char *coefffilename)
MPI_Bcast(&eof,1,MPI_INT,0,world);
if (eof)
error->all(FLERR,"Incorrect format in coefficient file");
error->all(FLERR,"Incorrect format in MLIAPModel coefficient file");
MPI_Bcast(&n,1,MPI_INT,0,world);
MPI_Bcast(line,n,MPI_CHAR,0,world);
nwords = utils::trim_and_count_words(line);
if (nwords != 1)
error->all(FLERR,"Incorrect format in coefficient file");
iword = 0;
words[iword] = strtok(line,"' \t\n\r\f");
coeffelem[ielem][icoeff] = atof(words[0]);
try {
ValueTokenizer coeffs(utils::trim_comment(line));
if (coeffs.count() != 1)
throw TokenizerException("Wrong number of items","");
coeffelem[ielem][icoeff] = coeffs.next_double();
} catch (TokenizerException &e) {
error->all(FLERR,fmt::format("Incorrect format in MLIAPModel "
"coefficient file: {}",e.what()));
}
}
}

10
src/MLIAP/mliap_model_python.cpp
View File

@ -87,7 +87,7 @@ int MLIAPModelPython::get_nparams()
return nparams;
}
void MLIAPModelPython::read_coeffs(char * fname)
void MLIAPModelPython::read_coeffs(char *fname)
{
PyGILState_STATE gstate = PyGILState_Ensure();
@ -134,7 +134,7 @@ void MLIAPModelPython::connect_param_counts()
for each atom beta_i = dE(B_i)/dB_i
---------------------------------------------------------------------- */
void MLIAPModelPython::compute_gradients(MLIAPData* data)
void MLIAPModelPython::compute_gradients(MLIAPData *data)
{
if (not model_loaded) {
error->all(FLERR,"Model not loaded.");
@ -167,7 +167,7 @@ void MLIAPModelPython::compute_gradients(MLIAPData* data)
egradient is derivative of energy w.r.t. parameters
---------------------------------------------------------------------- */
void MLIAPModelPython::compute_gradgrads(class MLIAPData* data)
void MLIAPModelPython::compute_gradgrads(class MLIAPData *)
{
error->all(FLERR,"compute_gradgrads not implemented");
}
@ -177,7 +177,7 @@ void MLIAPModelPython::compute_gradgrads(class MLIAPData* data)
egradient is derivative of energy w.r.t. parameters
---------------------------------------------------------------------- */
void MLIAPModelPython::compute_force_gradients(class MLIAPData* data)
void MLIAPModelPython::compute_force_gradients(class MLIAPData *)
{
error->all(FLERR,"compute_force_gradients not implemented");
}
@ -186,7 +186,7 @@ void MLIAPModelPython::compute_force_gradients(class MLIAPData* data)
count the number of non-zero entries in gamma matrix
---------------------------------------------------------------------- */
int MLIAPModelPython::get_gamma_nnz(class MLIAPData* data)
int MLIAPModelPython::get_gamma_nnz(class MLIAPData *)
{
// todo: get_gamma_nnz
return 0;

1
src/REPLICA/compute_event_displace.cpp
View File

@ -28,7 +28,6 @@
using namespace LAMMPS_NS;
#define INVOKED_SCALAR 1
/* ---------------------------------------------------------------------- */

4
src/SPIN/pair_spin_exchange_biquadratic.cpp
View File

@ -474,7 +474,7 @@ double PairSpinExchangeBiquadratic::compute_energy(int i, int j, double rsq,
int *type = atom->type;
int itype,jtype;
double Jex,Kex,ra,sdots;
double rj,rk,r2j,r2k,ir3j,ir3k;
double rj,rk,r2j,r2k;
double energy = 0.0;
itype = type[i];
jtype = type[j];
@ -482,10 +482,8 @@ double PairSpinExchangeBiquadratic::compute_energy(int i, int j, double rsq,
ra = sqrt(rsq);
rj = ra/J3[itype][jtype];
r2j = rsq/J3[itype][jtype]/J3[itype][jtype];
ir3j = 1.0/(rj*rj*rj);
rk = ra/K3[itype][jtype];
r2k = rsq/K3[itype][jtype]/K3[itype][jtype];
ir3k = 1.0/(rk*rk*rk);
Jex = 4.0*J1_mech[itype][jtype]*r2j;
Jex *= (1.0-J2[itype][jtype]*r2j);

5
src/USER-DIFFRACTION/fix_saed_vtk.cpp
View File

@ -36,7 +36,6 @@ using namespace FixConst;
enum{ONE,RUNNING,WINDOW};
enum{FIRST,MULTI};
#define INVOKED_VECTOR 2
/* ---------------------------------------------------------------------- */
@ -326,9 +325,9 @@ void FixSAEDVTK::invoke_vector(bigint ntimestep)
Compute *compute = modify->compute[icompute];
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
double *vector = compute->vector;

11
src/USER-MISC/fix_ave_correlate_long.cpp
View File

@ -42,9 +42,6 @@ using namespace FixConst;
enum{COMPUTE,FIX,VARIABLE};
enum{AUTO,UPPER,LOWER,AUTOUPPER,AUTOLOWER,FULL};
#define INVOKED_SCALAR 1
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
static const char cite_fix_ave_correlate_long[] =
"fix ave/correlate/long command:\n\n"
@ -448,15 +445,15 @@ void FixAveCorrelateLong::end_of_step()
Compute *compute = modify->compute[m];
if (argindex[i] == 0) {
if (!(compute->invoked_flag & INVOKED_SCALAR)) {
if (!(compute->invoked_flag & Compute::INVOKED_SCALAR)) {
compute->compute_scalar();
compute->invoked_flag |= INVOKED_SCALAR;
compute->invoked_flag |= Compute::INVOKED_SCALAR;
}
scalar = compute->scalar;
} else {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
scalar = compute->vector[argindex[i]-1];
}

4
src/USER-PHONON/fix_phonon.cpp
View File

@ -42,8 +42,6 @@
using namespace LAMMPS_NS;
using namespace FixConst;
#define INVOKED_SCALAR 1
#define INVOKED_VECTOR 2
#define MAXLINE 512
enum{FORWARD=-1,BACKWARD=1};
@ -338,7 +336,7 @@ void FixPhonon::end_of_step()
double xcur[3];
// to get the current temperature
if (!(temperature->invoked_flag & INVOKED_VECTOR)) temperature->compute_vector();
if (!(temperature->invoked_flag & Compute::INVOKED_VECTOR)) temperature->compute_vector();
for (idim = 0; idim < sysdim; ++idim) TempSum[idim] += temperature->vector[idim];
// evaluate R(r) on local proc

1
src/USER-PLUMED/fix_plumed.cpp
View File

@ -49,7 +49,6 @@ static char plumed_default_kernel[] = "PLUMED_KERNEL=" PLUMED_QUOTE(__PLUMED_DEF
using namespace LAMMPS_NS;
using namespace FixConst;
#define INVOKED_SCALAR 1
FixPlumed::FixPlumed(LAMMPS *lmp, int narg, char **arg) :
Fix(lmp, narg, arg),

13
src/USER-REAXC/reaxc_types.h
View File

@ -862,14 +862,23 @@ struct cubic_spline_coef
cubic_spline_coef() {}
LAMMPS_INLINE
void operator = (const cubic_spline_coef& rhs) {
cubic_spline_coef(const cubic_spline_coef &_c) {
a = _c.a;
b = _c.b;
c = _c.c;
d = _c.d;
}
LAMMPS_INLINE
void operator=(const cubic_spline_coef &rhs) {
a = rhs.a;
b = rhs.b;
c = rhs.c;
d = rhs.d;
}
LAMMPS_INLINE
void operator = (const cubic_spline_coef& rhs) volatile {
void operator=(const cubic_spline_coef &rhs) volatile {
a = rhs.a;
b = rhs.b;
c = rhs.c;

5
src/USER-VTK/dump_vtk.cpp
View File

@ -89,7 +89,6 @@ enum{X,Y,Z, // required for vtk, must come first
enum{LT,LE,GT,GE,EQ,NEQ};
enum{VTK,VTP,VTU,PVTP,PVTU}; // file formats
#define INVOKED_PERATOM 8
#define ONEFIELD 32
#define DELTA 1048576
@ -302,9 +301,9 @@ int DumpVTK::count()
error->all(FLERR,"Compute used in dump between runs is not current");
} else {
for (i = 0; i < ncompute; i++) {
if (!(compute[i]->invoked_flag & INVOKED_PERATOM)) {
if (!(compute[i]->invoked_flag & Compute::INVOKED_PERATOM)) {
compute[i]->compute_peratom();
compute[i]->invoked_flag |= INVOKED_PERATOM;
compute[i]->invoked_flag |= Compute::INVOKED_PERATOM;
}
}
}

2
src/compute.cpp
View File

@ -84,7 +84,7 @@ Compute::Compute(LAMMPS *lmp, int narg, char **arg) :
invoked_scalar = invoked_vector = invoked_array = -1;
invoked_peratom = invoked_local = -1;
invoked_flag = 0;
invoked_flag = INVOKED_NONE;
// set modify defaults

8
src/compute.h
View File

@ -20,6 +20,14 @@ namespace LAMMPS_NS {
class Compute : protected Pointers {
public:
enum {
INVOKED_NONE = 0,
INVOKED_SCALAR = 1<<0,
INVOKED_VECTOR = 1<<1,
INVOKED_ARRAY = 1<<2,
INVOKED_PERATOM = 1<<3,
INVOKED_LOCAL = 1<<4,
};
static int instance_total; // # of Compute classes ever instantiated
char *id,*style;

5
src/compute_chunk_atom.cpp
View File

@ -47,7 +47,6 @@ enum{ONCE,NFREQ,EVERY}; // used in several files
enum{LIMITMAX,LIMITEXACT};
#define IDMAX 1024*1024
#define INVOKED_PERATOM 8
/* ---------------------------------------------------------------------- */
@ -943,9 +942,9 @@ void ComputeChunkAtom::assign_chunk_ids()
}
} else if (which == ArgInfo::COMPUTE) {
if (!(cchunk->invoked_flag & INVOKED_PERATOM)) {
if (!(cchunk->invoked_flag & Compute::INVOKED_PERATOM)) {
cchunk->compute_peratom();
cchunk->invoked_flag |= INVOKED_PERATOM;
cchunk->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (argindex == 0) {

12
src/compute_chunk_spread_atom.cpp
View File

@ -25,10 +25,6 @@
using namespace LAMMPS_NS;
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
#define INVOKED_PERATOM 8
/* ---------------------------------------------------------------------- */
ComputeChunkSpreadAtom::
@ -256,9 +252,9 @@ void ComputeChunkSpreadAtom::compute_peratom()
Compute *compute = modify->compute[n];
if (argindex[m] == 0) {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
double *cvector = compute->vector;
for (i = 0; i < nlocal; i++, ptr += nstride) {
@ -270,9 +266,9 @@ void ComputeChunkSpreadAtom::compute_peratom()
}
} else {
if (!(compute->invoked_flag & INVOKED_ARRAY)) {
if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= INVOKED_ARRAY;
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
int icol = argindex[m]-1;
double **carray = compute->array;

5
src/compute_coord_atom.cpp
View File

@ -32,7 +32,6 @@
using namespace LAMMPS_NS;
#define INVOKED_PERATOM 8
/* ---------------------------------------------------------------------- */
@ -198,9 +197,9 @@ void ComputeCoordAtom::compute_peratom()
}
if (cstyle == ORIENT) {
if (!(c_orientorder->invoked_flag & INVOKED_PERATOM)) {
if (!(c_orientorder->invoked_flag & Compute::INVOKED_PERATOM)) {
c_orientorder->compute_peratom();
c_orientorder->invoked_flag |= INVOKED_PERATOM;
c_orientorder->invoked_flag |= Compute::INVOKED_PERATOM;
}
nqlist = c_orientorder->nqlist;
normv = c_orientorder->array_atom;

15
src/compute_global_atom.cpp
View File

@ -27,9 +27,6 @@ using namespace LAMMPS_NS;
enum{VECTOR,ARRAY};
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
#define INVOKED_PERATOM 8
#define BIG 1.0e20
@ -303,9 +300,9 @@ void ComputeGlobalAtom::compute_peratom()
if (whichref == ArgInfo::COMPUTE) {
Compute *compute = modify->compute[ref2index];
if (!(compute->invoked_flag & INVOKED_PERATOM)) {
if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (indexref == 0) {
@ -360,9 +357,9 @@ void ComputeGlobalAtom::compute_peratom()
if (which[m] == ArgInfo::COMPUTE) {
Compute *compute = modify->compute[value2index[m]];
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
source = compute->vector;
@ -418,9 +415,9 @@ void ComputeGlobalAtom::compute_peratom()
if (which[m] == ArgInfo::COMPUTE) {
Compute *compute = modify->compute[value2index[m]];
if (!(compute->invoked_flag & INVOKED_ARRAY)) {
if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= INVOKED_ARRAY;
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
double **compute_array = compute->array;

13
src/compute_heat_flux.cpp
View File

@ -27,7 +27,6 @@
using namespace LAMMPS_NS;
#define INVOKED_PERATOM 8
/* ---------------------------------------------------------------------- */
@ -108,17 +107,17 @@ void ComputeHeatFlux::compute_vector()
// invoke 3 computes if they haven't been already
if (!(c_ke->invoked_flag & INVOKED_PERATOM)) {
if (!(c_ke->invoked_flag & Compute::INVOKED_PERATOM)) {
c_ke->compute_peratom();
c_ke->invoked_flag |= INVOKED_PERATOM;
c_ke->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (!(c_pe->invoked_flag & INVOKED_PERATOM)) {
if (!(c_pe->invoked_flag & Compute::INVOKED_PERATOM)) {
c_pe->compute_peratom();
c_pe->invoked_flag |= INVOKED_PERATOM;
c_pe->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (!(c_stress->invoked_flag & INVOKED_PERATOM)) {
if (!(c_stress->invoked_flag & Compute::INVOKED_PERATOM)) {
c_stress->compute_peratom();
c_stress->invoked_flag |= INVOKED_PERATOM;
c_stress->invoked_flag |= Compute::INVOKED_PERATOM;
}
// heat flux vector = jc[3] + jv[3]

13
src/compute_reduce.cpp
View File

@ -27,11 +27,6 @@
using namespace LAMMPS_NS;
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
#define INVOKED_PERATOM 8
#define INVOKED_LOCAL 16
#define BIG 1.0e20
/* ---------------------------------------------------------------------- */
@ -495,9 +490,9 @@ double ComputeReduce::compute_one(int m, int flag)
Compute *compute = modify->compute[vidx];
if (flavor[m] == PERATOM) {
if (!(compute->invoked_flag & INVOKED_PERATOM)) {
if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (aidx == 0) {
@ -518,9 +513,9 @@ double ComputeReduce::compute_one(int m, int flag)
}
} else if (flavor[m] == LOCAL) {
if (!(compute->invoked_flag & INVOKED_LOCAL)) {
if (!(compute->invoked_flag & Compute::INVOKED_LOCAL)) {
compute->compute_local();
compute->invoked_flag |= INVOKED_LOCAL;
compute->invoked_flag |= Compute::INVOKED_LOCAL;
}
if (aidx == 0) {

5
src/compute_reduce_chunk.cpp
View File

@ -31,7 +31,6 @@ using namespace LAMMPS_NS;
enum{SUM,MINN,MAXX};
#define INVOKED_PERATOM 8
#define BIG 1.0e20
@ -353,9 +352,9 @@ void ComputeReduceChunk::compute_one(int m, double *vchunk, int nstride)
if (which[m] == ArgInfo::COMPUTE) {
Compute *compute = modify->compute[vidx];
if (!(compute->invoked_flag & INVOKED_PERATOM)) {
if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (argindex[m] == 0) {

13
src/compute_reduce_region.cpp
View File

@ -28,11 +28,6 @@
using namespace LAMMPS_NS;
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
#define INVOKED_PERATOM 8
#define INVOKED_LOCAL 16
#define BIG 1.0e20
/* ---------------------------------------------------------------------- */
@ -107,9 +102,9 @@ double ComputeReduceRegion::compute_one(int m, int flag)
Compute *compute = modify->compute[n];
if (flavor[m] == PERATOM) {
if (!(compute->invoked_flag & INVOKED_PERATOM)) {
if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (j == 0) {
@ -132,9 +127,9 @@ double ComputeReduceRegion::compute_one(int m, int flag)
}
} else if (flavor[m] == LOCAL) {
if (!(compute->invoked_flag & INVOKED_LOCAL)) {
if (!(compute->invoked_flag & Compute::INVOKED_LOCAL)) {
compute->compute_local();
compute->invoked_flag |= INVOKED_LOCAL;
compute->invoked_flag |= Compute::INVOKED_LOCAL;
}
if (j == 0) {

11
src/compute_slice.cpp
View File

@ -24,9 +24,6 @@
using namespace LAMMPS_NS;
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
/* ---------------------------------------------------------------------- */
ComputeSlice::ComputeSlice(LAMMPS *lmp, int narg, char **arg) :
@ -272,9 +269,9 @@ void ComputeSlice::extract_one(int m, double *vec, int stride)
Compute *compute = modify->compute[value2index[m]];
if (argindex[m] == 0) {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
double *cvector = compute->vector;
j = 0;
@ -284,9 +281,9 @@ void ComputeSlice::extract_one(int m, double *vec, int stride)
}
} else {
if (!(compute->invoked_flag & INVOKED_ARRAY)) {
if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= INVOKED_ARRAY;
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
double **carray = compute->array;
int icol = argindex[m]-1;

5
src/dump_custom.cpp
View File

@ -46,7 +46,6 @@ enum{ID,MOL,PROC,PROCP1,TYPE,ELEMENT,MASS,
COMPUTE,FIX,VARIABLE,INAME,DNAME};
enum{LT,LE,GT,GE,EQ,NEQ,XOR};
#define INVOKED_PERATOM 8
#define ONEFIELD 32
#define DELTA 1048576
@ -585,9 +584,9 @@ int DumpCustom::count()
error->all(FLERR,"Compute used in dump between runs is not current");
} else {
for (i = 0; i < ncompute; i++) {
if (!(compute[i]->invoked_flag & INVOKED_PERATOM)) {
if (!(compute[i]->invoked_flag & Compute::INVOKED_PERATOM)) {
compute[i]->compute_peratom();
compute[i]->invoked_flag |= INVOKED_PERATOM;
compute[i]->invoked_flag |= Compute::INVOKED_PERATOM;
}
}
}

5
src/dump_local.cpp
View File

@ -28,7 +28,6 @@ using namespace LAMMPS_NS;
enum{INT,DOUBLE};
#define INVOKED_LOCAL 16
#define ONEFIELD 32
#define DELTA 1048576
@ -298,9 +297,9 @@ int DumpLocal::count()
error->all(FLERR,"Compute used in dump between runs is not current");
} else {
for (i = 0; i < ncompute; i++) {
if (!(compute[i]->invoked_flag & INVOKED_LOCAL)) {
if (!(compute[i]->invoked_flag & Compute::INVOKED_LOCAL)) {
compute[i]->compute_local();
compute[i]->invoked_flag |= INVOKED_LOCAL;
compute[i]->invoked_flag |= Compute::INVOKED_LOCAL;
}
}
}

6
src/fix_ave_atom.cpp
View File

@ -28,8 +28,6 @@
using namespace LAMMPS_NS;
using namespace FixConst;
#define INVOKED_PERATOM 8
/* ---------------------------------------------------------------------- */
FixAveAtom::FixAveAtom(LAMMPS *lmp, int narg, char **arg) :
@ -326,9 +324,9 @@ void FixAveAtom::end_of_step()
} else if (which[m] == ArgInfo::COMPUTE) {
Compute *compute = modify->compute[n];
if (!(compute->invoked_flag & INVOKED_PERATOM)) {
if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (j == 0) {

5
src/fix_ave_chunk.cpp
View File

@ -39,7 +39,6 @@ enum{SAMPLE,ALL};
enum{NOSCALE,ATOM};
enum{ONE,RUNNING,WINDOW};
#define INVOKED_PERATOM 8
/* ---------------------------------------------------------------------- */
@ -738,9 +737,9 @@ void FixAveChunk::end_of_step()
} else if (which[m] == COMPUTE) {
Compute *compute = modify->compute[n];
if (!(compute->invoked_flag & INVOKED_PERATOM)) {
if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
double *vector = compute->vector_atom;
double **array = compute->array_atom;

11
src/fix_ave_correlate.cpp
View File

@ -37,9 +37,6 @@ enum{COMPUTE,FIX,VARIABLE};
enum{ONE,RUNNING};
enum{AUTO,UPPER,LOWER,AUTOUPPER,AUTOLOWER,FULL};
#define INVOKED_SCALAR 1
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
/* ---------------------------------------------------------------------- */
@ -442,15 +439,15 @@ void FixAveCorrelate::end_of_step()
Compute *compute = modify->compute[m];
if (argindex[i] == 0) {
if (!(compute->invoked_flag & INVOKED_SCALAR)) {
if (!(compute->invoked_flag & Compute::INVOKED_SCALAR)) {
compute->compute_scalar();
compute->invoked_flag |= INVOKED_SCALAR;
compute->invoked_flag |= Compute::INVOKED_SCALAR;
}
scalar = compute->scalar;
} else {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
scalar = compute->vector[argindex[i]-1];
}

29
src/fix_ave_histo.cpp
View File

@ -34,11 +34,6 @@ enum{SCALAR,VECTOR,WINDOW};
enum{DEFAULT,GLOBAL,PERATOM,LOCAL};
enum{IGNORE,END,EXTRA};
#define INVOKED_SCALAR 1
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
#define INVOKED_PERATOM 8
#define INVOKED_LOCAL 16
#define BIG 1.0e20
/* ---------------------------------------------------------------------- */
@ -638,29 +633,29 @@ void FixAveHisto::end_of_step()
if (kind == GLOBAL && mode == SCALAR) {
if (j == 0) {
if (!(compute->invoked_flag & INVOKED_SCALAR)) {
if (!(compute->invoked_flag & Compute::INVOKED_SCALAR)) {
compute->compute_scalar();
compute->invoked_flag |= INVOKED_SCALAR;
compute->invoked_flag |= Compute::INVOKED_SCALAR;
}
bin_one(compute->scalar);
} else {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
bin_one(compute->vector[j-1]);
}
} else if (kind == GLOBAL && mode == VECTOR) {
if (j == 0) {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
bin_vector(compute->size_vector,compute->vector,1);
} else {
if (!(compute->invoked_flag & INVOKED_ARRAY)) {
if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= INVOKED_ARRAY;
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
if (compute->array)
bin_vector(compute->size_array_rows,&compute->array[0][j-1],
@ -668,9 +663,9 @@ void FixAveHisto::end_of_step()
}
} else if (kind == PERATOM) {
if (!(compute->invoked_flag & INVOKED_PERATOM)) {
if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (j == 0)
bin_atoms(compute->vector_atom,1);
@ -678,9 +673,9 @@ void FixAveHisto::end_of_step()
bin_atoms(&compute->array_atom[0][j-1],compute->size_peratom_cols);
} else if (kind == LOCAL) {
if (!(compute->invoked_flag & INVOKED_LOCAL)) {
if (!(compute->invoked_flag & Compute::INVOKED_LOCAL)) {
compute->compute_local();
compute->invoked_flag |= INVOKED_LOCAL;
compute->invoked_flag |= Compute::INVOKED_LOCAL;
}
if (j == 0)
bin_vector(compute->size_local_rows,compute->vector_local,1);

53
src/fix_ave_histo_weight.cpp
View File

@ -37,11 +37,6 @@ enum{DEFAULT,GLOBAL,PERATOM,LOCAL};
enum{IGNORE,END,EXTRA};
enum{SINGLE,VALUE};
#define INVOKED_SCALAR 1
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
#define INVOKED_PERATOM 8
#define INVOKED_LOCAL 16
#define BIG 1.0e20
@ -155,38 +150,38 @@ void FixAveHistoWeight::end_of_step()
if (kind == GLOBAL && mode == SCALAR) {
if (j == 0) {
if (!(compute->invoked_flag & INVOKED_SCALAR)) {
if (!(compute->invoked_flag & Compute::INVOKED_SCALAR)) {
compute->compute_scalar();
compute->invoked_flag |= INVOKED_SCALAR;
compute->invoked_flag |= Compute::INVOKED_SCALAR;
}
weight = compute->scalar;
} else {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
weight = compute->vector[j-1];
}
} else if (kind == GLOBAL && mode == VECTOR) {
if (j == 0) {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
weights = compute->vector;
stride = 1;
} else {
if (!(compute->invoked_flag & INVOKED_ARRAY)) {
if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= INVOKED_ARRAY;
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
if (compute->array) weights = &compute->array[0][j-1];
stride = compute->size_array_cols;
}
} else if (kind == PERATOM) {
if (!(compute->invoked_flag & INVOKED_PERATOM)) {
if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (j == 0) {
weights = compute->vector_atom;
@ -196,9 +191,9 @@ void FixAveHistoWeight::end_of_step()
stride = compute->size_peratom_cols;
}
} else if (kind == LOCAL) {
if (!(compute->invoked_flag & INVOKED_LOCAL)) {
if (!(compute->invoked_flag & Compute::INVOKED_LOCAL)) {
compute->compute_local();
compute->invoked_flag |= INVOKED_LOCAL;
compute->invoked_flag |= Compute::INVOKED_LOCAL;
}
if (j == 0) {
weights = compute->vector_local;
@ -283,30 +278,30 @@ void FixAveHistoWeight::end_of_step()
Compute *compute = modify->compute[m];
if (kind == GLOBAL && mode == SCALAR) {
if (j == 0) {
if (!(compute->invoked_flag & INVOKED_SCALAR)) {
if (!(compute->invoked_flag & Compute::INVOKED_SCALAR)) {
compute->compute_scalar();
compute->invoked_flag |= INVOKED_SCALAR;
compute->invoked_flag |= Compute::INVOKED_SCALAR;
}
bin_one_weights(compute->scalar,weight);
} else {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
bin_one_weights(compute->vector[j-1],weight);
}
} else if (kind == GLOBAL && mode == VECTOR) {
if (j == 0) {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
bin_vector_weights(compute->size_vector,compute->vector,1,
weights,stride);
} else {
if (!(compute->invoked_flag & INVOKED_ARRAY)) {
if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= INVOKED_ARRAY;
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
if (compute->array)
bin_vector_weights(compute->size_array_rows,&compute->array[0][j-1],
@ -314,9 +309,9 @@ void FixAveHistoWeight::end_of_step()
}
} else if (kind == PERATOM) {
if (!(compute->invoked_flag & INVOKED_PERATOM)) {
if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (j == 0)
bin_atoms_weights(compute->vector_atom,1,weights, stride);
@ -325,9 +320,9 @@ void FixAveHistoWeight::end_of_step()
compute->size_peratom_cols,weights,stride);
} else if (kind == LOCAL) {
if (!(compute->invoked_flag & INVOKED_LOCAL)) {
if (!(compute->invoked_flag & Compute::INVOKED_LOCAL)) {
compute->compute_local();
compute->invoked_flag |= INVOKED_LOCAL;
compute->invoked_flag |= Compute::INVOKED_LOCAL;
}
if (j == 0)
bin_vector_weights(compute->size_local_rows,

19
src/fix_ave_time.cpp
View File

@ -35,9 +35,6 @@ enum{COMPUTE,FIX,VARIABLE};
enum{ONE,RUNNING,WINDOW};
enum{SCALAR,VECTOR};
#define INVOKED_SCALAR 1
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
/* ---------------------------------------------------------------------- */
@ -587,15 +584,15 @@ void FixAveTime::invoke_scalar(bigint ntimestep)
Compute *compute = modify->compute[m];
if (argindex[i] == 0) {
if (!(compute->invoked_flag & INVOKED_SCALAR)) {
if (!(compute->invoked_flag & Compute::INVOKED_SCALAR)) {
compute->compute_scalar();
compute->invoked_flag |= INVOKED_SCALAR;
compute->invoked_flag |= Compute::INVOKED_SCALAR;
}
scalar = compute->scalar;
} else {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
if (varlen[i] && compute->size_vector < argindex[i]) scalar = 0.0;
else scalar = compute->vector[argindex[i]-1];
@ -771,18 +768,18 @@ void FixAveTime::invoke_vector(bigint ntimestep)
Compute *compute = modify->compute[m];
if (argindex[j] == 0) {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
double *cvector = compute->vector;
for (i = 0; i < nrows; i++)
column[i] = cvector[i];
} else {
if (!(compute->invoked_flag & INVOKED_ARRAY)) {
if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= INVOKED_ARRAY;
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
double **carray = compute->array;
int icol = argindex[j]-1;

10
src/fix_controller.cpp
View File

@ -27,8 +27,6 @@ using namespace FixConst;
enum{COMPUTE,FIX,VARIABLE};
#define INVOKED_SCALAR 1
#define INVOKED_VECTOR 2
/* ---------------------------------------------------------------------- */
@ -200,15 +198,15 @@ void FixController::end_of_step()
if (pvwhich == COMPUTE) {
if (pvindex == 0) {
if (!(pcompute->invoked_flag & INVOKED_SCALAR)) {
if (!(pcompute->invoked_flag & Compute::INVOKED_SCALAR)) {
pcompute->compute_scalar();
pcompute->invoked_flag |= INVOKED_SCALAR;
pcompute->invoked_flag |= Compute::INVOKED_SCALAR;
}
current = pcompute->scalar;
} else {
if (!(pcompute->invoked_flag & INVOKED_VECTOR)) {
if (!(pcompute->invoked_flag & Compute::INVOKED_VECTOR)) {
pcompute->compute_vector();
pcompute->invoked_flag |= INVOKED_VECTOR;
pcompute->invoked_flag |= Compute::INVOKED_VECTOR;
}
current = pcompute->vector[pvindex-1];
}

5
src/fix_store_state.cpp
View File

@ -32,7 +32,6 @@ using namespace FixConst;
enum{KEYWORD,COMPUTE,FIX,VARIABLE,DNAME,INAME};
#define INVOKED_PERATOM 8
/* ---------------------------------------------------------------------- */
@ -495,9 +494,9 @@ void FixStoreState::end_of_step()
if (which[m] == COMPUTE) {
Compute *compute = modify->compute[n];
if (!(compute->invoked_flag & INVOKED_PERATOM)) {
if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (j == 0) {

11
src/fix_vector.cpp
View File

@ -30,9 +30,6 @@ enum{COMPUTE,FIX,VARIABLE};
enum{ONE,RUNNING,WINDOW};
enum{SCALAR,VECTOR};
#define INVOKED_SCALAR 1
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
/* ---------------------------------------------------------------------- */
@ -272,15 +269,15 @@ void FixVector::end_of_step()
Compute *compute = modify->compute[m];
if (argindex[i] == 0) {
if (!(compute->invoked_flag & INVOKED_SCALAR)) {
if (!(compute->invoked_flag & Compute::INVOKED_SCALAR)) {
compute->compute_scalar();
compute->invoked_flag |= INVOKED_SCALAR;
compute->invoked_flag |= Compute::INVOKED_SCALAR;
}
result[i] = compute->scalar;
} else {
if (!(compute->invoked_flag & INVOKED_VECTOR)) {
if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
result[i] = compute->vector[argindex[i]-1];
}

2
src/modify.cpp
View File

@ -1345,7 +1345,7 @@ int Modify::find_compute(const std::string &id)
void Modify::clearstep_compute()
{
for (int icompute = 0; icompute < ncompute; icompute++)
compute[icompute]->invoked_flag = 0;
compute[icompute]->invoked_flag = Compute::INVOKED_NONE;
}
/* ----------------------------------------------------------------------

88
src/thermo.cpp
View File

@ -73,9 +73,6 @@ enum{ONELINE,MULTILINE};
enum{INT,FLOAT,BIGINT};
enum{SCALAR,VECTOR,ARRAY};
#define INVOKED_SCALAR 1
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
#define DELTA 8
@ -339,19 +336,19 @@ void Thermo::compute(int flag)
for (i = 0; i < ncompute; i++)
if (compute_which[i] == SCALAR) {
if (!(computes[i]->invoked_flag & INVOKED_SCALAR)) {
if (!(computes[i]->invoked_flag & Compute::INVOKED_SCALAR)) {
computes[i]->compute_scalar();
computes[i]->invoked_flag |= INVOKED_SCALAR;
computes[i]->invoked_flag |= Compute::INVOKED_SCALAR;
}
} else if (compute_which[i] == VECTOR) {
if (!(computes[i]->invoked_flag & INVOKED_VECTOR)) {
if (!(computes[i]->invoked_flag & Compute::INVOKED_VECTOR)) {
computes[i]->compute_vector();
computes[i]->invoked_flag |= INVOKED_VECTOR;
computes[i]->invoked_flag |= Compute::INVOKED_VECTOR;
}
} else if (compute_which[i] == ARRAY) {
if (!(computes[i]->invoked_flag & INVOKED_ARRAY)) {
if (!(computes[i]->invoked_flag & Compute::INVOKED_ARRAY)) {
computes[i]->compute_array();
computes[i]->invoked_flag |= INVOKED_ARRAY;
computes[i]->invoked_flag |= Compute::INVOKED_ARRAY;
}
}
@ -381,6 +378,7 @@ void Thermo::compute(int flag)
if (me == 0) {
utils::logmesg(lmp,line);
if (screen && flushflag) fflush(screen);
if (logfile && flushflag) fflush(logfile);
}
@ -1161,9 +1159,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (temperature->invoked_scalar != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(temperature->invoked_flag & INVOKED_SCALAR)) {
} else if (!(temperature->invoked_flag & Compute::INVOKED_SCALAR)) {
temperature->compute_scalar();
temperature->invoked_flag |= INVOKED_SCALAR;
temperature->invoked_flag |= Compute::INVOKED_SCALAR;
}
compute_temp();
@ -1175,9 +1173,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (pressure->invoked_scalar != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(pressure->invoked_flag & INVOKED_SCALAR)) {
} else if (!(pressure->invoked_flag & Compute::INVOKED_SCALAR)) {
pressure->compute_scalar();
pressure->invoked_flag |= INVOKED_SCALAR;
pressure->invoked_flag |= Compute::INVOKED_SCALAR;
}
compute_press();
@ -1191,7 +1189,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
"is not current");
} else {
pe->compute_scalar();
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
}
compute_pe();
@ -1203,9 +1201,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (temperature->invoked_scalar != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(temperature->invoked_flag & INVOKED_SCALAR)) {
} else if (!(temperature->invoked_flag & Compute::INVOKED_SCALAR)) {
temperature->compute_scalar();
temperature->invoked_flag |= INVOKED_SCALAR;
temperature->invoked_flag |= Compute::INVOKED_SCALAR;
}
compute_ke();
@ -1219,7 +1217,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
"is not current");
} else {
pe->compute_scalar();
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
}
if (!temperature)
error->all(FLERR,"Thermo keyword in variable requires "
@ -1228,9 +1226,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (temperature->invoked_scalar != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(temperature->invoked_flag & INVOKED_SCALAR)) {
} else if (!(temperature->invoked_flag & Compute::INVOKED_SCALAR)) {
temperature->compute_scalar();
temperature->invoked_flag |= INVOKED_SCALAR;
temperature->invoked_flag |= Compute::INVOKED_SCALAR;
}
compute_etotal();
@ -1244,7 +1242,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
"is not current");
} else {
pe->compute_scalar();
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
}
if (!temperature)
error->all(FLERR,"Thermo keyword in variable requires "
@ -1253,9 +1251,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (temperature->invoked_scalar != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(temperature->invoked_flag & INVOKED_SCALAR)) {
} else if (!(temperature->invoked_flag & Compute::INVOKED_SCALAR)) {
temperature->compute_scalar();
temperature->invoked_flag |= INVOKED_SCALAR;
temperature->invoked_flag |= Compute::INVOKED_SCALAR;
}
if (!pressure)
error->all(FLERR,"Thermo keyword in variable requires "
@ -1264,9 +1262,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (pressure->invoked_scalar != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(pressure->invoked_flag & INVOKED_SCALAR)) {
} else if (!(pressure->invoked_flag & Compute::INVOKED_SCALAR)) {
pressure->compute_scalar();
pressure->invoked_flag |= INVOKED_SCALAR;
pressure->invoked_flag |= Compute::INVOKED_SCALAR;
}
compute_enthalpy();
@ -1276,7 +1274,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (!pe)
error->all(FLERR,
"Thermo keyword in variable requires thermo to use/init pe");
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
compute_evdwl();
} else if (strcmp(word,"ecoul") == 0) {
@ -1285,7 +1283,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (!pe)
error->all(FLERR,
"Thermo keyword in variable requires thermo to use/init pe");
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
compute_ecoul();
} else if (strcmp(word,"epair") == 0) {
@ -1294,7 +1292,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (!pe)
error->all(FLERR,
"Thermo keyword in variable requires thermo to use/init pe");
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
compute_epair();
} else if (strcmp(word,"ebond") == 0) {
@ -1303,7 +1301,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (!pe)
error->all(FLERR,
"Thermo keyword in variable requires thermo to use/init pe");
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
compute_ebond();
} else if (strcmp(word,"eangle") == 0) {
@ -1312,7 +1310,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (!pe)
error->all(FLERR,
"Thermo keyword in variable requires thermo to use/init pe");
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
compute_eangle();
} else if (strcmp(word,"edihed") == 0) {
@ -1321,7 +1319,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (!pe)
error->all(FLERR,
"Thermo keyword in variable requires thermo to use/init pe");
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
compute_edihed();
} else if (strcmp(word,"eimp") == 0) {
@ -1330,7 +1328,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (!pe)
error->all(FLERR,
"Thermo keyword in variable requires thermo to use/init pe");
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
compute_eimp();
} else if (strcmp(word,"emol") == 0) {
@ -1339,7 +1337,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (!pe)
error->all(FLERR,
"Thermo keyword in variable requires thermo to use/init pe");
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
compute_emol();
} else if (strcmp(word,"elong") == 0) {
@ -1348,7 +1346,7 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (!pe)
error->all(FLERR,
"Thermo keyword in variable requires thermo to use/init pe");
pe->invoked_flag |= INVOKED_SCALAR;
pe->invoked_flag |= Compute::INVOKED_SCALAR;
compute_elong();
} else if (strcmp(word,"etail") == 0) {
@ -1385,9 +1383,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (pressure->invoked_vector != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(pressure->invoked_flag & INVOKED_VECTOR)) {
} else if (!(pressure->invoked_flag & Compute::INVOKED_VECTOR)) {
pressure->compute_vector();
pressure->invoked_flag |= INVOKED_VECTOR;
pressure->invoked_flag |= Compute::INVOKED_VECTOR;
}
compute_pxx();
@ -1399,9 +1397,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (pressure->invoked_vector != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(pressure->invoked_flag & INVOKED_VECTOR)) {
} else if (!(pressure->invoked_flag & Compute::INVOKED_VECTOR)) {
pressure->compute_vector();
pressure->invoked_flag |= INVOKED_VECTOR;
pressure->invoked_flag |= Compute::INVOKED_VECTOR;
}
compute_pyy();
@ -1413,9 +1411,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (pressure->invoked_vector != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(pressure->invoked_flag & INVOKED_VECTOR)) {
} else if (!(pressure->invoked_flag & Compute::INVOKED_VECTOR)) {
pressure->compute_vector();
pressure->invoked_flag |= INVOKED_VECTOR;
pressure->invoked_flag |= Compute::INVOKED_VECTOR;
}
compute_pzz();
@ -1427,9 +1425,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (pressure->invoked_vector != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(pressure->invoked_flag & INVOKED_VECTOR)) {
} else if (!(pressure->invoked_flag & Compute::INVOKED_VECTOR)) {
pressure->compute_vector();
pressure->invoked_flag |= INVOKED_VECTOR;
pressure->invoked_flag |= Compute::INVOKED_VECTOR;
}
compute_pxy();
@ -1441,9 +1439,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (pressure->invoked_vector != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(pressure->invoked_flag & INVOKED_VECTOR)) {
} else if (!(pressure->invoked_flag & Compute::INVOKED_VECTOR)) {
pressure->compute_vector();
pressure->invoked_flag |= INVOKED_VECTOR;
pressure->invoked_flag |= Compute::INVOKED_VECTOR;
}
compute_pxz();
@ -1455,9 +1453,9 @@ int Thermo::evaluate_keyword(const char *word, double *answer)
if (pressure->invoked_vector != update->ntimestep)
error->all(FLERR,"Compute used in variable thermo keyword between runs "
"is not current");
} else if (!(pressure->invoked_flag & INVOKED_VECTOR)) {
} else if (!(pressure->invoked_flag & Compute::INVOKED_VECTOR)) {
pressure->compute_vector();
pressure->invoked_flag |= INVOKED_VECTOR;
pressure->invoked_flag |= Compute::INVOKED_VECTOR;
}
compute_pyz();
}

48
src/utils.cpp
View File

@ -588,6 +588,9 @@ std::string utils::utf8_subst(const std::string &line)
// UTF-8 2-byte character
if ((in[i] & 0xe0U) == 0xc0U) {
if ((i+1) < len) {
// NON-BREAKING SPACE (U+00A0)
if ((in[i] == 0xc2U) && (in[i+1] == 0xa0U))
out += ' ', ++i;
// MODIFIER LETTER PLUS SIGN (U+02D6)
if ((in[i] == 0xcbU) && (in[i+1] == 0x96U))
out += '+', ++i;
@ -598,6 +601,48 @@ std::string utils::utf8_subst(const std::string &line)
// UTF-8 3-byte character
} else if ((in[i] & 0xf0U) == 0xe0U) {
if ((i+2) < len) {
// EN QUAD (U+2000)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x80U))
out += ' ', i += 2;
// EM QUAD (U+2001)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x81U))
out += ' ', i += 2;
// EN SPACE (U+2002)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x82U))
out += ' ', i += 2;
// EM SPACE (U+2003)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x83U))
out += ' ', i += 2;
// THREE-PER-EM SPACE (U+2004)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x84U))
out += ' ', i += 2;
// FOUR-PER-EM SPACE (U+2005)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x85U))
out += ' ', i += 2;
// SIX-PER-EM SPACE (U+2006)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x86U))
out += ' ', i += 2;
// FIGURE SPACE (U+2007)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x87U))
out += ' ', i += 2;
// PUNCTUATION SPACE (U+2008)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x88U))
out += ' ', i += 2;
// THIN SPACE (U+2009)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x89U))
out += ' ', i += 2;
// HAIR SPACE (U+200A)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x8aU))
out += ' ', i += 2;
// ZERO WIDTH SPACE (U+200B)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0x8bU))
out += ' ', i += 2;
// NARROW NO-BREAK SPACE (U+202F)
if ((in[i] == 0xe2U) && (in[i+1] == 0x80U) && (in[i+2] == 0xafU))
out += ' ', i += 2;
// WORD JOINER (U+2060)
if ((in[i] == 0xe2U) && (in[i+1] == 0x81U) && (in[i+2] == 0xa0U))
out += ' ', i += 2;
// INVISIBLE SEPARATOR (U+2063)
if ((in[i] == 0xe2U) && (in[i+1] == 0x81U) && (in[i+2] == 0xa3U))
out += ' ', i += 2;
@ -607,6 +652,9 @@ std::string utils::utf8_subst(const std::string &line)
// MINUS SIGN (U+2212)
if ((in[i] == 0xe2U) && (in[i+1] == 0x88U) && (in[i+2] == 0x92U))
out += '-', i += 2;
// ZERO WIDTH NO-BREAK SPACE (U+FEFF)
if ((in[i] == 0xefU) && (in[i+1] == 0xbbU) && (in[i+2] == 0xbfU))
out += ' ', i += 2;
}
// UTF-8 4-byte character
} else if ((in[i] & 0xe8U) == 0xf0U) {

48
src/variable.cpp
View File

@ -72,10 +72,6 @@ enum{DONE,ADD,SUBTRACT,MULTIPLY,DIVIDE,CARAT,MODULO,UNARY,
enum{SUM,XMIN,XMAX,AVE,TRAP,SLOPE};
#define INVOKED_SCALAR 1
#define INVOKED_VECTOR 2
#define INVOKED_ARRAY 4
#define INVOKED_PERATOM 8
#define BIG 1.0e20
@ -1380,9 +1376,9 @@ double Variable::evaluate(char *str, Tree **tree, int ivar)
if (compute->invoked_scalar != update->ntimestep)
print_var_error(FLERR,"Compute used in variable between "
"runs is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_SCALAR)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_SCALAR)) {
compute->compute_scalar();
compute->invoked_flag |= INVOKED_SCALAR;
compute->invoked_flag |= Compute::INVOKED_SCALAR;
}
value1 = compute->scalar;
@ -1407,9 +1403,9 @@ double Variable::evaluate(char *str, Tree **tree, int ivar)
if (compute->invoked_vector != update->ntimestep)
print_var_error(FLERR,"Compute used in variable between runs "
"is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_VECTOR)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
if (compute->size_vector_variable &&
@ -1439,9 +1435,9 @@ double Variable::evaluate(char *str, Tree **tree, int ivar)
if (compute->invoked_array != update->ntimestep)
print_var_error(FLERR,"Compute used in variable between runs "
"is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_ARRAY)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= INVOKED_ARRAY;
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
if (compute->size_array_rows_variable &&
@ -1473,9 +1469,9 @@ double Variable::evaluate(char *str, Tree **tree, int ivar)
if (compute->invoked_vector != update->ntimestep)
print_var_error(FLERR,"Compute used in variable between "
"runs is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_VECTOR)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
Tree *newtree = new Tree();
@ -1505,9 +1501,9 @@ double Variable::evaluate(char *str, Tree **tree, int ivar)
if (compute->invoked_array != update->ntimestep)
print_var_error(FLERR,"Compute used in variable between "
"runs is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_ARRAY)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= INVOKED_ARRAY;
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
Tree *newtree = new Tree();
@ -1529,9 +1525,9 @@ double Variable::evaluate(char *str, Tree **tree, int ivar)
if (compute->invoked_peratom != update->ntimestep)
print_var_error(FLERR,"Compute used in variable "
"between runs is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_PERATOM)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
peratom2global(1,nullptr,compute->vector_atom,1,index1,
@ -1549,9 +1545,9 @@ double Variable::evaluate(char *str, Tree **tree, int ivar)
if (compute->invoked_peratom != update->ntimestep)
print_var_error(FLERR,"Compute used in variable "
"between runs is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_PERATOM)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (compute->array_atom)
@ -1578,9 +1574,9 @@ double Variable::evaluate(char *str, Tree **tree, int ivar)
if (compute->invoked_peratom != update->ntimestep)
print_var_error(FLERR,"Compute used in variable "
"between runs is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_PERATOM)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
Tree *newtree = new Tree();
@ -1610,9 +1606,9 @@ double Variable::evaluate(char *str, Tree **tree, int ivar)
if (compute->invoked_peratom != update->ntimestep)
print_var_error(FLERR,"Compute used in variable "
"between runs is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_PERATOM)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_PERATOM)) {
compute->compute_peratom();
compute->invoked_flag |= INVOKED_PERATOM;
compute->invoked_flag |= Compute::INVOKED_PERATOM;
}
Tree *newtree = new Tree();
@ -4137,9 +4133,9 @@ int Variable::special_function(char *word, char *contents, Tree **tree,
if (compute->invoked_vector != update->ntimestep)
print_var_error(FLERR,"Compute used in variable between runs "
"is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_VECTOR)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_VECTOR)) {
compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR;
compute->invoked_flag |= Compute::INVOKED_VECTOR;
}
nvec = compute->size_vector;
nstride = 1;
@ -4151,9 +4147,9 @@ int Variable::special_function(char *word, char *contents, Tree **tree,
if (compute->invoked_array != update->ntimestep)
print_var_error(FLERR,"Compute used in variable between runs "
"is not current",ivar);
} else if (!(compute->invoked_flag & INVOKED_ARRAY)) {
} else if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= INVOKED_ARRAY;
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
nvec = compute->size_array_rows;
nstride = compute->size_array_cols;

2
unittest/force-styles/tests/angle-quartic.yaml
View File

@ -1,7 +1,7 @@
---
lammps_version: 24 Aug 2020
date_generated: Tue Sep 15 09:44:35 202
epsilon: 2.5e-13
epsilon: 4e-13
prerequisites: ! |
atom full
angle quartic

2
unittest/force-styles/tests/atomic-pair-reax_c_lgvdw.yaml
View File

@ -1,7 +1,7 @@
---
lammps_version: 24 Aug 2020
date_generated: Tue Sep 15 09:44:25 202
epsilon: 1e-10
epsilon: 2e-10
prerequisites: ! |
pair reax/c
fix qeq/reax

2
unittest/force-styles/tests/fix-timestep-momentum.yaml
View File

@ -1,7 +1,7 @@
---
lammps_version: 24 Aug 2020
date_generated: Tue Sep 15 09:44:40 202
epsilon: 4e-14
epsilon: 5e-14
prerequisites: ! |
atom full
fix momentum

2
unittest/force-styles/tests/fix-timestep-temp_csvr.yaml
View File

@ -1,7 +1,7 @@
---
lammps_version: 24 Aug 2020
date_generated: Tue Sep 15 09:44:43 202
epsilon: 2e-14
epsilon: 3e-14
prerequisites: ! |
atom full
fix temp/csvr

2
unittest/force-styles/tests/mol-pair-tip4p_table.yaml
View File

@ -1,7 +1,7 @@
---
lammps_version: 24 Aug 2020
date_generated: Tue Sep 15 09:44:20 202
epsilon: 1e-13
epsilon: 2.5e-13
prerequisites: ! |
atom full
pair tip4p/long

1
unittest/python/python-open.py
View File

@ -4,6 +4,7 @@ from lammps import lammps
has_mpi=False
has_mpi4py=False
has_exceptions=False
try:
from mpi4py import __version__ as mpi4py_version
# tested to work with mpi4py versions 2 and 3