diff --git a/cmake/Modules/StyleHeaderUtils.cmake b/cmake/Modules/StyleHeaderUtils.cmake index 2bc84252d3..d95e265c4a 100644 --- a/cmake/Modules/StyleHeaderUtils.cmake +++ b/cmake/Modules/StyleHeaderUtils.cmake @@ -95,27 +95,27 @@ function(RegisterIntegrateStyle path) endfunction(RegisterIntegrateStyle) function(RegisterStyles search_path) - FindStyleHeaders(${search_path} ANGLE_CLASS angle_ ANGLE ) # angle ) # force - FindStyleHeaders(${search_path} ATOM_CLASS atom_vec_ ATOM_VEC ) # atom ) # atom atom_vec_hybrid - FindStyleHeaders(${search_path} BODY_CLASS body_ BODY ) # body ) # atom_vec_body - FindStyleHeaders(${search_path} BOND_CLASS bond_ BOND ) # bond ) # force - FindStyleHeaders(${search_path} COMMAND_CLASS "[^.]" COMMAND ) # command ) # input - FindStyleHeaders(${search_path} COMPUTE_CLASS compute_ COMPUTE ) # compute ) # modify - FindStyleHeaders(${search_path} DIHEDRAL_CLASS dihedral_ DIHEDRAL ) # dihedral ) # force - FindStyleHeaders(${search_path} DUMP_CLASS dump_ DUMP ) # dump ) # output write_dump - FindStyleHeaders(${search_path} FIX_CLASS fix_ FIX ) # fix ) # modify - FindStyleHeaders(${search_path} GSM_CLASS gsm_ GSM ) # gsm ) # granular_model - FindStyleHeaders(${search_path} IMPROPER_CLASS improper_ IMPROPER ) # improper ) # force - FindStyleHeaders(${search_path} INTEGRATE_CLASS "[^.]" INTEGRATE ) # integrate ) # update - FindStyleHeaders(${search_path} KSPACE_CLASS "[^.]" KSPACE ) # kspace ) # force - FindStyleHeaders(${search_path} MINIMIZE_CLASS min_ MINIMIZE ) # minimize ) # update - FindStyleHeaders(${search_path} NBIN_CLASS nbin_ NBIN ) # nbin ) # neighbor - FindStyleHeaders(${search_path} NPAIR_CLASS npair_ NPAIR ) # npair ) # neighbor - FindStyleHeaders(${search_path} NSTENCIL_CLASS nstencil_ NSTENCIL ) # nstencil ) # neighbor - FindStyleHeaders(${search_path} NTOPO_CLASS ntopo_ NTOPO ) # ntopo ) # neighbor - FindStyleHeaders(${search_path} PAIR_CLASS pair_ PAIR ) # pair ) # force - FindStyleHeaders(${search_path} READER_CLASS reader_ READER ) # reader ) # read_dump - FindStyleHeaders(${search_path} REGION_CLASS region_ REGION ) # region ) # domain + FindStyleHeaders(${search_path} ANGLE_CLASS angle_ ANGLE ) # angle ) # force + FindStyleHeaders(${search_path} ATOM_CLASS atom_vec_ ATOM_VEC ) # atom ) # atom atom_vec_hybrid + FindStyleHeaders(${search_path} BODY_CLASS body_ BODY ) # body ) # atom_vec_body + FindStyleHeaders(${search_path} BOND_CLASS bond_ BOND ) # bond ) # force + FindStyleHeaders(${search_path} COMMAND_CLASS "[^.]" COMMAND ) # command ) # input + FindStyleHeaders(${search_path} COMPUTE_CLASS compute_ COMPUTE ) # compute ) # modify + FindStyleHeaders(${search_path} DIHEDRAL_CLASS dihedral_ DIHEDRAL ) # dihedral ) # force + FindStyleHeaders(${search_path} DUMP_CLASS dump_ DUMP ) # dump ) # output write_dump + FindStyleHeaders(${search_path} FIX_CLASS fix_ FIX ) # fix ) # modify + FindStyleHeaders(${search_path} GRAN_SUB_MOD_CLASS gran_sub_mod_ GRAN_SUB_MOD ) # gran_sub_mod ) # granular_model + FindStyleHeaders(${search_path} IMPROPER_CLASS improper_ IMPROPER ) # improper ) # force + FindStyleHeaders(${search_path} INTEGRATE_CLASS "[^.]" INTEGRATE ) # integrate ) # update + FindStyleHeaders(${search_path} KSPACE_CLASS "[^.]" KSPACE ) # kspace ) # force + FindStyleHeaders(${search_path} MINIMIZE_CLASS min_ MINIMIZE ) # minimize ) # update + FindStyleHeaders(${search_path} NBIN_CLASS nbin_ NBIN ) # nbin ) # neighbor + FindStyleHeaders(${search_path} NPAIR_CLASS npair_ NPAIR ) # npair ) # neighbor + FindStyleHeaders(${search_path} NSTENCIL_CLASS nstencil_ NSTENCIL ) # nstencil ) # neighbor + FindStyleHeaders(${search_path} NTOPO_CLASS ntopo_ NTOPO ) # ntopo ) # neighbor + FindStyleHeaders(${search_path} PAIR_CLASS pair_ PAIR ) # pair ) # force + FindStyleHeaders(${search_path} READER_CLASS reader_ READER ) # reader ) # read_dump + FindStyleHeaders(${search_path} REGION_CLASS region_ REGION ) # region ) # domain endfunction(RegisterStyles) function(RegisterStylesExt search_path extension sources) diff --git a/doc/src/Modify.rst b/doc/src/Modify.rst index 39a1faeb87..8ea7850fc5 100644 --- a/doc/src/Modify.rst +++ b/doc/src/Modify.rst @@ -34,6 +34,6 @@ style requirements and recommendations `. Modify_min Modify_region Modify_body - Modify_gsm + Modify_gran_sub_mod Modify_thermo Modify_variable diff --git a/doc/src/Modify_gsm.rst b/doc/src/Modify_gran_sub_mod.rst similarity index 59% rename from doc/src/Modify_gsm.rst rename to doc/src/Modify_gran_sub_mod.rst index 515c776c6c..fe8b0da275 100644 --- a/doc/src/Modify_gsm.rst +++ b/doc/src/Modify_gran_sub_mod.rst @@ -1,4 +1,4 @@ -Granular Sub-model (GSM) styles +Granular Sub-Model styles =============================== In granular models, particles are spheres with a finite radius and rotational @@ -11,27 +11,27 @@ torques, and heat flow between two types of bodies is defined using a GranularModel class. The GranularModel class organizes the details of an interaction using a series of granular sub-models each of which describe a particular interaction mode (e.g. normal forces or rolling friction). From a -parent GSM class, several types of sub-model classes are derived: +parent GranSubMod class, several types of sub-model classes are derived: -* GSMNormal: normal force sub-model -* GSMDamping: normal damping sub-model -* GSMTangential: tangential forces and sliding friction sub-model -* GSMRolling: rolling friction sub-model -* GSMTwisting: twisting friction sub-model -* GSMHeat: heat conduction sub-model +* GranSubModNormal: normal force sub-model +* GranSubModDamping: normal damping sub-model +* GranSubModTangential: tangential forces and sliding friction sub-model +* GranSubModRolling: rolling friction sub-model +* GranSubModTwisting: twisting friction sub-model +* GranSubModHeat: heat conduction sub-model For each type of sub-model, more classes are further derived, each describing -a specific implementation. For instance, from the GSMNormal class the -GSMNormalHooke, GSMNormalHertz, and GSMNormalJKR classes are derived which -calculate Hookean, Hertzian, or JKR normal forces, respectively. This modular -structure simplifies the addition of new granular contact models as as one only -needs to create a new GSM class without having to modify the more complex -PairGranular, FixGranWall, and GranularModel classes. Most GSM methods are also -already defined by the parent classes so new contact models typically only require -edits to a few relevant methods (e.g. methods that define coefficients and +a specific implementation. For instance, from the GranSubModNormal class the +GranSubModNormalHooke, GranSubModNormalHertz, and GranSubModNormalJKR classes +are derived which calculate Hookean, Hertzian, or JKR normal forces, respectively. +This modular structure simplifies the addition of new granular contact models as +as one onlyneeds to create a new GranSubMod class without having to modify the more +complex PairGranular, FixGranWall, and GranularModel classes. Most GranSubMod methods +are also already defined by the parent classes so new contact models typically only +require edits to a few relevant methods (e.g. methods that define coefficients and calculate forces). -Each GSM class has a pointer to both the LAMMPS class and the GranularModel +Each GranSubMod class has a pointer to both the LAMMPS class and the GranularModel class which owns it, ``lmp`` and ``gm``, respectively. The GranularModel class includes several public variables that describe the geometry/dynamics of the contact such as @@ -59,69 +59,70 @@ These quantities, among others, are calculated in the ``GranularModel->check_con and ``GranularModel->calculate_forces()`` methods which can be referred to for more details. -To create a new GSM class, it is recommended that one first looks at similar GSM -classes. All GSM classes share several general methods which may need to be defined +To create a new GranSubMod class, it is recommended that one first looks at similar +GranSubMod classes. All GranSubMod classes share several general methods which may +need to be defined .. list-table:: - * - ``GSM->mix_coeff()`` + * - ``GranSubMod->mix_coeff()`` - Optional method to define how coefficients are mixed for different atom types. By default, coefficients are mixed using a geometric mean. - * - ``GSM->coeffs_to_local()`` + * - ``GranSubMod->coeffs_to_local()`` - Parses coefficients to define local variables. Run once at model construction. - * - ``GSM->init()`` - - Optional method to define local variables after other GSM types were created. For instance, this method may be used by a tangential model that derives parameters from the normal model. + * - ``GranSubMod->init()`` + - Optional method to define local variables after other GranSubMod types were created. For instance, this method may be used by a tangential model that derives parameters from the normal model. There are also several type-specific methods .. list-table:: - * - ``GSMNormal->touch()`` + * - ``GranSubModNormal->touch()`` - Optional method to test when particles are in contact. By default, this is when particles overlap. - * - ``GSMNormal->pulloff_distance()`` + * - ``GranSubModNormal->pulloff_distance()`` - Optional method to return the distance at which particles stop interacting. By default, this is when particles no longer overlap. - * - ``GSMNormal->calculate_area()`` + * - ``GranSubModNormal->calculate_area()`` - Optional method to return the surface area of the contact. By default, this returns the geometric cross section. - * - ``GSMNormal->set_fncrit()`` + * - ``GranSubModNormal->set_fncrit()`` - Optional method that defines the critical force to break the contact used by some tangential, rolling, and twisting sub-models. By default, this is the current total normal force including damping. - * - ``GSMNormal->calculate_forces()`` + * - ``GranSubModNormal->calculate_forces()`` - Required method that returns the normal contact force - * - ``GSMDamping->calculate_forces()`` + * - ``GranSubModDamping->calculate_forces()`` - Required method that returns the normal damping force - * - ``GSMTangential->calculate_forces()`` + * - ``GranSubModTangential->calculate_forces()`` - Required method that calculates tangential forces/torques - * - ``GSMTwisting->calculate_forces()`` + * - ``GranSubModTwisting->calculate_forces()`` - Required method that calculates twisting friction forces/torques - * - ``GSMRolling->calculate_forces()`` + * - ``GranSubModRolling->calculate_forces()`` - Required method that calculates rolling friction forces/torques - * - ``GSMHeat->calculate_heat()`` + * - ``GranSubModHeat->calculate_heat()`` - Required method that returns the rate of heat flow As an example, say one wanted to create a new normal force option that consisted of a Hookean force with a piecewise stiffness. This could be done by adding a new -set of files ``gsm_custom.h``: +set of files ``gran_sub_mod_custom.h``: .. code-block:: c++ - #ifdef GSM_CLASS + #ifdef GranSubMod_CLASS // clang-format off - GSMStyle(hooke/piecewise, - GSMNormalHookePiecewise, + GranSubModStyle(hooke/piecewise, + GranSubModNormalHookePiecewise, NORMAL); // clang-format on #else - #ifndef GSM_CUSTOM_H_ - #define GSM_CUSTOM_H_ + #ifndef GRAN_SUB_MOD_CUSTOM_H_ + #define GRAN_SUB_MOD_CUSTOM_H_ - #include "gsm.h" - #include "gsm_normal.h" + #include "gran_sub_mod.h" + #include "gran_sub_mod_normal.h" namespace LAMMPS_NS { namespace Granular_NS { - class GSMNormalHookePiecewise : public GSMNormal { + class GranSubModNormalHookePiecewise : public GranSubModNormal { public: - GSMNormalHookePiecewise(class GranularModel *, class LAMMPS *); + GranSubModNormalHookePiecewise(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; double calculate_forces(); protected: @@ -131,29 +132,29 @@ set of files ``gsm_custom.h``: } // namespace Granular_NS } // namespace LAMMPS_NS - #endif /*GSM_CUSTOM_H_ */ - #endif /*GSM_CLASS_H_ */ + #endif /*GRAN_SUB_MOD_CUSTOM_H_ */ + #endif /*GRAN_SUB_MOD_CLASS_H_ */ -and ``gsm_custom.cpp`` +and ``gran_sub_mod_custom.cpp`` .. code-block:: c++ - #include "gsm_custom.h" - #include "gsm_normal.h" + #include "gran_sub_mod_custom.h" + #include "gran_sub_mod_normal.h" #include "granular_model.h" using namespace LAMMPS_NS; using namespace Granular_NS; - GSMNormalHookePiecewise::GSMNormalHookePiecewise(GranularModel *gm, LAMMPS *lmp) : GSMNormal(gm, lmp) + GranSubModNormalHookePiecewise::GranSubModNormalHookePiecewise(GranularModel *gm, LAMMPS *lmp) : GranSubModNormal(gm, lmp) { num_coeffs = 4; } /* ---------------------------------------------------------------------- */ - void GSMNormalHookePiecewise::coeffs_to_local() + void GranSubModNormalHookePiecewise::coeffs_to_local() { k1 = coeffs[0]; k2 = coeffs[1]; @@ -163,7 +164,7 @@ and ``gsm_custom.cpp`` /* ---------------------------------------------------------------------- */ - double GSMNormalHookePiecewise::calculate_forces() + double GranSubModNormalHookePiecewise::calculate_forces() { double Fne; if (gm->delta >= delta_switch) { diff --git a/doc/src/fix_temp_integrate.rst b/doc/src/fix_heat_flow_sphere_temp.rst similarity index 85% rename from doc/src/fix_temp_integrate.rst rename to doc/src/fix_heat_flow_sphere_temp.rst index efcf450d8f..c604b041ad 100644 --- a/doc/src/fix_temp_integrate.rst +++ b/doc/src/fix_heat_flow_sphere_temp.rst @@ -1,6 +1,6 @@ -.. index:: fix temp/integrate +.. index:: fix heat/flow/sphere/temp -fix temp/integrate command +fix heat/flow/sphere/temp command ========================== Syntax @@ -8,10 +8,10 @@ Syntax .. parsed-literal:: - fix ID group-ID temp/integrate style values ... + fix ID group-ID heat/flow/sphere/temp style values ... * ID, group-ID are documented in :doc:`fix ` command -* temp/integrate = style name of this fix command +* heat/flow/sphere/temp = style name of this fix command * one style with corresponding value(s) needs to be listed .. parsed-literal:: @@ -29,8 +29,8 @@ Examples .. code-block:: LAMMPS - fix 1 all temp/integrate constant 1.0 - fix 1 all temp/integrate type 1.0 0.5 + fix 1 all heat/flow/sphere/temp constant 1.0 + fix 1 all heat/flow/sphere/temp type 1.0 0.5 Description """"""""""" diff --git a/src/.gitignore b/src/.gitignore index c03af484ee..f2f2d3c110 100644 --- a/src/.gitignore +++ b/src/.gitignore @@ -1533,8 +1533,8 @@ /fix_srp.h /fix_srp_react.cpp /fix_srp_react.h -/fix_temp_integrate.cpp -/fix_temp_integrate.h +/fix_heat_flow_sphere_temp.cpp +/fix_heat_flow_sphere_temp.h /fix_tfmc.cpp /fix_tfmc.h /fix_ttm.cpp @@ -1545,20 +1545,20 @@ /fix_ttm_mod.h /granular_model.cpp /granular_model.h -/gsm_normal.cpp -/gsm_normal.h -/gsm_damping.cpp -/gsm_damping.h -/gsm_tangential.cpp -/gsm_tangential.h -/gsm_twisting.cpp -/gsm_twisting.h -/gsm_rolling.cpp -/gsm_rolling.h -/gsm_heat.cpp -/gsm_heat.h -/gsm.cpp -/gsm.h +/gran_sub_mod_normal.cpp +/gran_sub_mod_normal.h +/gran_sub_mod_damping.cpp +/gran_sub_mod_damping.h +/gran_sub_mod_tangential.cpp +/gran_sub_mod_tangential.h +/gran_sub_mod_twisting.cpp +/gran_sub_mod_twisting.h +/gran_sub_mod_rolling.cpp +/gran_sub_mod_rolling.h +/gran_sub_mod_heat.cpp +/gran_sub_mod_heat.h +/gran_sub_mod.cpp +/gran_sub_mod.h /pair_born_coul_long_cs.cpp /pair_born_coul_long_cs.h /pair_born_coul_dsf_cs.cpp diff --git a/src/GRANULAR/fix_temp_integrate.cpp b/src/GRANULAR/fix_heat_flow_sphere_temp.cpp similarity index 89% rename from src/GRANULAR/fix_temp_integrate.cpp rename to src/GRANULAR/fix_heat_flow_sphere_temp.cpp index ab9739e874..fe7fc49324 100644 --- a/src/GRANULAR/fix_temp_integrate.cpp +++ b/src/GRANULAR/fix_heat_flow_sphere_temp.cpp @@ -12,7 +12,7 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "fix_temp_integrate.h" +#include "fix_heat_flow_sphere_temp.h" #include "atom.h" #include "error.h" @@ -28,7 +28,7 @@ enum {NONE, CONSTANT, TYPE}; /* ---------------------------------------------------------------------- */ -FixTempIntegrate::FixTempIntegrate(LAMMPS *lmp, int narg, char **arg) : +FixHeatFlowSphereTemp::FixHeatFlowSphereTemp(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg) { if (narg < 4) error->all(FLERR,"Illegal fix command"); @@ -56,12 +56,11 @@ FixTempIntegrate::FixTempIntegrate(LAMMPS *lmp, int narg, char **arg) : if (cp_style == NONE) error->all(FLERR, "Must specify specific heat in fix temp/integrate"); dynamic_group_allow = 1; - time_integrate = 1; } /* ---------------------------------------------------------------------- */ -int FixTempIntegrate::setmask() +int FixHeatFlowSphereTemp::setmask() { int mask = 0; mask |= FINAL_INTEGRATE; @@ -71,7 +70,7 @@ int FixTempIntegrate::setmask() /* ---------------------------------------------------------------------- */ -void FixTempIntegrate::init() +void FixHeatFlowSphereTemp::init() { dt = update->dt; @@ -83,7 +82,7 @@ void FixTempIntegrate::init() /* ---------------------------------------------------------------------- */ -void FixTempIntegrate::final_integrate() +void FixHeatFlowSphereTemp::final_integrate() { // update temperature of atoms in group @@ -111,7 +110,7 @@ void FixTempIntegrate::final_integrate() /* ---------------------------------------------------------------------- */ -void FixTempIntegrate::final_integrate_respa(int ilevel, int /*iloop*/) +void FixHeatFlowSphereTemp::final_integrate_respa(int ilevel, int /*iloop*/) { dt = update->dt; final_integrate(); @@ -119,14 +118,14 @@ void FixTempIntegrate::final_integrate_respa(int ilevel, int /*iloop*/) /* ---------------------------------------------------------------------- */ -void FixTempIntegrate::reset_dt() +void FixHeatFlowSphereTemp::reset_dt() { dt = update->dt; } /* ---------------------------------------------------------------------- */ -double FixTempIntegrate::calc_cp(int i) +double FixHeatFlowSphereTemp::calc_cp(int i) { if (cp_style == TYPE) { return cp_type[atom->type[i]]; diff --git a/src/GRANULAR/fix_temp_integrate.h b/src/GRANULAR/fix_heat_flow_sphere_temp.h similarity index 82% rename from src/GRANULAR/fix_temp_integrate.h rename to src/GRANULAR/fix_heat_flow_sphere_temp.h index 8356d00433..6bc2d50373 100644 --- a/src/GRANULAR/fix_temp_integrate.h +++ b/src/GRANULAR/fix_heat_flow_sphere_temp.h @@ -13,20 +13,20 @@ #ifdef FIX_CLASS // clang-format off -FixStyle(temp/integrate,FixTempIntegrate); +FixStyle(heat/flow/sphere/temp,FixHeatFlowSphereTemp); // clang-format on #else -#ifndef LMP_FIX_TEMP_INTEGRATE_H -#define LMP_FIX_TEMP_INTEGRATE_H +#ifndef LMP_FIX_HEAT_FLOW_SPHERE_TEMP_H +#define LMP_FIX_HEAT_FLOW_SPHERE_TEMP_H #include "fix.h" namespace LAMMPS_NS { -class FixTempIntegrate : public Fix { +class FixHeatFlowSphereTemp : public Fix { public: - FixTempIntegrate(class LAMMPS *, int, char **); + FixHeatFlowSphereTemp(class LAMMPS *, int, char **); int setmask() override; void init() override; diff --git a/src/GRANULAR/fix_wall_gran.cpp b/src/GRANULAR/fix_wall_gran.cpp index 583cbba62e..fe2286a0fa 100644 --- a/src/GRANULAR/fix_wall_gran.cpp +++ b/src/GRANULAR/fix_wall_gran.cpp @@ -21,7 +21,7 @@ #include "atom.h" #include "granular_model.h" -#include "gsm.h" +#include "gran_sub_mod.h" #include "domain.h" #include "error.h" #include "input.h" diff --git a/src/GRANULAR/fix_wall_gran.h b/src/GRANULAR/fix_wall_gran.h index a621a973e2..16a2fe5dc0 100644 --- a/src/GRANULAR/fix_wall_gran.h +++ b/src/GRANULAR/fix_wall_gran.h @@ -25,6 +25,10 @@ FixStyle(wall/gran,FixWallGran); namespace LAMMPS_NS { +namespace Granular_NS { + class GranularModel; +} + class FixWallGran : public Fix { public: FixWallGran(class LAMMPS *, int, char **); @@ -53,7 +57,7 @@ class FixWallGran : public Fix { bigint time_origin; // for granular model choices - Granular_NS::GranularModel *model; + class Granular_NS::GranularModel *model; double lo, hi, cylradius; double amplitude, period, omega, vshear; diff --git a/src/GRANULAR/gsm.cpp b/src/GRANULAR/gran_sub_mod.cpp similarity index 85% rename from src/GRANULAR/gsm.cpp rename to src/GRANULAR/gran_sub_mod.cpp index 4ac7473504..2d836151f8 100644 --- a/src/GRANULAR/gsm.cpp +++ b/src/GRANULAR/gran_sub_mod.cpp @@ -13,7 +13,7 @@ ------------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- - This class contains a framework for granular submodels (GSM) including: + This class contains a framework for granular submodels (GranSubMod): normal, damping, tangential, rolling, twisting, and heat These are used to calculate forces/torques/etc based on contact geometry @@ -21,7 +21,7 @@ Dan Bolintineanu (SNL), Joel Clemmer (SNL) ----------------------------------------------------------------------- */ -#include "gsm.h" +#include "gran_sub_mod.h" #include "error.h" #include "utils.h" @@ -32,7 +32,7 @@ using namespace Granular_NS; Parent class for all types of granular submodels ------------------------------------------------------------------------- */ -GSM::GSM(class GranularModel *gm, LAMMPS *lmp) : Pointers(lmp) +GranSubMod::GranSubMod(class GranularModel *gm, LAMMPS *lmp) : Pointers(lmp) { this->gm = gm; @@ -51,7 +51,7 @@ GSM::GSM(class GranularModel *gm, LAMMPS *lmp) : Pointers(lmp) /* ---------------------------------------------------------------------- */ -GSM::~GSM() +GranSubMod::~GranSubMod() { if (allocated) delete [] coeffs; delete [] transfer_history_factor; @@ -59,7 +59,7 @@ GSM::~GSM() /* ---------------------------------------------------------------------- */ -void GSM::allocate_coeffs() +void GranSubMod::allocate_coeffs() { allocated = 1; coeffs = new double[num_coeffs]; @@ -67,7 +67,7 @@ void GSM::allocate_coeffs() /* ---------------------------------------------------------------------- */ -void GSM::mix_coeffs(double* icoeffs, double* jcoeffs) +void GranSubMod::mix_coeffs(double* icoeffs, double* jcoeffs) { for (int i = 0; i < num_coeffs; i++) coeffs[i] = mix_geom(icoeffs[i], jcoeffs[i]); @@ -78,7 +78,7 @@ void GSM::mix_coeffs(double* icoeffs, double* jcoeffs) mixing of Young's modulus (E) ------------------------------------------------------------------------- */ -double GSM::mix_stiffnessE(double E1, double E2, +double GranSubMod::mix_stiffnessE(double E1, double E2, double pois1, double pois2) { double factor1 = (1 - pois1 * pois1) / E1; @@ -90,7 +90,7 @@ double GSM::mix_stiffnessE(double E1, double E2, mixing of shear modulus (G) ------------------------------------------------------------------------ */ -double GSM::mix_stiffnessG(double E1, double E2, +double GranSubMod::mix_stiffnessG(double E1, double E2, double pois1, double pois2) { double factor1 = 2 * (2 - pois1) * (1 + pois1) / E1; @@ -102,7 +102,7 @@ double GSM::mix_stiffnessG(double E1, double E2, mixing of Young's modulus (E) for walls ------------------------------------------------------------------------- */ -double GSM::mix_stiffnessE_wall(double E, double pois) +double GranSubMod::mix_stiffnessE_wall(double E, double pois) { double factor = 2 * (1 - pois); return E / factor; @@ -112,7 +112,7 @@ double GSM::mix_stiffnessE_wall(double E, double pois) mixing of shear modulus (G) for walls ------------------------------------------------------------------------ */ -double GSM::mix_stiffnessG_wall(double E, double pois) +double GranSubMod::mix_stiffnessG_wall(double E, double pois) { double factor = 32.0 * (2 - pois) * (1 + pois); return E / factor; @@ -122,7 +122,7 @@ double GSM::mix_stiffnessG_wall(double E, double pois) mixing of everything else ------------------------------------------------------------------------- */ -double GSM::mix_geom(double val1, double val2) +double GranSubMod::mix_geom(double val1, double val2) { return sqrt(val1 * val2); } diff --git a/src/GRANULAR/gsm.h b/src/GRANULAR/gran_sub_mod.h similarity index 89% rename from src/GRANULAR/gsm.h rename to src/GRANULAR/gran_sub_mod.h index 3c19179d52..78f4229b29 100644 --- a/src/GRANULAR/gsm.h +++ b/src/GRANULAR/gran_sub_mod.h @@ -11,8 +11,8 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#ifndef LMP_GSM_H_ -#define LMP_GSM_H_ +#ifndef LMP_GRAN_SUB_MOD_H_ +#define LMP_GRAN_SUB_MOD_H_ #include "granular_model.h" #include "pointers.h" // IWYU pragma: export @@ -20,10 +20,10 @@ namespace LAMMPS_NS { namespace Granular_NS { -class GSM : protected Pointers { +class GranSubMod : protected Pointers { public: - GSM(class GranularModel *, class LAMMPS *); - virtual ~GSM(); + GranSubMod(class GranularModel *, class LAMMPS *); + virtual ~GranSubMod(); int num_coeffs; double *coeffs; @@ -59,4 +59,4 @@ class GSM : protected Pointers { } // namespace GranularModel } // namespace LAMMPS_NS -#endif /* GSM_H_ */ +#endif /* GRAN_SUB_MOD_H_ */ diff --git a/src/GRANULAR/gsm_damping.cpp b/src/GRANULAR/gran_sub_mod_damping.cpp similarity index 74% rename from src/GRANULAR/gsm_damping.cpp rename to src/GRANULAR/gran_sub_mod_damping.cpp index db7f0f3371..e78233735a 100644 --- a/src/GRANULAR/gsm_damping.cpp +++ b/src/GRANULAR/gran_sub_mod_damping.cpp @@ -12,8 +12,8 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "gsm_damping.h" -#include "gsm_normal.h" +#include "gran_sub_mod_damping.h" +#include "gran_sub_mod_normal.h" #include "granular_model.h" #include "math_special.h" @@ -25,11 +25,11 @@ using namespace MathSpecial; Default damping model ------------------------------------------------------------------------- */ -GSMDamping::GSMDamping(GranularModel *gm, LAMMPS *lmp) : GSM(gm, lmp) {} +GranSubModDamping::GranSubModDamping(GranularModel *gm, LAMMPS *lmp) : GranSubMod(gm, lmp) {} /* ---------------------------------------------------------------------- */ -void GSMDamping::init() +void GranSubModDamping::init() { damp = gm->normal_model->damp; } @@ -38,11 +38,11 @@ void GSMDamping::init() No model ------------------------------------------------------------------------- */ -GSMDampingNone::GSMDampingNone(GranularModel *gm, LAMMPS *lmp) : GSMDamping(gm, lmp) {} +GranSubModDampingNone::GranSubModDampingNone(GranularModel *gm, LAMMPS *lmp) : GranSubModDamping(gm, lmp) {} /* ---------------------------------------------------------------------- */ -double GSMDampingNone::calculate_forces() +double GranSubModDampingNone::calculate_forces() { damp_prefactor = 0.0; return 0.0; @@ -52,11 +52,11 @@ double GSMDampingNone::calculate_forces() Velocity damping ------------------------------------------------------------------------- */ -GSMDampingVelocity::GSMDampingVelocity(GranularModel *gm, LAMMPS *lmp) : GSMDamping(gm, lmp) {} +GranSubModDampingVelocity::GranSubModDampingVelocity(GranularModel *gm, LAMMPS *lmp) : GranSubModDamping(gm, lmp) {} /* ---------------------------------------------------------------------- */ -double GSMDampingVelocity::calculate_forces() +double GranSubModDampingVelocity::calculate_forces() { damp_prefactor = damp; return -damp_prefactor * gm->vnnr; @@ -66,11 +66,11 @@ double GSMDampingVelocity::calculate_forces() Mass velocity damping ------------------------------------------------------------------------- */ -GSMDampingMassVelocity::GSMDampingMassVelocity(GranularModel *gm, LAMMPS *lmp) : GSMDamping(gm, lmp) {} +GranSubModDampingMassVelocity::GranSubModDampingMassVelocity(GranularModel *gm, LAMMPS *lmp) : GranSubModDamping(gm, lmp) {} /* ---------------------------------------------------------------------- */ -double GSMDampingMassVelocity::calculate_forces() +double GranSubModDampingMassVelocity::calculate_forces() { damp_prefactor = damp * gm->meff; return -damp_prefactor * gm->vnnr; @@ -80,14 +80,14 @@ double GSMDampingMassVelocity::calculate_forces() Default, viscoelastic damping ------------------------------------------------------------------------- */ -GSMDampingViscoelastic::GSMDampingViscoelastic(GranularModel *gm, LAMMPS *lmp) : GSMDamping(gm, lmp) +GranSubModDampingViscoelastic::GranSubModDampingViscoelastic(GranularModel *gm, LAMMPS *lmp) : GranSubModDamping(gm, lmp) { area_flag = 1; } /* ---------------------------------------------------------------------- */ -double GSMDampingViscoelastic::calculate_forces() +double GranSubModDampingViscoelastic::calculate_forces() { damp_prefactor = damp * gm->meff * gm->area; return -damp_prefactor * gm->vnnr; @@ -97,14 +97,14 @@ double GSMDampingViscoelastic::calculate_forces() Tsuji damping ------------------------------------------------------------------------- */ -GSMDampingTsuji::GSMDampingTsuji(GranularModel *gm, LAMMPS *lmp) : GSMDamping(gm, lmp) +GranSubModDampingTsuji::GranSubModDampingTsuji(GranularModel *gm, LAMMPS *lmp) : GranSubModDamping(gm, lmp) { allow_cohesion = 0; } /* ---------------------------------------------------------------------- */ -void GSMDampingTsuji::init() +void GranSubModDampingTsuji::init() { double tmp = gm->normal_model->damp; damp = 1.2728 - 4.2783 * tmp + 11.087 * square(tmp); @@ -114,7 +114,7 @@ void GSMDampingTsuji::init() /* ---------------------------------------------------------------------- */ -double GSMDampingTsuji::calculate_forces() +double GranSubModDampingTsuji::calculate_forces() { damp_prefactor = damp * sqrt(gm->meff * gm->Fnormal / gm->delta); return -damp_prefactor * gm->vnnr; diff --git a/src/GRANULAR/gsm_damping.h b/src/GRANULAR/gran_sub_mod_damping.h similarity index 58% rename from src/GRANULAR/gsm_damping.h rename to src/GRANULAR/gran_sub_mod_damping.h index 75c0f96356..04316a950d 100644 --- a/src/GRANULAR/gsm_damping.h +++ b/src/GRANULAR/gran_sub_mod_damping.h @@ -11,43 +11,43 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#ifdef GSM_CLASS +#ifdef GRAN_SUB_MOD_CLASS // clang-format off -GSMStyle(none, - GSMDampingNone, +GranSubModStyle(none, + GranSubModDampingNone, DAMPING); -GSMStyle(velocity, - GSMDampingVelocity, +GranSubModStyle(velocity, + GranSubModDampingVelocity, DAMPING); -GSMStyle(mass_velocity, - GSMDampingMassVelocity, +GranSubModStyle(mass_velocity, + GranSubModDampingMassVelocity, DAMPING); -GSMStyle(viscoelastic, - GSMDampingViscoelastic, +GranSubModStyle(viscoelastic, + GranSubModDampingViscoelastic, DAMPING); -GSMStyle(tsuji, - GSMDampingTsuji, +GranSubModStyle(tsuji, + GranSubModDampingTsuji, DAMPING); // clang-format on #else -#ifndef GSM_DAMPING_H_ -#define GSM_DAMPING_H_ +#ifndef GRAN_SUB_MOD_DAMPING_H_ +#define GRAN_SUB_MOD_DAMPING_H_ -#include "gsm.h" +#include "gran_sub_mod.h" #include "pointers.h" namespace LAMMPS_NS { namespace Granular_NS { -class GSMDamping : public GSM { +class GranSubModDamping : public GranSubMod { public: - GSMDamping(class GranularModel *, class LAMMPS *); - ~GSMDamping() {}; + GranSubModDamping(class GranularModel *, class LAMMPS *); + ~GranSubModDamping() {}; virtual void coeffs_to_local() {}; virtual void mix_coeffs(double*, double*) {}; virtual void init(); @@ -59,42 +59,42 @@ class GSMDamping : public GSM { /* ---------------------------------------------------------------------- */ -class GSMDampingNone : public GSMDamping { +class GranSubModDampingNone : public GranSubModDamping { public: - GSMDampingNone(class GranularModel *, class LAMMPS *); + GranSubModDampingNone(class GranularModel *, class LAMMPS *); void init() override {}; double calculate_forces(); }; /* ---------------------------------------------------------------------- */ -class GSMDampingVelocity : public GSMDamping { +class GranSubModDampingVelocity : public GranSubModDamping { public: - GSMDampingVelocity(class GranularModel *, class LAMMPS *); + GranSubModDampingVelocity(class GranularModel *, class LAMMPS *); double calculate_forces(); }; /* ---------------------------------------------------------------------- */ -class GSMDampingMassVelocity : public GSMDamping { +class GranSubModDampingMassVelocity : public GranSubModDamping { public: - GSMDampingMassVelocity(class GranularModel *, class LAMMPS *); + GranSubModDampingMassVelocity(class GranularModel *, class LAMMPS *); double calculate_forces(); }; /* ---------------------------------------------------------------------- */ -class GSMDampingViscoelastic : public GSMDamping { +class GranSubModDampingViscoelastic : public GranSubModDamping { public: - GSMDampingViscoelastic(class GranularModel *, class LAMMPS *); + GranSubModDampingViscoelastic(class GranularModel *, class LAMMPS *); double calculate_forces(); }; /* ---------------------------------------------------------------------- */ -class GSMDampingTsuji : public GSMDamping { +class GranSubModDampingTsuji : public GranSubModDamping { public: - GSMDampingTsuji(class GranularModel *, class LAMMPS *); + GranSubModDampingTsuji(class GranularModel *, class LAMMPS *); void init() override; double calculate_forces(); }; @@ -102,5 +102,5 @@ class GSMDampingTsuji : public GSMDamping { } // namespace Granular_NS } // namespace LAMMPS_NS -#endif /*GSM_DAMPING_H_ */ -#endif /*GSM_CLASS_H_ */ +#endif /*GRAN_SUB_MOD_DAMPING_H_ */ +#endif /*GRAN_SUB_MOD_CLASS_H_ */ diff --git a/src/GRANULAR/gsm_heat.cpp b/src/GRANULAR/gran_sub_mod_heat.cpp similarity index 79% rename from src/GRANULAR/gsm_heat.cpp rename to src/GRANULAR/gran_sub_mod_heat.cpp index 1a0cff5301..02a18117ff 100644 --- a/src/GRANULAR/gsm_heat.cpp +++ b/src/GRANULAR/gran_sub_mod_heat.cpp @@ -12,7 +12,7 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "gsm_heat.h" +#include "gran_sub_mod_heat.h" #include "granular_model.h" #include "error.h" @@ -23,17 +23,17 @@ using namespace Granular_NS; Default heat conduction ------------------------------------------------------------------------- */ -GSMHeat::GSMHeat(GranularModel *gm, LAMMPS *lmp) : GSM(gm, lmp) {} +GranSubModHeat::GranSubModHeat(GranularModel *gm, LAMMPS *lmp) : GranSubMod(gm, lmp) {} /* ---------------------------------------------------------------------- Area-based heat conduction ------------------------------------------------------------------------- */ -GSMHeatNone::GSMHeatNone(GranularModel *gm, LAMMPS *lmp) : GSMHeat(gm, lmp) {} +GranSubModHeatNone::GranSubModHeatNone(GranularModel *gm, LAMMPS *lmp) : GranSubModHeat(gm, lmp) {} /* ---------------------------------------------------------------------- */ -double GSMHeatNone::calculate_heat() +double GranSubModHeatNone::calculate_heat() { return 0.0; } @@ -42,7 +42,7 @@ double GSMHeatNone::calculate_heat() Area-based heat conduction ------------------------------------------------------------------------- */ -GSMHeatArea::GSMHeatArea(GranularModel *gm, LAMMPS *lmp) : GSMHeat(gm, lmp) +GranSubModHeatArea::GranSubModHeatArea(GranularModel *gm, LAMMPS *lmp) : GranSubModHeat(gm, lmp) { num_coeffs = 1; area_flag = 1; @@ -50,7 +50,7 @@ GSMHeatArea::GSMHeatArea(GranularModel *gm, LAMMPS *lmp) : GSMHeat(gm, lmp) /* ---------------------------------------------------------------------- */ -void GSMHeatArea::coeffs_to_local() +void GranSubModHeatArea::coeffs_to_local() { conductivity = coeffs[0]; @@ -59,7 +59,7 @@ void GSMHeatArea::coeffs_to_local() /* ---------------------------------------------------------------------- */ -double GSMHeatArea::calculate_heat() +double GranSubModHeatArea::calculate_heat() { return conductivity * gm->area * (gm->Tj - gm->Ti); } diff --git a/src/GRANULAR/gsm_heat.h b/src/GRANULAR/gran_sub_mod_heat.h similarity index 66% rename from src/GRANULAR/gsm_heat.h rename to src/GRANULAR/gran_sub_mod_heat.h index c913593f19..3520a41a06 100644 --- a/src/GRANULAR/gsm_heat.h +++ b/src/GRANULAR/gran_sub_mod_heat.h @@ -11,30 +11,30 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#ifdef GSM_CLASS +#ifdef GRAN_SUB_MOD_CLASS // clang-format off -GSMStyle(none, - GSMHeatNone, +GranSubModStyle(none, + GranSubModHeatNone, HEAT); -GSMStyle(area, - GSMHeatArea, +GranSubModStyle(area, + GranSubModHeatArea, HEAT); // clang-format on #else -#ifndef GSM_HEAT_H_ -#define GSM_HEAT_H_ +#ifndef GRAN_SUB_MOD_HEAT_H_ +#define GRAN_SUB_MOD_HEAT_H_ -#include "gsm.h" +#include "gran_sub_mod.h" namespace LAMMPS_NS { namespace Granular_NS { -class GSMHeat : public GSM { +class GranSubModHeat : public GranSubMod { public: - GSMHeat(class GranularModel *, class LAMMPS *); - ~GSMHeat() {}; + GranSubModHeat(class GranularModel *, class LAMMPS *); + ~GranSubModHeat() {}; virtual void coeffs_to_local() {}; virtual void init() {}; virtual double calculate_heat() = 0; @@ -42,17 +42,17 @@ class GSMHeat : public GSM { /* ---------------------------------------------------------------------- */ -class GSMHeatNone : public GSMHeat { +class GranSubModHeatNone : public GranSubModHeat { public: - GSMHeatNone(class GranularModel *, class LAMMPS *); + GranSubModHeatNone(class GranularModel *, class LAMMPS *); double calculate_heat(); }; /* ---------------------------------------------------------------------- */ -class GSMHeatArea : public GSMHeat { +class GranSubModHeatArea : public GranSubModHeat { public: - GSMHeatArea(class GranularModel *, class LAMMPS *); + GranSubModHeatArea(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; double calculate_heat(); protected: @@ -62,5 +62,5 @@ class GSMHeatArea : public GSMHeat { } // namespace Granular_NS } // namespace LAMMPS_NS -#endif /*GSM_HEAT_H_ */ -#endif /*GSM_CLASS_H_ */ +#endif /*GRAN_SUB_MOD_HEAT_H_ */ +#endif /*GRAN_SUB_MOD_CLASS_H_ */ diff --git a/src/GRANULAR/gsm_normal.cpp b/src/GRANULAR/gran_sub_mod_normal.cpp similarity index 82% rename from src/GRANULAR/gsm_normal.cpp rename to src/GRANULAR/gran_sub_mod_normal.cpp index 28e4d7af79..d10c984a51 100644 --- a/src/GRANULAR/gsm_normal.cpp +++ b/src/GRANULAR/gran_sub_mod_normal.cpp @@ -12,7 +12,7 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "gsm_normal.h" +#include "gran_sub_mod_normal.h" #include "granular_model.h" #include "error.h" #include "math_const.h" @@ -33,7 +33,7 @@ using namespace MathConst; Default normal model ------------------------------------------------------------------------- */ -GSMNormal::GSMNormal(GranularModel *gm, LAMMPS *lmp) : GSM(gm, lmp) +GranSubModNormal::GranSubModNormal(GranularModel *gm, LAMMPS *lmp) : GranSubMod(gm, lmp) { material_properties = 0; cohesive_flag = 0; @@ -41,7 +41,7 @@ GSMNormal::GSMNormal(GranularModel *gm, LAMMPS *lmp) : GSM(gm, lmp) /* ---------------------------------------------------------------------- */ -bool GSMNormal::touch() +bool GranSubModNormal::touch() { bool touchflag = (gm->rsq < gm->radsum * gm->radsum); return touchflag; @@ -49,7 +49,7 @@ bool GSMNormal::touch() /* ---------------------------------------------------------------------- */ -double GSMNormal::pulloff_distance(double radi, double radj) +double GranSubModNormal::pulloff_distance(double radi, double radj) { //called outside of compute(), do not assume correct geometry defined in contact return radi + radj; @@ -57,14 +57,14 @@ double GSMNormal::pulloff_distance(double radi, double radj) /* ---------------------------------------------------------------------- */ -double GSMNormal::calculate_area() +double GranSubModNormal::calculate_area() { return sqrt(gm->dR); } /* ---------------------------------------------------------------------- */ -void GSMNormal::set_fncrit() +void GranSubModNormal::set_fncrit() { Fncrit = fabs(gm->Fntot); } @@ -73,11 +73,11 @@ void GSMNormal::set_fncrit() No model ------------------------------------------------------------------------- */ -GSMNormalNone::GSMNormalNone(GranularModel *gm, LAMMPS *lmp) : GSMNormal(gm, lmp) {} +GranSubModNormalNone::GranSubModNormalNone(GranularModel *gm, LAMMPS *lmp) : GranSubModNormal(gm, lmp) {} /* ---------------------------------------------------------------------- */ -double GSMNormalNone::calculate_forces() +double GranSubModNormalNone::calculate_forces() { return 0.0; } @@ -86,14 +86,14 @@ double GSMNormalNone::calculate_forces() Hookean normal force ------------------------------------------------------------------------- */ -GSMNormalHooke::GSMNormalHooke(GranularModel *gm, LAMMPS *lmp) : GSMNormal(gm, lmp) +GranSubModNormalHooke::GranSubModNormalHooke(GranularModel *gm, LAMMPS *lmp) : GranSubModNormal(gm, lmp) { num_coeffs = 2; } /* ---------------------------------------------------------------------- */ -void GSMNormalHooke::coeffs_to_local() +void GranSubModNormalHooke::coeffs_to_local() { k = coeffs[0]; damp = coeffs[1]; @@ -103,7 +103,7 @@ void GSMNormalHooke::coeffs_to_local() /* ---------------------------------------------------------------------- */ -double GSMNormalHooke::calculate_forces() +double GranSubModNormalHooke::calculate_forces() { return k * gm->delta; } @@ -112,7 +112,7 @@ double GSMNormalHooke::calculate_forces() Hertzian normal force ------------------------------------------------------------------------- */ -GSMNormalHertz::GSMNormalHertz(GranularModel *gm, LAMMPS *lmp) : GSMNormal(gm, lmp) +GranSubModNormalHertz::GranSubModNormalHertz(GranularModel *gm, LAMMPS *lmp) : GranSubModNormal(gm, lmp) { num_coeffs = 2; area_flag = 1; @@ -120,7 +120,7 @@ GSMNormalHertz::GSMNormalHertz(GranularModel *gm, LAMMPS *lmp) : GSMNormal(gm, l /* ---------------------------------------------------------------------- */ -void GSMNormalHertz::coeffs_to_local() +void GranSubModNormalHertz::coeffs_to_local() { k = coeffs[0]; damp = coeffs[1]; @@ -130,7 +130,7 @@ void GSMNormalHertz::coeffs_to_local() /* ---------------------------------------------------------------------- */ -double GSMNormalHertz::calculate_forces() +double GranSubModNormalHertz::calculate_forces() { return k * gm->area * gm->delta; } @@ -139,7 +139,7 @@ double GSMNormalHertz::calculate_forces() Hertzian normal force with material properties ------------------------------------------------------------------------- */ -GSMNormalHertzMaterial::GSMNormalHertzMaterial(GranularModel *gm, LAMMPS *lmp) : GSMNormalHertz(gm, lmp) +GranSubModNormalHertzMaterial::GranSubModNormalHertzMaterial(GranularModel *gm, LAMMPS *lmp) : GranSubModNormalHertz(gm, lmp) { material_properties = 1; num_coeffs = 3; @@ -148,7 +148,7 @@ GSMNormalHertzMaterial::GSMNormalHertzMaterial(GranularModel *gm, LAMMPS *lmp) : /* ---------------------------------------------------------------------- */ -void GSMNormalHertzMaterial::coeffs_to_local() +void GranSubModNormalHertzMaterial::coeffs_to_local() { Emod = coeffs[0]; damp = coeffs[1]; @@ -164,7 +164,7 @@ void GSMNormalHertzMaterial::coeffs_to_local() /* ---------------------------------------------------------------------- */ -void GSMNormalHertzMaterial::mix_coeffs(double* icoeffs, double* jcoeffs) +void GranSubModNormalHertzMaterial::mix_coeffs(double* icoeffs, double* jcoeffs) { coeffs[0] = mix_stiffnessE(icoeffs[0], jcoeffs[0],icoeffs[2], jcoeffs[2]); coeffs[1] = mix_geom(icoeffs[1], jcoeffs[1]); @@ -176,7 +176,7 @@ void GSMNormalHertzMaterial::mix_coeffs(double* icoeffs, double* jcoeffs) DMT normal force ------------------------------------------------------------------------- */ -GSMNormalDMT::GSMNormalDMT(GranularModel *gm, LAMMPS *lmp) : GSMNormal(gm, lmp) +GranSubModNormalDMT::GranSubModNormalDMT(GranularModel *gm, LAMMPS *lmp) : GranSubModNormal(gm, lmp) { material_properties = 1; cohesive_flag = 1; @@ -186,7 +186,7 @@ GSMNormalDMT::GSMNormalDMT(GranularModel *gm, LAMMPS *lmp) : GSMNormal(gm, lmp) /* ---------------------------------------------------------------------- */ -void GSMNormalDMT::coeffs_to_local() +void GranSubModNormalDMT::coeffs_to_local() { Emod = coeffs[0]; damp = coeffs[1]; @@ -203,7 +203,7 @@ void GSMNormalDMT::coeffs_to_local() /* ---------------------------------------------------------------------- */ -void GSMNormalDMT::mix_coeffs(double* icoeffs, double* jcoeffs) +void GranSubModNormalDMT::mix_coeffs(double* icoeffs, double* jcoeffs) { coeffs[0] = mix_stiffnessE(icoeffs[0], jcoeffs[0],icoeffs[2], jcoeffs[2]); coeffs[1] = mix_geom(icoeffs[1], jcoeffs[1]); @@ -214,7 +214,7 @@ void GSMNormalDMT::mix_coeffs(double* icoeffs, double* jcoeffs) /* ---------------------------------------------------------------------- */ -double GSMNormalDMT::calculate_forces() +double GranSubModNormalDMT::calculate_forces() { Fne = k * gm->area * gm->delta; F_pulloff = 4.0 * MathConst::MY_PI * cohesion * gm->Reff; @@ -224,7 +224,7 @@ double GSMNormalDMT::calculate_forces() /* ---------------------------------------------------------------------- */ -void GSMNormalDMT::set_fncrit() +void GranSubModNormalDMT::set_fncrit() { Fncrit = fabs(Fne + 2.0 * F_pulloff); } @@ -233,7 +233,7 @@ void GSMNormalDMT::set_fncrit() JKR normal force ------------------------------------------------------------------------- */ -GSMNormalJKR::GSMNormalJKR(GranularModel *gm, LAMMPS *lmp) : GSMNormal(gm, lmp) +GranSubModNormalJKR::GranSubModNormalJKR(GranularModel *gm, LAMMPS *lmp) : GranSubModNormal(gm, lmp) { material_properties = 1; cohesive_flag = 1; @@ -244,7 +244,7 @@ GSMNormalJKR::GSMNormalJKR(GranularModel *gm, LAMMPS *lmp) : GSMNormal(gm, lmp) /* ---------------------------------------------------------------------- */ -void GSMNormalJKR::coeffs_to_local() +void GranSubModNormalJKR::coeffs_to_local() { Emod = coeffs[0]; damp = coeffs[1]; @@ -264,7 +264,7 @@ void GSMNormalJKR::coeffs_to_local() /* ---------------------------------------------------------------------- */ -void GSMNormalJKR::mix_coeffs(double* icoeffs, double* jcoeffs) +void GranSubModNormalJKR::mix_coeffs(double* icoeffs, double* jcoeffs) { coeffs[0] = mix_stiffnessE(icoeffs[0], jcoeffs[0],icoeffs[2], jcoeffs[2]); coeffs[1] = mix_geom(icoeffs[1], jcoeffs[1]); @@ -275,7 +275,7 @@ void GSMNormalJKR::mix_coeffs(double* icoeffs, double* jcoeffs) /* ---------------------------------------------------------------------- */ -bool GSMNormalJKR::touch() +bool GranSubModNormalJKR::touch() { double area_at_pulloff, R2, delta_pulloff, dist_pulloff; bool touchflag; @@ -297,7 +297,7 @@ bool GSMNormalJKR::touch() called outside of compute(), do not assume geometry defined in contact ------------------------------------------------------------------------- */ -double GSMNormalJKR::pulloff_distance(double radi, double radj) +double GranSubModNormalJKR::pulloff_distance(double radi, double radj) { double area_at_pulloff, Reff_tmp; @@ -310,7 +310,7 @@ double GSMNormalJKR::pulloff_distance(double radi, double radj) /* ---------------------------------------------------------------------- */ -double GSMNormalJKR::calculate_area() +double GranSubModNormalJKR::calculate_area() { double R2, dR2, t0, t1, t2, t3, t4, t5, t6; double sqrt1, sqrt2, sqrt3; @@ -335,7 +335,7 @@ double GSMNormalJKR::calculate_area() /* ---------------------------------------------------------------------- */ -double GSMNormalJKR::calculate_forces() +double GranSubModNormalJKR::calculate_forces() { double a2; a2 = gm->area * gm->area; @@ -347,7 +347,7 @@ double GSMNormalJKR::calculate_forces() /* ---------------------------------------------------------------------- */ -void GSMNormalJKR::set_fncrit() +void GranSubModNormalJKR::set_fncrit() { Fncrit = fabs(Fne + 2.0 * F_pulloff); } diff --git a/src/GRANULAR/gsm_normal.h b/src/GRANULAR/gran_sub_mod_normal.h similarity index 65% rename from src/GRANULAR/gsm_normal.h rename to src/GRANULAR/gran_sub_mod_normal.h index 2d7391f3c8..8fb0c01d4b 100644 --- a/src/GRANULAR/gsm_normal.h +++ b/src/GRANULAR/gran_sub_mod_normal.h @@ -11,46 +11,46 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#ifdef GSM_CLASS +#ifdef GRAN_SUB_MOD_CLASS // clang-format off -GSMStyle(none, - GSMNormalNone, +GranSubModStyle(none, + GranSubModNormalNone, NORMAL); -GSMStyle(hooke, - GSMNormalHooke, +GranSubModStyle(hooke, + GranSubModNormalHooke, NORMAL); -GSMStyle(hertz, - GSMNormalHertz, +GranSubModStyle(hertz, + GranSubModNormalHertz, NORMAL); -GSMStyle(hertz/material, - GSMNormalHertzMaterial, +GranSubModStyle(hertz/material, + GranSubModNormalHertzMaterial, NORMAL); -GSMStyle(dmt, - GSMNormalDMT, +GranSubModStyle(dmt, + GranSubModNormalDMT, NORMAL); -GSMStyle(jkr, - GSMNormalJKR, +GranSubModStyle(jkr, + GranSubModNormalJKR, NORMAL); // clang-format on #else -#ifndef GSM_NORMAL_H_ -#define GSM_NORMAL_H_ +#ifndef GRAN_SUB_MOD_NORMAL_H_ +#define GRAN_SUB_MOD_NORMAL_H_ -#include "gsm.h" +#include "gran_sub_mod.h" namespace LAMMPS_NS { namespace Granular_NS { -class GSMNormal : public GSM { +class GranSubModNormal : public GranSubMod { public: - GSMNormal(class GranularModel *, class LAMMPS *); - ~GSMNormal() {}; + GranSubModNormal(class GranularModel *, class LAMMPS *); + ~GranSubModNormal() {}; virtual void coeffs_to_local() {}; virtual void init() {}; virtual bool touch(); @@ -66,17 +66,17 @@ class GSMNormal : public GSM { /* ---------------------------------------------------------------------- */ -class GSMNormalNone : public GSMNormal { +class GranSubModNormalNone : public GranSubModNormal { public: - GSMNormalNone(class GranularModel *, class LAMMPS *); + GranSubModNormalNone(class GranularModel *, class LAMMPS *); double calculate_forces(); }; /* ---------------------------------------------------------------------- */ -class GSMNormalHooke : public GSMNormal { +class GranSubModNormalHooke : public GranSubModNormal { public: - GSMNormalHooke(class GranularModel *, class LAMMPS *); + GranSubModNormalHooke(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; double calculate_forces(); protected: @@ -85,9 +85,9 @@ class GSMNormalHooke : public GSMNormal { /* ---------------------------------------------------------------------- */ -class GSMNormalHertz : public GSMNormal { +class GranSubModNormalHertz : public GranSubModNormal { public: - GSMNormalHertz(class GranularModel *, class LAMMPS *); + GranSubModNormalHertz(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; double calculate_forces(); protected: @@ -96,18 +96,18 @@ class GSMNormalHertz : public GSMNormal { /* ---------------------------------------------------------------------- */ -class GSMNormalHertzMaterial : public GSMNormalHertz { +class GranSubModNormalHertzMaterial : public GranSubModNormalHertz { public: - GSMNormalHertzMaterial(class GranularModel *, class LAMMPS *); + GranSubModNormalHertzMaterial(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; void mix_coeffs(double*, double*) override; }; /* ---------------------------------------------------------------------- */ -class GSMNormalDMT : public GSMNormal { +class GranSubModNormalDMT : public GranSubModNormal { public: - GSMNormalDMT(class GranularModel *, class LAMMPS *); + GranSubModNormalDMT(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; void mix_coeffs(double*, double*) override; double calculate_forces(); @@ -119,9 +119,9 @@ class GSMNormalDMT : public GSMNormal { /* ---------------------------------------------------------------------- */ -class GSMNormalJKR : public GSMNormal { +class GranSubModNormalJKR : public GranSubModNormal { public: - GSMNormalJKR(class GranularModel *, class LAMMPS *); + GranSubModNormalJKR(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; void mix_coeffs(double*, double*) override; bool touch() override; @@ -137,5 +137,5 @@ class GSMNormalJKR : public GSMNormal { } // namespace Granular_NS } // namespace LAMMPS_NS -#endif /*GSM_NORMAL_H_ */ -#endif /*GSM_CLASS_H_ */ +#endif /*GRAN_SUB_MOD_NORMAL_H_ */ +#endif /*GRAN_SUB_MOD_CLASS_H_ */ diff --git a/src/GRANULAR/gsm_rolling.cpp b/src/GRANULAR/gran_sub_mod_rolling.cpp similarity index 87% rename from src/GRANULAR/gsm_rolling.cpp rename to src/GRANULAR/gran_sub_mod_rolling.cpp index ceda262853..c1dc53fcc8 100644 --- a/src/GRANULAR/gsm_rolling.cpp +++ b/src/GRANULAR/gran_sub_mod_rolling.cpp @@ -12,8 +12,8 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "gsm_normal.h" -#include "gsm_rolling.h" +#include "gran_sub_mod_normal.h" +#include "gran_sub_mod_rolling.h" #include "granular_model.h" #include "error.h" #include "math_const.h" @@ -24,23 +24,25 @@ using namespace Granular_NS; using namespace MathConst; using namespace MathExtra; +#define EPSILON 1e-10 + /* ---------------------------------------------------------------------- Default rolling friction model ------------------------------------------------------------------------- */ -GSMRolling::GSMRolling(GranularModel *gm, LAMMPS *lmp) : GSM(gm, lmp) {} +GranSubModRolling::GranSubModRolling(GranularModel *gm, LAMMPS *lmp) : GranSubMod(gm, lmp) {} /* ---------------------------------------------------------------------- No model ------------------------------------------------------------------------- */ -GSMRollingNone::GSMRollingNone(GranularModel *gm, LAMMPS *lmp) : GSMRolling(gm, lmp) {} +GranSubModRollingNone::GranSubModRollingNone(GranularModel *gm, LAMMPS *lmp) : GranSubModRolling(gm, lmp) {} /* ---------------------------------------------------------------------- SDS rolling friction model ------------------------------------------------------------------------- */ -GSMRollingSDS::GSMRollingSDS(GranularModel *gm, LAMMPS *lmp) : GSMRolling(gm, lmp) +GranSubModRollingSDS::GranSubModRollingSDS(GranularModel *gm, LAMMPS *lmp) : GranSubModRolling(gm, lmp) { num_coeffs = 3; size_history = 3; @@ -48,7 +50,7 @@ GSMRollingSDS::GSMRollingSDS(GranularModel *gm, LAMMPS *lmp) : GSMRolling(gm, lm /* ---------------------------------------------------------------------- */ -void GSMRollingSDS::coeffs_to_local() +void GranSubModRollingSDS::coeffs_to_local() { k = coeffs[0]; gamma = coeffs[1]; @@ -60,7 +62,7 @@ void GSMRollingSDS::coeffs_to_local() /* ---------------------------------------------------------------------- */ -void GSMRollingSDS::calculate_forces() +void GranSubModRollingSDS::calculate_forces() { int rhist0, rhist1, rhist2, frameupdate; double Frcrit, rolldotn, rollmag, prjmag, magfr, hist_temp[3], scalefac, temp_array[3]; diff --git a/src/GRANULAR/gsm_rolling.h b/src/GRANULAR/gran_sub_mod_rolling.h similarity index 65% rename from src/GRANULAR/gsm_rolling.h rename to src/GRANULAR/gran_sub_mod_rolling.h index 054b22954f..cb64c94219 100644 --- a/src/GRANULAR/gsm_rolling.h +++ b/src/GRANULAR/gran_sub_mod_rolling.h @@ -11,30 +11,30 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#ifdef GSM_CLASS +#ifdef GRAN_SUB_MOD_CLASS // clang-format off -GSMStyle(none, - GSMRollingNone, +GranSubModStyle(none, + GranSubModRollingNone, ROLLING); -GSMStyle(sds, - GSMRollingSDS, +GranSubModStyle(sds, + GranSubModRollingSDS, ROLLING); // clang-format on #else -#ifndef GSM_ROLLING_H_ -#define GSM_ROLLING_H_ +#ifndef GRAN_SUB_MOD_ROLLING_H_ +#define GRAN_SUB_MOD_ROLLING_H_ -#include "gsm.h" +#include "gran_sub_mod.h" namespace LAMMPS_NS { namespace Granular_NS { -class GSMRolling : public GSM { +class GranSubModRolling : public GranSubMod { public: - GSMRolling(class GranularModel *, class LAMMPS *); - ~GSMRolling() {}; + GranSubModRolling(class GranularModel *, class LAMMPS *); + ~GranSubModRolling() {}; virtual void coeffs_to_local() {}; virtual void init() {}; virtual void calculate_forces() = 0; @@ -42,17 +42,17 @@ class GSMRolling : public GSM { /* ---------------------------------------------------------------------- */ -class GSMRollingNone : public GSMRolling { +class GranSubModRollingNone : public GranSubModRolling { public: - GSMRollingNone(class GranularModel *, class LAMMPS *); + GranSubModRollingNone(class GranularModel *, class LAMMPS *); void calculate_forces() {}; }; /* ---------------------------------------------------------------------- */ -class GSMRollingSDS : public GSMRolling { +class GranSubModRollingSDS : public GranSubModRolling { public: - GSMRollingSDS(class GranularModel *, class LAMMPS *); + GranSubModRollingSDS(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; void calculate_forces(); protected: @@ -62,5 +62,5 @@ class GSMRollingSDS : public GSMRolling { } // namespace Granular_NS } // namespace LAMMPS_NS -#endif /*GSM_ROLLING_H_ */ -#endif /*GSM_CLASS_H_ */ +#endif /*GRAN_SUB_MOD_ROLLING_H_ */ +#endif /*GRAN_SUB_MOD_CLASS_H_ */ diff --git a/src/GRANULAR/gsm_tangential.cpp b/src/GRANULAR/gran_sub_mod_tangential.cpp similarity index 84% rename from src/GRANULAR/gsm_tangential.cpp rename to src/GRANULAR/gran_sub_mod_tangential.cpp index a5dabde8fd..677ba4d363 100644 --- a/src/GRANULAR/gsm_tangential.cpp +++ b/src/GRANULAR/gran_sub_mod_tangential.cpp @@ -12,9 +12,9 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "gsm_damping.h" -#include "gsm_normal.h" -#include "gsm_tangential.h" +#include "gran_sub_mod_damping.h" +#include "gran_sub_mod_normal.h" +#include "gran_sub_mod_tangential.h" #include "granular_model.h" #include "error.h" #include "math_const.h" @@ -25,23 +25,25 @@ using namespace Granular_NS; using namespace MathConst; using namespace MathExtra; +#define EPSILON 1e-10 + /* ---------------------------------------------------------------------- Default model ------------------------------------------------------------------------- */ -GSMTangential::GSMTangential(GranularModel *gm, LAMMPS *lmp) : GSM(gm, lmp) {} +GranSubModTangential::GranSubModTangential(GranularModel *gm, LAMMPS *lmp) : GranSubMod(gm, lmp) {} /* ---------------------------------------------------------------------- No model ------------------------------------------------------------------------- */ -GSMTangentialNone::GSMTangentialNone(GranularModel *gm, LAMMPS *lmp) : GSMTangential(gm, lmp) {} +GranSubModTangentialNone::GranSubModTangentialNone(GranularModel *gm, LAMMPS *lmp) : GranSubModTangential(gm, lmp) {} /* ---------------------------------------------------------------------- Linear model with no history ------------------------------------------------------------------------- */ -GSMTangentialLinearNoHistory::GSMTangentialLinearNoHistory(GranularModel *gm, LAMMPS *lmp) : GSMTangential(gm, lmp) +GranSubModTangentialLinearNoHistory::GranSubModTangentialLinearNoHistory(GranularModel *gm, LAMMPS *lmp) : GranSubModTangential(gm, lmp) { num_coeffs = 2; size_history = 0; @@ -49,7 +51,7 @@ GSMTangentialLinearNoHistory::GSMTangentialLinearNoHistory(GranularModel *gm, LA /* ---------------------------------------------------------------------- */ -void GSMTangentialLinearNoHistory::coeffs_to_local() +void GranSubModTangentialLinearNoHistory::coeffs_to_local() { k = 0.0; // No tangential stiffness with no history xt = coeffs[0]; @@ -61,7 +63,7 @@ void GSMTangentialLinearNoHistory::coeffs_to_local() /* ---------------------------------------------------------------------- */ -void GSMTangentialLinearNoHistory::calculate_forces() +void GranSubModTangentialLinearNoHistory::calculate_forces() { // classic pair gran/hooke (no history) damp = xt * gm->damping_model->damp_prefactor; @@ -80,7 +82,7 @@ void GSMTangentialLinearNoHistory::calculate_forces() Linear model with history ------------------------------------------------------------------------- */ -GSMTangentialLinearHistory::GSMTangentialLinearHistory(GranularModel *gm, LAMMPS *lmp) : GSMTangential(gm, lmp) +GranSubModTangentialLinearHistory::GranSubModTangentialLinearHistory(GranularModel *gm, LAMMPS *lmp) : GranSubModTangential(gm, lmp) { num_coeffs = 3; size_history = 3; @@ -88,7 +90,7 @@ GSMTangentialLinearHistory::GSMTangentialLinearHistory(GranularModel *gm, LAMMPS /* ---------------------------------------------------------------------- */ -void GSMTangentialLinearHistory::coeffs_to_local() +void GranSubModTangentialLinearHistory::coeffs_to_local() { k = coeffs[0]; xt = coeffs[1]; @@ -100,7 +102,7 @@ void GSMTangentialLinearHistory::coeffs_to_local() /* ---------------------------------------------------------------------- */ -void GSMTangentialLinearHistory::calculate_forces() +void GranSubModTangentialLinearHistory::calculate_forces() { // Note: this is the same as the base Mindlin calculation except k isn't scaled by area double magfs, magfs_inv, rsht, shrmag, prjmag, temp_dbl, temp_array[3]; @@ -163,14 +165,14 @@ void GSMTangentialLinearHistory::calculate_forces() Linear model with history from pair gran/hooke/history ------------------------------------------------------------------------- */ -GSMTangentialLinearHistoryClassic::GSMTangentialLinearHistoryClassic(GranularModel *gm, LAMMPS *lmp) : GSMTangentialLinearHistory(gm, lmp) +GranSubModTangentialLinearHistoryClassic::GranSubModTangentialLinearHistoryClassic(GranularModel *gm, LAMMPS *lmp) : GranSubModTangentialLinearHistory(gm, lmp) { area_flag = 1; // Sets gran/hooke/history behavior } /* ---------------------------------------------------------------------- */ -void GSMTangentialLinearHistoryClassic::calculate_forces() +void GranSubModTangentialLinearHistoryClassic::calculate_forces() { double magfs, magfs_inv, rsht, shrmag, prjmag, temp_dbl; double temp_array[3]; @@ -222,7 +224,7 @@ void GSMTangentialLinearHistoryClassic::calculate_forces() Mindlin from pair gran/hertz/history ------------------------------------------------------------------------- */ -GSMTangentialMindlinClassic::GSMTangentialMindlinClassic(GranularModel *gm, LAMMPS *lmp) : GSMTangentialLinearHistoryClassic(gm, lmp) +GranSubModTangentialMindlinClassic::GranSubModTangentialMindlinClassic(GranularModel *gm, LAMMPS *lmp) : GranSubModTangentialLinearHistoryClassic(gm, lmp) { area_flag = 1; // Sets gran/hertz/history behavior } @@ -231,7 +233,7 @@ GSMTangentialMindlinClassic::GSMTangentialMindlinClassic(GranularModel *gm, LAMM Mindlin model ------------------------------------------------------------------------- */ -GSMTangentialMindlin::GSMTangentialMindlin(GranularModel *gm, LAMMPS *lmp) : GSMTangential(gm, lmp) +GranSubModTangentialMindlin::GranSubModTangentialMindlin(GranularModel *gm, LAMMPS *lmp) : GranSubModTangential(gm, lmp) { num_coeffs = 3; size_history = 3; @@ -242,7 +244,7 @@ GSMTangentialMindlin::GSMTangentialMindlin(GranularModel *gm, LAMMPS *lmp) : GSM /* ---------------------------------------------------------------------- */ -void GSMTangentialMindlin::coeffs_to_local() +void GranSubModTangentialMindlin::coeffs_to_local() { k = coeffs[0]; xt = coeffs[1]; @@ -268,7 +270,7 @@ void GSMTangentialMindlin::coeffs_to_local() /* ---------------------------------------------------------------------- */ -void GSMTangentialMindlin::mix_coeffs(double* icoeffs, double* jcoeffs) +void GranSubModTangentialMindlin::mix_coeffs(double* icoeffs, double* jcoeffs) { if (icoeffs[0] == -1 || jcoeffs[0] == -1) coeffs[0] = -1; else coeffs[0] = mix_geom(icoeffs[0], jcoeffs[0]); @@ -279,7 +281,7 @@ void GSMTangentialMindlin::mix_coeffs(double* icoeffs, double* jcoeffs) /* ---------------------------------------------------------------------- */ -void GSMTangentialMindlin::calculate_forces() +void GranSubModTangentialMindlin::calculate_forces() { double k_scaled, magfs, magfs_inv, rsht, shrmag, prjmag, temp_dbl; double temp_array[3]; @@ -366,7 +368,7 @@ void GSMTangentialMindlin::calculate_forces() Mindlin force model ------------------------------------------------------------------------- */ -GSMTangentialMindlinForce::GSMTangentialMindlinForce(GranularModel *gm, LAMMPS *lmp) : GSMTangentialMindlin(gm, lmp) +GranSubModTangentialMindlinForce::GranSubModTangentialMindlinForce(GranularModel *gm, LAMMPS *lmp) : GranSubModTangentialMindlin(gm, lmp) { mindlin_force = 1; } @@ -375,7 +377,7 @@ GSMTangentialMindlinForce::GSMTangentialMindlinForce(GranularModel *gm, LAMMPS * Mindlin rescale model ------------------------------------------------------------------------- */ -GSMTangentialMindlinRescale::GSMTangentialMindlinRescale(GranularModel *gm, LAMMPS *lmp) : GSMTangentialMindlin(gm, lmp) +GranSubModTangentialMindlinRescale::GranSubModTangentialMindlinRescale(GranularModel *gm, LAMMPS *lmp) : GranSubModTangentialMindlin(gm, lmp) { size_history = 4; mindlin_rescale = 1; @@ -390,7 +392,7 @@ GSMTangentialMindlinRescale::GSMTangentialMindlinRescale(GranularModel *gm, LAMM Mindlin rescale force model ------------------------------------------------------------------------- */ -GSMTangentialMindlinRescaleForce::GSMTangentialMindlinRescaleForce(GranularModel *gm, LAMMPS *lmp) : GSMTangentialMindlin(gm, lmp) +GranSubModTangentialMindlinRescaleForce::GranSubModTangentialMindlinRescaleForce(GranularModel *gm, LAMMPS *lmp) : GranSubModTangentialMindlin(gm, lmp) { size_history = 4; mindlin_force = 1; diff --git a/src/GRANULAR/gsm_tangential.h b/src/GRANULAR/gran_sub_mod_tangential.h similarity index 50% rename from src/GRANULAR/gsm_tangential.h rename to src/GRANULAR/gran_sub_mod_tangential.h index e755f63304..56d72f80d3 100644 --- a/src/GRANULAR/gsm_tangential.h +++ b/src/GRANULAR/gran_sub_mod_tangential.h @@ -11,58 +11,58 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#ifdef GSM_CLASS +#ifdef GRAN_SUB_MOD_CLASS // clang-format off -GSMStyle(none, - GSMTangentialNone, +GranSubModStyle(none, + GranSubModTangentialNone, TANGENTIAL); -GSMStyle(linear_nohistory, - GSMTangentialLinearNoHistory, +GranSubModStyle(linear_nohistory, + GranSubModTangentialLinearNoHistory, TANGENTIAL); -GSMStyle(linear_history, - GSMTangentialLinearHistory, +GranSubModStyle(linear_history, + GranSubModTangentialLinearHistory, TANGENTIAL); -GSMStyle(linear_history_classic, - GSMTangentialLinearHistoryClassic, +GranSubModStyle(linear_history_classic, + GranSubModTangentialLinearHistoryClassic, TANGENTIAL); -GSMStyle(mindlin_classic, - GSMTangentialMindlinClassic, +GranSubModStyle(mindlin_classic, + GranSubModTangentialMindlinClassic, TANGENTIAL); -GSMStyle(mindlin, - GSMTangentialMindlin, +GranSubModStyle(mindlin, + GranSubModTangentialMindlin, TANGENTIAL); -GSMStyle(mindlin/force, - GSMTangentialMindlinForce, +GranSubModStyle(mindlin/force, + GranSubModTangentialMindlinForce, TANGENTIAL); -GSMStyle(mindlin_rescale, - GSMTangentialMindlinRescale, +GranSubModStyle(mindlin_rescale, + GranSubModTangentialMindlinRescale, TANGENTIAL); -GSMStyle(mindlin_rescale/force, - GSMTangentialMindlinRescaleForce, +GranSubModStyle(mindlin_rescale/force, + GranSubModTangentialMindlinRescaleForce, TANGENTIAL); // clang-format on #else -#ifndef GSM_TANGENTIAL_H_ -#define GSM_TANGENTIAL_H_ +#ifndef GRAN_SUB_MOD_TANGENTIAL_H_ +#define GRAN_SUB_MOD_TANGENTIAL_H_ -#include "gsm.h" +#include "gran_sub_mod.h" namespace LAMMPS_NS { namespace Granular_NS { -class GSMTangential : public GSM { +class GranSubModTangential : public GranSubMod { public: - GSMTangential(class GranularModel *, class LAMMPS *); - virtual ~GSMTangential() {}; + GranSubModTangential(class GranularModel *, class LAMMPS *); + virtual ~GranSubModTangential() {}; virtual void coeffs_to_local() {}; virtual void init() {}; virtual void calculate_forces() = 0; @@ -71,17 +71,17 @@ class GSMTangential : public GSM { /* ---------------------------------------------------------------------- */ -class GSMTangentialNone : public GSMTangential { +class GranSubModTangentialNone : public GranSubModTangential { public: - GSMTangentialNone(class GranularModel *, class LAMMPS *); + GranSubModTangentialNone(class GranularModel *, class LAMMPS *); void calculate_forces() {}; }; /* ---------------------------------------------------------------------- */ -class GSMTangentialLinearNoHistory : public GSMTangential { +class GranSubModTangentialLinearNoHistory : public GranSubModTangential { public: - GSMTangentialLinearNoHistory(class GranularModel *, class LAMMPS *); + GranSubModTangentialLinearNoHistory(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; void calculate_forces(); protected: @@ -90,9 +90,9 @@ class GSMTangentialLinearNoHistory : public GSMTangential { /* ---------------------------------------------------------------------- */ -class GSMTangentialLinearHistory : public GSMTangential { +class GranSubModTangentialLinearHistory : public GranSubModTangential { public: - GSMTangentialLinearHistory(class GranularModel *, class LAMMPS *); + GranSubModTangentialLinearHistory(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; void calculate_forces(); protected: @@ -101,9 +101,9 @@ class GSMTangentialLinearHistory : public GSMTangential { /* ---------------------------------------------------------------------- */ -class GSMTangentialLinearHistoryClassic : public GSMTangentialLinearHistory { +class GranSubModTangentialLinearHistoryClassic : public GranSubModTangentialLinearHistory { public: - GSMTangentialLinearHistoryClassic(class GranularModel *, class LAMMPS *); + GranSubModTangentialLinearHistoryClassic(class GranularModel *, class LAMMPS *); void calculate_forces(); protected: double xt; @@ -111,16 +111,16 @@ class GSMTangentialLinearHistoryClassic : public GSMTangentialLinearHistory { /* ---------------------------------------------------------------------- */ -class GSMTangentialMindlinClassic : public GSMTangentialLinearHistoryClassic { +class GranSubModTangentialMindlinClassic : public GranSubModTangentialLinearHistoryClassic { public: - GSMTangentialMindlinClassic(class GranularModel *, class LAMMPS *); + GranSubModTangentialMindlinClassic(class GranularModel *, class LAMMPS *); }; /* ---------------------------------------------------------------------- */ -class GSMTangentialMindlin : public GSMTangential { +class GranSubModTangentialMindlin : public GranSubModTangential { public: - GSMTangentialMindlin(class GranularModel *, class LAMMPS *); + GranSubModTangentialMindlin(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; void mix_coeffs(double*, double*) override; void calculate_forces(); @@ -131,27 +131,27 @@ class GSMTangentialMindlin : public GSMTangential { /* ---------------------------------------------------------------------- */ -class GSMTangentialMindlinForce : public GSMTangentialMindlin { +class GranSubModTangentialMindlinForce : public GranSubModTangentialMindlin { public: - GSMTangentialMindlinForce(class GranularModel *, class LAMMPS *); + GranSubModTangentialMindlinForce(class GranularModel *, class LAMMPS *); }; /* ---------------------------------------------------------------------- */ -class GSMTangentialMindlinRescale : public GSMTangentialMindlin { +class GranSubModTangentialMindlinRescale : public GranSubModTangentialMindlin { public: - GSMTangentialMindlinRescale(class GranularModel *, class LAMMPS *); + GranSubModTangentialMindlinRescale(class GranularModel *, class LAMMPS *); }; /* ---------------------------------------------------------------------- */ -class GSMTangentialMindlinRescaleForce : public GSMTangentialMindlin { +class GranSubModTangentialMindlinRescaleForce : public GranSubModTangentialMindlin { public: - GSMTangentialMindlinRescaleForce(class GranularModel *, class LAMMPS *); + GranSubModTangentialMindlinRescaleForce(class GranularModel *, class LAMMPS *); }; } // namespace Granular_NS } // namespace LAMMPS_NS -#endif /*GSM_TANGENTIAL_H_ */ -#endif /*GSM_CLASS_H_ */ +#endif /*GRAN_SUB_MOD_TANGENTIAL_H_ */ +#endif /*GRAN_SUB_MOD_CLASS_H_ */ diff --git a/src/GRANULAR/gsm_twisting.cpp b/src/GRANULAR/gran_sub_mod_twisting.cpp similarity index 82% rename from src/GRANULAR/gsm_twisting.cpp rename to src/GRANULAR/gran_sub_mod_twisting.cpp index 42609bf632..9cb6d69dc8 100644 --- a/src/GRANULAR/gsm_twisting.cpp +++ b/src/GRANULAR/gran_sub_mod_twisting.cpp @@ -12,9 +12,9 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "gsm_normal.h" -#include "gsm_tangential.h" -#include "gsm_twisting.h" +#include "gran_sub_mod_normal.h" +#include "gran_sub_mod_tangential.h" +#include "gran_sub_mod_twisting.h" #include "granular_model.h" #include "error.h" #include "math_const.h" @@ -27,19 +27,19 @@ using namespace MathConst; Default twisting model ------------------------------------------------------------------------- */ -GSMTwisting::GSMTwisting(GranularModel *gm, LAMMPS *lmp) : GSM(gm, lmp) {} +GranSubModTwisting::GranSubModTwisting(GranularModel *gm, LAMMPS *lmp) : GranSubMod(gm, lmp) {} /* ---------------------------------------------------------------------- No model ------------------------------------------------------------------------- */ -GSMTwistingNone::GSMTwistingNone(GranularModel *gm, LAMMPS *lmp) : GSMTwisting(gm, lmp) {} +GranSubModTwistingNone::GranSubModTwistingNone(GranularModel *gm, LAMMPS *lmp) : GranSubModTwisting(gm, lmp) {} /* ---------------------------------------------------------------------- Marshall twisting model ------------------------------------------------------------------------- */ -GSMTwistingMarshall::GSMTwistingMarshall(GranularModel *gm, LAMMPS *lmp) : GSMTwisting(gm, lmp) +GranSubModTwistingMarshall::GranSubModTwistingMarshall(GranularModel *gm, LAMMPS *lmp) : GranSubModTwisting(gm, lmp) { num_coeffs = 0; size_history = 3; @@ -49,7 +49,7 @@ GSMTwistingMarshall::GSMTwistingMarshall(GranularModel *gm, LAMMPS *lmp) : GSMTw /* ---------------------------------------------------------------------- */ -void GSMTwistingMarshall::init() +void GranSubModTwistingMarshall::init() { k_tang = gm->tangential_model->k; mu_tang = gm->tangential_model->mu; @@ -57,7 +57,7 @@ void GSMTwistingMarshall::init() /* ---------------------------------------------------------------------- */ -void GSMTwistingMarshall::calculate_forces() +void GranSubModTwistingMarshall::calculate_forces() { double signtwist, Mtcrit; @@ -86,7 +86,7 @@ void GSMTwistingMarshall::calculate_forces() SDS twisting model ------------------------------------------------------------------------- */ -GSMTwistingSDS::GSMTwistingSDS(GranularModel *gm, LAMMPS *lmp) : GSMTwisting(gm, lmp) +GranSubModTwistingSDS::GranSubModTwistingSDS(GranularModel *gm, LAMMPS *lmp) : GranSubModTwisting(gm, lmp) { num_coeffs = 3; size_history = 3; @@ -94,7 +94,7 @@ GSMTwistingSDS::GSMTwistingSDS(GranularModel *gm, LAMMPS *lmp) : GSMTwisting(gm, /* ---------------------------------------------------------------------- */ -void GSMTwistingSDS::coeffs_to_local() +void GranSubModTwistingSDS::coeffs_to_local() { k = coeffs[0]; damp = coeffs[1]; @@ -106,7 +106,7 @@ void GSMTwistingSDS::coeffs_to_local() /* ---------------------------------------------------------------------- */ -void GSMTwistingSDS::calculate_forces() +void GranSubModTwistingSDS::calculate_forces() { double signtwist, Mtcrit; diff --git a/src/GRANULAR/gsm_twisting.h b/src/GRANULAR/gran_sub_mod_twisting.h similarity index 62% rename from src/GRANULAR/gsm_twisting.h rename to src/GRANULAR/gran_sub_mod_twisting.h index b9ab7826a6..7f8addec97 100644 --- a/src/GRANULAR/gsm_twisting.h +++ b/src/GRANULAR/gran_sub_mod_twisting.h @@ -11,34 +11,34 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#ifdef GSM_CLASS +#ifdef GRAN_SUB_MOD_CLASS // clang-format off -GSMStyle(none, - GSMTwistingNone, +GranSubModStyle(none, + GranSubModTwistingNone, TWISTING); -GSMStyle(marshall, - GSMTwistingMarshall, +GranSubModStyle(marshall, + GranSubModTwistingMarshall, TWISTING); -GSMStyle(sds, - GSMTwistingSDS, +GranSubModStyle(sds, + GranSubModTwistingSDS, TWISTING); // clang-format on #else -#ifndef GSM_TWISTING_H_ -#define GSM_TWISTING_H_ +#ifndef GRAN_SUB_MOD_TWISTING_H_ +#define GRAN_SUB_MOD_TWISTING_H_ -#include "gsm.h" +#include "gran_sub_mod.h" namespace LAMMPS_NS { namespace Granular_NS { -class GSMTwisting : public GSM { +class GranSubModTwisting : public GranSubMod { public: - GSMTwisting(class GranularModel *, class LAMMPS *); - virtual ~GSMTwisting() {}; + GranSubModTwisting(class GranularModel *, class LAMMPS *); + virtual ~GranSubModTwisting() {}; virtual void coeffs_to_local() {}; virtual void init() {}; virtual void calculate_forces() = 0; @@ -46,17 +46,17 @@ class GSMTwisting : public GSM { /* ---------------------------------------------------------------------- */ -class GSMTwistingNone : public GSMTwisting { +class GranSubModTwistingNone : public GranSubModTwisting { public: - GSMTwistingNone(class GranularModel *, class LAMMPS *); + GranSubModTwistingNone(class GranularModel *, class LAMMPS *); void calculate_forces() {}; }; /* ---------------------------------------------------------------------- */ -class GSMTwistingMarshall : public GSMTwisting { +class GranSubModTwistingMarshall : public GranSubModTwisting { public: - GSMTwistingMarshall(class GranularModel *, class LAMMPS *); + GranSubModTwistingMarshall(class GranularModel *, class LAMMPS *); void calculate_forces(); void init(); protected: @@ -65,9 +65,9 @@ class GSMTwistingMarshall : public GSMTwisting { /* ---------------------------------------------------------------------- */ -class GSMTwistingSDS : public GSMTwisting { +class GranSubModTwistingSDS : public GranSubModTwisting { public: - GSMTwistingSDS(class GranularModel *, class LAMMPS *); + GranSubModTwistingSDS(class GranularModel *, class LAMMPS *); void coeffs_to_local() override; void calculate_forces(); protected: @@ -77,5 +77,5 @@ class GSMTwistingSDS : public GSMTwisting { } // namespace Granular_NS } // namespace LAMMPS_NS -#endif /*GSM_TWISTING_H_ */ -#endif /*GSM_CLASS_H_ */ +#endif /*GRAN_SUB_MOD_TWISTING_H_ */ +#endif /*GRAN_SUB_MOD_CLASS_H_ */ diff --git a/src/GRANULAR/granular_model.cpp b/src/GRANULAR/granular_model.cpp index 66e34386ed..872bfa6c8d 100644 --- a/src/GRANULAR/granular_model.cpp +++ b/src/GRANULAR/granular_model.cpp @@ -22,12 +22,12 @@ ----------------------------------------------------------------------- */ #include "granular_model.h" -#include "gsm.h" +#include "gran_sub_mod.h" #include "comm.h" #include "error.h" #include "force.h" #include "math_extra.h" -#include "style_gsm.h" // IWYU pragma: keep +#include "style_gran_sub_mod.h" // IWYU pragma: keep #include @@ -36,10 +36,10 @@ using namespace Granular_NS; using namespace MathExtra; /* ---------------------------------------------------------------------- - one instance per GSM style in style_gsm.h + one instance per GranSubMod style in style_gran_sub_mod.h ------------------------------------------------------------------------- */ -template static GSM *gsm_creator(GranularModel *gm, LAMMPS *lmp) +template static GranSubMod *gran_sub_mod_creator(GranularModel *gm, LAMMPS *lmp) { return new T(gm, lmp); } @@ -64,29 +64,29 @@ GranularModel::GranularModel(LAMMPS *lmp) : Pointers(lmp) for (int i = 0; i < NSUBMODELS; i++) sub_models[i] = nullptr; transfer_history_factor = nullptr; - // extract info from GSM classes listed in style_gsm.h + // extract info from GranSubMod classes listed in style_gran_sub_mod.h nclass = 0; -#define GSM_CLASS -#define GSMStyle(key,Class,type) nclass++; -#include "style_gsm.h" // IWYU pragma: keep -#undef GSMStyle -#undef GSM_CLASS +#define GRANSUBMOD_CLASS +#define GranSubModStyle(key,Class,type) nclass++; +#include "style_gran_sub_mod.h" // IWYU pragma: keep +#undef GranSubModStyle +#undef GRANSUBMOD_CLASS - gsmclass = new GSMCreator[nclass]; - gsmnames = new char*[nclass]; - gsmtypes = new int[nclass]; + gran_sub_mod_class = new GranSubModCreator[nclass]; + gran_sub_mod_names = new char*[nclass]; + gran_sub_mod_types = new int[nclass]; nclass = 0; -#define GSM_CLASS -#define GSMStyle(key,Class,type) \ - gsmclass[nclass] = &gsm_creator; \ - gsmnames[nclass] = (char *) #key; \ - gsmtypes[nclass++] = type; -#include "style_gsm.h" // IWYU pragma: keep -#undef GSMStyle -#undef GSM_CLASS +#define GRANSUBMOD_CLASS +#define GranSubModStyle(key,Class,type) \ + gran_sub_mod_class[nclass] = &gran_sub_mod_creator; \ + gran_sub_mod_names[nclass] = (char *) #key; \ + gran_sub_mod_types[nclass++] = type; +#include "style_gran_sub_mod.h" // IWYU pragma: keep +#undef GranSubModStyle +#undef GRANSUBMOD_CLASS } /* ---------------------------------------------------------------------- */ @@ -94,9 +94,9 @@ GranularModel::GranularModel(LAMMPS *lmp) : Pointers(lmp) GranularModel::~GranularModel() { delete [] transfer_history_factor; - delete [] gsmclass; - delete [] gsmnames; - delete [] gsmtypes; + delete [] gran_sub_mod_class; + delete [] gran_sub_mod_names; + delete [] gran_sub_mod_types; for (int i = 0; i < NSUBMODELS; i ++) delete sub_models[i]; } @@ -132,11 +132,11 @@ void GranularModel::construct_submodel(std::string model_name, SubmodelType mode { int i; for (i = 0; i < nclass; i++) { - if (gsmtypes[i] == model_type) { - if (strcmp(gsmnames[i], model_name.c_str()) == 0) { - GSMCreator &gsm_creator = gsmclass[i]; + if (gran_sub_mod_types[i] == model_type) { + if (strcmp(gran_sub_mod_names[i], model_name.c_str()) == 0) { + GranSubModCreator &gran_sub_mod_creator = gran_sub_mod_class[i]; delete sub_models[model_type]; - sub_models[model_type] = gsm_creator(this, lmp); + sub_models[model_type] = gran_sub_mod_creator(this, lmp); break; } } @@ -148,12 +148,12 @@ void GranularModel::construct_submodel(std::string model_name, SubmodelType mode sub_models[model_type]->name.assign(model_name); sub_models[model_type]->allocate_coeffs(); - if (model_type == NORMAL) normal_model = dynamic_cast (sub_models[NORMAL]); - if (model_type == DAMPING) damping_model = dynamic_cast (sub_models[DAMPING]); - if (model_type == TANGENTIAL) tangential_model = dynamic_cast (sub_models[TANGENTIAL]); - if (model_type == ROLLING) rolling_model = dynamic_cast (sub_models[ROLLING]); - if (model_type == TWISTING) twisting_model = dynamic_cast (sub_models[TWISTING]); - if (model_type == HEAT) heat_model = dynamic_cast (sub_models[HEAT]); + if (model_type == NORMAL) normal_model = dynamic_cast (sub_models[NORMAL]); + if (model_type == DAMPING) damping_model = dynamic_cast (sub_models[DAMPING]); + if (model_type == TANGENTIAL) tangential_model = dynamic_cast (sub_models[TANGENTIAL]); + if (model_type == ROLLING) rolling_model = dynamic_cast (sub_models[ROLLING]); + if (model_type == TWISTING) twisting_model = dynamic_cast (sub_models[TWISTING]); + if (model_type == HEAT) heat_model = dynamic_cast (sub_models[HEAT]); } /* ---------------------------------------------------------------------- */ diff --git a/src/GRANULAR/granular_model.h b/src/GRANULAR/granular_model.h index 3ea3d9e4b3..de4f82c01e 100644 --- a/src/GRANULAR/granular_model.h +++ b/src/GRANULAR/granular_model.h @@ -19,8 +19,6 @@ namespace LAMMPS_NS { namespace Granular_NS { -#define EPSILON 1e-10 - enum SubmodelType { NORMAL = 0, DAMPING, @@ -38,13 +36,13 @@ enum ContactType { }; // forward declarations -class GSM; -class GSMNormal; -class GSMDamping; -class GSMTangential; -class GSMRolling; -class GSMTwisting; -class GSMHeat; +class GranSubMod; +class GranSubModNormal; +class GranSubModDamping; +class GranSubModTangential; +class GranSubModRolling; +class GranSubModTwisting; +class GranSubModHeat; class GranularModel : protected Pointers { public: @@ -64,13 +62,13 @@ class GranularModel : protected Pointers { void read_restart(FILE *); // Sub models - GSMNormal *normal_model; - GSMDamping *damping_model; - GSMTangential *tangential_model; - GSMRolling *rolling_model; - GSMTwisting *twisting_model; - GSMHeat *heat_model; - GSM *sub_models[NSUBMODELS]; // Need to resize if we add more model flavors + GranSubModNormal *normal_model; + GranSubModDamping *damping_model; + GranSubModTangential *tangential_model; + GranSubModRolling *rolling_model; + GranSubModTwisting *twisting_model; + GranSubModHeat *heat_model; + GranSubMod *sub_models[NSUBMODELS]; // Need to resize if we add more model flavors // Extra options int beyond_contact, limit_damping, history_update; @@ -102,10 +100,10 @@ class GranularModel : protected Pointers { int nclass; - typedef class GSM *(*GSMCreator)(class GranularModel *, class LAMMPS *); - GSMCreator *gsmclass; - char **gsmnames; - int *gsmtypes; + typedef class GranSubMod *(*GranSubModCreator)(class GranularModel *, class LAMMPS *); + GranSubModCreator *gran_sub_mod_class; + char **gran_sub_mod_names; + int *gran_sub_mod_types; }; } // namespace Granular_NS diff --git a/src/GRANULAR/pair_granular.cpp b/src/GRANULAR/pair_granular.cpp index dcac8e32c3..b6c9bba705 100644 --- a/src/GRANULAR/pair_granular.cpp +++ b/src/GRANULAR/pair_granular.cpp @@ -23,7 +23,7 @@ #include "atom.h" #include "comm.h" #include "granular_model.h" -#include "gsm.h" +#include "gran_sub_mod.h" #include "error.h" #include "fix.h" #include "fix_dummy.h" diff --git a/src/GRANULAR/pair_granular.h b/src/GRANULAR/pair_granular.h index 9ae02a200a..956717d598 100644 --- a/src/GRANULAR/pair_granular.h +++ b/src/GRANULAR/pair_granular.h @@ -20,12 +20,15 @@ PairStyle(granular,PairGranular); #ifndef LMP_PAIR_GRANULAR_H #define LMP_PAIR_GRANULAR_H -#include "granular_model.h" #include "pair.h" #include namespace LAMMPS_NS { +namespace Granular_NS { + class GranularModel; +} + class PairGranular : public Pair { public: PairGranular(class LAMMPS *); @@ -73,7 +76,7 @@ class PairGranular : public Pair { // granular models int nmodels, maxmodels; - Granular_NS::GranularModel** models_list; + class Granular_NS::GranularModel** models_list; int **types_indices; // optional user-specified global cutoff, per-type user-specified cutoffs diff --git a/src/Make.sh b/src/Make.sh index da034f8226..8f63adea4a 100755 --- a/src/Make.sh +++ b/src/Make.sh @@ -95,27 +95,27 @@ cmd=$1 if (test $cmd = "style") || (test $cmd = "packages") then - $cmd ANGLE_CLASS angle_ angle force - $cmd ATOM_CLASS atom_vec_ atom atom atom_vec_hybrid - $cmd BODY_CLASS body_ body atom_vec_body - $cmd BOND_CLASS bond_ bond force - $cmd COMMAND_CLASS "" command input - $cmd COMPUTE_CLASS compute_ compute modify - $cmd DIHEDRAL_CLASS dihedral_ dihedral force - $cmd DUMP_CLASS dump_ dump output write_dump - $cmd FIX_CLASS fix_ fix modify - $cmd GSM_CLASS gsm_ gsm granular_model - $cmd IMPROPER_CLASS improper_ improper force - $cmd INTEGRATE_CLASS "" integrate update - $cmd KSPACE_CLASS "" kspace force - $cmd MINIMIZE_CLASS min_ minimize update - $cmd NBIN_CLASS nbin_ nbin neighbor - $cmd NPAIR_CLASS npair_ npair neighbor - $cmd NSTENCIL_CLASS nstencil_ nstencil neighbor - $cmd NTOPO_CLASS ntopo_ ntopo neighbor - $cmd PAIR_CLASS pair_ pair force - $cmd READER_CLASS reader_ reader read_dump - $cmd REGION_CLASS region_ region domain + $cmd ANGLE_CLASS angle_ angle force + $cmd ATOM_CLASS atom_vec_ atom atom atom_vec_hybrid + $cmd BODY_CLASS body_ body atom_vec_body + $cmd BOND_CLASS bond_ bond force + $cmd COMMAND_CLASS "" command input + $cmd COMPUTE_CLASS compute_ compute modify + $cmd DIHEDRAL_CLASS dihedral_ dihedral force + $cmd DUMP_CLASS dump_ dump output write_dump + $cmd FIX_CLASS fix_ fix modify + $cmd GRAN_SUB_MOD_CLASS gran_sub_mod_ gran_sub_mod granular_model + $cmd IMPROPER_CLASS improper_ improper force + $cmd INTEGRATE_CLASS "" integrate update + $cmd KSPACE_CLASS "" kspace force + $cmd MINIMIZE_CLASS min_ minimize update + $cmd NBIN_CLASS nbin_ nbin neighbor + $cmd NPAIR_CLASS npair_ npair neighbor + $cmd NSTENCIL_CLASS nstencil_ nstencil neighbor + $cmd NTOPO_CLASS ntopo_ ntopo neighbor + $cmd PAIR_CLASS pair_ pair force + $cmd READER_CLASS reader_ reader read_dump + $cmd REGION_CLASS region_ region domain # edit Makefile.lib, for creating non-shared lib # called by "make makelib"