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

Merge pull request #2707 from akohlmey/commands-base-class

Browse Source 
Add Command base class for command styles
This commit is contained in:
Axel Kohlmeyer
2021-04-16 16:16:40 -04:00
committed by GitHub
parent f07fa3d266 2e5079371a
commit 9ea465f56a
82 changed files with 269 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
doc/graphviz/lammps-classes.dot
View File

@ -18,8 +18,8 @@ digraph lammps {
Up [shape=box label="Update" color=blue]
Un [shape=box label="Universe" color=blue]
Ti [shape=box label="Timer" color=blue]
Lt [label="Lattice"]
Rg [label="Region" color=red]
Lt [label="Lattice"]
Rb [shape=box label="RegionBlock"]
Rs [shape=box label="RegionSphere"]
Av [label="AtomVec" color=red]
@ -34,6 +34,7 @@ digraph lammps {
Du [label="Dump" color=red]
Fi [label="Fix" color=red]
Cp [label="Compute" color=red]
Cm [label="Command" color=red]
Th [label="Thermo"]
Va [label="Variable"]
Ew [shape=box label="Ewald"]
@ -71,16 +72,19 @@ digraph lammps {
Dg [shape=box label="DumpCFG"]
Ve [shape=box label="Verlet"]
Rr [shape=box label="Respa"]
Ru [shape=box label="Run"]
Se [shape=box label="Set"]
Pt [shape=box label="PPPMTIP4P"]
Vs [shape=box label="VerletSplit"]
Ro [shape=box label="RespaOMP"]
Mc [shape=box label="MinCG"]
Mf [shape=box label="MinFire"]
La -> {At Ci Co Do Er Fo Gr In Me Mo Ne Ou Ti Up Un} [penwidth=2]
Do -> {Lt Rg} [penwidth=2]
Do -> {Rg Lt} [penwidth=2]
Rg -> {Rb Rs} [style=dashed penwidth=2]
Co -> {Cb Ct} [style=dashed penwidth=2]
In -> Va [penwidth=2]
In -> {Va Cm} [penwidth=2]
Cm -> {Ru Se} [style=dashed penwidth=2]
Mo -> {Fi Cp} [penwidth=2]
Fo -> {Pa Bo An Di Im Ks} [penwidth=2]
Ks -> {Ew Pp} [style=dashed penwidth=2]

16
doc/src/Developer_org.rst
View File

@ -49,8 +49,8 @@ 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.
are implemented with only a ``.h`` file. Examples are the Pointers and
Commands classes or the MathVec functions.
Class topology
--------------
@ -144,7 +144,7 @@ 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.
run, set, 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 source files are
@ -175,11 +175,11 @@ follows:
- The Input class reads and processes input input strings and files,
stores variables, and invokes :doc:`commands <Commands_all>`.
- As discussed above, command style classes are directly derived from
the Pointers class. They provide input script commands that perform
one-time operations before/after/between simulations or which invoke a
simulation. They are instantiated from within the Input class,
invoked, then immediately destructed.
- Command style classes are derived from the Command class. They provide
input script commands that perform one-time operations
before/after/between simulations or which invoke a simulation. They
are usually instantiated from within the Input class, its ``command``
method invoked, and then immediately destructed.
- The Finish class is instantiated to print statistics to the screen
after a simulation is performed, by commands like run and minimize.

61
doc/src/Developer_plugins.rst
View File

@ -59,31 +59,25 @@ Members of ``lammpsplugin_t``
* - author
- String with the name and email of the author
* - creator.v1
- Pointer to factory function for pair, bond, angle, dihedral, or improper styles
- Pointer to factory function for pair, bond, angle, dihedral, improper or command styles
* - creator.v2
- Pointer to factory function for compute, fix, or region styles
* - creator.v3
- Pointer to factory function for command styles
* - handle
- Pointer to the open DSO file handle
Only one of the three alternate creator entries can be used at a time
and which of those is determined by the style of plugin. The "creator.v1"
element is for factory functions of supported styles computing forces (i.e.
pair, bond, angle, dihedral, or improper styles) and the function takes
as single argument the pointer to the LAMMPS instance. The factory function
is cast to the ``lammpsplugin_factory1`` type before assignment. The
"creator.v2" element is for factory functions creating an instance of
a fix, compute, or region style and takes three arguments: a pointer to
the LAMMPS instance, an integer with the length of the argument list and
a ``char **`` pointer to the list of arguments. The factory function pointer
needs to be cast to the ``lammpsplugin_factory2`` type before assignment.
The "creator.v3" element takes the same arguments as "creator.v3" but is
specific to creating command styles: the factory function has to instantiate
the command style locally passing the LAMMPS pointer as argument and then
call its "command" member function with the number and list of arguments.
The factory function pointer needs to be cast to the
``lammpsplugin_factory3`` type before assignment.
and which of those is determined by the style of plugin. The
"creator.v1" element is for factory functions of supported styles
computing forces (i.e. command, pair, bond, angle, dihedral, or
improper styles) and the function takes as single argument the pointer
to the LAMMPS instance. The factory function is cast to the
``lammpsplugin_factory1`` type before assignment. The "creator.v2"
element is for factory functions creating an instance of a fix, compute,
or region style and takes three arguments: a pointer to the LAMMPS
instance, an integer with the length of the argument list and a ``char
**`` pointer to the list of arguments. The factory function pointer
needs to be cast to the ``lammpsplugin_factory2`` type before
assignment.
Pair style example
^^^^^^^^^^^^^^^^^^
@ -123,12 +117,12 @@ function would look like this:
The factory function in this example is called ``morse2creator()``. It
receives a pointer to the LAMMPS class as only argument and thus has to
be assigned to the *creator.v1* member of the plugin struct and cast to the
``lammpsplugin_factory1`` pointer type. It returns a
be assigned to the *creator.v1* member of the plugin struct and cast to
the ``lammpsplugin_factory1`` function pointer type. It returns a
pointer to the allocated class instance derived from the ``Pair`` class.
This function may be declared static to avoid clashes with other plugins.
The name of the derived class, ``PairMorse2``, must be unique inside
the entire LAMMPS executable.
This function may be declared static to avoid clashes with other
plugins. The name of the derived class, ``PairMorse2``, however must be
unique inside the entire LAMMPS executable.
Fix style example
^^^^^^^^^^^^^^^^^
@ -169,9 +163,9 @@ Below is an example for that:
Command style example
^^^^^^^^^^^^^^^^^^^^^
For command styles there is a third variant of factory function as
Command styles also use the first variant of factory function as
demonstrated in the following example, which also shows that the
implementation of the plugin class may also be within the same
implementation of the plugin class may be within the same source
file as the plugin interface code:
.. code-block:: C++
@ -180,15 +174,15 @@ file as the plugin interface code:
#include "comm.h"
#include "error.h"
#include "pointers.h"
#include "command.h"
#include "version.h"
#include <cstring>
namespace LAMMPS_NS {
class Hello : protected Pointers {
class Hello : public Command {
public:
Hello(class LAMMPS *lmp) : Pointers(lmp) {};
Hello(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
};
}
@ -202,10 +196,9 @@ file as the plugin interface code:
utils::logmesg(lmp,fmt::format("Hello, {}!\n",argv[0]));
}
static void hellocreator(LAMMPS *lmp, int argc, char **argv)
static void hellocreator(LAMMPS *lmp)
{
Hello hello(lmp);
hello.command(argc,argv);
return new Hello(lmp);
}
extern "C" void lammpsplugin_init(void *lmp, void *handle, void *regfunc)
@ -216,9 +209,9 @@ file as the plugin interface code:
plugin.version = LAMMPS_VERSION;
plugin.style = "command";
plugin.name = "hello";
plugin.info = "Hello world command v1.0";
plugin.info = "Hello world command v1.1";
plugin.author = "Axel Kohlmeyer (akohlmey@gmail.com)";
plugin.creator.v3 = (lammpsplugin_factory3 *) &hellocreator;
plugin.creator.v1 = (lammpsplugin_factory1 *) &hellocreator;
plugin.handle = handle;
(*register_plugin)(&plugin,lmp);
}

BIN
doc/src/JPG/lammps-classes.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 254 KiB

After

Width:  |  Height:  |  Size: 286 KiB

17
doc/src/Modify_command.rst
View File

@ -1,14 +1,15 @@
Input script command style
==========================
New commands can be added to LAMMPS input scripts by adding new
classes that have a "command" method. For example, the create_atoms,
read_data, velocity, and run commands are all implemented in this
fashion. When such a command is encountered in the LAMMPS input
script, LAMMPS simply creates a class with the corresponding name,
invokes the "command" method of the class, and passes it the arguments
from the input script. The command method can perform whatever
operations it wishes on LAMMPS data structures.
New commands can be added to LAMMPS input scripts by adding new classes
that are derived from the Command class and thus must have a "command"
method. For example, the create_atoms, read_data, velocity, and run
commands are all implemented in this fashion. When such a command is
encountered in the LAMMPS input script, LAMMPS simply creates a class
instance with the corresponding name, invokes the "command" method of
the class, and passes it the arguments from the input script. The
command method can perform whatever operations it wishes on LAMMPS data
structures.
The single method your new class must define is as follows:

15
examples/plugins/helloplugin.cpp
View File

@ -2,16 +2,16 @@
#include "lammpsplugin.h"
#include "comm.h"
#include "command.h"
#include "error.h"
#include "pointers.h"
#include "version.h"
#include <cstring>
namespace LAMMPS_NS {
class Hello : protected Pointers {
class Hello : public Command {
public:
Hello(class LAMMPS *lmp) : Pointers(lmp) {};
Hello(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
};
}
@ -25,10 +25,9 @@ void Hello::command(int argc, char **argv)
utils::logmesg(lmp,fmt::format("Hello, {}!\n",argv[0]));
}
static void hellocreator(LAMMPS *lmp, int argc, char **argv)
static Command *hellocreator(LAMMPS *lmp)
{
Hello hello(lmp);
hello.command(argc,argv);
return new Hello(lmp);
}
extern "C" void lammpsplugin_init(void *lmp, void *handle, void *regfunc)
@ -39,9 +38,9 @@ extern "C" void lammpsplugin_init(void *lmp, void *handle, void *regfunc)
plugin.version = LAMMPS_VERSION;
plugin.style = "command";
plugin.name = "hello";
plugin.info = "Hello world command v1.0";
plugin.info = "Hello world command v1.1";
plugin.author = "Axel Kohlmeyer (akohlmey@gmail.com)";
plugin.creator.v3 = (lammpsplugin_factory3 *) &hellocreator;
plugin.creator.v1 = (lammpsplugin_factory1 *) &hellocreator;
plugin.handle = handle;
(*register_plugin)(&plugin,lmp);
}

6
src/KIM/kim_command.h
View File

@ -62,13 +62,13 @@ CommandStyle(kim,KimCommand)
#ifndef LMP_KIM_COMMAND_H
#define LMP_KIM_COMMAND_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class KimCommand : protected Pointers {
class KimCommand : public Command {
public:
KimCommand(class LAMMPS *lmp) : Pointers(lmp) {};
KimCommand(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
};

6
src/MESSAGE/message.h
View File

@ -20,13 +20,13 @@ CommandStyle(message,Message)
#ifndef LMP_MESSAGE_H
#define LMP_MESSAGE_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Message : protected Pointers {
class Message : public Command {
public:
Message(class LAMMPS *lmp) : Pointers(lmp) {};
Message(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
private:

6
src/MESSAGE/server.h
View File

@ -20,13 +20,13 @@ CommandStyle(server,Server)
#ifndef LMP_SERVER_H
#define LMP_SERVER_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Server : protected Pointers {
class Server : public Command {
public:
Server(class LAMMPS *lmp) : Pointers(lmp) {};
Server(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
};

4
src/PLUGIN/plugin.cpp
View File

@ -41,7 +41,7 @@ namespace LAMMPS_NS
/* ---------------------------------------------------------------------- */
Plugin::Plugin(LAMMPS *lmp) : Pointers(lmp) {}
Plugin::Plugin(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */
@ -257,7 +257,7 @@ namespace LAMMPS_NS
"style {} from plugin",
plugin->name));
}
(*command_map)[plugin->name] = (Input::CommandCreator)plugin->creator.v3;
(*command_map)[plugin->name] = (Input::CommandCreator)plugin->creator.v1;
} else {
utils::logmesg(lmp,fmt::format("Loading plugin for {} styles not "

4
src/PLUGIN/plugin.h
View File

@ -21,12 +21,12 @@ CommandStyle(plugin,Plugin)
#define LMP_PLUGIN_H
#include "lammpsplugin.h"
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS
{
class Plugin : protected Pointers {
class Plugin : public Command {
public:
Plugin(class LAMMPS *);
void command(int, char **);

2
src/REPLICA/hyper.cpp
View File

@ -38,7 +38,7 @@ enum{NOHYPER,GLOBAL,LOCAL};
/* ---------------------------------------------------------------------- */
Hyper::Hyper(LAMMPS *lmp) : Pointers(lmp), dumplist(nullptr) {}
Hyper::Hyper(LAMMPS *lmp) : Command(lmp), dumplist(nullptr) {}
/* ----------------------------------------------------------------------
perform hyperdynamics simulation

4
src/REPLICA/hyper.h
View File

@ -20,11 +20,11 @@ CommandStyle(hyper,Hyper)
#ifndef LMP_HYPER_H
#define LMP_HYPER_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Hyper : protected Pointers {
class Hyper : public Command {
public:
Hyper(class LAMMPS *);
~Hyper() {}

4
src/REPLICA/neb.cpp
View File

@ -42,7 +42,7 @@ using namespace MathConst;
/* ---------------------------------------------------------------------- */
NEB::NEB(LAMMPS *lmp) : Pointers(lmp), all(nullptr), rdist(nullptr) {}
NEB::NEB(LAMMPS *lmp) : Command(lmp), all(nullptr), rdist(nullptr) {}
/* ----------------------------------------------------------------------
internal NEB constructor, called from TAD
@ -50,7 +50,7 @@ NEB::NEB(LAMMPS *lmp) : Pointers(lmp), all(nullptr), rdist(nullptr) {}
NEB::NEB(LAMMPS *lmp, double etol_in, double ftol_in, int n1steps_in,
int n2steps_in, int nevery_in, double *buf_init, double *buf_final)
: Pointers(lmp), all(nullptr), rdist(nullptr)
: Command(lmp), all(nullptr), rdist(nullptr)
{
double delx,dely,delz;

4
src/REPLICA/neb.h
View File

@ -20,11 +20,11 @@ CommandStyle(neb,NEB)
#ifndef LMP_NEB_H
#define LMP_NEB_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class NEB : protected Pointers {
class NEB : public Command {
public:
NEB(class LAMMPS *);
NEB(class LAMMPS *, double, double, int, int, int, double *, double *);

2
src/REPLICA/prd.cpp
View File

@ -46,7 +46,7 @@ enum{SINGLE_PROC_DIRECT,SINGLE_PROC_MAP,MULTI_PROC};
/* ---------------------------------------------------------------------- */
PRD::PRD(LAMMPS *lmp) : Pointers(lmp) {}
PRD::PRD(LAMMPS *lmp) : Command(lmp) {}
/* ----------------------------------------------------------------------
perform PRD simulation on one or more replicas

4
src/REPLICA/prd.h
View File

@ -20,11 +20,11 @@ CommandStyle(prd,PRD)
#ifndef LMP_PRD_H
#define LMP_PRD_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class PRD : protected Pointers {
class PRD : public Command {
public:
PRD(class LAMMPS *);
~PRD() {}

2
src/REPLICA/tad.cpp
View File

@ -43,7 +43,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
TAD::TAD(LAMMPS *lmp) : Pointers(lmp) {}
TAD::TAD(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/REPLICA/tad.h
View File

@ -20,11 +20,11 @@ CommandStyle(tad,TAD)
#ifndef LMP_TAD_H
#define LMP_TAD_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class TAD : protected Pointers {
class TAD : public Command {
public:
TAD(class LAMMPS *);
~TAD();

2
src/REPLICA/temper.cpp
View File

@ -40,7 +40,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
Temper::Temper(LAMMPS *lmp) : Pointers(lmp) {}
Temper::Temper(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/REPLICA/temper.h
View File

@ -20,11 +20,11 @@ CommandStyle(temper,Temper)
#ifndef LMP_TEMPER_H
#define LMP_TEMPER_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Temper : protected Pointers {
class Temper : public Command {
public:
Temper(class LAMMPS *);
~Temper();

2
src/SPIN/neb_spin.cpp
View File

@ -67,7 +67,7 @@ static const char cite_neb_spin[] =
/* ---------------------------------------------------------------------- */
NEBSpin::NEBSpin(LAMMPS *lmp) : Pointers(lmp) {
NEBSpin::NEBSpin(LAMMPS *lmp) : Command(lmp) {
if (lmp->citeme) lmp->citeme->add(cite_neb_spin);
}

4
src/SPIN/neb_spin.h
View File

@ -20,11 +20,11 @@ CommandStyle(neb/spin,NEBSpin)
#ifndef LMP_NEB_SPIN_H
#define LMP_NEB_SPIN_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class NEBSpin : protected Pointers {
class NEBSpin : public Command {
public:
NEBSpin(class LAMMPS *);
~NEBSpin();

6
src/USER-COLVARS/group_ndx.h
View File

@ -22,13 +22,13 @@ CommandStyle(group2ndx,Group2Ndx)
#ifndef LMP_GROUP_NDX_H
#define LMP_GROUP_NDX_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Group2Ndx : protected Pointers {
class Group2Ndx : public Command {
public:
Group2Ndx(class LAMMPS *lmp) : Pointers(lmp) {};
Group2Ndx(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
private:
void write_group(FILE *, int);

6
src/USER-COLVARS/ndx_group.h
View File

@ -22,14 +22,14 @@ CommandStyle(ndx2group,Ndx2Group)
#ifndef LMP_NDX_GROUP_H
#define LMP_NDX_GROUP_H
#include "pointers.h"
#include "command.h"
#include <vector>
namespace LAMMPS_NS {
class Ndx2Group : protected Pointers {
class Ndx2Group : public Command {
public:
Ndx2Group(class LAMMPS *lmp) : Pointers(lmp) {};
Ndx2Group(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
void create(const std::string &, const std::vector<tagint> &);
};

2
src/USER-MISC/temper_grem.cpp
View File

@ -40,7 +40,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
TemperGrem::TemperGrem(LAMMPS *lmp) : Pointers(lmp) {}
TemperGrem::TemperGrem(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/USER-MISC/temper_grem.h
View File

@ -20,11 +20,11 @@ CommandStyle(temper/grem,TemperGrem)
#ifndef LMP_TEMPER_GREM_H
#define LMP_TEMPER_GREM_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class TemperGrem : protected Pointers {
class TemperGrem : public Command {
public:
TemperGrem(class LAMMPS *);
~TemperGrem();

2
src/USER-MISC/temper_npt.cpp
View File

@ -42,7 +42,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
TemperNPT::TemperNPT(LAMMPS *lmp) : Pointers(lmp) {}
TemperNPT::TemperNPT(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/USER-MISC/temper_npt.h
View File

@ -21,11 +21,11 @@ CommandStyle(temper/npt,TemperNPT)
#ifndef LMP_TEMPERNPT_H
#define LMP_TEMPERNPT_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class TemperNPT : protected Pointers {
class TemperNPT : public Command {
public:
TemperNPT(class LAMMPS *);
~TemperNPT();

2
src/USER-PHONON/dynamical_matrix.cpp
View File

@ -32,7 +32,7 @@ enum{REGULAR,ESKM};
/* ---------------------------------------------------------------------- */
DynamicalMatrix::DynamicalMatrix(LAMMPS *lmp) : Pointers(lmp), fp(nullptr)
DynamicalMatrix::DynamicalMatrix(LAMMPS *lmp) : Command(lmp), fp(nullptr)
{
external_force_clear = 1;
}

86
src/USER-PHONON/dynamical_matrix.h
View File

@ -11,62 +11,62 @@ CommandStyle(dynamical_matrix,DynamicalMatrix)
#ifndef LMP_DYNAMICAL_MATRIX_H
#define LMP_DYNAMICAL_MATRIX_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class DynamicalMatrix : protected Pointers {
public:
DynamicalMatrix(class LAMMPS *);
virtual ~DynamicalMatrix();
void command(int, char **);
void setup();
class DynamicalMatrix : public Command {
public:
DynamicalMatrix(class LAMMPS *);
virtual ~DynamicalMatrix();
void command(int, char **);
void setup();
protected:
int eflag,vflag; // flags for energy/virial computation
int external_force_clear; // clear forces locally or externally
protected:
int eflag,vflag; // flags for energy/virial computation
int external_force_clear; // clear forces locally or externally
int triclinic; // 0 if domain is orthog, 1 if triclinic
int pairflag;
int triclinic; // 0 if domain is orthog, 1 if triclinic
int pairflag;
int pair_compute_flag; // 0 if pair->compute is skipped
int kspace_compute_flag; // 0 if kspace->compute is skipped
int pair_compute_flag; // 0 if pair->compute is skipped
int kspace_compute_flag; // 0 if kspace->compute is skipped
int nvec; // local atomic dof = length of xvec
int nvec; // local atomic dof = length of xvec
void update_force();
void force_clear();
virtual void openfile(const char* filename);
void update_force();
void force_clear();
virtual void openfile(const char* filename);
private:
void options(int, char **);
void calculateMatrix();
void dynmat_clear(double **dynmat);
void create_groupmap();
void writeMatrix(double **dynmat);
void convert_units(const char *style);
void displace_atom(int local_idx, int direction, int magnitude);
private:
void options(int, char **);
void calculateMatrix();
void dynmat_clear(double **dynmat);
void create_groupmap();
void writeMatrix(double **dynmat);
void convert_units(const char *style);
void displace_atom(int local_idx, int direction, int magnitude);
double conversion;
double conv_energy;
double conv_distance;
double conv_mass;
double del;
int igroup,groupbit;
bigint gcount; // number of atoms in group
bigint dynlen; // rank of dynamical matrix
int scaleflag;
int me;
bigint *groupmap;
double conversion;
double conv_energy;
double conv_distance;
double conv_mass;
double del;
int igroup,groupbit;
bigint gcount; // number of atoms in group
bigint dynlen; // rank of dynamical matrix
int scaleflag;
int me;
bigint *groupmap;
int compressed; // 1 if dump file is written compressed, 0 no
int binaryflag; // 1 if dump file is written binary, 0 no
int file_opened; // 1 if openfile method has been called, 0 no
int file_flag; // 1 custom file name, 0 dynmat.dat
int compressed; // 1 if dump file is written compressed, 0 no
int binaryflag; // 1 if dump file is written binary, 0 no
int file_opened; // 1 if openfile method has been called, 0 no
int file_flag; // 1 custom file name, 0 dynmat.dat
FILE *fp;
};
FILE *fp;
};
}

2
src/USER-PHONON/third_order.cpp
View File

@ -32,7 +32,7 @@ enum{REGULAR,BALLISTICO};
/* ---------------------------------------------------------------------- */
ThirdOrder::ThirdOrder(LAMMPS *lmp) : Pointers(lmp), fp(nullptr)
ThirdOrder::ThirdOrder(LAMMPS *lmp) : Command(lmp), fp(nullptr)
{
external_force_clear = 1;
}

4
src/USER-PHONON/third_order.h
View File

@ -12,11 +12,11 @@ CommandStyle(third_order,ThirdOrder)
#ifndef LMP_THIRD_ORDER_H
#define LMP_THIRD_ORDER_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class ThirdOrder : protected Pointers {
class ThirdOrder : public Command {
public:
ThirdOrder(class LAMMPS *);
virtual ~ThirdOrder();

2
src/balance.cpp
View File

@ -51,7 +51,7 @@ enum{X,Y,Z};
/* ---------------------------------------------------------------------- */
Balance::Balance(LAMMPS *lmp) : Pointers(lmp)
Balance::Balance(LAMMPS *lmp) : Command(lmp)
{
MPI_Comm_rank(world,&me);
MPI_Comm_size(world,&nprocs);

4
src/balance.h
View File

@ -20,11 +20,11 @@ CommandStyle(balance,Balance)
#ifndef LMP_BALANCE_H
#define LMP_BALANCE_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Balance : protected Pointers {
class Balance : public Command {
public:
class RCB *rcb;
class FixStore *fixstore; // per-atom weights stored in FixStore

2
src/change_box.cpp
View File

@ -35,7 +35,7 @@ enum{X=0,Y,Z,YZ,XZ,XY};
/* ---------------------------------------------------------------------- */
ChangeBox::ChangeBox(LAMMPS *lmp) : Pointers(lmp) {}
ChangeBox::ChangeBox(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/change_box.h
View File

@ -20,11 +20,11 @@ CommandStyle(change_box,ChangeBox)
#ifndef LMP_CHANGE_BOX_H
#define LMP_CHANGE_BOX_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class ChangeBox : protected Pointers {
class ChangeBox : public Command {
public:
ChangeBox(class LAMMPS *);
void command(int, char **);

29
src/command.h Normal file
View File

@ -0,0 +1,29 @@
/* -*- c++ -*- ----------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#ifndef LMP_COMMAND_H
#define LMP_COMMAND_H
#include "pointers.h"
namespace LAMMPS_NS {
class Command : protected Pointers {
public:
Command(class LAMMPS *lmp) : Pointers(lmp) {};
virtual void command(int, char **) = 0;
};
}
#endif

2
src/create_atoms.cpp
View File

@ -52,7 +52,7 @@ enum{NONE,RATIO,SUBSET};
/* ---------------------------------------------------------------------- */
CreateAtoms::CreateAtoms(LAMMPS *lmp) : Pointers(lmp), basistype(nullptr) {}
CreateAtoms::CreateAtoms(LAMMPS *lmp) : Command(lmp), basistype(nullptr) {}
/* ---------------------------------------------------------------------- */

4
src/create_atoms.h
View File

@ -20,11 +20,11 @@ CommandStyle(create_atoms,CreateAtoms)
#ifndef LMP_CREATE_ATOMS_H
#define LMP_CREATE_ATOMS_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class CreateAtoms : protected Pointers {
class CreateAtoms : public Command {
public:
CreateAtoms(class LAMMPS *);
void command(int, char **);

2
src/create_bonds.cpp
View File

@ -38,7 +38,7 @@ enum{MANY,SBOND,SANGLE,SDIHEDRAL,SIMPROPER};
/* ---------------------------------------------------------------------- */
CreateBonds::CreateBonds(LAMMPS *lmp) : Pointers(lmp) {}
CreateBonds::CreateBonds(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/create_bonds.h
View File

@ -20,11 +20,11 @@ CommandStyle(create_bonds,CreateBonds)
#ifndef LMP_CREATE_BONDS_H
#define LMP_CREATE_BONDS_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class CreateBonds : protected Pointers {
class CreateBonds : public Command {
public:
CreateBonds(class LAMMPS *);
void command(int, char **);

12
src/create_box.cpp
View File

@ -12,22 +12,24 @@
------------------------------------------------------------------------- */
#include "create_box.h"
#include <cstring>
#include "atom.h"
#include "atom_vec.h"
#include "comm.h"
#include "domain.h"
#include "error.h"
#include "force.h"
#include "region.h"
#include "region_prism.h"
#include "force.h"
#include "comm.h"
#include "update.h"
#include "error.h"
#include <cstring>
using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
CreateBox::CreateBox(LAMMPS *lmp) : Pointers(lmp) {}
CreateBox::CreateBox(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/create_box.h
View File

@ -20,11 +20,11 @@ CommandStyle(create_box,CreateBox)
#ifndef LMP_CREATE_BOX_H
#define LMP_CREATE_BOX_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class CreateBox : protected Pointers {
class CreateBox : public Command {
public:
CreateBox(class LAMMPS *);
void command(int, char **);

2
src/delete_atoms.cpp
View File

@ -41,7 +41,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
DeleteAtoms::DeleteAtoms(LAMMPS *lmp) : Pointers(lmp) {}
DeleteAtoms::DeleteAtoms(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/delete_atoms.h
View File

@ -20,12 +20,12 @@ CommandStyle(delete_atoms,DeleteAtoms)
#ifndef LMP_DELETE_ATOMS_H
#define LMP_DELETE_ATOMS_H
#include "pointers.h"
#include "command.h"
#include <map>
namespace LAMMPS_NS {
class DeleteAtoms : protected Pointers {
class DeleteAtoms : public Command {
public:
DeleteAtoms(class LAMMPS *);
void command(int, char **);

2
src/delete_bonds.cpp
View File

@ -30,7 +30,7 @@ enum{MULTI,ATOM,BOND,ANGLE,DIHEDRAL,IMPROPER,STATS};
/* ---------------------------------------------------------------------- */
DeleteBonds::DeleteBonds(LAMMPS *lmp) : Pointers(lmp) {}
DeleteBonds::DeleteBonds(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/delete_bonds.h
View File

@ -20,11 +20,11 @@ CommandStyle(delete_bonds,DeleteBonds)
#ifndef LMP_DELETE_BONDS_H
#define LMP_DELETE_BONDS_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class DeleteBonds : protected Pointers {
class DeleteBonds : public Command {
public:
DeleteBonds(class LAMMPS *);
void command(int, char **);

6
src/deprecated.h
View File

@ -26,13 +26,13 @@ CommandStyle(kim_query,Deprecated)
#ifndef LMP_DEPRECATED_H
#define LMP_DEPRECATED_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Deprecated : protected Pointers {
class Deprecated : public Command {
public:
Deprecated(class LAMMPS *lmp) : Pointers(lmp) {};
Deprecated(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
};

2
src/displace_atoms.cpp
View File

@ -42,7 +42,7 @@ enum{MOVE,RAMP,RANDOM,ROTATE};
/* ---------------------------------------------------------------------- */
DisplaceAtoms::DisplaceAtoms(LAMMPS *lmp) : Pointers(lmp)
DisplaceAtoms::DisplaceAtoms(LAMMPS *lmp) : Command(lmp)
{
mvec = nullptr;
}

4
src/displace_atoms.h
View File

@ -20,11 +20,11 @@ CommandStyle(displace_atoms,DisplaceAtoms)
#ifndef LMP_DISPLACE_ATOMS_H
#define LMP_DISPLACE_ATOMS_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class DisplaceAtoms : protected Pointers {
class DisplaceAtoms : public Command {
public:
DisplaceAtoms(class LAMMPS *);
~DisplaceAtoms();

6
src/info.h
View File

@ -20,15 +20,15 @@ CommandStyle(info,Info)
#ifndef LMP_INFO_H
#define LMP_INFO_H
#include "pointers.h"
#include "command.h"
#include <vector>
namespace LAMMPS_NS {
class Info : protected Pointers {
class Info : public Command {
public:
Info(class LAMMPS *lmp) : Pointers(lmp) {};
Info(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
bool is_active(const char *, const char *);

12
src/input.cpp
View File

@ -21,6 +21,7 @@
#include "comm.h"
#include "comm_brick.h"
#include "comm_tiled.h"
#include "command.h"
#include "compute.h"
#include "dihedral.h"
#include "domain.h"
@ -82,7 +83,7 @@ command line flags, holds the factory of commands and creates and
initializes an instance of the Variable class.
To execute a command, a specific class instance, derived from
:cpp:class:`Pointers`, is created, then its ``command()`` member
:cpp:class:`Command`, is created, then its ``command()`` member
function executed, and finally the class instance is deleted.
\endverbatim
@ -789,7 +790,9 @@ int Input::execute_command()
if (command_map->find(command) != command_map->end()) {
CommandCreator &command_creator = (*command_map)[command];
command_creator(lmp,narg,arg);
Command *cmd = command_creator(lmp);
cmd->command(narg,arg);
delete cmd;
return 0;
}
@ -803,10 +806,9 @@ int Input::execute_command()
------------------------------------------------------------------------- */
template <typename T>
void Input::command_creator(LAMMPS *lmp, int narg, char **arg)
Command *Input::command_creator(LAMMPS *lmp)
{
T cmd(lmp);
cmd.command(narg,arg);
return new T(lmp);
}
/* ---------------------------------------------------------------------- */

5
src/input.h
View File

@ -19,6 +19,7 @@
#include <map>
namespace LAMMPS_NS {
class Command;
class Input : protected Pointers {
friend class Info;
@ -59,12 +60,12 @@ class Input : protected Pointers {
FILE **infiles; // list of open input files
public:
typedef void (*CommandCreator)(LAMMPS *, int, char **);
typedef Command * (*CommandCreator)(LAMMPS *);
typedef std::map<std::string,CommandCreator> CommandCreatorMap;
CommandCreatorMap *command_map;
protected:
template <typename T> static void command_creator(LAMMPS *, int, char **);
template <typename T> static Command *command_creator(LAMMPS *);
private:
void parse(); // parse an input text line

2
src/lammpsplugin.h
View File

@ -20,7 +20,6 @@ extern "C" {
typedef void *(lammpsplugin_factory1)(void *);
typedef void *(lammpsplugin_factory2)(void *, int, char **);
typedef void (lammpsplugin_factory3)(void *, int, char **);
typedef struct {
const char *version;
@ -31,7 +30,6 @@ extern "C" {
union {
lammpsplugin_factory1 *v1;
lammpsplugin_factory2 *v2;
lammpsplugin_factory3 *v3;
} creator;
void *handle;
} lammpsplugin_t;

2
src/minimize.cpp
View File

@ -25,7 +25,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
Minimize::Minimize(LAMMPS *lmp) : Pointers(lmp) {}
Minimize::Minimize(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/minimize.h
View File

@ -20,11 +20,11 @@ CommandStyle(minimize,Minimize)
#ifndef LMP_MINIMIZE_H
#define LMP_MINIMIZE_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Minimize : protected Pointers {
class Minimize : public Command {
public:
Minimize(class LAMMPS *);
void command(int, char **);

6
src/read_data.cpp
View File

@ -11,10 +11,6 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
// lmptype.h must be first b/c this file uses MAXBIGINT and includes mpi.h
// due to OpenMPI bug which sets INT64_MAX via its mpi.h
// before lmptype.h can set flags to insure it is done correctly
#include "read_data.h"
#include "angle.h"
@ -66,7 +62,7 @@ const char *suffixes[] = {"/cuda","/gpu","/opt","/omp","/kk",
/* ---------------------------------------------------------------------- */
ReadData::ReadData(LAMMPS *lmp) : Pointers(lmp)
ReadData::ReadData(LAMMPS *lmp) : Command(lmp)
{
MPI_Comm_rank(world,&me);
line = new char[MAXLINE];

4
src/read_data.h
View File

@ -20,11 +20,11 @@ CommandStyle(read_data,ReadData)
#ifndef LMP_READ_DATA_H
#define LMP_READ_DATA_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class ReadData : protected Pointers {
class ReadData : public Command {
public:
ReadData(class LAMMPS *);
~ReadData();

6
src/read_dump.cpp
View File

@ -15,10 +15,6 @@
Contributing author: Timothy Sirk (ARL)
------------------------------------------------------------------------- */
// lmptype.h must be first b/c this file uses MAXBIGINT and includes mpi.h
// due to OpenMPI bug which sets INT64_MAX via its mpi.h
// before lmptype.h can set flags to insure it is done correctly
#include "read_dump.h"
#include "atom.h"
@ -46,7 +42,7 @@ enum{NOADD,YESADD,KEEPADD};
/* ---------------------------------------------------------------------- */
ReadDump::ReadDump(LAMMPS *lmp) : Pointers(lmp)
ReadDump::ReadDump(LAMMPS *lmp) : Command(lmp)
{
MPI_Comm_rank(world,&me);
MPI_Comm_size(world,&nprocs);

4
src/read_dump.h
View File

@ -22,11 +22,11 @@ CommandStyle(read_dump,ReadDump)
#ifndef LMP_READ_DUMP_H
#define LMP_READ_DUMP_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class ReadDump : protected Pointers {
class ReadDump : public Command {
public:
ReadDump(class LAMMPS *);
~ReadDump();

2
src/read_restart.cpp
View File

@ -43,7 +43,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
ReadRestart::ReadRestart(LAMMPS *lmp) : Pointers(lmp) {}
ReadRestart::ReadRestart(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/read_restart.h
View File

@ -20,11 +20,11 @@ CommandStyle(read_restart,ReadRestart)
#ifndef LMP_READ_RESTART_H
#define LMP_READ_RESTART_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class ReadRestart : protected Pointers {
class ReadRestart : public Command {
public:
ReadRestart(class LAMMPS *);
void command(int, char **);

2
src/replicate.cpp
View File

@ -31,7 +31,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
Replicate::Replicate(LAMMPS *lmp) : Pointers(lmp) {}
Replicate::Replicate(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/replicate.h
View File

@ -20,11 +20,11 @@ CommandStyle(replicate,Replicate)
#ifndef LMP_REPLICATE_H
#define LMP_REPLICATE_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Replicate : protected Pointers {
class Replicate : public Command {
public:
Replicate(class LAMMPS *);
void command(int, char **);

2
src/rerun.cpp
View File

@ -29,7 +29,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
Rerun::Rerun(LAMMPS *lmp) : Pointers(lmp) {}
Rerun::Rerun(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/rerun.h
View File

@ -20,11 +20,11 @@ CommandStyle(rerun,Rerun)
#ifndef LMP_RERUN_H
#define LMP_RERUN_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Rerun : protected Pointers {
class Rerun : public Command {
public:
Rerun(class LAMMPS *);
void command(int, char **);

2
src/reset_atom_ids.cpp
View File

@ -43,7 +43,7 @@ static int compare_coords(const int, const int, void *);
/* ---------------------------------------------------------------------- */
ResetIDs::ResetIDs(LAMMPS *lmp) : Pointers(lmp) {}
ResetIDs::ResetIDs(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/reset_atom_ids.h
View File

@ -20,11 +20,11 @@ CommandStyle(reset_atom_ids,ResetIDs)
#ifndef LMP_RESET_IDS_H
#define LMP_RESET_IDS_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class ResetIDs : protected Pointers {
class ResetIDs : public Command {
public:
struct AtomRvous {
bigint ibin;

2
src/reset_mol_ids.cpp
View File

@ -32,7 +32,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
ResetMolIDs::ResetMolIDs(LAMMPS *lmp) : Pointers(lmp) {
ResetMolIDs::ResetMolIDs(LAMMPS *lmp) : Command(lmp) {
cfa = nullptr;
cca = nullptr;

4
src/reset_mol_ids.h
View File

@ -20,11 +20,11 @@ CommandStyle(reset_mol_ids,ResetMolIDs)
#ifndef LMP_RESET_MOL_IDS_H
#define LMP_RESET_MOL_IDS_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class ResetMolIDs : protected Pointers {
class ResetMolIDs : public Command {
public:
ResetMolIDs(class LAMMPS *);
~ResetMolIDs();

2
src/run.cpp
View File

@ -31,7 +31,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
Run::Run(LAMMPS *lmp) : Pointers(lmp) {}
Run::Run(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/run.h
View File

@ -20,11 +20,11 @@ CommandStyle(run,Run)
#ifndef LMP_RUN_H
#define LMP_RUN_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Run : protected Pointers {
class Run : public Command {
public:
Run(class LAMMPS *);
void command(int, char **);

6
src/set.h
View File

@ -20,13 +20,13 @@ CommandStyle(set,Set)
#ifndef LMP_SET_H
#define LMP_SET_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Set : protected Pointers {
class Set : public Command {
public:
Set(class LAMMPS *lmp) : Pointers(lmp) {};
Set(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
private:

2
src/velocity.cpp
View File

@ -42,7 +42,7 @@ enum{NONE,CONSTANT,EQUAL,ATOM};
/* ---------------------------------------------------------------------- */
Velocity::Velocity(LAMMPS *lmp) : Pointers(lmp) {}
Velocity::Velocity(LAMMPS *lmp) : Command(lmp) {}
/* ---------------------------------------------------------------------- */

4
src/velocity.h
View File

@ -20,11 +20,11 @@ CommandStyle(velocity,Velocity)
#ifndef LMP_VELOCITY_H
#define LMP_VELOCITY_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class Velocity : protected Pointers {
class Velocity : public Command {
public:
Velocity(class LAMMPS *);
void command(int, char **);

6
src/write_coeff.h
View File

@ -20,13 +20,13 @@ CommandStyle(write_coeff,WriteCoeff)
#ifndef LMP_WRITE_COEFF_H
#define LMP_WRITE_COEFF_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class WriteCoeff : protected Pointers {
class WriteCoeff : public Command {
public:
WriteCoeff(class LAMMPS *lmp) : Pointers(lmp) {};
WriteCoeff(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
};

2
src/write_data.cpp
View File

@ -41,7 +41,7 @@ enum{ELLIPSOID,LINE,TRIANGLE,BODY}; // also in AtomVecHybrid
/* ---------------------------------------------------------------------- */
WriteData::WriteData(LAMMPS *lmp) : Pointers(lmp)
WriteData::WriteData(LAMMPS *lmp) : Command(lmp)
{
MPI_Comm_rank(world,&me);
MPI_Comm_size(world,&nprocs);

4
src/write_data.h
View File

@ -20,11 +20,11 @@ CommandStyle(write_data,WriteData)
#ifndef LMP_WRITE_DATA_H
#define LMP_WRITE_DATA_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class WriteData : protected Pointers {
class WriteData : public Command {
public:
WriteData(class LAMMPS *);
void command(int, char **);

6
src/write_dump.h
View File

@ -20,13 +20,13 @@ CommandStyle(write_dump,WriteDump)
#ifndef LMP_WRITE_DUMP_H
#define LMP_WRITE_DUMP_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class WriteDump : protected Pointers {
class WriteDump : public Command {
public:
WriteDump(class LAMMPS *lmp) : Pointers(lmp) {};
WriteDump(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
};

2
src/write_restart.cpp
View File

@ -43,7 +43,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
WriteRestart::WriteRestart(LAMMPS *lmp) : Pointers(lmp)
WriteRestart::WriteRestart(LAMMPS *lmp) : Command(lmp)
{
MPI_Comm_rank(world,&me);
MPI_Comm_size(world,&nprocs);

4
src/write_restart.h
View File

@ -20,11 +20,11 @@ CommandStyle(write_restart,WriteRestart)
#ifndef LMP_WRITE_RESTART_H
#define LMP_WRITE_RESTART_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class WriteRestart : protected Pointers {
class WriteRestart : public Command {
public:
WriteRestart(class LAMMPS *);
void command(int, char **);