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

merge in current develop

Browse Source
This commit is contained in:
Steve Plimpton
2024-04-04 13:30:14 -06:00
parent 30f330718a 1529a61901
commit 6a2bcc7258
31 changed files with 567 additions and 953 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.github/CODEOWNERS vendored
View File

@ -83,7 +83,7 @@ src/bond.* @sjplimp
src/comm*.* @sjplimp
src/compute.* @sjplimp
src/dihedral.* @sjplimp
src/domain.* @sjplimp
src/domain.* @sjplimp @stanmoore1
src/dump*.* @sjplimp
src/error.* @sjplimp
src/finish.* @sjplimp

4
doc/src/Developer_utils.rst
View File

@ -635,10 +635,10 @@ Tohoku University (under MIT license)
----------
.. doxygenfunction:: MathEigen::jacobi3(double const *const *mat, double *eval, double **evec)
.. doxygenfunction:: MathEigen::jacobi3(double const *const *mat, double *eval, double **evec, int sort)
:project: progguide
.. doxygenfunction:: MathEigen::jacobi3(double const mat[3][3], double *eval, double evec[3][3])
.. doxygenfunction:: MathEigen::jacobi3(double const mat[3][3], double *eval, double evec[3][3], int sort)
:project: progguide
---------------------------

49
doc/src/Errors_details.rst
View File

@ -13,15 +13,44 @@ discussions of such cases.
Unknown identifier in data file
-------------------------------
This error happens when LAMMPS encounters a line of text in an unexpected format
while reading a data file. This is most commonly cause by inconsistent header and
section data. The header section informs LAMMPS how many entries or lines are expected in the
various sections (like Atoms, Masses, Pair Coeffs, *etc.*\ ) of the data file.
If there is a mismatch, LAMMPS will either keep reading beyond the end of a section
or stop reading before the section has ended.
This error happens when LAMMPS encounters a line of text with an
unexpected keyword while :doc:`reading a data file <read_data>`. This
would be either header keywords or section header keywords. This is
most commonly due to a mistyped keyword or due to a keyword that is
inconsistent with the :doc:`atom style <atom_style>` used.
Such a mismatch can happen unexpectedly when the first line of the data
is *not* a comment as required by the format. That would result in
LAMMPS expecting, for instance, 0 atoms because the "atoms" header line
is treated as a comment.
The header section informs LAMMPS how many entries or lines are expected
in the various sections (like Atoms, Masses, Pair Coeffs, *etc.*\ ) of
the data file. If there is a mismatch, LAMMPS will either keep reading
beyond the end of a section or stop reading before the section has
ended. In that case the next line will not contain a recognized keyword.
Such a mismatch can also happen when the first line of the data
is *not* a comment as required by the format, but a line with a valid
header keyword. That would result in LAMMPS expecting, for instance,
0 atoms because the "atoms" header line is the first line and thus
treated as a comment.
Another possibility to trigger this error is to have a keyword in the
data file that corresponds to a fix (e.g. :doc:`fix cmap <fix_cmap>`)
but the :doc:`read_data <read_data>` command is missing the (optional)
arguments that identify the fix and the header keyword and section
keyword or those arguments are inconsistent with the keywords in the
data file.
.. _err0002:
Incorrect format in ... section of data file
--------------------------------------------
This error happens when LAMMPS reads the contents of a section of a
:doc:`data file <read_data>` and the number of parameters in the line
differs from what is expected. This most commonly happens, when the
atom style is different from what is expected for a specific data file
since changing the atom style usually changes the format of the line.
This error can also happen when the number of entries indicated in the
header of a data file (e.g. the number of atoms) is larger than the
number of lines provided (e.g. in the corresponding Atoms section)
and then LAMMPS will continue reading into the next section and that
would have a completely different format.

1
doc/src/fix_ave_correlate.rst
View File

@ -65,7 +65,6 @@ Examples
fix 1 all ave/correlate 1 50 10000 &
c_thermo_press[1] c_thermo_press[2] c_thermo_press[3] &
type upper ave running title1 "My correlation data"
fix 1 all ave/correlate 1 50 10000 c_thermo_press[*]
Description

13
doc/src/fix_ave_correlate_long.rst
View File

@ -20,11 +20,11 @@ Syntax
.. parsed-literal::
c_ID = global scalar calculated by a compute with ID
c_ID[I] = Ith component of global vector calculated by a compute with ID
c_ID[I] = Ith component of global vector calculated by a compute with ID, I can include wildcard (see below)
f_ID = global scalar calculated by a fix with ID
f_ID[I] = Ith component of global vector calculated by a fix with ID
f_ID[I] = Ith component of global vector calculated by a fix with ID, I can include wildcard (see below)
v_name = global value calculated by an equal-style variable with name
v_name[I] = Ith component of global vector calculated by a vector-style variable with name
v_name[I] = Ith component of a vector-style variable with name, I can include wildcard (see below)
* zero or more keyword/arg pairs may be appended
* keyword = *type* or *start* or *file* or *overwrite* or *title1* or *title2* or *ncorr* or *nlen* or *ncount*
@ -63,6 +63,7 @@ Examples
fix 1 all ave/correlate/long 1 10000 &
c_thermo_press[1] c_thermo_press[2] c_thermo_press[3] &
type upper title1 "My correlation data" nlen 15 ncount 3
fix 1 all ave/correlate/long 1 10000 c_thermo_press[*]
Description
"""""""""""
@ -80,8 +81,10 @@ specified values may represent calculations performed by computes and
fixes which store their own "group" definitions.
Each listed value can be the result of a compute or fix or the
evaluation of an equal-style variable. See the
:doc:`fix ave/correlate <fix_ave_correlate>` page for details.
evaluation of an equal-style or vector-style variable. For
vector-style variables, the specified indices can include a wildcard
character. See the :doc:`fix ave/correlate <fix_ave_correlate>` page
for details.
The *Nevery* and *Nfreq* arguments specify on what time steps the input
values will be used to calculate correlation data and the frequency

75
doc/src/fix_ttm.rst
View File

@ -136,23 +136,23 @@ transfer between the subsystems:
\bigtriangledown (\kappa_e \bigtriangledown T_e) -
g_p (T_e - T_a) + g_s T_a'
where C_e is the specific heat, rho_e is the density, kappa_e is the
thermal conductivity, T is temperature, the "e" and "a" subscripts
represent electronic and atomic subsystems respectively, g_p is the
coupling constant for the electron-ion interaction, and g_s is the
electron stopping coupling parameter. C_e, rho_e, and kappa_e are
specified as parameters to the fix. The other quantities are derived.
The form of the heat diffusion equation used here is almost the same
as that in equation 6 of :ref:`(Duffy) <Duffy>`, with the exception that the
electronic density is explicitly represented, rather than being part
of the specific heat parameter.
where :math:`C_e` is the specific heat, :math:`\rho_e` is the density,
:math:`\kappa_e` is the thermal conductivity, *T* is temperature, the
"e" and "a" subscripts represent electronic and atomic subsystems
respectively, :math:`g_p` is the coupling constant for the electron-ion
interaction, and :math:`g_s` is the electron stopping coupling
parameter. :math:`C_e`, :math:`\rho_e`, and :math:`\kappa_e` are
specified as parameters to the fix *ttm* or *ttm/grid*. The other
quantities are derived. The form of the heat diffusion equation used
here is almost the same as that in equation 6 of :ref:`(Duffy) <Duffy>`,
with the exception that the electronic density is explicitly
represented, rather than being part of the specific heat parameter.
Currently, the TTM fixes assume that none of the user-supplied
parameters will vary with temperature. Note that :ref:`(Duffy)
<Duffy>` used a tanh() functional form for the temperature dependence
of the electronic specific heat, but ignored temperature dependencies
of any of the other parameters. See more discussion below for fix
ttm/mod.
parameters will vary with temperature. Note that :ref:`(Duffy) <Duffy>`
used a tanh() functional form for the temperature dependence of the
electronic specific heat, but ignored temperature dependencies of any of
the other parameters. See more discussion below for fix *ttm/mod*.
.. note::
@ -265,27 +265,27 @@ heat sources (e.g. laser heating in ablation simulations):
\bigtriangledown (\kappa_e \bigtriangledown T_e) -
g_p (T_e - T_a) + g_s T_a' + \theta (x-x_{surface})I_0 \exp(-x/l_{skin})
where theta is the Heaviside step function, I_0 is the (absorbed)
laser pulse intensity for ablation simulations, l_skin is the depth
of skin-layer, and all other designations have the same meaning as in
the former equation. The duration of the pulse is set by the parameter
*tau* in the *init_file*.
where :math:`\theta` is the Heaviside step function, :math:`I_0` is the
(absorbed) laser pulse intensity for ablation simulations,
:math:`l_{skin}` is the depth of the skin-layer, and all other
designations have the same meaning as in the former equation. The
duration of the pulse is set by the parameter *tau* in the *init_file*.
Fix ttm/mod also allows users to specify the dependencies of C_e and
kappa_e on the electronic temperature. The specific heat is expressed
as
Fix *ttm/mod* also allows users to specify the dependencies of
:math:`C_e` and :math:`\kappa_e` on the electronic temperature. The
specific heat is expressed as
.. math::
C_e = C_0 + (a_0 + a_1 X + a_2 X^2 + a_3 X^3 + a_4 X^4) \exp (-(AX)^2)
where *X* = T_e/1000, and the thermal conductivity is defined as
kappa_e = D_e\*rho_e\*C_e, where D_e is the thermal diffusion
coefficient.
where :math:`X = \frac{T_e}{1000}`, and the thermal conductivity is
defined as :math:`\kappa_e = D_e \cdot rho_e \cdot C_e`, where
:math:`D_e` is the thermal diffusion coefficient.
Electronic pressure effects are included in the TTM model to account
for the blast force acting on ions because of electronic pressure
gradient (see :ref:`(Chen) <Chen>`, :ref:`(Norman) <Norman>`). The total force
Electronic pressure effects are included in the TTM model to account for
the blast force acting on ions because of electronic pressure gradient
(see :ref:`(Chen) <Chen>`, :ref:`(Norman) <Norman>`). The total force
acting on an ion is:
.. math::
@ -293,13 +293,14 @@ acting on an ion is:
{\vec F}_i = - \partial U / \partial {\vec r}_i + {\vec
F}_{langevin} - \nabla P_e/n_{ion}
where F_langevin is a force from Langevin thermostat simulating
electron-phonon coupling, and nabla P_e/n_ion is the electron blast
force.
where :math:`F_{langevin}` is a force from Langevin thermostat
simulating electron-phonon coupling, and :math:`\nabla P_e/n_{ion}` is
the electron blast force.
The electronic pressure is taken to be P_e = B\*rho_e\*C_e\*T_e
The electronic pressure is taken to be :math:`P_e = B \cdot rho_e \cdot
C_e \cdot T_e`
The current fix ttm/mod implementation allows TTM simulations with a
The current fix *ttm/mod* implementation allows TTM simulations with a
vacuum. The vacuum region is defined as the grid cells with zero
electronic temperature. The numerical scheme does not allow energy
exchange with such cells. Since the material can expand to previously
@ -319,10 +320,10 @@ electronic pressure gradient is calculated as
\frac{x}{x+\lambda}\frac{(C_e{}T_e)_{x+\Delta
x}-(C_e{}T_e)_{x}}{\Delta x} \right]
where lambda is the electron mean free path (see :ref:`(Norman) <Norman>`,
:ref:`(Pisarev) <Pisarev>`)
where :math:`\lambda` is the electron mean free path (see :ref:`(Norman)
<Norman>`, :ref:`(Pisarev) <Pisarev>`)
The fix ttm/mod parameter file *init_file* has the following syntax.
The fix *ttm/mod* parameter file *init_file* has the following syntax.
Every line with an odd number is considered as a comment and
ignored. The lines with the even numbers are treated as follows:

31
doc/src/variable.rst
View File

@ -1174,12 +1174,17 @@ custom atom properties are the same; just replace the leading "i" with
+--------+---------------+------------------------------------------+
| equal | i_name[I] | element of per-atom vector (I = atom ID) |
+--------+---------------+------------------------------------------+
| equal | i2_name[I][J] | element of per-atom array (I = atom ID) |
+--------+---------------+------------------------------------------+
+--------+---------------+------------------------------------------+
| vector | i_name[I] | element of per-atom vector (I = atom ID) |
+--------+---------------+------------------------------------------+
| vector | i2_name[I][J] | element of per-atom array (I = atom ID) |
+--------+---------------+------------------------------------------+
+--------+---------------+------------------------------------------+
| atom | i_name | per-atom vector |
+--------+---------------+------------------------------------------+
| atom | i2_name[I] | column of per-atom array |
+--------+---------------+------------------------------------------+
@ -1222,15 +1227,23 @@ table:
+--------+------------+------------------------------------------+
| equal | c_ID | global scalar |
+--------+------------+------------------------------------------+
| equal | c_ID[I] | element of global vector |
+--------+------------+------------------------------------------+
| equal | c_ID[I][J] | element of global array |
+--------+------------+------------------------------------------+
| equal | C_ID[I] | element of per-atom vector (I = atom ID) |
+--------+------------+------------------------------------------+
| equal | C_ID[I][J] | element of per-atom array (I = atom ID) |
+--------+------------+------------------------------------------+
+--------+------------+------------------------------------------+
| vector | c_ID | global vector |
+--------+------------+------------------------------------------+
| vector | c_ID[I] | column of global array |
+--------+------------+------------------------------------------+
+--------+------------+------------------------------------------+
| atom | c_ID | per-atom vector |
+--------+------------+------------------------------------------+
| atom | c_ID[I] | column of per-atom array |
+--------+------------+------------------------------------------+
@ -1286,15 +1299,23 @@ and atom-style variables are listed in the following table:
+--------+------------+------------------------------------------+
| equal | f_ID | global scalar |
+--------+------------+------------------------------------------+
| equal | f_ID[I] | element of global vector |
+--------+------------+------------------------------------------+
| equal | f_ID[I][J] | element of global array |
+--------+------------+------------------------------------------+
| equal | F_ID[I] | element of per-atom vector (I = atom ID) |
+--------+------------+------------------------------------------+
| equal | F_ID[I][J] | element of per-atom array (I = atom ID) |
+--------+------------+------------------------------------------+
+--------+------------+------------------------------------------+
| vector | f_ID | global vector |
+--------+------------+------------------------------------------+
| vector | f_ID[I] | column of global array |
+--------+------------+------------------------------------------+
+--------+------------+------------------------------------------+
| atom | f_ID | per-atom vector |
+--------+------------+------------------------------------------+
| atom | f_ID[I] | column of per-atom array |
+--------+------------+------------------------------------------+
@ -1365,17 +1386,27 @@ per-atom vector.
+--------+-----------+-----------------------------------------------------------------------------------+
| equal | v_name | global scalar from an equal-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+
| equal | v_name[I] | element of global vector from a vector-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+
| equal | v_name[I] | element of per-atom vector (I = atom ID) from an atom- or atomfile-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+
+--------+-----------+-----------------------------------------------------------------------------------+
| vector | v_name | global scalar from an equal-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+
| vector | v_name | global vector from a vector-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+
| vector | v_name[I] | element of global vector from a vector-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+
| vector | v_name[I] | element of per-atom vector (I = atom ID) from an atom- or atomfile-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+
+--------+-----------+-----------------------------------------------------------------------------------+
| atom | v_name | global scalar from an equal-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+
| atom | v_name | per-atom vector from an atom-style or atomfile-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+
| atom | v_name[I] | element of global vector from a vector-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+
| atom | v_name[I] | element of per-atom vector (I = atom ID) from an atom- or atomfile-style variable |
+--------+-----------+-----------------------------------------------------------------------------------+

5
lib/gpu/lal_base_amoeba.h
View File

@ -33,6 +33,7 @@
//#define ASYNC_DEVICE_COPY
#if 0
#if !defined(USE_OPENCL) && !defined(USE_HIP)
// temporary workaround for int2 also defined in cufft
#ifdef int2
@ -40,6 +41,7 @@
#endif
#include "cufft.h"
#endif
#endif
namespace LAMMPS_AL {
@ -313,10 +315,11 @@ class BaseAmoeba {
virtual int fphi_mpole();
virtual int polar_real(const int eflag, const int vflag) = 0;
#if 0
#if !defined(USE_OPENCL) && !defined(USE_HIP)
cufftHandle plan;
#endif
#endif
bool fft_plan_created;
};

6
src/BODY/body_rounded_polyhedron.cpp
View File

@ -99,10 +99,9 @@ int BodyRoundedPolyhedron::nedges(AtomVecBody::Bonus *bonus)
{
int nvertices = bonus->ivalue[0];
int nedges = bonus->ivalue[1];
//int nfaces = bonus->ivalue[2];
if (nvertices == 1) return 0;
else if (nvertices == 2) return 1;
return nedges; //(nvertices+nfaces-2); // Euler formula: V-E+F=2
return nedges;
}
/* ---------------------------------------------------------------------- */
@ -116,6 +115,9 @@ double *BodyRoundedPolyhedron::edges(AtomVecBody::Bonus *bonus)
int BodyRoundedPolyhedron::nfaces(AtomVecBody::Bonus *bonus)
{
int nvertices = bonus->ivalue[0];
if (nvertices < 3) return 0;
return bonus->ivalue[2];
}

37
src/BODY/pair_body_rounded_polygon.cpp
View File

@ -415,17 +415,14 @@ void PairBodyRoundedPolygon::init_style()
if (!avec)
error->all(FLERR,"Pair body/rounded/polygon requires atom style body");
if (strcmp(avec->bptr->style,"rounded/polygon") != 0)
error->all(FLERR,"Pair body/rounded/polygon requires "
"body style rounded/polygon");
error->all(FLERR,"Pair body/rounded/polygon requires body style rounded/polygon");
bptr = dynamic_cast<BodyRoundedPolygon *>(avec->bptr);
if (force->newton_pair == 0)
error->all(FLERR,"Pair style body/rounded/polygon requires "
"newton pair on");
error->all(FLERR,"Pair style body/rounded/polygon requires newton pair on");
if (comm->ghost_velocity == 0)
error->all(FLERR,"Pair body/rounded/polygon requires "
"ghost atoms store velocity");
error->all(FLERR,"Pair body/rounded/polygon requires ghost atoms store velocity");
neighbor->add_request(this);
@ -463,27 +460,24 @@ void PairBodyRoundedPolygon::init_style()
for (i = 1; i <= ntypes; i++)
maxerad[i] = merad[i] = 0;
int ipour;
for (ipour = 0; ipour < modify->nfix; ipour++)
if (strcmp(modify->fix[ipour]->style,"pour") == 0) break;
if (ipour == modify->nfix) ipour = -1;
Fix *fixpour = nullptr;
auto pours = modify->get_fix_by_style("^pour");
if (pours.size() > 0) fixpour = pours[0];
Fix *fixdep = nullptr;
auto deps = modify->get_fix_by_style("^deposit");
if (deps.size() > 0) fixdep = deps[0];
int idep;
for (idep = 0; idep < modify->nfix; idep++)
if (strcmp(modify->fix[idep]->style,"deposit") == 0) break;
if (idep == modify->nfix) idep = -1;
for (i = 1; i <= ntypes; i++) {
merad[i] = 0.0;
if (ipour >= 0) {
if (fixpour) {
itype = i;
merad[i] =
*((double *) modify->fix[ipour]->extract("radius",itype));
merad[i] = *((double *) fixpour->extract("radius",itype));
}
if (idep >= 0) {
if (fixdep) {
itype = i;
merad[i] =
*((double *) modify->fix[idep]->extract("radius",itype));
merad[i] = *((double *) fixdep->extract("radius",itype));
}
}
@ -570,8 +564,7 @@ void PairBodyRoundedPolygon::body2space(int i)
}
if ((body_num_edges > 0) && (edge_ends == nullptr))
error->one(FLERR,"Inconsistent edge data for body of atom {}",
atom->tag[i]);
error->one(FLERR,"Inconsistent edge data for body of atom {}", atom->tag[i]);
for (int m = 0; m < body_num_edges; m++) {
edge[nedge][0] = static_cast<int>(edge_ends[2*m+0]);

45
src/BODY/pair_body_rounded_polyhedron.cpp
View File

@ -222,8 +222,7 @@ void PairBodyRoundedPolyhedron::compute(int eflag, int vflag)
// sphere-sphere interaction
if (npi == 1 && npj == 1) {
sphere_against_sphere(i, j, itype, jtype, delx, dely, delz,
rsq, v, f, evflag);
sphere_against_sphere(i, j, itype, jtype, delx, dely, delz, rsq, v, f, evflag);
continue;
}
@ -391,20 +390,16 @@ void PairBodyRoundedPolyhedron::coeff(int narg, char **arg)
void PairBodyRoundedPolyhedron::init_style()
{
avec = dynamic_cast<AtomVecBody *>(atom->style_match("body"));
if (!avec) error->all(FLERR,"Pair body/rounded/polyhedron requires "
"atom style body");
if (!avec) error->all(FLERR,"Pair body/rounded/polyhedron requires atom style body");
if (strcmp(avec->bptr->style,"rounded/polyhedron") != 0)
error->all(FLERR,"Pair body/rounded/polyhedron requires "
"body style rounded/polyhedron");
error->all(FLERR,"Pair body/rounded/polyhedron requires body style rounded/polyhedron");
bptr = dynamic_cast<BodyRoundedPolyhedron *>(avec->bptr);
if (force->newton_pair == 0)
error->all(FLERR,"Pair style body/rounded/polyhedron requires "
"newton pair on");
error->all(FLERR,"Pair style body/rounded/polyhedron requires newton pair on");
if (comm->ghost_velocity == 0)
error->all(FLERR,"Pair body/rounded/polyhedron requires "
"ghost atoms store velocity");
error->all(FLERR,"Pair body/rounded/polyhedron requires ghost atoms store velocity");
neighbor->add_request(this);
@ -446,27 +441,23 @@ void PairBodyRoundedPolyhedron::init_style()
for (i = 1; i <= ntypes; i++)
maxerad[i] = merad[i] = 0;
int ipour;
for (ipour = 0; ipour < modify->nfix; ipour++)
if (strcmp(modify->fix[ipour]->style,"pour") == 0) break;
if (ipour == modify->nfix) ipour = -1;
Fix *fixpour = nullptr;
auto pours = modify->get_fix_by_style("^pour");
if (pours.size() > 0) fixpour = pours[0];
int idep;
for (idep = 0; idep < modify->nfix; idep++)
if (strcmp(modify->fix[idep]->style,"deposit") == 0) break;
if (idep == modify->nfix) idep = -1;
Fix *fixdep = nullptr;
auto deps = modify->get_fix_by_style("^deposit");
if (deps.size() > 0) fixdep = deps[0];
for (i = 1; i <= ntypes; i++) {
merad[i] = 0.0;
if (ipour >= 0) {
if (fixpour) {
itype = i;
merad[i] =
*((double *) modify->fix[ipour]->extract("radius",itype));
merad[i] = *((double *) fixpour->extract("radius",itype));
}
if (idep >= 0) {
if (fixdep) {
itype = i;
merad[i] =
*((double *) modify->fix[idep]->extract("radius",itype));
merad[i] = *((double *) fixdep->extract("radius",itype));
}
}
@ -558,8 +549,7 @@ void PairBodyRoundedPolyhedron::body2space(int i)
}
if ((body_num_edges > 0) && (edge_ends == nullptr))
error->one(FLERR,"Inconsistent edge data for body of atom {}",
atom->tag[i]);
error->one(FLERR,"Inconsistent edge data for body of atom {}", atom->tag[i]);
for (int m = 0; m < body_num_edges; m++) {
edge[nedge][0] = static_cast<int>(edge_ends[2*m+0]);
@ -585,8 +575,7 @@ void PairBodyRoundedPolyhedron::body2space(int i)
}
if ((body_num_faces > 0) && (face_pts == nullptr))
error->one(FLERR,"Inconsistent face data for body of atom {}",
atom->tag[i]);
error->one(FLERR,"Inconsistent face data for body of atom {}", atom->tag[i]);
for (int m = 0; m < body_num_faces; m++) {
for (int k = 0; k < MAX_FACE_SIZE; k++)

55
src/EXTRA-DUMP/dump_xtc.cpp
View File

@ -14,7 +14,7 @@
/* ----------------------------------------------------------------------
Contributing authors: Naveen Michaud-Agrawal (Johns Hopkins U)
open-source XDR routines from
Open Source XDR based I/O routines from
Frans van Hoesel (https://www.rug.nl/staff/f.h.j.van.hoesel/)
are included in this file
Axel Kohlmeyer (Temple U)
@ -35,27 +35,29 @@
#include "output.h"
#include "update.h"
#include "xdr_compat.h"
#include <climits>
#include <cmath>
#include <cstring>
using namespace LAMMPS_NS;
#define EPS 1e-5
#define XTC_MAGIC 1995
static constexpr double EPS = 1.0e-5;
static constexpr int XTC_MAGIC = 1995;
#define MYMIN(a,b) ((a) < (b) ? (a) : (b))
#define MYMAX(a,b) ((a) > (b) ? (a) : (b))
int xdropen(XDR *, const char *, const char *);
int xdrclose(XDR *);
void xdrfreebuf();
int xdr3dfcoord(XDR *, float *, int *, float *);
static int xdropen(XDR *, const char *, const char *);
static int xdrclose(XDR *);
static void xdrfreebuf();
static int xdr3dfcoord(XDR *, float *, int *, float *);
/* ---------------------------------------------------------------------- */
DumpXTC::DumpXTC(LAMMPS *lmp, int narg, char **arg) : Dump(lmp, narg, arg),
coords(nullptr)
DumpXTC::DumpXTC(LAMMPS *lmp, int narg, char **arg)
: Dump(lmp, narg, arg), coords(nullptr), xd(nullptr)
{
if (narg != 5) error->all(FLERR,"Illegal dump xtc command");
if (binary || compressed || multifile || multiproc)
@ -68,6 +70,7 @@ DumpXTC::DumpXTC(LAMMPS *lmp, int narg, char **arg) : Dump(lmp, narg, arg),
flush_flag = 0;
unwrap_flag = 0;
precision = 1000.0;
xd = new XDR;
// allocate global array for atom coords
@ -105,9 +108,10 @@ DumpXTC::~DumpXTC()
memory->destroy(coords);
if (me == 0) {
xdrclose(&xd);
xdrclose(xd);
xdrfreebuf();
}
delete xd;
}
/* ---------------------------------------------------------------------- */
@ -150,7 +154,8 @@ void DumpXTC::openfile()
fp = nullptr;
if (me == 0)
if (xdropen(&xd,filename,"w") == 0) error->one(FLERR,"Cannot open dump file");
if (xdropen(xd,filename,"w") == 0)
error->one(FLERR,"Cannot open XTC format dump file {}: {}", filename, utils::getsyserror());
}
/* ---------------------------------------------------------------------- */
@ -176,11 +181,11 @@ void DumpXTC::write_header(bigint nbig)
if (me != 0) return;
int tmp = XTC_MAGIC;
xdr_int(&xd,&tmp);
xdr_int(&xd,&n);
xdr_int(&xd,&ntimestep);
xdr_int(xd,&tmp);
xdr_int(xd,&n);
xdr_int(xd,&ntimestep);
float time_value = ntimestep * tfactor * update->dt;
xdr_float(&xd,&time_value);
xdr_float(xd,&time_value);
// cell basis vectors
if (domain->triclinic) {
@ -192,18 +197,18 @@ void DumpXTC::write_header(bigint nbig)
float xz = sfactor * domain->xz;
float yz = sfactor * domain->yz;
xdr_float(&xd,&xdim); xdr_float(&xd,&zero); xdr_float(&xd,&zero);
xdr_float(&xd,&xy ); xdr_float(&xd,&ydim); xdr_float(&xd,&zero);
xdr_float(&xd,&xz ); xdr_float(&xd,&yz ); xdr_float(&xd,&zdim);
xdr_float(xd,&xdim); xdr_float(xd,&zero); xdr_float(xd,&zero);
xdr_float(xd,&xy ); xdr_float(xd,&ydim); xdr_float(xd,&zero);
xdr_float(xd,&xz ); xdr_float(xd,&yz ); xdr_float(xd,&zdim);
} else {
float zero = 0.0;
float xdim = sfactor * (domain->boxhi[0] - domain->boxlo[0]);
float ydim = sfactor * (domain->boxhi[1] - domain->boxlo[1]);
float zdim = sfactor * (domain->boxhi[2] - domain->boxlo[2]);
xdr_float(&xd,&xdim); xdr_float(&xd,&zero); xdr_float(&xd,&zero);
xdr_float(&xd,&zero); xdr_float(&xd,&ydim); xdr_float(&xd,&zero);
xdr_float(&xd,&zero); xdr_float(&xd,&zero); xdr_float(&xd,&zdim);
xdr_float(xd,&xdim); xdr_float(xd,&zero); xdr_float(xd,&zero);
xdr_float(xd,&zero); xdr_float(xd,&ydim); xdr_float(xd,&zero);
xdr_float(xd,&zero); xdr_float(xd,&zero); xdr_float(xd,&zdim);
}
}
@ -328,7 +333,7 @@ double DumpXTC::memory_usage()
void DumpXTC::write_frame()
{
xdr3dfcoord(&xd,coords,&natoms,&precision);
xdr3dfcoord(xd,coords,&natoms,&precision);
}
// ----------------------------------------------------------------------
@ -406,7 +411,7 @@ static int magicints[] = {
|
| xdropen - open xdr file
|
| This versions differs from xdrstdio_create, because I need to know
| This version differs from xdrstdio_create, because I need to know
| the state of the file (read or write) so I can use xdr3dfcoord
| in eigther read or write mode, and the file descriptor
| so I can close the file (something xdr_destroy doesn't do).
@ -1048,7 +1053,7 @@ int xdr3dfcoord(XDR *xdrs, float *fp, int *size, float *precision)
}
if (buf[1] != 0) buf[0]++;
xdr_int(xdrs, &(buf[0])); /* buf[0] holds the length in bytes */
return errval * (xdr_opaque(xdrs, (caddr_t)&(buf[3]), (u_int)buf[0]));
return errval * (xdr_opaque(xdrs, (char *)&(buf[3]), (unsigned int)buf[0]));
} else {
/* xdrs is open for reading */
@ -1129,7 +1134,7 @@ int xdr3dfcoord(XDR *xdrs, float *fp, int *size, float *precision)
if (xdr_int(xdrs, &(buf[0])) == 0)
return 0;
if (xdr_opaque(xdrs, (caddr_t)&(buf[3]), (u_int)buf[0]) == 0)
if (xdr_opaque(xdrs, (char *)&(buf[3]), (unsigned int)buf[0]) == 0)
return 0;
buf[0] = buf[1] = buf[2] = 0;

4
src/EXTRA-DUMP/dump_xtc.h
View File

@ -21,8 +21,8 @@ DumpStyle(xtc,DumpXTC);
#define LMP_DUMP_XTC_H
#include "dump.h"
#include "xdr_compat.h"
struct XDR;
namespace LAMMPS_NS {
class DumpXTC : public Dump {
@ -37,7 +37,7 @@ class DumpXTC : public Dump {
float precision; // user-adjustable precision setting
float *coords;
double sfactor, tfactor; // scaling factors for positions and time unit
XDR xd;
XDR *xd;
void init_style() override;
int modify_param(int, char **) override;

615
src/EXTRA-DUMP/xdr_compat.cpp
View File

@ -1,54 +1,63 @@
// clang-format off
#include "xdr_compat.h"
#include <cstdlib>
#include <cstring>
/* This file is needed for systems, that do not provide XDR support
* in their system libraries. It was written for windows, but will
* most probably work on other platforms too. better make sure you
* test that the xtc files produced are ok before using it.
/*
* This file contains an implementation of the Sun External Data Representation (XDR)
* routines. They have been adapted specifically for the use with the LAMMPS xtc dump
* style to produce compressed trajectory files in the Gromacs XTC format.
*
* It is also needed on BG/L and Cray XT3/XT4 as we don't have
* XDR support in the lightweight kernel runtimes either.
* The XDR sources are avaiable under the BSD 3-clause license for example in
* the MIT Kerberos 5 distribution with the following copyright notice and license.
*
* This file contains the definitions for Sun External Data
* Representation (XDR) headers and routines.
* @(#)xdr.h 2.2 88/07/29 4.0 RPCSRC
*
* Although the rest of LAMPPS is GPL, you can copy and use the XDR
* routines in any way you want as long as you obey Sun's license:
* Copyright (c) 2010, Oracle America, Inc.
*
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
* unrestricted use provided that this legend is included on all tape
* media and as a part of the software program in whole or part. Users
* may copy or modify Sun RPC without charge, but are not authorized
* to license or distribute it to anyone else except as part of a product or
* program developed by the user.
* All rights reserved.
*
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Sun RPC is provided with no support and without any obligation on the
* part of Sun Microsystems, Inc. to assist in its use, correction,
* modification or enhancement.
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
* OR ANY PART THEREOF.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
* or profits or other special, indirect and consequential damages, even if
* Sun has been advised of the possibility of such damages.
* * Neither the name of the "Oracle America, Inc." nor the names of
* its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* Sun Microsystems, Inc.
* 2550 Garcia Avenue
* Mountain View, California 94043
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef FALSE
#define FALSE (0)
#endif
#ifndef TRUE
#define TRUE (1)
#endif
#define BYTES_PER_XDR_UNIT (4)
/*
* for unit alignment
*/
@ -58,19 +67,18 @@ static xdr_uint32_t xdr_swapbytes(xdr_uint32_t x)
{
xdr_uint32_t y;
int i;
char *px=(char *)&x;
char *py=(char *)&y;
char *px = (char *) &x;
char *py = (char *) &y;
for (i=0;i<4;i++)
py[i]=px[3-i];
for (i = 0; i < 4; i++) py[i] = px[3 - i];
return y;
}
static xdr_uint32_t xdr_htonl(xdr_uint32_t x)
{
short s=0x0F00;
if (*((char *)&s)==(char)0x0F) {
short s = 0x0F00;
if (*((char *) &s) == (char) 0x0F) {
/* bigendian, do nothing */
return x;
} else {
@ -81,8 +89,8 @@ static xdr_uint32_t xdr_htonl(xdr_uint32_t x)
static xdr_uint32_t xdr_ntohl(xdr_uint32_t x)
{
short s=0x0F00;
if (*((char *)&s)==(char)0x0F) {
short s = 0x0F00;
if (*((char *) &s) == (char) 0x0F) {
/* bigendian, do nothing */
return x;
} else {
@ -91,221 +99,39 @@ static xdr_uint32_t xdr_ntohl(xdr_uint32_t x)
}
}
/*
* Free a data structure using XDR
* Not a filter, but a convenient utility nonetheless
*/
void
xdr_free (xdrproc_t proc, char *objp)
{
XDR x;
x.x_op = XDR_FREE;
(*proc) (&x, objp);
}
/*
* XDR nothing
*/
bool_t
xdr_void (void)
{
return TRUE;
}
/*
* XDR integers
*/
bool_t
xdr_int (XDR *xdrs, int *ip)
bool_t xdr_int(XDR *xdrs, int *ip)
{
xdr_int32_t l;
switch (xdrs->x_op)
{
switch (xdrs->x_op) {
case XDR_ENCODE:
l = (xdr_int32_t) (*ip);
return xdr_putint32 (xdrs, &l);
return xdr_putint32(xdrs, &l);
break;
case XDR_DECODE:
if (!xdr_getint32 (xdrs, &l))
{
return FALSE;
}
if (!xdr_getint32(xdrs, &l)) return FALSE;
*ip = (int) l;
return TRUE;
break;
case XDR_FREE:
return TRUE;
break;
}
return FALSE;
}
/*
* XDR unsigned integers
*/
bool_t
xdr_u_int (XDR *xdrs, unsigned int *up)
{
xdr_uint32_t l;
switch (xdrs->x_op)
{
case XDR_ENCODE:
l = (xdr_uint32_t) (*up);
return xdr_putuint32 (xdrs, &l);
case XDR_DECODE:
if (!xdr_getuint32 (xdrs, &l))
{
return FALSE;
}
*up = (unsigned int) l;
case XDR_FREE:
return TRUE;
}
return FALSE;
}
/*
* XDR short integers
*/
bool_t
xdr_short (XDR *xdrs, short *sp)
{
xdr_int32_t l;
switch (xdrs->x_op)
{
case XDR_ENCODE:
l = (xdr_int32_t) *sp;
return xdr_putint32 (xdrs, &l);
case XDR_DECODE:
if (!xdr_getint32 (xdrs, &l))
{
return FALSE;
}
*sp = (short) l;
return TRUE;
case XDR_FREE:
return TRUE;
}
return FALSE;
}
/*
* XDR unsigned short integers
*/
bool_t
xdr_u_short (XDR *xdrs, unsigned short *usp)
{
xdr_uint32_t l;
switch (xdrs->x_op)
{
case XDR_ENCODE:
l = (xdr_uint32_t) *usp;
return xdr_putuint32 (xdrs, &l);
case XDR_DECODE:
if (!xdr_getuint32 (xdrs, &l))
{
return FALSE;
}
*usp = (unsigned short) l;
return TRUE;
case XDR_FREE:
return TRUE;
}
return FALSE;
}
/*
* XDR a char
*/
bool_t
xdr_char (XDR *xdrs, char *cp)
{
int i;
i = (*cp);
if (!xdr_int (xdrs, &i))
{
return FALSE;
}
*cp = i;
return TRUE;
}
/*
* XDR an unsigned char
*/
bool_t
xdr_u_char (XDR *xdrs, unsigned char *cp)
{
unsigned int u;
u = (*cp);
if (!xdr_u_int (xdrs, &u))
{
return FALSE;
}
*cp = u;
return TRUE;
}
/*
* XDR booleans
*/
bool_t
xdr_bool (XDR *xdrs, int *bp)
{
#define XDR_FALSE ((xdr_int32_t) 0)
#define XDR_TRUE ((xdr_int32_t) 1)
xdr_int32_t lb;
switch (xdrs->x_op)
{
case XDR_ENCODE:
lb = *bp ? XDR_TRUE : XDR_FALSE;
return xdr_putint32 (xdrs, &lb);
case XDR_DECODE:
if (!xdr_getint32 (xdrs, &lb))
{
return FALSE;
}
*bp = (lb == XDR_FALSE) ? FALSE : TRUE;
return TRUE;
case XDR_FREE:
return TRUE;
}
return FALSE;
#undef XDR_FALSE
#undef XDR_TRUE
}
/*
* XDR opaque data
* Allows the specification of a fixed size sequence of opaque bytes.
* cp points to the opaque object and cnt gives the byte length.
*/
bool_t
xdr_opaque (XDR *xdrs, char *cp, unsigned int cnt)
bool_t xdr_opaque(XDR *xdrs, char *cp, unsigned int cnt)
{
unsigned int rndup;
static char crud[BYTES_PER_XDR_UNIT];
@ -313,220 +139,62 @@ xdr_opaque (XDR *xdrs, char *cp, unsigned int cnt)
/*
* if no data we are done
*/
if (cnt == 0)
return TRUE;
if (cnt == 0) return TRUE;
/*
* round byte count to full xdr units
*/
rndup = cnt % BYTES_PER_XDR_UNIT;
if (rndup > 0)
rndup = BYTES_PER_XDR_UNIT - rndup;
if (rndup > 0) rndup = BYTES_PER_XDR_UNIT - rndup;
switch (xdrs->x_op) {
switch (xdrs->x_op)
{
case XDR_DECODE:
if (!xdr_getbytes (xdrs, cp, cnt))
{
return FALSE;
}
if (rndup == 0)
return TRUE;
return xdr_getbytes (xdrs, (char *)crud, rndup);
if (!xdr_getbytes(xdrs, cp, cnt)) { return FALSE; }
if (rndup == 0) return TRUE;
return xdr_getbytes(xdrs, (char *) crud, rndup);
break;
case XDR_ENCODE:
if (!xdr_putbytes (xdrs, cp, cnt))
{
return FALSE;
}
if (rndup == 0)
return TRUE;
return xdr_putbytes (xdrs, xdr_zero, rndup);
if (!xdr_putbytes(xdrs, cp, cnt)) { return FALSE; }
if (rndup == 0) return TRUE;
return xdr_putbytes(xdrs, xdr_zero, rndup);
break;
case XDR_FREE:
return TRUE;
break;
}
return FALSE;
}
/*
* XDR null terminated ASCII strings
* xdr_string deals with "C strings" - arrays of bytes that are
* terminated by a nullptr character. The parameter cpp references a
* pointer to storage; If the pointer is null, then the necessary
* storage is allocated. The last parameter is the max allowed length
* of the string as specified by a protocol.
*/
bool_t
xdr_string (XDR *xdrs, char **cpp, unsigned int maxsize)
{
char *sp = *cpp; /* sp is the actual string pointer */
unsigned int size = 0;
unsigned int nodesize = 0;
/*
* first deal with the length since xdr strings are counted-strings
*/
switch (xdrs->x_op)
{
case XDR_FREE:
if (sp == nullptr)
{
return TRUE; /* already free */
}
/* fall through... */
case XDR_ENCODE:
if (sp == nullptr)
return FALSE;
size = strlen (sp);
break;
case XDR_DECODE:
break;
}
if (!xdr_u_int (xdrs, &size))
{
return FALSE;
}
if (size > maxsize)
{
return FALSE;
}
nodesize = size + 1;
/*
* now deal with the actual bytes
*/
switch (xdrs->x_op)
{
case XDR_DECODE:
if (nodesize == 0)
{
return TRUE;
}
if (sp == nullptr)
*cpp = sp = (char *) malloc (nodesize);
if (sp == nullptr)
{
(void) fputs ("xdr_string: out of memory\n", stderr);
return FALSE;
}
sp[size] = 0;
/* fall into ... */
case XDR_ENCODE:
return xdr_opaque (xdrs, sp, size);
case XDR_FREE:
free (sp);
*cpp = nullptr;
return TRUE;
}
return FALSE;
}
/* Floating-point stuff */
bool_t
xdr_float(XDR *xdrs, float *fp)
bool_t xdr_float(XDR *xdrs, float *fp)
{
xdr_int32_t tmp;
switch (xdrs->x_op) {
case XDR_ENCODE:
tmp = *(xdr_int32_t *)fp;
tmp = *(xdr_int32_t *) fp;
return (xdr_putint32(xdrs, &tmp));
break;
case XDR_DECODE:
if (xdr_getint32(xdrs, &tmp)) {
*(xdr_int32_t *)fp = tmp;
return (TRUE);
*(xdr_int32_t *) fp = tmp;
return TRUE;
}
break;
case XDR_FREE:
return (TRUE);
}
return (FALSE);
}
bool_t
xdr_double(XDR *xdrs, double *dp)
{
/* Windows and some other systems dont define double-precision
* word order in the header files, so unfortunately we have
* to calculate it!
*/
static int LSW=-1; /* Least significant fp word */
int *ip;
xdr_int32_t tmp[2];
if (LSW<0) {
double x=0.987654321; /* Just a number */
/* Possible representations in IEEE double precision:
* (S=small endian, B=big endian)
*
* Byte order, Word order, Hex
* S S b8 56 0e 3c dd 9a ef 3f
* B S 3c 0e 56 b8 3f ef 9a dd
* S B dd 9a ef 3f b8 56 0e 3c
* B B 3f ef 9a dd 3c 0e 56 b8
*/
unsigned char ix = *((char *)&x);
if (ix==0xdd || ix==0x3f)
LSW=1; /* Big endian word order */
else if (ix==0xb8 || ix==0x3c)
LSW=0; /* Small endian word order */
else { /* Catch strange errors */
printf("Error when detecting floating-point word order.\n"
"Do you have a non-IEEE system?\n"
"If possible, use the XDR libraries provided with your system,\n"
"instead of the Gromacs fallback XDR source.\n");
exit(0);
}
}
switch (xdrs->x_op) {
case XDR_ENCODE:
ip = (int *)dp;
tmp[0] = ip[!LSW];
tmp[1] = ip[LSW];
return (xdr_putint32(xdrs, tmp) &&
xdr_putint32(xdrs, tmp+1));
return TRUE;
break;
case XDR_DECODE:
ip = (int *)dp;
if (xdr_getint32(xdrs, tmp+!LSW) &&
xdr_getint32(xdrs, tmp+LSW)) {
ip[0] = tmp[0];
ip[1] = tmp[1];
return (TRUE);
}
break;
case XDR_FREE:
return (TRUE);
}
return (FALSE);
return FALSE;
}
/* Array routines */
/*
@ -539,55 +207,37 @@ xdr_double(XDR *xdrs, double *dp)
* > elemsize: size of each element
* > xdr_elem: routine to XDR each element
*/
bool_t
xdr_vector (XDR *xdrs, char *basep, unsigned int nelem,
unsigned int elemsize, xdrproc_t xdr_elem)
bool_t xdr_vector(XDR *xdrs, char *basep, unsigned int nelem, unsigned int elemsize,
xdrproc_t xdr_elem)
{
#define LASTUNSIGNED ((unsigned int)0-1)
#define LASTUNSIGNED ((unsigned int) 0 - 1)
unsigned int i;
char *elptr;
elptr = basep;
for (i = 0; i < nelem; i++)
{
if (!(*xdr_elem) (xdrs, elptr, LASTUNSIGNED))
{
return FALSE;
}
for (i = 0; i < nelem; i++) {
if (!(*xdr_elem)(xdrs, elptr, LASTUNSIGNED)) { return FALSE; }
elptr += elemsize;
}
return TRUE;
#undef LASTUNSIGNED
}
static bool_t xdrstdio_getbytes (XDR *, char *, unsigned int);
static bool_t xdrstdio_putbytes (XDR *, char *, unsigned int);
static unsigned int xdrstdio_getpos (XDR *);
static bool_t xdrstdio_setpos (XDR *, unsigned int);
static xdr_int32_t *xdrstdio_inline (XDR *, int);
static void xdrstdio_destroy (XDR *);
static bool_t xdrstdio_getint32 (XDR *, xdr_int32_t *);
static bool_t xdrstdio_putint32 (XDR *, xdr_int32_t *);
static bool_t xdrstdio_getuint32 (XDR *, xdr_uint32_t *);
static bool_t xdrstdio_putuint32 (XDR *, xdr_uint32_t *);
static bool_t xdrstdio_getbytes(XDR *, char *, unsigned int);
static bool_t xdrstdio_putbytes(XDR *, char *, unsigned int);
static void xdrstdio_destroy(XDR *);
static bool_t xdrstdio_getint32(XDR *, xdr_int32_t *);
static bool_t xdrstdio_putint32(XDR *, xdr_int32_t *);
/*
* Ops vector for stdio type XDR
*/
static const struct xdr_ops xdrstdio_ops =
{
static const struct xdr_ops xdrstdio_ops = {
xdrstdio_getbytes, /* deserialize counted bytes */
xdrstdio_putbytes, /* serialize counted bytes */
xdrstdio_getpos, /* get offset in the stream */
xdrstdio_setpos, /* set offset in the stream */
xdrstdio_inline, /* prime stream for inline macros */
xdrstdio_destroy, /* destroy stream */
xdrstdio_getint32, /* deserialize a int */
xdrstdio_putint32, /* serialize a int */
xdrstdio_getuint32, /* deserialize a int */
xdrstdio_putuint32 /* serialize a int */
};
/*
@ -595,8 +245,7 @@ static const struct xdr_ops xdrstdio_ops =
* Sets the xdr stream handle xdrs for use on the stream file.
* Operation flag is set to op.
*/
void
xdrstdio_create (XDR *xdrs, FILE *file, enum xdr_op op)
void xdrstdio_create(XDR *xdrs, FILE *file, enum xdr_op op)
{
xdrs->x_op = op;
/* We have to add the const since the `struct xdr_ops' in `struct XDR'
@ -611,104 +260,42 @@ xdrstdio_create (XDR *xdrs, FILE *file, enum xdr_op op)
* Destroy a stdio xdr stream.
* Cleans up the xdr stream handle xdrs previously set up by xdrstdio_create.
*/
static void
xdrstdio_destroy (XDR *xdrs)
static void xdrstdio_destroy(XDR *xdrs)
{
(void) fflush ((FILE *) xdrs->x_private);
(void) fflush((FILE *) xdrs->x_private);
/* xx should we close the file ?? */
}
static bool_t
xdrstdio_getbytes (XDR *xdrs, char *addr, unsigned int len)
static bool_t xdrstdio_getbytes(XDR *xdrs, char *addr, unsigned int len)
{
if ((len != 0) && (fread (addr, (int) len, 1,
(FILE *) xdrs->x_private) != 1))
return FALSE;
if ((len != 0) && (fread(addr, (int) len, 1, (FILE *) xdrs->x_private) != 1)) return FALSE;
return TRUE;
}
static bool_t
xdrstdio_putbytes (XDR *xdrs, char *addr, unsigned int len)
static bool_t xdrstdio_putbytes(XDR *xdrs, char *addr, unsigned int len)
{
if ((len != 0) && (fwrite (addr, (int) len, 1,
(FILE *) xdrs->x_private) != 1))
return FALSE;
if ((len != 0) && (fwrite(addr, (int) len, 1, (FILE *) xdrs->x_private) != 1)) return FALSE;
return TRUE;
}
static unsigned int
xdrstdio_getpos (XDR *xdrs)
{
return (unsigned int) ftell ((FILE *) xdrs->x_private);
}
static bool_t
xdrstdio_setpos (XDR *xdrs, unsigned int pos)
{
return fseek ((FILE *) xdrs->x_private, (xdr_int32_t) pos, 0) < 0 ? FALSE : TRUE;
}
static xdr_int32_t *
xdrstdio_inline (XDR * /*xdrs*/, int /*len*/)
{
/*
* Must do some work to implement this: must ensure
* enough data in the underlying stdio buffer,
* that the buffer is aligned so that we can indirect through a
* long *, and stuff this pointer in xdrs->x_buf. Doing
* a fread or fwrite to a scratch buffer would defeat
* most of the gains to be had here and require storage
* management on this buffer, so we don't do this.
*/
return nullptr;
}
static bool_t
xdrstdio_getint32 (XDR *xdrs, xdr_int32_t *ip)
static bool_t xdrstdio_getint32(XDR *xdrs, xdr_int32_t *ip)
{
xdr_int32_t mycopy;
if (fread ((char *) &mycopy, 4, 1, (FILE *) xdrs->x_private) != 1)
return FALSE;
*ip = xdr_ntohl (mycopy);
if (fread((char *) &mycopy, 4, 1, (FILE *) xdrs->x_private) != 1) return FALSE;
*ip = xdr_ntohl(mycopy);
return TRUE;
}
static bool_t
xdrstdio_putint32 (XDR *xdrs, xdr_int32_t *ip)
static bool_t xdrstdio_putint32(XDR *xdrs, xdr_int32_t *ip)
{
xdr_int32_t mycopy = xdr_htonl (*ip);
xdr_int32_t mycopy = xdr_htonl(*ip);
ip = &mycopy;
if (fwrite ((char *) ip, 4, 1, (FILE *) xdrs->x_private) != 1)
return FALSE;
return TRUE;
}
static bool_t
xdrstdio_getuint32 (XDR *xdrs, xdr_uint32_t *ip)
{
xdr_uint32_t mycopy;
if (fread ((char *) &mycopy, 4, 1, (FILE *) xdrs->x_private) != 1)
return FALSE;
*ip = xdr_ntohl (mycopy);
return TRUE;
}
static bool_t
xdrstdio_putuint32 (XDR *xdrs, xdr_uint32_t *ip)
{
xdr_uint32_t mycopy = xdr_htonl (*ip);
ip = &mycopy;
if (fwrite ((char *) ip, 4, 1, (FILE *) xdrs->x_private) != 1)
return FALSE;
if (fwrite((char *) ip, 4, 1, (FILE *) xdrs->x_private) != 1) return FALSE;
return TRUE;
}
#ifdef __cplusplus
}
#endif

154
src/EXTRA-DUMP/xdr_compat.h
View File

@ -1,7 +1,7 @@
#ifndef LMP_XDR_COMPAT_H
#define LMP_XDR_COMPAT_H
#include <climits>
#include <cstdint>
#include <cstdio>
#ifdef __cplusplus
@ -9,47 +9,53 @@ extern "C" {
#endif
/*
* This file is needed for systems, that do not provide XDR support
* in their system libraries. It was written for windows, but will
* most probably work on other platforms too. better make sure you
* test that the xtc files produced are ok before using it.
* This file contains the definitions for Sun External Data Representation (XDR).
* They have been adapted specifically for the use with the LAMMPS xtc dump style
* to produce compressed trajectory files in the Gromacs XTC format.
*
* It is also needed on BG/L, BG/P and Cray XT3/XT4/XT5 as we don't
* have XDR support in the lightweight kernel runtimes either.
* The XDR sources are avaiable under the BSD 3-clause license for example in
* the MIT Kerberos 5 distribution with the following copyright notice and license.
*
* This file contains the definitions for Sun External Data
* Representation (XDR) headers and routines.
* @(#)xdr.h 2.2 88/07/29 4.0 RPCSRC
*
* Although the rest of LAMPPS is GPL, you can copy and use the XDR
* routines in any way you want as long as you obey Sun's license:
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
* unrestricted use provided that this legend is included on all tape
* media and as a part of the software program in whole or part. Users
* may copy or modify Sun RPC without charge, but are not authorized
* to license or distribute it to anyone else except as part of a product or
* program developed by the user.
* Copyright (c) 2010, Oracle America, Inc.
*
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
* All rights reserved.
*
* Sun RPC is provided with no support and without any obligation on the
* part of Sun Microsystems, Inc. to assist in its use, correction,
* modification or enhancement.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
* OR ANY PART THEREOF.
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
* or profits or other special, indirect and consequential damages, even if
* Sun has been advised of the possibility of such damages.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* Sun Microsystems, Inc.
* 2550 Garcia Avenue
* Mountain View, California 94043
* * Neither the name of the "Oracle America, Inc." nor the names of
* its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* compatibility typedefs */
typedef int bool_t;
typedef int32_t xdr_int32_t;
typedef uint32_t xdr_uint32_t;
/*
* Xdr operations. XDR_ENCODE causes the type to be encoded into the
* stream. XDR_DECODE causes the type to be extracted from the stream.
@ -57,44 +63,8 @@ extern "C" {
* XDR_DECODE request.
*/
typedef int bool_t;
#if defined(_WIN32) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__DragonFly__) || \
defined(__OpenBSD__) || defined(__NetBSD__) || (defined(__linux__) && !defined(__GLIBC_MINOR__))
typedef char *caddr_t;
typedef unsigned int u_int;
#endif
/*
* Aninteger type that is 32 bits wide. Check if int,
* long or short is 32 bits and die if none of them is :-)
*/
#if (INT_MAX == 2147483647)
typedef int xdr_int32_t;
typedef unsigned int xdr_uint32_t;
#elif (LONG_MAX == 2147483647L)
typedef long xdr_int32_t;
typedef unsigned long xdr_uint32_t;
#elif (SHRT_MAX == 2147483647)
typedef short xdr_int32_t;
typedef unsigned short xdr_uint32_t;
#else
#error ERROR: No 32 bit wide integer type found!
#endif
enum xdr_op { XDR_ENCODE = 0, XDR_DECODE = 1, XDR_FREE = 2 };
#ifndef FALSE
#define FALSE (0)
#endif
#ifndef TRUE
#define TRUE (1)
#endif
#define BYTES_PER_XDR_UNIT (4)
/* Macro to round up to units of 4. */
#define XDR_RNDUP(x) (((x) + BYTES_PER_XDR_UNIT - 1) & ~(BYTES_PER_XDR_UNIT - 1))
/*
* The XDR handle.
* Contains operation which is being applied to the stream,
@ -113,26 +83,16 @@ struct XDR {
};
struct xdr_ops {
/* get some bytes from XDR stream */
bool_t (*x_getbytes)(XDR *__xdrs, char *__addr, unsigned int __len);
/* get some bytes from " */
/* put some bytes to XDR stream */
bool_t (*x_putbytes)(XDR *__xdrs, char *__addr, unsigned int __len);
/* put some bytes to " */
unsigned int (*x_getpostn)(XDR *__xdrs);
/* returns bytes off from beginning */
bool_t (*x_setpostn)(XDR *__xdrs, unsigned int __pos);
/* lets you reposition the stream */
xdr_int32_t *(*x_inline)(XDR *__xdrs, int __len);
/* buf quick ptr to buffered data */
void (*x_destroy)(XDR *__xdrs);
/* free privates of this xdr_stream */
void (*x_destroy)(XDR *__xdrs);
/* get a int from XDR stream */
bool_t (*x_getint32)(XDR *__xdrs, xdr_int32_t *__ip);
/* get a int from underlying stream */
/* put a int to XDR stream */
bool_t (*x_putint32)(XDR *__xdrs, xdr_int32_t *__ip);
/* put a int to " */
bool_t (*x_getuint32)(XDR *__xdrs, xdr_uint32_t *__ip);
/* get a unsigned int from underlying stream */
bool_t (*x_putuint32)(XDR *__xdrs, xdr_uint32_t *__ip);
/* put a int to " */
};
/*
@ -151,53 +111,25 @@ typedef bool_t (*xdrproc_t)(XDR *, void *, ...);
*
* XDR *xdrs;
* xdr_int32_t *int32p;
* long *longp;
* char *addr;
* unsigned int len;
* unsigned int pos;
*/
#define xdr_getint32(xdrs, int32p) (*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
#define xdr_putint32(xdrs, int32p) (*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
#define xdr_getuint32(xdrs, uint32p) (*(xdrs)->x_ops->x_getuint32)(xdrs, uint32p)
#define xdr_putuint32(xdrs, uint32p) (*(xdrs)->x_ops->x_putuint32)(xdrs, uint32p)
#define xdr_getbytes(xdrs, addr, len) (*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
#define xdr_putbytes(xdrs, addr, len) (*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
#define xdr_getpos(xdrs) (*(xdrs)->x_ops->x_getpostn)(xdrs)
#define xdr_setpos(xdrs, pos) (*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
#define xdr_inline(xdrs, len) (*(xdrs)->x_ops->x_inline)(xdrs, len)
#define xdr_destroy(xdrs) \
do { \
if ((xdrs)->x_ops->x_destroy) (*(xdrs)->x_ops->x_destroy)(xdrs); \
} while (0)
extern bool_t xdr_int(XDR *__xdrs, int *__ip);
extern bool_t xdr_u_int(XDR *__xdrs, unsigned int *__ip);
extern bool_t xdr_short(XDR *__xdrs, short *__ip);
extern bool_t xdr_u_short(XDR *__xdrs, unsigned short *__ip);
extern bool_t xdr_bool(XDR *__xdrs, int *__bp);
extern bool_t xdr_opaque(XDR *__xdrs, char *__cp, unsigned int __cnt);
extern bool_t xdr_string(XDR *__xdrs, char **__cpp, unsigned int __maxsize);
extern bool_t xdr_char(XDR *__xdrs, char *__cp);
extern bool_t xdr_u_char(XDR *__xdrs, unsigned char *__cp);
extern bool_t xdr_vector(XDR *__xdrs, char *__basep, unsigned int __nelem, unsigned int __elemsize,
xdrproc_t __xdr_elem);
extern bool_t xdr_float(XDR *__xdrs, float *__fp);
extern bool_t xdr_double(XDR *__xdrs, double *__dp);
extern void xdrstdio_create(XDR *__xdrs, FILE *__file, enum xdr_op __xop);
/* free memory buffers for xdr */
extern void xdr_free(xdrproc_t __proc, char *__objp);
#ifdef __cplusplus
}
#endif

5
src/KOKKOS/domain_kokkos.cpp
View File

@ -80,6 +80,11 @@ public:
void DomainKokkos::reset_box()
{
// perform shrink-wrapping
// nothing to do for empty systems
if (atom->natoms == 0) return;
// compute extent of atoms on this proc
// for triclinic, this is done in lamda space

3
src/KOKKOS/fft3d_kokkos.cpp
View File

@ -39,8 +39,11 @@ FFT3dKokkos<DeviceType>::FFT3dKokkos(LAMMPS *lmp, MPI_Comm comm, int nfast, int
Pointers(lmp)
{
int nthreads = lmp->kokkos->nthreads;
#if defined(LMP_KOKKOS_GPU)
int ngpus = lmp->kokkos->ngpus;
ExecutionSpace execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
#endif
#if defined(FFT_KOKKOS_MKL)
if (ngpus > 0 && execution_space == Device)

4
src/KOKKOS/pair_kokkos.h
View File

@ -950,10 +950,10 @@ EV_FLOAT pair_compute_neighlist (PairStyle* fpair, std::enable_if_t<(NEIGHFLAG&P
static int vectorsize = 0;
static int atoms_per_team = 0;
static int teamsize_max_for = 0;
static int teamsize_max_reduce = 0;
#if defined(LMP_KOKKOS_GPU)
static int teamsize_max_for = 0;
static int teamsize_max_reduce = 0;
static int lastcall = -1;
if (!vectorsize || lastcall < fpair->lmp->neighbor->lastcall) {
lastcall = fpair->lmp->update->ntimestep;

3
src/MOLECULE/fix_cmap.cpp
View File

@ -970,7 +970,8 @@ void FixCMAP::read_data_section(char * /*keyword*/, int /*n*/, char *buf,
atom5 = values.next_tagint();
if (values.has_next()) throw TokenizerException("too many items",line);
} catch (std::exception &e) {
error->all(FLERR,"Incorrect format of CMAP section: {}", e.what());
error->all(FLERR,"Incorrect format of CMAP section in data file: {}{}",
e.what(), utils::errorurl(2));
}
atom1 += id_offset;

6
src/OPENMP/angle_cosine_squared_omp.cpp
View File

@ -16,14 +16,16 @@
Contributing author: Axel Kohlmeyer (Temple U)
------------------------------------------------------------------------- */
#include "omp_compat.h"
#include "angle_cosine_squared_omp.h"
#include <cmath>
#include "atom.h"
#include "comm.h"
#include "force.h"
#include "neighbor.h"
#include <cmath>
#include "omp_compat.h"
#include "suffix.h"
using namespace LAMMPS_NS;

3
src/SPIN/compute_spin.cpp
View File

@ -215,10 +215,9 @@ void ComputeSpin::compute_vector()
tempnum += tx*tx+ty*ty+tz*tz;
tempdenom += sp[i][0]*fm[i][0]+fm[i][1]*sp[i][1]+sp[i][2]*fm[i][2];
countsp++;
} else error->all(FLERR,"Compute compute/spin requires atom/spin style");
}
}
else error->all(FLERR,"Compute compute/spin requires atom/spin style");
}
MPI_Allreduce(mag,magtot,4,MPI_DOUBLE,MPI_SUM,world);
MPI_Allreduce(&magenergy,&magenergytot,1,MPI_DOUBLE,MPI_SUM,world);

28
src/atom.cpp
View File

@ -1068,7 +1068,8 @@ void Atom::data_atoms(int n, char *buf, tagint id_offset, tagint mol_offset,
}
if ((nwords != avec->size_data_atom) && (nwords != avec->size_data_atom + 3))
error->all(FLERR,"Incorrect format in {}: {}", location, utils::trim(buf));
error->all(FLERR,"Incorrect format in {}: {}{}", location,
utils::trim(buf), utils::errorurl(2));
*next = '\n';
// set bounds for my proc
@ -1149,7 +1150,8 @@ void Atom::data_atoms(int n, char *buf, tagint id_offset, tagint mol_offset,
// skip over empty or comment lines
} else if ((nvalues < nwords) ||
((nvalues > nwords) && (!utils::strmatch(values[nwords],"^#")))) {
error->all(FLERR, "Incorrect format in {}: {}", location, utils::trim(buf));
error->all(FLERR, "Incorrect format in {}: {}{}", location,
utils::trim(buf), utils::errorurl(2));
} else {
int imx = 0, imy = 0, imz = 0;
if (imageflag) {
@ -1243,7 +1245,8 @@ void Atom::data_vels(int n, char *buf, tagint id_offset)
if (values.size() == 0) {
// skip over empty or comment lines
} else if ((int)values.size() != avec->size_data_vel) {
error->all(FLERR, "Incorrect velocity format in data file: {}", utils::trim(buf));
error->all(FLERR, "Incorrect format in Velocities section of data file: {}{}",
utils::trim(buf), utils::errorurl(2));
} else {
tagint tagdata = utils::tnumeric(FLERR,values[0],false,lmp) + id_offset;
if (tagdata <= 0 || tagdata > map_tag_max)
@ -1287,7 +1290,9 @@ void Atom::data_bonds(int n, char *buf, int *count, tagint id_offset,
// skip over empty or comment lines
// Bonds line is: number(ignored), bond type, atomID 1, atomID 2
if (nwords > 0) {
if (nwords != 4) error->all(FLERR, "Incorrect format in {}: {}", location, utils::trim(buf));
if (nwords != 4)
error->all(FLERR, "Incorrect format in {}: {}{}", location,
utils::trim(buf), utils::errorurl(2));
typestr = utils::utf8_subst(values[1]);
atom1 = utils::tnumeric(FLERR, values[2], false, lmp);
atom2 = utils::tnumeric(FLERR, values[3], false, lmp);
@ -1378,7 +1383,9 @@ void Atom::data_angles(int n, char *buf, int *count, tagint id_offset,
// skip over empty or comment lines
// Angles line is: number(ignored), angle type, atomID 1, atomID 2, atomID 3
if (nwords > 0) {
if (nwords != 5) error->all(FLERR, "Incorrect format in {}: {}", location, utils::trim(buf));
if (nwords != 5)
error->all(FLERR, "Incorrect format in {}: {}{}", location,
utils::trim(buf), utils::errorurl(2));
typestr = utils::utf8_subst(values[1]);
atom1 = utils::tnumeric(FLERR, values[2], false, lmp);
atom2 = utils::tnumeric(FLERR, values[3], false, lmp);
@ -1485,7 +1492,9 @@ void Atom::data_dihedrals(int n, char *buf, int *count, tagint id_offset,
// skip over empty or comment lines
// Dihedrals line is: number(ignored), bond type, atomID 1, atomID 2, atomID 3, atomID 4
if (nwords > 0) {
if (nwords != 6) error->all(FLERR, "Incorrect format in {}: {}", location, utils::trim(buf));
if (nwords != 6)
error->all(FLERR, "Incorrect format in {}: {}{}", location,
utils::trim(buf), utils::errorurl(2));
typestr = utils::utf8_subst(values[1]);
atom1 = utils::tnumeric(FLERR, values[2], false, lmp);
atom2 = utils::tnumeric(FLERR, values[3], false, lmp);
@ -1611,7 +1620,9 @@ void Atom::data_impropers(int n, char *buf, int *count, tagint id_offset,
// skip over empty or comment lines
// Impropers line is: number(ignored), bond type, atomID 1, atomID 2, atomID 3, atomID 4
if (nwords > 0) {
if (nwords != 6) error->all(FLERR, "Incorrect format in {}: {}", location, utils::trim(buf));
if (nwords != 6)
error->all(FLERR, "Incorrect format in {}: {}{}", location,
utils::trim(buf), utils::errorurl(2));
typestr = utils::utf8_subst(values[1]);
atom1 = utils::tnumeric(FLERR, values[2], false, lmp);
atom2 = utils::tnumeric(FLERR, values[3], false, lmp);
@ -1727,7 +1738,8 @@ void Atom::data_bonus(int n, char *buf, AtomVec *avec_bonus, tagint id_offset)
if (values.size() == 0) {
// skip over empty or comment lines
} else if ((int)values.size() != avec_bonus->size_data_bonus) {
error->all(FLERR, "Incorrect bonus data format in data file: {}", utils::trim(buf));
error->all(FLERR, "Incorrect format in Bonus section of data file: {}{}",
utils::trim(buf), utils::errorurl(2));
} else {
tagint tagdata = utils::tnumeric(FLERR,values[0],false,lmp) + id_offset;
if (tagdata <= 0 || tagdata > map_tag_max)

14
src/fix_ave_correlate.cpp
View File

@ -97,7 +97,7 @@ FixAveCorrelate::FixAveCorrelate(LAMMPS *lmp, int narg, char **arg) :
while (iarg < nargnew) {
if (strcmp(arg[iarg],"type") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix ave/correlate type", error);
if (iarg+2 > nargnew) utils::missing_cmd_args(FLERR, "fix ave/correlate type", error);
if (strcmp(arg[iarg+1],"auto") == 0) type = AUTO;
else if (strcmp(arg[iarg+1],"upper") == 0) type = UPPER;
else if (strcmp(arg[iarg+1],"lower") == 0) type = LOWER;
@ -107,17 +107,17 @@ FixAveCorrelate::FixAveCorrelate(LAMMPS *lmp, int narg, char **arg) :
else error->all(FLERR,"Unknown fix ave/correlate type: {}");
iarg += 2;
} else if (strcmp(arg[iarg],"ave") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix ave/correlate ave", error);
if (iarg+2 > nargnew) utils::missing_cmd_args(FLERR, "fix ave/correlate ave", error);
if (strcmp(arg[iarg+1],"one") == 0) ave = ONE;
else if (strcmp(arg[iarg+1],"running") == 0) ave = RUNNING;
else error->all(FLERR,"Unknown fix ave/correlate ave mode: {}", arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"start") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix ave/correlate start", error);
if (iarg+2 > nargnew) utils::missing_cmd_args(FLERR, "fix ave/correlate start", error);
startstep = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"prefactor") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix ave/correlate prefactor", error);
if (iarg+2 > nargnew) utils::missing_cmd_args(FLERR, "fix ave/correlate prefactor", error);
prefactor = utils::numeric(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"file") == 0) {
@ -133,17 +133,17 @@ FixAveCorrelate::FixAveCorrelate(LAMMPS *lmp, int narg, char **arg) :
overwrite = 1;
iarg += 1;
} else if (strcmp(arg[iarg],"title1") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix ave/correlate title1", error);
if (iarg+2 > nargnew) utils::missing_cmd_args(FLERR, "fix ave/correlate title1", error);
delete[] title1;
title1 = utils::strdup(arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"title2") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix ave/correlate title2", error);
if (iarg+2 > nargnew) utils::missing_cmd_args(FLERR, "fix ave/correlate title2", error);
delete[] title2;
title2 = utils::strdup(arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"title3") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix ave/correlate title3", error);
if (iarg+2 > nargnew) utils::missing_cmd_args(FLERR, "fix ave/correlate title3", error);
delete[] title3;
title3 = utils::strdup(arg[iarg+1]);
iarg += 2;

228
src/fix_ave_histo_weight.cpp
View File

@ -113,256 +113,256 @@ void FixAveHistoWeight::end_of_step()
double weight = 0.0;
double *weights = nullptr;
int stride = 0;
auto &val = values[1];
int j = val.argindex;
auto &val1 = values[1];
int j = val1.argindex;
// atom attributes
if (val.which == ArgInfo::X) {
if (val1.which == ArgInfo::X) {
weights = &atom->x[0][j];
stride = 3;
} else if (val.which == ArgInfo::V) {
} else if (val1.which == ArgInfo::V) {
weights = &atom->v[0][j];
stride = 3;
bin_atoms(&atom->v[0][j],3);
} else if (val.which == ArgInfo::F) {
} else if (val1.which == ArgInfo::F) {
weights = &atom->f[0][j];
stride = 3;
}
// invoke compute if not previously invoked
if (val.which == ArgInfo::COMPUTE) {
if (val1.which == ArgInfo::COMPUTE) {
if (kind == GLOBAL && mode == SCALAR) {
if (j == 0) {
if (!(val.val.c->invoked_flag & Compute::INVOKED_SCALAR)) {
val.val.c->compute_scalar();
val.val.c->invoked_flag |= Compute::INVOKED_SCALAR;
if (!(val1.val.c->invoked_flag & Compute::INVOKED_SCALAR)) {
val1.val.c->compute_scalar();
val1.val.c->invoked_flag |= Compute::INVOKED_SCALAR;
}
weight = val.val.c->scalar;
weight = val1.val.c->scalar;
} else {
if (!(val.val.c->invoked_flag & Compute::INVOKED_VECTOR)) {
val.val.c->compute_vector();
val.val.c->invoked_flag |= Compute::INVOKED_VECTOR;
if (!(val1.val.c->invoked_flag & Compute::INVOKED_VECTOR)) {
val1.val.c->compute_vector();
val1.val.c->invoked_flag |= Compute::INVOKED_VECTOR;
}
weight = val.val.c->vector[j-1];
weight = val1.val.c->vector[j-1];
}
} else if (kind == GLOBAL && mode == VECTOR) {
if (j == 0) {
if (!(val.val.c->invoked_flag & Compute::INVOKED_VECTOR)) {
val.val.c->compute_vector();
val.val.c->invoked_flag |= Compute::INVOKED_VECTOR;
if (!(val1.val.c->invoked_flag & Compute::INVOKED_VECTOR)) {
val1.val.c->compute_vector();
val1.val.c->invoked_flag |= Compute::INVOKED_VECTOR;
}
weights = val.val.c->vector;
weights = val1.val.c->vector;
stride = 1;
} else {
if (!(val.val.c->invoked_flag & Compute::INVOKED_ARRAY)) {
val.val.c->compute_array();
val.val.c->invoked_flag |= Compute::INVOKED_ARRAY;
if (!(val1.val.c->invoked_flag & Compute::INVOKED_ARRAY)) {
val1.val.c->compute_array();
val1.val.c->invoked_flag |= Compute::INVOKED_ARRAY;
}
if (val.val.c->array) weights = &val.val.c->array[0][j-1];
stride = val.val.c->size_array_cols;
if (val1.val.c->array) weights = &val1.val.c->array[0][j-1];
stride = val1.val.c->size_array_cols;
}
} else if (kind == PERATOM) {
if (!(val.val.c->invoked_flag & Compute::INVOKED_PERATOM)) {
val.val.c->compute_peratom();
val.val.c->invoked_flag |= Compute::INVOKED_PERATOM;
if (!(val1.val.c->invoked_flag & Compute::INVOKED_PERATOM)) {
val1.val.c->compute_peratom();
val1.val.c->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (j == 0) {
weights = val.val.c->vector_atom;
weights = val1.val.c->vector_atom;
stride = 1;
} else if (val.val.c->array_atom) {
weights = &val.val.c->array_atom[0][j-1];
stride = val.val.c->size_peratom_cols;
} else if (val1.val.c->array_atom) {
weights = &val1.val.c->array_atom[0][j-1];
stride = val1.val.c->size_peratom_cols;
}
} else if (kind == LOCAL) {
if (!(val.val.c->invoked_flag & Compute::INVOKED_LOCAL)) {
val.val.c->compute_local();
val.val.c->invoked_flag |= Compute::INVOKED_LOCAL;
if (!(val1.val.c->invoked_flag & Compute::INVOKED_LOCAL)) {
val1.val.c->compute_local();
val1.val.c->invoked_flag |= Compute::INVOKED_LOCAL;
}
if (j == 0) {
weights = val.val.c->vector_local;
weights = val1.val.c->vector_local;
stride = 1;
} else if (val.val.c->array_local) {
weights = &val.val.c->array_local[0][j-1];
stride = val.val.c->size_local_cols;
} else if (val1.val.c->array_local) {
weights = &val1.val.c->array_local[0][j-1];
stride = val1.val.c->size_local_cols;
}
}
// access fix fields, guaranteed to be ready
} else if (val.which == ArgInfo::FIX) {
} else if (val1.which == ArgInfo::FIX) {
if (kind == GLOBAL && mode == SCALAR) {
if (j == 0) weight = val.val.f->compute_scalar();
else weight = val.val.f->compute_vector(j-1);
if (j == 0) weight = val1.val.f->compute_scalar();
else weight = val1.val.f->compute_vector(j-1);
} else if (kind == GLOBAL && mode == VECTOR) {
error->all(FLERR,"Fix ave/histo/weight option not yet supported");
// NOTE: need to allocate local storage
if (j == 0) {
int n = val.val.f->size_vector;
for (int i = 0; i < n; i++) weights[n] = val.val.f->compute_vector(i);
int n = val1.val.f->size_vector;
for (int i = 0; i < n; i++) weights[n] = val1.val.f->compute_vector(i);
} else {
int n = val.val.f->size_vector;
for (int i = 0; i < n; i++) weights[n] = val.val.f->compute_array(i,j-1);
int n = val1.val.f->size_vector;
for (int i = 0; i < n; i++) weights[n] = val1.val.f->compute_array(i,j-1);
}
} else if (kind == PERATOM) {
if (j == 0) {
weights = val.val.f->vector_atom;
weights = val1.val.f->vector_atom;
stride = 1;
} else if (val.val.f->array_atom) {
weights = &val.val.f->array_atom[0][j-1];
stride = val.val.f->size_peratom_cols;
} else if (val1.val.f->array_atom) {
weights = &val1.val.f->array_atom[0][j-1];
stride = val1.val.f->size_peratom_cols;
}
} else if (kind == LOCAL) {
if (j == 0) {
weights = val.val.f->vector_local;
weights = val1.val.f->vector_local;
stride = 1;
} else if (val.val.f->array_local) {
weights = &val.val.f->array_local[0][j-1];
stride = val.val.f->size_local_cols;
} else if (val1.val.f->array_local) {
weights = &val1.val.f->array_local[0][j-1];
stride = val1.val.f->size_local_cols;
}
}
// evaluate equal-style variable
} else if (val.which == ArgInfo::VARIABLE && kind == GLOBAL) {
weight = input->variable->compute_equal(val.val.v);
} else if (val1.which == ArgInfo::VARIABLE && kind == GLOBAL) {
weight = input->variable->compute_equal(val1.val.v);
} else if (val.which == ArgInfo::VARIABLE && kind == PERATOM) {
} else if (val1.which == ArgInfo::VARIABLE && kind == PERATOM) {
if (atom->nmax > maxatom) {
memory->destroy(vector);
maxatom = atom->nmax;
memory->create(vector,maxatom,"ave/histo/weight:vector");
}
input->variable->compute_atom(val.val.v,igroup,vector,1,0);
input->variable->compute_atom(val1.val.v,igroup,vector,1,0);
weights = vector;
stride = 1;
}
// bin values using weights, values are 1st value (i = 0)
val = values[0];
j = val.argindex;
auto &val0 = values[0];
j = val0.argindex;
// atom attributes
if (val.which == ArgInfo::X && weights != nullptr)
if (val0.which == ArgInfo::X && weights != nullptr)
bin_atoms_weights(&atom->x[0][j],3,weights,stride);
else if (val.which == ArgInfo::V && weights != nullptr)
else if (val0.which == ArgInfo::V && weights != nullptr)
bin_atoms_weights(&atom->v[0][j],3,weights,stride);
else if (val.which == ArgInfo::F && weights != nullptr)
else if (val0.which == ArgInfo::F && weights != nullptr)
bin_atoms_weights(&atom->f[0][j],3,weights,stride);
// invoke compute if not previously invoked
if (val.which == ArgInfo::COMPUTE) {
if (val0.which == ArgInfo::COMPUTE) {
if (kind == GLOBAL && mode == SCALAR) {
if (j == 0) {
if (!(val.val.c->invoked_flag & Compute::INVOKED_SCALAR)) {
val.val.c->compute_scalar();
val.val.c->invoked_flag |= Compute::INVOKED_SCALAR;
if (!(val0.val.c->invoked_flag & Compute::INVOKED_SCALAR)) {
val0.val.c->compute_scalar();
val0.val.c->invoked_flag |= Compute::INVOKED_SCALAR;
}
bin_one_weights(val.val.c->scalar,weight);
bin_one_weights(val0.val.c->scalar,weight);
} else {
if (!(val.val.c->invoked_flag & Compute::INVOKED_VECTOR)) {
val.val.c->compute_vector();
val.val.c->invoked_flag |= Compute::INVOKED_VECTOR;
if (!(val0.val.c->invoked_flag & Compute::INVOKED_VECTOR)) {
val0.val.c->compute_vector();
val0.val.c->invoked_flag |= Compute::INVOKED_VECTOR;
}
bin_one_weights(val.val.c->vector[j-1],weight);
bin_one_weights(val0.val.c->vector[j-1],weight);
}
} else if (kind == GLOBAL && mode == VECTOR) {
if (j == 0) {
if (!(val.val.c->invoked_flag & Compute::INVOKED_VECTOR)) {
val.val.c->compute_vector();
val.val.c->invoked_flag |= Compute::INVOKED_VECTOR;
if (!(val0.val.c->invoked_flag & Compute::INVOKED_VECTOR)) {
val0.val.c->compute_vector();
val0.val.c->invoked_flag |= Compute::INVOKED_VECTOR;
}
bin_vector_weights(val.val.c->size_vector,val.val.c->vector,1,
bin_vector_weights(val0.val.c->size_vector,val0.val.c->vector,1,
weights,stride);
} else {
if (!(val.val.c->invoked_flag & Compute::INVOKED_ARRAY)) {
val.val.c->compute_array();
val.val.c->invoked_flag |= Compute::INVOKED_ARRAY;
if (!(val0.val.c->invoked_flag & Compute::INVOKED_ARRAY)) {
val0.val.c->compute_array();
val0.val.c->invoked_flag |= Compute::INVOKED_ARRAY;
}
if (val.val.c->array)
bin_vector_weights(val.val.c->size_array_rows,&val.val.c->array[0][j-1],
val.val.c->size_array_cols,weights,stride);
if (val0.val.c->array)
bin_vector_weights(val0.val.c->size_array_rows,&val0.val.c->array[0][j-1],
val0.val.c->size_array_cols,weights,stride);
}
} else if (kind == PERATOM) {
if (!(val.val.c->invoked_flag & Compute::INVOKED_PERATOM)) {
val.val.c->compute_peratom();
val.val.c->invoked_flag |= Compute::INVOKED_PERATOM;
if (!(val0.val.c->invoked_flag & Compute::INVOKED_PERATOM)) {
val0.val.c->compute_peratom();
val0.val.c->invoked_flag |= Compute::INVOKED_PERATOM;
}
if (j == 0)
bin_atoms_weights(val.val.c->vector_atom,1,weights, stride);
else if (val.val.c->array_atom)
bin_atoms_weights(&val.val.c->array_atom[0][j-1],
val.val.c->size_peratom_cols,weights,stride);
bin_atoms_weights(val0.val.c->vector_atom,1,weights, stride);
else if (val0.val.c->array_atom)
bin_atoms_weights(&val0.val.c->array_atom[0][j-1],
val0.val.c->size_peratom_cols,weights,stride);
} else if (kind == LOCAL) {
if (!(val.val.c->invoked_flag & Compute::INVOKED_LOCAL)) {
val.val.c->compute_local();
val.val.c->invoked_flag |= Compute::INVOKED_LOCAL;
if (!(val0.val.c->invoked_flag & Compute::INVOKED_LOCAL)) {
val0.val.c->compute_local();
val0.val.c->invoked_flag |= Compute::INVOKED_LOCAL;
}
if (j == 0)
bin_vector_weights(val.val.c->size_local_rows,
val.val.c->vector_local,1,weights,stride);
else if (val.val.c->array_local)
bin_vector_weights(val.val.c->size_local_rows,
&val.val.c->array_local[0][j-1],
val.val.c->size_local_cols,weights,stride);
bin_vector_weights(val0.val.c->size_local_rows,
val0.val.c->vector_local,1,weights,stride);
else if (val0.val.c->array_local)
bin_vector_weights(val0.val.c->size_local_rows,
&val0.val.c->array_local[0][j-1],
val0.val.c->size_local_cols,weights,stride);
}
// access fix fields, guaranteed to be ready
} else if (val.which == ArgInfo::FIX) {
} else if (val0.which == ArgInfo::FIX) {
if (kind == GLOBAL && mode == SCALAR) {
if (j == 0) bin_one_weights(val.val.f->compute_scalar(),weight);
else bin_one_weights(val.val.f->compute_vector(j-1),weight);
if (j == 0) bin_one_weights(val0.val.f->compute_scalar(),weight);
else bin_one_weights(val0.val.f->compute_vector(j-1),weight);
} else if (kind == GLOBAL && mode == VECTOR) {
if (j == 0) {
int n = val.val.f->size_vector;
int n = val0.val.f->size_vector;
for (int i = 0; i < n; i++)
bin_one_weights(val.val.f->compute_vector(i),weights[i*stride]);
bin_one_weights(val0.val.f->compute_vector(i),weights[i*stride]);
} else {
int n = val.val.f->size_vector;
int n = val0.val.f->size_vector;
for (int i = 0; i < n; i++)
bin_one_weights(val.val.f->compute_array(i,j-1),weights[i*stride]);
bin_one_weights(val0.val.f->compute_array(i,j-1),weights[i*stride]);
}
} else if (kind == PERATOM) {
if (j == 0)
bin_atoms_weights(val.val.f->vector_atom,1,weights,stride);
else if (val.val.f->array_atom)
bin_atoms_weights(&val.val.f->array_atom[0][j-1],val.val.f->size_peratom_cols,
bin_atoms_weights(val0.val.f->vector_atom,1,weights,stride);
else if (val0.val.f->array_atom)
bin_atoms_weights(&val0.val.f->array_atom[0][j-1],val0.val.f->size_peratom_cols,
weights,stride);
} else if (kind == LOCAL) {
if (j == 0) bin_vector_weights(val.val.f->size_local_rows,val.val.f->vector_local,1,
if (j == 0) bin_vector_weights(val0.val.f->size_local_rows,val0.val.f->vector_local,1,
weights,stride);
else if (val.val.f->array_local)
bin_vector_weights(val.val.f->size_local_rows,&val.val.f->array_local[0][j-1],
val.val.f->size_local_cols,weights,stride);
else if (val0.val.f->array_local)
bin_vector_weights(val0.val.f->size_local_rows,&val0.val.f->array_local[0][j-1],
val0.val.f->size_local_cols,weights,stride);
}
// evaluate equal-style variable
} else if (val.which == ArgInfo::VARIABLE && kind == GLOBAL) {
bin_one_weights(input->variable->compute_equal(val.val.v),weight);
} else if (val0.which == ArgInfo::VARIABLE && kind == GLOBAL) {
bin_one_weights(input->variable->compute_equal(val0.val.v),weight);
} else if (val.which == ArgInfo::VARIABLE && kind == PERATOM) {
} else if (val0.which == ArgInfo::VARIABLE && kind == PERATOM) {
if (atom->nmax > maxatom) {
memory->destroy(vector);
maxatom = atom->nmax;
memory->create(vector,maxatom,"ave/histo/weight:vector");
}
input->variable->compute_atom(val.val.v,igroup,vector,1,0);
input->variable->compute_atom(val0.val.v,igroup,vector,1,0);
bin_atoms_weights(vector,1,weights,stride);
}

5
src/fix_property_atom.cpp
View File

@ -328,8 +328,9 @@ void FixPropertyAtom::read_data_section(char *keyword, int n, char *buf, tagint
try {
ValueTokenizer values(buf);
if ((int) values.count() != values_peratom + 1)
error->all(FLERR, "Incorrect format in {} section of data file: {} expected {} and got {}",
keyword, buf, values_peratom + 1, values.count());
error->all(FLERR, "Incorrect format in {} section of data file: {}\n"
"expected {} parameters and got {}{}", keyword, utils::trim(buf),
values_peratom + 1, values.count(), utils::errorurl(2));
itag = values.next_tagint() + id_offset;
if (itag <= 0 || itag > map_tag_max)

24
src/math_eigen.cpp
View File

@ -31,7 +31,7 @@ using namespace MathEigen;
typedef Jacobi<double, double *, double (*)[3], double const (*)[3]> Jacobi_v1;
typedef Jacobi<double, double *, double **, double const *const *> Jacobi_v2;
int MathEigen::jacobi3(double const mat[3][3], double *eval, double evec[3][3])
int MathEigen::jacobi3(double const mat[3][3], double *eval, double evec[3][3], int sort)
{
// make copy of const matrix
@ -44,7 +44,15 @@ int MathEigen::jacobi3(double const mat[3][3], double *eval, double evec[3][3])
// create instance of generic Jacobi class and get eigenvalues and -vectors
Jacobi_v1 ecalc3(3, M, midx);
int ierror = ecalc3.Diagonalize(mat, eval, evec, Jacobi_v1::SORT_DECREASING_EVALS);
int ierror = 1;
if (sort == -1)
ierror = ecalc3.Diagonalize(mat, eval, evec, Jacobi_v1::SORT_DECREASING_EVALS);
else if (sort == 0)
ierror = ecalc3.Diagonalize(mat, eval, evec, Jacobi_v1::DO_NOT_SORT);
else if (sort == 1)
ierror = ecalc3.Diagonalize(mat, eval, evec, Jacobi_v1::SORT_INCREASING_EVALS);
if (ierror) return ierror;
// transpose the evec matrix
@ -54,7 +62,7 @@ int MathEigen::jacobi3(double const mat[3][3], double *eval, double evec[3][3])
return ierror;
}
int MathEigen::jacobi3(double const *const *mat, double *eval, double **evec)
int MathEigen::jacobi3(double const *const *mat, double *eval, double **evec, int sort)
{
// make copy of const matrix
@ -67,7 +75,15 @@ int MathEigen::jacobi3(double const *const *mat, double *eval, double **evec)
// create instance of generic Jacobi class and get eigenvalues and -vectors
Jacobi_v2 ecalc3(3, M, midx);
int ierror = ecalc3.Diagonalize(mat, eval, evec, Jacobi_v2::SORT_DECREASING_EVALS);
int ierror = 1;
if (sort == -1)
ierror = ecalc3.Diagonalize(mat, eval, evec, Jacobi_v2::SORT_DECREASING_EVALS);
else if (sort == 0)
ierror = ecalc3.Diagonalize(mat, eval, evec, Jacobi_v2::DO_NOT_SORT);
else if (sort == 1)
ierror = ecalc3.Diagonalize(mat, eval, evec, Jacobi_v2::SORT_INCREASING_EVALS);
if (ierror) return ierror;
// transpose the evec matrix

5
src/math_eigen.h
View File

@ -22,13 +22,14 @@ namespace MathEigen {
* \param mat the 3x3 matrix you wish to diagonalize
* \param eval store the eigenvalues here
* \param evec store the eigenvectors here...
* \param sort order eigenvalues and -vectors (-1 decreasing (default), 1 increasing, 0 unsorted)
* \return 0 if eigenvalue calculation converged, 1 if it failed */
int jacobi3(double const *const *mat, double *eval, double **evec);
int jacobi3(double const *const *mat, double *eval, double **evec, int sort = -1);
/** \overload */
int jacobi3(double const mat[3][3], double *eval, double evec[3][3]);
int jacobi3(double const mat[3][3], double *eval, double evec[3][3], int sort = -1);
} // namespace MathEigen

7
src/platform.cpp
View File

@ -249,12 +249,7 @@ std::string platform::os_info()
} else if (build == "22631") {
buf = "Windows 11 23H2";
} else {
const char *entry = "ProductName";
RegGetValue(HKEY_LOCAL_MACHINE, subkey, entry, RRF_RT_REG_SZ, nullptr, &value,
(LPDWORD) &value_length);
// enforce zero termination
value[1023] = '\0';
buf = value;
buf = "Windows Build " + build;
}
DWORD fullversion, majorv, minorv, buildv = 0;
fullversion = GetVersion();

3
src/read_data.cpp
View File

@ -1360,7 +1360,8 @@ void ReadData::header(int firstpass)
// check that exiting string is a valid section keyword
parse_keyword(1);
if (!is_data_section(keyword)) error->all(FLERR, "Unknown identifier in data file: {}", keyword);
if (!is_data_section(keyword))
error->all(FLERR, "Unknown identifier in data file: {}{}", keyword, utils::errorurl(1));
// error checks on header values
// must be consistent with atom style and other header values

8
src/variable.cpp
View File

@ -1662,15 +1662,19 @@ double Variable::evaluate(char *str, Tree **tree, int ivar)
if (!compute->array_flag)
print_var_error(FLERR,"Mismatched compute in variable formula",ivar);
if (index1 > compute->size_array_cols)
print_var_error(FLERR,"Variable formula compute array is accessed out-of-range",ivar,0);
if (!compute->is_initialized())
print_var_error(FLERR,"Variable formula compute cannot be invoked before "
"initialization by a run",ivar);
if (index1 > compute->size_array_cols)
print_var_error(FLERR,"Variable formula compute array is accessed out-of-range",ivar,0);
if (!(compute->invoked_flag & Compute::INVOKED_ARRAY)) {
compute->compute_array();
compute->invoked_flag |= Compute::INVOKED_ARRAY;
}
// wait until after compute invocation to check size_array_rows
// b/c may be zero until after initial invocation
if (compute->size_array_rows == 0)
print_var_error(FLERR,"Variable formula compute array is zero length",ivar);
// wait to check row count until after compute invocation
// to allow for computes with size_array_rows_variable == 1

16
unittest/force-styles/check_tests.py
View File

@ -54,7 +54,7 @@ improper = {}
kspace = {}
pair = {}
style_pattern = re.compile("(.+)Style\((.+),(.+)\)")
style_pattern = re.compile("(.+)Style\\((.+),(.+)\\)")
upper = re.compile("[A-Z]+")
gpu = re.compile("(.+)/gpu$")
intel = re.compile("(.+)/intel$")
@ -176,19 +176,19 @@ def check_tests(name,styles,yaml,search,skip=()):
counter = 0
counter += check_tests('pair',pair,'*-pair-*.yaml',
'.*pair_style:\s*((\S+).*)?',skip=('meam','lj/sf'))
'.*pair_style:\\s*((\\S+).*)?',skip=('meam','lj/sf'))
counter += check_tests('bond',bond,'bond-*.yaml',
'.*bond_style:\s*((\S+).*)?')
'.*bond_style:\\s*((\\S+).*)?')
counter += check_tests('angle',angle,'angle-*.yaml',
'.*angle_style:\s*((\S+).*)?')
'.*angle_style:\\s*((\\S+).*)?')
counter += check_tests('dihedral',dihedral,'dihedral-*.yaml',
'.*dihedral_style:\s*((\S+).*)?')
'.*dihedral_style:\\s*((\\S+).*)?')
counter += check_tests('improper',improper,'improper-*.yaml',
'.*improper_style:\s*((\S+).*)?')
'.*improper_style:\\s*((\\S+).*)?')
counter += check_tests('kspace',kspace,'kspace-*.yaml',
'.*kspace_style\s*((\S+).*)?')
'.*kspace_style\\s*((\\S+).*)?')
counter += check_tests('fix',fix,'fix-*.yaml',
' fix\s+((\S+)\s*)?')
' fix\\s+((\\S+)\\s*)?')
total = len(pair)+len(bond)+len(angle)+len(dihedral)+len(improper)+len(kspace)+len(fix)
print(f"\nTotal tests missing: {counter} of {total}")