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

"stringify" and "vectorize" processing of per-atom attributs in AtomVec classes

Browse Source
This commit is contained in:
Axel Kohlmeyer
2022-04-14 11:06:10 -04:00
parent 1755d06870
commit b16d48aa41
37 changed files with 1596 additions and 1832 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
src/AWPMD/atom_vec_wavepacket.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -20,8 +19,6 @@
#include "atom.h"
#include <cstring>
using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
@ -32,12 +29,9 @@ AtomVecWavepacket::AtomVecWavepacket(LAMMPS *lmp) : AtomVec(lmp)
molecular = Atom::ATOMIC;
forceclearflag = 1;
atom->wavepacket_flag = 1;
atom->electron_flag = 1; // compatible with eff
atom->q_flag = atom->spin_flag = atom->eradius_flag =
atom->ervel_flag = atom->erforce_flag = 1;
atom->cs_flag = atom->csforce_flag =
atom->wavepacket_flag = atom->q_flag = atom->spin_flag = atom->eradius_flag = 1;
atom->ervel_flag = atom->erforce_flag = atom->cs_flag = atom->csforce_flag = 1;
atom->vforce_flag = atom->ervelforce_flag = atom->etag_flag = 1;
// strings with peratom variables to include in each AtomVec method
@ -45,20 +39,19 @@ AtomVecWavepacket::AtomVecWavepacket(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *)
"q spin eradius ervel erforce cs csforce "
"vforce ervelforce etag";
fields_copy = (char *) "q spin eradius ervel cs etag";
fields_comm = (char *) "eradius";
fields_comm_vel = (char *) "eradius ervel cs";
fields_reverse = (char *) "erforce ervelforce vforce csforce";
fields_border = (char *) "q spin eradius etag";
fields_border_vel = (char *) "q spin eradius etag ervel cs";
fields_exchange = (char *) "q spin eradius ervel etag cs";
fields_restart = (char *) "q spin eradius ervel etag cs";
fields_create = (char *) "q spin eradius ervel etag cs";
fields_data_atom = (char *) "id type q spin eradius etag cs x";
fields_data_vel = (char *) "id v ervel";
fields_grow = {"q", "spin", "eradius", "ervel", "erforce",
"cs", "csforce", "vforce", "ervelforce", "etag"};
fields_copy = {"q", "spin", "eradius", "ervel", "cs", "etag"};
fields_comm = {"eradius"};
fields_comm_vel = {"eradius", "ervel", "cs"};
fields_reverse = {"erforce", "ervelforce", "vforce", "csforce"};
fields_border = {"q", "spin", "eradius", "etag"};
fields_border_vel = {"q", "spin", "eradius", "etag", "ervel", "cs"};
fields_exchange = {"q", "spin", "eradius", "ervel", "etag", "cs"};
fields_restart = {"q", "spin", "eradius", "ervel", "etag", "cs"};
fields_create = {"q", "spin", "eradius", "ervel", "etag", "cs"};
fields_data_atom = {"id", "type", "q", "spin", "eradius", "etag", "cs", "x"};
fields_data_vel = {"id", "v", "ervel"};
setup_fields();
}
@ -84,7 +77,7 @@ void AtomVecWavepacket::grow_pointers()
void AtomVecWavepacket::force_clear(int n, size_t nbytes)
{
memset(&erforce[n],0,nbytes);
memset(&erforce[n], 0, nbytes);
}
/* ----------------------------------------------------------------------
@ -114,10 +107,10 @@ void AtomVecWavepacket::data_atom_post(int ilocal)
int AtomVecWavepacket::property_atom(char *name)
{
if (strcmp(name,"spin") == 0) return 0;
if (strcmp(name,"eradius") == 0) return 1;
if (strcmp(name,"ervel") == 0) return 2;
if (strcmp(name,"erforce") == 0) return 3;
if (strcmp(name, "spin") == 0) return 0;
if (strcmp(name, "eradius") == 0) return 1;
if (strcmp(name, "ervel") == 0) return 2;
if (strcmp(name, "erforce") == 0) return 3;
return -1;
}
@ -126,34 +119,41 @@ int AtomVecWavepacket::property_atom(char *name)
index maps to data specific to this atom style
------------------------------------------------------------------------- */
void AtomVecWavepacket::pack_property_atom(int index, double *buf,
int nvalues, int groupbit)
void AtomVecWavepacket::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
{
int nlocal = atom->nlocal;
int n = 0;
if (index == 0) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = spin[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = spin[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 1) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = eradius[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = eradius[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 2) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = ervel[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = ervel[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 3) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = erforce[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = erforce[i];
else
buf[n] = 0.0;
n += nvalues;
}
}

24
src/CG-DNA/atom_vec_oxdna.cpp
View File

@ -33,18 +33,18 @@ AtomVecOxdna::AtomVecOxdna(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "id5p";
fields_copy = (char *) "id5p";
fields_comm = (char *) "";
fields_comm_vel = (char *) "";
fields_reverse = (char *) "";
fields_border = (char *) "id5p";
fields_border_vel = (char *) "";
fields_exchange = (char *) "id5p";
fields_restart = (char *) "id5p";
fields_create = (char *) "";
fields_data_atom = (char *) "id type x";
fields_data_vel = (char *) "id v";
fields_grow = {"id5p"};
fields_copy = {"id5p"};
fields_comm = {};
fields_comm_vel = {};
fields_reverse = {};
fields_border = {"id5p"};
fields_border_vel = {};
fields_exchange = {"id5p"};
fields_restart = {"id5p"};
fields_create = {};
fields_data_atom = {"id", "type", "x"};
fields_data_vel = {"id", "v"};
setup_fields();

143
src/DIELECTRIC/atom_vec_dielectric.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/ Sandia National Laboratories
@ -18,7 +17,6 @@
#include "citeme.h"
#include <cmath>
#include <cstring>
using namespace LAMMPS_NS;
@ -33,8 +31,7 @@ static const char cite_user_dielectric_package[] =
" year = 2019,\n"
" volume = 241,\n"
" pages = {80--91}\n"
"}\n\n"
;
"}\n\n";
/* ---------------------------------------------------------------------- */
@ -53,55 +50,41 @@ AtomVecDielectric::AtomVecDielectric(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *)
"q molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4 "
"nspecial special "
"mu area ed em epsilon curvature q_unscaled";
fields_copy = (char *)
"q molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4 "
"nspecial special "
"mu area ed em epsilon curvature q_unscaled";
fields_comm = (char *) "q mu area ed em epsilon curvature q_unscaled";
fields_comm_vel = (char *) "";
fields_reverse = (char *) "";
fields_border = (char *) "q molecule mu area ed em epsilon curvature q_unscaled";
fields_border_vel = (char *) "q molecule mu area ed em epsilon curvature q_unscaled";
fields_exchange = (char *)
"q molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4 "
"nspecial special "
"mu area ed em epsilon curvature q_unscaled";
fields_restart = (char *)
"q molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4 "
"mu area ed em epsilon curvature q_unscaled";
fields_create = (char *)
"q molecule num_bond num_angle num_dihedral num_improper nspecial "
"mu area ed em epsilon curvature q_unscaled";
fields_data_atom = (char *) "id molecule type q x "
"mu3 area ed em epsilon curvature";
fields_data_vel = (char *) "id v";
// clang-format off
fields_grow = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special",
"mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
fields_copy = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special",
"mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
fields_comm = {"q", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
fields_comm_vel = {};
fields_reverse = {};
fields_border = {"q", "molecule", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
fields_border_vel = {"q", "molecule", "mu", "area", "ed", "em", "epsilon", "curvature",
"q_unscaled"};
fields_exchange = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle",
"angle_type", "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type",
"dihedral_atom1", "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper",
"improper_type", "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4",
"nspecial", "special", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
fields_restart = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle",
"angle_type", "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type",
"dihedral_atom1", "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper",
"improper_type", "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4",
"mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
fields_create = {"q", "molecule", "num_bond", "num_angle", "num_dihedral", "num_improper",
"nspecial", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
fields_data_atom = { "id", "molecule", "type", "q", "x", "mu3", "area", "ed", "em", "epsilon",
"curvature"};
fields_data_vel = {"id v"};
// clang-format on
setup_fields();
bond_per_atom = angle_per_atom = dihedral_per_atom = improper_per_atom = 0;
}
@ -157,13 +140,12 @@ void AtomVecDielectric::data_atom_post(int ilocal)
nspecial[ilocal][1] = 0;
nspecial[ilocal][2] = 0;
double* q = atom->q;
double *q = atom->q;
q_unscaled[ilocal] = q[ilocal];
q[ilocal] /= epsilon[ilocal];
double *mu_one = mu[ilocal];
mu_one[3] =
sqrt(mu_one[0]*mu_one[0] + mu_one[1]*mu_one[1] + mu_one[2]*mu_one[2]);
mu_one[3] = sqrt(mu_one[0] * mu_one[0] + mu_one[1] * mu_one[1] + mu_one[2] * mu_one[2]);
}
/* ----------------------------------------------------------------------
@ -182,14 +164,14 @@ void AtomVecDielectric::unpack_restart_init(int ilocal)
return -1 if name is unknown to this atom style
------------------------------------------------------------------------- */
int AtomVecDielectric::property_atom(char *name)
int AtomVecDielectric::property_atom(const std::string &name)
{
if (strcmp(name,"area") == 0) return 0;
if (strcmp(name,"ed") == 0) return 1;
if (strcmp(name,"em") == 0) return 2;
if (strcmp(name,"epsilon") == 0) return 3;
if (strcmp(name,"curvature") == 0) return 4;
if (strcmp(name,"q_unscaled") == 0) return 5;
if (name == "area") return 0;
if (name == "ed") return 1;
if (name == "em") return 2;
if (name == "epsilon") return 3;
if (name == "curvature") return 4;
if (name == "q_unscaled") return 5;
return -1;
}
@ -198,8 +180,7 @@ int AtomVecDielectric::property_atom(char *name)
index maps to data specific to this atom style
------------------------------------------------------------------------- */
void AtomVecDielectric::pack_property_atom(int index, double *buf,
int nvalues, int groupbit)
void AtomVecDielectric::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
{
int *mask = atom->mask;
int nlocal = atom->nlocal;
@ -207,38 +188,50 @@ void AtomVecDielectric::pack_property_atom(int index, double *buf,
if (index == 0) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = area[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = area[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 1) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = ed[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = ed[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 2) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = em[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = em[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 3) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = epsilon[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = epsilon[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 4) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = curvature[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = curvature[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 5) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = q_unscaled[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = q_unscaled[i];
else
buf[n] = 0.0;
n += nvalues;
}
}

2
src/DIELECTRIC/atom_vec_dielectric.h
View File

@ -35,7 +35,7 @@ class AtomVecDielectric : public AtomVec {
void create_atom_post(int) override;
void data_atom_post(int) override;
void unpack_restart_init(int) override;
int property_atom(char *) override;
int property_atom(const std::string &) override;
void pack_property_atom(int, double *, int, int) override;
protected:

28
src/DIPOLE/atom_vec_dipole.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -34,18 +33,18 @@ AtomVecDipole::AtomVecDipole(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "q mu";
fields_copy = (char *) "q mu";
fields_comm = (char *) "mu3";
fields_comm_vel = (char *) "mu3";
fields_reverse = (char *) "";
fields_border = (char *) "q mu";
fields_border_vel = (char *) "q mu";
fields_exchange = (char *) "q mu";
fields_restart = (char *) "q mu";
fields_create = (char *) "q mu";
fields_data_atom = (char *) "id type q x mu3";
fields_data_vel = (char *) "id v";
fields_grow = {"q", "mu"};
fields_copy = {"q", "mu"};
fields_comm = {"mu3"};
fields_comm_vel = {"mu3"};
fields_reverse = {};
fields_border = {"q", "mu"};
fields_border_vel = {"q", "mu"};
fields_exchange = {"q", "mu"};
fields_restart = {"q", "mu"};
fields_create = {"q", "mu"};
fields_data_atom = {"id", "type", "q", "x", "mu3"};
fields_data_vel = {"id", "v"};
setup_fields();
}
@ -68,6 +67,5 @@ void AtomVecDipole::grow_pointers()
void AtomVecDipole::data_atom_post(int ilocal)
{
double *mu_one = mu[ilocal];
mu_one[3] =
sqrt(mu_one[0]*mu_one[0] + mu_one[1]*mu_one[1] + mu_one[2]*mu_one[2]);
mu_one[3] = sqrt(mu_one[0] * mu_one[0] + mu_one[1] * mu_one[1] + mu_one[2] * mu_one[2]);
}

32
src/DPD-MESO/atom_vec_edpd.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -38,18 +37,18 @@ AtomVecEDPD::AtomVecEDPD(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "edpd_cv edpd_temp edpd_flux vest vest_temp";
fields_copy = (char *) "edpd_cv edpd_temp edpd_flux vest vest_temp";
fields_comm = (char *) "edpd_temp vest vest_temp";
fields_comm_vel = (char *) "edpd_temp vest vest_temp";
fields_reverse = (char *) "edpd_flux";
fields_border = (char *) "edpd_cv edpd_temp vest vest_temp";
fields_border_vel = (char *) "edpd_cv edpd_temp vest vest_temp";
fields_exchange = (char *) "edpd_cv edpd_temp vest vest_temp";
fields_restart = (char * ) "edpd_cv edpd_temp vest vest_temp";
fields_create = (char *) "edpd_cv edpd_temp edpd_flux vest vest_temp";
fields_data_atom = (char *) "id type edpd_temp edpd_cv x";
fields_data_vel = (char *) "id v";
fields_grow = {"edpd_cv", "edpd_temp", "edpd_flux", "vest", "vest_temp"};
fields_copy = {"edpd_cv", "edpd_temp", "edpd_flux", "vest", "vest_temp"};
fields_comm = {"edpd_temp", "vest", "vest_temp"};
fields_comm_vel = {"edpd_temp", "vest", "vest_temp"};
fields_reverse = {"edpd_flux"};
fields_border = {"edpd_cv", "edpd_temp", "vest", "vest_temp"};
fields_border_vel = {"edpd_cv", "edpd_temp", "vest", "vest_temp"};
fields_exchange = {"edpd_cv", "edpd_temp", "vest", "vest_temp"};
fields_restart = {"edpd_cv", "edpd_temp", "vest", "vest_temp"};
fields_create = {"edpd_cv", "edpd_temp", "edpd_flux", "vest", "vest_temp"};
fields_data_atom = {"id", "type", "edpd_temp", "edpd_cv", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
}
@ -60,8 +59,7 @@ void AtomVecEDPD::init()
{
AtomVec::init();
if (strcmp(update->unit_style,"lj") != 0)
error->all(FLERR,"Atom style edpd requires lj units");
if (strcmp(update->unit_style, "lj") != 0) error->all(FLERR, "Atom style edpd requires lj units");
}
/* ----------------------------------------------------------------------
@ -85,7 +83,7 @@ void AtomVecEDPD::grow_pointers()
void AtomVecEDPD::force_clear(int n, size_t nbytes)
{
memset(&edpd_flux[n],0,nbytes);
memset(&edpd_flux[n], 0, nbytes);
}
/* ----------------------------------------------------------------------
@ -95,7 +93,7 @@ void AtomVecEDPD::force_clear(int n, size_t nbytes)
void AtomVecEDPD::create_atom_post(int ilocal)
{
edpd_temp[ilocal] = 1.0;
edpd_cv[ilocal]= 1.0e5;
edpd_cv[ilocal] = 1.0e5;
vest_temp[ilocal] = edpd_temp[ilocal];
}

57
src/DPD-MESO/atom_vec_mdpd.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -13,10 +12,12 @@
------------------------------------------------------------------------- */
#include "atom_vec_mdpd.h"
#include <cstring>
#include "atom.h"
#include "update.h"
#include "error.h"
#include "update.h"
#include <cstring>
using namespace LAMMPS_NS;
@ -36,18 +37,18 @@ AtomVecMDPD::AtomVecMDPD(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rho drho vest";
fields_copy = (char *) "rho drho vest";
fields_comm = (char *) "rho vest";
fields_comm_vel = (char *) "rho vest";
fields_reverse = (char *) "drho";
fields_border = (char *) "rho vest";
fields_border_vel = (char *) "rho vest";
fields_exchange = (char *) "rho vest";
fields_restart = (char * ) "rho vest";
fields_create = (char *) "rho drho vest";
fields_data_atom = (char *) "id type rho x";
fields_data_vel = (char *) "id v";
fields_grow = {"rho", "drho", "vest"};
fields_copy = {"rho", "drho", "vest"};
fields_comm = {"rho", "vest"};
fields_comm_vel = {"rho", "vest"};
fields_reverse = {"drho"};
fields_border = {"rho", "vest"};
fields_border_vel = {"rho", "vest"};
fields_exchange = {"rho", "vest"};
fields_restart = {"rho", "vest"};
fields_create = {"rho", "drho", "vest"};
fields_data_atom = {"id", "type", "rho", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
}
@ -58,8 +59,7 @@ void AtomVecMDPD::init()
{
AtomVec::init();
if (strcmp(update->unit_style,"lj") != 0)
error->all(FLERR,"Atom style mdpd requires lj units");
if (strcmp(update->unit_style, "lj") != 0) error->all(FLERR, "Atom style mdpd requires lj units");
}
/* ----------------------------------------------------------------------
@ -81,7 +81,7 @@ void AtomVecMDPD::grow_pointers()
void AtomVecMDPD::force_clear(int n, size_t nbytes)
{
memset(&drho[n],0,nbytes);
memset(&drho[n], 0, nbytes);
}
/* ----------------------------------------------------------------------
@ -102,10 +102,10 @@ void AtomVecMDPD::data_atom_post(int ilocal)
return -1 if name is unknown to this atom style
------------------------------------------------------------------------- */
int AtomVecMDPD::property_atom(char *name)
int AtomVecMDPD::property_atom(const std::string &name)
{
if (strcmp(name,"rho") == 0) return 0;
if (strcmp(name,"drho") == 0) return 1;
if (name == "rho") return 0;
if (name == "drho") return 1;
return -1;
}
@ -114,8 +114,7 @@ int AtomVecMDPD::property_atom(char *name)
index maps to data specific to this atom style
------------------------------------------------------------------------- */
void AtomVecMDPD::pack_property_atom(int index, double *buf,
int nvalues, int groupbit)
void AtomVecMDPD::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
{
int *mask = atom->mask;
int nlocal = atom->nlocal;
@ -123,14 +122,18 @@ void AtomVecMDPD::pack_property_atom(int index, double *buf,
int n = 0;
if (index == 0) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = rho[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = rho[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 1) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = drho[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = drho[i];
else
buf[n] = 0.0;
n += nvalues;
}
}

2
src/DPD-MESO/atom_vec_mdpd.h
View File

@ -32,7 +32,7 @@ class AtomVecMDPD : public AtomVec {
void grow_pointers() override;
void force_clear(int, size_t) override;
void data_atom_post(int) override;
int property_atom(char *) override;
int property_atom(const std::string &) override;
void pack_property_atom(int, double *, int, int) override;
private:

48
src/DPD-MESO/atom_vec_tdpd.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -13,11 +12,12 @@
------------------------------------------------------------------------- */
#include "atom_vec_tdpd.h"
#include <cstring>
#include "atom.h"
#include "update.h"
#include "error.h"
#include "atom.h"
#include "error.h"
#include "update.h"
#include <cstring>
using namespace LAMMPS_NS;
@ -37,18 +37,18 @@ AtomVecTDPD::AtomVecTDPD(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "cc cc_flux vest";
fields_copy = (char *) "cc vest";
fields_comm = (char *) "cc vest";
fields_comm_vel = (char *) "cc vest";
fields_reverse = (char *) "cc_flux";
fields_border = (char *) "cc vest";
fields_border_vel = (char *) "cc vest";
fields_exchange = (char *) "cc vest";
fields_restart = (char * ) "cc vest";
fields_create = (char *) "cc vest";
fields_data_atom = (char *) "id type x cc";
fields_data_vel = (char *) "id v";
fields_grow = {"cc", "cc_flux", "vest"};
fields_copy = {"cc", "vest"};
fields_comm = {"cc", "vest"};
fields_comm_vel = {"cc", "vest"};
fields_reverse = {"cc_flux"};
fields_border = {"cc", "vest"};
fields_border_vel = {"cc", "vest"};
fields_exchange = {"cc", "vest"};
fields_restart = {"cc", "vest"};
fields_create = {"cc", "vest"};
fields_data_atom = {"id", "type", "x", "cc"};
fields_data_vel = {"id", "v"};
}
/* ----------------------------------------------------------------------
@ -58,13 +58,13 @@ AtomVecTDPD::AtomVecTDPD(LAMMPS *lmp) : AtomVec(lmp)
void AtomVecTDPD::process_args(int narg, char **arg)
{
if (narg < 1) error->all(FLERR,"Invalid atom_style tdpd command");
if (narg < 1) error->all(FLERR, "Invalid atom_style tdpd command");
atom->cc_species = utils::inumeric(FLERR,arg[0],false,lmp);
atom->cc_species = utils::inumeric(FLERR, arg[0], false, lmp);
cc_species = atom->cc_species;
atom->add_peratom_change_columns("cc",cc_species);
atom->add_peratom_change_columns("cc_flux",cc_species);
atom->add_peratom_change_columns("cc", cc_species);
atom->add_peratom_change_columns("cc_flux", cc_species);
// delay setting up of fields until now
@ -77,8 +77,7 @@ void AtomVecTDPD::init()
{
AtomVec::init();
if (strcmp(update->unit_style,"lj") != 0)
error->all(FLERR,"Atom style tdpd requires lj units");
if (strcmp(update->unit_style, "lj") != 0) error->all(FLERR, "Atom style tdpd requires lj units");
}
/* ----------------------------------------------------------------------
@ -92,7 +91,6 @@ void AtomVecTDPD::grow_pointers()
vest = atom->vest;
}
/* ----------------------------------------------------------------------
clear extra forces starting at atom N
nbytes = # of bytes to clear for a per-atom vector
@ -100,7 +98,7 @@ void AtomVecTDPD::grow_pointers()
void AtomVecTDPD::force_clear(int n, size_t nbytes)
{
memset(&cc_flux[n][0],0,cc_species*nbytes);
memset(&cc_flux[n][0], 0, cc_species * nbytes);
}
/* ----------------------------------------------------------------------

29
src/DPD-REACT/atom_vec_dpd.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -17,6 +16,7 @@
------------------------------------------------------------------------- */
#include "atom_vec_dpd.h"
#include "atom.h"
#include "error.h"
@ -37,18 +37,18 @@ AtomVecDPD::AtomVecDPD(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rho dpdTheta uCond uMech uChem uCG uCGnew duChem";
fields_copy = (char *) "dpdTheta uCond uMech uChem uCG uCGnew";
fields_comm = (char *) "dpdTheta uCond uMech uChem";
fields_comm_vel = (char *) "dpdTheta uCond uMech uChem";
fields_reverse = (char *) "";
fields_border = (char *) "dpdTheta uCond uMech uChem uCG uCGnew";
fields_border_vel = (char *) "dpdTheta uCond uMech uChem uCG uCGnew";
fields_exchange = (char *) "dpdTheta uCond uMech uChem uCG uCGnew";
fields_restart = (char *) "dpdTheta uCond uMech uChem";
fields_create = (char *) "rho dpdTheta uCond uMech uChem uCG uCGnew duChem";
fields_data_atom = (char *) "id type dpdTheta x";
fields_data_vel = (char *) "id v";
fields_grow = {"rho", "dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew", "duChem"};
fields_copy = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"};
fields_comm = {"dpdTheta", "uCond", "uMech", "uChem"};
fields_comm_vel = {"dpdTheta", "uCond", "uMech", "uChem"};
fields_reverse = {};
fields_border = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"};
fields_border_vel = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"};
fields_exchange = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"};
fields_restart = {"dpdTheta", "uCond", "uMech", "uChem"};
fields_create = {"rho", "dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew", "duChem"};
fields_data_atom = {"id", "type", "dpdTheta", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
}
@ -94,6 +94,5 @@ void AtomVecDPD::data_atom_post(int ilocal)
uCGnew[ilocal] = 0.0;
if (dpdTheta[ilocal] <= 0)
error->one(FLERR,"Internal temperature in Atoms section of date file "
"must be > zero");
error->one(FLERR, "Internal temperature in Atoms section of date file must be > zero");
}

72
src/EFF/atom_vec_electron.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -21,15 +20,14 @@
#include "atom.h"
#include "citeme.h"
#include <cstring>
using namespace LAMMPS_NS;
static const char cite_user_eff_package[] =
"EFF package:\n\n"
"@Article{Jaramillo-Botero11,\n"
" author = {A. Jaramillo-Botero, J. Su, A. Qi, W. A. Goddard III},\n"
" title = {Large-Scale, Long-Term Nonadiabatic Electron Molecular Dynamics for Describing Material Properties and Phenomena in Extreme Environments},\n"
" title = {Large-Scale, Long-Term Nonadiabatic Electron Molecular Dynamics for Describing "
"Material Properties and Phenomena in Extreme Environments},\n"
" journal = {J.~Comp.~Chem.},\n"
" year = 2011,\n"
" volume = 32,\n"
@ -47,26 +45,25 @@ AtomVecElectron::AtomVecElectron(LAMMPS *lmp) : AtomVec(lmp)
forceclearflag = 1;
atom->electron_flag = 1;
atom->q_flag = atom->spin_flag = atom->eradius_flag =
atom->ervel_flag = atom->erforce_flag = 1;
atom->q_flag = atom->spin_flag = atom->eradius_flag = atom->ervel_flag = atom->erforce_flag = 1;
// strings with peratom variables to include in each AtomVec method
// strings cannot contain fields in corresponding AtomVec default strings
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "q spin eradius ervel erforce";
fields_copy = (char *) "q spin eradius ervel";
fields_comm = (char *) "eradius";
fields_comm_vel = (char *) "eradius";
fields_reverse = (char *) "erforce";
fields_border = (char *) "q spin eradius";
fields_border_vel = (char *) "q spin eradius";
fields_exchange = (char *) "q spin eradius ervel";
fields_restart = (char *) "q spin eradius ervel";
fields_create = (char *) "q spin eradius ervel";
fields_data_atom = (char *) "id type q spin eradius x";
fields_data_vel = (char *) "id v ervel";
fields_grow = {"q", "spin", "eradius", "ervel", "erforce"};
fields_copy = {"q", "spin", "eradius", "ervel"};
fields_comm = {"eradius"};
fields_comm_vel = {"eradius"};
fields_reverse = {"erforce"};
fields_border = {"q", "spin", "eradius"};
fields_border_vel = {"q", "spin", "eradius"};
fields_exchange = {"q", "spin", "eradius", "ervel"};
fields_restart = {"q", "spin", "eradius", "ervel"};
fields_create = {"q", "spin", "eradius", "ervel"};
fields_data_atom = {"id", "type", "q", "spin", "eradius", "x"};
fields_data_vel = {"id", "v", "ervel"};
setup_fields();
}
@ -91,7 +88,7 @@ void AtomVecElectron::grow_pointers()
void AtomVecElectron::force_clear(int n, size_t nbytes)
{
memset(&erforce[n],0,nbytes);
memset(&erforce[n], 0, nbytes);
}
/* ----------------------------------------------------------------------
@ -119,12 +116,12 @@ void AtomVecElectron::data_atom_post(int ilocal)
return -1 if name is unknown to this atom style
------------------------------------------------------------------------- */
int AtomVecElectron::property_atom(char *name)
int AtomVecElectron::property_atom(const std::string &name)
{
if (strcmp(name,"spin") == 0) return 0;
if (strcmp(name,"eradius") == 0) return 1;
if (strcmp(name,"ervel") == 0) return 2;
if (strcmp(name,"erforce") == 0) return 3;
if (name == "spin") return 0;
if (name == "eradius") return 1;
if (name == "ervel") return 2;
if (name == "erforce") return 3;
return -1;
}
@ -133,8 +130,7 @@ int AtomVecElectron::property_atom(char *name)
index maps to data specific to this atom style
------------------------------------------------------------------------- */
void AtomVecElectron::pack_property_atom(int index, double *buf,
int nvalues, int groupbit)
void AtomVecElectron::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
{
int *mask = atom->mask;
int nlocal = atom->nlocal;
@ -142,26 +138,34 @@ void AtomVecElectron::pack_property_atom(int index, double *buf,
if (index == 0) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = spin[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = spin[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 1) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = eradius[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = eradius[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 2) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = ervel[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = ervel[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 3) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = erforce[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = erforce[i];
else
buf[n] = 0.0;
n += nvalues;
}
}

2
src/EFF/atom_vec_electron.h
View File

@ -32,7 +32,7 @@ class AtomVecElectron : public AtomVec {
void force_clear(int, size_t) override;
void create_atom_post(int) override;
void data_atom_post(int) override;
int property_atom(char *) override;
int property_atom(const std::string &) override;
void pack_property_atom(int, double *, int, int) override;
private:

17
src/KOKKOS/atom_vec_hybrid_kokkos.cpp
View File

@ -1073,17 +1073,14 @@ void AtomVecHybridKokkos::write_data(FILE *fp, int n, double **buf)
int k,m;
for (int i = 0; i < n; i++) {
fprintf(fp,TAGINT_FORMAT " %d %-1.16e %-1.16e %-1.16e",
(tagint) ubuf(buf[i][0]).i,(int) ubuf(buf[i][1]).i,
buf[i][2],buf[i][3],buf[i][4]);
fmt::print(fp,"{} {} {:.16e} {:.16e} {:.16e}", ubuf(buf[i][0]).i, ubuf(buf[i][1]).i,
buf[i][2], buf[i][3], buf[i][4]);
m = 5;
for (k = 0; k < nstyles; k++)
m += styles[k]->write_data_hybrid(fp,&buf[i][m]);
fprintf(fp," %d %d %d\n",
(int) ubuf(buf[i][m]).i,(int) ubuf(buf[i][m+1]).i,
(int) ubuf(buf[i][m+2]).i);
fmt::print(fp," {} {} {}\n", ubuf(buf[i][m]).i, ubuf(buf[i][m+1]).i, ubuf(buf[i][m+2]).i);
}
}
@ -1119,8 +1116,7 @@ void AtomVecHybridKokkos::write_vel(FILE *fp, int n, double **buf)
int k,m;
for (int i = 0; i < n; i++) {
fprintf(fp,TAGINT_FORMAT " %g %g %g",
(tagint) ubuf(buf[i][0]).i,buf[i][1],buf[i][2],buf[i][3]);
fmt::print(fp,"{} {} {} {}", (tagint) ubuf(buf[i][0]).i,buf[i][1],buf[i][2],buf[i][3]);
m = 4;
for (k = 0; k < nstyles; k++)
@ -1136,7 +1132,7 @@ void AtomVecHybridKokkos::write_vel(FILE *fp, int n, double **buf)
return -1 if name is unknown to any sub-styles
------------------------------------------------------------------------- */
int AtomVecHybridKokkos::property_atom(char *name)
int AtomVecHybridKokkos::property_atom(const std::string &name)
{
for (int k = 0; k < nstyles; k++) {
int index = styles[k]->property_atom(name);
@ -1150,8 +1146,7 @@ int AtomVecHybridKokkos::property_atom(char *name)
index maps to data specific to this atom style
------------------------------------------------------------------------- */
void AtomVecHybridKokkos::pack_property_atom(int multiindex, double *buf,
int nvalues, int groupbit)
void AtomVecHybridKokkos::pack_property_atom(int multiindex, double *buf, int nvalues, int groupbit)
{
int k = multiindex % nstyles;
int index = multiindex/nstyles;

2
src/KOKKOS/atom_vec_hybrid_kokkos.h
View File

@ -64,7 +64,7 @@ class AtomVecHybridKokkos : public AtomVecKokkos {
void write_data(FILE *, int, double **) override;
void pack_vel(double **) override;
void write_vel(FILE *, int, double **) override;
int property_atom(char *) override;
int property_atom(const std::string &) override;
void pack_property_atom(int, double *, int, int) override;
double memory_usage() override;

68
src/MACHDYN/atom_vec_smd.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
*
* *** Smooth Mach Dynamics ***
@ -27,8 +26,6 @@
#include "atom.h"
#include <cstring>
using namespace LAMMPS_NS;
#define NMAT_FULL 9
@ -63,42 +60,33 @@ AtomVecSMD::AtomVecSMD(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *)
"esph desph vfrac rmass x0 radius contact_radius molecule "
"smd_data_9 vest smd_stress "
"eff_plastic_strain eff_plastic_strain_rate damage";
fields_copy = (char *)
"esph vfrac rmass x0 radius contact_radius molecule "
"eff_plastic_strain eff_plastic_strain_rate vest "
"smd_data_9 smd_stress damage";
fields_comm = (char *) "radius vfrac vest esph";
fields_comm_vel = (char *) "radius vfrac vest esph";
fields_reverse = (char *) "desph";
fields_border = (char *)
"x0 molecule radius rmass vfrac contact_radius esph "
"eff_plastic_strain smd_data_9 smd_stress";
fields_border_vel = (char *)
"x0 molecule radius rmass vfrac contact_radius esph "
"eff_plastic_strain smd_data_9 smd_stress vest";
fields_exchange = (char *)
"x0 molecule radius rmass vfrac contact_radius esph "
"eff_plastic_strain eff_plastic_strain_rate smd_data_9 smd_stress "
"vest damage";
fields_restart = (char *)
"x0 molecule radius rmass vfrac contact_radius esph "
"eff_plastic_strain eff_plastic_strain_rate smd_data_9 smd_stress "
"vest damage";
fields_create = (char *)
"x0 vest vfrac rmass radius contact_radius molecule esph "
"eff_plastic_strain eff_plastic_strain_rate smd_data_9 smd_stress damage";
fields_data_atom = (char *)
"id type molecule vfrac rmass radius contact_radius x0 x";
fields_data_vel = (char *) "id v";
// clang-format off
fields_grow = {"esph", "desph", "vfrac", "rmass", "x0", "radius", "contact_radius", "molecule",
"smd_data_9", "vest", "smd_stress", "eff_plastic_strain", "eff_plastic_strain_rate", "damage"};
fields_copy = {"esph", "vfrac", "rmass", "x0", "radius", "contact_radius", "molecule",
"eff_plastic_strain", "eff_plastic_strain_rate", "vest", "smd_data_9", "smd_stress", "damage"};
fields_comm = {"radius", "vfrac", "vest", "esph"};
fields_comm_vel = {"radius", "vfrac", "vest", "esph"};
fields_reverse = {"desph"};
fields_border = {"x0", "molecule", "radius", "rmass", "vfrac", "contact_radius", "esph",
"eff_plastic_strain", "smd_data_9", "smd_stress"};
fields_border_vel = {"x0", "molecule", "radius", "rmass", "vfrac", "contact_radius", "esph",
"eff_plastic_strain", "smd_data_9", "smd_stress", "vest"};
fields_exchange = {"x0", "molecule", "radius", "rmass", "vfrac", "contact_radius", "esph",
"eff_plastic_strain", "eff_plastic_strain_rate", "smd_data_9", "smd_stress", "vest", "damage"};
fields_restart ={"x0", "molecule", "radius", "rmass", "vfrac", "contact_radius", "esph",
"eff_plastic_strain", "eff_plastic_strain_rate", "smd_data_9", "smd_stress", "vest", "damage"};
fields_create = {"x0", "vest", "vfrac", "rmass", "radius", "contact_radius", "molecule",
"esph", "eff_plastic_strain", "eff_plastic_strain_rate", "smd_data_9", "smd_stress", "damage"};
fields_data_atom = {"id", "type", "molecule", "vfrac", "rmass", "radius", "contact_radius",
"x0", "x"};
fields_data_vel = {"id", "v"};
// clang-format on
// set these array sizes based on defines
atom->add_peratom_change_columns("smd_data_9",NMAT_FULL);
atom->add_peratom_change_columns("smd_stress",NMAT_SYMM);
atom->add_peratom_change_columns("smd_data_9", NMAT_FULL);
atom->add_peratom_change_columns("smd_stress", NMAT_SYMM);
setup_fields();
}
@ -134,7 +122,7 @@ void AtomVecSMD::grow_pointers()
void AtomVecSMD::force_clear(int n, size_t nbytes)
{
memset(&desph[n],0,nbytes);
memset(&desph[n], 0, nbytes);
}
/* ----------------------------------------------------------------------
@ -179,11 +167,9 @@ void AtomVecSMD::data_atom_post(int ilocal)
eff_plastic_strain[ilocal] = 0.0;
eff_plastic_strain_rate[ilocal] = 0.0;
for (int k = 0; k < NMAT_FULL; k++)
smd_data_9[ilocal][k] = 0.0;
for (int k = 0; k < NMAT_FULL; k++) smd_data_9[ilocal][k] = 0.0;
for (int k = 0; k < NMAT_SYMM; k++)
smd_stress[ilocal][k] = 0.0;
for (int k = 0; k < NMAT_SYMM; k++) smd_stress[ilocal][k] = 0.0;
smd_data_9[ilocal][0] = 1.0; // xx
smd_data_9[ilocal][4] = 1.0; // yy

26
src/MESONT/atom_vec_mesont.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -33,18 +32,19 @@ AtomVecMesoNT::AtomVecMesoNT(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rmass radius length buckling bond_nt molecule";
fields_copy = (char *) "rmass radius length buckling bond_nt molecule";
fields_comm = (char *) "";
fields_comm_vel = (char *) "";
fields_reverse = (char *) "";
fields_border = (char *) "rmass radius length buckling bond_nt molecule";
fields_border_vel = (char *) "rmass radius length buckling bond_nt molecule";
fields_exchange = (char *) "rmass radius length buckling bond_nt molecule";
fields_restart = (char *) "rmass radius length buckling bond_nt molecule";
fields_create = (char *) "rmass radius length buckling bond_nt molecule";
fields_data_atom = (char *) "id molecule type bond_nt rmass radius length buckling x";
fields_data_vel = (char *) "id v";
fields_grow = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_copy = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_comm = {};
fields_comm_vel = {};
fields_reverse = {};
fields_border = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_border_vel = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_exchange = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_restart = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_create = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_data_atom = {"id", "molecule", "type", "bond_nt", "rmass",
"radius", "length", "buckling", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
}

54
src/MOLECULE/atom_vec_angle.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -32,26 +31,25 @@ AtomVecAngle::AtomVecAngle(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *)
"molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 nspecial special";
fields_copy = (char *)
"molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 nspecial special";
fields_comm = (char *) "";
fields_comm_vel = (char *) "";
fields_reverse = (char *) "";
fields_border = (char *) "molecule";
fields_border_vel = (char *) "molecule";
fields_exchange = (char *)
"molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 nspecial special";
fields_restart = (char *)
"molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3";
fields_create = (char *) "molecule num_bond num_angle nspecial";
fields_data_atom = (char *) "id molecule type x";
fields_data_vel = (char *) "id v";
fields_grow = {"molecule", "num_bond", "bond_type", "bond_atom",
"num_angle", "angle_type", "angle_atom1", "angle_atom2",
"angle_atom3", "nspecial", "special"};
fields_copy = {"molecule", "num_bond", "bond_type", "bond_atom",
"num_angle", "angle_type", "angle_atom1", "angle_atom2",
"angle_atom3", "nspecial", "special"};
fields_comm = {};
fields_comm_vel = {};
fields_reverse = {};
fields_border = {"molecule"};
fields_border_vel = {"molecule"};
fields_exchange = {"molecule", "num_bond", "bond_type", "bond_atom",
"num_angle", "angle_type", "angle_atom1", "angle_atom2",
"angle_atom3", "nspecial", "special"};
fields_restart = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle",
"angle_type", "angle_atom1", "angle_atom2", "angle_atom3"};
fields_create = {"molecule", "num_bond", "num_angle", "nspecial"};
fields_data_atom = {"id", "molecule", "type", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
@ -63,8 +61,8 @@ AtomVecAngle::AtomVecAngle(LAMMPS *lmp) : AtomVec(lmp)
AtomVecAngle::~AtomVecAngle()
{
delete [] bond_negative;
delete [] angle_negative;
delete[] bond_negative;
delete[] angle_negative;
}
/* ----------------------------------------------------------------------
@ -90,12 +88,12 @@ void AtomVecAngle::pack_restart_pre(int ilocal)
// insure negative vectors are needed length
if (bond_per_atom < atom->bond_per_atom) {
delete [] bond_negative;
delete[] bond_negative;
bond_per_atom = atom->bond_per_atom;
bond_negative = new int[bond_per_atom];
}
if (angle_per_atom < atom->angle_per_atom) {
delete [] angle_negative;
delete[] angle_negative;
angle_per_atom = atom->angle_per_atom;
angle_negative = new int[angle_per_atom];
}
@ -108,7 +106,8 @@ void AtomVecAngle::pack_restart_pre(int ilocal)
bond_negative[m] = 1;
bond_type[ilocal][m] = -bond_type[ilocal][m];
any_bond_negative = 1;
} else bond_negative[m] = 0;
} else
bond_negative[m] = 0;
}
any_angle_negative = 0;
@ -117,7 +116,8 @@ void AtomVecAngle::pack_restart_pre(int ilocal)
angle_negative[m] = 1;
angle_type[ilocal][m] = -angle_type[ilocal][m];
any_angle_negative = 1;
} else angle_negative[m] = 0;
} else
angle_negative[m] = 0;
}
}

35
src/MOLECULE/atom_vec_bond.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -32,21 +31,18 @@ AtomVecBond::AtomVecBond(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *)
"molecule num_bond bond_type bond_atom nspecial special";
fields_copy = (char *)
"molecule num_bond bond_type bond_atom nspecial special";
fields_comm = (char *) "";
fields_comm_vel = (char *) "";
fields_reverse = (char *) "";
fields_border = (char *) "molecule";
fields_border_vel = (char *) "molecule";
fields_exchange = (char *)
"molecule num_bond bond_type bond_atom nspecial special";
fields_restart = (char *) "molecule num_bond bond_type bond_atom";
fields_create = (char *) "molecule num_bond nspecial";
fields_data_atom = (char *) "id molecule type x";
fields_data_vel = (char *) "id v";
fields_grow = {"molecule", "num_bond", "bond_type", "bond_atom", "nspecial", "special"};
fields_copy = {"molecule", "num_bond", "bond_type", "bond_atom", "nspecial", "special"};
fields_comm = {};
fields_comm_vel = {};
fields_reverse = {};
fields_border = {"molecule"};
fields_border_vel = {"molecule"};
fields_exchange = {"molecule", "num_bond", "bond_type", "bond_atom", "nspecial", "special"};
fields_restart = {"molecule", "num_bond", "bond_type", "bond_atom"};
fields_create = {"molecule", "num_bond", "nspecial"};
fields_data_atom = {"id", "molecule", "type", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
@ -58,7 +54,7 @@ AtomVecBond::AtomVecBond(LAMMPS *lmp) : AtomVec(lmp)
AtomVecBond::~AtomVecBond()
{
delete [] bond_negative;
delete[] bond_negative;
}
/* ----------------------------------------------------------------------
@ -82,7 +78,7 @@ void AtomVecBond::pack_restart_pre(int ilocal)
// insure bond_negative vector is needed length
if (bond_per_atom < atom->bond_per_atom) {
delete [] bond_negative;
delete[] bond_negative;
bond_per_atom = atom->bond_per_atom;
bond_negative = new int[bond_per_atom];
}
@ -95,7 +91,8 @@ void AtomVecBond::pack_restart_pre(int ilocal)
bond_negative[m] = 1;
bond_type[ilocal][m] = -bond_type[ilocal][m];
any_bond_negative = 1;
} else bond_negative[m] = 0;
} else
bond_negative[m] = 0;
}
}

104
src/MOLECULE/atom_vec_full.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -32,47 +31,34 @@ AtomVecFull::AtomVecFull(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *)
"q molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4 "
"nspecial special";
fields_copy = (char *)
"q molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4 "
"nspecial special";
fields_comm = (char *) "";
fields_comm_vel = (char *) "";
fields_reverse = (char *) "";
fields_border = (char *) "q molecule";
fields_border_vel = (char *) "q molecule";
fields_exchange = (char *)
"q molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4 "
"nspecial special";
fields_restart = (char *)
"q molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4";
fields_create = (char *)
"q molecule num_bond num_angle num_dihedral num_improper nspecial";
fields_data_atom = (char *) "id molecule type q x";
fields_data_vel = (char *) "id v";
// clang-format off
fields_grow = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
fields_copy = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
fields_comm = {};
fields_comm_vel = {};
fields_reverse = {};
fields_border = {"q", "molecule"};
fields_border_vel = {"q", "molecule"};
fields_exchange = {"q", "molecule", "num_bond", "bond_type", "bond_atom",
"num_angle", "angle_type", "angle_atom1", "angle_atom2", "angle_atom3",
"num_dihedral", "dihedral_type", "dihedral_atom1", "dihedral_atom2",
"dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", "improper_atom1",
"improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
fields_restart = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle",
"angle_type", "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type",
"dihedral_atom1", "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper",
"improper_type", "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4"};
fields_create = {"q", "molecule", "num_bond", "num_angle",
"num_dihedral", "num_improper", "nspecial"};
fields_data_atom = {"id", "molecule", "type", "q", "x"};
fields_data_vel = {"id", "v"};
// clang-format on
setup_fields();
bond_per_atom = angle_per_atom = dihedral_per_atom = improper_per_atom = 0;
@ -83,10 +69,10 @@ AtomVecFull::AtomVecFull(LAMMPS *lmp) : AtomVec(lmp)
AtomVecFull::~AtomVecFull()
{
delete [] bond_negative;
delete [] angle_negative;
delete [] dihedral_negative;
delete [] improper_negative;
delete[] bond_negative;
delete[] angle_negative;
delete[] dihedral_negative;
delete[] improper_negative;
}
/* ----------------------------------------------------------------------
@ -116,22 +102,22 @@ void AtomVecFull::pack_restart_pre(int ilocal)
// insure negative vectors are needed length
if (bond_per_atom < atom->bond_per_atom) {
delete [] bond_negative;
delete[] bond_negative;
bond_per_atom = atom->bond_per_atom;
bond_negative = new int[bond_per_atom];
}
if (angle_per_atom < atom->angle_per_atom) {
delete [] angle_negative;
delete[] angle_negative;
angle_per_atom = atom->angle_per_atom;
angle_negative = new int[angle_per_atom];
}
if (dihedral_per_atom < atom->dihedral_per_atom) {
delete [] dihedral_negative;
delete[] dihedral_negative;
dihedral_per_atom = atom->dihedral_per_atom;
dihedral_negative = new int[dihedral_per_atom];
}
if (improper_per_atom < atom->improper_per_atom) {
delete [] improper_negative;
delete[] improper_negative;
improper_per_atom = atom->improper_per_atom;
improper_negative = new int[improper_per_atom];
}
@ -144,7 +130,8 @@ void AtomVecFull::pack_restart_pre(int ilocal)
bond_negative[m] = 1;
bond_type[ilocal][m] = -bond_type[ilocal][m];
any_bond_negative = 1;
} else bond_negative[m] = 0;
} else
bond_negative[m] = 0;
}
any_angle_negative = 0;
@ -153,7 +140,8 @@ void AtomVecFull::pack_restart_pre(int ilocal)
angle_negative[m] = 1;
angle_type[ilocal][m] = -angle_type[ilocal][m];
any_angle_negative = 1;
} else angle_negative[m] = 0;
} else
angle_negative[m] = 0;
}
any_dihedral_negative = 0;
@ -162,7 +150,8 @@ void AtomVecFull::pack_restart_pre(int ilocal)
dihedral_negative[m] = 1;
dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
any_dihedral_negative = 1;
} else dihedral_negative[m] = 0;
} else
dihedral_negative[m] = 0;
}
any_improper_negative = 0;
@ -171,7 +160,8 @@ void AtomVecFull::pack_restart_pre(int ilocal)
improper_negative[m] = 1;
improper_type[ilocal][m] = -improper_type[ilocal][m];
any_improper_negative = 1;
} else improper_negative[m] = 0;
} else
improper_negative[m] = 0;
}
}
@ -195,14 +185,12 @@ void AtomVecFull::pack_restart_post(int ilocal)
if (any_dihedral_negative) {
for (int m = 0; m < num_dihedral[ilocal]; m++)
if (dihedral_negative[m])
dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
if (dihedral_negative[m]) dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
}
if (any_improper_negative) {
for (int m = 0; m < num_improper[ilocal]; m++)
if (improper_negative[m])
improper_type[ilocal][m] = -improper_type[ilocal][m];
if (improper_negative[m]) improper_type[ilocal][m] = -improper_type[ilocal][m];
}
}

101
src/MOLECULE/atom_vec_molecular.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -32,46 +31,32 @@ AtomVecMolecular::AtomVecMolecular(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *)
"molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4 "
"nspecial special";
fields_copy = (char *)
"molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4 "
"nspecial special";
fields_comm = (char *) "";
fields_comm_vel = (char *) "";
fields_reverse = (char *) "";
fields_border = (char *) "molecule";
fields_border_vel = (char *) "molecule";
fields_exchange = (char *)
"molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4 "
"nspecial special";
fields_restart = (char *)
"molecule num_bond bond_type bond_atom "
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 "
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 "
"dihedral_atom3 dihedral_atom4 "
"num_improper improper_type improper_atom1 improper_atom2 "
"improper_atom3 improper_atom4";
fields_create = (char *)
"molecule num_bond num_angle num_dihedral num_improper nspecial";
fields_data_atom = (char *) "id molecule type x";
fields_data_vel = (char *) "id v";
// clang-format off
fields_grow = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
fields_copy = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
fields_comm = {};
fields_comm_vel = {};
fields_reverse = {};
fields_border = {"molecule"};
fields_border_vel = {"molecule"};
fields_exchange = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
fields_restart = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4"};
fields_create = {"molecule", "num_bond", "num_angle", "num_dihedral", "num_improper", "nspecial"};
fields_data_atom = {"id", "molecule", "type", "x"};
fields_data_vel = {"id", "v"};
// clang-format on
setup_fields();
@ -83,10 +68,10 @@ AtomVecMolecular::AtomVecMolecular(LAMMPS *lmp) : AtomVec(lmp)
AtomVecMolecular::~AtomVecMolecular()
{
delete [] bond_negative;
delete [] angle_negative;
delete [] dihedral_negative;
delete [] improper_negative;
delete[] bond_negative;
delete[] angle_negative;
delete[] dihedral_negative;
delete[] improper_negative;
}
/* ----------------------------------------------------------------------
@ -116,22 +101,22 @@ void AtomVecMolecular::pack_restart_pre(int ilocal)
// insure negative vectors are needed length
if (bond_per_atom < atom->bond_per_atom) {
delete [] bond_negative;
delete[] bond_negative;
bond_per_atom = atom->bond_per_atom;
bond_negative = new int[bond_per_atom];
}
if (angle_per_atom < atom->angle_per_atom) {
delete [] angle_negative;
delete[] angle_negative;
angle_per_atom = atom->angle_per_atom;
angle_negative = new int[angle_per_atom];
}
if (dihedral_per_atom < atom->dihedral_per_atom) {
delete [] dihedral_negative;
delete[] dihedral_negative;
dihedral_per_atom = atom->dihedral_per_atom;
dihedral_negative = new int[dihedral_per_atom];
}
if (improper_per_atom < atom->improper_per_atom) {
delete [] improper_negative;
delete[] improper_negative;
improper_per_atom = atom->improper_per_atom;
improper_negative = new int[improper_per_atom];
}
@ -144,7 +129,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal)
bond_negative[m] = 1;
bond_type[ilocal][m] = -bond_type[ilocal][m];
any_bond_negative = 1;
} else bond_negative[m] = 0;
} else
bond_negative[m] = 0;
}
any_angle_negative = 0;
@ -153,7 +139,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal)
angle_negative[m] = 1;
angle_type[ilocal][m] = -angle_type[ilocal][m];
any_angle_negative = 1;
} else angle_negative[m] = 0;
} else
angle_negative[m] = 0;
}
any_dihedral_negative = 0;
@ -162,7 +149,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal)
dihedral_negative[m] = 1;
dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
any_dihedral_negative = 1;
} else dihedral_negative[m] = 0;
} else
dihedral_negative[m] = 0;
}
any_improper_negative = 0;
@ -171,7 +159,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal)
improper_negative[m] = 1;
improper_type[ilocal][m] = -improper_type[ilocal][m];
any_improper_negative = 1;
} else improper_negative[m] = 0;
} else
improper_negative[m] = 0;
}
}
@ -195,14 +184,12 @@ void AtomVecMolecular::pack_restart_post(int ilocal)
if (any_dihedral_negative) {
for (int m = 0; m < num_dihedral[ilocal]; m++)
if (dihedral_negative[m])
dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
if (dihedral_negative[m]) dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
}
if (any_improper_negative) {
for (int m = 0; m < num_improper[ilocal]; m++)
if (improper_negative[m])
improper_type[ilocal][m] = -improper_type[ilocal][m];
if (improper_negative[m]) improper_type[ilocal][m] = -improper_type[ilocal][m];
}
}

43
src/MOLECULE/atom_vec_template.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -36,18 +35,18 @@ AtomVecTemplate::AtomVecTemplate(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in the string does not matter
// except fields_data_atom and fields_data_vel which must match data file
fields_grow = (char *) "molecule molindex molatom";
fields_copy = (char *) "molecule molindex molatom";
fields_comm = (char *) "";
fields_comm_vel = (char *) "";
fields_reverse = (char *) "";
fields_border = (char *) "molecule molindex molatom";
fields_border_vel = (char *) "molecule molindex molatom";
fields_exchange = (char *) "molecule molindex molatom";
fields_restart = (char *) "molecule molindex molatom";
fields_create = (char *) "molecule molindex molatom";
fields_data_atom = (char *) "id molecule molindex molatom type x";
fields_data_vel = (char *) "id v";
fields_grow = {"molecule", "molindex", "molatom"};
fields_copy = {"molecule", "molindex", "molatom"};
fields_comm = {};
fields_comm_vel = {};
fields_reverse = {};
fields_border = {"molecule", "molindex", "molatom"};
fields_border_vel = {"molecule", "molindex", "molatom"};
fields_exchange = {"molecule", "molindex", "molatom"};
fields_restart = {"molecule", "molindex", "molatom"};
fields_create = {"molecule", "molindex", "molatom"};
fields_data_atom = {"id", "molecule", "molindex", "molatom", "type", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
}
@ -58,11 +57,10 @@ AtomVecTemplate::AtomVecTemplate(LAMMPS *lmp) : AtomVec(lmp)
void AtomVecTemplate::process_args(int narg, char **arg)
{
if (narg != 1) error->all(FLERR,"Illegal atom_style template command");
if (narg != 1) error->all(FLERR, "Illegal atom_style template command");
int imol = atom->find_molecule(arg[0]);
if (imol == -1) error->all(FLERR,"Molecule template ID for "
"atom_style template does not exist");
if (imol == -1) error->all(FLERR, "Molecule template ID for atom_style template does not exist");
onemols = &atom->molecules[imol];
nset = atom->molecules[imol]->nset;
@ -81,10 +79,10 @@ void AtomVecTemplate::process_args(int narg, char **arg)
// do this here b/c data file will typically not contain these settings
for (int i = 0; i < nset; i++) {
atom->nbondtypes = MAX(atom->nbondtypes,onemols[i]->nbondtypes);
atom->nangletypes = MAX(atom->nangletypes,onemols[i]->nangletypes);
atom->ndihedraltypes = MAX(atom->ndihedraltypes,onemols[i]->ndihedraltypes);
atom->nimpropertypes = MAX(atom->nimpropertypes,onemols[i]->nimpropertypes);
atom->nbondtypes = MAX(atom->nbondtypes, onemols[i]->nbondtypes);
atom->nangletypes = MAX(atom->nangletypes, onemols[i]->nangletypes);
atom->ndihedraltypes = MAX(atom->ndihedraltypes, onemols[i]->ndihedraltypes);
atom->nimpropertypes = MAX(atom->nimpropertypes, onemols[i]->nimpropertypes);
}
}
@ -129,7 +127,6 @@ void AtomVecTemplate::pack_data_post(int ilocal)
molatom[ilocal]--;
}
/* ----------------------------------------------------------------------
modify what AtomVec::data_atom() just unpacked
or initialize other atom quantities
@ -141,7 +138,7 @@ void AtomVecTemplate::data_atom_post(int ilocal)
int molatom_one = --molatom[ilocal];
if ((molindex_one < -1) || (molindex_one >= nset))
error->one(FLERR,"Invalid template index in Atoms section of data file");
error->one(FLERR, "Invalid template index in Atoms section of data file");
if ((molatom_one < -1) || ((molindex_one >= 0) && (molatom_one >= onemols[molindex_one]->natoms)))
error->one(FLERR,"Invalid template atom in Atoms section of data file");
error->one(FLERR, "Invalid template atom in Atoms section of data file");
}

50
src/PERI/atom_vec_peri.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -23,7 +22,6 @@
#include "error.h"
#include <cfloat>
#include <cstring>
using namespace LAMMPS_NS;
@ -55,18 +53,18 @@ AtomVecPeri::AtomVecPeri(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rmass vfrac s0 x0";
fields_copy = (char *) "rmass vfrac s0 x0";
fields_comm = (char *) "s0";
fields_comm_vel = (char *) "s0";
fields_reverse = (char *) "";
fields_border = (char *) "rmass vfrac s0 x0";
fields_border_vel = (char *) "rmass vfrac s0 x0";
fields_exchange = (char *) "rmass vfrac s0 x0";
fields_restart = (char *) "rmass vfrac s0 x0";
fields_create = (char *) "rmass vfrac s0 x0";
fields_data_atom = (char *) "id type vfrac rmass x";
fields_data_vel = (char *) "id v";
fields_grow = {"rmass", "vfrac", "s0", "x0"};
fields_copy = {"rmass", "vfrac", "s0", "x0"};
fields_comm = {"s0"};
fields_comm_vel = {"s0"};
fields_reverse = {};
fields_border = {"rmass", "vfrac", "s0", "x0"};
fields_border_vel = {"rmass", "vfrac", "s0", "x0"};
fields_exchange = {"rmass", "vfrac", "s0", "x0"};
fields_restart = {"rmass", "vfrac", "s0", "x0"};
fields_create = {"rmass", "vfrac", "s0", "x0"};
fields_data_atom = {"id", "type", "vfrac", "rmass", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
}
@ -110,8 +108,7 @@ void AtomVecPeri::data_atom_post(int ilocal)
x0[ilocal][1] = x[ilocal][1];
x0[ilocal][2] = x[ilocal][2];
if (rmass[ilocal] <= 0.0)
error->one(FLERR,"Invalid mass in Atoms section of data file");
if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid mass in Atoms section of data file");
}
/* ----------------------------------------------------------------------
@ -119,10 +116,10 @@ void AtomVecPeri::data_atom_post(int ilocal)
return -1 if name is unknown to this atom style
------------------------------------------------------------------------- */
int AtomVecPeri::property_atom(char *name)
int AtomVecPeri::property_atom(const std::string &name)
{
if (strcmp(name,"vfrac") == 0) return 0;
if (strcmp(name,"s0") == 0) return 1;
if (name == "vfrac") return 0;
if (name == "s0") return 1;
return -1;
}
@ -131,8 +128,7 @@ int AtomVecPeri::property_atom(char *name)
index maps to data specific to this atom style
------------------------------------------------------------------------- */
void AtomVecPeri::pack_property_atom(int index, double *buf,
int nvalues, int groupbit)
void AtomVecPeri::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
{
int *mask = atom->mask;
int nlocal = atom->nlocal;
@ -140,14 +136,18 @@ void AtomVecPeri::pack_property_atom(int index, double *buf,
if (index == 0) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = vfrac[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = vfrac[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 1) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = s0[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = s0[i];
else
buf[n] = 0.0;
n += nvalues;
}
}

2
src/PERI/atom_vec_peri.h
View File

@ -31,7 +31,7 @@ class AtomVecPeri : public AtomVec {
void grow_pointers() override;
void create_atom_post(int) override;
void data_atom_post(int) override;
int property_atom(char *) override;
int property_atom(const std::string &) override;
void pack_property_atom(int, double *, int, int) override;
private:

76
src/SPH/atom_vec_sph.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -16,8 +15,6 @@
#include "atom.h"
#include <cstring>
using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
@ -38,18 +35,18 @@ AtomVecSPH::AtomVecSPH(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rho drho esph desph cv vest";
fields_copy = (char *) "rho drho esph desph cv vest";
fields_comm = (char *) "rho esph vest";
fields_comm_vel = (char *) "rho esph vest";
fields_reverse = (char *) "drho desph";
fields_border = (char *) "rho esph cv vest";
fields_border_vel = (char *) "rho esph cv vest";
fields_exchange = (char *) "rho esph cv vest";
fields_restart = (char * ) "rho esph cv vest";
fields_create = (char *) "rho esph cv vest desph drho";
fields_data_atom = (char *) "id type rho esph cv x";
fields_data_vel = (char *) "id v";
fields_grow = {"rho", "drho", "esph", "desph", "cv", "vest"};
fields_copy = {"rho", "drho", "esph", "desph", "cv", "vest"};
fields_comm = {"rho", "esph", "vest"};
fields_comm_vel = {"rho", "esph", "vest"};
fields_reverse = {"drho", "desph"};
fields_border = {"rho", "esph", "cv", "vest"};
fields_border_vel = {"rho", "esph", "cv", "vest"};
fields_exchange = {"rho", "esph", "cv", "vest"};
fields_restart = {"rho", "esph", "cv", "vest"};
fields_create = {"rho", "esph", "cv", "vest", "desph", "drho"};
fields_data_atom = {"id", "type", "rho", "esph", "cv", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
}
@ -76,8 +73,8 @@ void AtomVecSPH::grow_pointers()
void AtomVecSPH::force_clear(int n, size_t nbytes)
{
memset(&desph[n],0,nbytes);
memset(&drho[n],0,nbytes);
memset(&desph[n], 0, nbytes);
memset(&drho[n], 0, nbytes);
}
/* ----------------------------------------------------------------------
@ -108,13 +105,13 @@ void AtomVecSPH::data_atom_post(int ilocal)
return -1 if name is unknown to this atom style
------------------------------------------------------------------------- */
int AtomVecSPH::property_atom(char *name)
int AtomVecSPH::property_atom(const std::string &name)
{
if (strcmp(name,"rho") == 0) return 0;
if (strcmp(name,"drho") == 0) return 1;
if (strcmp(name,"esph") == 0) return 2;
if (strcmp(name,"desph") == 0) return 3;
if (strcmp(name,"cv") == 0) return 4;
if (name == "rho") return 0;
if (name == "drho") return 1;
if (name == "esph") return 2;
if (name == "desph") return 3;
if (name == "cv") return 4;
return -1;
}
@ -123,8 +120,7 @@ int AtomVecSPH::property_atom(char *name)
index maps to data specific to this atom style
------------------------------------------------------------------------- */
void AtomVecSPH::pack_property_atom(int index, double *buf,
int nvalues, int groupbit)
void AtomVecSPH::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
{
int *mask = atom->mask;
int nlocal = atom->nlocal;
@ -132,32 +128,42 @@ void AtomVecSPH::pack_property_atom(int index, double *buf,
if (index == 0) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = rho[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = rho[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 1) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = drho[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = drho[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 2) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = esph[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = esph[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 3) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = desph[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = desph[i];
else
buf[n] = 0.0;
n += nvalues;
}
} else if (index == 4) {
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = cv[i];
else buf[n] = 0.0;
if (mask[i] & groupbit)
buf[n] = cv[i];
else
buf[n] = 0.0;
n += nvalues;
}
}

2
src/SPH/atom_vec_sph.h
View File

@ -32,7 +32,7 @@ class AtomVecSPH : public AtomVec {
void force_clear(int, size_t) override;
void create_atom_post(int) override;
void data_atom_post(int) override;
int property_atom(char *) override;
int property_atom(const std::string &) override;
void pack_property_atom(int, double *, int, int) override;
private:

37
src/SPIN/atom_vec_spin.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
@ -25,10 +24,11 @@
------------------------------------------------------------------------- */
#include "atom_vec_spin.h"
#include <cmath>
#include <cstring>
#include "atom.h"
#include <cmath>
using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
@ -46,18 +46,18 @@ AtomVecSpin::AtomVecSpin(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "sp fm fm_long";
fields_copy = (char *) "sp";
fields_comm = (char *) "sp";
fields_comm_vel = (char *) "sp";
fields_reverse = (char *) "fm fm_long";
fields_border = (char *) "sp";
fields_border_vel = (char *) "sp";
fields_exchange = (char *) "sp";
fields_restart = (char *) "sp";
fields_create = (char *) "sp";
fields_data_atom = (char *) "id type x sp";
fields_data_vel = (char *) "id v";
fields_grow = {"sp", "fm", "fm_long"};
fields_copy = {"sp"};
fields_comm = {"sp"};
fields_comm_vel = {"sp"};
fields_reverse = {"fm", "fm_long"};
fields_border = {"sp"};
fields_border_vel = {"sp"};
fields_exchange = {"sp"};
fields_restart = {"sp"};
fields_create = {"sp"};
fields_data_atom = {"id", "type", "x", "sp"};
fields_data_vel = {"id", "v"};
setup_fields();
}
@ -82,8 +82,8 @@ void AtomVecSpin::grow_pointers()
void AtomVecSpin::force_clear(int n, size_t nbytes)
{
memset(&fm[n][0],0,3*nbytes);
memset(&fm_long[n][0],0,3*nbytes);
memset(&fm[n][0], 0, 3 * nbytes);
memset(&fm_long[n][0], 0, 3 * nbytes);
}
/* ----------------------------------------------------------------------
@ -94,8 +94,7 @@ void AtomVecSpin::force_clear(int n, size_t nbytes)
void AtomVecSpin::data_atom_post(int ilocal)
{
double *sp_one = sp[ilocal];
double norm =
1.0/sqrt(sp_one[0]*sp_one[0] + sp_one[1]*sp_one[1] + sp_one[2]*sp_one[2]);
double norm = 1.0 / sqrt(sp_one[0] * sp_one[0] + sp_one[1] * sp_one[1] + sp_one[2] * sp_one[2]);
sp_one[0] *= norm;
sp_one[1] *= norm;
sp_one[2] *= norm;

937
src/atom_vec.cpp
View File

File diff suppressed because it is too large Load Diff

22
src/atom_vec.h
View File

@ -59,11 +59,10 @@ class AtomVec : protected Pointers {
// additional list of peratom fields operated on by different methods
// set or created by child styles
char *fields_grow, *fields_copy;
char *fields_comm, *fields_comm_vel, *fields_reverse;
char *fields_border, *fields_border_vel;
char *fields_exchange, *fields_restart;
char *fields_create, *fields_data_atom, *fields_data_vel;
std::vector<std::string> fields_grow, fields_copy, fields_comm, fields_comm_vel;
std::vector<std::string> fields_reverse, fields_border, fields_border_vel;
std::vector<std::string> fields_exchange, fields_restart, fields_create;
std::vector<std::string> fields_data_atom, fields_data_vel;
// methods
@ -152,7 +151,7 @@ class AtomVec : protected Pointers {
virtual int pack_data_bonus(double *, int) { return 0; }
virtual void write_data_bonus(FILE *, int, double *, int) {}
virtual int property_atom(char *) { return -1; }
virtual int property_atom(const std::string &) { return -1; }
virtual void pack_property_atom(int, double *, int, int) {}
virtual double memory_usage();
@ -187,11 +186,10 @@ class AtomVec : protected Pointers {
// standard list of peratom fields always operated on by different methods
// common to all styles, so not listed in field strings
const char *default_grow, *default_copy;
const char *default_comm, *default_comm_vel, *default_reverse;
const char *default_border, *default_border_vel;
const char *default_exchange, *default_restart;
const char *default_create, *default_data_atom, *default_data_vel;
static const std::vector<std::string> default_grow, default_copy, default_comm, default_comm_vel;
static const std::vector<std::string> default_reverse, default_border, default_border_vel;
static const std::vector<std::string> default_exchange, default_restart, default_create;
static const std::vector<std::string> default_data_atom, default_data_vel;
struct Method {
std::vector<void *> pdata;
@ -223,7 +221,7 @@ class AtomVec : protected Pointers {
void grow_nmax();
int grow_nmax_bonus(int);
void setup_fields();
int process_fields(char *, const char *, Method *);
int process_fields(const std::vector<std::string> &, const std::vector<std::string> &, Method *);
void init_method(int, Method *);
};

25
src/atom_vec_atomic.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -30,18 +29,18 @@ AtomVecAtomic::AtomVecAtomic(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "";
fields_copy = (char *) "";
fields_comm = (char *) "";
fields_comm_vel = (char *) "";
fields_reverse = (char *) "";
fields_border = (char *) "";
fields_border_vel = (char *) "";
fields_exchange = (char *) "";
fields_restart = (char *) "";
fields_create = (char *) "";
fields_data_atom = (char *) "id type x";
fields_data_vel = (char *) "id v";
fields_grow = {};
fields_copy = {};
fields_comm = {};
fields_comm_vel = {};
fields_reverse = {};
fields_border = {};
fields_border_vel = {};
fields_exchange = {};
fields_restart = {};
fields_create = {};
fields_data_atom = {"id", "type", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
}

220
src/atom_vec_body.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -23,8 +22,6 @@
#include "modify.h"
#include "my_pool_chunk.h"
#include <cstring>
using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
@ -54,27 +51,30 @@ AtomVecBody::AtomVecBody(LAMMPS *lmp) : AtomVec(lmp)
bptr = nullptr;
if (sizeof(double) == sizeof(int)) intdoubleratio = 1;
else if (sizeof(double) == 2*sizeof(int)) intdoubleratio = 2;
else error->all(FLERR,"Internal error in atom_style body");
if (sizeof(double) == sizeof(int))
intdoubleratio = 1;
else if (sizeof(double) == 2 * sizeof(int))
intdoubleratio = 2;
else
error->all(FLERR, "Internal error in atom_style body");
// strings with peratom variables to include in each AtomVec method
// strings cannot contain fields in corresponding AtomVec default strings
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "radius rmass angmom torque body";
fields_copy = (char *) "radius rmass angmom";
fields_comm = (char *) "";
fields_comm_vel = (char *) "angmom";
fields_reverse = (char *) "torque";
fields_border = (char *) "radius rmass";
fields_border_vel = (char *) "radius rmass angmom";
fields_exchange = (char *) "radius rmass angmom";
fields_restart = (char *) "radius rmass angmom";
fields_create = (char *) "radius rmass angmom body";
fields_data_atom = (char *) "id type body rmass x";
fields_data_vel = (char *) "id v angmom";
fields_grow = {"radius", "rmass", "angmom", "torque", "body"};
fields_copy = {"radius", "rmass", "angmom"};
fields_comm = {};
fields_comm_vel = {"angmom"};
fields_reverse = {"torque"};
fields_border = {"radius", "rmass"};
fields_border_vel = {"radius", "rmass", "angmom"};
fields_exchange = {"radius", "rmass", "angmom"};
fields_restart = {"radius", "rmass", "angmom"};
fields_create = {"radius", "rmass", "angmom", "body"};
fields_data_atom = {"id", "type", "body", "rmass", "x"};
fields_data_vel = {"id", "v", "angmom"};
}
/* ---------------------------------------------------------------------- */
@ -101,23 +101,25 @@ void AtomVecBody::process_args(int narg, char **arg)
{
// suppress unused parameter warning dependent on style_body.h
(void)(arg);
(void) (arg);
if (narg < 1) error->all(FLERR,"Invalid atom_style body command");
if (narg < 1) error->all(FLERR, "Invalid atom_style body command");
if (false) { // NOLINT
bptr = nullptr;
#define BODY_CLASS
#define BodyStyle(key,Class) \
} else if (strcmp(arg[0],#key) == 0) { \
bptr = new Class(lmp,narg,arg);
#define BodyStyle(key, Class) \
} \
else if (strcmp(arg[0], #key) == 0) \
{ \
bptr = new Class(lmp, narg, arg);
#include "style_body.h" // IWYU pragma: keep
#undef BodyStyle
#undef BODY_CLASS
} else error->all(FLERR,utils::
check_packages_for_style("body",arg[0],lmp).c_str());
} else
error->all(FLERR, utils::check_packages_for_style("body", arg[0], lmp).c_str());
bptr->avec = this;
icp = bptr->icp;
@ -153,11 +155,9 @@ void AtomVecBody::grow_pointers()
void AtomVecBody::grow_bonus()
{
nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0)
error->one(FLERR,"Per-processor system is too big");
if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big");
bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus),
"atom:bonus");
bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom:bonus");
}
/* ----------------------------------------------------------------------
@ -173,7 +173,7 @@ void AtomVecBody::copy_bonus(int i, int j, int delflag)
int k = body[j];
icp->put(bonus[k].iindex);
dcp->put(bonus[k].dindex);
copy_bonus_all(nlocal_bonus-1,k);
copy_bonus_all(nlocal_bonus - 1, k);
nlocal_bonus--;
}
@ -192,7 +192,7 @@ void AtomVecBody::copy_bonus(int i, int j, int delflag)
void AtomVecBody::copy_bonus_all(int i, int j)
{
body[bonus[i].ilocal] = j;
memcpy(&bonus[j],&bonus[i],sizeof(Bonus));
memcpy(&bonus[j], &bonus[i], sizeof(Bonus));
}
/* ----------------------------------------------------------------------
@ -218,7 +218,7 @@ void AtomVecBody::clear_bonus()
int AtomVecBody::pack_comm_bonus(int n, int *list, double *buf)
{
int i,j,m;
int i, j, m;
double *quat;
m = 0;
@ -230,7 +230,7 @@ int AtomVecBody::pack_comm_bonus(int n, int *list, double *buf)
buf[m++] = quat[1];
buf[m++] = quat[2];
buf[m++] = quat[3];
m += bptr->pack_comm_body(&bonus[body[j]],&buf[m]);
m += bptr->pack_comm_body(&bonus[body[j]], &buf[m]);
}
}
@ -241,7 +241,7 @@ int AtomVecBody::pack_comm_bonus(int n, int *list, double *buf)
void AtomVecBody::unpack_comm_bonus(int n, int first, double *buf)
{
int i,m,last;
int i, m, last;
double *quat;
m = 0;
@ -253,7 +253,7 @@ void AtomVecBody::unpack_comm_bonus(int n, int first, double *buf)
quat[1] = buf[m++];
quat[2] = buf[m++];
quat[3] = buf[m++];
m += bptr->unpack_comm_body(&bonus[body[i]],&buf[m]);
m += bptr->unpack_comm_body(&bonus[body[i]], &buf[m]);
}
}
}
@ -262,13 +262,14 @@ void AtomVecBody::unpack_comm_bonus(int n, int first, double *buf)
int AtomVecBody::pack_border_bonus(int n, int *list, double *buf)
{
int i,j,m;
double *quat,*inertia;
int i, j, m;
double *quat, *inertia;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
if (body[j] < 0) buf[m++] = ubuf(0).d;
if (body[j] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
quat = bonus[body[j]].quat;
@ -282,7 +283,7 @@ int AtomVecBody::pack_border_bonus(int n, int *list, double *buf)
buf[m++] = inertia[2];
buf[m++] = ubuf(bonus[body[j]].ninteger).d;
buf[m++] = ubuf(bonus[body[j]].ndouble).d;
m += bptr->pack_border_body(&bonus[body[j]],&buf[m]);
m += bptr->pack_border_body(&bonus[body[j]], &buf[m]);
}
}
@ -293,14 +294,15 @@ int AtomVecBody::pack_border_bonus(int n, int *list, double *buf)
int AtomVecBody::unpack_border_bonus(int n, int first, double *buf)
{
int i,j,m,last;
double *quat,*inertia;
int i, j, m, last;
double *quat, *inertia;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
body[i] = (int) ubuf(buf[m++]).i;
if (body[i] == 0) body[i] = -1;
if (body[i] == 0)
body[i] = -1;
else {
j = nlocal_bonus + nghost_bonus;
if (j == nmax_bonus) grow_bonus();
@ -316,9 +318,9 @@ int AtomVecBody::unpack_border_bonus(int n, int first, double *buf)
bonus[j].ninteger = (int) ubuf(buf[m++]).i;
bonus[j].ndouble = (int) ubuf(buf[m++]).i;
// corresponding put() calls are in clear_bonus()
bonus[j].ivalue = icp->get(bonus[j].ninteger,bonus[j].iindex);
bonus[j].dvalue = dcp->get(bonus[j].ndouble,bonus[j].dindex);
m += bptr->unpack_border_body(&bonus[j],&buf[m]);
bonus[j].ivalue = icp->get(bonus[j].ninteger, bonus[j].iindex);
bonus[j].dvalue = dcp->get(bonus[j].ndouble, bonus[j].dindex);
m += bptr->unpack_border_body(&bonus[j], &buf[m]);
bonus[j].ilocal = i;
body[i] = j;
nghost_bonus++;
@ -337,7 +339,8 @@ int AtomVecBody::pack_exchange_bonus(int i, double *buf)
{
int m = 0;
if (body[i] < 0) buf[m++] = ubuf(0).d;
if (body[i] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
int j = body[i];
@ -352,10 +355,12 @@ int AtomVecBody::pack_exchange_bonus(int i, double *buf)
buf[m++] = inertia[2];
buf[m++] = ubuf(bonus[j].ninteger).d;
buf[m++] = ubuf(bonus[j].ndouble).d;
memcpy(&buf[m],bonus[j].ivalue,bonus[j].ninteger*sizeof(int));
if (intdoubleratio == 1) m += bonus[j].ninteger;
else m += (bonus[j].ninteger+1)/2;
memcpy(&buf[m],bonus[j].dvalue,bonus[j].ndouble*sizeof(double));
memcpy(&buf[m], bonus[j].ivalue, bonus[j].ninteger * sizeof(int));
if (intdoubleratio == 1)
m += bonus[j].ninteger;
else
m += (bonus[j].ninteger + 1) / 2;
memcpy(&buf[m], bonus[j].dvalue, bonus[j].ndouble * sizeof(double));
m += bonus[j].ndouble;
}
@ -369,7 +374,8 @@ int AtomVecBody::unpack_exchange_bonus(int ilocal, double *buf)
int m = 0;
body[ilocal] = (int) ubuf(buf[m++]).i;
if (body[ilocal] == 0) body[ilocal] = -1;
if (body[ilocal] == 0)
body[ilocal] = -1;
else {
if (nlocal_bonus == nmax_bonus) grow_bonus();
double *quat = bonus[nlocal_bonus].quat;
@ -384,16 +390,14 @@ int AtomVecBody::unpack_exchange_bonus(int ilocal, double *buf)
bonus[nlocal_bonus].ninteger = (int) ubuf(buf[m++]).i;
bonus[nlocal_bonus].ndouble = (int) ubuf(buf[m++]).i;
// corresponding put() calls are in copy()
bonus[nlocal_bonus].ivalue = icp->get(bonus[nlocal_bonus].ninteger,
bonus[nlocal_bonus].iindex);
bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble,
bonus[nlocal_bonus].dindex);
memcpy(bonus[nlocal_bonus].ivalue,&buf[m],
bonus[nlocal_bonus].ninteger*sizeof(int));
if (intdoubleratio == 1) m += bonus[nlocal_bonus].ninteger;
else m += (bonus[nlocal_bonus].ninteger+1)/2;
memcpy(bonus[nlocal_bonus].dvalue,&buf[m],
bonus[nlocal_bonus].ndouble*sizeof(double));
bonus[nlocal_bonus].ivalue = icp->get(bonus[nlocal_bonus].ninteger, bonus[nlocal_bonus].iindex);
bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble, bonus[nlocal_bonus].dindex);
memcpy(bonus[nlocal_bonus].ivalue, &buf[m], bonus[nlocal_bonus].ninteger * sizeof(int));
if (intdoubleratio == 1)
m += bonus[nlocal_bonus].ninteger;
else
m += (bonus[nlocal_bonus].ninteger + 1) / 2;
memcpy(bonus[nlocal_bonus].dvalue, &buf[m], bonus[nlocal_bonus].ndouble * sizeof(double));
m += bonus[nlocal_bonus].ndouble;
bonus[nlocal_bonus].ilocal = ilocal;
@ -416,10 +420,13 @@ int AtomVecBody::size_restart_bonus()
for (i = 0; i < nlocal; i++) {
if (body[i] >= 0) {
n += size_restart_bonus_one;
if (intdoubleratio == 1) n += bonus[body[i]].ninteger;
else n += (bonus[body[i]].ninteger+1)/2;
if (intdoubleratio == 1)
n += bonus[body[i]].ninteger;
else
n += (bonus[body[i]].ninteger + 1) / 2;
n += bonus[body[i]].ndouble;
} else n++;
} else
n++;
}
return n;
@ -435,7 +442,8 @@ int AtomVecBody::pack_restart_bonus(int i, double *buf)
{
int m = 0;
if (body[i] < 0) buf[m++] = ubuf(0).d;
if (body[i] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
int j = body[i];
@ -450,10 +458,12 @@ int AtomVecBody::pack_restart_bonus(int i, double *buf)
buf[m++] = inertia[2];
buf[m++] = ubuf(bonus[j].ninteger).d;
buf[m++] = ubuf(bonus[j].ndouble).d;
memcpy(&buf[m],bonus[j].ivalue,bonus[j].ninteger*sizeof(int));
if (intdoubleratio == 1) m += bonus[j].ninteger;
else m += (bonus[j].ninteger+1)/2;
memcpy(&buf[m],bonus[j].dvalue,bonus[j].ndouble*sizeof(double));
memcpy(&buf[m], bonus[j].ivalue, bonus[j].ninteger * sizeof(int));
if (intdoubleratio == 1)
m += bonus[j].ninteger;
else
m += (bonus[j].ninteger + 1) / 2;
memcpy(&buf[m], bonus[j].dvalue, bonus[j].ndouble * sizeof(double));
m += bonus[j].ndouble;
}
@ -469,7 +479,8 @@ int AtomVecBody::unpack_restart_bonus(int ilocal, double *buf)
int m = 0;
body[ilocal] = (int) ubuf(buf[m++]).i;
if (body[ilocal] == 0) body[ilocal] = -1;
if (body[ilocal] == 0)
body[ilocal] = -1;
else {
if (nlocal_bonus == nmax_bonus) grow_bonus();
double *quat = bonus[nlocal_bonus].quat;
@ -483,16 +494,14 @@ int AtomVecBody::unpack_restart_bonus(int ilocal, double *buf)
inertia[2] = buf[m++];
bonus[nlocal_bonus].ninteger = (int) ubuf(buf[m++]).i;
bonus[nlocal_bonus].ndouble = (int) ubuf(buf[m++]).i;
bonus[nlocal_bonus].ivalue = icp->get(bonus[nlocal_bonus].ninteger,
bonus[nlocal_bonus].iindex);
bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble,
bonus[nlocal_bonus].dindex);
memcpy(bonus[nlocal_bonus].ivalue,&buf[m],
bonus[nlocal_bonus].ninteger*sizeof(int));
if (intdoubleratio == 1) m += bonus[nlocal_bonus].ninteger;
else m += (bonus[nlocal_bonus].ninteger+1)/2;
memcpy(bonus[nlocal_bonus].dvalue,&buf[m],
bonus[nlocal_bonus].ndouble*sizeof(double));
bonus[nlocal_bonus].ivalue = icp->get(bonus[nlocal_bonus].ninteger, bonus[nlocal_bonus].iindex);
bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble, bonus[nlocal_bonus].dindex);
memcpy(bonus[nlocal_bonus].ivalue, &buf[m], bonus[nlocal_bonus].ninteger * sizeof(int));
if (intdoubleratio == 1)
m += bonus[nlocal_bonus].ninteger;
else
m += (bonus[nlocal_bonus].ninteger + 1) / 2;
memcpy(bonus[nlocal_bonus].dvalue, &buf[m], bonus[nlocal_bonus].ndouble * sizeof(double));
m += bonus[nlocal_bonus].ndouble;
bonus[nlocal_bonus].ilocal = ilocal;
body[ilocal] = nlocal_bonus++;
@ -521,13 +530,15 @@ void AtomVecBody::create_atom_post(int ilocal)
void AtomVecBody::data_atom_post(int ilocal)
{
body_flag = body[ilocal];
if (body_flag == 0) body_flag = -1;
else if (body_flag == 1) body_flag = 0;
else error->one(FLERR,"Invalid body flag in Atoms section of data file");
if (body_flag == 0)
body_flag = -1;
else if (body_flag == 1)
body_flag = 0;
else
error->one(FLERR, "Invalid body flag in Atoms section of data file");
body[ilocal] = body_flag;
if (rmass[ilocal] <= 0.0)
error->one(FLERR,"Invalid density in Atoms section of data file");
if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file");
radius[ilocal] = 0.5;
angmom[ilocal][0] = 0.0;
@ -539,14 +550,12 @@ void AtomVecBody::data_atom_post(int ilocal)
unpack one body from Bodies section of data file
------------------------------------------------------------------------- */
void AtomVecBody::data_body(int m, int ninteger, int ndouble,
int *ivalues, double *dvalues)
void AtomVecBody::data_body(int m, int ninteger, int ndouble, int *ivalues, double *dvalues)
{
if (body[m])
error->one(FLERR,"Assigning body parameters to non-body atom");
if (body[m]) error->one(FLERR, "Assigning body parameters to non-body atom");
if (nlocal_bonus == nmax_bonus) grow_bonus();
bonus[nlocal_bonus].ilocal = m;
bptr->data_body(nlocal_bonus,ninteger,ndouble,ivalues,dvalues);
bptr->data_body(nlocal_bonus, ninteger, ndouble, ivalues, dvalues);
body[m] = nlocal_bonus++;
}
@ -557,14 +566,14 @@ void AtomVecBody::data_body(int m, int ninteger, int ndouble,
double AtomVecBody::memory_usage_bonus()
{
double bytes = 0;
bytes += (double)nmax_bonus*sizeof(Bonus);
bytes += (double) nmax_bonus * sizeof(Bonus);
bytes += icp->size() + dcp->size();
int nall = nlocal_bonus + nghost_bonus;
for (int i = 0; i < nall; i++) {
if (body[i] >= 0) {
bytes += (double)bonus[body[i]].ninteger * sizeof(int);
bytes += (double)bonus[body[i]].ndouble * sizeof(double);
bytes += (double) bonus[body[i]].ninteger * sizeof(int);
bytes += (double) bonus[body[i]].ndouble * sizeof(double);
}
}
@ -579,8 +588,10 @@ void AtomVecBody::pack_data_pre(int ilocal)
{
body_flag = body[ilocal];
if (body_flag < 0) body[ilocal] = 0;
else body[ilocal] = 1;
if (body_flag < 0)
body[ilocal] = 0;
else
body[ilocal] = 1;
}
/* ----------------------------------------------------------------------
@ -598,7 +609,7 @@ int AtomVecBody::pack_data_bonus(double *buf, int /*flag*/)
int m = 0;
for (i = 0; i < nlocal; i++) {
if (body[i] < 0) continue;
int n = bptr->pack_data_body(tag[i],body[i],buf);
int n = bptr->pack_data_body(tag[i], body[i], buf);
m += n;
if (buf) buf += n;
}
@ -613,9 +624,7 @@ int AtomVecBody::pack_data_bonus(double *buf, int /*flag*/)
void AtomVecBody::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/)
{
int i = 0;
while (i < n) {
i += bptr->write_data_body(fp,&buf[i]);
}
while (i < n) { i += bptr->write_data_body(fp, &buf[i]); }
}
/* ----------------------------------------------------------------------
@ -631,10 +640,9 @@ void AtomVecBody::pack_data_post(int ilocal)
body computes its size based on ivalues/dvalues and returns it
------------------------------------------------------------------------- */
double AtomVecBody::radius_body(int ninteger, int ndouble,
int *ivalues, double *dvalues)
double AtomVecBody::radius_body(int ninteger, int ndouble, int *ivalues, double *dvalues)
{
return bptr->radius_body(ninteger,ndouble,ivalues,dvalues);
return bptr->radius_body(ninteger, ndouble, ivalues, dvalues);
}
/* ----------------------------------------------------------------------
@ -644,10 +652,12 @@ double AtomVecBody::radius_body(int ninteger, int ndouble,
void AtomVecBody::set_quat(int m, double *quat_external)
{
if (body[m] < 0) error->one(FLERR,"Assigning quat to non-body atom");
if (body[m] < 0) error->one(FLERR, "Assigning quat to non-body atom");
double *quat = bonus[body[m]].quat;
quat[0] = quat_external[0]; quat[1] = quat_external[1];
quat[2] = quat_external[2]; quat[3] = quat_external[3];
quat[0] = quat_external[0];
quat[1] = quat_external[1];
quat[2] = quat_external[2];
quat[3] = quat_external[3];
}
/* ----------------------------------------------------------------------

25
src/atom_vec_charge.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -31,18 +30,18 @@ AtomVecCharge::AtomVecCharge(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "q";
fields_copy = (char *) "q";
fields_comm = (char *) "";
fields_comm_vel = (char *) "";
fields_reverse = (char *) "";
fields_border = (char *) "q";
fields_border_vel = (char *) "q";
fields_exchange = (char *) "q";
fields_restart = (char *) "q";
fields_create = (char *) "q";
fields_data_atom = (char *) "id type q x";
fields_data_vel = (char *) "id v";
fields_grow = {"q"};
fields_copy = {"q"};
fields_comm = {};
fields_comm_vel = {};
fields_reverse = {};
fields_border = {"q"};
fields_border_vel = {"q"};
fields_exchange = {"q"};
fields_restart = {"q"};
fields_create = {"q"};
fields_data_atom = {"id", "type", "q", "x"};
fields_data_vel = {"id", "v"};
setup_fields();
}

137
src/atom_vec_ellipsoid.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -26,10 +25,8 @@
#include "memory.h"
#include "modify.h"
#include <cstring>
using namespace LAMMPS_NS;
using namespace MathConst;
using MathConst::MY_PI;
/* ---------------------------------------------------------------------- */
@ -54,18 +51,18 @@ AtomVecEllipsoid::AtomVecEllipsoid(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rmass angmom torque ellipsoid";
fields_copy = (char *) "rmass angmom";
fields_comm = (char *) "";
fields_comm_vel = (char *) "angmom";
fields_reverse = (char *) "torque";
fields_border = (char *) "rmass";
fields_border_vel = (char *) "rmass angmom";
fields_exchange = (char *) "rmass angmom";
fields_restart = (char *) "rmass angmom";
fields_create = (char *) "rmass angmom ellipsoid";
fields_data_atom = (char *) "id type ellipsoid rmass x";
fields_data_vel = (char *) "id v angmom";
fields_grow = {"rmass", "angmom", "torque", "ellipsoid"};
fields_copy = {"rmass", "angmom"};
fields_comm = {};
fields_comm_vel = {"angmom"};
fields_reverse = {"torque"};
fields_border = {"rmass"};
fields_border_vel = {"rmass", "angmom"};
fields_exchange = {"rmass", "angmom"};
fields_restart = {"rmass", "angmom"};
fields_create = {"rmass", "angmom", "ellipsoid"};
fields_data_atom = {"id", "type", "ellipsoid", "rmass", "x"};
fields_data_vel = {"id", "v", "angmom"};
setup_fields();
}
@ -96,11 +93,9 @@ void AtomVecEllipsoid::grow_pointers()
void AtomVecEllipsoid::grow_bonus()
{
nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0)
error->one(FLERR,"Per-processor system is too big");
if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big");
bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus),
"atom:bonus");
bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom:bonus");
}
/* ----------------------------------------------------------------------
@ -112,7 +107,7 @@ void AtomVecEllipsoid::copy_bonus(int i, int j, int delflag)
// if deleting atom J via delflag and J has bonus data, then delete it
if (delflag && ellipsoid[j] >= 0) {
copy_bonus_all(nlocal_bonus-1,ellipsoid[j]);
copy_bonus_all(nlocal_bonus - 1, ellipsoid[j]);
nlocal_bonus--;
}
@ -131,7 +126,7 @@ void AtomVecEllipsoid::copy_bonus(int i, int j, int delflag)
void AtomVecEllipsoid::copy_bonus_all(int i, int j)
{
ellipsoid[bonus[i].ilocal] = j;
memcpy(&bonus[j],&bonus[i],sizeof(Bonus));
memcpy(&bonus[j], &bonus[i], sizeof(Bonus));
}
/* ----------------------------------------------------------------------
@ -152,7 +147,7 @@ void AtomVecEllipsoid::clear_bonus()
int AtomVecEllipsoid::pack_comm_bonus(int n, int *list, double *buf)
{
int i,j,m;
int i, j, m;
double *quat;
m = 0;
@ -174,7 +169,7 @@ int AtomVecEllipsoid::pack_comm_bonus(int n, int *list, double *buf)
void AtomVecEllipsoid::unpack_comm_bonus(int n, int first, double *buf)
{
int i,m,last;
int i, m, last;
double *quat;
m = 0;
@ -194,13 +189,14 @@ void AtomVecEllipsoid::unpack_comm_bonus(int n, int first, double *buf)
int AtomVecEllipsoid::pack_border_bonus(int n, int *list, double *buf)
{
int i,j,m;
double *shape,*quat;
int i, j, m;
double *shape, *quat;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
if (ellipsoid[j] < 0) buf[m++] = ubuf(0).d;
if (ellipsoid[j] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
shape = bonus[ellipsoid[j]].shape;
@ -222,14 +218,15 @@ int AtomVecEllipsoid::pack_border_bonus(int n, int *list, double *buf)
int AtomVecEllipsoid::unpack_border_bonus(int n, int first, double *buf)
{
int i,j,m,last;
double *shape,*quat;
int i, j, m, last;
double *shape, *quat;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
ellipsoid[i] = (int) ubuf(buf[m++]).i;
if (ellipsoid[i] == 0) ellipsoid[i] = -1;
if (ellipsoid[i] == 0)
ellipsoid[i] = -1;
else {
j = nlocal_bonus + nghost_bonus;
if (j == nmax_bonus) grow_bonus();
@ -260,7 +257,8 @@ int AtomVecEllipsoid::pack_exchange_bonus(int i, double *buf)
{
int m = 0;
if (ellipsoid[i] < 0) buf[m++] = ubuf(0).d;
if (ellipsoid[i] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
int j = ellipsoid[i];
@ -285,7 +283,8 @@ int AtomVecEllipsoid::unpack_exchange_bonus(int ilocal, double *buf)
int m = 0;
ellipsoid[ilocal] = (int) ubuf(buf[m++]).i;
if (ellipsoid[ilocal] == 0) ellipsoid[ilocal] = -1;
if (ellipsoid[ilocal] == 0)
ellipsoid[ilocal] = -1;
else {
if (nlocal_bonus == nmax_bonus) grow_bonus();
double *shape = bonus[nlocal_bonus].shape;
@ -316,8 +315,10 @@ int AtomVecEllipsoid::size_restart_bonus()
int n = 0;
int nlocal = atom->nlocal;
for (i = 0; i < nlocal; i++) {
if (ellipsoid[i] >= 0) n += size_restart_bonus_one;
else n++;
if (ellipsoid[i] >= 0)
n += size_restart_bonus_one;
else
n++;
}
return n;
@ -333,7 +334,8 @@ int AtomVecEllipsoid::pack_restart_bonus(int i, double *buf)
{
int m = 0;
if (ellipsoid[i] < 0) buf[m++] = ubuf(0).d;
if (ellipsoid[i] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
int j = ellipsoid[i];
@ -358,7 +360,8 @@ int AtomVecEllipsoid::unpack_restart_bonus(int ilocal, double *buf)
int m = 0;
ellipsoid[ilocal] = (int) ubuf(buf[m++]).i;
if (ellipsoid[ilocal] == 0) ellipsoid[ilocal] = -1;
if (ellipsoid[ilocal] == 0)
ellipsoid[ilocal] = -1;
else {
if (nlocal_bonus == nmax_bonus) grow_bonus();
double *shape = bonus[nlocal_bonus].shape;
@ -381,32 +384,31 @@ int AtomVecEllipsoid::unpack_restart_bonus(int ilocal, double *buf)
unpack one line from Ellipsoids section of data file
------------------------------------------------------------------------- */
void AtomVecEllipsoid::data_atom_bonus(int m, const std::vector<std::string> & values)
void AtomVecEllipsoid::data_atom_bonus(int m, const std::vector<std::string> &values)
{
if (ellipsoid[m])
error->one(FLERR,"Assigning ellipsoid parameters to non-ellipsoid atom");
if (ellipsoid[m]) error->one(FLERR, "Assigning ellipsoid parameters to non-ellipsoid atom");
if (nlocal_bonus == nmax_bonus) grow_bonus();
double *shape = bonus[nlocal_bonus].shape;
int ivalue = 1;
shape[0] = 0.5 * utils::numeric(FLERR,values[ivalue++],true,lmp);
shape[1] = 0.5 * utils::numeric(FLERR,values[ivalue++],true,lmp);
shape[2] = 0.5 * utils::numeric(FLERR,values[ivalue++],true,lmp);
shape[0] = 0.5 * utils::numeric(FLERR, values[ivalue++], true, lmp);
shape[1] = 0.5 * utils::numeric(FLERR, values[ivalue++], true, lmp);
shape[2] = 0.5 * utils::numeric(FLERR, values[ivalue++], true, lmp);
if (shape[0] <= 0.0 || shape[1] <= 0.0 || shape[2] <= 0.0)
error->one(FLERR,"Invalid shape in Ellipsoids section of data file");
error->one(FLERR, "Invalid shape in Ellipsoids section of data file");
double *quat = bonus[nlocal_bonus].quat;
quat[0] = utils::numeric(FLERR,values[ivalue++],true,lmp);
quat[1] = utils::numeric(FLERR,values[ivalue++],true,lmp);
quat[2] = utils::numeric(FLERR,values[ivalue++],true,lmp);
quat[3] = utils::numeric(FLERR,values[ivalue++],true,lmp);
quat[0] = utils::numeric(FLERR, values[ivalue++], true, lmp);
quat[1] = utils::numeric(FLERR, values[ivalue++], true, lmp);
quat[2] = utils::numeric(FLERR, values[ivalue++], true, lmp);
quat[3] = utils::numeric(FLERR, values[ivalue++], true, lmp);
MathExtra::qnormalize(quat);
// reset ellipsoid mass
// previously stored density in rmass
rmass[m] *= 4.0*MY_PI/3.0 * shape[0]*shape[1]*shape[2];
rmass[m] *= 4.0 * MY_PI / 3.0 * shape[0] * shape[1] * shape[2];
bonus[nlocal_bonus].ilocal = m;
ellipsoid[m] = nlocal_bonus++;
@ -419,7 +421,7 @@ void AtomVecEllipsoid::data_atom_bonus(int m, const std::vector<std::string> & v
double AtomVecEllipsoid::memory_usage_bonus()
{
double bytes = 0;
bytes += nmax_bonus*sizeof(Bonus);
bytes += nmax_bonus * sizeof(Bonus);
return bytes;
}
@ -441,13 +443,15 @@ void AtomVecEllipsoid::create_atom_post(int ilocal)
void AtomVecEllipsoid::data_atom_post(int ilocal)
{
ellipsoid_flag = ellipsoid[ilocal];
if (ellipsoid_flag == 0) ellipsoid_flag = -1;
else if (ellipsoid_flag == 1) ellipsoid_flag = 0;
else error->one(FLERR,"Invalid ellipsoid flag in Atoms section of data file");
if (ellipsoid_flag == 0)
ellipsoid_flag = -1;
else if (ellipsoid_flag == 1)
ellipsoid_flag = 0;
else
error->one(FLERR, "Invalid ellipsoid flag in Atoms section of data file");
ellipsoid[ilocal] = ellipsoid_flag;
if (rmass[ilocal] <= 0.0)
error->one(FLERR,"Invalid density in Atoms section of data file");
if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file");
angmom[ilocal][0] = 0.0;
angmom[ilocal][1] = 0.0;
@ -465,12 +469,14 @@ void AtomVecEllipsoid::pack_data_pre(int ilocal)
ellipsoid_flag = atom->ellipsoid[ilocal];
rmass_one = atom->rmass[ilocal];
if (ellipsoid_flag < 0) ellipsoid[ilocal] = 0;
else ellipsoid[ilocal] = 1;
if (ellipsoid_flag < 0)
ellipsoid[ilocal] = 0;
else
ellipsoid[ilocal] = 1;
if (ellipsoid_flag >= 0) {
shape = bonus[ellipsoid_flag].shape;
rmass[ilocal] /= 4.0*MY_PI/3.0 * shape[0]*shape[1]*shape[2];
rmass[ilocal] /= 4.0 * MY_PI / 3.0 * shape[0] * shape[1] * shape[2];
}
}
@ -491,7 +497,7 @@ void AtomVecEllipsoid::pack_data_post(int ilocal)
int AtomVecEllipsoid::pack_data_bonus(double *buf, int /*flag*/)
{
int i,j;
int i, j;
tagint *tag = atom->tag;
int nlocal = atom->nlocal;
@ -502,14 +508,15 @@ int AtomVecEllipsoid::pack_data_bonus(double *buf, int /*flag*/)
if (buf) {
buf[m++] = ubuf(tag[i]).d;
j = ellipsoid[i];
buf[m++] = 2.0*bonus[j].shape[0];
buf[m++] = 2.0*bonus[j].shape[1];
buf[m++] = 2.0*bonus[j].shape[2];
buf[m++] = 2.0 * bonus[j].shape[0];
buf[m++] = 2.0 * bonus[j].shape[1];
buf[m++] = 2.0 * bonus[j].shape[2];
buf[m++] = bonus[j].quat[0];
buf[m++] = bonus[j].quat[1];
buf[m++] = bonus[j].quat[2];
buf[m++] = bonus[j].quat[3];
} else m += size_data_bonus;
} else
m += size_data_bonus;
}
return m;
@ -523,8 +530,8 @@ void AtomVecEllipsoid::write_data_bonus(FILE *fp, int n, double *buf, int /*flag
{
int i = 0;
while (i < n) {
fmt::print(fp,"{} {} {} {} {} {} {} {}\n",ubuf(buf[i]).i,
buf[i+1],buf[i+2],buf[i+3],buf[i+4],buf[i+5],buf[i+6],buf[i+7]);
fmt::print(fp, "{} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3],
buf[i + 4], buf[i + 5], buf[i + 6], buf[i + 7]);
i += size_data_bonus;
}
}
@ -552,7 +559,7 @@ void AtomVecEllipsoid::set_shape(int i, double shapex, double shapey, double sha
bonus[nlocal_bonus].ilocal = i;
ellipsoid[i] = nlocal_bonus++;
} else if (shapex == 0.0 && shapey == 0.0 && shapez == 0.0) {
copy_bonus_all(nlocal_bonus-1,ellipsoid[i]);
copy_bonus_all(nlocal_bonus - 1, ellipsoid[i]);
nlocal_bonus--;
ellipsoid[i] = -1;
} else {

318
src/atom_vec_hybrid.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -19,12 +18,12 @@
#include "error.h"
#include "tokenizer.h"
#include <algorithm>
#include <cstring>
using namespace LAMMPS_NS;
#define NFIELDSTRINGS 12 // # of field strings
enum{ELLIPSOID,LINE,TRIANGLE,BODY}; // also in WriteData
enum { ELLIPSOID, LINE, TRIANGLE, BODY }; // also in WriteData
/* ---------------------------------------------------------------------- */
@ -33,22 +32,16 @@ AtomVecHybrid::AtomVecHybrid(LAMMPS *lmp) : AtomVec(lmp)
nstyles = 0;
styles = nullptr;
keywords = nullptr;
fieldstrings = nullptr;
bonus_flag = 0;
nstyles_bonus = 0;
styles_bonus = nullptr;
// these strings will be concatenated from sub-style strings
// field strings will be concatenated from sub-style strings
// fields_data_atom & fields_data_vel start with fields common to all styles
fields_grow = fields_copy = fields_comm = fields_comm_vel = (char *) "";
fields_reverse = fields_border = fields_border_vel = (char *) "";
fields_exchange = fields_restart = fields_create = (char *) "";
fields_data_atom = (char *) "id type x";
fields_data_vel = (char *) "id v";
fields_allocated = 0;
fields_data_atom = {"id", "type", "x"};
fields_data_vel = {"id", "v"};
}
/* ---------------------------------------------------------------------- */
@ -56,28 +49,10 @@ AtomVecHybrid::AtomVecHybrid(LAMMPS *lmp) : AtomVec(lmp)
AtomVecHybrid::~AtomVecHybrid()
{
for (int k = 0; k < nstyles; k++) delete styles[k];
delete [] styles;
for (int k = 0; k < nstyles; k++) delete [] keywords[k];
delete [] keywords;
delete [] styles_bonus;
if (!fields_allocated) return;
delete [] fields_grow;
delete [] fields_copy;
delete [] fields_comm;
delete [] fields_comm_vel;
delete [] fields_reverse;
delete [] fields_border;
delete [] fields_border_vel;
delete [] fields_exchange;
delete [] fields_restart;
delete [] fields_create;
delete [] fields_data_atom;
delete [] fields_data_vel;
for (int k = 0; k < nstyles; k++) delete [] fieldstrings[k].fstr;
delete [] fieldstrings;
delete[] styles;
for (int k = 0; k < nstyles; k++) delete[] keywords[k];
delete[] keywords;
delete[] styles_bonus;
}
/* ----------------------------------------------------------------------
@ -92,28 +67,27 @@ void AtomVecHybrid::process_args(int narg, char **arg)
// allocate list of sub-styles as big as possibly needed if no extra args
styles = new AtomVec*[narg];
keywords = new char*[narg];
styles = new AtomVec *[narg];
keywords = new char *[narg];
// allocate each sub-style
// call process_args() with set of args that are not atom style names
// use known_style() to determine which args these are
int i,k,jarg,dummy;
int dummy;
int iarg = 0;
nstyles = 0;
while (iarg < narg) {
if (strcmp(arg[iarg],"hybrid") == 0)
error->all(FLERR,"Atom style hybrid cannot have hybrid as an argument");
for (i = 0; i < nstyles; i++)
if (strcmp(arg[iarg],keywords[i]) == 0)
error->all(FLERR,"Atom style hybrid cannot use same atom style twice");
styles[nstyles] = atom->new_avec(arg[iarg],1,dummy);
if (strcmp(arg[iarg], "hybrid") == 0)
error->all(FLERR, "Atom style hybrid cannot have hybrid as an argument");
for (int i = 0; i < nstyles; i++)
if (strcmp(arg[iarg], keywords[i]) == 0)
error->all(FLERR, "Atom style hybrid cannot use same atom style twice");
styles[nstyles] = atom->new_avec(arg[iarg], 1, dummy);
keywords[nstyles] = utils::strdup(arg[iarg]);
jarg = iarg + 1;
int jarg = iarg + 1;
while (jarg < narg && !known_style(arg[jarg])) jarg++;
styles[nstyles]->process_args(jarg-iarg-1,&arg[iarg+1]);
styles[nstyles]->process_args(jarg - iarg - 1, &arg[iarg + 1]);
iarg = jarg;
nstyles++;
}
@ -124,20 +98,19 @@ void AtomVecHybrid::process_args(int narg, char **arg)
molecular = Atom::ATOMIC;
maxexchange = 0;
for (k = 0; k < nstyles; k++) {
for (int k = 0; k < nstyles; k++) {
if ((styles[k]->molecular == Atom::MOLECULAR && molecular == Atom::TEMPLATE) ||
(styles[k]->molecular == Atom::TEMPLATE && molecular == Atom::MOLECULAR))
error->all(FLERR,
"Cannot mix molecular and molecule template atom styles");
molecular = MAX(molecular,styles[k]->molecular);
error->all(FLERR, "Cannot mix molecular and molecule template atom styles");
molecular = MAX(molecular, styles[k]->molecular);
bonds_allow = MAX(bonds_allow,styles[k]->bonds_allow);
angles_allow = MAX(angles_allow,styles[k]->angles_allow);
dihedrals_allow = MAX(dihedrals_allow,styles[k]->dihedrals_allow);
impropers_allow = MAX(impropers_allow,styles[k]->impropers_allow);
mass_type = MAX(mass_type,styles[k]->mass_type);
dipole_type = MAX(dipole_type,styles[k]->dipole_type);
forceclearflag = MAX(forceclearflag,styles[k]->forceclearflag);
bonds_allow = MAX(bonds_allow, styles[k]->bonds_allow);
angles_allow = MAX(angles_allow, styles[k]->angles_allow);
dihedrals_allow = MAX(dihedrals_allow, styles[k]->dihedrals_allow);
impropers_allow = MAX(impropers_allow, styles[k]->impropers_allow);
mass_type = MAX(mass_type, styles[k]->mass_type);
dipole_type = MAX(dipole_type, styles[k]->dipole_type);
forceclearflag = MAX(forceclearflag, styles[k]->forceclearflag);
maxexchange += styles[k]->maxexchange;
if (styles[k]->molecular == Atom::TEMPLATE) onemols = styles[k]->onemols;
@ -148,95 +121,71 @@ void AtomVecHybrid::process_args(int narg, char **arg)
int mass_pertype = 0;
int mass_peratom = 0;
for (k = 0; k < nstyles; k++) {
for (int k = 0; k < nstyles; k++) {
if (styles[k]->mass_type == 0) mass_peratom = 1;
if (styles[k]->mass_type == 1) mass_pertype = 1;
}
if (mass_pertype && mass_peratom && comm->me == 0)
error->warning(FLERR, "Atom style hybrid defines both, per-type "
error->warning(FLERR,
"Atom style hybrid defines both, per-type "
"and per-atom masses; both must be set, but only "
"per-atom masses will be used");
// free allstyles created by build_styles()
for (i = 0; i < nallstyles; i++) delete [] allstyles[i];
delete [] allstyles;
// set field strings from all substyles
fieldstrings = new FieldStrings[nstyles];
for (k = 0; k < nstyles; k++) {
fieldstrings[k].fstr = new char*[NFIELDSTRINGS];
fieldstrings[k].fstr[0] = styles[k]->fields_grow;
fieldstrings[k].fstr[1] = styles[k]->fields_copy;
fieldstrings[k].fstr[2] = styles[k]->fields_comm;
fieldstrings[k].fstr[3] = styles[k]->fields_comm_vel;
fieldstrings[k].fstr[4] = styles[k]->fields_reverse;
fieldstrings[k].fstr[5] = styles[k]->fields_border;
fieldstrings[k].fstr[6] = styles[k]->fields_border_vel;
fieldstrings[k].fstr[7] = styles[k]->fields_exchange;
fieldstrings[k].fstr[8] = styles[k]->fields_restart;
fieldstrings[k].fstr[9] = styles[k]->fields_create;
fieldstrings[k].fstr[10] = styles[k]->fields_data_atom;
fieldstrings[k].fstr[11] = styles[k]->fields_data_vel;
}
for (int i = 0; i < nallstyles; i++) delete[] allstyles[i];
delete[] allstyles;
// merge field strings from all sub-styles
// save concat_grow to check for duplicates of special-case fields
char *concat_grow;;
char *dummyptr = nullptr;
std::vector<std::string> concat_grow;
std::vector<std::string> concat_dummy;
fields_grow = merge_fields(0,fields_grow,1,concat_grow);
fields_copy = merge_fields(1,fields_copy,0,dummyptr);
fields_comm = merge_fields(2,fields_comm,0,dummyptr);
fields_comm_vel = merge_fields(3,fields_comm_vel,0,dummyptr);
fields_reverse = merge_fields(4,fields_reverse,0,dummyptr);
fields_border = merge_fields(5,fields_border,0,dummyptr);
fields_border_vel = merge_fields(6,fields_border_vel,0,dummyptr);
fields_exchange = merge_fields(7,fields_exchange,0,dummyptr);
fields_restart = merge_fields(8,fields_restart,0,dummyptr);
fields_create = merge_fields(9,fields_create,0,dummyptr);
fields_data_atom = merge_fields(10,fields_data_atom,0,dummyptr);
fields_data_vel = merge_fields(11,fields_data_vel,0,dummyptr);
fields_allocated = 1;
for (int k = 0; k < nstyles; k++) {
merge_fields(fields_grow, styles[k]->fields_grow, 1, concat_grow);
merge_fields(fields_copy, styles[k]->fields_copy, 0, concat_dummy);
merge_fields(fields_comm, styles[k]->fields_comm, 0, concat_dummy);
merge_fields(fields_comm_vel, styles[k]->fields_comm_vel, 0, concat_dummy);
merge_fields(fields_reverse, styles[k]->fields_reverse, 0, concat_dummy);
merge_fields(fields_border, styles[k]->fields_border, 0, concat_dummy);
merge_fields(fields_border_vel, styles[k]->fields_border_vel, 0, concat_dummy);
merge_fields(fields_exchange, styles[k]->fields_exchange, 0, concat_dummy);
merge_fields(fields_restart, styles[k]->fields_restart, 0, concat_dummy);
merge_fields(fields_create, styles[k]->fields_create, 0, concat_dummy);
merge_fields(fields_data_atom, styles[k]->fields_data_atom, 0, concat_dummy);
merge_fields(fields_data_vel, styles[k]->fields_data_vel, 0, concat_dummy);
}
// check concat_grow for multiple special-case fields
// may cause issues with style-specific create_atom() and data_atom() methods
// issue warnings if appear in multiple sub-styles
const char *dupfield[] = {"radius","rmass"};
int ndupfield = 2;
char *ptr;
std::vector<std::string> dupfield = {"radius", "rmass"};
for (int idup = 0; idup < ndupfield; idup++) {
auto dup = (char *) dupfield[idup];
ptr = strstr(concat_grow,dup);
if ((ptr && strstr(ptr+1,dup)) && (comm->me == 0))
error->warning(FLERR,fmt::format("Per-atom {} is used in multiple sub-"
"styles; must be used consistently",dup));
for (const auto &idup : dupfield) {
if ((comm->me == 0) && (std::count(concat_grow.begin(), concat_grow.end(), idup) > 1))
error->warning(FLERR,
"Per-atom field {} is used in multiple sub-styles; must be used consistently",
idup);
}
delete [] concat_grow;
// set bonus_flag if any substyle has bonus data
// set nstyles_bonus & styles_bonus
// sum two sizes over contributions from each substyle with bonus data.
nstyles_bonus = 0;
for (k = 0; k < nstyles; k++)
for (int k = 0; k < nstyles; k++)
if (styles[k]->bonus_flag) nstyles_bonus++;
if (nstyles_bonus) {
bonus_flag = 1;
styles_bonus = new AtomVec*[nstyles_bonus];
styles_bonus = new AtomVec *[nstyles_bonus];
nstyles_bonus = 0;
size_forward_bonus = 0;
size_border_bonus = 0;
for (k = 0; k < nstyles; k++) {
for (int k = 0; k < nstyles; k++) {
if (styles[k]->bonus_flag) {
styles_bonus[nstyles_bonus++] = styles[k];
size_forward_bonus += styles[k]->size_forward_bonus;
@ -270,23 +219,21 @@ void AtomVecHybrid::grow_pointers()
void AtomVecHybrid::force_clear(int n, size_t nbytes)
{
for (int k = 0; k < nstyles; k++)
if (styles[k]->forceclearflag) styles[k]->force_clear(n,nbytes);
if (styles[k]->forceclearflag) styles[k]->force_clear(n, nbytes);
}
/* ---------------------------------------------------------------------- */
void AtomVecHybrid::copy_bonus(int i, int j, int delflag)
{
for (int k = 0; k < nstyles_bonus; k++)
styles_bonus[k]->copy_bonus(i,j,delflag);
for (int k = 0; k < nstyles_bonus; k++) styles_bonus[k]->copy_bonus(i, j, delflag);
}
/* ---------------------------------------------------------------------- */
void AtomVecHybrid::clear_bonus()
{
for (int k = 0; k < nstyles_bonus; k++)
styles_bonus[k]->clear_bonus();
for (int k = 0; k < nstyles_bonus; k++) styles_bonus[k]->clear_bonus();
}
/* ---------------------------------------------------------------------- */
@ -294,8 +241,7 @@ void AtomVecHybrid::clear_bonus()
int AtomVecHybrid::pack_comm_bonus(int n, int *list, double *buf)
{
int m = 0;
for (int k = 0; k < nstyles_bonus; k++)
m += styles_bonus[k]->pack_comm_bonus(n,list,buf);
for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_comm_bonus(n, list, buf);
return m;
}
@ -303,8 +249,7 @@ int AtomVecHybrid::pack_comm_bonus(int n, int *list, double *buf)
void AtomVecHybrid::unpack_comm_bonus(int n, int first, double *buf)
{
for (int k = 0; k < nstyles_bonus; k++)
styles_bonus[k]->unpack_comm_bonus(n,first,buf);
for (int k = 0; k < nstyles_bonus; k++) styles_bonus[k]->unpack_comm_bonus(n, first, buf);
}
/* ---------------------------------------------------------------------- */
@ -312,8 +257,7 @@ void AtomVecHybrid::unpack_comm_bonus(int n, int first, double *buf)
int AtomVecHybrid::pack_border_bonus(int n, int *list, double *buf)
{
int m = 0;
for (int k = 0; k < nstyles_bonus; k++)
m += styles_bonus[k]->pack_border_bonus(n,list,buf);
for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_border_bonus(n, list, buf);
return m;
}
@ -322,8 +266,7 @@ int AtomVecHybrid::pack_border_bonus(int n, int *list, double *buf)
int AtomVecHybrid::unpack_border_bonus(int n, int first, double *buf)
{
int m = 0;
for (int k = 0; k < nstyles_bonus; k++)
m += styles_bonus[k]->unpack_border_bonus(n,first,buf);
for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->unpack_border_bonus(n, first, buf);
return m;
}
@ -332,8 +275,7 @@ int AtomVecHybrid::unpack_border_bonus(int n, int first, double *buf)
int AtomVecHybrid::pack_exchange_bonus(int i, double *buf)
{
int m = 0;
for (int k = 0; k < nstyles_bonus; k++)
m += styles_bonus[k]->pack_exchange_bonus(i,buf);
for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_exchange_bonus(i, buf);
return m;
}
@ -342,8 +284,7 @@ int AtomVecHybrid::pack_exchange_bonus(int i, double *buf)
int AtomVecHybrid::unpack_exchange_bonus(int ilocal, double *buf)
{
int m = 0;
for (int k = 0; k < nstyles_bonus; k++)
m += styles_bonus[k]->unpack_exchange_bonus(ilocal,buf);
for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->unpack_exchange_bonus(ilocal, buf);
return m;
}
@ -352,8 +293,7 @@ int AtomVecHybrid::unpack_exchange_bonus(int ilocal, double *buf)
int AtomVecHybrid::size_restart_bonus()
{
int n = 0;
for (int k = 0; k < nstyles_bonus; k++)
n += styles_bonus[k]->size_restart_bonus();
for (int k = 0; k < nstyles_bonus; k++) n += styles_bonus[k]->size_restart_bonus();
return n;
}
@ -362,8 +302,7 @@ int AtomVecHybrid::size_restart_bonus()
int AtomVecHybrid::pack_restart_bonus(int i, double *buf)
{
int m = 0;
for (int k = 0; k < nstyles_bonus; k++)
m += styles_bonus[k]->pack_restart_bonus(i,buf);
for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_restart_bonus(i, buf);
return m;
}
@ -372,8 +311,7 @@ int AtomVecHybrid::pack_restart_bonus(int i, double *buf)
int AtomVecHybrid::unpack_restart_bonus(int ilocal, double *buf)
{
int m = 0;
for (int k = 0; k < nstyles_bonus; k++)
m += styles_bonus[k]->unpack_restart_bonus(ilocal,buf);
for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->unpack_restart_bonus(ilocal, buf);
return m;
}
@ -382,8 +320,7 @@ int AtomVecHybrid::unpack_restart_bonus(int ilocal, double *buf)
double AtomVecHybrid::memory_usage_bonus()
{
double bytes = 0;
for (int k = 0; k < nstyles_bonus; k++)
bytes += styles_bonus[k]->memory_usage_bonus();
for (int k = 0; k < nstyles_bonus; k++) bytes += styles_bonus[k]->memory_usage_bonus();
return bytes;
}
@ -393,8 +330,7 @@ double AtomVecHybrid::memory_usage_bonus()
void AtomVecHybrid::pack_restart_pre(int ilocal)
{
for (int k = 0; k < nstyles; k++)
styles[k]->pack_restart_pre(ilocal);
for (int k = 0; k < nstyles; k++) styles[k]->pack_restart_pre(ilocal);
}
/* ----------------------------------------------------------------------
@ -403,8 +339,7 @@ void AtomVecHybrid::pack_restart_pre(int ilocal)
void AtomVecHybrid::pack_restart_post(int ilocal)
{
for (int k = 0; k < nstyles; k++)
styles[k]->pack_restart_post(ilocal);
for (int k = 0; k < nstyles; k++) styles[k]->pack_restart_post(ilocal);
}
/* ----------------------------------------------------------------------
@ -413,8 +348,7 @@ void AtomVecHybrid::pack_restart_post(int ilocal)
void AtomVecHybrid::unpack_restart_init(int ilocal)
{
for (int k = 0; k < nstyles; k++)
styles[k]->unpack_restart_init(ilocal);
for (int k = 0; k < nstyles; k++) styles[k]->unpack_restart_init(ilocal);
}
/* ----------------------------------------------------------------------
@ -423,8 +357,7 @@ void AtomVecHybrid::unpack_restart_init(int ilocal)
void AtomVecHybrid::create_atom_post(int ilocal)
{
for (int k = 0; k < nstyles; k++)
styles[k]->create_atom_post(ilocal);
for (int k = 0; k < nstyles; k++) styles[k]->create_atom_post(ilocal);
}
/* ----------------------------------------------------------------------
@ -434,16 +367,15 @@ void AtomVecHybrid::create_atom_post(int ilocal)
void AtomVecHybrid::data_atom_post(int ilocal)
{
for (int k = 0; k < nstyles; k++)
styles[k]->data_atom_post(ilocal);
for (int k = 0; k < nstyles; k++) styles[k]->data_atom_post(ilocal);
}
/* ----------------------------------------------------------------------
modify what AtomVec::data_bonds() just unpacked
or initialize other bond quantities
------------------------------------------------------------------------- */
void AtomVecHybrid::data_bonds_post(int m, int num_bond, tagint atom1,
tagint atom2, tagint id_offset)
void AtomVecHybrid::data_bonds_post(int m, int num_bond, tagint atom1, tagint atom2,
tagint id_offset)
{
for (int k = 0; k < nstyles; k++)
styles[k]->data_bonds_post(m, num_bond, atom1, atom2, id_offset);
@ -455,8 +387,7 @@ void AtomVecHybrid::data_bonds_post(int m, int num_bond, tagint atom1,
void AtomVecHybrid::pack_data_pre(int ilocal)
{
for (int k = 0; k < nstyles; k++)
styles[k]->pack_data_pre(ilocal);
for (int k = 0; k < nstyles; k++) styles[k]->pack_data_pre(ilocal);
}
/* ----------------------------------------------------------------------
@ -465,8 +396,7 @@ void AtomVecHybrid::pack_data_pre(int ilocal)
void AtomVecHybrid::pack_data_post(int ilocal)
{
for (int k = 0; k < nstyles; k++)
styles[k]->pack_data_post(ilocal);
for (int k = 0; k < nstyles; k++) styles[k]->pack_data_post(ilocal);
}
/* ----------------------------------------------------------------------
@ -476,12 +406,12 @@ void AtomVecHybrid::pack_data_post(int ilocal)
int AtomVecHybrid::pack_data_bonus(double *buf, int flag)
{
for (int k = 0; k < nstyles; k++) {
if (flag == ELLIPSOID && strcmp(keywords[k],"ellipsoid") != 0) continue;
if (flag == LINE && strcmp(keywords[k],"line") != 0) continue;
if (flag == TRIANGLE && strcmp(keywords[k],"tri") != 0) continue;
if (flag == BODY && strcmp(keywords[k],"body") != 0) continue;
if (flag == ELLIPSOID && strcmp(keywords[k], "ellipsoid") != 0) continue;
if (flag == LINE && strcmp(keywords[k], "line") != 0) continue;
if (flag == TRIANGLE && strcmp(keywords[k], "tri") != 0) continue;
if (flag == BODY && strcmp(keywords[k], "body") != 0) continue;
return styles[k]->pack_data_bonus(buf,flag);
return styles[k]->pack_data_bonus(buf, flag);
}
return 0;
}
@ -493,12 +423,12 @@ int AtomVecHybrid::pack_data_bonus(double *buf, int flag)
void AtomVecHybrid::write_data_bonus(FILE *fp, int n, double *buf, int flag)
{
for (int k = 0; k < nstyles; k++) {
if (flag == ELLIPSOID && strcmp(keywords[k],"ellipsoid") != 0) continue;
if (flag == LINE && strcmp(keywords[k],"line") != 0) continue;
if (flag == TRIANGLE && strcmp(keywords[k],"tri") != 0) continue;
if (flag == BODY && strcmp(keywords[k],"body") != 0) continue;
if (flag == ELLIPSOID && strcmp(keywords[k], "ellipsoid") != 0) continue;
if (flag == LINE && strcmp(keywords[k], "line") != 0) continue;
if (flag == TRIANGLE && strcmp(keywords[k], "tri") != 0) continue;
if (flag == BODY && strcmp(keywords[k], "body") != 0) continue;
styles[k]->write_data_bonus(fp,n,buf,flag);
styles[k]->write_data_bonus(fp, n, buf, flag);
}
}
@ -508,11 +438,11 @@ void AtomVecHybrid::write_data_bonus(FILE *fp, int n, double *buf, int flag)
return -1 if name is unknown to any sub-styles
------------------------------------------------------------------------- */
int AtomVecHybrid::property_atom(char *name)
int AtomVecHybrid::property_atom(const std::string &name)
{
for (int k = 0; k < nstyles; k++) {
int index = styles[k]->property_atom(name);
if (index >= 0) return index*nstyles + k;
if (index >= 0) return index * nstyles + k;
}
return -1;
}
@ -522,12 +452,11 @@ int AtomVecHybrid::property_atom(char *name)
index maps to data specific to this atom style
------------------------------------------------------------------------- */
void AtomVecHybrid::pack_property_atom(int multiindex, double *buf,
int nvalues, int groupbit)
void AtomVecHybrid::pack_property_atom(int multiindex, double *buf, int nvalues, int groupbit)
{
int k = multiindex % nstyles;
int index = multiindex/nstyles;
styles[k]->pack_property_atom(index,buf,nvalues,groupbit);
int index = multiindex / nstyles;
styles[k]->pack_property_atom(index, buf, nvalues, groupbit);
}
// ----------------------------------------------------------------------
@ -535,48 +464,21 @@ void AtomVecHybrid::pack_property_atom(int multiindex, double *buf,
// ----------------------------------------------------------------------
/* ----------------------------------------------------------------------
merge fields and remove duplicate fields
concat = root + Inum fields string from all substyles
return dedup = concat with duplicate fields removed
merge fields into root vector and remove duplicate fields
if concat_flag set, also return concat (w/ duplicates)
so caller can check for problematic fields, call will free it
so caller can check for problematic fields
------------------------------------------------------------------------- */
char *AtomVecHybrid::merge_fields(int inum, char *root,
int concat_flag, char *&concat_str)
void AtomVecHybrid::merge_fields(std::vector<std::string> &root,
const std::vector<std::string> &fields, int concat_flag,
std::vector<std::string> &concat)
{
// create vector with all words combined
// grow vector with all words combined with dedup and
std::string concat;
if (root) concat += root;
for (int k = 0; k < nstyles; k++) {
if (concat.size() > 0) concat += " ";
concat += fieldstrings[k].fstr[inum];
for (const auto &field : fields) {
if (concat_flag) concat.push_back(field);
if (std::find(root.begin(), root.end(), field) == root.end()) root.push_back(field);
}
if (concat_flag) concat_str = utils::strdup(concat);
// remove duplicate words without changing the order
auto words = Tokenizer(concat, " ").as_vector();
std::vector<std::string> dedup;
for (auto &w : words) {
bool found = false;
for (auto &d : dedup) {
if (w == d) found = true;
}
if (!found) dedup.push_back(w);
}
// create final concatenated, deduped string
concat.clear();
for (auto &d : dedup) {
concat += d;
concat += " ";
}
// remove trailing blank
if (concat.size() > 0) concat.pop_back();
return utils::strdup(concat);
}
/* ----------------------------------------------------------------------
@ -587,16 +489,16 @@ void AtomVecHybrid::build_styles()
{
nallstyles = 0;
#define ATOM_CLASS
#define AtomStyle(key,Class) nallstyles++;
#define AtomStyle(key, Class) nallstyles++;
#include "style_atom.h" // IWYU pragma: keep
#undef AtomStyle
#undef ATOM_CLASS
allstyles = new char*[nallstyles];
allstyles = new char *[nallstyles];
nallstyles = 0;
#define ATOM_CLASS
#define AtomStyle(key,Class) \
#define AtomStyle(key, Class) \
allstyles[nallstyles] = utils::strdup(#key); \
nallstyles++;
#include "style_atom.h" // IWYU pragma: keep
@ -611,6 +513,6 @@ void AtomVecHybrid::build_styles()
int AtomVecHybrid::known_style(char *str)
{
for (int i = 0; i < nallstyles; i++)
if (strcmp(str,allstyles[i]) == 0) return 1;
if (strcmp(str, allstyles[i]) == 0) return 1;
return 0;
}

11
src/atom_vec_hybrid.h
View File

@ -64,23 +64,18 @@ class AtomVecHybrid : public AtomVec {
int pack_data_bonus(double *, int) override;
void write_data_bonus(FILE *, int, double *, int) override;
int property_atom(char *) override;
int property_atom(const std::string &) override;
void pack_property_atom(int, double *, int, int) override;
private:
int nallstyles;
char **allstyles;
int fields_allocated;
struct FieldStrings {
char **fstr;
};
FieldStrings *fieldstrings;
int nstyles_bonus;
class AtomVec **styles_bonus;
char *merge_fields(int, char *, int, char *&);
void merge_fields(std::vector<std::string> &, const std::vector<std::string> &,
int, std::vector<std::string> &);
void build_styles();
int known_style(char *);
};

196
src/atom_vec_line.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -23,12 +22,11 @@
#include "modify.h"
#include <cmath>
#include <cstring>
using namespace LAMMPS_NS;
using namespace MathConst;
using MathConst::MY_PI;
#define EPSILON 0.001
static constexpr double EPSILON = 0.001;
/* ---------------------------------------------------------------------- */
@ -55,18 +53,18 @@ AtomVecLine::AtomVecLine(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "molecule radius rmass omega torque line";
fields_copy = (char *) "molecule radius rmass omega";
fields_comm = (char *) "";
fields_comm_vel = (char *) "omega";
fields_reverse = (char *) "torque";
fields_border = (char *) "molecule radius rmass";
fields_border_vel = (char *) "molecule radius rmass omega";
fields_exchange = (char *) "molecule radius rmass omega";
fields_restart = (char *) "molecule radius rmass omega";
fields_create = (char *) "molecule radius rmass omega line";
fields_data_atom = (char *) "id molecule type line rmass x";
fields_data_vel = (char *) "id v omega";
fields_grow = {"molecule", "radius", "rmass", "omega", "torque", "line"};
fields_copy = {"molecule", "radius", "rmass", "omega"};
fields_comm = {};
fields_comm_vel = {"omega"};
fields_reverse = {"torque"};
fields_border = {"molecule", "radius", "rmass"};
fields_border_vel = {"molecule", "radius", "rmass", "omega"};
fields_exchange = {"molecule", "radius", "rmass", "omega"};
fields_restart = {"molecule", "radius", "rmass", "omega"};
fields_create = {"molecule", "radius", "rmass", "omega", "line"};
fields_data_atom = {"id", "molecule", "type", "line", "rmass", "x"};
fields_data_vel = {"id", "v", "omega"};
setup_fields();
}
@ -85,7 +83,7 @@ void AtomVecLine::init()
AtomVec::init();
if (domain->dimension != 2)
error->all(FLERR,"Atom_style line can only be used in 2d simulations");
error->all(FLERR, "Atom_style line can only be used in 2d simulations");
}
/* ----------------------------------------------------------------------
@ -108,11 +106,9 @@ void AtomVecLine::grow_pointers()
void AtomVecLine::grow_bonus()
{
nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0)
error->one(FLERR,"Per-processor system is too big");
if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big");
bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus),
"atom:bonus");
bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom:bonus");
}
/* ----------------------------------------------------------------------
@ -124,7 +120,7 @@ void AtomVecLine::copy_bonus(int i, int j, int delflag)
// if deleting atom J via delflag and J has bonus data, then delete it
if (delflag && line[j] >= 0) {
copy_bonus_all(nlocal_bonus-1,line[j]);
copy_bonus_all(nlocal_bonus - 1, line[j]);
nlocal_bonus--;
}
@ -143,7 +139,7 @@ void AtomVecLine::copy_bonus(int i, int j, int delflag)
void AtomVecLine::copy_bonus_all(int i, int j)
{
line[bonus[i].ilocal] = j;
memcpy(&bonus[j],&bonus[i],sizeof(Bonus));
memcpy(&bonus[j], &bonus[i], sizeof(Bonus));
}
/* ----------------------------------------------------------------------
@ -164,7 +160,7 @@ void AtomVecLine::clear_bonus()
int AtomVecLine::pack_comm_bonus(int n, int *list, double *buf)
{
int i,j,m;
int i, j, m;
m = 0;
for (i = 0; i < n; i++) {
@ -179,7 +175,7 @@ int AtomVecLine::pack_comm_bonus(int n, int *list, double *buf)
void AtomVecLine::unpack_comm_bonus(int n, int first, double *buf)
{
int i,m,last;
int i, m, last;
m = 0;
last = first + n;
@ -192,12 +188,13 @@ void AtomVecLine::unpack_comm_bonus(int n, int first, double *buf)
int AtomVecLine::pack_border_bonus(int n, int *list, double *buf)
{
int i,j,m;
int i, j, m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
if (line[j] < 0) buf[m++] = ubuf(0).d;
if (line[j] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
buf[m++] = bonus[line[j]].length;
@ -212,13 +209,14 @@ int AtomVecLine::pack_border_bonus(int n, int *list, double *buf)
int AtomVecLine::unpack_border_bonus(int n, int first, double *buf)
{
int i,j,m,last;
int i, j, m, last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
line[i] = (int) ubuf(buf[m++]).i;
if (line[i] == 0) line[i] = -1;
if (line[i] == 0)
line[i] = -1;
else {
j = nlocal_bonus + nghost_bonus;
if (j == nmax_bonus) grow_bonus();
@ -242,7 +240,8 @@ int AtomVecLine::pack_exchange_bonus(int i, double *buf)
{
int m = 0;
if (line[i] < 0) buf[m++] = ubuf(0).d;
if (line[i] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
int j = line[i];
@ -260,7 +259,8 @@ int AtomVecLine::unpack_exchange_bonus(int ilocal, double *buf)
int m = 0;
line[ilocal] = (int) ubuf(buf[m++]).i;
if (line[ilocal] == 0) line[ilocal] = -1;
if (line[ilocal] == 0)
line[ilocal] = -1;
else {
if (nlocal_bonus == nmax_bonus) grow_bonus();
bonus[nlocal_bonus].length = buf[m++];
@ -284,8 +284,10 @@ int AtomVecLine::size_restart_bonus()
int n = 0;
int nlocal = atom->nlocal;
for (i = 0; i < nlocal; i++) {
if (line[i] >= 0) n += size_restart_bonus_one;
else n++;
if (line[i] >= 0)
n += size_restart_bonus_one;
else
n++;
}
return n;
@ -301,7 +303,8 @@ int AtomVecLine::pack_restart_bonus(int i, double *buf)
{
int m = 0;
if (line[i] < 0) buf[m++] = ubuf(0).d;
if (line[i] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
int j = line[i];
@ -321,7 +324,8 @@ int AtomVecLine::unpack_restart_bonus(int ilocal, double *buf)
int m = 0;
line[ilocal] = (int) ubuf(buf[m++]).i;
if (line[ilocal] == 0) line[ilocal] = -1;
if (line[ilocal] == 0)
line[ilocal] = -1;
else {
if (nlocal_bonus == nmax_bonus) grow_bonus();
bonus[nlocal_bonus].length = buf[m++];
@ -339,31 +343,32 @@ int AtomVecLine::unpack_restart_bonus(int ilocal, double *buf)
void AtomVecLine::data_atom_bonus(int m, const std::vector<std::string> &values)
{
if (line[m]) error->one(FLERR,"Assigning line parameters to non-line atom");
if (line[m]) error->one(FLERR, "Assigning line parameters to non-line atom");
if (nlocal_bonus == nmax_bonus) grow_bonus();
int ivalue = 1;
double x1 = utils::numeric(FLERR,values[ivalue++],true,lmp);
double y1 = utils::numeric(FLERR,values[ivalue++],true,lmp);
double x2 = utils::numeric(FLERR,values[ivalue++],true,lmp);
double y2 = utils::numeric(FLERR,values[ivalue++],true,lmp);
double x1 = utils::numeric(FLERR, values[ivalue++], true, lmp);
double y1 = utils::numeric(FLERR, values[ivalue++], true, lmp);
double x2 = utils::numeric(FLERR, values[ivalue++], true, lmp);
double y2 = utils::numeric(FLERR, values[ivalue++], true, lmp);
double dx = x2 - x1;
double dy = y2 - y1;
double length = sqrt(dx*dx + dy*dy);
double length = sqrt(dx * dx + dy * dy);
bonus[nlocal_bonus].length = length;
if (dy >= 0.0) bonus[nlocal_bonus].theta = acos(dx/length);
else bonus[nlocal_bonus].theta = -acos(dx/length);
if (dy >= 0.0)
bonus[nlocal_bonus].theta = acos(dx / length);
else
bonus[nlocal_bonus].theta = -acos(dx / length);
double xc = 0.5*(x1+x2);
double yc = 0.5*(y1+y2);
double xc = 0.5 * (x1 + x2);
double yc = 0.5 * (y1 + y2);
dx = xc - x[m][0];
dy = yc - x[m][1];
double delta = sqrt(dx*dx + dy*dy);
double delta = sqrt(dx * dx + dy * dy);
if (delta/length > EPSILON)
error->one(FLERR,"Inconsistent line segment in data file");
if (delta / length > EPSILON) error->one(FLERR, "Inconsistent line segment in data file");
x[m][0] = xc;
x[m][1] = yc;
@ -385,7 +390,7 @@ void AtomVecLine::data_atom_bonus(int m, const std::vector<std::string> &values)
double AtomVecLine::memory_usage_bonus()
{
double bytes = 0;
bytes += (double)nmax_bonus*sizeof(Bonus);
bytes += (double) nmax_bonus * sizeof(Bonus);
return bytes;
}
@ -398,7 +403,7 @@ void AtomVecLine::create_atom_post(int ilocal)
{
double radius_one = 0.5;
radius[ilocal] = radius_one;
rmass[ilocal] = 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one;
rmass[ilocal] = 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one;
line[ilocal] = -1;
}
@ -410,19 +415,22 @@ void AtomVecLine::create_atom_post(int ilocal)
void AtomVecLine::data_atom_post(int ilocal)
{
line_flag = line[ilocal];
if (line_flag == 0) line_flag = -1;
else if (line_flag == 1) line_flag = 0;
else error->one(FLERR,"Invalid line flag in Atoms section of data file");
if (line_flag == 0)
line_flag = -1;
else if (line_flag == 1)
line_flag = 0;
else
error->one(FLERR, "Invalid line flag in Atoms section of data file");
line[ilocal] = line_flag;
if (rmass[ilocal] <= 0.0)
error->one(FLERR,"Invalid density in Atoms section of data file");
if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file");
if (line_flag < 0) {
double radius_one = 0.5;
radius[ilocal] = radius_one;
rmass[ilocal] *= 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one;
} else radius[ilocal] = 0.0;
rmass[ilocal] *= 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one;
} else
radius[ilocal] = 0.0;
omega[ilocal][0] = 0.0;
omega[ilocal][1] = 0.0;
@ -438,13 +446,16 @@ void AtomVecLine::pack_data_pre(int ilocal)
line_flag = line[ilocal];
rmass_one = rmass[ilocal];
if (line_flag < 0) line[ilocal] = 0;
else line[ilocal] = 1;
if (line_flag < 0)
line[ilocal] = 0;
else
line[ilocal] = 1;
if (line_flag < 0) {
double radius_one = radius[ilocal];
rmass[ilocal] /= 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one;
} else rmass[ilocal] /= bonus[line_flag].length;
rmass[ilocal] /= 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one;
} else
rmass[ilocal] /= bonus[line_flag].length;
}
/* ----------------------------------------------------------------------
@ -464,9 +475,9 @@ void AtomVecLine::pack_data_post(int ilocal)
int AtomVecLine::pack_data_bonus(double *buf, int /*flag*/)
{
int i,j;
double length,theta;
double xc,yc,x1,x2,y1,y2;
int i, j;
double length, theta;
double xc, yc, x1, x2, y1, y2;
double **x = atom->x;
tagint *tag = atom->tag;
@ -482,15 +493,16 @@ int AtomVecLine::pack_data_bonus(double *buf, int /*flag*/)
theta = bonus[j].theta;
xc = x[i][0];
yc = x[i][1];
x1 = xc - 0.5*cos(theta)*length;
y1 = yc - 0.5*sin(theta)*length;
x2 = xc + 0.5*cos(theta)*length;
y2 = yc + 0.5*sin(theta)*length;
x1 = xc - 0.5 * cos(theta) * length;
y1 = yc - 0.5 * sin(theta) * length;
x2 = xc + 0.5 * cos(theta) * length;
y2 = yc + 0.5 * sin(theta) * length;
buf[m++] = x1;
buf[m++] = y1;
buf[m++] = x2;
buf[m++] = y2;
} else m += size_data_bonus;
} else
m += size_data_bonus;
}
return m;
}
@ -503,8 +515,8 @@ void AtomVecLine::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/)
{
int i = 0;
while (i < n) {
fmt::print(fp,"{} {} {} {} {}\n",ubuf(buf[i]).i,
buf[i+1],buf[i+2],buf[i+3],buf[i+4]);
fmt::print(fp, "{} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3],
buf[i + 4]);
i += size_data_bonus;
}
}
@ -525,10 +537,11 @@ void AtomVecLine::set_length(int i, double value)
bonus[nlocal_bonus].ilocal = i;
line[i] = nlocal_bonus++;
} else if (value == 0.0) {
copy_bonus_all(nlocal_bonus-1,line[i]);
copy_bonus_all(nlocal_bonus - 1, line[i]);
nlocal_bonus--;
line[i] = -1;
} else bonus[line[i]].length = value;
} else
bonus[line[i]].length = value;
// also set radius = half of length
// unless value = 0.0, then set diameter = 1.0
@ -536,40 +549,3 @@ void AtomVecLine::set_length(int i, double value)
radius[i] = 0.5 * value;
if (value == 0.0) radius[i] = 0.5;
}
/* ----------------------------------------------------------------------
check consistency of internal Bonus data structure
n = # of atoms in regular structure to check against
------------------------------------------------------------------------- */
/*
void AtomVecLine::consistency_check(int n, char *str)
{
int iflag = 0;
int count = 0;
for (int i = 0; i < n; i++) {
if (line[i] >= 0) {
count++;
if (line[i] >= nlocal_bonus) iflag++;
if (bonus[line[i]].ilocal != i) iflag++;
//if (comm->me == 1 && update->ntimestep == 873)
// printf("CCHK %s: %d %d: %d %d: %d %d\n",
// str,i,n,line[i],nlocal_bonus,bonus[line[i]].ilocal,iflag);
}
}
if (iflag) {
printf("BAD vecline ptrs: %s: %d %d: %d\n",str,comm->me,
update->ntimestep,iflag);
MPI_Abort(world,1);
}
if (count != nlocal_bonus) {
char msg[128];
printf("BAD vecline count: %s: %d %d: %d %d\n",
str,comm->me,update->ntimestep,count,nlocal_bonus);
MPI_Abort(world,1);
}
}
*/

62
src/atom_vec_sphere.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -21,8 +20,6 @@
#include "math_const.h"
#include "modify.h"
#include <cstring>
using namespace LAMMPS_NS;
using namespace MathConst;
@ -34,26 +31,25 @@ AtomVecSphere::AtomVecSphere(LAMMPS *lmp) : AtomVec(lmp)
molecular = Atom::ATOMIC;
atom->sphere_flag = 1;
atom->radius_flag = atom->rmass_flag = atom->omega_flag =
atom->torque_flag = 1;
atom->radius_flag = atom->rmass_flag = atom->omega_flag = atom->torque_flag = 1;
// strings with peratom variables to include in each AtomVec method
// strings cannot contain fields in corresponding AtomVec default strings
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "radius rmass omega torque";
fields_copy = (char *) "radius rmass omega";
fields_comm = (char *) "";
fields_comm_vel = (char *) "omega";
fields_reverse = (char *) "torque";
fields_border = (char *) "radius rmass";
fields_border_vel = (char *) "radius rmass omega";
fields_exchange = (char *) "radius rmass omega";
fields_restart = (char *) "radius rmass omega";
fields_create = (char *) "radius rmass omega";
fields_data_atom = (char *) "id type radius rmass x";
fields_data_vel = (char *) "id v omega";
fields_grow = {"radius", "rmass", "omega", "torque"};
fields_copy = {"radius", "rmass", "omega"};
fields_comm = {};
fields_comm_vel = {"omega"};
fields_reverse = {"torque"};
fields_border = {"radius", "rmass"};
fields_border_vel = {"radius", "rmass", "omega"};
fields_exchange = {"radius", "rmass", "omega"};
fields_restart = {"radius", "rmass", "omega"};
fields_create = {"radius", "rmass", "omega"};
fields_data_atom = {"id", "type", "radius", "rmass", "x"};
fields_data_vel = {"id", "v", "omega"};
}
/* ----------------------------------------------------------------------
@ -63,21 +59,19 @@ AtomVecSphere::AtomVecSphere(LAMMPS *lmp) : AtomVec(lmp)
void AtomVecSphere::process_args(int narg, char **arg)
{
if (narg != 0 && narg != 1)
error->all(FLERR,"Illegal atom_style sphere command");
if (narg != 0 && narg != 1) error->all(FLERR, "Illegal atom_style sphere command");
radvary = 0;
if (narg == 1) {
radvary = utils::numeric(FLERR,arg[0],true,lmp);
if (radvary < 0 || radvary > 1)
error->all(FLERR,"Illegal atom_style sphere command");
radvary = utils::numeric(FLERR, arg[0], true, lmp);
if (radvary < 0 || radvary > 1) error->all(FLERR, "Illegal atom_style sphere command");
}
// dynamic particle radius and mass must be communicated every step
if (radvary) {
fields_comm = (char *) "radius rmass";
fields_comm_vel = (char *) "radius rmass omega";
fields_comm = {"radius", "rmass"};
fields_comm_vel = {"radius", "rmass", "omega"};
}
// delay setting up of fields until now
@ -94,11 +88,10 @@ void AtomVecSphere::init()
// check if optional radvary setting should have been set to 1
for (int i = 0; i < modify->nfix; i++)
if (strcmp(modify->fix[i]->style,"adapt") == 0) {
auto fix = dynamic_cast<FixAdapt *>( modify->fix[i]);
if (strcmp(modify->fix[i]->style, "adapt") == 0) {
auto fix = dynamic_cast<FixAdapt *>(modify->fix[i]);
if (fix->diamflag && radvary == 0)
error->all(FLERR,"Fix adapt changes particle radii "
"but atom_style sphere is not dynamic");
error->all(FLERR, "Fix adapt changes particle radii but atom_style sphere is not dynamic");
}
}
@ -121,7 +114,7 @@ void AtomVecSphere::grow_pointers()
void AtomVecSphere::create_atom_post(int ilocal)
{
radius[ilocal] = 0.5;
rmass[ilocal] = 4.0*MY_PI/3.0 * 0.5*0.5*0.5;
rmass[ilocal] = 4.0 * MY_PI / 3.0 * 0.5 * 0.5 * 0.5;
}
/* ----------------------------------------------------------------------
@ -133,11 +126,9 @@ void AtomVecSphere::data_atom_post(int ilocal)
{
radius_one = 0.5 * atom->radius[ilocal];
radius[ilocal] = radius_one;
if (radius_one > 0.0)
rmass[ilocal] *= 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one;
if (radius_one > 0.0) rmass[ilocal] *= 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one;
if (rmass[ilocal] <= 0.0)
error->one(FLERR,"Invalid density in Atoms section of data file");
if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file");
omega[ilocal][0] = 0.0;
omega[ilocal][1] = 0.0;
@ -154,9 +145,8 @@ void AtomVecSphere::pack_data_pre(int ilocal)
rmass_one = rmass[ilocal];
radius[ilocal] *= 2.0;
if (radius_one!= 0.0)
rmass[ilocal] =
rmass_one / (4.0*MY_PI/3.0 * radius_one*radius_one*radius_one);
if (radius_one != 0.0)
rmass[ilocal] = rmass_one / (4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one);
}
/* ----------------------------------------------------------------------

263
src/atom_vec_tri.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -19,18 +18,17 @@
#include "error.h"
#include "fix.h"
#include "math_const.h"
#include "math_extra.h"
#include "math_eigen.h"
#include "math_extra.h"
#include "memory.h"
#include "modify.h"
#include <cmath>
#include <cstring>
using namespace LAMMPS_NS;
using namespace MathConst;
using MathConst::MY_PI;
#define EPSILON 0.001
static constexpr double EPSILON = 0.001;
/* ---------------------------------------------------------------------- */
@ -58,18 +56,18 @@ AtomVecTri::AtomVecTri(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "molecule radius rmass omega angmom torque tri";
fields_copy = (char *) "molecule radius rmass omega angmom";
fields_comm = (char *) "";
fields_comm_vel = (char *) "omega angmom";
fields_reverse = (char *) "torque";
fields_border = (char *) "molecule radius rmass";
fields_border_vel = (char *) "molecule radius rmass omega";
fields_exchange = (char *) "molecule radius rmass omega angmom";
fields_restart = (char *) "molecule radius rmass omega angmom";
fields_create = (char *) "molecule radius rmass omega angmom tri";
fields_data_atom = (char *) "id molecule type tri rmass x";
fields_data_vel = (char *) "id v omega angmom";
fields_grow = {"molecule", "radius", "rmass", "omega", "angmom", "torque", "tri"};
fields_copy = {"molecule", "radius", "rmass", "omega", "angmom"};
fields_comm = {};
fields_comm_vel = {"omega", "angmom"};
fields_reverse = {"torque"};
fields_border = {"molecule", "radius", "rmass"};
fields_border_vel = {"molecule", "radius", "rmass", "omega"};
fields_exchange = {"molecule", "radius", "rmass", "omega", "angmom"};
fields_restart = {"molecule", "radius", "rmass", "omega", "angmom"};
fields_create = {"molecule", "radius", "rmass", "omega", "angmom", "tri"};
fields_data_atom = {"id", "molecule", "type", "tri", "rmass", "x"};
fields_data_vel = {"id", "v", "omega", "angmom"};
setup_fields();
}
@ -88,7 +86,7 @@ void AtomVecTri::init()
AtomVec::init();
if (domain->dimension != 3)
error->all(FLERR,"Atom_style tri can only be used in 3d simulations");
error->all(FLERR, "Atom_style tri can only be used in 3d simulations");
}
/* ----------------------------------------------------------------------
@ -112,11 +110,9 @@ void AtomVecTri::grow_pointers()
void AtomVecTri::grow_bonus()
{
nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0)
error->one(FLERR,"Per-processor system is too big");
if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big");
bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus),
"atom:bonus");
bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom:bonus");
}
/* ----------------------------------------------------------------------
@ -129,7 +125,7 @@ void AtomVecTri::copy_bonus(int i, int j, int delflag)
// if deleting atom J via delflag and J has bonus data, then delete it
if (delflag && tri[j] >= 0) {
copy_bonus_all(nlocal_bonus-1,tri[j]);
copy_bonus_all(nlocal_bonus - 1, tri[j]);
nlocal_bonus--;
}
@ -148,7 +144,7 @@ void AtomVecTri::copy_bonus(int i, int j, int delflag)
void AtomVecTri::copy_bonus_all(int i, int j)
{
tri[bonus[i].ilocal] = j;
memcpy(&bonus[j],&bonus[i],sizeof(Bonus));
memcpy(&bonus[j], &bonus[i], sizeof(Bonus));
}
/* ----------------------------------------------------------------------
@ -169,7 +165,7 @@ void AtomVecTri::clear_bonus()
int AtomVecTri::pack_comm_bonus(int n, int *list, double *buf)
{
int i,j,m;
int i, j, m;
double *quat;
m = 0;
@ -191,7 +187,7 @@ int AtomVecTri::pack_comm_bonus(int n, int *list, double *buf)
void AtomVecTri::unpack_comm_bonus(int n, int first, double *buf)
{
int i,m,last;
int i, m, last;
double *quat;
m = 0;
@ -211,13 +207,14 @@ void AtomVecTri::unpack_comm_bonus(int n, int first, double *buf)
int AtomVecTri::pack_border_bonus(int n, int *list, double *buf)
{
int i,j,m;
double *quat,*c1,*c2,*c3,*inertia;
int i, j, m;
double *quat, *c1, *c2, *c3, *inertia;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
if (tri[j] < 0) buf[m++] = ubuf(0).d;
if (tri[j] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
quat = bonus[tri[j]].quat;
@ -251,14 +248,15 @@ int AtomVecTri::pack_border_bonus(int n, int *list, double *buf)
int AtomVecTri::unpack_border_bonus(int n, int first, double *buf)
{
int i,j,m,last;
double *quat,*c1,*c2,*c3,*inertia;
int i, j, m, last;
double *quat, *c1, *c2, *c3, *inertia;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
tri[i] = (int) ubuf(buf[m++]).i;
if (tri[i] == 0) tri[i] = -1;
if (tri[i] == 0)
tri[i] = -1;
else {
j = nlocal_bonus + nghost_bonus;
if (j == nmax_bonus) grow_bonus();
@ -301,7 +299,8 @@ int AtomVecTri::pack_exchange_bonus(int i, double *buf)
{
int m = 0;
if (tri[i] < 0) buf[m++] = ubuf(0).d;
if (tri[i] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
int j = tri[i];
@ -338,7 +337,8 @@ int AtomVecTri::unpack_exchange_bonus(int ilocal, double *buf)
int m = 0;
tri[ilocal] = (int) ubuf(buf[m++]).i;
if (tri[ilocal] == 0) tri[ilocal] = -1;
if (tri[ilocal] == 0)
tri[ilocal] = -1;
else {
if (nlocal_bonus == nmax_bonus) grow_bonus();
double *quat = bonus[nlocal_bonus].quat;
@ -381,8 +381,10 @@ int AtomVecTri::size_restart_bonus()
int n = 0;
int nlocal = atom->nlocal;
for (i = 0; i < nlocal; i++) {
if (tri[i] >= 0) n += size_restart_bonus_one;
else n++;
if (tri[i] >= 0)
n += size_restart_bonus_one;
else
n++;
}
return n;
@ -396,7 +398,8 @@ int AtomVecTri::pack_restart_bonus(int i, double *buf)
{
int m = 0;
if (tri[i] < 0) buf[m++] = ubuf(0).d;
if (tri[i] < 0)
buf[m++] = ubuf(0).d;
else {
buf[m++] = ubuf(1).d;
int j = tri[i];
@ -435,7 +438,8 @@ int AtomVecTri::unpack_restart_bonus(int ilocal, double *buf)
int m = 0;
tri[ilocal] = (int) ubuf(buf[m++]).i;
if (tri[ilocal] == 0) tri[ilocal] = -1;
if (tri[ilocal] == 0)
tri[ilocal] = -1;
else {
if (nlocal_bonus == nmax_bonus) grow_bonus();
double *quat = bonus[nlocal_bonus].quat;
@ -472,52 +476,51 @@ int AtomVecTri::unpack_restart_bonus(int ilocal, double *buf)
void AtomVecTri::data_atom_bonus(int m, const std::vector<std::string> &values)
{
if (tri[m]) error->one(FLERR,"Assigning tri parameters to non-tri atom");
if (tri[m]) error->one(FLERR, "Assigning tri parameters to non-tri atom");
if (nlocal_bonus == nmax_bonus) grow_bonus();
double c1[3],c2[3],c3[3];
double c1[3], c2[3], c3[3];
int ivalue = 1;
c1[0] = utils::numeric(FLERR,values[ivalue++],true,lmp);
c1[1] = utils::numeric(FLERR,values[ivalue++],true,lmp);
c1[2] = utils::numeric(FLERR,values[ivalue++],true,lmp);
c2[0] = utils::numeric(FLERR,values[ivalue++],true,lmp);
c2[1] = utils::numeric(FLERR,values[ivalue++],true,lmp);
c2[2] = utils::numeric(FLERR,values[ivalue++],true,lmp);
c3[0] = utils::numeric(FLERR,values[ivalue++],true,lmp);
c3[1] = utils::numeric(FLERR,values[ivalue++],true,lmp);
c3[2] = utils::numeric(FLERR,values[ivalue++],true,lmp);
c1[0] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c1[1] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c1[2] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c2[0] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c2[1] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c2[2] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c3[0] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c3[1] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c3[2] = utils::numeric(FLERR, values[ivalue++], true, lmp);
// check for duplicate points
if (c1[0] == c2[0] && c1[1] == c2[1] && c1[2] == c2[2])
error->one(FLERR,"Invalid shape in Triangles section of data file");
error->one(FLERR, "Invalid shape in Triangles section of data file");
if (c1[0] == c3[0] && c1[1] == c3[1] && c1[2] == c3[2])
error->one(FLERR,"Invalid shape in Triangles section of data file");
error->one(FLERR, "Invalid shape in Triangles section of data file");
if (c2[0] == c3[0] && c2[1] == c3[1] && c2[2] == c3[2])
error->one(FLERR,"Invalid shape in Triangles section of data file");
error->one(FLERR, "Invalid shape in Triangles section of data file");
// size = length of one edge
double c2mc1[3],c3mc1[3];
MathExtra::sub3(c2,c1,c2mc1);
MathExtra::sub3(c3,c1,c3mc1);
double size = MAX(MathExtra::len3(c2mc1),MathExtra::len3(c3mc1));
double c2mc1[3], c3mc1[3];
MathExtra::sub3(c2, c1, c2mc1);
MathExtra::sub3(c3, c1, c3mc1);
double size = MAX(MathExtra::len3(c2mc1), MathExtra::len3(c3mc1));
// centroid = 1/3 of sum of vertices
double centroid[3];
centroid[0] = (c1[0]+c2[0]+c3[0]) / 3.0;
centroid[1] = (c1[1]+c2[1]+c3[1]) / 3.0;
centroid[2] = (c1[2]+c2[2]+c3[2]) / 3.0;
centroid[0] = (c1[0] + c2[0] + c3[0]) / 3.0;
centroid[1] = (c1[1] + c2[1] + c3[1]) / 3.0;
centroid[2] = (c1[2] + c2[2] + c3[2]) / 3.0;
double dx = centroid[0] - x[m][0];
double dy = centroid[1] - x[m][1];
double dz = centroid[2] - x[m][2];
double delta = sqrt(dx*dx + dy*dy + dz*dz);
double delta = sqrt(dx * dx + dy * dy + dz * dz);
if (delta/size > EPSILON)
error->one(FLERR,"Inconsistent triangle in data file");
if (delta / size > EPSILON) error->one(FLERR, "Inconsistent triangle in data file");
x[m][0] = centroid[0];
x[m][1] = centroid[1];
@ -528,29 +531,29 @@ void AtomVecTri::data_atom_bonus(int m, const std::vector<std::string> &values)
// tri area = 0.5 len(U x V), where U,V are edge vectors from one vertex
double c4[3];
MathExtra::sub3(c1,centroid,c4);
MathExtra::sub3(c1, centroid, c4);
radius[m] = MathExtra::lensq3(c4);
MathExtra::sub3(c2,centroid,c4);
radius[m] = MAX(radius[m],MathExtra::lensq3(c4));
MathExtra::sub3(c3,centroid,c4);
radius[m] = MAX(radius[m],MathExtra::lensq3(c4));
MathExtra::sub3(c2, centroid, c4);
radius[m] = MAX(radius[m], MathExtra::lensq3(c4));
MathExtra::sub3(c3, centroid, c4);
radius[m] = MAX(radius[m], MathExtra::lensq3(c4));
radius[m] = sqrt(radius[m]);
double norm[3];
MathExtra::cross3(c2mc1,c3mc1,norm);
MathExtra::cross3(c2mc1, c3mc1, norm);
double area = 0.5 * MathExtra::len3(norm);
rmass[m] *= area;
// inertia = inertia tensor of triangle as 6-vector in Voigt ordering
double inertia[6];
MathExtra::inertia_triangle(c1,c2,c3,rmass[m],inertia);
MathExtra::inertia_triangle(c1, c2, c3, rmass[m], inertia);
// diagonalize inertia tensor via Jacobi rotations
// bonus[].inertia = 3 eigenvalues = principal moments of inertia
// evectors and exzy_space = 3 evectors = principal axes of triangle
double tensor[3][3],evectors[3][3];
double tensor[3][3], evectors[3][3];
tensor[0][0] = inertia[0];
tensor[1][1] = inertia[1];
tensor[2][2] = inertia[2];
@ -558,10 +561,10 @@ void AtomVecTri::data_atom_bonus(int m, const std::vector<std::string> &values)
tensor[0][2] = tensor[2][0] = inertia[4];
tensor[0][1] = tensor[1][0] = inertia[5];
int ierror = MathEigen::jacobi3(tensor,bonus[nlocal_bonus].inertia,evectors);
if (ierror) error->one(FLERR,"Insufficient Jacobi rotations for triangle");
int ierror = MathEigen::jacobi3(tensor, bonus[nlocal_bonus].inertia, evectors);
if (ierror) error->one(FLERR, "Insufficient Jacobi rotations for triangle");
double ex_space[3],ey_space[3],ez_space[3];
double ex_space[3], ey_space[3], ez_space[3];
ex_space[0] = evectors[0][0];
ex_space[1] = evectors[1][0];
ex_space[2] = evectors[2][0];
@ -575,26 +578,23 @@ void AtomVecTri::data_atom_bonus(int m, const std::vector<std::string> &values)
// enforce 3 orthogonal vectors as a right-handed coordinate system
// flip 3rd vector if needed
MathExtra::cross3(ex_space,ey_space,norm);
if (MathExtra::dot3(norm,ez_space) < 0.0) MathExtra::negate3(ez_space);
MathExtra::cross3(ex_space, ey_space, norm);
if (MathExtra::dot3(norm, ez_space) < 0.0) MathExtra::negate3(ez_space);
// create initial quaternion
MathExtra::exyz_to_q(ex_space,ey_space,ez_space,bonus[nlocal_bonus].quat);
MathExtra::exyz_to_q(ex_space, ey_space, ez_space, bonus[nlocal_bonus].quat);
// bonus c1,c2,c3 = displacement of c1,c2,c3 from centroid
// in basis of principal axes
double disp[3];
MathExtra::sub3(c1,centroid,disp);
MathExtra::transpose_matvec(ex_space,ey_space,ez_space,
disp,bonus[nlocal_bonus].c1);
MathExtra::sub3(c2,centroid,disp);
MathExtra::transpose_matvec(ex_space,ey_space,ez_space,
disp,bonus[nlocal_bonus].c2);
MathExtra::sub3(c3,centroid,disp);
MathExtra::transpose_matvec(ex_space,ey_space,ez_space,
disp,bonus[nlocal_bonus].c3);
MathExtra::sub3(c1, centroid, disp);
MathExtra::transpose_matvec(ex_space, ey_space, ez_space, disp, bonus[nlocal_bonus].c1);
MathExtra::sub3(c2, centroid, disp);
MathExtra::transpose_matvec(ex_space, ey_space, ez_space, disp, bonus[nlocal_bonus].c2);
MathExtra::sub3(c3, centroid, disp);
MathExtra::transpose_matvec(ex_space, ey_space, ez_space, disp, bonus[nlocal_bonus].c3);
bonus[nlocal_bonus].ilocal = m;
tri[m] = nlocal_bonus++;
@ -607,7 +607,7 @@ void AtomVecTri::data_atom_bonus(int m, const std::vector<std::string> &values)
double AtomVecTri::memory_usage_bonus()
{
double bytes = 0;
bytes += (double)nmax_bonus*sizeof(Bonus);
bytes += (double) nmax_bonus * sizeof(Bonus);
return bytes;
}
@ -620,7 +620,7 @@ void AtomVecTri::create_atom_post(int ilocal)
{
double radius_one = 0.5;
radius[ilocal] = radius_one;
rmass[ilocal] = 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one;
rmass[ilocal] = 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one;
tri[ilocal] = -1;
}
@ -632,19 +632,22 @@ void AtomVecTri::create_atom_post(int ilocal)
void AtomVecTri::data_atom_post(int ilocal)
{
tri_flag = tri[ilocal];
if (tri_flag == 0) tri_flag = -1;
else if (tri_flag == 1) tri_flag = 0;
else error->one(FLERR,"Invalid tri flag in Atoms section of data file");
if (tri_flag == 0)
tri_flag = -1;
else if (tri_flag == 1)
tri_flag = 0;
else
error->one(FLERR, "Invalid tri flag in Atoms section of data file");
tri[ilocal] = tri_flag;
if (rmass[ilocal] <= 0.0)
error->one(FLERR,"Invalid density in Atoms section of data file");
if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file");
if (tri_flag < 0) {
double radius_one = 0.5;
radius[ilocal] = radius_one;
rmass[ilocal] *= 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one;
} else radius[ilocal] = 0.0;
rmass[ilocal] *= 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one;
} else
radius[ilocal] = 0.0;
omega[ilocal][0] = 0.0;
omega[ilocal][1] = 0.0;
@ -663,17 +666,19 @@ void AtomVecTri::pack_data_pre(int ilocal)
tri_flag = tri[ilocal];
rmass_one = rmass[ilocal];
if (tri_flag < 0) tri[ilocal] = 0;
else tri[ilocal] = 1;
if (tri_flag < 0)
tri[ilocal] = 0;
else
tri[ilocal] = 1;
if (tri_flag < 0) {
double radius_one = radius[ilocal];
rmass[ilocal] /= 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one;
rmass[ilocal] /= 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one;
} else {
double c2mc1[3],c3mc1[3],norm[3];
MathExtra::sub3(bonus[tri_flag].c2,bonus[tri_flag].c1,c2mc1);
MathExtra::sub3(bonus[tri_flag].c3,bonus[tri_flag].c1,c3mc1);
MathExtra::cross3(c2mc1,c3mc1,norm);
double c2mc1[3], c3mc1[3], norm[3];
MathExtra::sub3(bonus[tri_flag].c2, bonus[tri_flag].c1, c2mc1);
MathExtra::sub3(bonus[tri_flag].c3, bonus[tri_flag].c1, c3mc1);
MathExtra::cross3(c2mc1, c3mc1, norm);
double area = 0.5 * MathExtra::len3(norm);
rmass[ilocal] /= area;
}
@ -696,9 +701,9 @@ void AtomVecTri::pack_data_post(int ilocal)
int AtomVecTri::pack_data_bonus(double *buf, int /*flag*/)
{
int i,j;
double xc,yc,zc;
double dc1[3],dc2[3],dc3[3];
int i, j;
double xc, yc, zc;
double dc1[3], dc2[3], dc3[3];
double p[3][3];
double **x = atom->x;
@ -711,10 +716,10 @@ int AtomVecTri::pack_data_bonus(double *buf, int /*flag*/)
if (buf) {
buf[m++] = ubuf(tag[i]).d;
j = tri[i];
MathExtra::quat_to_mat(bonus[j].quat,p);
MathExtra::matvec(p,bonus[j].c1,dc1);
MathExtra::matvec(p,bonus[j].c2,dc2);
MathExtra::matvec(p,bonus[j].c3,dc3);
MathExtra::quat_to_mat(bonus[j].quat, p);
MathExtra::matvec(p, bonus[j].c1, dc1);
MathExtra::matvec(p, bonus[j].c2, dc2);
MathExtra::matvec(p, bonus[j].c3, dc3);
xc = x[i][0];
yc = x[i][1];
zc = x[i][2];
@ -727,7 +732,8 @@ int AtomVecTri::pack_data_bonus(double *buf, int /*flag*/)
buf[m++] = xc + dc3[0];
buf[m++] = yc + dc3[1];
buf[m++] = zc + dc3[2];
} else m += size_data_bonus;
} else
m += size_data_bonus;
}
return m;
}
@ -740,9 +746,8 @@ void AtomVecTri::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/)
{
int i = 0;
while (i < n) {
fmt::print(fp,"{} {} {} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i,
buf[i+1],buf[i+2],buf[i+3],buf[i+4],buf[i+5],buf[i+6],
buf[i+7],buf[i+8],buf[i+9]);
fmt::print(fp, "{} {} {} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2],
buf[i + 3], buf[i + 4], buf[i + 5], buf[i + 6], buf[i + 7], buf[i + 8], buf[i + 9]);
i += size_data_bonus;
}
}
@ -770,24 +775,24 @@ void AtomVecTri::set_equilateral(int i, double size)
quat[1] = 0.0;
quat[2] = 0.0;
quat[3] = 0.0;
c1[0] = -size/2.0;
c1[1] = -sqrt(3.0)/2.0 * size / 3.0;
c1[0] = -size / 2.0;
c1[1] = -sqrt(3.0) / 2.0 * size / 3.0;
c1[2] = 0.0;
c2[0] = size/2.0;
c2[1] = -sqrt(3.0)/2.0 * size / 3.0;
c2[0] = size / 2.0;
c2[1] = -sqrt(3.0) / 2.0 * size / 3.0;
c2[2] = 0.0;
c3[0] = 0.0;
c3[1] = sqrt(3.0)/2.0 * size * 2.0/3.0;
c3[1] = sqrt(3.0) / 2.0 * size * 2.0 / 3.0;
c3[2] = 0.0;
inertia[0] = sqrt(3.0)/96.0 * size*size*size*size;
inertia[1] = sqrt(3.0)/96.0 * size*size*size*size;
inertia[2] = sqrt(3.0)/48.0 * size*size*size*size;
inertia[0] = sqrt(3.0) / 96.0 * size * size * size * size;
inertia[1] = sqrt(3.0) / 96.0 * size * size * size * size;
inertia[2] = sqrt(3.0) / 48.0 * size * size * size * size;
radius[i] = MathExtra::len3(c1);
bonus[nlocal_bonus].ilocal = i;
tri[i] = nlocal_bonus++;
} else if (size == 0.0) {
radius[i] = 0.5;
copy_bonus_all(nlocal_bonus-1,tri[i]);
copy_bonus_all(nlocal_bonus - 1, tri[i]);
nlocal_bonus--;
tri[i] = -1;
} else {
@ -795,18 +800,18 @@ void AtomVecTri::set_equilateral(int i, double size)
double *c2 = bonus[tri[i]].c2;
double *c3 = bonus[tri[i]].c3;
double *inertia = bonus[tri[i]].inertia;
c1[0] = -size/2.0;
c1[1] = -sqrt(3.0)/2.0 * size / 3.0;
c1[0] = -size / 2.0;
c1[1] = -sqrt(3.0) / 2.0 * size / 3.0;
c1[2] = 0.0;
c2[0] = size/2.0;
c2[1] = -sqrt(3.0)/2.0 * size / 3.0;
c2[0] = size / 2.0;
c2[1] = -sqrt(3.0) / 2.0 * size / 3.0;
c2[2] = 0.0;
c3[0] = 0.0;
c3[1] = sqrt(3.0)/2.0 * size * 2.0/3.0;
c3[1] = sqrt(3.0) / 2.0 * size * 2.0 / 3.0;
c3[2] = 0.0;
inertia[0] = sqrt(3.0)/96.0 * size*size*size*size;
inertia[1] = sqrt(3.0)/96.0 * size*size*size*size;
inertia[2] = sqrt(3.0)/48.0 * size*size*size*size;
inertia[0] = sqrt(3.0) / 96.0 * size * size * size * size;
inertia[1] = sqrt(3.0) / 96.0 * size * size * size * size;
inertia[2] = sqrt(3.0) / 48.0 * size * size * size * size;
radius[i] = MathExtra::len3(c1);
}
}