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

76
src/AWPMD/atom_vec_wavepacket.cpp
View File

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

163
src/DIELECTRIC/atom_vec_dielectric.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/ Sandia National Laboratories https://www.lammps.org/ Sandia National Laboratories
@ -18,23 +17,21 @@
#include "citeme.h" #include "citeme.h"
#include <cmath> #include <cmath>
#include <cstring>
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
static const char cite_user_dielectric_package[] = static const char cite_user_dielectric_package[] =
"DIELECTRIC package:\n\n" "DIELECTRIC package:\n\n"
"@Article{TrungCPC19,\n" "@Article{TrungCPC19,\n"
" author = {Trung Dac Nguyen, Honghao Li, Debarshee Bagchi," " author = {Trung Dac Nguyen, Honghao Li, Debarshee Bagchi,"
" Francisco J. Solis, Monica Olvera de la Cruz,\n" " Francisco J. Solis, Monica Olvera de la Cruz,\n"
" title = {Incorporating surface polarization effects into large-scale" " title = {Incorporating surface polarization effects into large-scale"
" coarse-grained Molecular Dynamics simulation},\n" " coarse-grained Molecular Dynamics simulation},\n"
" journal = {Comp.~Phys.~Comm.},\n" " journal = {Comp.~Phys.~Comm.},\n"
" year = 2019,\n" " year = 2019,\n"
" volume = 241,\n" " volume = 241,\n"
" pages = {80--91}\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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) // clang-format off
"q molecule num_bond bond_type bond_atom " fields_grow = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"dihedral_atom3 dihedral_atom4 " "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special",
"num_improper improper_type improper_atom1 improper_atom2 " "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
"improper_atom3 improper_atom4 " fields_copy = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"nspecial special " "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"mu area ed em epsilon curvature q_unscaled"; "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
fields_copy = (char *) "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special",
"q molecule num_bond bond_type bond_atom " "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " fields_comm = {"q", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " fields_comm_vel = {};
"dihedral_atom3 dihedral_atom4 " fields_reverse = {};
"num_improper improper_type improper_atom1 improper_atom2 " fields_border = {"q", "molecule", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
"improper_atom3 improper_atom4 " fields_border_vel = {"q", "molecule", "mu", "area", "ed", "em", "epsilon", "curvature",
"nspecial special " "q_unscaled"};
"mu area ed em epsilon curvature q_unscaled"; fields_exchange = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle",
fields_comm = (char *) "q mu area ed em epsilon curvature q_unscaled"; "angle_type", "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type",
fields_comm_vel = (char *) ""; "dihedral_atom1", "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper",
fields_reverse = (char *) ""; "improper_type", "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4",
fields_border = (char *) "q molecule mu area ed em epsilon curvature q_unscaled"; "nspecial", "special", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
fields_border_vel = (char *) "q molecule mu area ed em epsilon curvature q_unscaled"; fields_restart = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle",
fields_exchange = (char *) "angle_type", "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type",
"q molecule num_bond bond_type bond_atom " "dihedral_atom1", "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper",
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " "improper_type", "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4",
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
"dihedral_atom3 dihedral_atom4 " fields_create = {"q", "molecule", "num_bond", "num_angle", "num_dihedral", "num_improper",
"num_improper improper_type improper_atom1 improper_atom2 " "nspecial", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"};
"improper_atom3 improper_atom4 " fields_data_atom = { "id", "molecule", "type", "q", "x", "mu3", "area", "ed", "em", "epsilon",
"nspecial special " "curvature"};
"mu area ed em epsilon curvature q_unscaled"; fields_data_vel = {"id v"};
fields_restart = (char *) // clang-format on
"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";
setup_fields(); setup_fields();
bond_per_atom = angle_per_atom = dihedral_per_atom = improper_per_atom = 0; 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][1] = 0;
nspecial[ilocal][2] = 0; nspecial[ilocal][2] = 0;
double* q = atom->q; double *q = atom->q;
q_unscaled[ilocal] = q[ilocal]; q_unscaled[ilocal] = q[ilocal];
q[ilocal] /= epsilon[ilocal]; q[ilocal] /= epsilon[ilocal];
double *mu_one = mu[ilocal]; double *mu_one = mu[ilocal];
mu_one[3] = mu_one[3] = sqrt(mu_one[0] * mu_one[0] + mu_one[1] * mu_one[1] + mu_one[2] * mu_one[2]);
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 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 (name == "area") return 0;
if (strcmp(name,"ed") == 0) return 1; if (name == "ed") return 1;
if (strcmp(name,"em") == 0) return 2; if (name == "em") return 2;
if (strcmp(name,"epsilon") == 0) return 3; if (name == "epsilon") return 3;
if (strcmp(name,"curvature") == 0) return 4; if (name == "curvature") return 4;
if (strcmp(name,"q_unscaled") == 0) return 5; if (name == "q_unscaled") return 5;
return -1; return -1;
} }
@ -198,8 +180,7 @@ int AtomVecDielectric::property_atom(char *name)
index maps to data specific to this atom style index maps to data specific to this atom style
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecDielectric::pack_property_atom(int index, double *buf, void AtomVecDielectric::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
int nvalues, int groupbit)
{ {
int *mask = atom->mask; int *mask = atom->mask;
int nlocal = atom->nlocal; int nlocal = atom->nlocal;
@ -207,38 +188,50 @@ void AtomVecDielectric::pack_property_atom(int index, double *buf,
if (index == 0) { if (index == 0) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = area[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = area[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 1) { } else if (index == 1) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = ed[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = ed[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 2) { } else if (index == 2) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = em[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = em[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 3) { } else if (index == 3) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = epsilon[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = epsilon[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 4) { } else if (index == 4) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = curvature[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = curvature[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 5) { } else if (index == 5) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = q_unscaled[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = q_unscaled[i];
else
buf[n] = 0.0;
n += nvalues; 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 create_atom_post(int) override;
void data_atom_post(int) override; void data_atom_post(int) override;
void unpack_restart_init(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; void pack_property_atom(int, double *, int, int) override;
protected: 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "q mu"; fields_grow = {"q", "mu"};
fields_copy = (char *) "q mu"; fields_copy = {"q", "mu"};
fields_comm = (char *) "mu3"; fields_comm = {"mu3"};
fields_comm_vel = (char *) "mu3"; fields_comm_vel = {"mu3"};
fields_reverse = (char *) ""; fields_reverse = {};
fields_border = (char *) "q mu"; fields_border = {"q", "mu"};
fields_border_vel = (char *) "q mu"; fields_border_vel = {"q", "mu"};
fields_exchange = (char *) "q mu"; fields_exchange = {"q", "mu"};
fields_restart = (char *) "q mu"; fields_restart = {"q", "mu"};
fields_create = (char *) "q mu"; fields_create = {"q", "mu"};
fields_data_atom = (char *) "id type q x mu3"; fields_data_atom = {"id", "type", "q", "x", "mu3"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
setup_fields(); setup_fields();
} }
@ -68,6 +67,5 @@ void AtomVecDipole::grow_pointers()
void AtomVecDipole::data_atom_post(int ilocal) void AtomVecDipole::data_atom_post(int ilocal)
{ {
double *mu_one = mu[ilocal]; double *mu_one = mu[ilocal];
mu_one[3] = mu_one[3] = sqrt(mu_one[0] * mu_one[0] + mu_one[1] * mu_one[1] + mu_one[2] * mu_one[2]);
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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "edpd_cv edpd_temp edpd_flux vest vest_temp"; fields_grow = {"edpd_cv", "edpd_temp", "edpd_flux", "vest", "vest_temp"};
fields_copy = (char *) "edpd_cv edpd_temp edpd_flux vest vest_temp"; fields_copy = {"edpd_cv", "edpd_temp", "edpd_flux", "vest", "vest_temp"};
fields_comm = (char *) "edpd_temp vest vest_temp"; fields_comm = {"edpd_temp", "vest", "vest_temp"};
fields_comm_vel = (char *) "edpd_temp vest vest_temp"; fields_comm_vel = {"edpd_temp", "vest", "vest_temp"};
fields_reverse = (char *) "edpd_flux"; fields_reverse = {"edpd_flux"};
fields_border = (char *) "edpd_cv edpd_temp vest vest_temp"; fields_border = {"edpd_cv", "edpd_temp", "vest", "vest_temp"};
fields_border_vel = (char *) "edpd_cv edpd_temp vest vest_temp"; fields_border_vel = {"edpd_cv", "edpd_temp", "vest", "vest_temp"};
fields_exchange = (char *) "edpd_cv edpd_temp vest vest_temp"; fields_exchange = {"edpd_cv", "edpd_temp", "vest", "vest_temp"};
fields_restart = (char * ) "edpd_cv edpd_temp vest vest_temp"; fields_restart = {"edpd_cv", "edpd_temp", "vest", "vest_temp"};
fields_create = (char *) "edpd_cv edpd_temp edpd_flux vest vest_temp"; fields_create = {"edpd_cv", "edpd_temp", "edpd_flux", "vest", "vest_temp"};
fields_data_atom = (char *) "id type edpd_temp edpd_cv x"; fields_data_atom = {"id", "type", "edpd_temp", "edpd_cv", "x"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
setup_fields(); setup_fields();
} }
@ -60,8 +59,7 @@ void AtomVecEDPD::init()
{ {
AtomVec::init(); AtomVec::init();
if (strcmp(update->unit_style,"lj") != 0) if (strcmp(update->unit_style, "lj") != 0) error->all(FLERR, "Atom style edpd requires lj units");
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) 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) void AtomVecEDPD::create_atom_post(int ilocal)
{ {
edpd_temp[ilocal] = 1.0; edpd_temp[ilocal] = 1.0;
edpd_cv[ilocal]= 1.0e5; edpd_cv[ilocal] = 1.0e5;
vest_temp[ilocal] = edpd_temp[ilocal]; 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -13,10 +12,12 @@
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "atom_vec_mdpd.h" #include "atom_vec_mdpd.h"
#include <cstring>
#include "atom.h" #include "atom.h"
#include "update.h"
#include "error.h" #include "error.h"
#include "update.h"
#include <cstring>
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
@ -36,18 +37,18 @@ AtomVecMDPD::AtomVecMDPD(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rho drho vest"; fields_grow = {"rho", "drho", "vest"};
fields_copy = (char *) "rho drho vest"; fields_copy = {"rho", "drho", "vest"};
fields_comm = (char *) "rho vest"; fields_comm = {"rho", "vest"};
fields_comm_vel = (char *) "rho vest"; fields_comm_vel = {"rho", "vest"};
fields_reverse = (char *) "drho"; fields_reverse = {"drho"};
fields_border = (char *) "rho vest"; fields_border = {"rho", "vest"};
fields_border_vel = (char *) "rho vest"; fields_border_vel = {"rho", "vest"};
fields_exchange = (char *) "rho vest"; fields_exchange = {"rho", "vest"};
fields_restart = (char * ) "rho vest"; fields_restart = {"rho", "vest"};
fields_create = (char *) "rho drho vest"; fields_create = {"rho", "drho", "vest"};
fields_data_atom = (char *) "id type rho x"; fields_data_atom = {"id", "type", "rho", "x"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
setup_fields(); setup_fields();
} }
@ -58,8 +59,7 @@ void AtomVecMDPD::init()
{ {
AtomVec::init(); AtomVec::init();
if (strcmp(update->unit_style,"lj") != 0) if (strcmp(update->unit_style, "lj") != 0) error->all(FLERR, "Atom style mdpd requires lj units");
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) 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 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 (name == "rho") return 0;
if (strcmp(name,"drho") == 0) return 1; if (name == "drho") return 1;
return -1; return -1;
} }
@ -114,8 +114,7 @@ int AtomVecMDPD::property_atom(char *name)
index maps to data specific to this atom style index maps to data specific to this atom style
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecMDPD::pack_property_atom(int index, double *buf, void AtomVecMDPD::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
int nvalues, int groupbit)
{ {
int *mask = atom->mask; int *mask = atom->mask;
int nlocal = atom->nlocal; int nlocal = atom->nlocal;
@ -123,14 +122,18 @@ void AtomVecMDPD::pack_property_atom(int index, double *buf,
int n = 0; int n = 0;
if (index == 0) { if (index == 0) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = rho[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = rho[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 1) { } else if (index == 1) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = drho[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = drho[i];
else
buf[n] = 0.0;
n += nvalues; 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 grow_pointers() override;
void force_clear(int, size_t) override; void force_clear(int, size_t) override;
void data_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; void pack_property_atom(int, double *, int, int) override;
private: 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -13,11 +12,12 @@
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "atom_vec_tdpd.h" #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; using namespace LAMMPS_NS;
@ -37,18 +37,18 @@ AtomVecTDPD::AtomVecTDPD(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "cc cc_flux vest"; fields_grow = {"cc", "cc_flux", "vest"};
fields_copy = (char *) "cc vest"; fields_copy = {"cc", "vest"};
fields_comm = (char *) "cc vest"; fields_comm = {"cc", "vest"};
fields_comm_vel = (char *) "cc vest"; fields_comm_vel = {"cc", "vest"};
fields_reverse = (char *) "cc_flux"; fields_reverse = {"cc_flux"};
fields_border = (char *) "cc vest"; fields_border = {"cc", "vest"};
fields_border_vel = (char *) "cc vest"; fields_border_vel = {"cc", "vest"};
fields_exchange = (char *) "cc vest"; fields_exchange = {"cc", "vest"};
fields_restart = (char * ) "cc vest"; fields_restart = {"cc", "vest"};
fields_create = (char *) "cc vest"; fields_create = {"cc", "vest"};
fields_data_atom = (char *) "id type x cc"; fields_data_atom = {"id", "type", "x", "cc"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -58,13 +58,13 @@ AtomVecTDPD::AtomVecTDPD(LAMMPS *lmp) : AtomVec(lmp)
void AtomVecTDPD::process_args(int narg, char **arg) 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; cc_species = atom->cc_species;
atom->add_peratom_change_columns("cc",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_flux", cc_species);
// delay setting up of fields until now // delay setting up of fields until now
@ -77,8 +77,7 @@ void AtomVecTDPD::init()
{ {
AtomVec::init(); AtomVec::init();
if (strcmp(update->unit_style,"lj") != 0) if (strcmp(update->unit_style, "lj") != 0) error->all(FLERR, "Atom style tdpd requires lj units");
error->all(FLERR,"Atom style tdpd requires lj units");
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -92,7 +91,6 @@ void AtomVecTDPD::grow_pointers()
vest = atom->vest; vest = atom->vest;
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
clear extra forces starting at atom N clear extra forces starting at atom N
nbytes = # of bytes to clear for a per-atom vector 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) 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -17,6 +16,7 @@
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "atom_vec_dpd.h" #include "atom_vec_dpd.h"
#include "atom.h" #include "atom.h"
#include "error.h" #include "error.h"
@ -37,18 +37,18 @@ AtomVecDPD::AtomVecDPD(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rho dpdTheta uCond uMech uChem uCG uCGnew duChem"; fields_grow = {"rho", "dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew", "duChem"};
fields_copy = (char *) "dpdTheta uCond uMech uChem uCG uCGnew"; fields_copy = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"};
fields_comm = (char *) "dpdTheta uCond uMech uChem"; fields_comm = {"dpdTheta", "uCond", "uMech", "uChem"};
fields_comm_vel = (char *) "dpdTheta uCond uMech uChem"; fields_comm_vel = {"dpdTheta", "uCond", "uMech", "uChem"};
fields_reverse = (char *) ""; fields_reverse = {};
fields_border = (char *) "dpdTheta uCond uMech uChem uCG uCGnew"; fields_border = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"};
fields_border_vel = (char *) "dpdTheta uCond uMech uChem uCG uCGnew"; fields_border_vel = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"};
fields_exchange = (char *) "dpdTheta uCond uMech uChem uCG uCGnew"; fields_exchange = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"};
fields_restart = (char *) "dpdTheta uCond uMech uChem"; fields_restart = {"dpdTheta", "uCond", "uMech", "uChem"};
fields_create = (char *) "rho dpdTheta uCond uMech uChem uCG uCGnew duChem"; fields_create = {"rho", "dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew", "duChem"};
fields_data_atom = (char *) "id type dpdTheta x"; fields_data_atom = {"id", "type", "dpdTheta", "x"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
setup_fields(); setup_fields();
} }
@ -94,6 +94,5 @@ void AtomVecDPD::data_atom_post(int ilocal)
uCGnew[ilocal] = 0.0; uCGnew[ilocal] = 0.0;
if (dpdTheta[ilocal] <= 0) if (dpdTheta[ilocal] <= 0)
error->one(FLERR,"Internal temperature in Atoms section of date file " error->one(FLERR, "Internal temperature in Atoms section of date file must be > zero");
"must be > zero");
} }

88
src/EFF/atom_vec_electron.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -21,20 +20,19 @@
#include "atom.h" #include "atom.h"
#include "citeme.h" #include "citeme.h"
#include <cstring>
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
static const char cite_user_eff_package[] = static const char cite_user_eff_package[] =
"EFF package:\n\n" "EFF package:\n\n"
"@Article{Jaramillo-Botero11,\n" "@Article{Jaramillo-Botero11,\n"
" author = {A. Jaramillo-Botero, J. Su, A. Qi, W. A. Goddard III},\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 "
" journal = {J.~Comp.~Chem.},\n" "Material Properties and Phenomena in Extreme Environments},\n"
" year = 2011,\n" " journal = {J.~Comp.~Chem.},\n"
" volume = 32,\n" " year = 2011,\n"
" pages = {497--512}\n" " volume = 32,\n"
"}\n\n"; " pages = {497--512}\n"
"}\n\n";
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -47,26 +45,25 @@ AtomVecElectron::AtomVecElectron(LAMMPS *lmp) : AtomVec(lmp)
forceclearflag = 1; forceclearflag = 1;
atom->electron_flag = 1; atom->electron_flag = 1;
atom->q_flag = atom->spin_flag = atom->eradius_flag = atom->q_flag = atom->spin_flag = atom->eradius_flag = atom->ervel_flag = atom->erforce_flag = 1;
atom->ervel_flag = atom->erforce_flag = 1;
// strings with peratom variables to include in each AtomVec method // strings with peratom variables to include in each AtomVec method
// strings cannot contain fields in corresponding AtomVec default strings // strings cannot contain fields in corresponding AtomVec default strings
// order of fields in a string does not matter // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "q spin eradius ervel erforce"; fields_grow = {"q", "spin", "eradius", "ervel", "erforce"};
fields_copy = (char *) "q spin eradius ervel"; fields_copy = {"q", "spin", "eradius", "ervel"};
fields_comm = (char *) "eradius"; fields_comm = {"eradius"};
fields_comm_vel = (char *) "eradius"; fields_comm_vel = {"eradius"};
fields_reverse = (char *) "erforce"; fields_reverse = {"erforce"};
fields_border = (char *) "q spin eradius"; fields_border = {"q", "spin", "eradius"};
fields_border_vel = (char *) "q spin eradius"; fields_border_vel = {"q", "spin", "eradius"};
fields_exchange = (char *) "q spin eradius ervel"; fields_exchange = {"q", "spin", "eradius", "ervel"};
fields_restart = (char *) "q spin eradius ervel"; fields_restart = {"q", "spin", "eradius", "ervel"};
fields_create = (char *) "q spin eradius ervel"; fields_create = {"q", "spin", "eradius", "ervel"};
fields_data_atom = (char *) "id type q spin eradius x"; fields_data_atom = {"id", "type", "q", "spin", "eradius", "x"};
fields_data_vel = (char *) "id v ervel"; fields_data_vel = {"id", "v", "ervel"};
setup_fields(); setup_fields();
} }
@ -91,7 +88,7 @@ void AtomVecElectron::grow_pointers()
void AtomVecElectron::force_clear(int n, size_t nbytes) 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 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 (name == "spin") return 0;
if (strcmp(name,"eradius") == 0) return 1; if (name == "eradius") return 1;
if (strcmp(name,"ervel") == 0) return 2; if (name == "ervel") return 2;
if (strcmp(name,"erforce") == 0) return 3; if (name == "erforce") return 3;
return -1; return -1;
} }
@ -133,8 +130,7 @@ int AtomVecElectron::property_atom(char *name)
index maps to data specific to this atom style index maps to data specific to this atom style
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecElectron::pack_property_atom(int index, double *buf, void AtomVecElectron::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
int nvalues, int groupbit)
{ {
int *mask = atom->mask; int *mask = atom->mask;
int nlocal = atom->nlocal; int nlocal = atom->nlocal;
@ -142,26 +138,34 @@ void AtomVecElectron::pack_property_atom(int index, double *buf,
if (index == 0) { if (index == 0) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = spin[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = spin[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 1) { } else if (index == 1) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = eradius[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = eradius[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 2) { } else if (index == 2) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = ervel[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = ervel[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 3) { } else if (index == 3) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = erforce[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = erforce[i];
else
buf[n] = 0.0;
n += nvalues; 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 force_clear(int, size_t) override;
void create_atom_post(int) override; void create_atom_post(int) override;
void data_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; void pack_property_atom(int, double *, int, int) override;
private: 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; int k,m;
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
fprintf(fp,TAGINT_FORMAT " %d %-1.16e %-1.16e %-1.16e", fmt::print(fp,"{} {} {:.16e} {:.16e} {:.16e}", ubuf(buf[i][0]).i, ubuf(buf[i][1]).i,
(tagint) ubuf(buf[i][0]).i,(int) ubuf(buf[i][1]).i, buf[i][2], buf[i][3], buf[i][4]);
buf[i][2],buf[i][3],buf[i][4]);
m = 5; m = 5;
for (k = 0; k < nstyles; k++) for (k = 0; k < nstyles; k++)
m += styles[k]->write_data_hybrid(fp,&buf[i][m]); m += styles[k]->write_data_hybrid(fp,&buf[i][m]);
fprintf(fp," %d %d %d\n", fmt::print(fp," {} {} {}\n", ubuf(buf[i][m]).i, ubuf(buf[i][m+1]).i, ubuf(buf[i][m+2]).i);
(int) ubuf(buf[i][m]).i,(int) ubuf(buf[i][m+1]).i,
(int) ubuf(buf[i][m+2]).i);
} }
} }
@ -1119,8 +1116,7 @@ void AtomVecHybridKokkos::write_vel(FILE *fp, int n, double **buf)
int k,m; int k,m;
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
fprintf(fp,TAGINT_FORMAT " %g %g %g", fmt::print(fp,"{} {} {} {}", (tagint) ubuf(buf[i][0]).i,buf[i][1],buf[i][2],buf[i][3]);
(tagint) ubuf(buf[i][0]).i,buf[i][1],buf[i][2],buf[i][3]);
m = 4; m = 4;
for (k = 0; k < nstyles; k++) 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 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++) { for (int k = 0; k < nstyles; k++) {
int index = styles[k]->property_atom(name); 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 index maps to data specific to this atom style
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecHybridKokkos::pack_property_atom(int multiindex, double *buf, void AtomVecHybridKokkos::pack_property_atom(int multiindex, double *buf, int nvalues, int groupbit)
int nvalues, int groupbit)
{ {
int k = multiindex % nstyles; int k = multiindex % nstyles;
int index = 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 write_data(FILE *, int, double **) override;
void pack_vel(double **) override; void pack_vel(double **) override;
void write_vel(FILE *, int, 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; void pack_property_atom(int, double *, int, int) override;
double memory_usage() override; double memory_usage() override;

80
src/MACHDYN/atom_vec_smd.cpp
View File

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

26
src/MESONT/atom_vec_mesont.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rmass radius length buckling bond_nt molecule"; fields_grow = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_copy = (char *) "rmass radius length buckling bond_nt molecule"; fields_copy = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_comm = (char *) ""; fields_comm = {};
fields_comm_vel = (char *) ""; fields_comm_vel = {};
fields_reverse = (char *) ""; fields_reverse = {};
fields_border = (char *) "rmass radius length buckling bond_nt molecule"; fields_border = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_border_vel = (char *) "rmass radius length buckling bond_nt molecule"; fields_border_vel = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_exchange = (char *) "rmass radius length buckling bond_nt molecule"; fields_exchange = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_restart = (char *) "rmass radius length buckling bond_nt molecule"; fields_restart = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_create = (char *) "rmass radius length buckling bond_nt molecule"; fields_create = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"};
fields_data_atom = (char *) "id molecule type bond_nt rmass radius length buckling x"; fields_data_atom = {"id", "molecule", "type", "bond_nt", "rmass",
fields_data_vel = (char *) "id v"; "radius", "length", "buckling", "x"};
fields_data_vel = {"id", "v"};
setup_fields(); 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) fields_grow = {"molecule", "num_bond", "bond_type", "bond_atom",
"molecule num_bond bond_type bond_atom " "num_angle", "angle_type", "angle_atom1", "angle_atom2",
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 nspecial special"; "angle_atom3", "nspecial", "special"};
fields_copy = (char *) fields_copy = {"molecule", "num_bond", "bond_type", "bond_atom",
"molecule num_bond bond_type bond_atom " "num_angle", "angle_type", "angle_atom1", "angle_atom2",
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 nspecial special"; "angle_atom3", "nspecial", "special"};
fields_comm = (char *) ""; fields_comm = {};
fields_comm_vel = (char *) ""; fields_comm_vel = {};
fields_reverse = (char *) ""; fields_reverse = {};
fields_border = (char *) "molecule"; fields_border = {"molecule"};
fields_border_vel = (char *) "molecule"; fields_border_vel = {"molecule"};
fields_exchange = (char *) fields_exchange = {"molecule", "num_bond", "bond_type", "bond_atom",
"molecule num_bond bond_type bond_atom " "num_angle", "angle_type", "angle_atom1", "angle_atom2",
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 nspecial special"; "angle_atom3", "nspecial", "special"};
fields_restart = (char *) fields_restart = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle",
"molecule num_bond bond_type bond_atom " "angle_type", "angle_atom1", "angle_atom2", "angle_atom3"};
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3"; fields_create = {"molecule", "num_bond", "num_angle", "nspecial"};
fields_create = (char *) "molecule num_bond num_angle nspecial"; fields_data_atom = {"id", "molecule", "type", "x"};
fields_data_atom = (char *) "id molecule type x"; fields_data_vel = {"id", "v"};
fields_data_vel = (char *) "id v";
setup_fields(); setup_fields();
@ -63,8 +61,8 @@ AtomVecAngle::AtomVecAngle(LAMMPS *lmp) : AtomVec(lmp)
AtomVecAngle::~AtomVecAngle() AtomVecAngle::~AtomVecAngle()
{ {
delete [] bond_negative; delete[] bond_negative;
delete [] angle_negative; delete[] angle_negative;
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -90,12 +88,12 @@ void AtomVecAngle::pack_restart_pre(int ilocal)
// insure negative vectors are needed length // insure negative vectors are needed length
if (bond_per_atom < atom->bond_per_atom) { if (bond_per_atom < atom->bond_per_atom) {
delete [] bond_negative; delete[] bond_negative;
bond_per_atom = atom->bond_per_atom; bond_per_atom = atom->bond_per_atom;
bond_negative = new int[bond_per_atom]; bond_negative = new int[bond_per_atom];
} }
if (angle_per_atom < atom->angle_per_atom) { if (angle_per_atom < atom->angle_per_atom) {
delete [] angle_negative; delete[] angle_negative;
angle_per_atom = atom->angle_per_atom; angle_per_atom = atom->angle_per_atom;
angle_negative = new int[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_negative[m] = 1;
bond_type[ilocal][m] = -bond_type[ilocal][m]; bond_type[ilocal][m] = -bond_type[ilocal][m];
any_bond_negative = 1; any_bond_negative = 1;
} else bond_negative[m] = 0; } else
bond_negative[m] = 0;
} }
any_angle_negative = 0; any_angle_negative = 0;
@ -117,7 +116,8 @@ void AtomVecAngle::pack_restart_pre(int ilocal)
angle_negative[m] = 1; angle_negative[m] = 1;
angle_type[ilocal][m] = -angle_type[ilocal][m]; angle_type[ilocal][m] = -angle_type[ilocal][m];
any_angle_negative = 1; 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) fields_grow = {"molecule", "num_bond", "bond_type", "bond_atom", "nspecial", "special"};
"molecule num_bond bond_type bond_atom nspecial special"; fields_copy = {"molecule", "num_bond", "bond_type", "bond_atom", "nspecial", "special"};
fields_copy = (char *) fields_comm = {};
"molecule num_bond bond_type bond_atom nspecial special"; fields_comm_vel = {};
fields_comm = (char *) ""; fields_reverse = {};
fields_comm_vel = (char *) ""; fields_border = {"molecule"};
fields_reverse = (char *) ""; fields_border_vel = {"molecule"};
fields_border = (char *) "molecule"; fields_exchange = {"molecule", "num_bond", "bond_type", "bond_atom", "nspecial", "special"};
fields_border_vel = (char *) "molecule"; fields_restart = {"molecule", "num_bond", "bond_type", "bond_atom"};
fields_exchange = (char *) fields_create = {"molecule", "num_bond", "nspecial"};
"molecule num_bond bond_type bond_atom nspecial special"; fields_data_atom = {"id", "molecule", "type", "x"};
fields_restart = (char *) "molecule num_bond bond_type bond_atom"; fields_data_vel = {"id", "v"};
fields_create = (char *) "molecule num_bond nspecial";
fields_data_atom = (char *) "id molecule type x";
fields_data_vel = (char *) "id v";
setup_fields(); setup_fields();
@ -58,7 +54,7 @@ AtomVecBond::AtomVecBond(LAMMPS *lmp) : AtomVec(lmp)
AtomVecBond::~AtomVecBond() 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 // insure bond_negative vector is needed length
if (bond_per_atom < atom->bond_per_atom) { if (bond_per_atom < atom->bond_per_atom) {
delete [] bond_negative; delete[] bond_negative;
bond_per_atom = atom->bond_per_atom; bond_per_atom = atom->bond_per_atom;
bond_negative = new int[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_negative[m] = 1;
bond_type[ilocal][m] = -bond_type[ilocal][m]; bond_type[ilocal][m] = -bond_type[ilocal][m];
any_bond_negative = 1; 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) // clang-format off
"q molecule num_bond bond_type bond_atom " fields_grow = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"dihedral_atom3 dihedral_atom4 " "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
"num_improper improper_type improper_atom1 improper_atom2 " fields_copy = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"improper_atom3 improper_atom4 " "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"nspecial special"; "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
fields_copy = (char *) "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
"q molecule num_bond bond_type bond_atom " fields_comm = {};
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " fields_comm_vel = {};
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " fields_reverse = {};
"dihedral_atom3 dihedral_atom4 " fields_border = {"q", "molecule"};
"num_improper improper_type improper_atom1 improper_atom2 " fields_border_vel = {"q", "molecule"};
"improper_atom3 improper_atom4 " fields_exchange = {"q", "molecule", "num_bond", "bond_type", "bond_atom",
"nspecial special"; "num_angle", "angle_type", "angle_atom1", "angle_atom2", "angle_atom3",
fields_comm = (char *) ""; "num_dihedral", "dihedral_type", "dihedral_atom1", "dihedral_atom2",
fields_comm_vel = (char *) ""; "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", "improper_atom1",
fields_reverse = (char *) ""; "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
fields_border = (char *) "q molecule"; fields_restart = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle",
fields_border_vel = (char *) "q molecule"; "angle_type", "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type",
fields_exchange = (char *) "dihedral_atom1", "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper",
"q molecule num_bond bond_type bond_atom " "improper_type", "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4"};
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " fields_create = {"q", "molecule", "num_bond", "num_angle",
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " "num_dihedral", "num_improper", "nspecial"};
"dihedral_atom3 dihedral_atom4 " fields_data_atom = {"id", "molecule", "type", "q", "x"};
"num_improper improper_type improper_atom1 improper_atom2 " fields_data_vel = {"id", "v"};
"improper_atom3 improper_atom4 " // clang-format on
"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";
setup_fields(); setup_fields();
bond_per_atom = angle_per_atom = dihedral_per_atom = improper_per_atom = 0; 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() AtomVecFull::~AtomVecFull()
{ {
delete [] bond_negative; delete[] bond_negative;
delete [] angle_negative; delete[] angle_negative;
delete [] dihedral_negative; delete[] dihedral_negative;
delete [] improper_negative; delete[] improper_negative;
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -116,22 +102,22 @@ void AtomVecFull::pack_restart_pre(int ilocal)
// insure negative vectors are needed length // insure negative vectors are needed length
if (bond_per_atom < atom->bond_per_atom) { if (bond_per_atom < atom->bond_per_atom) {
delete [] bond_negative; delete[] bond_negative;
bond_per_atom = atom->bond_per_atom; bond_per_atom = atom->bond_per_atom;
bond_negative = new int[bond_per_atom]; bond_negative = new int[bond_per_atom];
} }
if (angle_per_atom < atom->angle_per_atom) { if (angle_per_atom < atom->angle_per_atom) {
delete [] angle_negative; delete[] angle_negative;
angle_per_atom = atom->angle_per_atom; angle_per_atom = atom->angle_per_atom;
angle_negative = new int[angle_per_atom]; angle_negative = new int[angle_per_atom];
} }
if (dihedral_per_atom < atom->dihedral_per_atom) { if (dihedral_per_atom < atom->dihedral_per_atom) {
delete [] dihedral_negative; delete[] dihedral_negative;
dihedral_per_atom = atom->dihedral_per_atom; dihedral_per_atom = atom->dihedral_per_atom;
dihedral_negative = new int[dihedral_per_atom]; dihedral_negative = new int[dihedral_per_atom];
} }
if (improper_per_atom < atom->improper_per_atom) { if (improper_per_atom < atom->improper_per_atom) {
delete [] improper_negative; delete[] improper_negative;
improper_per_atom = atom->improper_per_atom; improper_per_atom = atom->improper_per_atom;
improper_negative = new int[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_negative[m] = 1;
bond_type[ilocal][m] = -bond_type[ilocal][m]; bond_type[ilocal][m] = -bond_type[ilocal][m];
any_bond_negative = 1; any_bond_negative = 1;
} else bond_negative[m] = 0; } else
bond_negative[m] = 0;
} }
any_angle_negative = 0; any_angle_negative = 0;
@ -153,7 +140,8 @@ void AtomVecFull::pack_restart_pre(int ilocal)
angle_negative[m] = 1; angle_negative[m] = 1;
angle_type[ilocal][m] = -angle_type[ilocal][m]; angle_type[ilocal][m] = -angle_type[ilocal][m];
any_angle_negative = 1; any_angle_negative = 1;
} else angle_negative[m] = 0; } else
angle_negative[m] = 0;
} }
any_dihedral_negative = 0; any_dihedral_negative = 0;
@ -162,7 +150,8 @@ void AtomVecFull::pack_restart_pre(int ilocal)
dihedral_negative[m] = 1; dihedral_negative[m] = 1;
dihedral_type[ilocal][m] = -dihedral_type[ilocal][m]; dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
any_dihedral_negative = 1; any_dihedral_negative = 1;
} else dihedral_negative[m] = 0; } else
dihedral_negative[m] = 0;
} }
any_improper_negative = 0; any_improper_negative = 0;
@ -171,7 +160,8 @@ void AtomVecFull::pack_restart_pre(int ilocal)
improper_negative[m] = 1; improper_negative[m] = 1;
improper_type[ilocal][m] = -improper_type[ilocal][m]; improper_type[ilocal][m] = -improper_type[ilocal][m];
any_improper_negative = 1; 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) { if (any_dihedral_negative) {
for (int m = 0; m < num_dihedral[ilocal]; m++) for (int m = 0; m < num_dihedral[ilocal]; m++)
if (dihedral_negative[m]) if (dihedral_negative[m]) dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
} }
if (any_improper_negative) { if (any_improper_negative) {
for (int m = 0; m < num_improper[ilocal]; m++) for (int m = 0; m < num_improper[ilocal]; m++)
if (improper_negative[m]) if (improper_negative[m]) improper_type[ilocal][m] = -improper_type[ilocal][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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) // clang-format off
"molecule num_bond bond_type bond_atom " fields_grow = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
"dihedral_atom3 dihedral_atom4 " "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
"num_improper improper_type improper_atom1 improper_atom2 " fields_copy = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"improper_atom3 improper_atom4 " "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
"nspecial special"; "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
fields_copy = (char *) "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
"molecule num_bond bond_type bond_atom " fields_comm = {};
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " fields_comm_vel = {};
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " fields_reverse = {};
"dihedral_atom3 dihedral_atom4 " fields_border = {"molecule"};
"num_improper improper_type improper_atom1 improper_atom2 " fields_border_vel = {"molecule"};
"improper_atom3 improper_atom4 " fields_exchange = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
"nspecial special"; "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
fields_comm = (char *) ""; "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
fields_comm_vel = (char *) ""; "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"};
fields_reverse = (char *) ""; fields_restart = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type",
fields_border = (char *) "molecule"; "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1",
fields_border_vel = (char *) "molecule"; "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type",
fields_exchange = (char *) "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4"};
"molecule num_bond bond_type bond_atom " fields_create = {"molecule", "num_bond", "num_angle", "num_dihedral", "num_improper", "nspecial"};
"num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " fields_data_atom = {"id", "molecule", "type", "x"};
"num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " fields_data_vel = {"id", "v"};
"dihedral_atom3 dihedral_atom4 " // clang-format on
"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";
setup_fields(); setup_fields();
@ -83,10 +68,10 @@ AtomVecMolecular::AtomVecMolecular(LAMMPS *lmp) : AtomVec(lmp)
AtomVecMolecular::~AtomVecMolecular() AtomVecMolecular::~AtomVecMolecular()
{ {
delete [] bond_negative; delete[] bond_negative;
delete [] angle_negative; delete[] angle_negative;
delete [] dihedral_negative; delete[] dihedral_negative;
delete [] improper_negative; delete[] improper_negative;
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -116,22 +101,22 @@ void AtomVecMolecular::pack_restart_pre(int ilocal)
// insure negative vectors are needed length // insure negative vectors are needed length
if (bond_per_atom < atom->bond_per_atom) { if (bond_per_atom < atom->bond_per_atom) {
delete [] bond_negative; delete[] bond_negative;
bond_per_atom = atom->bond_per_atom; bond_per_atom = atom->bond_per_atom;
bond_negative = new int[bond_per_atom]; bond_negative = new int[bond_per_atom];
} }
if (angle_per_atom < atom->angle_per_atom) { if (angle_per_atom < atom->angle_per_atom) {
delete [] angle_negative; delete[] angle_negative;
angle_per_atom = atom->angle_per_atom; angle_per_atom = atom->angle_per_atom;
angle_negative = new int[angle_per_atom]; angle_negative = new int[angle_per_atom];
} }
if (dihedral_per_atom < atom->dihedral_per_atom) { if (dihedral_per_atom < atom->dihedral_per_atom) {
delete [] dihedral_negative; delete[] dihedral_negative;
dihedral_per_atom = atom->dihedral_per_atom; dihedral_per_atom = atom->dihedral_per_atom;
dihedral_negative = new int[dihedral_per_atom]; dihedral_negative = new int[dihedral_per_atom];
} }
if (improper_per_atom < atom->improper_per_atom) { if (improper_per_atom < atom->improper_per_atom) {
delete [] improper_negative; delete[] improper_negative;
improper_per_atom = atom->improper_per_atom; improper_per_atom = atom->improper_per_atom;
improper_negative = new int[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_negative[m] = 1;
bond_type[ilocal][m] = -bond_type[ilocal][m]; bond_type[ilocal][m] = -bond_type[ilocal][m];
any_bond_negative = 1; any_bond_negative = 1;
} else bond_negative[m] = 0; } else
bond_negative[m] = 0;
} }
any_angle_negative = 0; any_angle_negative = 0;
@ -153,7 +139,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal)
angle_negative[m] = 1; angle_negative[m] = 1;
angle_type[ilocal][m] = -angle_type[ilocal][m]; angle_type[ilocal][m] = -angle_type[ilocal][m];
any_angle_negative = 1; any_angle_negative = 1;
} else angle_negative[m] = 0; } else
angle_negative[m] = 0;
} }
any_dihedral_negative = 0; any_dihedral_negative = 0;
@ -162,7 +149,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal)
dihedral_negative[m] = 1; dihedral_negative[m] = 1;
dihedral_type[ilocal][m] = -dihedral_type[ilocal][m]; dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
any_dihedral_negative = 1; any_dihedral_negative = 1;
} else dihedral_negative[m] = 0; } else
dihedral_negative[m] = 0;
} }
any_improper_negative = 0; any_improper_negative = 0;
@ -171,7 +159,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal)
improper_negative[m] = 1; improper_negative[m] = 1;
improper_type[ilocal][m] = -improper_type[ilocal][m]; improper_type[ilocal][m] = -improper_type[ilocal][m];
any_improper_negative = 1; 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) { if (any_dihedral_negative) {
for (int m = 0; m < num_dihedral[ilocal]; m++) for (int m = 0; m < num_dihedral[ilocal]; m++)
if (dihedral_negative[m]) if (dihedral_negative[m]) dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
dihedral_type[ilocal][m] = -dihedral_type[ilocal][m];
} }
if (any_improper_negative) { if (any_improper_negative) {
for (int m = 0; m < num_improper[ilocal]; m++) for (int m = 0; m < num_improper[ilocal]; m++)
if (improper_negative[m]) if (improper_negative[m]) improper_type[ilocal][m] = -improper_type[ilocal][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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories 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 // order of fields in the string does not matter
// except fields_data_atom and fields_data_vel which must match data file // except fields_data_atom and fields_data_vel which must match data file
fields_grow = (char *) "molecule molindex molatom"; fields_grow = {"molecule", "molindex", "molatom"};
fields_copy = (char *) "molecule molindex molatom"; fields_copy = {"molecule", "molindex", "molatom"};
fields_comm = (char *) ""; fields_comm = {};
fields_comm_vel = (char *) ""; fields_comm_vel = {};
fields_reverse = (char *) ""; fields_reverse = {};
fields_border = (char *) "molecule molindex molatom"; fields_border = {"molecule", "molindex", "molatom"};
fields_border_vel = (char *) "molecule molindex molatom"; fields_border_vel = {"molecule", "molindex", "molatom"};
fields_exchange = (char *) "molecule molindex molatom"; fields_exchange = {"molecule", "molindex", "molatom"};
fields_restart = (char *) "molecule molindex molatom"; fields_restart = {"molecule", "molindex", "molatom"};
fields_create = (char *) "molecule molindex molatom"; fields_create = {"molecule", "molindex", "molatom"};
fields_data_atom = (char *) "id molecule molindex molatom type x"; fields_data_atom = {"id", "molecule", "molindex", "molatom", "type", "x"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
setup_fields(); setup_fields();
} }
@ -58,11 +57,10 @@ AtomVecTemplate::AtomVecTemplate(LAMMPS *lmp) : AtomVec(lmp)
void AtomVecTemplate::process_args(int narg, char **arg) 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]); int imol = atom->find_molecule(arg[0]);
if (imol == -1) error->all(FLERR,"Molecule template ID for " if (imol == -1) error->all(FLERR, "Molecule template ID for atom_style template does not exist");
"atom_style template does not exist");
onemols = &atom->molecules[imol]; onemols = &atom->molecules[imol];
nset = atom->molecules[imol]->nset; 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 // do this here b/c data file will typically not contain these settings
for (int i = 0; i < nset; i++) { for (int i = 0; i < nset; i++) {
atom->nbondtypes = MAX(atom->nbondtypes,onemols[i]->nbondtypes); atom->nbondtypes = MAX(atom->nbondtypes, onemols[i]->nbondtypes);
atom->nangletypes = MAX(atom->nangletypes,onemols[i]->nangletypes); atom->nangletypes = MAX(atom->nangletypes, onemols[i]->nangletypes);
atom->ndihedraltypes = MAX(atom->ndihedraltypes,onemols[i]->ndihedraltypes); atom->ndihedraltypes = MAX(atom->ndihedraltypes, onemols[i]->ndihedraltypes);
atom->nimpropertypes = MAX(atom->nimpropertypes,onemols[i]->nimpropertypes); atom->nimpropertypes = MAX(atom->nimpropertypes, onemols[i]->nimpropertypes);
} }
} }
@ -129,7 +127,6 @@ void AtomVecTemplate::pack_data_post(int ilocal)
molatom[ilocal]--; molatom[ilocal]--;
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
modify what AtomVec::data_atom() just unpacked modify what AtomVec::data_atom() just unpacked
or initialize other atom quantities or initialize other atom quantities
@ -141,7 +138,7 @@ void AtomVecTemplate::data_atom_post(int ilocal)
int molatom_one = --molatom[ilocal]; int molatom_one = --molatom[ilocal];
if ((molindex_one < -1) || (molindex_one >= nset)) 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))) 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");
} }

68
src/PERI/atom_vec_peri.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -23,20 +22,19 @@
#include "error.h" #include "error.h"
#include <cfloat> #include <cfloat>
#include <cstring>
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
static const char cite_peri_package[] = static const char cite_peri_package[] =
"PERI package for Peridynamics:\n\n" "PERI package for Peridynamics:\n\n"
"@Article{Parks08,\n" "@Article{Parks08,\n"
" author = {M. L. Parks, R. B. Lehoucq, S. J. Plimpton, S. A. Silling},\n" " author = {M. L. Parks, R. B. Lehoucq, S. J. Plimpton, S. A. Silling},\n"
" title = {Implementing peridynamics within a molecular dynamics code},\n" " title = {Implementing peridynamics within a molecular dynamics code},\n"
" journal = {Comp.~Phys.~Comm.},\n" " journal = {Comp.~Phys.~Comm.},\n"
" year = 2008,\n" " year = 2008,\n"
" volume = 179,\n" " volume = 179,\n"
" pages = {777--783}\n" " pages = {777--783}\n"
"}\n\n"; "}\n\n";
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -55,18 +53,18 @@ AtomVecPeri::AtomVecPeri(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rmass vfrac s0 x0"; fields_grow = {"rmass", "vfrac", "s0", "x0"};
fields_copy = (char *) "rmass vfrac s0 x0"; fields_copy = {"rmass", "vfrac", "s0", "x0"};
fields_comm = (char *) "s0"; fields_comm = {"s0"};
fields_comm_vel = (char *) "s0"; fields_comm_vel = {"s0"};
fields_reverse = (char *) ""; fields_reverse = {};
fields_border = (char *) "rmass vfrac s0 x0"; fields_border = {"rmass", "vfrac", "s0", "x0"};
fields_border_vel = (char *) "rmass vfrac s0 x0"; fields_border_vel = {"rmass", "vfrac", "s0", "x0"};
fields_exchange = (char *) "rmass vfrac s0 x0"; fields_exchange = {"rmass", "vfrac", "s0", "x0"};
fields_restart = (char *) "rmass vfrac s0 x0"; fields_restart = {"rmass", "vfrac", "s0", "x0"};
fields_create = (char *) "rmass vfrac s0 x0"; fields_create = {"rmass", "vfrac", "s0", "x0"};
fields_data_atom = (char *) "id type vfrac rmass x"; fields_data_atom = {"id", "type", "vfrac", "rmass", "x"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
setup_fields(); setup_fields();
} }
@ -110,8 +108,7 @@ void AtomVecPeri::data_atom_post(int ilocal)
x0[ilocal][1] = x[ilocal][1]; x0[ilocal][1] = x[ilocal][1];
x0[ilocal][2] = x[ilocal][2]; x0[ilocal][2] = x[ilocal][2];
if (rmass[ilocal] <= 0.0) if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid mass in Atoms section of data file");
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 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 (name == "vfrac") return 0;
if (strcmp(name,"s0") == 0) return 1; if (name == "s0") return 1;
return -1; return -1;
} }
@ -131,8 +128,7 @@ int AtomVecPeri::property_atom(char *name)
index maps to data specific to this atom style index maps to data specific to this atom style
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecPeri::pack_property_atom(int index, double *buf, void AtomVecPeri::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
int nvalues, int groupbit)
{ {
int *mask = atom->mask; int *mask = atom->mask;
int nlocal = atom->nlocal; int nlocal = atom->nlocal;
@ -140,14 +136,18 @@ void AtomVecPeri::pack_property_atom(int index, double *buf,
if (index == 0) { if (index == 0) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = vfrac[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = vfrac[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 1) { } else if (index == 1) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = s0[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = s0[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} }

2
src/PERI/atom_vec_peri.h
View File

@ -31,7 +31,7 @@ class AtomVecPeri : public AtomVec {
void grow_pointers() override; void grow_pointers() override;
void create_atom_post(int) override; void create_atom_post(int) override;
void data_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; void pack_property_atom(int, double *, int, int) override;
private: 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -16,8 +15,6 @@
#include "atom.h" #include "atom.h"
#include <cstring>
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -38,18 +35,18 @@ AtomVecSPH::AtomVecSPH(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rho drho esph desph cv vest"; fields_grow = {"rho", "drho", "esph", "desph", "cv", "vest"};
fields_copy = (char *) "rho drho esph desph cv vest"; fields_copy = {"rho", "drho", "esph", "desph", "cv", "vest"};
fields_comm = (char *) "rho esph vest"; fields_comm = {"rho", "esph", "vest"};
fields_comm_vel = (char *) "rho esph vest"; fields_comm_vel = {"rho", "esph", "vest"};
fields_reverse = (char *) "drho desph"; fields_reverse = {"drho", "desph"};
fields_border = (char *) "rho esph cv vest"; fields_border = {"rho", "esph", "cv", "vest"};
fields_border_vel = (char *) "rho esph cv vest"; fields_border_vel = {"rho", "esph", "cv", "vest"};
fields_exchange = (char *) "rho esph cv vest"; fields_exchange = {"rho", "esph", "cv", "vest"};
fields_restart = (char * ) "rho esph cv vest"; fields_restart = {"rho", "esph", "cv", "vest"};
fields_create = (char *) "rho esph cv vest desph drho"; fields_create = {"rho", "esph", "cv", "vest", "desph", "drho"};
fields_data_atom = (char *) "id type rho esph cv x"; fields_data_atom = {"id", "type", "rho", "esph", "cv", "x"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
setup_fields(); setup_fields();
} }
@ -76,8 +73,8 @@ void AtomVecSPH::grow_pointers()
void AtomVecSPH::force_clear(int n, size_t nbytes) void AtomVecSPH::force_clear(int n, size_t nbytes)
{ {
memset(&desph[n],0,nbytes); memset(&desph[n], 0, nbytes);
memset(&drho[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 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 (name == "rho") return 0;
if (strcmp(name,"drho") == 0) return 1; if (name == "drho") return 1;
if (strcmp(name,"esph") == 0) return 2; if (name == "esph") return 2;
if (strcmp(name,"desph") == 0) return 3; if (name == "desph") return 3;
if (strcmp(name,"cv") == 0) return 4; if (name == "cv") return 4;
return -1; return -1;
} }
@ -123,8 +120,7 @@ int AtomVecSPH::property_atom(char *name)
index maps to data specific to this atom style index maps to data specific to this atom style
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecSPH::pack_property_atom(int index, double *buf, void AtomVecSPH::pack_property_atom(int index, double *buf, int nvalues, int groupbit)
int nvalues, int groupbit)
{ {
int *mask = atom->mask; int *mask = atom->mask;
int nlocal = atom->nlocal; int nlocal = atom->nlocal;
@ -132,32 +128,42 @@ void AtomVecSPH::pack_property_atom(int index, double *buf,
if (index == 0) { if (index == 0) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = rho[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = rho[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 1) { } else if (index == 1) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = drho[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = drho[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 2) { } else if (index == 2) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = esph[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = esph[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 3) { } else if (index == 3) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = desph[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = desph[i];
else
buf[n] = 0.0;
n += nvalues; n += nvalues;
} }
} else if (index == 4) { } else if (index == 4) {
for (int i = 0; i < nlocal; i++) { for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = cv[i]; if (mask[i] & groupbit)
else buf[n] = 0.0; buf[n] = cv[i];
else
buf[n] = 0.0;
n += nvalues; 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 force_clear(int, size_t) override;
void create_atom_post(int) override; void create_atom_post(int) override;
void data_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; void pack_property_atom(int, double *, int, int) override;
private: 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
@ -25,10 +24,11 @@
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "atom_vec_spin.h" #include "atom_vec_spin.h"
#include <cmath>
#include <cstring>
#include "atom.h" #include "atom.h"
#include <cmath>
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -46,18 +46,18 @@ AtomVecSpin::AtomVecSpin(LAMMPS *lmp) : AtomVec(lmp)
// order of fields in a string does not matter // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "sp fm fm_long"; fields_grow = {"sp", "fm", "fm_long"};
fields_copy = (char *) "sp"; fields_copy = {"sp"};
fields_comm = (char *) "sp"; fields_comm = {"sp"};
fields_comm_vel = (char *) "sp"; fields_comm_vel = {"sp"};
fields_reverse = (char *) "fm fm_long"; fields_reverse = {"fm", "fm_long"};
fields_border = (char *) "sp"; fields_border = {"sp"};
fields_border_vel = (char *) "sp"; fields_border_vel = {"sp"};
fields_exchange = (char *) "sp"; fields_exchange = {"sp"};
fields_restart = (char *) "sp"; fields_restart = {"sp"};
fields_create = (char *) "sp"; fields_create = {"sp"};
fields_data_atom = (char *) "id type x sp"; fields_data_atom = {"id", "type", "x", "sp"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
setup_fields(); setup_fields();
} }
@ -82,8 +82,8 @@ void AtomVecSpin::grow_pointers()
void AtomVecSpin::force_clear(int n, size_t nbytes) void AtomVecSpin::force_clear(int n, size_t nbytes)
{ {
memset(&fm[n][0],0,3*nbytes); memset(&fm[n][0], 0, 3 * nbytes);
memset(&fm_long[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) void AtomVecSpin::data_atom_post(int ilocal)
{ {
double *sp_one = sp[ilocal]; double *sp_one = sp[ilocal];
double norm = double norm = 1.0 / sqrt(sp_one[0] * sp_one[0] + sp_one[1] * sp_one[1] + sp_one[2] * sp_one[2]);
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[0] *= norm;
sp_one[1] *= norm; sp_one[1] *= norm;
sp_one[2] *= norm; sp_one[2] *= norm;

943
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 // additional list of peratom fields operated on by different methods
// set or created by child styles // set or created by child styles
char *fields_grow, *fields_copy; std::vector<std::string> fields_grow, fields_copy, fields_comm, fields_comm_vel;
char *fields_comm, *fields_comm_vel, *fields_reverse; std::vector<std::string> fields_reverse, fields_border, fields_border_vel;
char *fields_border, *fields_border_vel; std::vector<std::string> fields_exchange, fields_restart, fields_create;
char *fields_exchange, *fields_restart; std::vector<std::string> fields_data_atom, fields_data_vel;
char *fields_create, *fields_data_atom, *fields_data_vel;
// methods // methods
@ -152,7 +151,7 @@ class AtomVec : protected Pointers {
virtual int pack_data_bonus(double *, int) { return 0; } virtual int pack_data_bonus(double *, int) { return 0; }
virtual void write_data_bonus(FILE *, int, double *, int) {} 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 void pack_property_atom(int, double *, int, int) {}
virtual double memory_usage(); virtual double memory_usage();
@ -187,11 +186,10 @@ class AtomVec : protected Pointers {
// standard list of peratom fields always operated on by different methods // standard list of peratom fields always operated on by different methods
// common to all styles, so not listed in field strings // common to all styles, so not listed in field strings
const char *default_grow, *default_copy; static const std::vector<std::string> default_grow, default_copy, default_comm, default_comm_vel;
const char *default_comm, *default_comm_vel, *default_reverse; static const std::vector<std::string> default_reverse, default_border, default_border_vel;
const char *default_border, *default_border_vel; static const std::vector<std::string> default_exchange, default_restart, default_create;
const char *default_exchange, *default_restart; static const std::vector<std::string> default_data_atom, default_data_vel;
const char *default_create, *default_data_atom, *default_data_vel;
struct Method { struct Method {
std::vector<void *> pdata; std::vector<void *> pdata;
@ -223,7 +221,7 @@ class AtomVec : protected Pointers {
void grow_nmax(); void grow_nmax();
int grow_nmax_bonus(int); int grow_nmax_bonus(int);
void setup_fields(); 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 *); 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) ""; fields_grow = {};
fields_copy = (char *) ""; fields_copy = {};
fields_comm = (char *) ""; fields_comm = {};
fields_comm_vel = (char *) ""; fields_comm_vel = {};
fields_reverse = (char *) ""; fields_reverse = {};
fields_border = (char *) ""; fields_border = {};
fields_border_vel = (char *) ""; fields_border_vel = {};
fields_exchange = (char *) ""; fields_exchange = {};
fields_restart = (char *) ""; fields_restart = {};
fields_create = (char *) ""; fields_create = {};
fields_data_atom = (char *) "id type x"; fields_data_atom = {"id", "type", "x"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
setup_fields(); setup_fields();
} }

224
src/atom_vec_body.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -23,8 +22,6 @@
#include "modify.h" #include "modify.h"
#include "my_pool_chunk.h" #include "my_pool_chunk.h"
#include <cstring>
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -54,27 +51,30 @@ AtomVecBody::AtomVecBody(LAMMPS *lmp) : AtomVec(lmp)
bptr = nullptr; bptr = nullptr;
if (sizeof(double) == sizeof(int)) intdoubleratio = 1; if (sizeof(double) == sizeof(int))
else if (sizeof(double) == 2*sizeof(int)) intdoubleratio = 2; intdoubleratio = 1;
else error->all(FLERR,"Internal error in atom_style body"); 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 with peratom variables to include in each AtomVec method
// strings cannot contain fields in corresponding AtomVec default strings // strings cannot contain fields in corresponding AtomVec default strings
// order of fields in a string does not matter // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "radius rmass angmom torque body"; fields_grow = {"radius", "rmass", "angmom", "torque", "body"};
fields_copy = (char *) "radius rmass angmom"; fields_copy = {"radius", "rmass", "angmom"};
fields_comm = (char *) ""; fields_comm = {};
fields_comm_vel = (char *) "angmom"; fields_comm_vel = {"angmom"};
fields_reverse = (char *) "torque"; fields_reverse = {"torque"};
fields_border = (char *) "radius rmass"; fields_border = {"radius", "rmass"};
fields_border_vel = (char *) "radius rmass angmom"; fields_border_vel = {"radius", "rmass", "angmom"};
fields_exchange = (char *) "radius rmass angmom"; fields_exchange = {"radius", "rmass", "angmom"};
fields_restart = (char *) "radius rmass angmom"; fields_restart = {"radius", "rmass", "angmom"};
fields_create = (char *) "radius rmass angmom body"; fields_create = {"radius", "rmass", "angmom", "body"};
fields_data_atom = (char *) "id type body rmass x"; fields_data_atom = {"id", "type", "body", "rmass", "x"};
fields_data_vel = (char *) "id v angmom"; 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 // 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 if (false) { // NOLINT
bptr = nullptr; bptr = nullptr;
#define BODY_CLASS #define BODY_CLASS
#define BodyStyle(key,Class) \ #define BodyStyle(key, Class) \
} else if (strcmp(arg[0],#key) == 0) { \ } \
bptr = new Class(lmp,narg,arg); else if (strcmp(arg[0], #key) == 0) \
#include "style_body.h" // IWYU pragma: keep { \
bptr = new Class(lmp, narg, arg);
#include "style_body.h" // IWYU pragma: keep
#undef BodyStyle #undef BodyStyle
#undef BODY_CLASS #undef BODY_CLASS
} else error->all(FLERR,utils:: } else
check_packages_for_style("body",arg[0],lmp).c_str()); error->all(FLERR, utils::check_packages_for_style("body", arg[0], lmp).c_str());
bptr->avec = this; bptr->avec = this;
icp = bptr->icp; icp = bptr->icp;
@ -153,11 +155,9 @@ void AtomVecBody::grow_pointers()
void AtomVecBody::grow_bonus() void AtomVecBody::grow_bonus()
{ {
nmax_bonus = grow_nmax_bonus(nmax_bonus); nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0) if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big");
error->one(FLERR,"Per-processor system is too big");
bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus), bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom:bonus");
"atom:bonus");
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -173,7 +173,7 @@ void AtomVecBody::copy_bonus(int i, int j, int delflag)
int k = body[j]; int k = body[j];
icp->put(bonus[k].iindex); icp->put(bonus[k].iindex);
dcp->put(bonus[k].dindex); dcp->put(bonus[k].dindex);
copy_bonus_all(nlocal_bonus-1,k); copy_bonus_all(nlocal_bonus - 1, k);
nlocal_bonus--; 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) void AtomVecBody::copy_bonus_all(int i, int j)
{ {
body[bonus[i].ilocal] = 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 AtomVecBody::pack_comm_bonus(int n, int *list, double *buf)
{ {
int i,j,m; int i, j, m;
double *quat; double *quat;
m = 0; m = 0;
@ -230,7 +230,7 @@ int AtomVecBody::pack_comm_bonus(int n, int *list, double *buf)
buf[m++] = quat[1]; buf[m++] = quat[1];
buf[m++] = quat[2]; buf[m++] = quat[2];
buf[m++] = quat[3]; 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) void AtomVecBody::unpack_comm_bonus(int n, int first, double *buf)
{ {
int i,m,last; int i, m, last;
double *quat; double *quat;
m = 0; m = 0;
@ -253,7 +253,7 @@ void AtomVecBody::unpack_comm_bonus(int n, int first, double *buf)
quat[1] = buf[m++]; quat[1] = buf[m++];
quat[2] = buf[m++]; quat[2] = buf[m++];
quat[3] = 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 AtomVecBody::pack_border_bonus(int n, int *list, double *buf)
{ {
int i,j,m; int i, j, m;
double *quat,*inertia; double *quat, *inertia;
m = 0; m = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
j = list[i]; j = list[i];
if (body[j] < 0) buf[m++] = ubuf(0).d; if (body[j] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
quat = bonus[body[j]].quat; 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++] = inertia[2];
buf[m++] = ubuf(bonus[body[j]].ninteger).d; buf[m++] = ubuf(bonus[body[j]].ninteger).d;
buf[m++] = ubuf(bonus[body[j]].ndouble).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 AtomVecBody::unpack_border_bonus(int n, int first, double *buf)
{ {
int i,j,m,last; int i, j, m, last;
double *quat,*inertia; double *quat, *inertia;
m = 0; m = 0;
last = first + n; last = first + n;
for (i = first; i < last; i++) { for (i = first; i < last; i++) {
body[i] = (int) ubuf(buf[m++]).i; body[i] = (int) ubuf(buf[m++]).i;
if (body[i] == 0) body[i] = -1; if (body[i] == 0)
body[i] = -1;
else { else {
j = nlocal_bonus + nghost_bonus; j = nlocal_bonus + nghost_bonus;
if (j == nmax_bonus) grow_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].ninteger = (int) ubuf(buf[m++]).i;
bonus[j].ndouble = (int) ubuf(buf[m++]).i; bonus[j].ndouble = (int) ubuf(buf[m++]).i;
// corresponding put() calls are in clear_bonus() // corresponding put() calls are in clear_bonus()
bonus[j].ivalue = icp->get(bonus[j].ninteger,bonus[j].iindex); bonus[j].ivalue = icp->get(bonus[j].ninteger, bonus[j].iindex);
bonus[j].dvalue = dcp->get(bonus[j].ndouble,bonus[j].dindex); bonus[j].dvalue = dcp->get(bonus[j].ndouble, bonus[j].dindex);
m += bptr->unpack_border_body(&bonus[j],&buf[m]); m += bptr->unpack_border_body(&bonus[j], &buf[m]);
bonus[j].ilocal = i; bonus[j].ilocal = i;
body[i] = j; body[i] = j;
nghost_bonus++; nghost_bonus++;
@ -337,7 +339,8 @@ int AtomVecBody::pack_exchange_bonus(int i, double *buf)
{ {
int m = 0; int m = 0;
if (body[i] < 0) buf[m++] = ubuf(0).d; if (body[i] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
int j = body[i]; int j = body[i];
@ -352,10 +355,12 @@ int AtomVecBody::pack_exchange_bonus(int i, double *buf)
buf[m++] = inertia[2]; buf[m++] = inertia[2];
buf[m++] = ubuf(bonus[j].ninteger).d; buf[m++] = ubuf(bonus[j].ninteger).d;
buf[m++] = ubuf(bonus[j].ndouble).d; buf[m++] = ubuf(bonus[j].ndouble).d;
memcpy(&buf[m],bonus[j].ivalue,bonus[j].ninteger*sizeof(int)); memcpy(&buf[m], bonus[j].ivalue, bonus[j].ninteger * sizeof(int));
if (intdoubleratio == 1) m += bonus[j].ninteger; if (intdoubleratio == 1)
else m += (bonus[j].ninteger+1)/2; m += bonus[j].ninteger;
memcpy(&buf[m],bonus[j].dvalue,bonus[j].ndouble*sizeof(double)); else
m += (bonus[j].ninteger + 1) / 2;
memcpy(&buf[m], bonus[j].dvalue, bonus[j].ndouble * sizeof(double));
m += bonus[j].ndouble; m += bonus[j].ndouble;
} }
@ -369,7 +374,8 @@ int AtomVecBody::unpack_exchange_bonus(int ilocal, double *buf)
int m = 0; int m = 0;
body[ilocal] = (int) ubuf(buf[m++]).i; body[ilocal] = (int) ubuf(buf[m++]).i;
if (body[ilocal] == 0) body[ilocal] = -1; if (body[ilocal] == 0)
body[ilocal] = -1;
else { else {
if (nlocal_bonus == nmax_bonus) grow_bonus(); if (nlocal_bonus == nmax_bonus) grow_bonus();
double *quat = bonus[nlocal_bonus].quat; 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].ninteger = (int) ubuf(buf[m++]).i;
bonus[nlocal_bonus].ndouble = (int) ubuf(buf[m++]).i; bonus[nlocal_bonus].ndouble = (int) ubuf(buf[m++]).i;
// corresponding put() calls are in copy() // corresponding put() calls are in copy()
bonus[nlocal_bonus].ivalue = icp->get(bonus[nlocal_bonus].ninteger, bonus[nlocal_bonus].ivalue = icp->get(bonus[nlocal_bonus].ninteger, bonus[nlocal_bonus].iindex);
bonus[nlocal_bonus].iindex); bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble, bonus[nlocal_bonus].dindex);
bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble, memcpy(bonus[nlocal_bonus].ivalue, &buf[m], bonus[nlocal_bonus].ninteger * sizeof(int));
bonus[nlocal_bonus].dindex); if (intdoubleratio == 1)
memcpy(bonus[nlocal_bonus].ivalue,&buf[m], m += bonus[nlocal_bonus].ninteger;
bonus[nlocal_bonus].ninteger*sizeof(int)); else
if (intdoubleratio == 1) m += bonus[nlocal_bonus].ninteger; m += (bonus[nlocal_bonus].ninteger + 1) / 2;
else m += (bonus[nlocal_bonus].ninteger+1)/2; memcpy(bonus[nlocal_bonus].dvalue, &buf[m], bonus[nlocal_bonus].ndouble * sizeof(double));
memcpy(bonus[nlocal_bonus].dvalue,&buf[m],
bonus[nlocal_bonus].ndouble*sizeof(double));
m += bonus[nlocal_bonus].ndouble; m += bonus[nlocal_bonus].ndouble;
bonus[nlocal_bonus].ilocal = ilocal; bonus[nlocal_bonus].ilocal = ilocal;
@ -416,10 +420,13 @@ int AtomVecBody::size_restart_bonus()
for (i = 0; i < nlocal; i++) { for (i = 0; i < nlocal; i++) {
if (body[i] >= 0) { if (body[i] >= 0) {
n += size_restart_bonus_one; n += size_restart_bonus_one;
if (intdoubleratio == 1) n += bonus[body[i]].ninteger; if (intdoubleratio == 1)
else n += (bonus[body[i]].ninteger+1)/2; n += bonus[body[i]].ninteger;
else
n += (bonus[body[i]].ninteger + 1) / 2;
n += bonus[body[i]].ndouble; n += bonus[body[i]].ndouble;
} else n++; } else
n++;
} }
return n; return n;
@ -435,7 +442,8 @@ int AtomVecBody::pack_restart_bonus(int i, double *buf)
{ {
int m = 0; int m = 0;
if (body[i] < 0) buf[m++] = ubuf(0).d; if (body[i] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
int j = body[i]; int j = body[i];
@ -450,10 +458,12 @@ int AtomVecBody::pack_restart_bonus(int i, double *buf)
buf[m++] = inertia[2]; buf[m++] = inertia[2];
buf[m++] = ubuf(bonus[j].ninteger).d; buf[m++] = ubuf(bonus[j].ninteger).d;
buf[m++] = ubuf(bonus[j].ndouble).d; buf[m++] = ubuf(bonus[j].ndouble).d;
memcpy(&buf[m],bonus[j].ivalue,bonus[j].ninteger*sizeof(int)); memcpy(&buf[m], bonus[j].ivalue, bonus[j].ninteger * sizeof(int));
if (intdoubleratio == 1) m += bonus[j].ninteger; if (intdoubleratio == 1)
else m += (bonus[j].ninteger+1)/2; m += bonus[j].ninteger;
memcpy(&buf[m],bonus[j].dvalue,bonus[j].ndouble*sizeof(double)); else
m += (bonus[j].ninteger + 1) / 2;
memcpy(&buf[m], bonus[j].dvalue, bonus[j].ndouble * sizeof(double));
m += bonus[j].ndouble; m += bonus[j].ndouble;
} }
@ -469,7 +479,8 @@ int AtomVecBody::unpack_restart_bonus(int ilocal, double *buf)
int m = 0; int m = 0;
body[ilocal] = (int) ubuf(buf[m++]).i; body[ilocal] = (int) ubuf(buf[m++]).i;
if (body[ilocal] == 0) body[ilocal] = -1; if (body[ilocal] == 0)
body[ilocal] = -1;
else { else {
if (nlocal_bonus == nmax_bonus) grow_bonus(); if (nlocal_bonus == nmax_bonus) grow_bonus();
double *quat = bonus[nlocal_bonus].quat; double *quat = bonus[nlocal_bonus].quat;
@ -483,16 +494,14 @@ int AtomVecBody::unpack_restart_bonus(int ilocal, double *buf)
inertia[2] = buf[m++]; inertia[2] = buf[m++];
bonus[nlocal_bonus].ninteger = (int) ubuf(buf[m++]).i; bonus[nlocal_bonus].ninteger = (int) ubuf(buf[m++]).i;
bonus[nlocal_bonus].ndouble = (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].ivalue = icp->get(bonus[nlocal_bonus].ninteger, bonus[nlocal_bonus].iindex);
bonus[nlocal_bonus].iindex); bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble, bonus[nlocal_bonus].dindex);
bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble, memcpy(bonus[nlocal_bonus].ivalue, &buf[m], bonus[nlocal_bonus].ninteger * sizeof(int));
bonus[nlocal_bonus].dindex); if (intdoubleratio == 1)
memcpy(bonus[nlocal_bonus].ivalue,&buf[m], m += bonus[nlocal_bonus].ninteger;
bonus[nlocal_bonus].ninteger*sizeof(int)); else
if (intdoubleratio == 1) m += bonus[nlocal_bonus].ninteger; m += (bonus[nlocal_bonus].ninteger + 1) / 2;
else m += (bonus[nlocal_bonus].ninteger+1)/2; memcpy(bonus[nlocal_bonus].dvalue, &buf[m], bonus[nlocal_bonus].ndouble * sizeof(double));
memcpy(bonus[nlocal_bonus].dvalue,&buf[m],
bonus[nlocal_bonus].ndouble*sizeof(double));
m += bonus[nlocal_bonus].ndouble; m += bonus[nlocal_bonus].ndouble;
bonus[nlocal_bonus].ilocal = ilocal; bonus[nlocal_bonus].ilocal = ilocal;
body[ilocal] = nlocal_bonus++; body[ilocal] = nlocal_bonus++;
@ -521,13 +530,15 @@ void AtomVecBody::create_atom_post(int ilocal)
void AtomVecBody::data_atom_post(int ilocal) void AtomVecBody::data_atom_post(int ilocal)
{ {
body_flag = body[ilocal]; body_flag = body[ilocal];
if (body_flag == 0) body_flag = -1; if (body_flag == 0)
else if (body_flag == 1) body_flag = 0; body_flag = -1;
else error->one(FLERR,"Invalid body flag in Atoms section of data file"); 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; body[ilocal] = body_flag;
if (rmass[ilocal] <= 0.0) if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file");
error->one(FLERR,"Invalid density in Atoms section of data file");
radius[ilocal] = 0.5; radius[ilocal] = 0.5;
angmom[ilocal][0] = 0.0; 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 unpack one body from Bodies section of data file
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecBody::data_body(int m, int ninteger, int ndouble, void AtomVecBody::data_body(int m, int ninteger, int ndouble, int *ivalues, double *dvalues)
int *ivalues, double *dvalues)
{ {
if (body[m]) if (body[m]) error->one(FLERR, "Assigning body parameters to non-body atom");
error->one(FLERR,"Assigning body parameters to non-body atom");
if (nlocal_bonus == nmax_bonus) grow_bonus(); if (nlocal_bonus == nmax_bonus) grow_bonus();
bonus[nlocal_bonus].ilocal = m; 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++; body[m] = nlocal_bonus++;
} }
@ -557,14 +566,14 @@ void AtomVecBody::data_body(int m, int ninteger, int ndouble,
double AtomVecBody::memory_usage_bonus() double AtomVecBody::memory_usage_bonus()
{ {
double bytes = 0; double bytes = 0;
bytes += (double)nmax_bonus*sizeof(Bonus); bytes += (double) nmax_bonus * sizeof(Bonus);
bytes += icp->size() + dcp->size(); bytes += icp->size() + dcp->size();
int nall = nlocal_bonus + nghost_bonus; int nall = nlocal_bonus + nghost_bonus;
for (int i = 0; i < nall; i++) { for (int i = 0; i < nall; i++) {
if (body[i] >= 0) { if (body[i] >= 0) {
bytes += (double)bonus[body[i]].ninteger * sizeof(int); bytes += (double) bonus[body[i]].ninteger * sizeof(int);
bytes += (double)bonus[body[i]].ndouble * sizeof(double); bytes += (double) bonus[body[i]].ndouble * sizeof(double);
} }
} }
@ -579,8 +588,10 @@ void AtomVecBody::pack_data_pre(int ilocal)
{ {
body_flag = body[ilocal]; body_flag = body[ilocal];
if (body_flag < 0) body[ilocal] = 0; if (body_flag < 0)
else body[ilocal] = 1; body[ilocal] = 0;
else
body[ilocal] = 1;
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -598,7 +609,7 @@ int AtomVecBody::pack_data_bonus(double *buf, int /*flag*/)
int m = 0; int m = 0;
for (i = 0; i < nlocal; i++) { for (i = 0; i < nlocal; i++) {
if (body[i] < 0) continue; 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; m += n;
if (buf) buf += 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*/) void AtomVecBody::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/)
{ {
int i = 0; int i = 0;
while (i < n) { while (i < n) { i += bptr->write_data_body(fp, &buf[i]); }
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 body computes its size based on ivalues/dvalues and returns it
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
double AtomVecBody::radius_body(int ninteger, int ndouble, double AtomVecBody::radius_body(int ninteger, int ndouble, int *ivalues, double *dvalues)
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) 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; double *quat = bonus[body[m]].quat;
quat[0] = quat_external[0]; quat[1] = quat_external[1]; quat[0] = quat_external[0];
quat[2] = quat_external[2]; quat[3] = quat_external[3]; 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "q"; fields_grow = {"q"};
fields_copy = (char *) "q"; fields_copy = {"q"};
fields_comm = (char *) ""; fields_comm = {};
fields_comm_vel = (char *) ""; fields_comm_vel = {};
fields_reverse = (char *) ""; fields_reverse = {};
fields_border = (char *) "q"; fields_border = {"q"};
fields_border_vel = (char *) "q"; fields_border_vel = {"q"};
fields_exchange = (char *) "q"; fields_exchange = {"q"};
fields_restart = (char *) "q"; fields_restart = {"q"};
fields_create = (char *) "q"; fields_create = {"q"};
fields_data_atom = (char *) "id type q x"; fields_data_atom = {"id", "type", "q", "x"};
fields_data_vel = (char *) "id v"; fields_data_vel = {"id", "v"};
setup_fields(); 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -26,10 +25,8 @@
#include "memory.h" #include "memory.h"
#include "modify.h" #include "modify.h"
#include <cstring>
using namespace LAMMPS_NS; 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "rmass angmom torque ellipsoid"; fields_grow = {"rmass", "angmom", "torque", "ellipsoid"};
fields_copy = (char *) "rmass angmom"; fields_copy = {"rmass", "angmom"};
fields_comm = (char *) ""; fields_comm = {};
fields_comm_vel = (char *) "angmom"; fields_comm_vel = {"angmom"};
fields_reverse = (char *) "torque"; fields_reverse = {"torque"};
fields_border = (char *) "rmass"; fields_border = {"rmass"};
fields_border_vel = (char *) "rmass angmom"; fields_border_vel = {"rmass", "angmom"};
fields_exchange = (char *) "rmass angmom"; fields_exchange = {"rmass", "angmom"};
fields_restart = (char *) "rmass angmom"; fields_restart = {"rmass", "angmom"};
fields_create = (char *) "rmass angmom ellipsoid"; fields_create = {"rmass", "angmom", "ellipsoid"};
fields_data_atom = (char *) "id type ellipsoid rmass x"; fields_data_atom = {"id", "type", "ellipsoid", "rmass", "x"};
fields_data_vel = (char *) "id v angmom"; fields_data_vel = {"id", "v", "angmom"};
setup_fields(); setup_fields();
} }
@ -96,11 +93,9 @@ void AtomVecEllipsoid::grow_pointers()
void AtomVecEllipsoid::grow_bonus() void AtomVecEllipsoid::grow_bonus()
{ {
nmax_bonus = grow_nmax_bonus(nmax_bonus); nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0) if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big");
error->one(FLERR,"Per-processor system is too big");
bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus), bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom: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 deleting atom J via delflag and J has bonus data, then delete it
if (delflag && ellipsoid[j] >= 0) { if (delflag && ellipsoid[j] >= 0) {
copy_bonus_all(nlocal_bonus-1,ellipsoid[j]); copy_bonus_all(nlocal_bonus - 1, ellipsoid[j]);
nlocal_bonus--; 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) void AtomVecEllipsoid::copy_bonus_all(int i, int j)
{ {
ellipsoid[bonus[i].ilocal] = 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 AtomVecEllipsoid::pack_comm_bonus(int n, int *list, double *buf)
{ {
int i,j,m; int i, j, m;
double *quat; double *quat;
m = 0; 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) void AtomVecEllipsoid::unpack_comm_bonus(int n, int first, double *buf)
{ {
int i,m,last; int i, m, last;
double *quat; double *quat;
m = 0; 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 AtomVecEllipsoid::pack_border_bonus(int n, int *list, double *buf)
{ {
int i,j,m; int i, j, m;
double *shape,*quat; double *shape, *quat;
m = 0; m = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
j = list[i]; j = list[i];
if (ellipsoid[j] < 0) buf[m++] = ubuf(0).d; if (ellipsoid[j] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
shape = bonus[ellipsoid[j]].shape; 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 AtomVecEllipsoid::unpack_border_bonus(int n, int first, double *buf)
{ {
int i,j,m,last; int i, j, m, last;
double *shape,*quat; double *shape, *quat;
m = 0; m = 0;
last = first + n; last = first + n;
for (i = first; i < last; i++) { for (i = first; i < last; i++) {
ellipsoid[i] = (int) ubuf(buf[m++]).i; ellipsoid[i] = (int) ubuf(buf[m++]).i;
if (ellipsoid[i] == 0) ellipsoid[i] = -1; if (ellipsoid[i] == 0)
ellipsoid[i] = -1;
else { else {
j = nlocal_bonus + nghost_bonus; j = nlocal_bonus + nghost_bonus;
if (j == nmax_bonus) grow_bonus(); if (j == nmax_bonus) grow_bonus();
@ -260,7 +257,8 @@ int AtomVecEllipsoid::pack_exchange_bonus(int i, double *buf)
{ {
int m = 0; int m = 0;
if (ellipsoid[i] < 0) buf[m++] = ubuf(0).d; if (ellipsoid[i] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
int j = ellipsoid[i]; int j = ellipsoid[i];
@ -285,7 +283,8 @@ int AtomVecEllipsoid::unpack_exchange_bonus(int ilocal, double *buf)
int m = 0; int m = 0;
ellipsoid[ilocal] = (int) ubuf(buf[m++]).i; ellipsoid[ilocal] = (int) ubuf(buf[m++]).i;
if (ellipsoid[ilocal] == 0) ellipsoid[ilocal] = -1; if (ellipsoid[ilocal] == 0)
ellipsoid[ilocal] = -1;
else { else {
if (nlocal_bonus == nmax_bonus) grow_bonus(); if (nlocal_bonus == nmax_bonus) grow_bonus();
double *shape = bonus[nlocal_bonus].shape; double *shape = bonus[nlocal_bonus].shape;
@ -316,8 +315,10 @@ int AtomVecEllipsoid::size_restart_bonus()
int n = 0; int n = 0;
int nlocal = atom->nlocal; int nlocal = atom->nlocal;
for (i = 0; i < nlocal; i++) { for (i = 0; i < nlocal; i++) {
if (ellipsoid[i] >= 0) n += size_restart_bonus_one; if (ellipsoid[i] >= 0)
else n++; n += size_restart_bonus_one;
else
n++;
} }
return n; return n;
@ -333,7 +334,8 @@ int AtomVecEllipsoid::pack_restart_bonus(int i, double *buf)
{ {
int m = 0; int m = 0;
if (ellipsoid[i] < 0) buf[m++] = ubuf(0).d; if (ellipsoid[i] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
int j = ellipsoid[i]; int j = ellipsoid[i];
@ -358,7 +360,8 @@ int AtomVecEllipsoid::unpack_restart_bonus(int ilocal, double *buf)
int m = 0; int m = 0;
ellipsoid[ilocal] = (int) ubuf(buf[m++]).i; ellipsoid[ilocal] = (int) ubuf(buf[m++]).i;
if (ellipsoid[ilocal] == 0) ellipsoid[ilocal] = -1; if (ellipsoid[ilocal] == 0)
ellipsoid[ilocal] = -1;
else { else {
if (nlocal_bonus == nmax_bonus) grow_bonus(); if (nlocal_bonus == nmax_bonus) grow_bonus();
double *shape = bonus[nlocal_bonus].shape; 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 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]) if (ellipsoid[m]) error->one(FLERR, "Assigning ellipsoid parameters to non-ellipsoid atom");
error->one(FLERR,"Assigning ellipsoid parameters to non-ellipsoid atom");
if (nlocal_bonus == nmax_bonus) grow_bonus(); if (nlocal_bonus == nmax_bonus) grow_bonus();
double *shape = bonus[nlocal_bonus].shape; double *shape = bonus[nlocal_bonus].shape;
int ivalue = 1; int ivalue = 1;
shape[0] = 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[1] = 0.5 * utils::numeric(FLERR, values[ivalue++], true, lmp);
shape[2] = 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) 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; double *quat = bonus[nlocal_bonus].quat;
quat[0] = 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[1] = utils::numeric(FLERR, values[ivalue++], true, lmp);
quat[2] = 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[3] = utils::numeric(FLERR, values[ivalue++], true, lmp);
MathExtra::qnormalize(quat); MathExtra::qnormalize(quat);
// reset ellipsoid mass // reset ellipsoid mass
// previously stored density in rmass // 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; bonus[nlocal_bonus].ilocal = m;
ellipsoid[m] = nlocal_bonus++; 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 AtomVecEllipsoid::memory_usage_bonus()
{ {
double bytes = 0; double bytes = 0;
bytes += nmax_bonus*sizeof(Bonus); bytes += nmax_bonus * sizeof(Bonus);
return bytes; return bytes;
} }
@ -441,13 +443,15 @@ void AtomVecEllipsoid::create_atom_post(int ilocal)
void AtomVecEllipsoid::data_atom_post(int ilocal) void AtomVecEllipsoid::data_atom_post(int ilocal)
{ {
ellipsoid_flag = ellipsoid[ilocal]; ellipsoid_flag = ellipsoid[ilocal];
if (ellipsoid_flag == 0) ellipsoid_flag = -1; if (ellipsoid_flag == 0)
else if (ellipsoid_flag == 1) ellipsoid_flag = 0; ellipsoid_flag = -1;
else error->one(FLERR,"Invalid ellipsoid flag in Atoms section of data file"); 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; ellipsoid[ilocal] = ellipsoid_flag;
if (rmass[ilocal] <= 0.0) if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file");
error->one(FLERR,"Invalid density in Atoms section of data file");
angmom[ilocal][0] = 0.0; angmom[ilocal][0] = 0.0;
angmom[ilocal][1] = 0.0; angmom[ilocal][1] = 0.0;
@ -465,12 +469,14 @@ void AtomVecEllipsoid::pack_data_pre(int ilocal)
ellipsoid_flag = atom->ellipsoid[ilocal]; ellipsoid_flag = atom->ellipsoid[ilocal];
rmass_one = atom->rmass[ilocal]; rmass_one = atom->rmass[ilocal];
if (ellipsoid_flag < 0) ellipsoid[ilocal] = 0; if (ellipsoid_flag < 0)
else ellipsoid[ilocal] = 1; ellipsoid[ilocal] = 0;
else
ellipsoid[ilocal] = 1;
if (ellipsoid_flag >= 0) { if (ellipsoid_flag >= 0) {
shape = bonus[ellipsoid_flag].shape; 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 AtomVecEllipsoid::pack_data_bonus(double *buf, int /*flag*/)
{ {
int i,j; int i, j;
tagint *tag = atom->tag; tagint *tag = atom->tag;
int nlocal = atom->nlocal; int nlocal = atom->nlocal;
@ -502,14 +508,15 @@ int AtomVecEllipsoid::pack_data_bonus(double *buf, int /*flag*/)
if (buf) { if (buf) {
buf[m++] = ubuf(tag[i]).d; buf[m++] = ubuf(tag[i]).d;
j = ellipsoid[i]; j = ellipsoid[i];
buf[m++] = 2.0*bonus[j].shape[0]; buf[m++] = 2.0 * bonus[j].shape[0];
buf[m++] = 2.0*bonus[j].shape[1]; buf[m++] = 2.0 * bonus[j].shape[1];
buf[m++] = 2.0*bonus[j].shape[2]; buf[m++] = 2.0 * bonus[j].shape[2];
buf[m++] = bonus[j].quat[0]; buf[m++] = bonus[j].quat[0];
buf[m++] = bonus[j].quat[1]; buf[m++] = bonus[j].quat[1];
buf[m++] = bonus[j].quat[2]; buf[m++] = bonus[j].quat[2];
buf[m++] = bonus[j].quat[3]; buf[m++] = bonus[j].quat[3];
} else m += size_data_bonus; } else
m += size_data_bonus;
} }
return m; return m;
@ -523,8 +530,8 @@ void AtomVecEllipsoid::write_data_bonus(FILE *fp, int n, double *buf, int /*flag
{ {
int i = 0; int i = 0;
while (i < n) { while (i < n) {
fmt::print(fp,"{} {} {} {} {} {} {} {}\n",ubuf(buf[i]).i, fmt::print(fp, "{} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3],
buf[i+1],buf[i+2],buf[i+3],buf[i+4],buf[i+5],buf[i+6],buf[i+7]); buf[i + 4], buf[i + 5], buf[i + 6], buf[i + 7]);
i += size_data_bonus; 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; bonus[nlocal_bonus].ilocal = i;
ellipsoid[i] = nlocal_bonus++; ellipsoid[i] = nlocal_bonus++;
} else if (shapex == 0.0 && shapey == 0.0 && shapez == 0.0) { } 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--; nlocal_bonus--;
ellipsoid[i] = -1; ellipsoid[i] = -1;
} else { } else {

322
src/atom_vec_hybrid.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -19,12 +18,12 @@
#include "error.h" #include "error.h"
#include "tokenizer.h" #include "tokenizer.h"
#include <algorithm>
#include <cstring> #include <cstring>
using namespace LAMMPS_NS; 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; nstyles = 0;
styles = nullptr; styles = nullptr;
keywords = nullptr; keywords = nullptr;
fieldstrings = nullptr;
bonus_flag = 0; bonus_flag = 0;
nstyles_bonus = 0; nstyles_bonus = 0;
styles_bonus = nullptr; 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_data_atom & fields_data_vel start with fields common to all styles
fields_grow = fields_copy = fields_comm = fields_comm_vel = (char *) ""; fields_data_atom = {"id", "type", "x"};
fields_reverse = fields_border = fields_border_vel = (char *) ""; fields_data_vel = {"id", "v"};
fields_exchange = fields_restart = fields_create = (char *) "";
fields_data_atom = (char *) "id type x";
fields_data_vel = (char *) "id v";
fields_allocated = 0;
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -56,28 +49,10 @@ AtomVecHybrid::AtomVecHybrid(LAMMPS *lmp) : AtomVec(lmp)
AtomVecHybrid::~AtomVecHybrid() AtomVecHybrid::~AtomVecHybrid()
{ {
for (int k = 0; k < nstyles; k++) delete styles[k]; for (int k = 0; k < nstyles; k++) delete styles[k];
delete [] styles; delete[] styles;
for (int k = 0; k < nstyles; k++) delete [] keywords[k]; for (int k = 0; k < nstyles; k++) delete[] keywords[k];
delete [] keywords; delete[] keywords;
delete [] styles_bonus; 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;
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -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 // allocate list of sub-styles as big as possibly needed if no extra args
styles = new AtomVec*[narg]; styles = new AtomVec *[narg];
keywords = new char*[narg]; keywords = new char *[narg];
// allocate each sub-style // allocate each sub-style
// call process_args() with set of args that are not atom style names // call process_args() with set of args that are not atom style names
// use known_style() to determine which args these are // use known_style() to determine which args these are
int i,k,jarg,dummy; int dummy;
int iarg = 0; int iarg = 0;
nstyles = 0; nstyles = 0;
while (iarg < narg) { while (iarg < narg) {
if (strcmp(arg[iarg],"hybrid") == 0) if (strcmp(arg[iarg], "hybrid") == 0)
error->all(FLERR,"Atom style hybrid cannot have hybrid as an argument"); error->all(FLERR, "Atom style hybrid cannot have hybrid as an argument");
for (i = 0; i < nstyles; i++) for (int i = 0; i < nstyles; i++)
if (strcmp(arg[iarg],keywords[i]) == 0) if (strcmp(arg[iarg], keywords[i]) == 0)
error->all(FLERR,"Atom style hybrid cannot use same atom style twice"); error->all(FLERR, "Atom style hybrid cannot use same atom style twice");
styles[nstyles] = atom->new_avec(arg[iarg],1,dummy); styles[nstyles] = atom->new_avec(arg[iarg], 1, dummy);
keywords[nstyles] = utils::strdup(arg[iarg]); keywords[nstyles] = utils::strdup(arg[iarg]);
jarg = iarg + 1; int jarg = iarg + 1;
while (jarg < narg && !known_style(arg[jarg])) jarg++; 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; iarg = jarg;
nstyles++; nstyles++;
} }
@ -124,20 +98,19 @@ void AtomVecHybrid::process_args(int narg, char **arg)
molecular = Atom::ATOMIC; molecular = Atom::ATOMIC;
maxexchange = 0; maxexchange = 0;
for (k = 0; k < nstyles; k++) { for (int k = 0; k < nstyles; k++) {
if ((styles[k]->molecular == Atom::MOLECULAR && molecular == Atom::TEMPLATE) || if ((styles[k]->molecular == Atom::MOLECULAR && molecular == Atom::TEMPLATE) ||
(styles[k]->molecular == Atom::TEMPLATE && molecular == Atom::MOLECULAR)) (styles[k]->molecular == Atom::TEMPLATE && molecular == Atom::MOLECULAR))
error->all(FLERR, error->all(FLERR, "Cannot mix molecular and molecule template atom styles");
"Cannot mix molecular and molecule template atom styles"); molecular = MAX(molecular, styles[k]->molecular);
molecular = MAX(molecular,styles[k]->molecular);
bonds_allow = MAX(bonds_allow,styles[k]->bonds_allow); bonds_allow = MAX(bonds_allow, styles[k]->bonds_allow);
angles_allow = MAX(angles_allow,styles[k]->angles_allow); angles_allow = MAX(angles_allow, styles[k]->angles_allow);
dihedrals_allow = MAX(dihedrals_allow,styles[k]->dihedrals_allow); dihedrals_allow = MAX(dihedrals_allow, styles[k]->dihedrals_allow);
impropers_allow = MAX(impropers_allow,styles[k]->impropers_allow); impropers_allow = MAX(impropers_allow, styles[k]->impropers_allow);
mass_type = MAX(mass_type,styles[k]->mass_type); mass_type = MAX(mass_type, styles[k]->mass_type);
dipole_type = MAX(dipole_type,styles[k]->dipole_type); dipole_type = MAX(dipole_type, styles[k]->dipole_type);
forceclearflag = MAX(forceclearflag,styles[k]->forceclearflag); forceclearflag = MAX(forceclearflag, styles[k]->forceclearflag);
maxexchange += styles[k]->maxexchange; maxexchange += styles[k]->maxexchange;
if (styles[k]->molecular == Atom::TEMPLATE) onemols = styles[k]->onemols; 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_pertype = 0;
int mass_peratom = 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 == 0) mass_peratom = 1;
if (styles[k]->mass_type == 1) mass_pertype = 1; if (styles[k]->mass_type == 1) mass_pertype = 1;
} }
if (mass_pertype && mass_peratom && comm->me == 0) 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 " "and per-atom masses; both must be set, but only "
"per-atom masses will be used"); "per-atom masses will be used");
// free allstyles created by build_styles() // free allstyles created by build_styles()
for (i = 0; i < nallstyles; i++) delete [] allstyles[i]; for (int i = 0; i < nallstyles; i++) delete[] allstyles[i];
delete [] allstyles; 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;
}
// merge field strings from all sub-styles // merge field strings from all sub-styles
// save concat_grow to check for duplicates of special-case fields // save concat_grow to check for duplicates of special-case fields
char *concat_grow;; std::vector<std::string> concat_grow;
char *dummyptr = nullptr; std::vector<std::string> concat_dummy;
fields_grow = merge_fields(0,fields_grow,1,concat_grow); for (int k = 0; k < nstyles; k++) {
fields_copy = merge_fields(1,fields_copy,0,dummyptr); merge_fields(fields_grow, styles[k]->fields_grow, 1, concat_grow);
fields_comm = merge_fields(2,fields_comm,0,dummyptr); merge_fields(fields_copy, styles[k]->fields_copy, 0, concat_dummy);
fields_comm_vel = merge_fields(3,fields_comm_vel,0,dummyptr); merge_fields(fields_comm, styles[k]->fields_comm, 0, concat_dummy);
fields_reverse = merge_fields(4,fields_reverse,0,dummyptr); merge_fields(fields_comm_vel, styles[k]->fields_comm_vel, 0, concat_dummy);
fields_border = merge_fields(5,fields_border,0,dummyptr); merge_fields(fields_reverse, styles[k]->fields_reverse, 0, concat_dummy);
fields_border_vel = merge_fields(6,fields_border_vel,0,dummyptr); merge_fields(fields_border, styles[k]->fields_border, 0, concat_dummy);
fields_exchange = merge_fields(7,fields_exchange,0,dummyptr); merge_fields(fields_border_vel, styles[k]->fields_border_vel, 0, concat_dummy);
fields_restart = merge_fields(8,fields_restart,0,dummyptr); merge_fields(fields_exchange, styles[k]->fields_exchange, 0, concat_dummy);
fields_create = merge_fields(9,fields_create,0,dummyptr); merge_fields(fields_restart, styles[k]->fields_restart, 0, concat_dummy);
fields_data_atom = merge_fields(10,fields_data_atom,0,dummyptr); merge_fields(fields_create, styles[k]->fields_create, 0, concat_dummy);
fields_data_vel = merge_fields(11,fields_data_vel,0,dummyptr); 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);
fields_allocated = 1; }
// check concat_grow for multiple special-case fields // check concat_grow for multiple special-case fields
// may cause issues with style-specific create_atom() and data_atom() methods // may cause issues with style-specific create_atom() and data_atom() methods
// issue warnings if appear in multiple sub-styles // issue warnings if appear in multiple sub-styles
const char *dupfield[] = {"radius","rmass"}; std::vector<std::string> dupfield = {"radius", "rmass"};
int ndupfield = 2;
char *ptr;
for (int idup = 0; idup < ndupfield; idup++) { for (const auto &idup : dupfield) {
auto dup = (char *) dupfield[idup]; if ((comm->me == 0) && (std::count(concat_grow.begin(), concat_grow.end(), idup) > 1))
ptr = strstr(concat_grow,dup); error->warning(FLERR,
if ((ptr && strstr(ptr+1,dup)) && (comm->me == 0)) "Per-atom field {} is used in multiple sub-styles; must be used consistently",
error->warning(FLERR,fmt::format("Per-atom {} is used in multiple sub-" idup);
"styles; must be used consistently",dup));
} }
delete [] concat_grow;
// set bonus_flag if any substyle has bonus data // set bonus_flag if any substyle has bonus data
// set nstyles_bonus & styles_bonus // set nstyles_bonus & styles_bonus
// sum two sizes over contributions from each substyle with bonus data. // sum two sizes over contributions from each substyle with bonus data.
nstyles_bonus = 0; nstyles_bonus = 0;
for (k = 0; k < nstyles; k++) for (int k = 0; k < nstyles; k++)
if (styles[k]->bonus_flag) nstyles_bonus++; if (styles[k]->bonus_flag) nstyles_bonus++;
if (nstyles_bonus) { if (nstyles_bonus) {
bonus_flag = 1; bonus_flag = 1;
styles_bonus = new AtomVec*[nstyles_bonus]; styles_bonus = new AtomVec *[nstyles_bonus];
nstyles_bonus = 0; nstyles_bonus = 0;
size_forward_bonus = 0; size_forward_bonus = 0;
size_border_bonus = 0; size_border_bonus = 0;
for (k = 0; k < nstyles; k++) { for (int k = 0; k < nstyles; k++) {
if (styles[k]->bonus_flag) { if (styles[k]->bonus_flag) {
styles_bonus[nstyles_bonus++] = styles[k]; styles_bonus[nstyles_bonus++] = styles[k];
size_forward_bonus += styles[k]->size_forward_bonus; 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) void AtomVecHybrid::force_clear(int n, size_t nbytes)
{ {
for (int k = 0; k < nstyles; k++) 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) void AtomVecHybrid::copy_bonus(int i, int j, int delflag)
{ {
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) styles_bonus[k]->copy_bonus(i, j, delflag);
styles_bonus[k]->copy_bonus(i,j,delflag);
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
void AtomVecHybrid::clear_bonus() void AtomVecHybrid::clear_bonus()
{ {
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) styles_bonus[k]->clear_bonus();
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 AtomVecHybrid::pack_comm_bonus(int n, int *list, double *buf)
{ {
int m = 0; int m = 0;
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_comm_bonus(n, list, buf);
m += styles_bonus[k]->pack_comm_bonus(n,list,buf);
return m; 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) void AtomVecHybrid::unpack_comm_bonus(int n, int first, double *buf)
{ {
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) styles_bonus[k]->unpack_comm_bonus(n, first, buf);
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 AtomVecHybrid::pack_border_bonus(int n, int *list, double *buf)
{ {
int m = 0; int m = 0;
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_border_bonus(n, list, buf);
m += styles_bonus[k]->pack_border_bonus(n,list,buf);
return m; 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 AtomVecHybrid::unpack_border_bonus(int n, int first, double *buf)
{ {
int m = 0; int m = 0;
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->unpack_border_bonus(n, first, buf);
m += styles_bonus[k]->unpack_border_bonus(n,first,buf);
return m; 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 AtomVecHybrid::pack_exchange_bonus(int i, double *buf)
{ {
int m = 0; int m = 0;
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_exchange_bonus(i, buf);
m += styles_bonus[k]->pack_exchange_bonus(i,buf);
return m; 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 AtomVecHybrid::unpack_exchange_bonus(int ilocal, double *buf)
{ {
int m = 0; int m = 0;
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->unpack_exchange_bonus(ilocal, buf);
m += styles_bonus[k]->unpack_exchange_bonus(ilocal,buf);
return m; return m;
} }
@ -352,8 +293,7 @@ int AtomVecHybrid::unpack_exchange_bonus(int ilocal, double *buf)
int AtomVecHybrid::size_restart_bonus() int AtomVecHybrid::size_restart_bonus()
{ {
int n = 0; int n = 0;
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) n += styles_bonus[k]->size_restart_bonus();
n += styles_bonus[k]->size_restart_bonus();
return n; return n;
} }
@ -362,8 +302,7 @@ int AtomVecHybrid::size_restart_bonus()
int AtomVecHybrid::pack_restart_bonus(int i, double *buf) int AtomVecHybrid::pack_restart_bonus(int i, double *buf)
{ {
int m = 0; int m = 0;
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_restart_bonus(i, buf);
m += styles_bonus[k]->pack_restart_bonus(i,buf);
return m; 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 AtomVecHybrid::unpack_restart_bonus(int ilocal, double *buf)
{ {
int m = 0; int m = 0;
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->unpack_restart_bonus(ilocal, buf);
m += styles_bonus[k]->unpack_restart_bonus(ilocal,buf);
return m; return m;
} }
@ -382,8 +320,7 @@ int AtomVecHybrid::unpack_restart_bonus(int ilocal, double *buf)
double AtomVecHybrid::memory_usage_bonus() double AtomVecHybrid::memory_usage_bonus()
{ {
double bytes = 0; double bytes = 0;
for (int k = 0; k < nstyles_bonus; k++) for (int k = 0; k < nstyles_bonus; k++) bytes += styles_bonus[k]->memory_usage_bonus();
bytes += styles_bonus[k]->memory_usage_bonus();
return bytes; return bytes;
} }
@ -393,8 +330,7 @@ double AtomVecHybrid::memory_usage_bonus()
void AtomVecHybrid::pack_restart_pre(int ilocal) void AtomVecHybrid::pack_restart_pre(int ilocal)
{ {
for (int k = 0; k < nstyles; k++) for (int k = 0; k < nstyles; k++) styles[k]->pack_restart_pre(ilocal);
styles[k]->pack_restart_pre(ilocal);
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -403,8 +339,7 @@ void AtomVecHybrid::pack_restart_pre(int ilocal)
void AtomVecHybrid::pack_restart_post(int ilocal) void AtomVecHybrid::pack_restart_post(int ilocal)
{ {
for (int k = 0; k < nstyles; k++) for (int k = 0; k < nstyles; k++) styles[k]->pack_restart_post(ilocal);
styles[k]->pack_restart_post(ilocal);
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -413,8 +348,7 @@ void AtomVecHybrid::pack_restart_post(int ilocal)
void AtomVecHybrid::unpack_restart_init(int ilocal) void AtomVecHybrid::unpack_restart_init(int ilocal)
{ {
for (int k = 0; k < nstyles; k++) for (int k = 0; k < nstyles; k++) styles[k]->unpack_restart_init(ilocal);
styles[k]->unpack_restart_init(ilocal);
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -423,8 +357,7 @@ void AtomVecHybrid::unpack_restart_init(int ilocal)
void AtomVecHybrid::create_atom_post(int ilocal) void AtomVecHybrid::create_atom_post(int ilocal)
{ {
for (int k = 0; k < nstyles; k++) for (int k = 0; k < nstyles; k++) styles[k]->create_atom_post(ilocal);
styles[k]->create_atom_post(ilocal);
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -434,16 +367,15 @@ void AtomVecHybrid::create_atom_post(int ilocal)
void AtomVecHybrid::data_atom_post(int ilocal) void AtomVecHybrid::data_atom_post(int ilocal)
{ {
for (int k = 0; k < nstyles; k++) for (int k = 0; k < nstyles; k++) styles[k]->data_atom_post(ilocal);
styles[k]->data_atom_post(ilocal);
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
modify what AtomVec::data_bonds() just unpacked modify what AtomVec::data_bonds() just unpacked
or initialize other bond quantities or initialize other bond quantities
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecHybrid::data_bonds_post(int m, int num_bond, tagint atom1, void AtomVecHybrid::data_bonds_post(int m, int num_bond, tagint atom1, tagint atom2,
tagint atom2, tagint id_offset) tagint id_offset)
{ {
for (int k = 0; k < nstyles; k++) for (int k = 0; k < nstyles; k++)
styles[k]->data_bonds_post(m, num_bond, atom1, atom2, id_offset); 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) void AtomVecHybrid::pack_data_pre(int ilocal)
{ {
for (int k = 0; k < nstyles; k++) for (int k = 0; k < nstyles; k++) styles[k]->pack_data_pre(ilocal);
styles[k]->pack_data_pre(ilocal);
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -465,8 +396,7 @@ void AtomVecHybrid::pack_data_pre(int ilocal)
void AtomVecHybrid::pack_data_post(int ilocal) void AtomVecHybrid::pack_data_post(int ilocal)
{ {
for (int k = 0; k < nstyles; k++) for (int k = 0; k < nstyles; k++) styles[k]->pack_data_post(ilocal);
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) int AtomVecHybrid::pack_data_bonus(double *buf, int flag)
{ {
for (int k = 0; k < nstyles; k++) { for (int k = 0; k < nstyles; k++) {
if (flag == ELLIPSOID && strcmp(keywords[k],"ellipsoid") != 0) continue; if (flag == ELLIPSOID && strcmp(keywords[k], "ellipsoid") != 0) continue;
if (flag == LINE && strcmp(keywords[k],"line") != 0) continue; if (flag == LINE && strcmp(keywords[k], "line") != 0) continue;
if (flag == TRIANGLE && strcmp(keywords[k],"tri") != 0) continue; if (flag == TRIANGLE && strcmp(keywords[k], "tri") != 0) continue;
if (flag == BODY && strcmp(keywords[k],"body") != 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; 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) void AtomVecHybrid::write_data_bonus(FILE *fp, int n, double *buf, int flag)
{ {
for (int k = 0; k < nstyles; k++) { for (int k = 0; k < nstyles; k++) {
if (flag == ELLIPSOID && strcmp(keywords[k],"ellipsoid") != 0) continue; if (flag == ELLIPSOID && strcmp(keywords[k], "ellipsoid") != 0) continue;
if (flag == LINE && strcmp(keywords[k],"line") != 0) continue; if (flag == LINE && strcmp(keywords[k], "line") != 0) continue;
if (flag == TRIANGLE && strcmp(keywords[k],"tri") != 0) continue; if (flag == TRIANGLE && strcmp(keywords[k], "tri") != 0) continue;
if (flag == BODY && strcmp(keywords[k],"body") != 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 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++) { for (int k = 0; k < nstyles; k++) {
int index = styles[k]->property_atom(name); int index = styles[k]->property_atom(name);
if (index >= 0) return index*nstyles + k; if (index >= 0) return index * nstyles + k;
} }
return -1; return -1;
} }
@ -522,12 +452,11 @@ int AtomVecHybrid::property_atom(char *name)
index maps to data specific to this atom style index maps to data specific to this atom style
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void AtomVecHybrid::pack_property_atom(int multiindex, double *buf, void AtomVecHybrid::pack_property_atom(int multiindex, double *buf, int nvalues, int groupbit)
int nvalues, int groupbit)
{ {
int k = multiindex % nstyles; int k = multiindex % nstyles;
int index = multiindex/nstyles; int index = multiindex / nstyles;
styles[k]->pack_property_atom(index,buf,nvalues,groupbit); 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 merge fields into root vector and remove duplicate fields
concat = root + Inum fields string from all substyles
return dedup = concat with duplicate fields removed
if concat_flag set, also return concat (w/ duplicates) 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, void AtomVecHybrid::merge_fields(std::vector<std::string> &root,
int concat_flag, char *&concat_str) 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; for (const auto &field : fields) {
if (root) concat += root; if (concat_flag) concat.push_back(field);
for (int k = 0; k < nstyles; k++) { if (std::find(root.begin(), root.end(), field) == root.end()) root.push_back(field);
if (concat.size() > 0) concat += " ";
concat += fieldstrings[k].fstr[inum];
} }
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,19 +489,19 @@ void AtomVecHybrid::build_styles()
{ {
nallstyles = 0; nallstyles = 0;
#define ATOM_CLASS #define ATOM_CLASS
#define AtomStyle(key,Class) nallstyles++; #define AtomStyle(key, Class) nallstyles++;
#include "style_atom.h" // IWYU pragma: keep #include "style_atom.h" // IWYU pragma: keep
#undef AtomStyle #undef AtomStyle
#undef ATOM_CLASS #undef ATOM_CLASS
allstyles = new char*[nallstyles]; allstyles = new char *[nallstyles];
nallstyles = 0; nallstyles = 0;
#define ATOM_CLASS #define ATOM_CLASS
#define AtomStyle(key,Class) \ #define AtomStyle(key, Class) \
allstyles[nallstyles] = utils::strdup(#key); \ allstyles[nallstyles] = utils::strdup(#key); \
nallstyles++; nallstyles++;
#include "style_atom.h" // IWYU pragma: keep #include "style_atom.h" // IWYU pragma: keep
#undef AtomStyle #undef AtomStyle
#undef ATOM_CLASS #undef ATOM_CLASS
} }
@ -611,6 +513,6 @@ void AtomVecHybrid::build_styles()
int AtomVecHybrid::known_style(char *str) int AtomVecHybrid::known_style(char *str)
{ {
for (int i = 0; i < nallstyles; i++) 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; 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; int pack_data_bonus(double *, int) override;
void write_data_bonus(FILE *, int, 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; void pack_property_atom(int, double *, int, int) override;
private: private:
int nallstyles; int nallstyles;
char **allstyles; char **allstyles;
int fields_allocated;
struct FieldStrings {
char **fstr;
};
FieldStrings *fieldstrings;
int nstyles_bonus; int nstyles_bonus;
class AtomVec **styles_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(); void build_styles();
int known_style(char *); 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -23,12 +22,11 @@
#include "modify.h" #include "modify.h"
#include <cmath> #include <cmath>
#include <cstring>
using namespace LAMMPS_NS; 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "molecule radius rmass omega torque line"; fields_grow = {"molecule", "radius", "rmass", "omega", "torque", "line"};
fields_copy = (char *) "molecule radius rmass omega"; fields_copy = {"molecule", "radius", "rmass", "omega"};
fields_comm = (char *) ""; fields_comm = {};
fields_comm_vel = (char *) "omega"; fields_comm_vel = {"omega"};
fields_reverse = (char *) "torque"; fields_reverse = {"torque"};
fields_border = (char *) "molecule radius rmass"; fields_border = {"molecule", "radius", "rmass"};
fields_border_vel = (char *) "molecule radius rmass omega"; fields_border_vel = {"molecule", "radius", "rmass", "omega"};
fields_exchange = (char *) "molecule radius rmass omega"; fields_exchange = {"molecule", "radius", "rmass", "omega"};
fields_restart = (char *) "molecule radius rmass omega"; fields_restart = {"molecule", "radius", "rmass", "omega"};
fields_create = (char *) "molecule radius rmass omega line"; fields_create = {"molecule", "radius", "rmass", "omega", "line"};
fields_data_atom = (char *) "id molecule type line rmass x"; fields_data_atom = {"id", "molecule", "type", "line", "rmass", "x"};
fields_data_vel = (char *) "id v omega"; fields_data_vel = {"id", "v", "omega"};
setup_fields(); setup_fields();
} }
@ -85,7 +83,7 @@ void AtomVecLine::init()
AtomVec::init(); AtomVec::init();
if (domain->dimension != 2) 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() void AtomVecLine::grow_bonus()
{ {
nmax_bonus = grow_nmax_bonus(nmax_bonus); nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0) if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big");
error->one(FLERR,"Per-processor system is too big");
bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus), bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom: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 deleting atom J via delflag and J has bonus data, then delete it
if (delflag && line[j] >= 0) { if (delflag && line[j] >= 0) {
copy_bonus_all(nlocal_bonus-1,line[j]); copy_bonus_all(nlocal_bonus - 1, line[j]);
nlocal_bonus--; 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) void AtomVecLine::copy_bonus_all(int i, int j)
{ {
line[bonus[i].ilocal] = 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 AtomVecLine::pack_comm_bonus(int n, int *list, double *buf)
{ {
int i,j,m; int i, j, m;
m = 0; m = 0;
for (i = 0; i < n; i++) { 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) void AtomVecLine::unpack_comm_bonus(int n, int first, double *buf)
{ {
int i,m,last; int i, m, last;
m = 0; m = 0;
last = first + n; 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 AtomVecLine::pack_border_bonus(int n, int *list, double *buf)
{ {
int i,j,m; int i, j, m;
m = 0; m = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
j = list[i]; j = list[i];
if (line[j] < 0) buf[m++] = ubuf(0).d; if (line[j] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
buf[m++] = bonus[line[j]].length; 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 AtomVecLine::unpack_border_bonus(int n, int first, double *buf)
{ {
int i,j,m,last; int i, j, m, last;
m = 0; m = 0;
last = first + n; last = first + n;
for (i = first; i < last; i++) { for (i = first; i < last; i++) {
line[i] = (int) ubuf(buf[m++]).i; line[i] = (int) ubuf(buf[m++]).i;
if (line[i] == 0) line[i] = -1; if (line[i] == 0)
line[i] = -1;
else { else {
j = nlocal_bonus + nghost_bonus; j = nlocal_bonus + nghost_bonus;
if (j == nmax_bonus) grow_bonus(); if (j == nmax_bonus) grow_bonus();
@ -242,7 +240,8 @@ int AtomVecLine::pack_exchange_bonus(int i, double *buf)
{ {
int m = 0; int m = 0;
if (line[i] < 0) buf[m++] = ubuf(0).d; if (line[i] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
int j = line[i]; int j = line[i];
@ -260,7 +259,8 @@ int AtomVecLine::unpack_exchange_bonus(int ilocal, double *buf)
int m = 0; int m = 0;
line[ilocal] = (int) ubuf(buf[m++]).i; line[ilocal] = (int) ubuf(buf[m++]).i;
if (line[ilocal] == 0) line[ilocal] = -1; if (line[ilocal] == 0)
line[ilocal] = -1;
else { else {
if (nlocal_bonus == nmax_bonus) grow_bonus(); if (nlocal_bonus == nmax_bonus) grow_bonus();
bonus[nlocal_bonus].length = buf[m++]; bonus[nlocal_bonus].length = buf[m++];
@ -284,8 +284,10 @@ int AtomVecLine::size_restart_bonus()
int n = 0; int n = 0;
int nlocal = atom->nlocal; int nlocal = atom->nlocal;
for (i = 0; i < nlocal; i++) { for (i = 0; i < nlocal; i++) {
if (line[i] >= 0) n += size_restart_bonus_one; if (line[i] >= 0)
else n++; n += size_restart_bonus_one;
else
n++;
} }
return n; return n;
@ -301,7 +303,8 @@ int AtomVecLine::pack_restart_bonus(int i, double *buf)
{ {
int m = 0; int m = 0;
if (line[i] < 0) buf[m++] = ubuf(0).d; if (line[i] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
int j = line[i]; int j = line[i];
@ -321,7 +324,8 @@ int AtomVecLine::unpack_restart_bonus(int ilocal, double *buf)
int m = 0; int m = 0;
line[ilocal] = (int) ubuf(buf[m++]).i; line[ilocal] = (int) ubuf(buf[m++]).i;
if (line[ilocal] == 0) line[ilocal] = -1; if (line[ilocal] == 0)
line[ilocal] = -1;
else { else {
if (nlocal_bonus == nmax_bonus) grow_bonus(); if (nlocal_bonus == nmax_bonus) grow_bonus();
bonus[nlocal_bonus].length = buf[m++]; 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) 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(); if (nlocal_bonus == nmax_bonus) grow_bonus();
int ivalue = 1; int ivalue = 1;
double x1 = 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 y1 = utils::numeric(FLERR, values[ivalue++], true, lmp);
double x2 = 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 y2 = utils::numeric(FLERR, values[ivalue++], true, lmp);
double dx = x2 - x1; double dx = x2 - x1;
double dy = y2 - y1; double dy = y2 - y1;
double length = sqrt(dx*dx + dy*dy); double length = sqrt(dx * dx + dy * dy);
bonus[nlocal_bonus].length = length; bonus[nlocal_bonus].length = length;
if (dy >= 0.0) bonus[nlocal_bonus].theta = acos(dx/length); if (dy >= 0.0)
else bonus[nlocal_bonus].theta = -acos(dx/length); bonus[nlocal_bonus].theta = acos(dx / length);
else
bonus[nlocal_bonus].theta = -acos(dx / length);
double xc = 0.5*(x1+x2); double xc = 0.5 * (x1 + x2);
double yc = 0.5*(y1+y2); double yc = 0.5 * (y1 + y2);
dx = xc - x[m][0]; dx = xc - x[m][0];
dy = yc - x[m][1]; dy = yc - x[m][1];
double delta = sqrt(dx*dx + dy*dy); double delta = sqrt(dx * dx + dy * dy);
if (delta/length > EPSILON) if (delta / length > EPSILON) error->one(FLERR, "Inconsistent line segment in data file");
error->one(FLERR,"Inconsistent line segment in data file");
x[m][0] = xc; x[m][0] = xc;
x[m][1] = yc; 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 AtomVecLine::memory_usage_bonus()
{ {
double bytes = 0; double bytes = 0;
bytes += (double)nmax_bonus*sizeof(Bonus); bytes += (double) nmax_bonus * sizeof(Bonus);
return bytes; return bytes;
} }
@ -398,7 +403,7 @@ void AtomVecLine::create_atom_post(int ilocal)
{ {
double radius_one = 0.5; double radius_one = 0.5;
radius[ilocal] = radius_one; 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; line[ilocal] = -1;
} }
@ -410,19 +415,22 @@ void AtomVecLine::create_atom_post(int ilocal)
void AtomVecLine::data_atom_post(int ilocal) void AtomVecLine::data_atom_post(int ilocal)
{ {
line_flag = line[ilocal]; line_flag = line[ilocal];
if (line_flag == 0) line_flag = -1; if (line_flag == 0)
else if (line_flag == 1) line_flag = 0; line_flag = -1;
else error->one(FLERR,"Invalid line flag in Atoms section of data file"); 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; line[ilocal] = line_flag;
if (rmass[ilocal] <= 0.0) if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file");
error->one(FLERR,"Invalid density in Atoms section of data file");
if (line_flag < 0) { if (line_flag < 0) {
double radius_one = 0.5; double radius_one = 0.5;
radius[ilocal] = radius_one; 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;
} else radius[ilocal] = 0.0; } else
radius[ilocal] = 0.0;
omega[ilocal][0] = 0.0; omega[ilocal][0] = 0.0;
omega[ilocal][1] = 0.0; omega[ilocal][1] = 0.0;
@ -438,13 +446,16 @@ void AtomVecLine::pack_data_pre(int ilocal)
line_flag = line[ilocal]; line_flag = line[ilocal];
rmass_one = rmass[ilocal]; rmass_one = rmass[ilocal];
if (line_flag < 0) line[ilocal] = 0; if (line_flag < 0)
else line[ilocal] = 1; line[ilocal] = 0;
else
line[ilocal] = 1;
if (line_flag < 0) { if (line_flag < 0) {
double radius_one = radius[ilocal]; 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 rmass[ilocal] /= bonus[line_flag].length; } 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 AtomVecLine::pack_data_bonus(double *buf, int /*flag*/)
{ {
int i,j; int i, j;
double length,theta; double length, theta;
double xc,yc,x1,x2,y1,y2; double xc, yc, x1, x2, y1, y2;
double **x = atom->x; double **x = atom->x;
tagint *tag = atom->tag; tagint *tag = atom->tag;
@ -482,15 +493,16 @@ int AtomVecLine::pack_data_bonus(double *buf, int /*flag*/)
theta = bonus[j].theta; theta = bonus[j].theta;
xc = x[i][0]; xc = x[i][0];
yc = x[i][1]; yc = x[i][1];
x1 = xc - 0.5*cos(theta)*length; x1 = xc - 0.5 * cos(theta) * length;
y1 = yc - 0.5*sin(theta)*length; y1 = yc - 0.5 * sin(theta) * length;
x2 = xc + 0.5*cos(theta)*length; x2 = xc + 0.5 * cos(theta) * length;
y2 = yc + 0.5*sin(theta)*length; y2 = yc + 0.5 * sin(theta) * length;
buf[m++] = x1; buf[m++] = x1;
buf[m++] = y1; buf[m++] = y1;
buf[m++] = x2; buf[m++] = x2;
buf[m++] = y2; buf[m++] = y2;
} else m += size_data_bonus; } else
m += size_data_bonus;
} }
return m; return m;
} }
@ -503,8 +515,8 @@ void AtomVecLine::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/)
{ {
int i = 0; int i = 0;
while (i < n) { while (i < n) {
fmt::print(fp,"{} {} {} {} {}\n",ubuf(buf[i]).i, fmt::print(fp, "{} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3],
buf[i+1],buf[i+2],buf[i+3],buf[i+4]); buf[i + 4]);
i += size_data_bonus; i += size_data_bonus;
} }
} }
@ -525,10 +537,11 @@ void AtomVecLine::set_length(int i, double value)
bonus[nlocal_bonus].ilocal = i; bonus[nlocal_bonus].ilocal = i;
line[i] = nlocal_bonus++; line[i] = nlocal_bonus++;
} else if (value == 0.0) { } else if (value == 0.0) {
copy_bonus_all(nlocal_bonus-1,line[i]); copy_bonus_all(nlocal_bonus - 1, line[i]);
nlocal_bonus--; nlocal_bonus--;
line[i] = -1; line[i] = -1;
} else bonus[line[i]].length = value; } else
bonus[line[i]].length = value;
// also set radius = half of length // also set radius = half of length
// unless value = 0.0, then set diameter = 1.0 // 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; radius[i] = 0.5 * value;
if (value == 0.0) radius[i] = 0.5; 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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -21,8 +20,6 @@
#include "math_const.h" #include "math_const.h"
#include "modify.h" #include "modify.h"
#include <cstring>
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
using namespace MathConst; using namespace MathConst;
@ -34,26 +31,25 @@ AtomVecSphere::AtomVecSphere(LAMMPS *lmp) : AtomVec(lmp)
molecular = Atom::ATOMIC; molecular = Atom::ATOMIC;
atom->sphere_flag = 1; atom->sphere_flag = 1;
atom->radius_flag = atom->rmass_flag = atom->omega_flag = atom->radius_flag = atom->rmass_flag = atom->omega_flag = atom->torque_flag = 1;
atom->torque_flag = 1;
// strings with peratom variables to include in each AtomVec method // strings with peratom variables to include in each AtomVec method
// strings cannot contain fields in corresponding AtomVec default strings // strings cannot contain fields in corresponding AtomVec default strings
// order of fields in a string does not matter // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "radius rmass omega torque"; fields_grow = {"radius", "rmass", "omega", "torque"};
fields_copy = (char *) "radius rmass omega"; fields_copy = {"radius", "rmass", "omega"};
fields_comm = (char *) ""; fields_comm = {};
fields_comm_vel = (char *) "omega"; fields_comm_vel = {"omega"};
fields_reverse = (char *) "torque"; fields_reverse = {"torque"};
fields_border = (char *) "radius rmass"; fields_border = {"radius", "rmass"};
fields_border_vel = (char *) "radius rmass omega"; fields_border_vel = {"radius", "rmass", "omega"};
fields_exchange = (char *) "radius rmass omega"; fields_exchange = {"radius", "rmass", "omega"};
fields_restart = (char *) "radius rmass omega"; fields_restart = {"radius", "rmass", "omega"};
fields_create = (char *) "radius rmass omega"; fields_create = {"radius", "rmass", "omega"};
fields_data_atom = (char *) "id type radius rmass x"; fields_data_atom = {"id", "type", "radius", "rmass", "x"};
fields_data_vel = (char *) "id v omega"; fields_data_vel = {"id", "v", "omega"};
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
@ -63,21 +59,19 @@ AtomVecSphere::AtomVecSphere(LAMMPS *lmp) : AtomVec(lmp)
void AtomVecSphere::process_args(int narg, char **arg) void AtomVecSphere::process_args(int narg, char **arg)
{ {
if (narg != 0 && narg != 1) if (narg != 0 && narg != 1) error->all(FLERR, "Illegal atom_style sphere command");
error->all(FLERR,"Illegal atom_style sphere command");
radvary = 0; radvary = 0;
if (narg == 1) { if (narg == 1) {
radvary = utils::numeric(FLERR,arg[0],true,lmp); radvary = utils::numeric(FLERR, arg[0], true, lmp);
if (radvary < 0 || radvary > 1) if (radvary < 0 || radvary > 1) error->all(FLERR, "Illegal atom_style sphere command");
error->all(FLERR,"Illegal atom_style sphere command");
} }
// dynamic particle radius and mass must be communicated every step // dynamic particle radius and mass must be communicated every step
if (radvary) { if (radvary) {
fields_comm = (char *) "radius rmass"; fields_comm = {"radius", "rmass"};
fields_comm_vel = (char *) "radius rmass omega"; fields_comm_vel = {"radius", "rmass", "omega"};
} }
// delay setting up of fields until now // 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 // check if optional radvary setting should have been set to 1
for (int i = 0; i < modify->nfix; i++) for (int i = 0; i < modify->nfix; i++)
if (strcmp(modify->fix[i]->style,"adapt") == 0) { if (strcmp(modify->fix[i]->style, "adapt") == 0) {
auto fix = dynamic_cast<FixAdapt *>( modify->fix[i]); auto fix = dynamic_cast<FixAdapt *>(modify->fix[i]);
if (fix->diamflag && radvary == 0) if (fix->diamflag && radvary == 0)
error->all(FLERR,"Fix adapt changes particle radii " error->all(FLERR, "Fix adapt changes particle radii but atom_style sphere is not dynamic");
"but atom_style sphere is not dynamic");
} }
} }
@ -121,7 +114,7 @@ void AtomVecSphere::grow_pointers()
void AtomVecSphere::create_atom_post(int ilocal) void AtomVecSphere::create_atom_post(int ilocal)
{ {
radius[ilocal] = 0.5; 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_one = 0.5 * atom->radius[ilocal];
radius[ilocal] = radius_one; radius[ilocal] = radius_one;
if (radius_one > 0.0) if (radius_one > 0.0) 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;
if (rmass[ilocal] <= 0.0) if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file");
error->one(FLERR,"Invalid density in Atoms section of data file");
omega[ilocal][0] = 0.0; omega[ilocal][0] = 0.0;
omega[ilocal][1] = 0.0; omega[ilocal][1] = 0.0;
@ -154,9 +145,8 @@ void AtomVecSphere::pack_data_pre(int ilocal)
rmass_one = rmass[ilocal]; rmass_one = rmass[ilocal];
radius[ilocal] *= 2.0; radius[ilocal] *= 2.0;
if (radius_one!= 0.0) if (radius_one != 0.0)
rmass[ilocal] = rmass[ilocal] = rmass_one / (4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one);
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 LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -19,18 +18,17 @@
#include "error.h" #include "error.h"
#include "fix.h" #include "fix.h"
#include "math_const.h" #include "math_const.h"
#include "math_extra.h"
#include "math_eigen.h" #include "math_eigen.h"
#include "math_extra.h"
#include "memory.h" #include "memory.h"
#include "modify.h" #include "modify.h"
#include <cmath> #include <cmath>
#include <cstring>
using namespace LAMMPS_NS; 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 // order of fields in a string does not matter
// except: fields_data_atom & fields_data_vel must match data file // except: fields_data_atom & fields_data_vel must match data file
fields_grow = (char *) "molecule radius rmass omega angmom torque tri"; fields_grow = {"molecule", "radius", "rmass", "omega", "angmom", "torque", "tri"};
fields_copy = (char *) "molecule radius rmass omega angmom"; fields_copy = {"molecule", "radius", "rmass", "omega", "angmom"};
fields_comm = (char *) ""; fields_comm = {};
fields_comm_vel = (char *) "omega angmom"; fields_comm_vel = {"omega", "angmom"};
fields_reverse = (char *) "torque"; fields_reverse = {"torque"};
fields_border = (char *) "molecule radius rmass"; fields_border = {"molecule", "radius", "rmass"};
fields_border_vel = (char *) "molecule radius rmass omega"; fields_border_vel = {"molecule", "radius", "rmass", "omega"};
fields_exchange = (char *) "molecule radius rmass omega angmom"; fields_exchange = {"molecule", "radius", "rmass", "omega", "angmom"};
fields_restart = (char *) "molecule radius rmass omega angmom"; fields_restart = {"molecule", "radius", "rmass", "omega", "angmom"};
fields_create = (char *) "molecule radius rmass omega angmom tri"; fields_create = {"molecule", "radius", "rmass", "omega", "angmom", "tri"};
fields_data_atom = (char *) "id molecule type tri rmass x"; fields_data_atom = {"id", "molecule", "type", "tri", "rmass", "x"};
fields_data_vel = (char *) "id v omega angmom"; fields_data_vel = {"id", "v", "omega", "angmom"};
setup_fields(); setup_fields();
} }
@ -88,7 +86,7 @@ void AtomVecTri::init()
AtomVec::init(); AtomVec::init();
if (domain->dimension != 3) 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() void AtomVecTri::grow_bonus()
{ {
nmax_bonus = grow_nmax_bonus(nmax_bonus); nmax_bonus = grow_nmax_bonus(nmax_bonus);
if (nmax_bonus < 0) if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big");
error->one(FLERR,"Per-processor system is too big");
bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus), bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom: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 deleting atom J via delflag and J has bonus data, then delete it
if (delflag && tri[j] >= 0) { if (delflag && tri[j] >= 0) {
copy_bonus_all(nlocal_bonus-1,tri[j]); copy_bonus_all(nlocal_bonus - 1, tri[j]);
nlocal_bonus--; 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) void AtomVecTri::copy_bonus_all(int i, int j)
{ {
tri[bonus[i].ilocal] = 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 AtomVecTri::pack_comm_bonus(int n, int *list, double *buf)
{ {
int i,j,m; int i, j, m;
double *quat; double *quat;
m = 0; 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) void AtomVecTri::unpack_comm_bonus(int n, int first, double *buf)
{ {
int i,m,last; int i, m, last;
double *quat; double *quat;
m = 0; 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 AtomVecTri::pack_border_bonus(int n, int *list, double *buf)
{ {
int i,j,m; int i, j, m;
double *quat,*c1,*c2,*c3,*inertia; double *quat, *c1, *c2, *c3, *inertia;
m = 0; m = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
j = list[i]; j = list[i];
if (tri[j] < 0) buf[m++] = ubuf(0).d; if (tri[j] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
quat = bonus[tri[j]].quat; 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 AtomVecTri::unpack_border_bonus(int n, int first, double *buf)
{ {
int i,j,m,last; int i, j, m, last;
double *quat,*c1,*c2,*c3,*inertia; double *quat, *c1, *c2, *c3, *inertia;
m = 0; m = 0;
last = first + n; last = first + n;
for (i = first; i < last; i++) { for (i = first; i < last; i++) {
tri[i] = (int) ubuf(buf[m++]).i; tri[i] = (int) ubuf(buf[m++]).i;
if (tri[i] == 0) tri[i] = -1; if (tri[i] == 0)
tri[i] = -1;
else { else {
j = nlocal_bonus + nghost_bonus; j = nlocal_bonus + nghost_bonus;
if (j == nmax_bonus) grow_bonus(); if (j == nmax_bonus) grow_bonus();
@ -301,7 +299,8 @@ int AtomVecTri::pack_exchange_bonus(int i, double *buf)
{ {
int m = 0; int m = 0;
if (tri[i] < 0) buf[m++] = ubuf(0).d; if (tri[i] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
int j = tri[i]; int j = tri[i];
@ -338,7 +337,8 @@ int AtomVecTri::unpack_exchange_bonus(int ilocal, double *buf)
int m = 0; int m = 0;
tri[ilocal] = (int) ubuf(buf[m++]).i; tri[ilocal] = (int) ubuf(buf[m++]).i;
if (tri[ilocal] == 0) tri[ilocal] = -1; if (tri[ilocal] == 0)
tri[ilocal] = -1;
else { else {
if (nlocal_bonus == nmax_bonus) grow_bonus(); if (nlocal_bonus == nmax_bonus) grow_bonus();
double *quat = bonus[nlocal_bonus].quat; double *quat = bonus[nlocal_bonus].quat;
@ -381,8 +381,10 @@ int AtomVecTri::size_restart_bonus()
int n = 0; int n = 0;
int nlocal = atom->nlocal; int nlocal = atom->nlocal;
for (i = 0; i < nlocal; i++) { for (i = 0; i < nlocal; i++) {
if (tri[i] >= 0) n += size_restart_bonus_one; if (tri[i] >= 0)
else n++; n += size_restart_bonus_one;
else
n++;
} }
return n; return n;
@ -396,7 +398,8 @@ int AtomVecTri::pack_restart_bonus(int i, double *buf)
{ {
int m = 0; int m = 0;
if (tri[i] < 0) buf[m++] = ubuf(0).d; if (tri[i] < 0)
buf[m++] = ubuf(0).d;
else { else {
buf[m++] = ubuf(1).d; buf[m++] = ubuf(1).d;
int j = tri[i]; int j = tri[i];
@ -435,7 +438,8 @@ int AtomVecTri::unpack_restart_bonus(int ilocal, double *buf)
int m = 0; int m = 0;
tri[ilocal] = (int) ubuf(buf[m++]).i; tri[ilocal] = (int) ubuf(buf[m++]).i;
if (tri[ilocal] == 0) tri[ilocal] = -1; if (tri[ilocal] == 0)
tri[ilocal] = -1;
else { else {
if (nlocal_bonus == nmax_bonus) grow_bonus(); if (nlocal_bonus == nmax_bonus) grow_bonus();
double *quat = bonus[nlocal_bonus].quat; 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) 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(); if (nlocal_bonus == nmax_bonus) grow_bonus();
double c1[3],c2[3],c3[3]; double c1[3], c2[3], c3[3];
int ivalue = 1; int ivalue = 1;
c1[0] = 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[1] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c1[2] = 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[0] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c2[1] = 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); c2[2] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c3[0] = 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[1] = utils::numeric(FLERR, values[ivalue++], true, lmp);
c3[2] = utils::numeric(FLERR,values[ivalue++],true,lmp); c3[2] = utils::numeric(FLERR, values[ivalue++], true, lmp);
// check for duplicate points // check for duplicate points
if (c1[0] == c2[0] && c1[1] == c2[1] && c1[2] == c2[2]) 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]) 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]) 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 // size = length of one edge
double c2mc1[3],c3mc1[3]; double c2mc1[3], c3mc1[3];
MathExtra::sub3(c2,c1,c2mc1); MathExtra::sub3(c2, c1, c2mc1);
MathExtra::sub3(c3,c1,c3mc1); MathExtra::sub3(c3, c1, c3mc1);
double size = MAX(MathExtra::len3(c2mc1),MathExtra::len3(c3mc1)); double size = MAX(MathExtra::len3(c2mc1), MathExtra::len3(c3mc1));
// centroid = 1/3 of sum of vertices // centroid = 1/3 of sum of vertices
double centroid[3]; double centroid[3];
centroid[0] = (c1[0]+c2[0]+c3[0]) / 3.0; centroid[0] = (c1[0] + c2[0] + c3[0]) / 3.0;
centroid[1] = (c1[1]+c2[1]+c3[1]) / 3.0; centroid[1] = (c1[1] + c2[1] + c3[1]) / 3.0;
centroid[2] = (c1[2]+c2[2]+c3[2]) / 3.0; centroid[2] = (c1[2] + c2[2] + c3[2]) / 3.0;
double dx = centroid[0] - x[m][0]; double dx = centroid[0] - x[m][0];
double dy = centroid[1] - x[m][1]; double dy = centroid[1] - x[m][1];
double dz = centroid[2] - x[m][2]; 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) if (delta / size > EPSILON) error->one(FLERR, "Inconsistent triangle in data file");
error->one(FLERR,"Inconsistent triangle in data file");
x[m][0] = centroid[0]; x[m][0] = centroid[0];
x[m][1] = centroid[1]; 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 // tri area = 0.5 len(U x V), where U,V are edge vectors from one vertex
double c4[3]; double c4[3];
MathExtra::sub3(c1,centroid,c4); MathExtra::sub3(c1, centroid, c4);
radius[m] = MathExtra::lensq3(c4); radius[m] = MathExtra::lensq3(c4);
MathExtra::sub3(c2,centroid,c4); MathExtra::sub3(c2, centroid, c4);
radius[m] = MAX(radius[m],MathExtra::lensq3(c4)); radius[m] = MAX(radius[m], MathExtra::lensq3(c4));
MathExtra::sub3(c3,centroid,c4); MathExtra::sub3(c3, centroid, c4);
radius[m] = MAX(radius[m],MathExtra::lensq3(c4)); radius[m] = MAX(radius[m], MathExtra::lensq3(c4));
radius[m] = sqrt(radius[m]); radius[m] = sqrt(radius[m]);
double norm[3]; double norm[3];
MathExtra::cross3(c2mc1,c3mc1,norm); MathExtra::cross3(c2mc1, c3mc1, norm);
double area = 0.5 * MathExtra::len3(norm); double area = 0.5 * MathExtra::len3(norm);
rmass[m] *= area; rmass[m] *= area;
// inertia = inertia tensor of triangle as 6-vector in Voigt ordering // inertia = inertia tensor of triangle as 6-vector in Voigt ordering
double inertia[6]; 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 // diagonalize inertia tensor via Jacobi rotations
// bonus[].inertia = 3 eigenvalues = principal moments of inertia // bonus[].inertia = 3 eigenvalues = principal moments of inertia
// evectors and exzy_space = 3 evectors = principal axes of triangle // 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[0][0] = inertia[0];
tensor[1][1] = inertia[1]; tensor[1][1] = inertia[1];
tensor[2][2] = inertia[2]; 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][2] = tensor[2][0] = inertia[4];
tensor[0][1] = tensor[1][0] = inertia[5]; tensor[0][1] = tensor[1][0] = inertia[5];
int ierror = MathEigen::jacobi3(tensor,bonus[nlocal_bonus].inertia,evectors); int ierror = MathEigen::jacobi3(tensor, bonus[nlocal_bonus].inertia, evectors);
if (ierror) error->one(FLERR,"Insufficient Jacobi rotations for triangle"); 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[0] = evectors[0][0];
ex_space[1] = evectors[1][0]; ex_space[1] = evectors[1][0];
ex_space[2] = evectors[2][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 // enforce 3 orthogonal vectors as a right-handed coordinate system
// flip 3rd vector if needed // flip 3rd vector if needed
MathExtra::cross3(ex_space,ey_space,norm); MathExtra::cross3(ex_space, ey_space, norm);
if (MathExtra::dot3(norm,ez_space) < 0.0) MathExtra::negate3(ez_space); if (MathExtra::dot3(norm, ez_space) < 0.0) MathExtra::negate3(ez_space);
// create initial quaternion // 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 // bonus c1,c2,c3 = displacement of c1,c2,c3 from centroid
// in basis of principal axes // in basis of principal axes
double disp[3]; double disp[3];
MathExtra::sub3(c1,centroid,disp); MathExtra::sub3(c1, centroid, disp);
MathExtra::transpose_matvec(ex_space,ey_space,ez_space, MathExtra::transpose_matvec(ex_space, ey_space, ez_space, disp, bonus[nlocal_bonus].c1);
disp,bonus[nlocal_bonus].c1); MathExtra::sub3(c2, centroid, disp);
MathExtra::sub3(c2,centroid,disp); MathExtra::transpose_matvec(ex_space, ey_space, ez_space, disp, bonus[nlocal_bonus].c2);
MathExtra::transpose_matvec(ex_space,ey_space,ez_space, MathExtra::sub3(c3, centroid, disp);
disp,bonus[nlocal_bonus].c2); MathExtra::transpose_matvec(ex_space, ey_space, ez_space, disp, bonus[nlocal_bonus].c3);
MathExtra::sub3(c3,centroid,disp);
MathExtra::transpose_matvec(ex_space,ey_space,ez_space,
disp,bonus[nlocal_bonus].c3);
bonus[nlocal_bonus].ilocal = m; bonus[nlocal_bonus].ilocal = m;
tri[m] = nlocal_bonus++; 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 AtomVecTri::memory_usage_bonus()
{ {
double bytes = 0; double bytes = 0;
bytes += (double)nmax_bonus*sizeof(Bonus); bytes += (double) nmax_bonus * sizeof(Bonus);
return bytes; return bytes;
} }
@ -620,7 +620,7 @@ void AtomVecTri::create_atom_post(int ilocal)
{ {
double radius_one = 0.5; double radius_one = 0.5;
radius[ilocal] = radius_one; 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; tri[ilocal] = -1;
} }
@ -632,19 +632,22 @@ void AtomVecTri::create_atom_post(int ilocal)
void AtomVecTri::data_atom_post(int ilocal) void AtomVecTri::data_atom_post(int ilocal)
{ {
tri_flag = tri[ilocal]; tri_flag = tri[ilocal];
if (tri_flag == 0) tri_flag = -1; if (tri_flag == 0)
else if (tri_flag == 1) tri_flag = 0; tri_flag = -1;
else error->one(FLERR,"Invalid tri flag in Atoms section of data file"); 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; tri[ilocal] = tri_flag;
if (rmass[ilocal] <= 0.0) if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file");
error->one(FLERR,"Invalid density in Atoms section of data file");
if (tri_flag < 0) { if (tri_flag < 0) {
double radius_one = 0.5; double radius_one = 0.5;
radius[ilocal] = radius_one; 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;
} else radius[ilocal] = 0.0; } else
radius[ilocal] = 0.0;
omega[ilocal][0] = 0.0; omega[ilocal][0] = 0.0;
omega[ilocal][1] = 0.0; omega[ilocal][1] = 0.0;
@ -663,17 +666,19 @@ void AtomVecTri::pack_data_pre(int ilocal)
tri_flag = tri[ilocal]; tri_flag = tri[ilocal];
rmass_one = rmass[ilocal]; rmass_one = rmass[ilocal];
if (tri_flag < 0) tri[ilocal] = 0; if (tri_flag < 0)
else tri[ilocal] = 1; tri[ilocal] = 0;
else
tri[ilocal] = 1;
if (tri_flag < 0) { if (tri_flag < 0) {
double radius_one = radius[ilocal]; 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 { } else {
double c2mc1[3],c3mc1[3],norm[3]; double c2mc1[3], c3mc1[3], norm[3];
MathExtra::sub3(bonus[tri_flag].c2,bonus[tri_flag].c1,c2mc1); MathExtra::sub3(bonus[tri_flag].c2, bonus[tri_flag].c1, c2mc1);
MathExtra::sub3(bonus[tri_flag].c3,bonus[tri_flag].c1,c3mc1); MathExtra::sub3(bonus[tri_flag].c3, bonus[tri_flag].c1, c3mc1);
MathExtra::cross3(c2mc1,c3mc1,norm); MathExtra::cross3(c2mc1, c3mc1, norm);
double area = 0.5 * MathExtra::len3(norm); double area = 0.5 * MathExtra::len3(norm);
rmass[ilocal] /= area; rmass[ilocal] /= area;
} }
@ -696,9 +701,9 @@ void AtomVecTri::pack_data_post(int ilocal)
int AtomVecTri::pack_data_bonus(double *buf, int /*flag*/) int AtomVecTri::pack_data_bonus(double *buf, int /*flag*/)
{ {
int i,j; int i, j;
double xc,yc,zc; double xc, yc, zc;
double dc1[3],dc2[3],dc3[3]; double dc1[3], dc2[3], dc3[3];
double p[3][3]; double p[3][3];
double **x = atom->x; double **x = atom->x;
@ -711,10 +716,10 @@ int AtomVecTri::pack_data_bonus(double *buf, int /*flag*/)
if (buf) { if (buf) {
buf[m++] = ubuf(tag[i]).d; buf[m++] = ubuf(tag[i]).d;
j = tri[i]; j = tri[i];
MathExtra::quat_to_mat(bonus[j].quat,p); MathExtra::quat_to_mat(bonus[j].quat, p);
MathExtra::matvec(p,bonus[j].c1,dc1); MathExtra::matvec(p, bonus[j].c1, dc1);
MathExtra::matvec(p,bonus[j].c2,dc2); MathExtra::matvec(p, bonus[j].c2, dc2);
MathExtra::matvec(p,bonus[j].c3,dc3); MathExtra::matvec(p, bonus[j].c3, dc3);
xc = x[i][0]; xc = x[i][0];
yc = x[i][1]; yc = x[i][1];
zc = x[i][2]; zc = x[i][2];
@ -727,7 +732,8 @@ int AtomVecTri::pack_data_bonus(double *buf, int /*flag*/)
buf[m++] = xc + dc3[0]; buf[m++] = xc + dc3[0];
buf[m++] = yc + dc3[1]; buf[m++] = yc + dc3[1];
buf[m++] = zc + dc3[2]; buf[m++] = zc + dc3[2];
} else m += size_data_bonus; } else
m += size_data_bonus;
} }
return m; return m;
} }
@ -740,9 +746,8 @@ void AtomVecTri::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/)
{ {
int i = 0; int i = 0;
while (i < n) { while (i < n) {
fmt::print(fp,"{} {} {} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, fmt::print(fp, "{} {} {} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2],
buf[i+1],buf[i+2],buf[i+3],buf[i+4],buf[i+5],buf[i+6], buf[i + 3], buf[i + 4], buf[i + 5], buf[i + 6], buf[i + 7], buf[i + 8], buf[i + 9]);
buf[i+7],buf[i+8],buf[i+9]);
i += size_data_bonus; i += size_data_bonus;
} }
} }
@ -770,24 +775,24 @@ void AtomVecTri::set_equilateral(int i, double size)
quat[1] = 0.0; quat[1] = 0.0;
quat[2] = 0.0; quat[2] = 0.0;
quat[3] = 0.0; quat[3] = 0.0;
c1[0] = -size/2.0; c1[0] = -size / 2.0;
c1[1] = -sqrt(3.0)/2.0 * size / 3.0; c1[1] = -sqrt(3.0) / 2.0 * size / 3.0;
c1[2] = 0.0; c1[2] = 0.0;
c2[0] = size/2.0; c2[0] = size / 2.0;
c2[1] = -sqrt(3.0)/2.0 * size / 3.0; c2[1] = -sqrt(3.0) / 2.0 * size / 3.0;
c2[2] = 0.0; c2[2] = 0.0;
c3[0] = 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; c3[2] = 0.0;
inertia[0] = sqrt(3.0)/96.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[1] = sqrt(3.0) / 96.0 * size * size * size * size;
inertia[2] = sqrt(3.0)/48.0 * size*size*size*size; inertia[2] = sqrt(3.0) / 48.0 * size * size * size * size;
radius[i] = MathExtra::len3(c1); radius[i] = MathExtra::len3(c1);
bonus[nlocal_bonus].ilocal = i; bonus[nlocal_bonus].ilocal = i;
tri[i] = nlocal_bonus++; tri[i] = nlocal_bonus++;
} else if (size == 0.0) { } else if (size == 0.0) {
radius[i] = 0.5; radius[i] = 0.5;
copy_bonus_all(nlocal_bonus-1,tri[i]); copy_bonus_all(nlocal_bonus - 1, tri[i]);
nlocal_bonus--; nlocal_bonus--;
tri[i] = -1; tri[i] = -1;
} else { } else {
@ -795,18 +800,18 @@ void AtomVecTri::set_equilateral(int i, double size)
double *c2 = bonus[tri[i]].c2; double *c2 = bonus[tri[i]].c2;
double *c3 = bonus[tri[i]].c3; double *c3 = bonus[tri[i]].c3;
double *inertia = bonus[tri[i]].inertia; double *inertia = bonus[tri[i]].inertia;
c1[0] = -size/2.0; c1[0] = -size / 2.0;
c1[1] = -sqrt(3.0)/2.0 * size / 3.0; c1[1] = -sqrt(3.0) / 2.0 * size / 3.0;
c1[2] = 0.0; c1[2] = 0.0;
c2[0] = size/2.0; c2[0] = size / 2.0;
c2[1] = -sqrt(3.0)/2.0 * size / 3.0; c2[1] = -sqrt(3.0) / 2.0 * size / 3.0;
c2[2] = 0.0; c2[2] = 0.0;
c3[0] = 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; c3[2] = 0.0;
inertia[0] = sqrt(3.0)/96.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[1] = sqrt(3.0) / 96.0 * size * size * size * size;
inertia[2] = sqrt(3.0)/48.0 * size*size*size*size; inertia[2] = sqrt(3.0) / 48.0 * size * size * size * size;
radius[i] = MathExtra::len3(c1); radius[i] = MathExtra::len3(c1);
} }
} }