From b16d48aa41468d0cf2244b1e50fce680afc00517 Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Thu, 14 Apr 2022 11:06:10 -0400 Subject: [PATCH] "stringify" and "vectorize" processing of per-atom attributs in AtomVec classes --- src/AWPMD/atom_vec_wavepacket.cpp | 76 +- src/CG-DNA/atom_vec_oxdna.cpp | 24 +- src/DIELECTRIC/atom_vec_dielectric.cpp | 163 ++--- src/DIELECTRIC/atom_vec_dielectric.h | 2 +- src/DIPOLE/atom_vec_dipole.cpp | 28 +- src/DPD-MESO/atom_vec_edpd.cpp | 32 +- src/DPD-MESO/atom_vec_mdpd.cpp | 57 +- src/DPD-MESO/atom_vec_mdpd.h | 2 +- src/DPD-MESO/atom_vec_tdpd.cpp | 48 +- src/DPD-REACT/atom_vec_dpd.cpp | 29 +- src/EFF/atom_vec_electron.cpp | 88 +-- src/EFF/atom_vec_electron.h | 2 +- src/KOKKOS/atom_vec_hybrid_kokkos.cpp | 17 +- src/KOKKOS/atom_vec_hybrid_kokkos.h | 2 +- src/MACHDYN/atom_vec_smd.cpp | 80 +-- src/MESONT/atom_vec_mesont.cpp | 26 +- src/MOLECULE/atom_vec_angle.cpp | 54 +- src/MOLECULE/atom_vec_bond.cpp | 35 +- src/MOLECULE/atom_vec_full.cpp | 104 ++- src/MOLECULE/atom_vec_molecular.cpp | 101 ++- src/MOLECULE/atom_vec_template.cpp | 43 +- src/PERI/atom_vec_peri.cpp | 68 +- src/PERI/atom_vec_peri.h | 2 +- src/SPH/atom_vec_sph.cpp | 76 +- src/SPH/atom_vec_sph.h | 2 +- src/SPIN/atom_vec_spin.cpp | 37 +- src/atom_vec.cpp | 943 ++++++++++++------------- src/atom_vec.h | 22 +- src/atom_vec_atomic.cpp | 25 +- src/atom_vec_body.cpp | 224 +++--- src/atom_vec_charge.cpp | 25 +- src/atom_vec_ellipsoid.cpp | 137 ++-- src/atom_vec_hybrid.cpp | 322 +++------ src/atom_vec_hybrid.h | 11 +- src/atom_vec_line.cpp | 196 +++-- src/atom_vec_sphere.cpp | 62 +- src/atom_vec_tri.cpp | 263 +++---- 37 files changed, 1596 insertions(+), 1832 deletions(-) diff --git a/src/AWPMD/atom_vec_wavepacket.cpp b/src/AWPMD/atom_vec_wavepacket.cpp index c339e8343f..bea662eda5 100644 --- a/src/AWPMD/atom_vec_wavepacket.cpp +++ b/src/AWPMD/atom_vec_wavepacket.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -20,8 +19,6 @@ #include "atom.h" -#include - using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ @@ -32,33 +29,29 @@ AtomVecWavepacket::AtomVecWavepacket(LAMMPS *lmp) : AtomVec(lmp) molecular = Atom::ATOMIC; forceclearflag = 1; - atom->wavepacket_flag = 1; - atom->electron_flag = 1; // compatible with eff - atom->q_flag = atom->spin_flag = atom->eradius_flag = - atom->ervel_flag = atom->erforce_flag = 1; - atom->cs_flag = atom->csforce_flag = - atom->vforce_flag = atom->ervelforce_flag = atom->etag_flag = 1; + atom->wavepacket_flag = atom->q_flag = atom->spin_flag = atom->eradius_flag = 1; + atom->ervel_flag = atom->erforce_flag = atom->cs_flag = atom->csforce_flag = 1; + atom->vforce_flag = atom->ervelforce_flag = atom->etag_flag = 1; // strings with peratom variables to include in each AtomVec method // strings cannot contain fields in corresponding AtomVec default strings // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) - "q spin eradius ervel erforce cs csforce " - "vforce ervelforce etag"; - fields_copy = (char *) "q spin eradius ervel cs etag"; - fields_comm = (char *) "eradius"; - fields_comm_vel = (char *) "eradius ervel cs"; - fields_reverse = (char *) "erforce ervelforce vforce csforce"; - fields_border = (char *) "q spin eradius etag"; - fields_border_vel = (char *) "q spin eradius etag ervel cs"; - fields_exchange = (char *) "q spin eradius ervel etag cs"; - fields_restart = (char *) "q spin eradius ervel etag cs"; - fields_create = (char *) "q spin eradius ervel etag cs"; - fields_data_atom = (char *) "id type q spin eradius etag cs x"; - fields_data_vel = (char *) "id v ervel"; + fields_grow = {"q", "spin", "eradius", "ervel", "erforce", + "cs", "csforce", "vforce", "ervelforce", "etag"}; + fields_copy = {"q", "spin", "eradius", "ervel", "cs", "etag"}; + fields_comm = {"eradius"}; + fields_comm_vel = {"eradius", "ervel", "cs"}; + fields_reverse = {"erforce", "ervelforce", "vforce", "csforce"}; + fields_border = {"q", "spin", "eradius", "etag"}; + fields_border_vel = {"q", "spin", "eradius", "etag", "ervel", "cs"}; + fields_exchange = {"q", "spin", "eradius", "ervel", "etag", "cs"}; + fields_restart = {"q", "spin", "eradius", "ervel", "etag", "cs"}; + fields_create = {"q", "spin", "eradius", "ervel", "etag", "cs"}; + fields_data_atom = {"id", "type", "q", "spin", "eradius", "etag", "cs", "x"}; + fields_data_vel = {"id", "v", "ervel"}; setup_fields(); } @@ -84,7 +77,7 @@ void AtomVecWavepacket::grow_pointers() void AtomVecWavepacket::force_clear(int n, size_t nbytes) { - memset(&erforce[n],0,nbytes); + memset(&erforce[n], 0, nbytes); } /* ---------------------------------------------------------------------- @@ -114,10 +107,10 @@ void AtomVecWavepacket::data_atom_post(int ilocal) int AtomVecWavepacket::property_atom(char *name) { - if (strcmp(name,"spin") == 0) return 0; - if (strcmp(name,"eradius") == 0) return 1; - if (strcmp(name,"ervel") == 0) return 2; - if (strcmp(name,"erforce") == 0) return 3; + if (strcmp(name, "spin") == 0) return 0; + if (strcmp(name, "eradius") == 0) return 1; + if (strcmp(name, "ervel") == 0) return 2; + if (strcmp(name, "erforce") == 0) return 3; return -1; } @@ -126,34 +119,41 @@ int AtomVecWavepacket::property_atom(char *name) index maps to data specific to this atom style ------------------------------------------------------------------------- */ -void AtomVecWavepacket::pack_property_atom(int index, double *buf, - int nvalues, int groupbit) +void AtomVecWavepacket::pack_property_atom(int index, double *buf, int nvalues, int groupbit) { int nlocal = atom->nlocal; int n = 0; if (index == 0) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = spin[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = spin[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 1) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = eradius[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = eradius[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 2) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = ervel[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = ervel[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 3) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = erforce[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = erforce[i]; + else + buf[n] = 0.0; n += nvalues; } } diff --git a/src/CG-DNA/atom_vec_oxdna.cpp b/src/CG-DNA/atom_vec_oxdna.cpp index 120fe5d9ac..6c06ee9349 100644 --- a/src/CG-DNA/atom_vec_oxdna.cpp +++ b/src/CG-DNA/atom_vec_oxdna.cpp @@ -33,18 +33,18 @@ AtomVecOxdna::AtomVecOxdna(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "id5p"; - fields_copy = (char *) "id5p"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) ""; - fields_reverse = (char *) ""; - fields_border = (char *) "id5p"; - fields_border_vel = (char *) ""; - fields_exchange = (char *) "id5p"; - fields_restart = (char *) "id5p"; - fields_create = (char *) ""; - fields_data_atom = (char *) "id type x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"id5p"}; + fields_copy = {"id5p"}; + fields_comm = {}; + fields_comm_vel = {}; + fields_reverse = {}; + fields_border = {"id5p"}; + fields_border_vel = {}; + fields_exchange = {"id5p"}; + fields_restart = {"id5p"}; + fields_create = {}; + fields_data_atom = {"id", "type", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); diff --git a/src/DIELECTRIC/atom_vec_dielectric.cpp b/src/DIELECTRIC/atom_vec_dielectric.cpp index 2d6d6d00b1..4d65c07969 100644 --- a/src/DIELECTRIC/atom_vec_dielectric.cpp +++ b/src/DIELECTRIC/atom_vec_dielectric.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/ Sandia National Laboratories @@ -18,23 +17,21 @@ #include "citeme.h" #include -#include using namespace LAMMPS_NS; static const char cite_user_dielectric_package[] = - "DIELECTRIC package:\n\n" - "@Article{TrungCPC19,\n" - " author = {Trung Dac Nguyen, Honghao Li, Debarshee Bagchi," - " Francisco J. Solis, Monica Olvera de la Cruz,\n" - " title = {Incorporating surface polarization effects into large-scale" - " coarse-grained Molecular Dynamics simulation},\n" - " journal = {Comp.~Phys.~Comm.},\n" - " year = 2019,\n" - " volume = 241,\n" - " pages = {80--91}\n" - "}\n\n" - ; + "DIELECTRIC package:\n\n" + "@Article{TrungCPC19,\n" + " author = {Trung Dac Nguyen, Honghao Li, Debarshee Bagchi," + " Francisco J. Solis, Monica Olvera de la Cruz,\n" + " title = {Incorporating surface polarization effects into large-scale" + " coarse-grained Molecular Dynamics simulation},\n" + " journal = {Comp.~Phys.~Comm.},\n" + " year = 2019,\n" + " volume = 241,\n" + " pages = {80--91}\n" + "}\n\n"; /* ---------------------------------------------------------------------- */ @@ -53,55 +50,41 @@ AtomVecDielectric::AtomVecDielectric(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) - "q molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4 " - "nspecial special " - "mu area ed em epsilon curvature q_unscaled"; - fields_copy = (char *) - "q molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4 " - "nspecial special " - "mu area ed em epsilon curvature q_unscaled"; - fields_comm = (char *) "q mu area ed em epsilon curvature q_unscaled"; - fields_comm_vel = (char *) ""; - fields_reverse = (char *) ""; - fields_border = (char *) "q molecule mu area ed em epsilon curvature q_unscaled"; - fields_border_vel = (char *) "q molecule mu area ed em epsilon curvature q_unscaled"; - fields_exchange = (char *) - "q molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4 " - "nspecial special " - "mu area ed em epsilon curvature q_unscaled"; - fields_restart = (char *) - "q molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4 " - "mu area ed em epsilon curvature q_unscaled"; - fields_create = (char *) - "q molecule num_bond num_angle num_dihedral num_improper nspecial " - "mu area ed em epsilon curvature q_unscaled"; - fields_data_atom = (char *) "id molecule type q x " - "mu3 area ed em epsilon curvature"; - fields_data_vel = (char *) "id v"; + // clang-format off + fields_grow = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type", + "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1", + "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", + "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special", + "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"}; + fields_copy = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type", + "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1", + "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", + "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special", + "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"}; + fields_comm = {"q", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"}; + fields_comm_vel = {}; + fields_reverse = {}; + fields_border = {"q", "molecule", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"}; + fields_border_vel = {"q", "molecule", "mu", "area", "ed", "em", "epsilon", "curvature", + "q_unscaled"}; + fields_exchange = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", + "angle_type", "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", + "dihedral_atom1", "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", + "improper_type", "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", + "nspecial", "special", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"}; + fields_restart = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", + "angle_type", "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", + "dihedral_atom1", "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", + "improper_type", "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", + "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"}; + fields_create = {"q", "molecule", "num_bond", "num_angle", "num_dihedral", "num_improper", + "nspecial", "mu", "area", "ed", "em", "epsilon", "curvature", "q_unscaled"}; + fields_data_atom = { "id", "molecule", "type", "q", "x", "mu3", "area", "ed", "em", "epsilon", + "curvature"}; + fields_data_vel = {"id v"}; + // clang-format on setup_fields(); - bond_per_atom = angle_per_atom = dihedral_per_atom = improper_per_atom = 0; } @@ -157,13 +140,12 @@ void AtomVecDielectric::data_atom_post(int ilocal) nspecial[ilocal][1] = 0; nspecial[ilocal][2] = 0; - double* q = atom->q; + double *q = atom->q; q_unscaled[ilocal] = q[ilocal]; q[ilocal] /= epsilon[ilocal]; double *mu_one = mu[ilocal]; - mu_one[3] = - sqrt(mu_one[0]*mu_one[0] + mu_one[1]*mu_one[1] + mu_one[2]*mu_one[2]); + mu_one[3] = sqrt(mu_one[0] * mu_one[0] + mu_one[1] * mu_one[1] + mu_one[2] * mu_one[2]); } /* ---------------------------------------------------------------------- @@ -182,14 +164,14 @@ void AtomVecDielectric::unpack_restart_init(int ilocal) return -1 if name is unknown to this atom style ------------------------------------------------------------------------- */ -int AtomVecDielectric::property_atom(char *name) +int AtomVecDielectric::property_atom(const std::string &name) { - if (strcmp(name,"area") == 0) return 0; - if (strcmp(name,"ed") == 0) return 1; - if (strcmp(name,"em") == 0) return 2; - if (strcmp(name,"epsilon") == 0) return 3; - if (strcmp(name,"curvature") == 0) return 4; - if (strcmp(name,"q_unscaled") == 0) return 5; + if (name == "area") return 0; + if (name == "ed") return 1; + if (name == "em") return 2; + if (name == "epsilon") return 3; + if (name == "curvature") return 4; + if (name == "q_unscaled") return 5; return -1; } @@ -198,8 +180,7 @@ int AtomVecDielectric::property_atom(char *name) index maps to data specific to this atom style ------------------------------------------------------------------------- */ -void AtomVecDielectric::pack_property_atom(int index, double *buf, - int nvalues, int groupbit) +void AtomVecDielectric::pack_property_atom(int index, double *buf, int nvalues, int groupbit) { int *mask = atom->mask; int nlocal = atom->nlocal; @@ -207,38 +188,50 @@ void AtomVecDielectric::pack_property_atom(int index, double *buf, if (index == 0) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = area[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = area[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 1) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = ed[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = ed[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 2) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = em[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = em[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 3) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = epsilon[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = epsilon[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 4) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = curvature[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = curvature[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 5) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = q_unscaled[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = q_unscaled[i]; + else + buf[n] = 0.0; n += nvalues; } } diff --git a/src/DIELECTRIC/atom_vec_dielectric.h b/src/DIELECTRIC/atom_vec_dielectric.h index 2d4510b330..7e38164582 100644 --- a/src/DIELECTRIC/atom_vec_dielectric.h +++ b/src/DIELECTRIC/atom_vec_dielectric.h @@ -35,7 +35,7 @@ class AtomVecDielectric : public AtomVec { void create_atom_post(int) override; void data_atom_post(int) override; void unpack_restart_init(int) override; - int property_atom(char *) override; + int property_atom(const std::string &) override; void pack_property_atom(int, double *, int, int) override; protected: diff --git a/src/DIPOLE/atom_vec_dipole.cpp b/src/DIPOLE/atom_vec_dipole.cpp index a38e1d6d01..cd0ce5bff3 100644 --- a/src/DIPOLE/atom_vec_dipole.cpp +++ b/src/DIPOLE/atom_vec_dipole.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -34,18 +33,18 @@ AtomVecDipole::AtomVecDipole(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "q mu"; - fields_copy = (char *) "q mu"; - fields_comm = (char *) "mu3"; - fields_comm_vel = (char *) "mu3"; - fields_reverse = (char *) ""; - fields_border = (char *) "q mu"; - fields_border_vel = (char *) "q mu"; - fields_exchange = (char *) "q mu"; - fields_restart = (char *) "q mu"; - fields_create = (char *) "q mu"; - fields_data_atom = (char *) "id type q x mu3"; - fields_data_vel = (char *) "id v"; + fields_grow = {"q", "mu"}; + fields_copy = {"q", "mu"}; + fields_comm = {"mu3"}; + fields_comm_vel = {"mu3"}; + fields_reverse = {}; + fields_border = {"q", "mu"}; + fields_border_vel = {"q", "mu"}; + fields_exchange = {"q", "mu"}; + fields_restart = {"q", "mu"}; + fields_create = {"q", "mu"}; + fields_data_atom = {"id", "type", "q", "x", "mu3"}; + fields_data_vel = {"id", "v"}; setup_fields(); } @@ -68,6 +67,5 @@ void AtomVecDipole::grow_pointers() void AtomVecDipole::data_atom_post(int ilocal) { double *mu_one = mu[ilocal]; - mu_one[3] = - sqrt(mu_one[0]*mu_one[0] + mu_one[1]*mu_one[1] + mu_one[2]*mu_one[2]); + mu_one[3] = sqrt(mu_one[0] * mu_one[0] + mu_one[1] * mu_one[1] + mu_one[2] * mu_one[2]); } diff --git a/src/DPD-MESO/atom_vec_edpd.cpp b/src/DPD-MESO/atom_vec_edpd.cpp index cf7c8ed29f..d8592d26f5 100644 --- a/src/DPD-MESO/atom_vec_edpd.cpp +++ b/src/DPD-MESO/atom_vec_edpd.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -38,18 +37,18 @@ AtomVecEDPD::AtomVecEDPD(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "edpd_cv edpd_temp edpd_flux vest vest_temp"; - fields_copy = (char *) "edpd_cv edpd_temp edpd_flux vest vest_temp"; - fields_comm = (char *) "edpd_temp vest vest_temp"; - fields_comm_vel = (char *) "edpd_temp vest vest_temp"; - fields_reverse = (char *) "edpd_flux"; - fields_border = (char *) "edpd_cv edpd_temp vest vest_temp"; - fields_border_vel = (char *) "edpd_cv edpd_temp vest vest_temp"; - fields_exchange = (char *) "edpd_cv edpd_temp vest vest_temp"; - fields_restart = (char * ) "edpd_cv edpd_temp vest vest_temp"; - fields_create = (char *) "edpd_cv edpd_temp edpd_flux vest vest_temp"; - fields_data_atom = (char *) "id type edpd_temp edpd_cv x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"edpd_cv", "edpd_temp", "edpd_flux", "vest", "vest_temp"}; + fields_copy = {"edpd_cv", "edpd_temp", "edpd_flux", "vest", "vest_temp"}; + fields_comm = {"edpd_temp", "vest", "vest_temp"}; + fields_comm_vel = {"edpd_temp", "vest", "vest_temp"}; + fields_reverse = {"edpd_flux"}; + fields_border = {"edpd_cv", "edpd_temp", "vest", "vest_temp"}; + fields_border_vel = {"edpd_cv", "edpd_temp", "vest", "vest_temp"}; + fields_exchange = {"edpd_cv", "edpd_temp", "vest", "vest_temp"}; + fields_restart = {"edpd_cv", "edpd_temp", "vest", "vest_temp"}; + fields_create = {"edpd_cv", "edpd_temp", "edpd_flux", "vest", "vest_temp"}; + fields_data_atom = {"id", "type", "edpd_temp", "edpd_cv", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); } @@ -60,8 +59,7 @@ void AtomVecEDPD::init() { AtomVec::init(); - if (strcmp(update->unit_style,"lj") != 0) - error->all(FLERR,"Atom style edpd requires lj units"); + if (strcmp(update->unit_style, "lj") != 0) error->all(FLERR, "Atom style edpd requires lj units"); } /* ---------------------------------------------------------------------- @@ -85,7 +83,7 @@ void AtomVecEDPD::grow_pointers() void AtomVecEDPD::force_clear(int n, size_t nbytes) { - memset(&edpd_flux[n],0,nbytes); + memset(&edpd_flux[n], 0, nbytes); } /* ---------------------------------------------------------------------- @@ -95,7 +93,7 @@ void AtomVecEDPD::force_clear(int n, size_t nbytes) void AtomVecEDPD::create_atom_post(int ilocal) { edpd_temp[ilocal] = 1.0; - edpd_cv[ilocal]= 1.0e5; + edpd_cv[ilocal] = 1.0e5; vest_temp[ilocal] = edpd_temp[ilocal]; } diff --git a/src/DPD-MESO/atom_vec_mdpd.cpp b/src/DPD-MESO/atom_vec_mdpd.cpp index 5a05d33b79..4b9b58b0d6 100644 --- a/src/DPD-MESO/atom_vec_mdpd.cpp +++ b/src/DPD-MESO/atom_vec_mdpd.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -13,10 +12,12 @@ ------------------------------------------------------------------------- */ #include "atom_vec_mdpd.h" -#include + #include "atom.h" -#include "update.h" #include "error.h" +#include "update.h" + +#include using namespace LAMMPS_NS; @@ -36,18 +37,18 @@ AtomVecMDPD::AtomVecMDPD(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "rho drho vest"; - fields_copy = (char *) "rho drho vest"; - fields_comm = (char *) "rho vest"; - fields_comm_vel = (char *) "rho vest"; - fields_reverse = (char *) "drho"; - fields_border = (char *) "rho vest"; - fields_border_vel = (char *) "rho vest"; - fields_exchange = (char *) "rho vest"; - fields_restart = (char * ) "rho vest"; - fields_create = (char *) "rho drho vest"; - fields_data_atom = (char *) "id type rho x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"rho", "drho", "vest"}; + fields_copy = {"rho", "drho", "vest"}; + fields_comm = {"rho", "vest"}; + fields_comm_vel = {"rho", "vest"}; + fields_reverse = {"drho"}; + fields_border = {"rho", "vest"}; + fields_border_vel = {"rho", "vest"}; + fields_exchange = {"rho", "vest"}; + fields_restart = {"rho", "vest"}; + fields_create = {"rho", "drho", "vest"}; + fields_data_atom = {"id", "type", "rho", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); } @@ -58,8 +59,7 @@ void AtomVecMDPD::init() { AtomVec::init(); - if (strcmp(update->unit_style,"lj") != 0) - error->all(FLERR,"Atom style mdpd requires lj units"); + if (strcmp(update->unit_style, "lj") != 0) error->all(FLERR, "Atom style mdpd requires lj units"); } /* ---------------------------------------------------------------------- @@ -81,7 +81,7 @@ void AtomVecMDPD::grow_pointers() void AtomVecMDPD::force_clear(int n, size_t nbytes) { - memset(&drho[n],0,nbytes); + memset(&drho[n], 0, nbytes); } /* ---------------------------------------------------------------------- @@ -102,10 +102,10 @@ void AtomVecMDPD::data_atom_post(int ilocal) return -1 if name is unknown to this atom style ------------------------------------------------------------------------- */ -int AtomVecMDPD::property_atom(char *name) +int AtomVecMDPD::property_atom(const std::string &name) { - if (strcmp(name,"rho") == 0) return 0; - if (strcmp(name,"drho") == 0) return 1; + if (name == "rho") return 0; + if (name == "drho") return 1; return -1; } @@ -114,8 +114,7 @@ int AtomVecMDPD::property_atom(char *name) index maps to data specific to this atom style ------------------------------------------------------------------------- */ -void AtomVecMDPD::pack_property_atom(int index, double *buf, - int nvalues, int groupbit) +void AtomVecMDPD::pack_property_atom(int index, double *buf, int nvalues, int groupbit) { int *mask = atom->mask; int nlocal = atom->nlocal; @@ -123,14 +122,18 @@ void AtomVecMDPD::pack_property_atom(int index, double *buf, int n = 0; if (index == 0) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = rho[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = rho[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 1) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = drho[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = drho[i]; + else + buf[n] = 0.0; n += nvalues; } } diff --git a/src/DPD-MESO/atom_vec_mdpd.h b/src/DPD-MESO/atom_vec_mdpd.h index 4e8aefeebe..1d7bc3db71 100644 --- a/src/DPD-MESO/atom_vec_mdpd.h +++ b/src/DPD-MESO/atom_vec_mdpd.h @@ -32,7 +32,7 @@ class AtomVecMDPD : public AtomVec { void grow_pointers() override; void force_clear(int, size_t) override; void data_atom_post(int) override; - int property_atom(char *) override; + int property_atom(const std::string &) override; void pack_property_atom(int, double *, int, int) override; private: diff --git a/src/DPD-MESO/atom_vec_tdpd.cpp b/src/DPD-MESO/atom_vec_tdpd.cpp index 8b558457ed..bbd6bc89bc 100644 --- a/src/DPD-MESO/atom_vec_tdpd.cpp +++ b/src/DPD-MESO/atom_vec_tdpd.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -13,11 +12,12 @@ ------------------------------------------------------------------------- */ #include "atom_vec_tdpd.h" -#include -#include "atom.h" -#include "update.h" -#include "error.h" +#include "atom.h" +#include "error.h" +#include "update.h" + +#include using namespace LAMMPS_NS; @@ -37,18 +37,18 @@ AtomVecTDPD::AtomVecTDPD(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "cc cc_flux vest"; - fields_copy = (char *) "cc vest"; - fields_comm = (char *) "cc vest"; - fields_comm_vel = (char *) "cc vest"; - fields_reverse = (char *) "cc_flux"; - fields_border = (char *) "cc vest"; - fields_border_vel = (char *) "cc vest"; - fields_exchange = (char *) "cc vest"; - fields_restart = (char * ) "cc vest"; - fields_create = (char *) "cc vest"; - fields_data_atom = (char *) "id type x cc"; - fields_data_vel = (char *) "id v"; + fields_grow = {"cc", "cc_flux", "vest"}; + fields_copy = {"cc", "vest"}; + fields_comm = {"cc", "vest"}; + fields_comm_vel = {"cc", "vest"}; + fields_reverse = {"cc_flux"}; + fields_border = {"cc", "vest"}; + fields_border_vel = {"cc", "vest"}; + fields_exchange = {"cc", "vest"}; + fields_restart = {"cc", "vest"}; + fields_create = {"cc", "vest"}; + fields_data_atom = {"id", "type", "x", "cc"}; + fields_data_vel = {"id", "v"}; } /* ---------------------------------------------------------------------- @@ -58,13 +58,13 @@ AtomVecTDPD::AtomVecTDPD(LAMMPS *lmp) : AtomVec(lmp) void AtomVecTDPD::process_args(int narg, char **arg) { - if (narg < 1) error->all(FLERR,"Invalid atom_style tdpd command"); + if (narg < 1) error->all(FLERR, "Invalid atom_style tdpd command"); - atom->cc_species = utils::inumeric(FLERR,arg[0],false,lmp); + atom->cc_species = utils::inumeric(FLERR, arg[0], false, lmp); cc_species = atom->cc_species; - atom->add_peratom_change_columns("cc",cc_species); - atom->add_peratom_change_columns("cc_flux",cc_species); + atom->add_peratom_change_columns("cc", cc_species); + atom->add_peratom_change_columns("cc_flux", cc_species); // delay setting up of fields until now @@ -77,8 +77,7 @@ void AtomVecTDPD::init() { AtomVec::init(); - if (strcmp(update->unit_style,"lj") != 0) - error->all(FLERR,"Atom style tdpd requires lj units"); + if (strcmp(update->unit_style, "lj") != 0) error->all(FLERR, "Atom style tdpd requires lj units"); } /* ---------------------------------------------------------------------- @@ -92,7 +91,6 @@ void AtomVecTDPD::grow_pointers() vest = atom->vest; } - /* ---------------------------------------------------------------------- clear extra forces starting at atom N nbytes = # of bytes to clear for a per-atom vector @@ -100,7 +98,7 @@ void AtomVecTDPD::grow_pointers() void AtomVecTDPD::force_clear(int n, size_t nbytes) { - memset(&cc_flux[n][0],0,cc_species*nbytes); + memset(&cc_flux[n][0], 0, cc_species * nbytes); } /* ---------------------------------------------------------------------- diff --git a/src/DPD-REACT/atom_vec_dpd.cpp b/src/DPD-REACT/atom_vec_dpd.cpp index 461b1d2246..8df589ad71 100644 --- a/src/DPD-REACT/atom_vec_dpd.cpp +++ b/src/DPD-REACT/atom_vec_dpd.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -17,6 +16,7 @@ ------------------------------------------------------------------------- */ #include "atom_vec_dpd.h" + #include "atom.h" #include "error.h" @@ -37,18 +37,18 @@ AtomVecDPD::AtomVecDPD(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "rho dpdTheta uCond uMech uChem uCG uCGnew duChem"; - fields_copy = (char *) "dpdTheta uCond uMech uChem uCG uCGnew"; - fields_comm = (char *) "dpdTheta uCond uMech uChem"; - fields_comm_vel = (char *) "dpdTheta uCond uMech uChem"; - fields_reverse = (char *) ""; - fields_border = (char *) "dpdTheta uCond uMech uChem uCG uCGnew"; - fields_border_vel = (char *) "dpdTheta uCond uMech uChem uCG uCGnew"; - fields_exchange = (char *) "dpdTheta uCond uMech uChem uCG uCGnew"; - fields_restart = (char *) "dpdTheta uCond uMech uChem"; - fields_create = (char *) "rho dpdTheta uCond uMech uChem uCG uCGnew duChem"; - fields_data_atom = (char *) "id type dpdTheta x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"rho", "dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew", "duChem"}; + fields_copy = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"}; + fields_comm = {"dpdTheta", "uCond", "uMech", "uChem"}; + fields_comm_vel = {"dpdTheta", "uCond", "uMech", "uChem"}; + fields_reverse = {}; + fields_border = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"}; + fields_border_vel = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"}; + fields_exchange = {"dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew"}; + fields_restart = {"dpdTheta", "uCond", "uMech", "uChem"}; + fields_create = {"rho", "dpdTheta", "uCond", "uMech", "uChem", "uCG", "uCGnew", "duChem"}; + fields_data_atom = {"id", "type", "dpdTheta", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); } @@ -94,6 +94,5 @@ void AtomVecDPD::data_atom_post(int ilocal) uCGnew[ilocal] = 0.0; if (dpdTheta[ilocal] <= 0) - error->one(FLERR,"Internal temperature in Atoms section of date file " - "must be > zero"); + error->one(FLERR, "Internal temperature in Atoms section of date file must be > zero"); } diff --git a/src/EFF/atom_vec_electron.cpp b/src/EFF/atom_vec_electron.cpp index ca80f186a8..1f9d1f3e65 100644 --- a/src/EFF/atom_vec_electron.cpp +++ b/src/EFF/atom_vec_electron.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -21,20 +20,19 @@ #include "atom.h" #include "citeme.h" -#include - using namespace LAMMPS_NS; static const char cite_user_eff_package[] = - "EFF package:\n\n" - "@Article{Jaramillo-Botero11,\n" - " author = {A. Jaramillo-Botero, J. Su, A. Qi, W. A. Goddard III},\n" - " title = {Large-Scale, Long-Term Nonadiabatic Electron Molecular Dynamics for Describing Material Properties and Phenomena in Extreme Environments},\n" - " journal = {J.~Comp.~Chem.},\n" - " year = 2011,\n" - " volume = 32,\n" - " pages = {497--512}\n" - "}\n\n"; + "EFF package:\n\n" + "@Article{Jaramillo-Botero11,\n" + " author = {A. Jaramillo-Botero, J. Su, A. Qi, W. A. Goddard III},\n" + " title = {Large-Scale, Long-Term Nonadiabatic Electron Molecular Dynamics for Describing " + "Material Properties and Phenomena in Extreme Environments},\n" + " journal = {J.~Comp.~Chem.},\n" + " year = 2011,\n" + " volume = 32,\n" + " pages = {497--512}\n" + "}\n\n"; /* ---------------------------------------------------------------------- */ @@ -47,26 +45,25 @@ AtomVecElectron::AtomVecElectron(LAMMPS *lmp) : AtomVec(lmp) forceclearflag = 1; atom->electron_flag = 1; - atom->q_flag = atom->spin_flag = atom->eradius_flag = - atom->ervel_flag = atom->erforce_flag = 1; + atom->q_flag = atom->spin_flag = atom->eradius_flag = atom->ervel_flag = atom->erforce_flag = 1; // strings with peratom variables to include in each AtomVec method // strings cannot contain fields in corresponding AtomVec default strings // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "q spin eradius ervel erforce"; - fields_copy = (char *) "q spin eradius ervel"; - fields_comm = (char *) "eradius"; - fields_comm_vel = (char *) "eradius"; - fields_reverse = (char *) "erforce"; - fields_border = (char *) "q spin eradius"; - fields_border_vel = (char *) "q spin eradius"; - fields_exchange = (char *) "q spin eradius ervel"; - fields_restart = (char *) "q spin eradius ervel"; - fields_create = (char *) "q spin eradius ervel"; - fields_data_atom = (char *) "id type q spin eradius x"; - fields_data_vel = (char *) "id v ervel"; + fields_grow = {"q", "spin", "eradius", "ervel", "erforce"}; + fields_copy = {"q", "spin", "eradius", "ervel"}; + fields_comm = {"eradius"}; + fields_comm_vel = {"eradius"}; + fields_reverse = {"erforce"}; + fields_border = {"q", "spin", "eradius"}; + fields_border_vel = {"q", "spin", "eradius"}; + fields_exchange = {"q", "spin", "eradius", "ervel"}; + fields_restart = {"q", "spin", "eradius", "ervel"}; + fields_create = {"q", "spin", "eradius", "ervel"}; + fields_data_atom = {"id", "type", "q", "spin", "eradius", "x"}; + fields_data_vel = {"id", "v", "ervel"}; setup_fields(); } @@ -91,7 +88,7 @@ void AtomVecElectron::grow_pointers() void AtomVecElectron::force_clear(int n, size_t nbytes) { - memset(&erforce[n],0,nbytes); + memset(&erforce[n], 0, nbytes); } /* ---------------------------------------------------------------------- @@ -119,12 +116,12 @@ void AtomVecElectron::data_atom_post(int ilocal) return -1 if name is unknown to this atom style ------------------------------------------------------------------------- */ -int AtomVecElectron::property_atom(char *name) +int AtomVecElectron::property_atom(const std::string &name) { - if (strcmp(name,"spin") == 0) return 0; - if (strcmp(name,"eradius") == 0) return 1; - if (strcmp(name,"ervel") == 0) return 2; - if (strcmp(name,"erforce") == 0) return 3; + if (name == "spin") return 0; + if (name == "eradius") return 1; + if (name == "ervel") return 2; + if (name == "erforce") return 3; return -1; } @@ -133,8 +130,7 @@ int AtomVecElectron::property_atom(char *name) index maps to data specific to this atom style ------------------------------------------------------------------------- */ -void AtomVecElectron::pack_property_atom(int index, double *buf, - int nvalues, int groupbit) +void AtomVecElectron::pack_property_atom(int index, double *buf, int nvalues, int groupbit) { int *mask = atom->mask; int nlocal = atom->nlocal; @@ -142,26 +138,34 @@ void AtomVecElectron::pack_property_atom(int index, double *buf, if (index == 0) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = spin[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = spin[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 1) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = eradius[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = eradius[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 2) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = ervel[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = ervel[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 3) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = erforce[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = erforce[i]; + else + buf[n] = 0.0; n += nvalues; } } diff --git a/src/EFF/atom_vec_electron.h b/src/EFF/atom_vec_electron.h index 6c9b11cccb..21015d56b0 100644 --- a/src/EFF/atom_vec_electron.h +++ b/src/EFF/atom_vec_electron.h @@ -32,7 +32,7 @@ class AtomVecElectron : public AtomVec { void force_clear(int, size_t) override; void create_atom_post(int) override; void data_atom_post(int) override; - int property_atom(char *) override; + int property_atom(const std::string &) override; void pack_property_atom(int, double *, int, int) override; private: diff --git a/src/KOKKOS/atom_vec_hybrid_kokkos.cpp b/src/KOKKOS/atom_vec_hybrid_kokkos.cpp index 22ce80478c..c733e5fe18 100644 --- a/src/KOKKOS/atom_vec_hybrid_kokkos.cpp +++ b/src/KOKKOS/atom_vec_hybrid_kokkos.cpp @@ -1073,17 +1073,14 @@ void AtomVecHybridKokkos::write_data(FILE *fp, int n, double **buf) int k,m; for (int i = 0; i < n; i++) { - fprintf(fp,TAGINT_FORMAT " %d %-1.16e %-1.16e %-1.16e", - (tagint) ubuf(buf[i][0]).i,(int) ubuf(buf[i][1]).i, - buf[i][2],buf[i][3],buf[i][4]); + fmt::print(fp,"{} {} {:.16e} {:.16e} {:.16e}", ubuf(buf[i][0]).i, ubuf(buf[i][1]).i, + buf[i][2], buf[i][3], buf[i][4]); m = 5; for (k = 0; k < nstyles; k++) m += styles[k]->write_data_hybrid(fp,&buf[i][m]); - fprintf(fp," %d %d %d\n", - (int) ubuf(buf[i][m]).i,(int) ubuf(buf[i][m+1]).i, - (int) ubuf(buf[i][m+2]).i); + fmt::print(fp," {} {} {}\n", ubuf(buf[i][m]).i, ubuf(buf[i][m+1]).i, ubuf(buf[i][m+2]).i); } } @@ -1119,8 +1116,7 @@ void AtomVecHybridKokkos::write_vel(FILE *fp, int n, double **buf) int k,m; for (int i = 0; i < n; i++) { - fprintf(fp,TAGINT_FORMAT " %g %g %g", - (tagint) ubuf(buf[i][0]).i,buf[i][1],buf[i][2],buf[i][3]); + fmt::print(fp,"{} {} {} {}", (tagint) ubuf(buf[i][0]).i,buf[i][1],buf[i][2],buf[i][3]); m = 4; for (k = 0; k < nstyles; k++) @@ -1136,7 +1132,7 @@ void AtomVecHybridKokkos::write_vel(FILE *fp, int n, double **buf) return -1 if name is unknown to any sub-styles ------------------------------------------------------------------------- */ -int AtomVecHybridKokkos::property_atom(char *name) +int AtomVecHybridKokkos::property_atom(const std::string &name) { for (int k = 0; k < nstyles; k++) { int index = styles[k]->property_atom(name); @@ -1150,8 +1146,7 @@ int AtomVecHybridKokkos::property_atom(char *name) index maps to data specific to this atom style ------------------------------------------------------------------------- */ -void AtomVecHybridKokkos::pack_property_atom(int multiindex, double *buf, - int nvalues, int groupbit) +void AtomVecHybridKokkos::pack_property_atom(int multiindex, double *buf, int nvalues, int groupbit) { int k = multiindex % nstyles; int index = multiindex/nstyles; diff --git a/src/KOKKOS/atom_vec_hybrid_kokkos.h b/src/KOKKOS/atom_vec_hybrid_kokkos.h index 29417f1e05..e1a5eb6182 100644 --- a/src/KOKKOS/atom_vec_hybrid_kokkos.h +++ b/src/KOKKOS/atom_vec_hybrid_kokkos.h @@ -64,7 +64,7 @@ class AtomVecHybridKokkos : public AtomVecKokkos { void write_data(FILE *, int, double **) override; void pack_vel(double **) override; void write_vel(FILE *, int, double **) override; - int property_atom(char *) override; + int property_atom(const std::string &) override; void pack_property_atom(int, double *, int, int) override; double memory_usage() override; diff --git a/src/MACHDYN/atom_vec_smd.cpp b/src/MACHDYN/atom_vec_smd.cpp index 81f32ca0a2..cfceadfbd4 100644 --- a/src/MACHDYN/atom_vec_smd.cpp +++ b/src/MACHDYN/atom_vec_smd.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- * * *** Smooth Mach Dynamics *** @@ -27,8 +26,6 @@ #include "atom.h" -#include - using namespace LAMMPS_NS; #define NMAT_FULL 9 @@ -63,42 +60,33 @@ AtomVecSMD::AtomVecSMD(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) - "esph desph vfrac rmass x0 radius contact_radius molecule " - "smd_data_9 vest smd_stress " - "eff_plastic_strain eff_plastic_strain_rate damage"; - fields_copy = (char *) - "esph vfrac rmass x0 radius contact_radius molecule " - "eff_plastic_strain eff_plastic_strain_rate vest " - "smd_data_9 smd_stress damage"; - fields_comm = (char *) "radius vfrac vest esph"; - fields_comm_vel = (char *) "radius vfrac vest esph"; - fields_reverse = (char *) "desph"; - fields_border = (char *) - "x0 molecule radius rmass vfrac contact_radius esph " - "eff_plastic_strain smd_data_9 smd_stress"; - fields_border_vel = (char *) - "x0 molecule radius rmass vfrac contact_radius esph " - "eff_plastic_strain smd_data_9 smd_stress vest"; - fields_exchange = (char *) - "x0 molecule radius rmass vfrac contact_radius esph " - "eff_plastic_strain eff_plastic_strain_rate smd_data_9 smd_stress " - "vest damage"; - fields_restart = (char *) - "x0 molecule radius rmass vfrac contact_radius esph " - "eff_plastic_strain eff_plastic_strain_rate smd_data_9 smd_stress " - "vest damage"; - fields_create = (char *) - "x0 vest vfrac rmass radius contact_radius molecule esph " - "eff_plastic_strain eff_plastic_strain_rate smd_data_9 smd_stress damage"; - fields_data_atom = (char *) - "id type molecule vfrac rmass radius contact_radius x0 x"; - fields_data_vel = (char *) "id v"; + // clang-format off + fields_grow = {"esph", "desph", "vfrac", "rmass", "x0", "radius", "contact_radius", "molecule", + "smd_data_9", "vest", "smd_stress", "eff_plastic_strain", "eff_plastic_strain_rate", "damage"}; + fields_copy = {"esph", "vfrac", "rmass", "x0", "radius", "contact_radius", "molecule", + "eff_plastic_strain", "eff_plastic_strain_rate", "vest", "smd_data_9", "smd_stress", "damage"}; + fields_comm = {"radius", "vfrac", "vest", "esph"}; + fields_comm_vel = {"radius", "vfrac", "vest", "esph"}; + fields_reverse = {"desph"}; + fields_border = {"x0", "molecule", "radius", "rmass", "vfrac", "contact_radius", "esph", + "eff_plastic_strain", "smd_data_9", "smd_stress"}; + fields_border_vel = {"x0", "molecule", "radius", "rmass", "vfrac", "contact_radius", "esph", + "eff_plastic_strain", "smd_data_9", "smd_stress", "vest"}; + fields_exchange = {"x0", "molecule", "radius", "rmass", "vfrac", "contact_radius", "esph", + "eff_plastic_strain", "eff_plastic_strain_rate", "smd_data_9", "smd_stress", "vest", "damage"}; + fields_restart ={"x0", "molecule", "radius", "rmass", "vfrac", "contact_radius", "esph", + "eff_plastic_strain", "eff_plastic_strain_rate", "smd_data_9", "smd_stress", "vest", "damage"}; + fields_create = {"x0", "vest", "vfrac", "rmass", "radius", "contact_radius", "molecule", + "esph", "eff_plastic_strain", "eff_plastic_strain_rate", "smd_data_9", "smd_stress", "damage"}; + fields_data_atom = {"id", "type", "molecule", "vfrac", "rmass", "radius", "contact_radius", + "x0", "x"}; + fields_data_vel = {"id", "v"}; + // clang-format on // set these array sizes based on defines - atom->add_peratom_change_columns("smd_data_9",NMAT_FULL); - atom->add_peratom_change_columns("smd_stress",NMAT_SYMM); + atom->add_peratom_change_columns("smd_data_9", NMAT_FULL); + atom->add_peratom_change_columns("smd_stress", NMAT_SYMM); setup_fields(); } @@ -134,7 +122,7 @@ void AtomVecSMD::grow_pointers() void AtomVecSMD::force_clear(int n, size_t nbytes) { - memset(&desph[n],0,nbytes); + memset(&desph[n], 0, nbytes); } /* ---------------------------------------------------------------------- @@ -153,9 +141,9 @@ void AtomVecSMD::create_atom_post(int ilocal) contact_radius[ilocal] = 0.5; molecule[ilocal] = 1; - smd_data_9[ilocal][0] = 1.0; // xx - smd_data_9[ilocal][4] = 1.0; // yy - smd_data_9[ilocal][8] = 1.0; // zz + smd_data_9[ilocal][0] = 1.0; // xx + smd_data_9[ilocal][4] = 1.0; // yy + 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_rate[ilocal] = 0.0; - for (int k = 0; k < NMAT_FULL; k++) - smd_data_9[ilocal][k] = 0.0; + for (int k = 0; k < NMAT_FULL; k++) smd_data_9[ilocal][k] = 0.0; - for (int k = 0; k < NMAT_SYMM; k++) - smd_stress[ilocal][k] = 0.0; + for (int k = 0; k < NMAT_SYMM; k++) smd_stress[ilocal][k] = 0.0; - smd_data_9[ilocal][0] = 1.0; // xx - smd_data_9[ilocal][4] = 1.0; // yy - smd_data_9[ilocal][8] = 1.0; // zz + smd_data_9[ilocal][0] = 1.0; // xx + smd_data_9[ilocal][4] = 1.0; // yy + smd_data_9[ilocal][8] = 1.0; // zz } diff --git a/src/MESONT/atom_vec_mesont.cpp b/src/MESONT/atom_vec_mesont.cpp index 5e57479b63..04b55c0541 100644 --- a/src/MESONT/atom_vec_mesont.cpp +++ b/src/MESONT/atom_vec_mesont.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -33,18 +32,19 @@ AtomVecMesoNT::AtomVecMesoNT(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "rmass radius length buckling bond_nt molecule"; - fields_copy = (char *) "rmass radius length buckling bond_nt molecule"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) ""; - fields_reverse = (char *) ""; - fields_border = (char *) "rmass radius length buckling bond_nt molecule"; - fields_border_vel = (char *) "rmass radius length buckling bond_nt molecule"; - fields_exchange = (char *) "rmass radius length buckling bond_nt molecule"; - fields_restart = (char *) "rmass radius length buckling bond_nt molecule"; - fields_create = (char *) "rmass radius length buckling bond_nt molecule"; - fields_data_atom = (char *) "id molecule type bond_nt rmass radius length buckling x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"}; + fields_copy = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"}; + fields_comm = {}; + fields_comm_vel = {}; + fields_reverse = {}; + fields_border = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"}; + fields_border_vel = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"}; + fields_exchange = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"}; + fields_restart = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"}; + fields_create = {"rmass", "radius", "length", "buckling", "bond_nt", "molecule"}; + fields_data_atom = {"id", "molecule", "type", "bond_nt", "rmass", + "radius", "length", "buckling", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); } diff --git a/src/MOLECULE/atom_vec_angle.cpp b/src/MOLECULE/atom_vec_angle.cpp index 06a4f441ca..091739cab2 100644 --- a/src/MOLECULE/atom_vec_angle.cpp +++ b/src/MOLECULE/atom_vec_angle.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -32,26 +31,25 @@ AtomVecAngle::AtomVecAngle(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) - "molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 nspecial special"; - fields_copy = (char *) - "molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 nspecial special"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) ""; - fields_reverse = (char *) ""; - fields_border = (char *) "molecule"; - fields_border_vel = (char *) "molecule"; - fields_exchange = (char *) - "molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 nspecial special"; - fields_restart = (char *) - "molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3"; - fields_create = (char *) "molecule num_bond num_angle nspecial"; - fields_data_atom = (char *) "id molecule type x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"molecule", "num_bond", "bond_type", "bond_atom", + "num_angle", "angle_type", "angle_atom1", "angle_atom2", + "angle_atom3", "nspecial", "special"}; + fields_copy = {"molecule", "num_bond", "bond_type", "bond_atom", + "num_angle", "angle_type", "angle_atom1", "angle_atom2", + "angle_atom3", "nspecial", "special"}; + fields_comm = {}; + fields_comm_vel = {}; + fields_reverse = {}; + fields_border = {"molecule"}; + fields_border_vel = {"molecule"}; + fields_exchange = {"molecule", "num_bond", "bond_type", "bond_atom", + "num_angle", "angle_type", "angle_atom1", "angle_atom2", + "angle_atom3", "nspecial", "special"}; + fields_restart = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", + "angle_type", "angle_atom1", "angle_atom2", "angle_atom3"}; + fields_create = {"molecule", "num_bond", "num_angle", "nspecial"}; + fields_data_atom = {"id", "molecule", "type", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); @@ -63,8 +61,8 @@ AtomVecAngle::AtomVecAngle(LAMMPS *lmp) : AtomVec(lmp) AtomVecAngle::~AtomVecAngle() { - delete [] bond_negative; - delete [] angle_negative; + delete[] bond_negative; + delete[] angle_negative; } /* ---------------------------------------------------------------------- @@ -90,12 +88,12 @@ void AtomVecAngle::pack_restart_pre(int ilocal) // insure negative vectors are needed length if (bond_per_atom < atom->bond_per_atom) { - delete [] bond_negative; + delete[] bond_negative; bond_per_atom = atom->bond_per_atom; bond_negative = new int[bond_per_atom]; } if (angle_per_atom < atom->angle_per_atom) { - delete [] angle_negative; + delete[] angle_negative; angle_per_atom = atom->angle_per_atom; angle_negative = new int[angle_per_atom]; } @@ -108,7 +106,8 @@ void AtomVecAngle::pack_restart_pre(int ilocal) bond_negative[m] = 1; bond_type[ilocal][m] = -bond_type[ilocal][m]; any_bond_negative = 1; - } else bond_negative[m] = 0; + } else + bond_negative[m] = 0; } any_angle_negative = 0; @@ -117,7 +116,8 @@ void AtomVecAngle::pack_restart_pre(int ilocal) angle_negative[m] = 1; angle_type[ilocal][m] = -angle_type[ilocal][m]; any_angle_negative = 1; - } else angle_negative[m] = 0; + } else + angle_negative[m] = 0; } } diff --git a/src/MOLECULE/atom_vec_bond.cpp b/src/MOLECULE/atom_vec_bond.cpp index acd0bc9979..3b6cd7b911 100644 --- a/src/MOLECULE/atom_vec_bond.cpp +++ b/src/MOLECULE/atom_vec_bond.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -32,21 +31,18 @@ AtomVecBond::AtomVecBond(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) - "molecule num_bond bond_type bond_atom nspecial special"; - fields_copy = (char *) - "molecule num_bond bond_type bond_atom nspecial special"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) ""; - fields_reverse = (char *) ""; - fields_border = (char *) "molecule"; - fields_border_vel = (char *) "molecule"; - fields_exchange = (char *) - "molecule num_bond bond_type bond_atom nspecial special"; - fields_restart = (char *) "molecule num_bond bond_type bond_atom"; - fields_create = (char *) "molecule num_bond nspecial"; - fields_data_atom = (char *) "id molecule type x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"molecule", "num_bond", "bond_type", "bond_atom", "nspecial", "special"}; + fields_copy = {"molecule", "num_bond", "bond_type", "bond_atom", "nspecial", "special"}; + fields_comm = {}; + fields_comm_vel = {}; + fields_reverse = {}; + fields_border = {"molecule"}; + fields_border_vel = {"molecule"}; + fields_exchange = {"molecule", "num_bond", "bond_type", "bond_atom", "nspecial", "special"}; + fields_restart = {"molecule", "num_bond", "bond_type", "bond_atom"}; + fields_create = {"molecule", "num_bond", "nspecial"}; + fields_data_atom = {"id", "molecule", "type", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); @@ -58,7 +54,7 @@ AtomVecBond::AtomVecBond(LAMMPS *lmp) : AtomVec(lmp) AtomVecBond::~AtomVecBond() { - delete [] bond_negative; + delete[] bond_negative; } /* ---------------------------------------------------------------------- @@ -82,7 +78,7 @@ void AtomVecBond::pack_restart_pre(int ilocal) // insure bond_negative vector is needed length if (bond_per_atom < atom->bond_per_atom) { - delete [] bond_negative; + delete[] bond_negative; bond_per_atom = atom->bond_per_atom; bond_negative = new int[bond_per_atom]; } @@ -95,7 +91,8 @@ void AtomVecBond::pack_restart_pre(int ilocal) bond_negative[m] = 1; bond_type[ilocal][m] = -bond_type[ilocal][m]; any_bond_negative = 1; - } else bond_negative[m] = 0; + } else + bond_negative[m] = 0; } } diff --git a/src/MOLECULE/atom_vec_full.cpp b/src/MOLECULE/atom_vec_full.cpp index e88c4d7a62..cfeffb1199 100644 --- a/src/MOLECULE/atom_vec_full.cpp +++ b/src/MOLECULE/atom_vec_full.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -32,47 +31,34 @@ AtomVecFull::AtomVecFull(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) - "q molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4 " - "nspecial special"; - fields_copy = (char *) - "q molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4 " - "nspecial special"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) ""; - fields_reverse = (char *) ""; - fields_border = (char *) "q molecule"; - fields_border_vel = (char *) "q molecule"; - fields_exchange = (char *) - "q molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4 " - "nspecial special"; - fields_restart = (char *) - "q molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4"; - fields_create = (char *) - "q molecule num_bond num_angle num_dihedral num_improper nspecial"; - fields_data_atom = (char *) "id molecule type q x"; - fields_data_vel = (char *) "id v"; - + // clang-format off + fields_grow = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type", + "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1", + "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", + "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"}; + fields_copy = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type", + "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1", + "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", + "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"}; + fields_comm = {}; + fields_comm_vel = {}; + fields_reverse = {}; + fields_border = {"q", "molecule"}; + fields_border_vel = {"q", "molecule"}; + fields_exchange = {"q", "molecule", "num_bond", "bond_type", "bond_atom", + "num_angle", "angle_type", "angle_atom1", "angle_atom2", "angle_atom3", + "num_dihedral", "dihedral_type", "dihedral_atom1", "dihedral_atom2", + "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", "improper_atom1", + "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"}; + fields_restart = {"q", "molecule", "num_bond", "bond_type", "bond_atom", "num_angle", + "angle_type", "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", + "dihedral_atom1", "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", + "improper_type", "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4"}; + fields_create = {"q", "molecule", "num_bond", "num_angle", + "num_dihedral", "num_improper", "nspecial"}; + fields_data_atom = {"id", "molecule", "type", "q", "x"}; + fields_data_vel = {"id", "v"}; + // clang-format on setup_fields(); bond_per_atom = angle_per_atom = dihedral_per_atom = improper_per_atom = 0; @@ -83,10 +69,10 @@ AtomVecFull::AtomVecFull(LAMMPS *lmp) : AtomVec(lmp) AtomVecFull::~AtomVecFull() { - delete [] bond_negative; - delete [] angle_negative; - delete [] dihedral_negative; - delete [] improper_negative; + delete[] bond_negative; + delete[] angle_negative; + delete[] dihedral_negative; + delete[] improper_negative; } /* ---------------------------------------------------------------------- @@ -116,22 +102,22 @@ void AtomVecFull::pack_restart_pre(int ilocal) // insure negative vectors are needed length if (bond_per_atom < atom->bond_per_atom) { - delete [] bond_negative; + delete[] bond_negative; bond_per_atom = atom->bond_per_atom; bond_negative = new int[bond_per_atom]; } if (angle_per_atom < atom->angle_per_atom) { - delete [] angle_negative; + delete[] angle_negative; angle_per_atom = atom->angle_per_atom; angle_negative = new int[angle_per_atom]; } if (dihedral_per_atom < atom->dihedral_per_atom) { - delete [] dihedral_negative; + delete[] dihedral_negative; dihedral_per_atom = atom->dihedral_per_atom; dihedral_negative = new int[dihedral_per_atom]; } if (improper_per_atom < atom->improper_per_atom) { - delete [] improper_negative; + delete[] improper_negative; improper_per_atom = atom->improper_per_atom; improper_negative = new int[improper_per_atom]; } @@ -144,7 +130,8 @@ void AtomVecFull::pack_restart_pre(int ilocal) bond_negative[m] = 1; bond_type[ilocal][m] = -bond_type[ilocal][m]; any_bond_negative = 1; - } else bond_negative[m] = 0; + } else + bond_negative[m] = 0; } any_angle_negative = 0; @@ -153,7 +140,8 @@ void AtomVecFull::pack_restart_pre(int ilocal) angle_negative[m] = 1; angle_type[ilocal][m] = -angle_type[ilocal][m]; any_angle_negative = 1; - } else angle_negative[m] = 0; + } else + angle_negative[m] = 0; } any_dihedral_negative = 0; @@ -162,7 +150,8 @@ void AtomVecFull::pack_restart_pre(int ilocal) dihedral_negative[m] = 1; dihedral_type[ilocal][m] = -dihedral_type[ilocal][m]; any_dihedral_negative = 1; - } else dihedral_negative[m] = 0; + } else + dihedral_negative[m] = 0; } any_improper_negative = 0; @@ -171,7 +160,8 @@ void AtomVecFull::pack_restart_pre(int ilocal) improper_negative[m] = 1; improper_type[ilocal][m] = -improper_type[ilocal][m]; any_improper_negative = 1; - } else improper_negative[m] = 0; + } else + improper_negative[m] = 0; } } @@ -195,14 +185,12 @@ void AtomVecFull::pack_restart_post(int ilocal) if (any_dihedral_negative) { for (int m = 0; m < num_dihedral[ilocal]; m++) - if (dihedral_negative[m]) - dihedral_type[ilocal][m] = -dihedral_type[ilocal][m]; + if (dihedral_negative[m]) dihedral_type[ilocal][m] = -dihedral_type[ilocal][m]; } if (any_improper_negative) { for (int m = 0; m < num_improper[ilocal]; m++) - if (improper_negative[m]) - improper_type[ilocal][m] = -improper_type[ilocal][m]; + if (improper_negative[m]) improper_type[ilocal][m] = -improper_type[ilocal][m]; } } diff --git a/src/MOLECULE/atom_vec_molecular.cpp b/src/MOLECULE/atom_vec_molecular.cpp index 9cb3f53f5a..5107c28af7 100644 --- a/src/MOLECULE/atom_vec_molecular.cpp +++ b/src/MOLECULE/atom_vec_molecular.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -32,46 +31,32 @@ AtomVecMolecular::AtomVecMolecular(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) - "molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4 " - "nspecial special"; - fields_copy = (char *) - "molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4 " - "nspecial special"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) ""; - fields_reverse = (char *) ""; - fields_border = (char *) "molecule"; - fields_border_vel = (char *) "molecule"; - fields_exchange = (char *) - "molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4 " - "nspecial special"; - fields_restart = (char *) - "molecule num_bond bond_type bond_atom " - "num_angle angle_type angle_atom1 angle_atom2 angle_atom3 " - "num_dihedral dihedral_type dihedral_atom1 dihedral_atom2 " - "dihedral_atom3 dihedral_atom4 " - "num_improper improper_type improper_atom1 improper_atom2 " - "improper_atom3 improper_atom4"; - fields_create = (char *) - "molecule num_bond num_angle num_dihedral num_improper nspecial"; - fields_data_atom = (char *) "id molecule type x"; - fields_data_vel = (char *) "id v"; + // clang-format off + fields_grow = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type", + "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1", + "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", + "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"}; + fields_copy = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type", + "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1", + "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", + "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"}; + fields_comm = {}; + fields_comm_vel = {}; + fields_reverse = {}; + fields_border = {"molecule"}; + fields_border_vel = {"molecule"}; + fields_exchange = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type", + "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1", + "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", + "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4", "nspecial", "special"}; + fields_restart = {"molecule", "num_bond", "bond_type", "bond_atom", "num_angle", "angle_type", + "angle_atom1", "angle_atom2", "angle_atom3", "num_dihedral", "dihedral_type", "dihedral_atom1", + "dihedral_atom2", "dihedral_atom3", "dihedral_atom4", "num_improper", "improper_type", + "improper_atom1", "improper_atom2", "improper_atom3", "improper_atom4"}; + fields_create = {"molecule", "num_bond", "num_angle", "num_dihedral", "num_improper", "nspecial"}; + fields_data_atom = {"id", "molecule", "type", "x"}; + fields_data_vel = {"id", "v"}; + // clang-format on setup_fields(); @@ -83,10 +68,10 @@ AtomVecMolecular::AtomVecMolecular(LAMMPS *lmp) : AtomVec(lmp) AtomVecMolecular::~AtomVecMolecular() { - delete [] bond_negative; - delete [] angle_negative; - delete [] dihedral_negative; - delete [] improper_negative; + delete[] bond_negative; + delete[] angle_negative; + delete[] dihedral_negative; + delete[] improper_negative; } /* ---------------------------------------------------------------------- @@ -116,22 +101,22 @@ void AtomVecMolecular::pack_restart_pre(int ilocal) // insure negative vectors are needed length if (bond_per_atom < atom->bond_per_atom) { - delete [] bond_negative; + delete[] bond_negative; bond_per_atom = atom->bond_per_atom; bond_negative = new int[bond_per_atom]; } if (angle_per_atom < atom->angle_per_atom) { - delete [] angle_negative; + delete[] angle_negative; angle_per_atom = atom->angle_per_atom; angle_negative = new int[angle_per_atom]; } if (dihedral_per_atom < atom->dihedral_per_atom) { - delete [] dihedral_negative; + delete[] dihedral_negative; dihedral_per_atom = atom->dihedral_per_atom; dihedral_negative = new int[dihedral_per_atom]; } if (improper_per_atom < atom->improper_per_atom) { - delete [] improper_negative; + delete[] improper_negative; improper_per_atom = atom->improper_per_atom; improper_negative = new int[improper_per_atom]; } @@ -144,7 +129,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal) bond_negative[m] = 1; bond_type[ilocal][m] = -bond_type[ilocal][m]; any_bond_negative = 1; - } else bond_negative[m] = 0; + } else + bond_negative[m] = 0; } any_angle_negative = 0; @@ -153,7 +139,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal) angle_negative[m] = 1; angle_type[ilocal][m] = -angle_type[ilocal][m]; any_angle_negative = 1; - } else angle_negative[m] = 0; + } else + angle_negative[m] = 0; } any_dihedral_negative = 0; @@ -162,7 +149,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal) dihedral_negative[m] = 1; dihedral_type[ilocal][m] = -dihedral_type[ilocal][m]; any_dihedral_negative = 1; - } else dihedral_negative[m] = 0; + } else + dihedral_negative[m] = 0; } any_improper_negative = 0; @@ -171,7 +159,8 @@ void AtomVecMolecular::pack_restart_pre(int ilocal) improper_negative[m] = 1; improper_type[ilocal][m] = -improper_type[ilocal][m]; any_improper_negative = 1; - } else improper_negative[m] = 0; + } else + improper_negative[m] = 0; } } @@ -195,14 +184,12 @@ void AtomVecMolecular::pack_restart_post(int ilocal) if (any_dihedral_negative) { for (int m = 0; m < num_dihedral[ilocal]; m++) - if (dihedral_negative[m]) - dihedral_type[ilocal][m] = -dihedral_type[ilocal][m]; + if (dihedral_negative[m]) dihedral_type[ilocal][m] = -dihedral_type[ilocal][m]; } if (any_improper_negative) { for (int m = 0; m < num_improper[ilocal]; m++) - if (improper_negative[m]) - improper_type[ilocal][m] = -improper_type[ilocal][m]; + if (improper_negative[m]) improper_type[ilocal][m] = -improper_type[ilocal][m]; } } diff --git a/src/MOLECULE/atom_vec_template.cpp b/src/MOLECULE/atom_vec_template.cpp index 919f5c9aec..7ca8f8bd62 100644 --- a/src/MOLECULE/atom_vec_template.cpp +++ b/src/MOLECULE/atom_vec_template.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -36,18 +35,18 @@ AtomVecTemplate::AtomVecTemplate(LAMMPS *lmp) : AtomVec(lmp) // order of fields in the string does not matter // except fields_data_atom and fields_data_vel which must match data file - fields_grow = (char *) "molecule molindex molatom"; - fields_copy = (char *) "molecule molindex molatom"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) ""; - fields_reverse = (char *) ""; - fields_border = (char *) "molecule molindex molatom"; - fields_border_vel = (char *) "molecule molindex molatom"; - fields_exchange = (char *) "molecule molindex molatom"; - fields_restart = (char *) "molecule molindex molatom"; - fields_create = (char *) "molecule molindex molatom"; - fields_data_atom = (char *) "id molecule molindex molatom type x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"molecule", "molindex", "molatom"}; + fields_copy = {"molecule", "molindex", "molatom"}; + fields_comm = {}; + fields_comm_vel = {}; + fields_reverse = {}; + fields_border = {"molecule", "molindex", "molatom"}; + fields_border_vel = {"molecule", "molindex", "molatom"}; + fields_exchange = {"molecule", "molindex", "molatom"}; + fields_restart = {"molecule", "molindex", "molatom"}; + fields_create = {"molecule", "molindex", "molatom"}; + fields_data_atom = {"id", "molecule", "molindex", "molatom", "type", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); } @@ -58,11 +57,10 @@ AtomVecTemplate::AtomVecTemplate(LAMMPS *lmp) : AtomVec(lmp) void AtomVecTemplate::process_args(int narg, char **arg) { - if (narg != 1) error->all(FLERR,"Illegal atom_style template command"); + if (narg != 1) error->all(FLERR, "Illegal atom_style template command"); int imol = atom->find_molecule(arg[0]); - if (imol == -1) error->all(FLERR,"Molecule template ID for " - "atom_style template does not exist"); + if (imol == -1) error->all(FLERR, "Molecule template ID for atom_style template does not exist"); onemols = &atom->molecules[imol]; nset = atom->molecules[imol]->nset; @@ -81,10 +79,10 @@ void AtomVecTemplate::process_args(int narg, char **arg) // do this here b/c data file will typically not contain these settings for (int i = 0; i < nset; i++) { - atom->nbondtypes = MAX(atom->nbondtypes,onemols[i]->nbondtypes); - atom->nangletypes = MAX(atom->nangletypes,onemols[i]->nangletypes); - atom->ndihedraltypes = MAX(atom->ndihedraltypes,onemols[i]->ndihedraltypes); - atom->nimpropertypes = MAX(atom->nimpropertypes,onemols[i]->nimpropertypes); + atom->nbondtypes = MAX(atom->nbondtypes, onemols[i]->nbondtypes); + atom->nangletypes = MAX(atom->nangletypes, onemols[i]->nangletypes); + atom->ndihedraltypes = MAX(atom->ndihedraltypes, onemols[i]->ndihedraltypes); + atom->nimpropertypes = MAX(atom->nimpropertypes, onemols[i]->nimpropertypes); } } @@ -129,7 +127,6 @@ void AtomVecTemplate::pack_data_post(int ilocal) molatom[ilocal]--; } - /* ---------------------------------------------------------------------- modify what AtomVec::data_atom() just unpacked or initialize other atom quantities @@ -141,7 +138,7 @@ void AtomVecTemplate::data_atom_post(int ilocal) int molatom_one = --molatom[ilocal]; if ((molindex_one < -1) || (molindex_one >= nset)) - error->one(FLERR,"Invalid template index in Atoms section of data file"); + error->one(FLERR, "Invalid template index in Atoms section of data file"); if ((molatom_one < -1) || ((molindex_one >= 0) && (molatom_one >= onemols[molindex_one]->natoms))) - error->one(FLERR,"Invalid template atom in Atoms section of data file"); + error->one(FLERR, "Invalid template atom in Atoms section of data file"); } diff --git a/src/PERI/atom_vec_peri.cpp b/src/PERI/atom_vec_peri.cpp index a0483efb4d..84e06a61b5 100644 --- a/src/PERI/atom_vec_peri.cpp +++ b/src/PERI/atom_vec_peri.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -23,20 +22,19 @@ #include "error.h" #include -#include using namespace LAMMPS_NS; static const char cite_peri_package[] = - "PERI package for Peridynamics:\n\n" - "@Article{Parks08,\n" - " author = {M. L. Parks, R. B. Lehoucq, S. J. Plimpton, S. A. Silling},\n" - " title = {Implementing peridynamics within a molecular dynamics code},\n" - " journal = {Comp.~Phys.~Comm.},\n" - " year = 2008,\n" - " volume = 179,\n" - " pages = {777--783}\n" - "}\n\n"; + "PERI package for Peridynamics:\n\n" + "@Article{Parks08,\n" + " author = {M. L. Parks, R. B. Lehoucq, S. J. Plimpton, S. A. Silling},\n" + " title = {Implementing peridynamics within a molecular dynamics code},\n" + " journal = {Comp.~Phys.~Comm.},\n" + " year = 2008,\n" + " volume = 179,\n" + " pages = {777--783}\n" + "}\n\n"; /* ---------------------------------------------------------------------- */ @@ -55,18 +53,18 @@ AtomVecPeri::AtomVecPeri(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "rmass vfrac s0 x0"; - fields_copy = (char *) "rmass vfrac s0 x0"; - fields_comm = (char *) "s0"; - fields_comm_vel = (char *) "s0"; - fields_reverse = (char *) ""; - fields_border = (char *) "rmass vfrac s0 x0"; - fields_border_vel = (char *) "rmass vfrac s0 x0"; - fields_exchange = (char *) "rmass vfrac s0 x0"; - fields_restart = (char *) "rmass vfrac s0 x0"; - fields_create = (char *) "rmass vfrac s0 x0"; - fields_data_atom = (char *) "id type vfrac rmass x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"rmass", "vfrac", "s0", "x0"}; + fields_copy = {"rmass", "vfrac", "s0", "x0"}; + fields_comm = {"s0"}; + fields_comm_vel = {"s0"}; + fields_reverse = {}; + fields_border = {"rmass", "vfrac", "s0", "x0"}; + fields_border_vel = {"rmass", "vfrac", "s0", "x0"}; + fields_exchange = {"rmass", "vfrac", "s0", "x0"}; + fields_restart = {"rmass", "vfrac", "s0", "x0"}; + fields_create = {"rmass", "vfrac", "s0", "x0"}; + fields_data_atom = {"id", "type", "vfrac", "rmass", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); } @@ -110,8 +108,7 @@ void AtomVecPeri::data_atom_post(int ilocal) x0[ilocal][1] = x[ilocal][1]; x0[ilocal][2] = x[ilocal][2]; - if (rmass[ilocal] <= 0.0) - error->one(FLERR,"Invalid mass in Atoms section of data file"); + if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid mass in Atoms section of data file"); } /* ---------------------------------------------------------------------- @@ -119,10 +116,10 @@ void AtomVecPeri::data_atom_post(int ilocal) return -1 if name is unknown to this atom style ------------------------------------------------------------------------- */ -int AtomVecPeri::property_atom(char *name) +int AtomVecPeri::property_atom(const std::string &name) { - if (strcmp(name,"vfrac") == 0) return 0; - if (strcmp(name,"s0") == 0) return 1; + if (name == "vfrac") return 0; + if (name == "s0") return 1; return -1; } @@ -131,8 +128,7 @@ int AtomVecPeri::property_atom(char *name) index maps to data specific to this atom style ------------------------------------------------------------------------- */ -void AtomVecPeri::pack_property_atom(int index, double *buf, - int nvalues, int groupbit) +void AtomVecPeri::pack_property_atom(int index, double *buf, int nvalues, int groupbit) { int *mask = atom->mask; int nlocal = atom->nlocal; @@ -140,14 +136,18 @@ void AtomVecPeri::pack_property_atom(int index, double *buf, if (index == 0) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = vfrac[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = vfrac[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 1) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = s0[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = s0[i]; + else + buf[n] = 0.0; n += nvalues; } } diff --git a/src/PERI/atom_vec_peri.h b/src/PERI/atom_vec_peri.h index 0d37138b36..3e990afb88 100644 --- a/src/PERI/atom_vec_peri.h +++ b/src/PERI/atom_vec_peri.h @@ -31,7 +31,7 @@ class AtomVecPeri : public AtomVec { void grow_pointers() override; void create_atom_post(int) override; void data_atom_post(int) override; - int property_atom(char *) override; + int property_atom(const std::string &) override; void pack_property_atom(int, double *, int, int) override; private: diff --git a/src/SPH/atom_vec_sph.cpp b/src/SPH/atom_vec_sph.cpp index 46f9d828e8..a26967a57b 100644 --- a/src/SPH/atom_vec_sph.cpp +++ b/src/SPH/atom_vec_sph.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -16,8 +15,6 @@ #include "atom.h" -#include - using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ @@ -38,18 +35,18 @@ AtomVecSPH::AtomVecSPH(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "rho drho esph desph cv vest"; - fields_copy = (char *) "rho drho esph desph cv vest"; - fields_comm = (char *) "rho esph vest"; - fields_comm_vel = (char *) "rho esph vest"; - fields_reverse = (char *) "drho desph"; - fields_border = (char *) "rho esph cv vest"; - fields_border_vel = (char *) "rho esph cv vest"; - fields_exchange = (char *) "rho esph cv vest"; - fields_restart = (char * ) "rho esph cv vest"; - fields_create = (char *) "rho esph cv vest desph drho"; - fields_data_atom = (char *) "id type rho esph cv x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"rho", "drho", "esph", "desph", "cv", "vest"}; + fields_copy = {"rho", "drho", "esph", "desph", "cv", "vest"}; + fields_comm = {"rho", "esph", "vest"}; + fields_comm_vel = {"rho", "esph", "vest"}; + fields_reverse = {"drho", "desph"}; + fields_border = {"rho", "esph", "cv", "vest"}; + fields_border_vel = {"rho", "esph", "cv", "vest"}; + fields_exchange = {"rho", "esph", "cv", "vest"}; + fields_restart = {"rho", "esph", "cv", "vest"}; + fields_create = {"rho", "esph", "cv", "vest", "desph", "drho"}; + fields_data_atom = {"id", "type", "rho", "esph", "cv", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); } @@ -76,8 +73,8 @@ void AtomVecSPH::grow_pointers() void AtomVecSPH::force_clear(int n, size_t nbytes) { - memset(&desph[n],0,nbytes); - memset(&drho[n],0,nbytes); + memset(&desph[n], 0, nbytes); + memset(&drho[n], 0, nbytes); } /* ---------------------------------------------------------------------- @@ -108,13 +105,13 @@ void AtomVecSPH::data_atom_post(int ilocal) return -1 if name is unknown to this atom style ------------------------------------------------------------------------- */ -int AtomVecSPH::property_atom(char *name) +int AtomVecSPH::property_atom(const std::string &name) { - if (strcmp(name,"rho") == 0) return 0; - if (strcmp(name,"drho") == 0) return 1; - if (strcmp(name,"esph") == 0) return 2; - if (strcmp(name,"desph") == 0) return 3; - if (strcmp(name,"cv") == 0) return 4; + if (name == "rho") return 0; + if (name == "drho") return 1; + if (name == "esph") return 2; + if (name == "desph") return 3; + if (name == "cv") return 4; return -1; } @@ -123,8 +120,7 @@ int AtomVecSPH::property_atom(char *name) index maps to data specific to this atom style ------------------------------------------------------------------------- */ -void AtomVecSPH::pack_property_atom(int index, double *buf, - int nvalues, int groupbit) +void AtomVecSPH::pack_property_atom(int index, double *buf, int nvalues, int groupbit) { int *mask = atom->mask; int nlocal = atom->nlocal; @@ -132,32 +128,42 @@ void AtomVecSPH::pack_property_atom(int index, double *buf, if (index == 0) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = rho[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = rho[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 1) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = drho[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = drho[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 2) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = esph[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = esph[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 3) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = desph[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = desph[i]; + else + buf[n] = 0.0; n += nvalues; } } else if (index == 4) { for (int i = 0; i < nlocal; i++) { - if (mask[i] & groupbit) buf[n] = cv[i]; - else buf[n] = 0.0; + if (mask[i] & groupbit) + buf[n] = cv[i]; + else + buf[n] = 0.0; n += nvalues; } } diff --git a/src/SPH/atom_vec_sph.h b/src/SPH/atom_vec_sph.h index 8af3ac2fc3..18d82d76de 100644 --- a/src/SPH/atom_vec_sph.h +++ b/src/SPH/atom_vec_sph.h @@ -32,7 +32,7 @@ class AtomVecSPH : public AtomVec { void force_clear(int, size_t) override; void create_atom_post(int) override; void data_atom_post(int) override; - int property_atom(char *) override; + int property_atom(const std::string &) override; void pack_property_atom(int, double *, int, int) override; private: diff --git a/src/SPIN/atom_vec_spin.cpp b/src/SPIN/atom_vec_spin.cpp index 4f3d0a3aab..209704fef8 100644 --- a/src/SPIN/atom_vec_spin.cpp +++ b/src/SPIN/atom_vec_spin.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator @@ -25,10 +24,11 @@ ------------------------------------------------------------------------- */ #include "atom_vec_spin.h" -#include -#include + #include "atom.h" +#include + using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ @@ -46,18 +46,18 @@ AtomVecSpin::AtomVecSpin(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "sp fm fm_long"; - fields_copy = (char *) "sp"; - fields_comm = (char *) "sp"; - fields_comm_vel = (char *) "sp"; - fields_reverse = (char *) "fm fm_long"; - fields_border = (char *) "sp"; - fields_border_vel = (char *) "sp"; - fields_exchange = (char *) "sp"; - fields_restart = (char *) "sp"; - fields_create = (char *) "sp"; - fields_data_atom = (char *) "id type x sp"; - fields_data_vel = (char *) "id v"; + fields_grow = {"sp", "fm", "fm_long"}; + fields_copy = {"sp"}; + fields_comm = {"sp"}; + fields_comm_vel = {"sp"}; + fields_reverse = {"fm", "fm_long"}; + fields_border = {"sp"}; + fields_border_vel = {"sp"}; + fields_exchange = {"sp"}; + fields_restart = {"sp"}; + fields_create = {"sp"}; + fields_data_atom = {"id", "type", "x", "sp"}; + fields_data_vel = {"id", "v"}; setup_fields(); } @@ -82,8 +82,8 @@ void AtomVecSpin::grow_pointers() void AtomVecSpin::force_clear(int n, size_t nbytes) { - memset(&fm[n][0],0,3*nbytes); - memset(&fm_long[n][0],0,3*nbytes); + memset(&fm[n][0], 0, 3 * nbytes); + memset(&fm_long[n][0], 0, 3 * nbytes); } /* ---------------------------------------------------------------------- @@ -94,8 +94,7 @@ void AtomVecSpin::force_clear(int n, size_t nbytes) void AtomVecSpin::data_atom_post(int ilocal) { double *sp_one = sp[ilocal]; - double norm = - 1.0/sqrt(sp_one[0]*sp_one[0] + sp_one[1]*sp_one[1] + sp_one[2]*sp_one[2]); + double norm = 1.0 / sqrt(sp_one[0] * sp_one[0] + sp_one[1] * sp_one[1] + sp_one[2] * sp_one[2]); sp_one[0] *= norm; sp_one[1] *= norm; sp_one[2] *= norm; diff --git a/src/atom_vec.cpp b/src/atom_vec.cpp index 6d1412cbd4..68e63f6507 100644 --- a/src/atom_vec.cpp +++ b/src/atom_vec.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -28,7 +27,24 @@ #include using namespace LAMMPS_NS; -using namespace MathConst; + +// peratom variables that are auto-included in corresponding child style field lists +// these fields cannot be specified in the fields strings + +const std::vector AtomVec::default_grow = {"id", "type", "mask", "image", + "x", "v", "f"}; +const std::vector AtomVec::default_copy = {"id", "type", "mask", "image", "x", "v"}; +const std::vector AtomVec::default_comm = {"x"}; +const std::vector AtomVec::default_comm_vel = {"x", "v"}; +const std::vector AtomVec::default_reverse = {"f"}; +const std::vector AtomVec::default_border = {"id", "type", "mask", "x"}; +const std::vector AtomVec::default_border_vel = {"id", "type", "mask", "x", "v"}; +const std::vector AtomVec::default_exchange = {"id", "type", "mask", + "image", "x", "v"}; +const std::vector AtomVec::default_restart = {"id", "type", "mask", "image", "x", "v"}; +const std::vector AtomVec::default_create = {"id", "type", "mask", "image", "x", "v"}; +const std::vector AtomVec::default_data_atom = {}; +const std::vector AtomVec::default_data_vel = {}; /* ---------------------------------------------------------------------- */ @@ -56,33 +72,17 @@ AtomVec::AtomVec(LAMMPS *lmp) : Pointers(lmp) x = v = f = nullptr; threads = nullptr; - - // peratom variables auto-included in corresponding child style fields string - // these fields cannot be specified in the fields string - - default_grow = "id type mask image x v f"; - default_copy = "id type mask image x v"; - default_comm = "x"; - default_comm_vel = "x v"; - default_reverse = "f"; - default_border = "id type mask x"; - default_border_vel = "id type mask x v"; - default_exchange = "id type mask image x v"; - default_restart = "id type mask image x v"; - default_create = "id type mask image x v"; - default_data_atom = ""; - default_data_vel = ""; } /* ---------------------------------------------------------------------- */ AtomVec::~AtomVec() { - int datatype,cols; + int datatype, cols; void *pdata; - for (int i = 0; i < nargcopy; i++) delete [] argcopy[i]; - delete [] argcopy; + for (int i = 0; i < nargcopy; i++) delete[] argcopy[i]; + delete[] argcopy; for (int i = 0; i < ngrow; i++) { pdata = mgrow.pdata[i]; @@ -115,7 +115,7 @@ AtomVec::~AtomVec() } } - delete [] threads; + delete[] threads; } /* ---------------------------------------------------------------------- @@ -125,10 +125,11 @@ AtomVec::~AtomVec() void AtomVec::store_args(int narg, char **arg) { nargcopy = narg; - if (nargcopy) argcopy = new char*[nargcopy]; - else argcopy = nullptr; - for (int i = 0; i < nargcopy; i++) - argcopy[i] = utils::strdup(arg[i]); + if (nargcopy) + argcopy = new char *[nargcopy]; + else + argcopy = nullptr; + for (int i = 0; i < nargcopy; i++) argcopy[i] = utils::strdup(arg[i]); } /* ---------------------------------------------------------------------- @@ -137,7 +138,7 @@ void AtomVec::store_args(int narg, char **arg) void AtomVec::process_args(int narg, char ** /*arg*/) { - if (narg) error->all(FLERR,"Invalid atom_style command"); + if (narg) error->all(FLERR, "Invalid atom_style command"); } /* ---------------------------------------------------------------------- @@ -152,10 +153,10 @@ void AtomVec::init() h_rate = domain->h_rate; if (lmp->kokkos != nullptr && !kokkosable) - error->all(FLERR,"KOKKOS package requires a kokkos enabled atom_style"); + error->all(FLERR, "KOKKOS package requires a kokkos enabled atom_style"); } -static constexpr bigint DELTA=16384; +static constexpr bigint DELTA = 16384; /* ---------------------------------------------------------------------- roundup N so it is a multiple of DELTA @@ -164,9 +165,8 @@ static constexpr bigint DELTA=16384; bigint AtomVec::roundup(bigint n) { - if (n % DELTA) n = n/DELTA * DELTA + DELTA; - if (n > MAXSMALLINT) - error->one(FLERR,"Too many atoms created on one or more procs"); + if (n % DELTA) n = n / DELTA * DELTA + DELTA; + if (n > MAXSMALLINT) error->one(FLERR, "Too many atoms created on one or more procs"); return n; } @@ -176,11 +176,11 @@ bigint AtomVec::roundup(bigint n) void AtomVec::grow_nmax() { - nmax = nmax/DELTA * DELTA; + nmax = nmax / DELTA * DELTA; nmax += DELTA; } -static constexpr bigint DELTA_BONUS=8192; +static constexpr bigint DELTA_BONUS = 8192; /* ---------------------------------------------------------------------- grow nmax_bonus so it is a multiple of DELTA_BONUS @@ -188,7 +188,7 @@ static constexpr bigint DELTA_BONUS=8192; int AtomVec::grow_nmax_bonus(int nmax_bonus) { - nmax_bonus = nmax_bonus/DELTA_BONUS * DELTA_BONUS; + nmax_bonus = nmax_bonus / DELTA_BONUS * DELTA_BONUS; nmax_bonus += DELTA_BONUS; return nmax_bonus; } @@ -201,22 +201,23 @@ int AtomVec::grow_nmax_bonus(int nmax_bonus) void AtomVec::grow(int n) { - int datatype,cols,maxcols; + int datatype, cols, maxcols; void *pdata; - if (n == 0) grow_nmax(); - else nmax = n; + if (n == 0) + grow_nmax(); + else + nmax = n; atom->nmax = nmax; - if (nmax < 0 || nmax > MAXSMALLINT) - error->one(FLERR,"Per-processor system is too big"); + if (nmax < 0 || nmax > MAXSMALLINT) error->one(FLERR, "Per-processor system is too big"); - tag = memory->grow(atom->tag,nmax,"atom:tag"); - type = memory->grow(atom->type,nmax,"atom:type"); - mask = memory->grow(atom->mask,nmax,"atom:mask"); - image = memory->grow(atom->image,nmax,"atom:image"); - x = memory->grow(atom->x,nmax,3,"atom:x"); - v = memory->grow(atom->v,nmax,3,"atom:v"); - f = memory->grow(atom->f,nmax*comm->nthreads,3,"atom:f"); + tag = memory->grow(atom->tag, nmax, "atom:tag"); + type = memory->grow(atom->type, nmax, "atom:type"); + mask = memory->grow(atom->mask, nmax, "atom:mask"); + image = memory->grow(atom->image, nmax, "atom:image"); + x = memory->grow(atom->x, nmax, 3, "atom:x"); + v = memory->grow(atom->v, nmax, 3, "atom:v"); + f = memory->grow(atom->f, nmax * comm->nthreads, 3, "atom:f"); for (int i = 0; i < ngrow; i++) { pdata = mgrow.pdata[i]; @@ -225,30 +226,30 @@ void AtomVec::grow(int n) const int nthreads = threads[i] ? comm->nthreads : 1; if (datatype == Atom::DOUBLE) { if (cols == 0) - memory->grow(*((double **) pdata),nmax*nthreads,"atom:dvec"); + memory->grow(*((double **) pdata), nmax * nthreads, "atom:dvec"); else if (cols > 0) - memory->grow(*((double ***) pdata),nmax*nthreads,cols,"atom:darray"); + memory->grow(*((double ***) pdata), nmax * nthreads, cols, "atom:darray"); else { maxcols = *(mgrow.maxcols[i]); - memory->grow(*((double ***) pdata),nmax*nthreads,maxcols,"atom:darray"); + memory->grow(*((double ***) pdata), nmax * nthreads, maxcols, "atom:darray"); } } else if (datatype == Atom::INT) { if (cols == 0) - memory->grow(*((int **) pdata),nmax*nthreads,"atom:ivec"); + memory->grow(*((int **) pdata), nmax * nthreads, "atom:ivec"); else if (cols > 0) - memory->grow(*((int ***) pdata),nmax*nthreads,cols,"atom:iarray"); + memory->grow(*((int ***) pdata), nmax * nthreads, cols, "atom:iarray"); else { maxcols = *(mgrow.maxcols[i]); - memory->grow(*((int ***) pdata),nmax*nthreads,maxcols,"atom:iarray"); + memory->grow(*((int ***) pdata), nmax * nthreads, maxcols, "atom:iarray"); } } else if (datatype == Atom::BIGINT) { if (cols == 0) - memory->grow(*((bigint **) pdata),nmax*nthreads,"atom:bvec"); + memory->grow(*((bigint **) pdata), nmax * nthreads, "atom:bvec"); else if (cols > 0) - memory->grow(*((bigint ***) pdata),nmax*nthreads,cols,"atom:barray"); + memory->grow(*((bigint ***) pdata), nmax * nthreads, cols, "atom:barray"); else { maxcols = *(mgrow.maxcols[i]); - memory->grow(*((bigint ***) pdata),nmax*nthreads,maxcols,"atom:barray"); + memory->grow(*((bigint ***) pdata), nmax * nthreads, maxcols, "atom:barray"); } } } @@ -265,8 +266,8 @@ void AtomVec::grow(int n) void AtomVec::copy(int i, int j, int delflag) { - int m,n,datatype,cols,collength,ncols; - void *pdata,*plength; + int m, n, datatype, cols, collength, ncols; + void *pdata, *plength; tag[j] = tag[i]; type[j] = type[i]; @@ -290,33 +291,33 @@ void AtomVec::copy(int i, int j, int delflag) vec[j] = vec[i]; } else if (cols > 0) { double **array = *((double ***) pdata); - for (m = 0; m < cols; m++) - array[j][m] = array[i][m]; + for (m = 0; m < cols; m++) array[j][m] = array[i][m]; } else { double **array = *((double ***) pdata); collength = mcopy.collength[n]; plength = mcopy.plength[n]; - if (collength) ncols = (*((int ***) plength))[i][collength-1]; - else ncols = (*((int **) plength))[i]; - for (m = 0; m < ncols; m++) - array[j][m] = array[i][m]; - } + if (collength) + ncols = (*((int ***) plength))[i][collength - 1]; + else + ncols = (*((int **) plength))[i]; + for (m = 0; m < ncols; m++) array[j][m] = array[i][m]; + } } else if (datatype == Atom::INT) { if (cols == 0) { int *vec = *((int **) pdata); vec[j] = vec[i]; } else if (cols > 0) { int **array = *((int ***) pdata); - for (m = 0; m < cols; m++) - array[j][m] = array[i][m]; + for (m = 0; m < cols; m++) array[j][m] = array[i][m]; } else { int **array = *((int ***) pdata); collength = mcopy.collength[n]; plength = mcopy.plength[n]; - if (collength) ncols = (*((int ***) plength))[i][collength-1]; - else ncols = (*((int **) plength))[i]; - for (m = 0; m < ncols; m++) - array[j][m] = array[i][m]; + if (collength) + ncols = (*((int ***) plength))[i][collength - 1]; + else + ncols = (*((int **) plength))[i]; + for (m = 0; m < ncols; m++) array[j][m] = array[i][m]; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { @@ -324,35 +325,34 @@ void AtomVec::copy(int i, int j, int delflag) vec[j] = vec[i]; } else if (cols > 0) { bigint **array = *((bigint ***) pdata); - for (m = 0; m < cols; m++) - array[j][m] = array[i][m]; + for (m = 0; m < cols; m++) array[j][m] = array[i][m]; } else { bigint **array = *((bigint ***) pdata); collength = mcopy.collength[n]; plength = mcopy.plength[n]; - if (collength) ncols = (*((int ***) plength))[i][collength-1]; - else ncols = (*((int **) plength))[i]; - for (m = 0; m < ncols; m++) - array[j][m] = array[i][m]; + if (collength) + ncols = (*((int ***) plength))[i][collength - 1]; + else + ncols = (*((int **) plength))[i]; + for (m = 0; m < ncols; m++) array[j][m] = array[i][m]; } } } } - if (bonus_flag) copy_bonus(i,j,delflag); + if (bonus_flag) copy_bonus(i, j, delflag); if (atom->nextra_grow) for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag); + modify->fix[atom->extra_grow[iextra]]->copy_arrays(i, j, delflag); } /* ---------------------------------------------------------------------- */ -int AtomVec::pack_comm(int n, int *list, double *buf, - int pbc_flag, int *pbc) +int AtomVec::pack_comm(int n, int *list, double *buf, int pbc_flag, int *pbc) { - int i,j,m,mm,nn,datatype,cols; - double dx,dy,dz; + int i, j, m, mm, nn, datatype, cols; + double dx, dy, dz; void *pdata; m = 0; @@ -365,13 +365,13 @@ int AtomVec::pack_comm(int n, int *list, double *buf, } } else { if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; + dx = pbc[0] * domain->xprd; + dy = pbc[1] * domain->yprd; + dz = pbc[2] * domain->zprd; } else { - dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz; - dy = pbc[1]*domain->yprd + pbc[3]*domain->yz; - dz = pbc[2]*domain->zprd; + dx = pbc[0] * domain->xprd + pbc[5] * domain->xy + pbc[4] * domain->xz; + dy = pbc[1] * domain->yprd + pbc[3] * domain->yz; + dz = pbc[2] * domain->zprd; } for (i = 0; i < n; i++) { j = list[i]; @@ -397,8 +397,7 @@ int AtomVec::pack_comm(int n, int *list, double *buf, double **array = *((double ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = array[j][mm]; + for (mm = 0; mm < cols; mm++) buf[m++] = array[j][mm]; } } } else if (datatype == Atom::INT) { @@ -412,8 +411,7 @@ int AtomVec::pack_comm(int n, int *list, double *buf, int **array = *((int ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[j][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[j][mm]).d; } } } else if (datatype == Atom::BIGINT) { @@ -427,26 +425,24 @@ int AtomVec::pack_comm(int n, int *list, double *buf, bigint **array = *((bigint ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[j][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[j][mm]).d; } } } } } - if (bonus_flag) m += pack_comm_bonus(n,list,&buf[m]); + if (bonus_flag) m += pack_comm_bonus(n, list, &buf[m]); return m; } /* ---------------------------------------------------------------------- */ -int AtomVec::pack_comm_vel(int n, int *list, double *buf, - int pbc_flag, int *pbc) +int AtomVec::pack_comm_vel(int n, int *list, double *buf, int pbc_flag, int *pbc) { - int i,j,m,mm,nn,datatype,cols; - double dx,dy,dz,dvx,dvy,dvz; + int i, j, m, mm, nn, datatype, cols; + double dx, dy, dz, dvx, dvy, dvz; void *pdata; m = 0; @@ -462,13 +458,13 @@ int AtomVec::pack_comm_vel(int n, int *list, double *buf, } } else { if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; + dx = pbc[0] * domain->xprd; + dy = pbc[1] * domain->yprd; + dz = pbc[2] * domain->zprd; } else { - dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz; - dy = pbc[1]*domain->yprd + pbc[3]*domain->yz; - dz = pbc[2]*domain->zprd; + dx = pbc[0] * domain->xprd + pbc[5] * domain->xy + pbc[4] * domain->xz; + dy = pbc[1] * domain->yprd + pbc[3] * domain->yz; + dz = pbc[2] * domain->zprd; } if (!deform_vremap) { for (i = 0; i < n; i++) { @@ -481,9 +477,9 @@ int AtomVec::pack_comm_vel(int n, int *list, double *buf, buf[m++] = v[j][2]; } } else { - dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4]; - dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3]; - dvz = pbc[2]*h_rate[2]; + dvx = pbc[0] * h_rate[0] + pbc[5] * h_rate[5] + pbc[4] * h_rate[4]; + dvy = pbc[1] * h_rate[1] + pbc[3] * h_rate[3]; + dvz = pbc[2] * h_rate[2]; for (i = 0; i < n; i++) { j = list[i]; buf[m++] = x[j][0] + dx; @@ -518,8 +514,7 @@ int AtomVec::pack_comm_vel(int n, int *list, double *buf, double **array = *((double ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = array[j][mm]; + for (mm = 0; mm < cols; mm++) buf[m++] = array[j][mm]; } } } else if (datatype == Atom::INT) { @@ -533,8 +528,7 @@ int AtomVec::pack_comm_vel(int n, int *list, double *buf, int **array = *((int ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[j][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[j][mm]).d; } } } else if (datatype == Atom::BIGINT) { @@ -548,15 +542,14 @@ int AtomVec::pack_comm_vel(int n, int *list, double *buf, bigint **array = *((bigint ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[j][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[j][mm]).d; } } } } } - if (bonus_flag) m += pack_comm_bonus(n,list,&buf[m]); + if (bonus_flag) m += pack_comm_bonus(n, list, &buf[m]); return m; } @@ -565,7 +558,7 @@ int AtomVec::pack_comm_vel(int n, int *list, double *buf, void AtomVec::unpack_comm(int n, int first, double *buf) { - int i,m,last,mm,nn,datatype,cols; + int i, m, last, mm, nn, datatype, cols; void *pdata; m = 0; @@ -584,48 +577,42 @@ void AtomVec::unpack_comm(int n, int first, double *buf) if (datatype == Atom::DOUBLE) { if (cols == 0) { double *vec = *((double **) pdata); - for (i = first; i < last; i++) - vec[i] = buf[m++]; + for (i = first; i < last; i++) vec[i] = buf[m++]; } else { double **array = *((double ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = buf[m++]; + for (mm = 0; mm < cols; mm++) array[i][mm] = buf[m++]; } } else if (datatype == Atom::INT) { if (cols == 0) { int *vec = *((int **) pdata); - for (i = first; i < last; i++) - vec[i] = (int) ubuf(buf[m++]).i; + for (i = first; i < last; i++) vec[i] = (int) ubuf(buf[m++]).i; } else { int **array = *((int ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = (int) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[i][mm] = (int) ubuf(buf[m++]).i; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { bigint *vec = *((bigint **) pdata); - for (i = first; i < last; i++) - vec[i] = (bigint) ubuf(buf[m++]).i; + for (i = first; i < last; i++) vec[i] = (bigint) ubuf(buf[m++]).i; } else { bigint **array = *((bigint ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = (bigint) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[i][mm] = (bigint) ubuf(buf[m++]).i; } } } } - if (bonus_flag) unpack_comm_bonus(n,first,&buf[m]); + if (bonus_flag) unpack_comm_bonus(n, first, &buf[m]); } /* ---------------------------------------------------------------------- */ void AtomVec::unpack_comm_vel(int n, int first, double *buf) { - int i,m,last,mm,nn,datatype,cols; + int i, m, last, mm, nn, datatype, cols; void *pdata; m = 0; @@ -647,48 +634,42 @@ void AtomVec::unpack_comm_vel(int n, int first, double *buf) if (datatype == Atom::DOUBLE) { if (cols == 0) { double *vec = *((double **) pdata); - for (i = first; i < last; i++) - vec[i] = buf[m++]; + for (i = first; i < last; i++) vec[i] = buf[m++]; } else { double **array = *((double ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = buf[m++]; + for (mm = 0; mm < cols; mm++) array[i][mm] = buf[m++]; } } else if (datatype == Atom::INT) { if (cols == 0) { int *vec = *((int **) pdata); - for (i = first; i < last; i++) - vec[i] = (int) ubuf(buf[m++]).i; + for (i = first; i < last; i++) vec[i] = (int) ubuf(buf[m++]).i; } else { int **array = *((int ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = (int) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[i][mm] = (int) ubuf(buf[m++]).i; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { bigint *vec = *((bigint **) pdata); - for (i = first; i < last; i++) - vec[i] = (bigint) ubuf(buf[m++]).i; + for (i = first; i < last; i++) vec[i] = (bigint) ubuf(buf[m++]).i; } else { bigint **array = *((bigint ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = (bigint) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[i][mm] = (bigint) ubuf(buf[m++]).i; } } } } - if (bonus_flag) unpack_comm_bonus(n,first,&buf[m]); + if (bonus_flag) unpack_comm_bonus(n, first, &buf[m]); } /* ---------------------------------------------------------------------- */ int AtomVec::pack_reverse(int n, int first, double *buf) { - int i,m,last,mm,nn,datatype,cols; + int i, m, last, mm, nn, datatype, cols; void *pdata; m = 0; @@ -707,40 +688,31 @@ int AtomVec::pack_reverse(int n, int first, double *buf) if (datatype == Atom::DOUBLE) { if (cols == 0) { double *vec = *((double **) pdata); - for (i = first; i < last; i++) { - buf[m++] = vec[i]; - } + for (i = first; i < last; i++) { buf[m++] = vec[i]; } } else { double **array = *((double ***) pdata); for (i = first; i < last; i++) { - for (mm = 0; mm < cols; mm++) - buf[m++] = array[i][mm]; + for (mm = 0; mm < cols; mm++) buf[m++] = array[i][mm]; } } } else if (datatype == Atom::INT) { if (cols == 0) { int *vec = *((int **) pdata); - for (i = first; i < last; i++) { - buf[m++] = ubuf(vec[i]).d; - } + for (i = first; i < last; i++) { buf[m++] = ubuf(vec[i]).d; } } else { int **array = *((int ***) pdata); for (i = first; i < last; i++) { - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[i][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[i][mm]).d; } } } else if (datatype == Atom::BIGINT) { if (cols == 0) { bigint *vec = *((bigint **) pdata); - for (i = first; i < last; i++) { - buf[m++] = ubuf(vec[i]).d; - } + for (i = first; i < last; i++) { buf[m++] = ubuf(vec[i]).d; } } else { bigint **array = *((bigint ***) pdata); for (i = first; i < last; i++) { - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[i][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[i][mm]).d; } } } @@ -754,7 +726,7 @@ int AtomVec::pack_reverse(int n, int first, double *buf) void AtomVec::unpack_reverse(int n, int *list, double *buf) { - int i,j,m,mm,nn,datatype,cols; + int i, j, m, mm, nn, datatype, cols; void *pdata; m = 0; @@ -781,8 +753,7 @@ void AtomVec::unpack_reverse(int n, int *list, double *buf) double **array = *((double ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - array[j][mm] += buf[m++]; + for (mm = 0; mm < cols; mm++) array[j][mm] += buf[m++]; } } } else if (datatype == Atom::INT) { @@ -796,8 +767,7 @@ void AtomVec::unpack_reverse(int n, int *list, double *buf) int **array = *((int ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - array[j][mm] += (int) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[j][mm] += (int) ubuf(buf[m++]).i; } } } else if (datatype == Atom::BIGINT) { @@ -811,8 +781,7 @@ void AtomVec::unpack_reverse(int n, int *list, double *buf) bigint **array = *((bigint ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - array[j][mm] += (bigint) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[j][mm] += (bigint) ubuf(buf[m++]).i; } } } @@ -824,8 +793,8 @@ void AtomVec::unpack_reverse(int n, int *list, double *buf) int AtomVec::pack_border(int n, int *list, double *buf, int pbc_flag, int *pbc) { - int i,j,m,mm,nn,datatype,cols; - double dx,dy,dz; + int i, j, m, mm, nn, datatype, cols; + double dx, dy, dz; void *pdata; m = 0; @@ -841,9 +810,9 @@ int AtomVec::pack_border(int n, int *list, double *buf, int pbc_flag, int *pbc) } } else { if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; + dx = pbc[0] * domain->xprd; + dy = pbc[1] * domain->yprd; + dz = pbc[2] * domain->zprd; } else { dx = pbc[0]; dy = pbc[1]; @@ -876,8 +845,7 @@ int AtomVec::pack_border(int n, int *list, double *buf, int pbc_flag, int *pbc) double **array = *((double ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = array[j][mm]; + for (mm = 0; mm < cols; mm++) buf[m++] = array[j][mm]; } } } else if (datatype == Atom::INT) { @@ -891,8 +859,7 @@ int AtomVec::pack_border(int n, int *list, double *buf, int pbc_flag, int *pbc) int **array = *((int ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[j][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[j][mm]).d; } } } else if (datatype == Atom::BIGINT) { @@ -906,30 +873,28 @@ int AtomVec::pack_border(int n, int *list, double *buf, int pbc_flag, int *pbc) bigint **array = *((bigint ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[j][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[j][mm]).d; } } } } } - if (bonus_flag) m += pack_border_bonus(n,list,&buf[m]); + if (bonus_flag) m += pack_border_bonus(n, list, &buf[m]); if (atom->nextra_border) for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]); + m += modify->fix[atom->extra_border[iextra]]->pack_border(n, list, &buf[m]); return m; } /* ---------------------------------------------------------------------- */ -int AtomVec::pack_border_vel(int n, int *list, double *buf, - int pbc_flag, int *pbc) +int AtomVec::pack_border_vel(int n, int *list, double *buf, int pbc_flag, int *pbc) { - int i,j,m,mm,nn,datatype,cols; - double dx,dy,dz,dvx,dvy,dvz; + int i, j, m, mm, nn, datatype, cols; + double dx, dy, dz, dvx, dvy, dvz; void *pdata; m = 0; @@ -948,9 +913,9 @@ int AtomVec::pack_border_vel(int n, int *list, double *buf, } } else { if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; + dx = pbc[0] * domain->xprd; + dy = pbc[1] * domain->yprd; + dz = pbc[2] * domain->zprd; } else { dx = pbc[0]; dy = pbc[1]; @@ -970,9 +935,9 @@ int AtomVec::pack_border_vel(int n, int *list, double *buf, buf[m++] = v[j][2]; } } else { - dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4]; - dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3]; - dvz = pbc[2]*h_rate[2]; + dvx = pbc[0] * h_rate[0] + pbc[5] * h_rate[5] + pbc[4] * h_rate[4]; + dvy = pbc[1] * h_rate[1] + pbc[3] * h_rate[3]; + dvz = pbc[2] * h_rate[2]; for (i = 0; i < n; i++) { j = list[i]; buf[m++] = x[j][0] + dx; @@ -1010,8 +975,7 @@ int AtomVec::pack_border_vel(int n, int *list, double *buf, double **array = *((double ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = array[j][mm]; + for (mm = 0; mm < cols; mm++) buf[m++] = array[j][mm]; } } } else if (datatype == Atom::INT) { @@ -1025,8 +989,7 @@ int AtomVec::pack_border_vel(int n, int *list, double *buf, int **array = *((int ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[j][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[j][mm]).d; } } } else if (datatype == Atom::BIGINT) { @@ -1040,19 +1003,18 @@ int AtomVec::pack_border_vel(int n, int *list, double *buf, bigint **array = *((bigint ***) pdata); for (i = 0; i < n; i++) { j = list[i]; - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[j][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[j][mm]).d; } } } } } - if (bonus_flag) m += pack_border_bonus(n,list,&buf[m]); + if (bonus_flag) m += pack_border_bonus(n, list, &buf[m]); if (atom->nextra_border) for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]); + m += modify->fix[atom->extra_border[iextra]]->pack_border(n, list, &buf[m]); return m; } @@ -1061,7 +1023,7 @@ int AtomVec::pack_border_vel(int n, int *list, double *buf, void AtomVec::unpack_border(int n, int first, double *buf) { - int i,m,last,mm,nn,datatype,cols; + int i, m, last, mm, nn, datatype, cols; void *pdata; m = 0; @@ -1085,53 +1047,46 @@ void AtomVec::unpack_border(int n, int first, double *buf) if (datatype == Atom::DOUBLE) { if (cols == 0) { double *vec = *((double **) pdata); - for (i = first; i < last; i++) - vec[i] = buf[m++]; + for (i = first; i < last; i++) vec[i] = buf[m++]; } else { double **array = *((double ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = buf[m++]; + for (mm = 0; mm < cols; mm++) array[i][mm] = buf[m++]; } } else if (datatype == Atom::INT) { if (cols == 0) { int *vec = *((int **) pdata); - for (i = first; i < last; i++) - vec[i] = (int) ubuf(buf[m++]).i; + for (i = first; i < last; i++) vec[i] = (int) ubuf(buf[m++]).i; } else { int **array = *((int ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = (int) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[i][mm] = (int) ubuf(buf[m++]).i; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { bigint *vec = *((bigint **) pdata); - for (i = first; i < last; i++) - vec[i] = (bigint) ubuf(buf[m++]).i; + for (i = first; i < last; i++) vec[i] = (bigint) ubuf(buf[m++]).i; } else { bigint **array = *((bigint ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = (bigint) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[i][mm] = (bigint) ubuf(buf[m++]).i; } } } } - if (bonus_flag) m += unpack_border_bonus(n,first,&buf[m]); + if (bonus_flag) m += unpack_border_bonus(n, first, &buf[m]); if (atom->nextra_border) for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]-> - unpack_border(n,first,&buf[m]); + m += modify->fix[atom->extra_border[iextra]]->unpack_border(n, first, &buf[m]); } /* ---------------------------------------------------------------------- */ void AtomVec::unpack_border_vel(int n, int first, double *buf) { - int i,m,last,mm,nn,datatype,cols; + int i, m, last, mm, nn, datatype, cols; void *pdata; m = 0; @@ -1158,46 +1113,39 @@ void AtomVec::unpack_border_vel(int n, int first, double *buf) if (datatype == Atom::DOUBLE) { if (cols == 0) { double *vec = *((double **) pdata); - for (i = first; i < last; i++) - vec[i] = buf[m++]; + for (i = first; i < last; i++) vec[i] = buf[m++]; } else { double **array = *((double ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = buf[m++]; + for (mm = 0; mm < cols; mm++) array[i][mm] = buf[m++]; } } else if (datatype == Atom::INT) { if (cols == 0) { int *vec = *((int **) pdata); - for (i = first; i < last; i++) - vec[i] = (int) ubuf(buf[m++]).i; + for (i = first; i < last; i++) vec[i] = (int) ubuf(buf[m++]).i; } else { int **array = *((int ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = (int) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[i][mm] = (int) ubuf(buf[m++]).i; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { bigint *vec = *((bigint **) pdata); - for (i = first; i < last; i++) - vec[i] = (bigint) ubuf(buf[m++]).i; + for (i = first; i < last; i++) vec[i] = (bigint) ubuf(buf[m++]).i; } else { bigint **array = *((bigint ***) pdata); for (i = first; i < last; i++) - for (mm = 0; mm < cols; mm++) - array[i][mm] = (bigint) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[i][mm] = (bigint) ubuf(buf[m++]).i; } } } } - if (bonus_flag) m += unpack_border_bonus(n,first,&buf[m]); + if (bonus_flag) m += unpack_border_bonus(n, first, &buf[m]); if (atom->nextra_border) for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]-> - unpack_border(n,first,&buf[m]); + m += modify->fix[atom->extra_border[iextra]]->unpack_border(n, first, &buf[m]); } /* ---------------------------------------------------------------------- @@ -1207,8 +1155,8 @@ void AtomVec::unpack_border_vel(int n, int first, double *buf) int AtomVec::pack_exchange(int i, double *buf) { - int mm,nn,datatype,cols,collength,ncols; - void *pdata,*plength; + int mm, nn, datatype, cols, collength, ncols; + void *pdata, *plength; int m = 1; buf[m++] = x[i][0]; @@ -1233,60 +1181,62 @@ int AtomVec::pack_exchange(int i, double *buf) buf[m++] = vec[i]; } else if (cols > 0) { double **array = *((double ***) pdata); - for (mm = 0; mm < cols; mm++) - buf[m++] = array[i][mm]; + for (mm = 0; mm < cols; mm++) buf[m++] = array[i][mm]; } else { double **array = *((double ***) pdata); collength = mexchange.collength[nn]; plength = mexchange.plength[nn]; - if (collength) ncols = (*((int ***) plength))[i][collength-1]; - else ncols = (*((int **) plength))[i]; - for (mm = 0; mm < ncols; mm++) - buf[m++] = array[i][mm]; + if (collength) + ncols = (*((int ***) plength))[i][collength - 1]; + else + ncols = (*((int **) plength))[i]; + for (mm = 0; mm < ncols; mm++) buf[m++] = array[i][mm]; } - } if (datatype == Atom::INT) { + } + if (datatype == Atom::INT) { if (cols == 0) { int *vec = *((int **) pdata); buf[m++] = ubuf(vec[i]).d; } else if (cols > 0) { int **array = *((int ***) pdata); - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[i][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[i][mm]).d; } else { int **array = *((int ***) pdata); collength = mexchange.collength[nn]; plength = mexchange.plength[nn]; - if (collength) ncols = (*((int ***) plength))[i][collength-1]; - else ncols = (*((int **) plength))[i]; - for (mm = 0; mm < ncols; mm++) - buf[m++] = ubuf(array[i][mm]).d; + if (collength) + ncols = (*((int ***) plength))[i][collength - 1]; + else + ncols = (*((int **) plength))[i]; + for (mm = 0; mm < ncols; mm++) buf[m++] = ubuf(array[i][mm]).d; } - } if (datatype == Atom::BIGINT) { + } + if (datatype == Atom::BIGINT) { if (cols == 0) { bigint *vec = *((bigint **) pdata); buf[m++] = ubuf(vec[i]).d; } else if (cols > 0) { bigint **array = *((bigint ***) pdata); - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[i][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[i][mm]).d; } else { bigint **array = *((bigint ***) pdata); collength = mexchange.collength[nn]; plength = mexchange.plength[nn]; - if (collength) ncols = (*((int ***) plength))[i][collength-1]; - else ncols = (*((int **) plength))[i]; - for (mm = 0; mm < ncols; mm++) - buf[m++] = ubuf(array[i][mm]).d; + if (collength) + ncols = (*((int ***) plength))[i][collength - 1]; + else + ncols = (*((int **) plength))[i]; + for (mm = 0; mm < ncols; mm++) buf[m++] = ubuf(array[i][mm]).d; } } } } - if (bonus_flag) m += pack_exchange_bonus(i,&buf[m]); + if (bonus_flag) m += pack_exchange_bonus(i, &buf[m]); if (atom->nextra_grow) for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - m += modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&buf[m]); + m += modify->fix[atom->extra_grow[iextra]]->pack_exchange(i, &buf[m]); buf[0] = m; return m; @@ -1296,8 +1246,8 @@ int AtomVec::pack_exchange(int i, double *buf) int AtomVec::unpack_exchange(double *buf) { - int mm,nn,datatype,cols,collength,ncols; - void *pdata,*plength; + int mm, nn, datatype, cols, collength, ncols; + void *pdata, *plength; int nlocal = atom->nlocal; if (nlocal == nmax) grow(0); @@ -1325,16 +1275,16 @@ int AtomVec::unpack_exchange(double *buf) vec[nlocal] = buf[m++]; } else if (cols > 0) { double **array = *((double ***) pdata); - for (mm = 0; mm < cols; mm++) - array[nlocal][mm] = buf[m++]; + for (mm = 0; mm < cols; mm++) array[nlocal][mm] = buf[m++]; } else { double **array = *((double ***) pdata); collength = mexchange.collength[nn]; plength = mexchange.plength[nn]; - if (collength) ncols = (*((int ***) plength))[nlocal][collength-1]; - else ncols = (*((int **) plength))[nlocal]; - for (mm = 0; mm < ncols; mm++) - array[nlocal][mm] = buf[m++]; + if (collength) + ncols = (*((int ***) plength))[nlocal][collength - 1]; + else + ncols = (*((int **) plength))[nlocal]; + for (mm = 0; mm < ncols; mm++) array[nlocal][mm] = buf[m++]; } } else if (datatype == Atom::INT) { if (cols == 0) { @@ -1342,16 +1292,16 @@ int AtomVec::unpack_exchange(double *buf) vec[nlocal] = (int) ubuf(buf[m++]).i; } else if (cols > 0) { int **array = *((int ***) pdata); - for (mm = 0; mm < cols; mm++) - array[nlocal][mm] = (int) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[nlocal][mm] = (int) ubuf(buf[m++]).i; } else { int **array = *((int ***) pdata); collength = mexchange.collength[nn]; plength = mexchange.plength[nn]; - if (collength) ncols = (*((int ***) plength))[nlocal][collength-1]; - else ncols = (*((int **) plength))[nlocal]; - for (mm = 0; mm < ncols; mm++) - array[nlocal][mm] = (int) ubuf(buf[m++]).i; + if (collength) + ncols = (*((int ***) plength))[nlocal][collength - 1]; + else + ncols = (*((int **) plength))[nlocal]; + for (mm = 0; mm < ncols; mm++) array[nlocal][mm] = (int) ubuf(buf[m++]).i; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { @@ -1359,27 +1309,26 @@ int AtomVec::unpack_exchange(double *buf) vec[nlocal] = (bigint) ubuf(buf[m++]).i; } else if (cols > 0) { bigint **array = *((bigint ***) pdata); - for (mm = 0; mm < cols; mm++) - array[nlocal][mm] = (bigint) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[nlocal][mm] = (bigint) ubuf(buf[m++]).i; } else { bigint **array = *((bigint ***) pdata); collength = mexchange.collength[nn]; plength = mexchange.plength[nn]; - if (collength) ncols = (*((int ***) plength))[nlocal][collength-1]; - else ncols = (*((int **) plength))[nlocal]; - for (mm = 0; mm < ncols; mm++) - array[nlocal][mm] = (bigint) ubuf(buf[m++]).i; + if (collength) + ncols = (*((int ***) plength))[nlocal][collength - 1]; + else + ncols = (*((int **) plength))[nlocal]; + for (mm = 0; mm < ncols; mm++) array[nlocal][mm] = (bigint) ubuf(buf[m++]).i; } } } } - if (bonus_flag) m += unpack_exchange_bonus(nlocal,&buf[m]); + if (bonus_flag) m += unpack_exchange_bonus(nlocal, &buf[m]); if (atom->nextra_grow) for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - m += modify->fix[atom->extra_grow[iextra]]-> - unpack_exchange(nlocal,&buf[m]); + m += modify->fix[atom->extra_grow[iextra]]->unpack_exchange(nlocal, &buf[m]); atom->nlocal++; return m; @@ -1392,7 +1341,7 @@ int AtomVec::unpack_exchange(double *buf) int AtomVec::size_restart() { - int i,nn,cols,collength,ncols; + int i, nn, cols, collength, ncols; void *plength; // NOTE: need to worry about overflow of returned int N @@ -1406,14 +1355,18 @@ int AtomVec::size_restart() if (nrestart) { for (nn = 0; nn < nrestart; nn++) { cols = mrestart.cols[nn]; - if (cols == 0) n += nlocal; - else if (cols > 0) n += cols*nlocal; + if (cols == 0) + n += nlocal; + else if (cols > 0) + n += cols * nlocal; else { collength = mrestart.collength[nn]; plength = mrestart.plength[nn]; for (i = 0; i < nlocal; i++) { - if (collength) ncols = (*((int ***) plength))[i][collength-1]; - else ncols = (*((int **) plength))[i]; + if (collength) + ncols = (*((int ***) plength))[i][collength - 1]; + else + ncols = (*((int **) plength))[i]; n += ncols; } } @@ -1424,8 +1377,7 @@ int AtomVec::size_restart() if (atom->nextra_restart) for (int iextra = 0; iextra < atom->nextra_restart; iextra++) - for (i = 0; i < nlocal; i++) - n += modify->fix[atom->extra_restart[iextra]]->size_restart(i); + for (i = 0; i < nlocal; i++) n += modify->fix[atom->extra_restart[iextra]]->size_restart(i); return n; } @@ -1438,8 +1390,8 @@ int AtomVec::size_restart() int AtomVec::pack_restart(int i, double *buf) { - int mm,nn,datatype,cols,collength,ncols; - void *pdata,*plength; + int mm, nn, datatype, cols, collength, ncols; + void *pdata, *plength; // if needed, change values before packing @@ -1467,16 +1419,16 @@ int AtomVec::pack_restart(int i, double *buf) buf[m++] = vec[i]; } else if (cols > 0) { double **array = *((double ***) pdata); - for (mm = 0; mm < cols; mm++) - buf[m++] = array[i][mm]; + for (mm = 0; mm < cols; mm++) buf[m++] = array[i][mm]; } else { double **array = *((double ***) pdata); collength = mrestart.collength[nn]; plength = mrestart.plength[nn]; - if (collength) ncols = (*((int ***) plength))[i][collength-1]; - else ncols = (*((int **) plength))[i]; - for (mm = 0; mm < ncols; mm++) - buf[m++] = array[i][mm]; + if (collength) + ncols = (*((int ***) plength))[i][collength - 1]; + else + ncols = (*((int **) plength))[i]; + for (mm = 0; mm < ncols; mm++) buf[m++] = array[i][mm]; } } else if (datatype == Atom::INT) { if (cols == 0) { @@ -1484,16 +1436,16 @@ int AtomVec::pack_restart(int i, double *buf) buf[m++] = ubuf(vec[i]).d; } else if (cols > 0) { int **array = *((int ***) pdata); - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[i][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[i][mm]).d; } else { int **array = *((int ***) pdata); collength = mrestart.collength[nn]; plength = mrestart.plength[nn]; - if (collength) ncols = (*((int ***) plength))[i][collength-1]; - else ncols = (*((int **) plength))[i]; - for (mm = 0; mm < ncols; mm++) - buf[m++] = ubuf(array[i][mm]).d; + if (collength) + ncols = (*((int ***) plength))[i][collength - 1]; + else + ncols = (*((int **) plength))[i]; + for (mm = 0; mm < ncols; mm++) buf[m++] = ubuf(array[i][mm]).d; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { @@ -1501,21 +1453,21 @@ int AtomVec::pack_restart(int i, double *buf) buf[m++] = ubuf(vec[i]).d; } else if (cols > 0) { bigint **array = *((bigint ***) pdata); - for (mm = 0; mm < cols; mm++) - buf[m++] = ubuf(array[i][mm]).d; + for (mm = 0; mm < cols; mm++) buf[m++] = ubuf(array[i][mm]).d; } else { bigint **array = *((bigint ***) pdata); collength = mrestart.collength[nn]; plength = mrestart.plength[nn]; - if (collength) ncols = (*((int ***) plength))[i][collength-1]; - else ncols = (*((int **) plength))[i]; - for (mm = 0; mm < ncols; mm++) - buf[m++] = ubuf(array[i][mm]).d; + if (collength) + ncols = (*((int ***) plength))[i][collength - 1]; + else + ncols = (*((int **) plength))[i]; + for (mm = 0; mm < ncols; mm++) buf[m++] = ubuf(array[i][mm]).d; } } } - if (bonus_flag) m += pack_restart_bonus(i,&buf[m]); + if (bonus_flag) m += pack_restart_bonus(i, &buf[m]); // if needed, restore values after packing @@ -1524,7 +1476,7 @@ int AtomVec::pack_restart(int i, double *buf) // invoke fixes which store peratom restart info for (int iextra = 0; iextra < atom->nextra_restart; iextra++) - m += modify->fix[atom->extra_restart[iextra]]->pack_restart(i,&buf[m]); + m += modify->fix[atom->extra_restart[iextra]]->pack_restart(i, &buf[m]); buf[0] = m; return m; @@ -1536,14 +1488,13 @@ int AtomVec::pack_restart(int i, double *buf) int AtomVec::unpack_restart(double *buf) { - int mm,nn,datatype,cols,collength,ncols; - void *pdata,*plength; + int mm, nn, datatype, cols, collength, ncols; + void *pdata, *plength; int nlocal = atom->nlocal; if (nlocal == nmax) { grow(0); - if (atom->nextra_store) - memory->grow(atom->extra,nmax,atom->nextra_store,"atom:extra"); + if (atom->nextra_store) memory->grow(atom->extra, nmax, atom->nextra_store, "atom:extra"); } int m = 1; @@ -1568,16 +1519,16 @@ int AtomVec::unpack_restart(double *buf) vec[nlocal] = buf[m++]; } else if (cols > 0) { double **array = *((double ***) pdata); - for (mm = 0; mm < cols; mm++) - array[nlocal][mm] = buf[m++]; + for (mm = 0; mm < cols; mm++) array[nlocal][mm] = buf[m++]; } else { double **array = *((double ***) pdata); collength = mrestart.collength[nn]; plength = mrestart.plength[nn]; - if (collength) ncols = (*((int ***) plength))[nlocal][collength-1]; - else ncols = (*((int **) plength))[nlocal]; - for (mm = 0; mm < ncols; mm++) - array[nlocal][mm] = buf[m++]; + if (collength) + ncols = (*((int ***) plength))[nlocal][collength - 1]; + else + ncols = (*((int **) plength))[nlocal]; + for (mm = 0; mm < ncols; mm++) array[nlocal][mm] = buf[m++]; } } else if (datatype == Atom::INT) { if (cols == 0) { @@ -1585,16 +1536,16 @@ int AtomVec::unpack_restart(double *buf) vec[nlocal] = (int) ubuf(buf[m++]).i; } else if (cols > 0) { int **array = *((int ***) pdata); - for (mm = 0; mm < cols; mm++) - array[nlocal][mm] = (int) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[nlocal][mm] = (int) ubuf(buf[m++]).i; } else { int **array = *((int ***) pdata); collength = mrestart.collength[nn]; plength = mrestart.plength[nn]; - if (collength) ncols = (*((int ***) plength))[nlocal][collength-1]; - else ncols = (*((int **) plength))[nlocal]; - for (mm = 0; mm < ncols; mm++) - array[nlocal][mm] = (int) ubuf(buf[m++]).i; + if (collength) + ncols = (*((int ***) plength))[nlocal][collength - 1]; + else + ncols = (*((int **) plength))[nlocal]; + for (mm = 0; mm < ncols; mm++) array[nlocal][mm] = (int) ubuf(buf[m++]).i; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { @@ -1602,21 +1553,21 @@ int AtomVec::unpack_restart(double *buf) vec[nlocal] = (bigint) ubuf(buf[m++]).i; } else if (cols > 0) { bigint **array = *((bigint ***) pdata); - for (mm = 0; mm < cols; mm++) - array[nlocal][mm] = (bigint) ubuf(buf[m++]).i; + for (mm = 0; mm < cols; mm++) array[nlocal][mm] = (bigint) ubuf(buf[m++]).i; } else { bigint **array = *((bigint ***) pdata); collength = mrestart.collength[nn]; plength = mrestart.plength[nn]; - if (collength) ncols = (*((int ***) plength))[nlocal][collength-1]; - else ncols = (*((int **) plength))[nlocal]; - for (mm = 0; mm < ncols; mm++) - array[nlocal][mm] = (bigint) ubuf(buf[m++]).i; + if (collength) + ncols = (*((int ***) plength))[nlocal][collength - 1]; + else + ncols = (*((int **) plength))[nlocal]; + for (mm = 0; mm < ncols; mm++) array[nlocal][mm] = (bigint) ubuf(buf[m++]).i; } } } - if (bonus_flag) m += unpack_restart_bonus(nlocal,&buf[m]); + if (bonus_flag) m += unpack_restart_bonus(nlocal, &buf[m]); // if needed, initialize other peratom values @@ -1626,7 +1577,7 @@ int AtomVec::unpack_restart(double *buf) double **extra = atom->extra; if (atom->nextra_store) { - int size = static_cast (buf[0]) - m; + int size = static_cast(buf[0]) - m; for (int i = 0; i < size; i++) extra[nlocal][i] = buf[m++]; } @@ -1641,7 +1592,7 @@ int AtomVec::unpack_restart(double *buf) void AtomVec::create_atom(int itype, double *coord) { - int m,n,datatype,cols; + int m, n, datatype, cols; void *pdata; int nlocal = atom->nlocal; @@ -1653,8 +1604,7 @@ void AtomVec::create_atom(int itype, double *coord) x[nlocal][1] = coord[1]; x[nlocal][2] = coord[2]; mask[nlocal] = 1; - image[nlocal] = ((imageint) IMGMAX << IMG2BITS) | - ((imageint) IMGMAX << IMGBITS) | IMGMAX; + image[nlocal] = ((imageint) IMGMAX << IMG2BITS) | ((imageint) IMGMAX << IMGBITS) | IMGMAX; v[nlocal][0] = 0.0; v[nlocal][1] = 0.0; v[nlocal][2] = 0.0; @@ -1671,8 +1621,7 @@ void AtomVec::create_atom(int itype, double *coord) vec[nlocal] = 0.0; } else { double **array = *((double ***) pdata); - for (m = 0; m < cols; m++) - array[nlocal][m] = 0.0; + for (m = 0; m < cols; m++) array[nlocal][m] = 0.0; } } else if (datatype == Atom::INT) { if (cols == 0) { @@ -1680,8 +1629,7 @@ void AtomVec::create_atom(int itype, double *coord) vec[nlocal] = 0; } else { int **array = *((int ***) pdata); - for (m = 0; m < cols; m++) - array[nlocal][m] = 0; + for (m = 0; m < cols; m++) array[nlocal][m] = 0; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { @@ -1689,8 +1637,7 @@ void AtomVec::create_atom(int itype, double *coord) vec[nlocal] = 0; } else { bigint **array = *((bigint ***) pdata); - for (m = 0; m < cols; m++) - array[nlocal][m] = 0; + for (m = 0; m < cols; m++) array[nlocal][m] = 0; } } } @@ -1709,7 +1656,7 @@ void AtomVec::create_atom(int itype, double *coord) void AtomVec::data_atom(double *coord, imageint imagetmp, const std::vector &values) { - int m,n,datatype,cols; + int m, n, datatype, cols; void *pdata; int nlocal = atom->nlocal; @@ -1732,43 +1679,42 @@ void AtomVec::data_atom(double *coord, imageint imagetmp, const std::vectorx) { // x was already set by coord arg + if (array == atom->x) { // x was already set by coord arg ivalue += cols; continue; } for (m = 0; m < cols; m++) - array[nlocal][m] = utils::numeric(FLERR,values[ivalue++],true,lmp); + array[nlocal][m] = utils::numeric(FLERR, values[ivalue++], true, lmp); } } else if (datatype == Atom::INT) { if (cols == 0) { int *vec = *((int **) pdata); - vec[nlocal] = utils::inumeric(FLERR,values[ivalue++],true,lmp); + vec[nlocal] = utils::inumeric(FLERR, values[ivalue++], true, lmp); } else { int **array = *((int ***) pdata); for (m = 0; m < cols; m++) - array[nlocal][m] = utils::inumeric(FLERR,values[ivalue++],true,lmp); + array[nlocal][m] = utils::inumeric(FLERR, values[ivalue++], true, lmp); } } else if (datatype == Atom::BIGINT) { if (cols == 0) { bigint *vec = *((bigint **) pdata); - vec[nlocal] = utils::bnumeric(FLERR,values[ivalue++],true,lmp); + vec[nlocal] = utils::bnumeric(FLERR, values[ivalue++], true, lmp); } else { bigint **array = *((bigint ***) pdata); for (m = 0; m < cols; m++) - array[nlocal][m] = utils::bnumeric(FLERR,values[ivalue++],true,lmp); + array[nlocal][m] = utils::bnumeric(FLERR, values[ivalue++], true, lmp); } } } // error checks applicable to all styles - if (tag[nlocal] <= 0) - error->one(FLERR,"Invalid atom ID in Atoms section of data file"); + if (tag[nlocal] <= 0) error->one(FLERR, "Invalid atom ID in Atoms section of data file"); if (type[nlocal] <= 0 || type[nlocal] > atom->ntypes) - error->one(FLERR,"Invalid atom type in Atoms section of data file"); + error->one(FLERR, "Invalid atom type in Atoms section of data file"); // if needed, modify unpacked values or initialize other peratom values @@ -1783,7 +1729,7 @@ void AtomVec::data_atom(double *coord, imageint imagetmp, const std::vectornlocal; @@ -1805,8 +1751,7 @@ void AtomVec::pack_data(double **buf) buf[i][j++] = vec[i]; } else { double **array = *((double ***) pdata); - for (m = 0; m < cols; m++) - buf[i][j++] = array[i][m]; + for (m = 0; m < cols; m++) buf[i][j++] = array[i][m]; } } else if (datatype == Atom::INT) { if (cols == 0) { @@ -1814,8 +1759,7 @@ void AtomVec::pack_data(double **buf) buf[i][j++] = ubuf(vec[i]).d; } else { int **array = *((int ***) pdata); - for (m = 0; m < cols; m++) - buf[i][j++] = ubuf(array[i][m]).d; + for (m = 0; m < cols; m++) buf[i][j++] = ubuf(array[i][m]).d; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { @@ -1823,8 +1767,7 @@ void AtomVec::pack_data(double **buf) buf[i][j++] = ubuf(vec[i]).d; } else { bigint **array = *((bigint ***) pdata); - for (m = 0; m < cols; m++) - buf[i][j++] = ubuf(array[i][m]).d; + for (m = 0; m < cols; m++) buf[i][j++] = ubuf(array[i][m]).d; } } } @@ -1846,10 +1789,10 @@ void AtomVec::pack_data(double **buf) void AtomVec::write_data(FILE *fp, int n, double **buf) { - int i,j,m,nn,datatype,cols; + int i, j, m, nn, datatype, cols; for (i = 0; i < n; i++) { - fmt::print(fp,"{}",ubuf(buf[i][0]).i); + fmt::print(fp, "{}", ubuf(buf[i][0]).i); j = 1; for (nn = 1; nn < ndata_atom; nn++) { @@ -1857,32 +1800,26 @@ void AtomVec::write_data(FILE *fp, int n, double **buf) cols = mdata_atom.cols[nn]; if (datatype == Atom::DOUBLE) { if (cols == 0) { - fmt::print(fp," {}",buf[i][j++]); + fmt::print(fp, " {:.16}", buf[i][j++]); } else { - for (m = 0; m < cols; m++) - fmt::print(fp," {}",buf[i][j++]); + for (m = 0; m < cols; m++) fmt::print(fp, " {}", buf[i][j++]); } } else if (datatype == Atom::INT) { if (cols == 0) { - fmt::print(fp," {}",ubuf(buf[i][j++]).i); + fmt::print(fp, " {}", ubuf(buf[i][j++]).i); } else { - for (m = 0; m < cols; m++) - fmt::print(fp," {}",ubuf(buf[i][j++]).i); + for (m = 0; m < cols; m++) fmt::print(fp, " {}", ubuf(buf[i][j++]).i); } } else if (datatype == Atom::BIGINT) { if (cols == 0) { - fmt::print(fp," {}",ubuf(buf[i][j++]).i); + fmt::print(fp, " {}", ubuf(buf[i][j++]).i); } else { - for (m = 0; m < cols; m++) - fmt::print(fp," {}",ubuf(buf[i][j++]).i); + for (m = 0; m < cols; m++) fmt::print(fp, " {}", ubuf(buf[i][j++]).i); } } } - fmt::print(fp," {} {} {}\n", - (int) ubuf(buf[i][j]).i, - (int) ubuf(buf[i][j+1]).i, - (int) ubuf(buf[i][j+2]).i); + fmt::print(fp, " {} {} {}\n", ubuf(buf[i][j]).i, ubuf(buf[i][j + 1]).i, ubuf(buf[i][j + 2]).i); } } @@ -1892,14 +1829,14 @@ void AtomVec::write_data(FILE *fp, int n, double **buf) void AtomVec::data_vel(int ilocal, const std::vector &values) { - int m,n,datatype,cols; + int m, n, datatype, cols; void *pdata; double **v = atom->v; int ivalue = 1; - v[ilocal][0] = utils::numeric(FLERR,values[ivalue++],true,lmp); - v[ilocal][1] = utils::numeric(FLERR,values[ivalue++],true,lmp); - v[ilocal][2] = utils::numeric(FLERR,values[ivalue++],true,lmp); + v[ilocal][0] = utils::numeric(FLERR, values[ivalue++], true, lmp); + v[ilocal][1] = utils::numeric(FLERR, values[ivalue++], true, lmp); + v[ilocal][2] = utils::numeric(FLERR, values[ivalue++], true, lmp); if (ndata_vel > 2) { for (n = 2; n < ndata_vel; n++) { @@ -1909,29 +1846,29 @@ void AtomVec::data_vel(int ilocal, const std::vector &values) if (datatype == Atom::DOUBLE) { if (cols == 0) { double *vec = *((double **) pdata); - vec[ilocal] = utils::numeric(FLERR,values[ivalue++],true,lmp); + vec[ilocal] = utils::numeric(FLERR, values[ivalue++], true, lmp); } else { double **array = *((double ***) pdata); for (m = 0; m < cols; m++) - array[ilocal][m] = utils::numeric(FLERR,values[ivalue++],true,lmp); + array[ilocal][m] = utils::numeric(FLERR, values[ivalue++], true, lmp); } } else if (datatype == Atom::INT) { if (cols == 0) { int *vec = *((int **) pdata); - vec[ilocal] = utils::inumeric(FLERR,values[ivalue++],true,lmp); + vec[ilocal] = utils::inumeric(FLERR, values[ivalue++], true, lmp); } else { int **array = *((int ***) pdata); for (m = 0; m < cols; m++) - array[ilocal][m] = utils::inumeric(FLERR,values[ivalue++],true,lmp); + array[ilocal][m] = utils::inumeric(FLERR, values[ivalue++], true, lmp); } } else if (datatype == Atom::BIGINT) { if (cols == 0) { bigint *vec = *((bigint **) pdata); - vec[ilocal] = utils::bnumeric(FLERR,values[ivalue++],true,lmp); + vec[ilocal] = utils::bnumeric(FLERR, values[ivalue++], true, lmp); } else { bigint **array = *((bigint ***) pdata); for (m = 0; m < cols; m++) - array[ilocal][m] = utils::bnumeric(FLERR,values[ivalue++],true,lmp); + array[ilocal][m] = utils::bnumeric(FLERR, values[ivalue++], true, lmp); } } } @@ -1944,7 +1881,7 @@ void AtomVec::data_vel(int ilocal, const std::vector &values) void AtomVec::pack_vel(double **buf) { - int i,j,m,n,datatype,cols; + int i, j, m, n, datatype, cols; void *pdata; int nlocal = atom->nlocal; @@ -1961,8 +1898,7 @@ void AtomVec::pack_vel(double **buf) buf[i][j++] = vec[i]; } else { double **array = *((double ***) pdata); - for (m = 0; m < cols; m++) - buf[i][j++] = array[i][m]; + for (m = 0; m < cols; m++) buf[i][j++] = array[i][m]; } } else if (datatype == Atom::INT) { if (cols == 0) { @@ -1970,8 +1906,7 @@ void AtomVec::pack_vel(double **buf) buf[i][j++] = ubuf(vec[i]).d; } else { int **array = *((int ***) pdata); - for (m = 0; m < cols; m++) - buf[i][j++] = ubuf(array[i][m]).d; + for (m = 0; m < cols; m++) buf[i][j++] = ubuf(array[i][m]).d; } } else if (datatype == Atom::BIGINT) { if (cols == 0) { @@ -1979,8 +1914,7 @@ void AtomVec::pack_vel(double **buf) buf[i][j++] = ubuf(vec[i]).d; } else { bigint **array = *((bigint ***) pdata); - for (m = 0; m < cols; m++) - buf[i][j++] = ubuf(array[i][m]).d; + for (m = 0; m < cols; m++) buf[i][j++] = ubuf(array[i][m]).d; } } } @@ -1994,10 +1928,10 @@ void AtomVec::pack_vel(double **buf) void AtomVec::write_vel(FILE *fp, int n, double **buf) { - int i,j,m,nn,datatype,cols; + int i, j, m, nn, datatype, cols; for (i = 0; i < n; i++) { - fmt::print(fp,"{}",ubuf(buf[i][0]).i); + fmt::print(fp, "{}", ubuf(buf[i][0]).i); j = 1; for (nn = 1; nn < ndata_vel; nn++) { @@ -2005,28 +1939,25 @@ void AtomVec::write_vel(FILE *fp, int n, double **buf) cols = mdata_vel.cols[nn]; if (datatype == Atom::DOUBLE) { if (cols == 0) { - fmt::print(fp," {}",buf[i][j++]); + fmt::print(fp, " {}", buf[i][j++]); } else { - for (m = 0; m < cols; m++) - fmt::print(fp," {}",buf[i][j++]); + for (m = 0; m < cols; m++) fmt::print(fp, " {}", buf[i][j++]); } } else if (datatype == Atom::INT) { if (cols == 0) { - fmt::print(fp," {}",ubuf(buf[i][j++]).i); + fmt::print(fp, " {}", ubuf(buf[i][j++]).i); } else { - for (m = 0; m < cols; m++) - fmt::print(fp," {}",ubuf(buf[i][j++]).i); + for (m = 0; m < cols; m++) fmt::print(fp, " {}", ubuf(buf[i][j++]).i); } } else if (datatype == Atom::BIGINT) { if (cols == 0) { - fmt::print(fp," {}",ubuf(buf[i][j++]).i); + fmt::print(fp, " {}", ubuf(buf[i][j++]).i); } else { - for (m = 0; m < cols; m++) - fmt::print(fp," {}",ubuf(buf[i][j++]).i); + for (m = 0; m < cols; m++) fmt::print(fp, " {}", ubuf(buf[i][j++]).i); } } } - fputs("\n",fp); + fputs("\n", fp); } } @@ -2046,14 +1977,14 @@ int AtomVec::pack_bond(tagint **buf) int nlocal = atom->nlocal; int newton_bond = force->newton_bond; - int i,j; + int i, j; int m = 0; if (newton_bond) { for (i = 0; i < nlocal; i++) for (j = 0; j < num_bond[i]; j++) { if (bond_type[i][j] == 0) continue; if (buf) { - buf[m][0] = MAX(bond_type[i][j],-bond_type[i][j]); + buf[m][0] = MAX(bond_type[i][j], -bond_type[i][j]); buf[m][1] = tag[i]; buf[m][2] = bond_atom[i][j]; } @@ -2065,7 +1996,7 @@ int AtomVec::pack_bond(tagint **buf) if (tag[i] < bond_atom[i][j]) { if (bond_type[i][j] == 0) continue; if (buf) { - buf[m][0] = MAX(bond_type[i][j],-bond_type[i][j]); + buf[m][0] = MAX(bond_type[i][j], -bond_type[i][j]); buf[m][1] = tag[i]; buf[m][2] = bond_atom[i][j]; } @@ -2083,7 +2014,7 @@ int AtomVec::pack_bond(tagint **buf) void AtomVec::write_bond(FILE *fp, int n, tagint **buf, int index) { for (int i = 0; i < n; i++) { - fmt::print(fp,"{} {} {} {}\n",index,buf[i][0],buf[i][1],buf[i][2]); + fmt::print(fp, "{} {} {} {}\n", index, buf[i][0], buf[i][1], buf[i][2]); index++; } } @@ -2106,14 +2037,14 @@ int AtomVec::pack_angle(tagint **buf) int nlocal = atom->nlocal; int newton_bond = force->newton_bond; - int i,j; + int i, j; int m = 0; if (newton_bond) { for (i = 0; i < nlocal; i++) for (j = 0; j < num_angle[i]; j++) { if (angle_type[i][j] == 0) continue; if (buf) { - buf[m][0] = MAX(angle_type[i][j],-angle_type[i][j]); + buf[m][0] = MAX(angle_type[i][j], -angle_type[i][j]); buf[m][1] = angle_atom1[i][j]; buf[m][2] = angle_atom2[i][j]; buf[m][3] = angle_atom3[i][j]; @@ -2126,7 +2057,7 @@ int AtomVec::pack_angle(tagint **buf) if (tag[i] == angle_atom2[i][j]) { if (angle_type[i][j] == 0) continue; if (buf) { - buf[m][0] = MAX(angle_type[i][j],-angle_type[i][j]); + buf[m][0] = MAX(angle_type[i][j], -angle_type[i][j]); buf[m][1] = angle_atom1[i][j]; buf[m][2] = angle_atom2[i][j]; buf[m][3] = angle_atom3[i][j]; @@ -2145,8 +2076,7 @@ int AtomVec::pack_angle(tagint **buf) void AtomVec::write_angle(FILE *fp, int n, tagint **buf, int index) { for (int i = 0; i < n; i++) { - fmt::print(fp,"{} {} {} {} {}\n",index, - buf[i][0],buf[i][1],buf[i][2],buf[i][3]); + fmt::print(fp, "{} {} {} {} {}\n", index, buf[i][0], buf[i][1], buf[i][2], buf[i][3]); index++; } } @@ -2167,13 +2097,13 @@ int AtomVec::pack_dihedral(tagint **buf) int nlocal = atom->nlocal; int newton_bond = force->newton_bond; - int i,j; + int i, j; int m = 0; if (newton_bond) { for (i = 0; i < nlocal; i++) for (j = 0; j < num_dihedral[i]; j++) { if (buf) { - buf[m][0] = MAX(dihedral_type[i][j],-dihedral_type[i][j]); + buf[m][0] = MAX(dihedral_type[i][j], -dihedral_type[i][j]); buf[m][1] = dihedral_atom1[i][j]; buf[m][2] = dihedral_atom2[i][j]; buf[m][3] = dihedral_atom3[i][j]; @@ -2186,7 +2116,7 @@ int AtomVec::pack_dihedral(tagint **buf) for (j = 0; j < num_dihedral[i]; j++) if (tag[i] == dihedral_atom2[i][j]) { if (buf) { - buf[m][0] = MAX(dihedral_type[i][j],-dihedral_type[i][j]); + buf[m][0] = MAX(dihedral_type[i][j], -dihedral_type[i][j]); buf[m][1] = dihedral_atom1[i][j]; buf[m][2] = dihedral_atom2[i][j]; buf[m][3] = dihedral_atom3[i][j]; @@ -2206,8 +2136,8 @@ int AtomVec::pack_dihedral(tagint **buf) void AtomVec::write_dihedral(FILE *fp, int n, tagint **buf, int index) { for (int i = 0; i < n; i++) { - fmt::print(fp,"{} {} {} {} {} {}\n",index,buf[i][0], - buf[i][1],buf[i][2],buf[i][3],buf[i][4]); + fmt::print(fp, "{} {} {} {} {} {}\n", index, buf[i][0], buf[i][1], buf[i][2], buf[i][3], + buf[i][4]); index++; } } @@ -2228,13 +2158,13 @@ int AtomVec::pack_improper(tagint **buf) int nlocal = atom->nlocal; int newton_bond = force->newton_bond; - int i,j; + int i, j; int m = 0; if (newton_bond) { for (i = 0; i < nlocal; i++) for (j = 0; j < num_improper[i]; j++) { if (buf) { - buf[m][0] = MAX(improper_type[i][j],-improper_type[i][j]); + buf[m][0] = MAX(improper_type[i][j], -improper_type[i][j]); buf[m][1] = improper_atom1[i][j]; buf[m][2] = improper_atom2[i][j]; buf[m][3] = improper_atom3[i][j]; @@ -2247,7 +2177,7 @@ int AtomVec::pack_improper(tagint **buf) for (j = 0; j < num_improper[i]; j++) if (tag[i] == improper_atom2[i][j]) { if (buf) { - buf[m][0] = MAX(improper_type[i][j],-improper_type[i][j]); + buf[m][0] = MAX(improper_type[i][j], -improper_type[i][j]); buf[m][1] = improper_atom1[i][j]; buf[m][2] = improper_atom2[i][j]; buf[m][3] = improper_atom3[i][j]; @@ -2267,8 +2197,8 @@ int AtomVec::pack_improper(tagint **buf) void AtomVec::write_improper(FILE *fp, int n, tagint **buf, int index) { for (int i = 0; i < n; i++) { - fmt::print(fp,"{} {} {} {} {} {}\n",index,buf[i][0], - buf[i][1],buf[i][2],buf[i][3],buf[i][4]); + fmt::print(fp, "{} {} {} {} {} {}\n", index, buf[i][0], buf[i][1], buf[i][2], buf[i][3], + buf[i][4]); index++; } } @@ -2279,18 +2209,18 @@ void AtomVec::write_improper(FILE *fp, int n, tagint **buf, int index) double AtomVec::memory_usage() { - int datatype,cols,maxcols; + int datatype, cols, maxcols; void *pdata; double bytes = 0; - bytes += memory->usage(tag,nmax); - bytes += memory->usage(type,nmax); - bytes += memory->usage(mask,nmax); - bytes += memory->usage(image,nmax); - bytes += memory->usage(x,nmax,3); - bytes += memory->usage(v,nmax,3); - bytes += memory->usage(f,nmax*comm->nthreads,3); + bytes += memory->usage(tag, nmax); + bytes += memory->usage(type, nmax); + bytes += memory->usage(mask, nmax); + bytes += memory->usage(image, nmax); + bytes += memory->usage(x, nmax, 3); + bytes += memory->usage(v, nmax, 3); + bytes += memory->usage(f, nmax * comm->nthreads, 3); for (int i = 0; i < ngrow; i++) { pdata = mgrow.pdata[i]; @@ -2299,30 +2229,30 @@ double AtomVec::memory_usage() const int nthreads = threads[i] ? comm->nthreads : 1; if (datatype == Atom::DOUBLE) { if (cols == 0) { - bytes += memory->usage(*((double **) pdata),nmax*nthreads); + bytes += memory->usage(*((double **) pdata), nmax * nthreads); } else if (cols > 0) { - bytes += memory->usage(*((double ***) pdata),nmax*nthreads,cols); + bytes += memory->usage(*((double ***) pdata), nmax * nthreads, cols); } else { maxcols = *(mgrow.maxcols[i]); - bytes += memory->usage(*((double ***) pdata),nmax*nthreads,maxcols); + bytes += memory->usage(*((double ***) pdata), nmax * nthreads, maxcols); } } else if (datatype == Atom::INT) { if (cols == 0) { - bytes += memory->usage(*((int **) pdata),nmax*nthreads); + bytes += memory->usage(*((int **) pdata), nmax * nthreads); } else if (cols > 0) { - bytes += memory->usage(*((int ***) pdata),nmax*nthreads,cols); + bytes += memory->usage(*((int ***) pdata), nmax * nthreads, cols); } else { maxcols = *(mgrow.maxcols[i]); - bytes += memory->usage(*((int ***) pdata),nmax*nthreads,maxcols); + bytes += memory->usage(*((int ***) pdata), nmax * nthreads, maxcols); } } else if (datatype == Atom::BIGINT) { if (cols == 0) { - bytes += memory->usage(*((bigint **) pdata),nmax*nthreads); + bytes += memory->usage(*((bigint **) pdata), nmax * nthreads); } else if (cols > 0) { - bytes += memory->usage(*((bigint ***) pdata),nmax*nthreads,cols); + bytes += memory->usage(*((bigint ***) pdata), nmax * nthreads, cols); } else { maxcols = *(mgrow.maxcols[i]); - bytes += memory->usage(*((bigint ***) pdata),nmax*nthreads,maxcols); + bytes += memory->usage(*((bigint ***) pdata), nmax * nthreads, maxcols); } } } @@ -2342,49 +2272,50 @@ double AtomVec::memory_usage() void AtomVec::setup_fields() { - int n,cols; + int n, cols; - if (!utils::strmatch(fields_data_atom,"^id ")) - error->all(FLERR,"Atom style fields_data_atom must have id as first field"); - if (!utils::strmatch(fields_data_vel,"^id v")) - error->all(FLERR,"Atom style fields_data_vel must have " - "'id v' as first fields"); + if ((fields_data_atom.size() < 1) || (fields_data_atom[0] != "id")) + error->all(FLERR, "Atom style fields_data_atom must have 'id' as first field"); + if ((fields_data_vel.size() < 2) || (fields_data_vel[0] != "id") || (fields_data_vel[1] != "v")) + error->all(FLERR, "Atom style fields_data_vel must have 'id' and 'v' as first two fields"); // process field strings // return # of fields and matching index into atom->peratom (in Method struct) - ngrow = process_fields(fields_grow,default_grow,&mgrow); - ncopy = process_fields(fields_copy,default_copy,&mcopy); - ncomm = process_fields(fields_comm,default_comm,&mcomm); - ncomm_vel = process_fields(fields_comm_vel,default_comm_vel,&mcomm_vel); - nreverse = process_fields(fields_reverse,default_reverse,&mreverse); - nborder = process_fields(fields_border,default_border,&mborder); - nborder_vel = process_fields(fields_border_vel,default_border_vel,&mborder_vel); - nexchange = process_fields(fields_exchange,default_exchange,&mexchange); - nrestart = process_fields(fields_restart,default_restart,&mrestart); - ncreate = process_fields(fields_create,default_create,&mcreate); - ndata_atom = process_fields(fields_data_atom,default_data_atom,&mdata_atom); - ndata_vel = process_fields(fields_data_vel,default_data_vel,&mdata_vel); + ngrow = process_fields(fields_grow, default_grow, &mgrow); + ncopy = process_fields(fields_copy, default_copy, &mcopy); + ncomm = process_fields(fields_comm, default_comm, &mcomm); + ncomm_vel = process_fields(fields_comm_vel, default_comm_vel, &mcomm_vel); + nreverse = process_fields(fields_reverse, default_reverse, &mreverse); + nborder = process_fields(fields_border, default_border, &mborder); + nborder_vel = process_fields(fields_border_vel, default_border_vel, &mborder_vel); + nexchange = process_fields(fields_exchange, default_exchange, &mexchange); + nrestart = process_fields(fields_restart, default_restart, &mrestart); + ncreate = process_fields(fields_create, default_create, &mcreate); + ndata_atom = process_fields(fields_data_atom, default_data_atom, &mdata_atom); + ndata_vel = process_fields(fields_data_vel, default_data_vel, &mdata_vel); // populate field-based data struct for each method to use - init_method(ngrow,&mgrow); - init_method(ncopy,&mcopy); - init_method(ncomm,&mcomm); - init_method(ncomm_vel,&mcomm_vel); - init_method(nreverse,&mreverse); - init_method(nborder,&mborder); - init_method(nborder_vel,&mborder_vel); - init_method(nexchange,&mexchange); - init_method(nrestart,&mrestart); - init_method(ncreate,&mcreate); - init_method(ndata_atom,&mdata_atom); - init_method(ndata_vel,&mdata_vel); + init_method(ngrow, &mgrow); + init_method(ncopy, &mcopy); + init_method(ncomm, &mcomm); + init_method(ncomm_vel, &mcomm_vel); + init_method(nreverse, &mreverse); + init_method(nborder, &mborder); + init_method(nborder_vel, &mborder_vel); + init_method(nexchange, &mexchange); + init_method(nrestart, &mrestart); + init_method(ncreate, &mcreate); + init_method(ndata_atom, &mdata_atom); + init_method(ndata_vel, &mdata_vel); // create threads data struct for grow and memory_usage to use - if (ngrow) threads = new bool[ngrow]; - else threads = nullptr; + if (ngrow) + threads = new bool[ngrow]; + else + threads = nullptr; for (int i = 0; i < ngrow; i++) { Atom::PerAtom *field = &atom->peratom[mgrow.index[i]]; threads[i] = field->threadflag == 1; @@ -2396,53 +2327,66 @@ void AtomVec::setup_fields() if (ncomm) comm_x_only = 0; if (bonus_flag && size_forward_bonus) comm_x_only = 0; - if (nreverse == 0) comm_f_only = 1; - else comm_f_only = 0; + if (nreverse == 0) + comm_f_only = 1; + else + comm_f_only = 0; size_forward = 3; for (n = 0; n < ncomm; n++) { cols = mcomm.cols[n]; - if (cols == 0) size_forward++; - else size_forward += cols; + if (cols == 0) + size_forward++; + else + size_forward += cols; } if (bonus_flag) size_forward += size_forward_bonus; size_reverse = 3; for (n = 0; n < nreverse; n++) { cols = mreverse.cols[n]; - if (cols == 0) size_reverse++; - else size_reverse += cols; + if (cols == 0) + size_reverse++; + else + size_reverse += cols; } size_border = 6; for (n = 0; n < nborder; n++) { cols = mborder.cols[n]; - if (cols == 0) size_border++; - else size_border += cols; + if (cols == 0) + size_border++; + else + size_border += cols; } if (bonus_flag) size_border += size_border_bonus; size_velocity = 3; for (n = 0; n < ncomm_vel; n++) { cols = mcomm_vel.cols[n]; - if (cols == 0) size_velocity++; - else size_velocity += cols; + if (cols == 0) + size_velocity++; + else + size_velocity += cols; } size_data_atom = 0; for (n = 0; n < ndata_atom; n++) { cols = mdata_atom.cols[n]; - if (strcmp(atom->peratom[mdata_atom.index[n]].name,"x") == 0) - xcol_data = size_data_atom + 1; - if (cols == 0) size_data_atom++; - else size_data_atom += cols; + if (strcmp(atom->peratom[mdata_atom.index[n]].name, "x") == 0) xcol_data = size_data_atom + 1; + if (cols == 0) + size_data_atom++; + else + size_data_atom += cols; } size_data_vel = 0; for (n = 0; n < ndata_vel; n++) { cols = mdata_vel.cols[n]; - if (cols == 0) size_data_vel++; - else size_data_vel += cols; + if (cols == 0) + size_data_vel++; + else + size_data_vel += cols; } } @@ -2450,18 +2394,11 @@ void AtomVec::setup_fields() process a single field string ------------------------------------------------------------------------- */ -int AtomVec::process_fields(char *str, const char *default_str, Method *method) +int AtomVec::process_fields(const std::vector &words, + const std::vector &def_words, Method *method) { - if (str == nullptr) { - return 0; - } - - // tokenize words in both strings - std::vector words = Tokenizer(str, " ").as_vector(); - std::vector def_words = Tokenizer(default_str, " ").as_vector(); - int nfield = words.size(); - int ndef = def_words.size(); + int ndef = def_words.size(); // process fields one by one, add to index vector @@ -2471,31 +2408,28 @@ int AtomVec::process_fields(char *str, const char *default_str, Method *method) // allocate memory in method method->resize(nfield); - std::vector & index = method->index; + std::vector &index = method->index; int match; for (int i = 0; i < nfield; i++) { - const std::string & field = words[i]; + const std::string &field = words[i]; // find field in master Atom::peratom list for (match = 0; match < nperatom; match++) if (field == peratom[match].name) break; - if (match == nperatom) - error->all(FLERR,"Peratom field {} not recognized", field); + if (match == nperatom) error->all(FLERR, "Peratom field {} not recognized", field); index[i] = match; // error if field appears multiple times for (match = 0; match < i; match++) - if (index[i] == index[match]) - error->all(FLERR,"Peratom field {} is repeated", field); + if (index[i] == index[match]) error->all(FLERR, "Peratom field {} is repeated", field); // error if field is in default str for (match = 0; match < ndef; match++) - if (field == def_words[match]) - error->all(FLERR,"Peratom field {} is a default", field); + if (field == def_words[match]) error->all(FLERR, "Peratom field {} is a default", field); } return nfield; @@ -2524,7 +2458,8 @@ void AtomVec::init_method(int nfield, Method *method) Method class members ------------------------------------------------------------------------- */ -void AtomVec::Method::resize(int nfield) { +void AtomVec::Method::resize(int nfield) +{ pdata.resize(nfield); datatype.resize(nfield); cols.resize(nfield); diff --git a/src/atom_vec.h b/src/atom_vec.h index ad1c7f3315..1af160ccbd 100644 --- a/src/atom_vec.h +++ b/src/atom_vec.h @@ -59,11 +59,10 @@ class AtomVec : protected Pointers { // additional list of peratom fields operated on by different methods // set or created by child styles - char *fields_grow, *fields_copy; - char *fields_comm, *fields_comm_vel, *fields_reverse; - char *fields_border, *fields_border_vel; - char *fields_exchange, *fields_restart; - char *fields_create, *fields_data_atom, *fields_data_vel; + std::vector fields_grow, fields_copy, fields_comm, fields_comm_vel; + std::vector fields_reverse, fields_border, fields_border_vel; + std::vector fields_exchange, fields_restart, fields_create; + std::vector fields_data_atom, fields_data_vel; // methods @@ -152,7 +151,7 @@ class AtomVec : protected Pointers { virtual int pack_data_bonus(double *, int) { return 0; } virtual void write_data_bonus(FILE *, int, double *, int) {} - virtual int property_atom(char *) { return -1; } + virtual int property_atom(const std::string &) { return -1; } virtual void pack_property_atom(int, double *, int, int) {} virtual double memory_usage(); @@ -187,11 +186,10 @@ class AtomVec : protected Pointers { // standard list of peratom fields always operated on by different methods // common to all styles, so not listed in field strings - const char *default_grow, *default_copy; - const char *default_comm, *default_comm_vel, *default_reverse; - const char *default_border, *default_border_vel; - const char *default_exchange, *default_restart; - const char *default_create, *default_data_atom, *default_data_vel; + static const std::vector default_grow, default_copy, default_comm, default_comm_vel; + static const std::vector default_reverse, default_border, default_border_vel; + static const std::vector default_exchange, default_restart, default_create; + static const std::vector default_data_atom, default_data_vel; struct Method { std::vector pdata; @@ -223,7 +221,7 @@ class AtomVec : protected Pointers { void grow_nmax(); int grow_nmax_bonus(int); void setup_fields(); - int process_fields(char *, const char *, Method *); + int process_fields(const std::vector &, const std::vector &, Method *); void init_method(int, Method *); }; diff --git a/src/atom_vec_atomic.cpp b/src/atom_vec_atomic.cpp index 88584981f5..ab84988a64 100644 --- a/src/atom_vec_atomic.cpp +++ b/src/atom_vec_atomic.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -30,18 +29,18 @@ AtomVecAtomic::AtomVecAtomic(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) ""; - fields_copy = (char *) ""; - fields_comm = (char *) ""; - fields_comm_vel = (char *) ""; - fields_reverse = (char *) ""; - fields_border = (char *) ""; - fields_border_vel = (char *) ""; - fields_exchange = (char *) ""; - fields_restart = (char *) ""; - fields_create = (char *) ""; - fields_data_atom = (char *) "id type x"; - fields_data_vel = (char *) "id v"; + fields_grow = {}; + fields_copy = {}; + fields_comm = {}; + fields_comm_vel = {}; + fields_reverse = {}; + fields_border = {}; + fields_border_vel = {}; + fields_exchange = {}; + fields_restart = {}; + fields_create = {}; + fields_data_atom = {"id", "type", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); } diff --git a/src/atom_vec_body.cpp b/src/atom_vec_body.cpp index 8d62b6b7e7..556deea3a4 100644 --- a/src/atom_vec_body.cpp +++ b/src/atom_vec_body.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -23,8 +22,6 @@ #include "modify.h" #include "my_pool_chunk.h" -#include - using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ @@ -54,27 +51,30 @@ AtomVecBody::AtomVecBody(LAMMPS *lmp) : AtomVec(lmp) bptr = nullptr; - if (sizeof(double) == sizeof(int)) intdoubleratio = 1; - else if (sizeof(double) == 2*sizeof(int)) intdoubleratio = 2; - else error->all(FLERR,"Internal error in atom_style body"); + if (sizeof(double) == sizeof(int)) + intdoubleratio = 1; + else if (sizeof(double) == 2 * sizeof(int)) + intdoubleratio = 2; + else + error->all(FLERR, "Internal error in atom_style body"); // strings with peratom variables to include in each AtomVec method // strings cannot contain fields in corresponding AtomVec default strings // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "radius rmass angmom torque body"; - fields_copy = (char *) "radius rmass angmom"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) "angmom"; - fields_reverse = (char *) "torque"; - fields_border = (char *) "radius rmass"; - fields_border_vel = (char *) "radius rmass angmom"; - fields_exchange = (char *) "radius rmass angmom"; - fields_restart = (char *) "radius rmass angmom"; - fields_create = (char *) "radius rmass angmom body"; - fields_data_atom = (char *) "id type body rmass x"; - fields_data_vel = (char *) "id v angmom"; + fields_grow = {"radius", "rmass", "angmom", "torque", "body"}; + fields_copy = {"radius", "rmass", "angmom"}; + fields_comm = {}; + fields_comm_vel = {"angmom"}; + fields_reverse = {"torque"}; + fields_border = {"radius", "rmass"}; + fields_border_vel = {"radius", "rmass", "angmom"}; + fields_exchange = {"radius", "rmass", "angmom"}; + fields_restart = {"radius", "rmass", "angmom"}; + fields_create = {"radius", "rmass", "angmom", "body"}; + fields_data_atom = {"id", "type", "body", "rmass", "x"}; + fields_data_vel = {"id", "v", "angmom"}; } /* ---------------------------------------------------------------------- */ @@ -101,23 +101,25 @@ void AtomVecBody::process_args(int narg, char **arg) { // suppress unused parameter warning dependent on style_body.h - (void)(arg); + (void) (arg); - if (narg < 1) error->all(FLERR,"Invalid atom_style body command"); + if (narg < 1) error->all(FLERR, "Invalid atom_style body command"); - if (false) { // NOLINT + if (false) { // NOLINT bptr = nullptr; #define BODY_CLASS -#define BodyStyle(key,Class) \ - } else if (strcmp(arg[0],#key) == 0) { \ - bptr = new Class(lmp,narg,arg); -#include "style_body.h" // IWYU pragma: keep +#define BodyStyle(key, Class) \ + } \ + else if (strcmp(arg[0], #key) == 0) \ + { \ + bptr = new Class(lmp, narg, arg); +#include "style_body.h" // IWYU pragma: keep #undef BodyStyle #undef BODY_CLASS - } else error->all(FLERR,utils:: - check_packages_for_style("body",arg[0],lmp).c_str()); + } else + error->all(FLERR, utils::check_packages_for_style("body", arg[0], lmp).c_str()); bptr->avec = this; icp = bptr->icp; @@ -153,11 +155,9 @@ void AtomVecBody::grow_pointers() void AtomVecBody::grow_bonus() { nmax_bonus = grow_nmax_bonus(nmax_bonus); - if (nmax_bonus < 0) - error->one(FLERR,"Per-processor system is too big"); + if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big"); - bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus), - "atom:bonus"); + bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom:bonus"); } /* ---------------------------------------------------------------------- @@ -173,7 +173,7 @@ void AtomVecBody::copy_bonus(int i, int j, int delflag) int k = body[j]; icp->put(bonus[k].iindex); dcp->put(bonus[k].dindex); - copy_bonus_all(nlocal_bonus-1,k); + copy_bonus_all(nlocal_bonus - 1, k); nlocal_bonus--; } @@ -192,7 +192,7 @@ void AtomVecBody::copy_bonus(int i, int j, int delflag) void AtomVecBody::copy_bonus_all(int i, int j) { body[bonus[i].ilocal] = j; - memcpy(&bonus[j],&bonus[i],sizeof(Bonus)); + memcpy(&bonus[j], &bonus[i], sizeof(Bonus)); } /* ---------------------------------------------------------------------- @@ -218,7 +218,7 @@ void AtomVecBody::clear_bonus() int AtomVecBody::pack_comm_bonus(int n, int *list, double *buf) { - int i,j,m; + int i, j, m; double *quat; m = 0; @@ -230,7 +230,7 @@ int AtomVecBody::pack_comm_bonus(int n, int *list, double *buf) buf[m++] = quat[1]; buf[m++] = quat[2]; buf[m++] = quat[3]; - m += bptr->pack_comm_body(&bonus[body[j]],&buf[m]); + m += bptr->pack_comm_body(&bonus[body[j]], &buf[m]); } } @@ -241,7 +241,7 @@ int AtomVecBody::pack_comm_bonus(int n, int *list, double *buf) void AtomVecBody::unpack_comm_bonus(int n, int first, double *buf) { - int i,m,last; + int i, m, last; double *quat; m = 0; @@ -253,7 +253,7 @@ void AtomVecBody::unpack_comm_bonus(int n, int first, double *buf) quat[1] = buf[m++]; quat[2] = buf[m++]; quat[3] = buf[m++]; - m += bptr->unpack_comm_body(&bonus[body[i]],&buf[m]); + m += bptr->unpack_comm_body(&bonus[body[i]], &buf[m]); } } } @@ -262,13 +262,14 @@ void AtomVecBody::unpack_comm_bonus(int n, int first, double *buf) int AtomVecBody::pack_border_bonus(int n, int *list, double *buf) { - int i,j,m; - double *quat,*inertia; + int i, j, m; + double *quat, *inertia; m = 0; for (i = 0; i < n; i++) { j = list[i]; - if (body[j] < 0) buf[m++] = ubuf(0).d; + if (body[j] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; quat = bonus[body[j]].quat; @@ -282,7 +283,7 @@ int AtomVecBody::pack_border_bonus(int n, int *list, double *buf) buf[m++] = inertia[2]; buf[m++] = ubuf(bonus[body[j]].ninteger).d; buf[m++] = ubuf(bonus[body[j]].ndouble).d; - m += bptr->pack_border_body(&bonus[body[j]],&buf[m]); + m += bptr->pack_border_body(&bonus[body[j]], &buf[m]); } } @@ -293,14 +294,15 @@ int AtomVecBody::pack_border_bonus(int n, int *list, double *buf) int AtomVecBody::unpack_border_bonus(int n, int first, double *buf) { - int i,j,m,last; - double *quat,*inertia; + int i, j, m, last; + double *quat, *inertia; m = 0; last = first + n; for (i = first; i < last; i++) { body[i] = (int) ubuf(buf[m++]).i; - if (body[i] == 0) body[i] = -1; + if (body[i] == 0) + body[i] = -1; else { j = nlocal_bonus + nghost_bonus; if (j == nmax_bonus) grow_bonus(); @@ -316,9 +318,9 @@ int AtomVecBody::unpack_border_bonus(int n, int first, double *buf) bonus[j].ninteger = (int) ubuf(buf[m++]).i; bonus[j].ndouble = (int) ubuf(buf[m++]).i; // corresponding put() calls are in clear_bonus() - bonus[j].ivalue = icp->get(bonus[j].ninteger,bonus[j].iindex); - bonus[j].dvalue = dcp->get(bonus[j].ndouble,bonus[j].dindex); - m += bptr->unpack_border_body(&bonus[j],&buf[m]); + bonus[j].ivalue = icp->get(bonus[j].ninteger, bonus[j].iindex); + bonus[j].dvalue = dcp->get(bonus[j].ndouble, bonus[j].dindex); + m += bptr->unpack_border_body(&bonus[j], &buf[m]); bonus[j].ilocal = i; body[i] = j; nghost_bonus++; @@ -337,7 +339,8 @@ int AtomVecBody::pack_exchange_bonus(int i, double *buf) { int m = 0; - if (body[i] < 0) buf[m++] = ubuf(0).d; + if (body[i] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; int j = body[i]; @@ -352,10 +355,12 @@ int AtomVecBody::pack_exchange_bonus(int i, double *buf) buf[m++] = inertia[2]; buf[m++] = ubuf(bonus[j].ninteger).d; buf[m++] = ubuf(bonus[j].ndouble).d; - memcpy(&buf[m],bonus[j].ivalue,bonus[j].ninteger*sizeof(int)); - if (intdoubleratio == 1) m += bonus[j].ninteger; - else m += (bonus[j].ninteger+1)/2; - memcpy(&buf[m],bonus[j].dvalue,bonus[j].ndouble*sizeof(double)); + memcpy(&buf[m], bonus[j].ivalue, bonus[j].ninteger * sizeof(int)); + if (intdoubleratio == 1) + m += bonus[j].ninteger; + else + m += (bonus[j].ninteger + 1) / 2; + memcpy(&buf[m], bonus[j].dvalue, bonus[j].ndouble * sizeof(double)); m += bonus[j].ndouble; } @@ -369,7 +374,8 @@ int AtomVecBody::unpack_exchange_bonus(int ilocal, double *buf) int m = 0; body[ilocal] = (int) ubuf(buf[m++]).i; - if (body[ilocal] == 0) body[ilocal] = -1; + if (body[ilocal] == 0) + body[ilocal] = -1; else { if (nlocal_bonus == nmax_bonus) grow_bonus(); double *quat = bonus[nlocal_bonus].quat; @@ -384,16 +390,14 @@ int AtomVecBody::unpack_exchange_bonus(int ilocal, double *buf) bonus[nlocal_bonus].ninteger = (int) ubuf(buf[m++]).i; bonus[nlocal_bonus].ndouble = (int) ubuf(buf[m++]).i; // corresponding put() calls are in copy() - bonus[nlocal_bonus].ivalue = icp->get(bonus[nlocal_bonus].ninteger, - bonus[nlocal_bonus].iindex); - bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble, - bonus[nlocal_bonus].dindex); - memcpy(bonus[nlocal_bonus].ivalue,&buf[m], - bonus[nlocal_bonus].ninteger*sizeof(int)); - if (intdoubleratio == 1) m += bonus[nlocal_bonus].ninteger; - else m += (bonus[nlocal_bonus].ninteger+1)/2; - memcpy(bonus[nlocal_bonus].dvalue,&buf[m], - bonus[nlocal_bonus].ndouble*sizeof(double)); + bonus[nlocal_bonus].ivalue = icp->get(bonus[nlocal_bonus].ninteger, bonus[nlocal_bonus].iindex); + bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble, bonus[nlocal_bonus].dindex); + memcpy(bonus[nlocal_bonus].ivalue, &buf[m], bonus[nlocal_bonus].ninteger * sizeof(int)); + if (intdoubleratio == 1) + m += bonus[nlocal_bonus].ninteger; + else + m += (bonus[nlocal_bonus].ninteger + 1) / 2; + memcpy(bonus[nlocal_bonus].dvalue, &buf[m], bonus[nlocal_bonus].ndouble * sizeof(double)); m += bonus[nlocal_bonus].ndouble; bonus[nlocal_bonus].ilocal = ilocal; @@ -416,10 +420,13 @@ int AtomVecBody::size_restart_bonus() for (i = 0; i < nlocal; i++) { if (body[i] >= 0) { n += size_restart_bonus_one; - if (intdoubleratio == 1) n += bonus[body[i]].ninteger; - else n += (bonus[body[i]].ninteger+1)/2; + if (intdoubleratio == 1) + n += bonus[body[i]].ninteger; + else + n += (bonus[body[i]].ninteger + 1) / 2; n += bonus[body[i]].ndouble; - } else n++; + } else + n++; } return n; @@ -435,7 +442,8 @@ int AtomVecBody::pack_restart_bonus(int i, double *buf) { int m = 0; - if (body[i] < 0) buf[m++] = ubuf(0).d; + if (body[i] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; int j = body[i]; @@ -450,10 +458,12 @@ int AtomVecBody::pack_restart_bonus(int i, double *buf) buf[m++] = inertia[2]; buf[m++] = ubuf(bonus[j].ninteger).d; buf[m++] = ubuf(bonus[j].ndouble).d; - memcpy(&buf[m],bonus[j].ivalue,bonus[j].ninteger*sizeof(int)); - if (intdoubleratio == 1) m += bonus[j].ninteger; - else m += (bonus[j].ninteger+1)/2; - memcpy(&buf[m],bonus[j].dvalue,bonus[j].ndouble*sizeof(double)); + memcpy(&buf[m], bonus[j].ivalue, bonus[j].ninteger * sizeof(int)); + if (intdoubleratio == 1) + m += bonus[j].ninteger; + else + m += (bonus[j].ninteger + 1) / 2; + memcpy(&buf[m], bonus[j].dvalue, bonus[j].ndouble * sizeof(double)); m += bonus[j].ndouble; } @@ -469,7 +479,8 @@ int AtomVecBody::unpack_restart_bonus(int ilocal, double *buf) int m = 0; body[ilocal] = (int) ubuf(buf[m++]).i; - if (body[ilocal] == 0) body[ilocal] = -1; + if (body[ilocal] == 0) + body[ilocal] = -1; else { if (nlocal_bonus == nmax_bonus) grow_bonus(); double *quat = bonus[nlocal_bonus].quat; @@ -483,16 +494,14 @@ int AtomVecBody::unpack_restart_bonus(int ilocal, double *buf) inertia[2] = buf[m++]; bonus[nlocal_bonus].ninteger = (int) ubuf(buf[m++]).i; bonus[nlocal_bonus].ndouble = (int) ubuf(buf[m++]).i; - bonus[nlocal_bonus].ivalue = icp->get(bonus[nlocal_bonus].ninteger, - bonus[nlocal_bonus].iindex); - bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble, - bonus[nlocal_bonus].dindex); - memcpy(bonus[nlocal_bonus].ivalue,&buf[m], - bonus[nlocal_bonus].ninteger*sizeof(int)); - if (intdoubleratio == 1) m += bonus[nlocal_bonus].ninteger; - else m += (bonus[nlocal_bonus].ninteger+1)/2; - memcpy(bonus[nlocal_bonus].dvalue,&buf[m], - bonus[nlocal_bonus].ndouble*sizeof(double)); + bonus[nlocal_bonus].ivalue = icp->get(bonus[nlocal_bonus].ninteger, bonus[nlocal_bonus].iindex); + bonus[nlocal_bonus].dvalue = dcp->get(bonus[nlocal_bonus].ndouble, bonus[nlocal_bonus].dindex); + memcpy(bonus[nlocal_bonus].ivalue, &buf[m], bonus[nlocal_bonus].ninteger * sizeof(int)); + if (intdoubleratio == 1) + m += bonus[nlocal_bonus].ninteger; + else + m += (bonus[nlocal_bonus].ninteger + 1) / 2; + memcpy(bonus[nlocal_bonus].dvalue, &buf[m], bonus[nlocal_bonus].ndouble * sizeof(double)); m += bonus[nlocal_bonus].ndouble; bonus[nlocal_bonus].ilocal = ilocal; body[ilocal] = nlocal_bonus++; @@ -521,13 +530,15 @@ void AtomVecBody::create_atom_post(int ilocal) void AtomVecBody::data_atom_post(int ilocal) { body_flag = body[ilocal]; - if (body_flag == 0) body_flag = -1; - else if (body_flag == 1) body_flag = 0; - else error->one(FLERR,"Invalid body flag in Atoms section of data file"); + if (body_flag == 0) + body_flag = -1; + else if (body_flag == 1) + body_flag = 0; + else + error->one(FLERR, "Invalid body flag in Atoms section of data file"); body[ilocal] = body_flag; - if (rmass[ilocal] <= 0.0) - error->one(FLERR,"Invalid density in Atoms section of data file"); + if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file"); radius[ilocal] = 0.5; angmom[ilocal][0] = 0.0; @@ -539,14 +550,12 @@ void AtomVecBody::data_atom_post(int ilocal) unpack one body from Bodies section of data file ------------------------------------------------------------------------- */ -void AtomVecBody::data_body(int m, int ninteger, int ndouble, - int *ivalues, double *dvalues) +void AtomVecBody::data_body(int m, int ninteger, int ndouble, int *ivalues, double *dvalues) { - if (body[m]) - error->one(FLERR,"Assigning body parameters to non-body atom"); + if (body[m]) error->one(FLERR, "Assigning body parameters to non-body atom"); if (nlocal_bonus == nmax_bonus) grow_bonus(); bonus[nlocal_bonus].ilocal = m; - bptr->data_body(nlocal_bonus,ninteger,ndouble,ivalues,dvalues); + bptr->data_body(nlocal_bonus, ninteger, ndouble, ivalues, dvalues); body[m] = nlocal_bonus++; } @@ -557,14 +566,14 @@ void AtomVecBody::data_body(int m, int ninteger, int ndouble, double AtomVecBody::memory_usage_bonus() { double bytes = 0; - bytes += (double)nmax_bonus*sizeof(Bonus); + bytes += (double) nmax_bonus * sizeof(Bonus); bytes += icp->size() + dcp->size(); int nall = nlocal_bonus + nghost_bonus; for (int i = 0; i < nall; i++) { if (body[i] >= 0) { - bytes += (double)bonus[body[i]].ninteger * sizeof(int); - bytes += (double)bonus[body[i]].ndouble * sizeof(double); + bytes += (double) bonus[body[i]].ninteger * sizeof(int); + bytes += (double) bonus[body[i]].ndouble * sizeof(double); } } @@ -579,8 +588,10 @@ void AtomVecBody::pack_data_pre(int ilocal) { body_flag = body[ilocal]; - if (body_flag < 0) body[ilocal] = 0; - else body[ilocal] = 1; + if (body_flag < 0) + body[ilocal] = 0; + else + body[ilocal] = 1; } /* ---------------------------------------------------------------------- @@ -598,7 +609,7 @@ int AtomVecBody::pack_data_bonus(double *buf, int /*flag*/) int m = 0; for (i = 0; i < nlocal; i++) { if (body[i] < 0) continue; - int n = bptr->pack_data_body(tag[i],body[i],buf); + int n = bptr->pack_data_body(tag[i], body[i], buf); m += n; if (buf) buf += n; } @@ -613,9 +624,7 @@ int AtomVecBody::pack_data_bonus(double *buf, int /*flag*/) void AtomVecBody::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/) { int i = 0; - while (i < n) { - i += bptr->write_data_body(fp,&buf[i]); - } + while (i < n) { i += bptr->write_data_body(fp, &buf[i]); } } /* ---------------------------------------------------------------------- @@ -631,10 +640,9 @@ void AtomVecBody::pack_data_post(int ilocal) body computes its size based on ivalues/dvalues and returns it ------------------------------------------------------------------------- */ -double AtomVecBody::radius_body(int ninteger, int ndouble, - int *ivalues, double *dvalues) +double AtomVecBody::radius_body(int ninteger, int ndouble, int *ivalues, double *dvalues) { - return bptr->radius_body(ninteger,ndouble,ivalues,dvalues); + return bptr->radius_body(ninteger, ndouble, ivalues, dvalues); } /* ---------------------------------------------------------------------- @@ -644,10 +652,12 @@ double AtomVecBody::radius_body(int ninteger, int ndouble, void AtomVecBody::set_quat(int m, double *quat_external) { - if (body[m] < 0) error->one(FLERR,"Assigning quat to non-body atom"); + if (body[m] < 0) error->one(FLERR, "Assigning quat to non-body atom"); double *quat = bonus[body[m]].quat; - quat[0] = quat_external[0]; quat[1] = quat_external[1]; - quat[2] = quat_external[2]; quat[3] = quat_external[3]; + quat[0] = quat_external[0]; + quat[1] = quat_external[1]; + quat[2] = quat_external[2]; + quat[3] = quat_external[3]; } /* ---------------------------------------------------------------------- diff --git a/src/atom_vec_charge.cpp b/src/atom_vec_charge.cpp index ca66048558..ce3e91b1f8 100644 --- a/src/atom_vec_charge.cpp +++ b/src/atom_vec_charge.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -31,18 +30,18 @@ AtomVecCharge::AtomVecCharge(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "q"; - fields_copy = (char *) "q"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) ""; - fields_reverse = (char *) ""; - fields_border = (char *) "q"; - fields_border_vel = (char *) "q"; - fields_exchange = (char *) "q"; - fields_restart = (char *) "q"; - fields_create = (char *) "q"; - fields_data_atom = (char *) "id type q x"; - fields_data_vel = (char *) "id v"; + fields_grow = {"q"}; + fields_copy = {"q"}; + fields_comm = {}; + fields_comm_vel = {}; + fields_reverse = {}; + fields_border = {"q"}; + fields_border_vel = {"q"}; + fields_exchange = {"q"}; + fields_restart = {"q"}; + fields_create = {"q"}; + fields_data_atom = {"id", "type", "q", "x"}; + fields_data_vel = {"id", "v"}; setup_fields(); } diff --git a/src/atom_vec_ellipsoid.cpp b/src/atom_vec_ellipsoid.cpp index 6c39e4cfaf..ac1b345308 100644 --- a/src/atom_vec_ellipsoid.cpp +++ b/src/atom_vec_ellipsoid.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -26,10 +25,8 @@ #include "memory.h" #include "modify.h" -#include - using namespace LAMMPS_NS; -using namespace MathConst; +using MathConst::MY_PI; /* ---------------------------------------------------------------------- */ @@ -54,18 +51,18 @@ AtomVecEllipsoid::AtomVecEllipsoid(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "rmass angmom torque ellipsoid"; - fields_copy = (char *) "rmass angmom"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) "angmom"; - fields_reverse = (char *) "torque"; - fields_border = (char *) "rmass"; - fields_border_vel = (char *) "rmass angmom"; - fields_exchange = (char *) "rmass angmom"; - fields_restart = (char *) "rmass angmom"; - fields_create = (char *) "rmass angmom ellipsoid"; - fields_data_atom = (char *) "id type ellipsoid rmass x"; - fields_data_vel = (char *) "id v angmom"; + fields_grow = {"rmass", "angmom", "torque", "ellipsoid"}; + fields_copy = {"rmass", "angmom"}; + fields_comm = {}; + fields_comm_vel = {"angmom"}; + fields_reverse = {"torque"}; + fields_border = {"rmass"}; + fields_border_vel = {"rmass", "angmom"}; + fields_exchange = {"rmass", "angmom"}; + fields_restart = {"rmass", "angmom"}; + fields_create = {"rmass", "angmom", "ellipsoid"}; + fields_data_atom = {"id", "type", "ellipsoid", "rmass", "x"}; + fields_data_vel = {"id", "v", "angmom"}; setup_fields(); } @@ -96,11 +93,9 @@ void AtomVecEllipsoid::grow_pointers() void AtomVecEllipsoid::grow_bonus() { nmax_bonus = grow_nmax_bonus(nmax_bonus); - if (nmax_bonus < 0) - error->one(FLERR,"Per-processor system is too big"); + if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big"); - bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus), - "atom:bonus"); + bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom:bonus"); } /* ---------------------------------------------------------------------- @@ -112,7 +107,7 @@ void AtomVecEllipsoid::copy_bonus(int i, int j, int delflag) // if deleting atom J via delflag and J has bonus data, then delete it if (delflag && ellipsoid[j] >= 0) { - copy_bonus_all(nlocal_bonus-1,ellipsoid[j]); + copy_bonus_all(nlocal_bonus - 1, ellipsoid[j]); nlocal_bonus--; } @@ -131,7 +126,7 @@ void AtomVecEllipsoid::copy_bonus(int i, int j, int delflag) void AtomVecEllipsoid::copy_bonus_all(int i, int j) { ellipsoid[bonus[i].ilocal] = j; - memcpy(&bonus[j],&bonus[i],sizeof(Bonus)); + memcpy(&bonus[j], &bonus[i], sizeof(Bonus)); } /* ---------------------------------------------------------------------- @@ -152,7 +147,7 @@ void AtomVecEllipsoid::clear_bonus() int AtomVecEllipsoid::pack_comm_bonus(int n, int *list, double *buf) { - int i,j,m; + int i, j, m; double *quat; m = 0; @@ -174,7 +169,7 @@ int AtomVecEllipsoid::pack_comm_bonus(int n, int *list, double *buf) void AtomVecEllipsoid::unpack_comm_bonus(int n, int first, double *buf) { - int i,m,last; + int i, m, last; double *quat; m = 0; @@ -194,13 +189,14 @@ void AtomVecEllipsoid::unpack_comm_bonus(int n, int first, double *buf) int AtomVecEllipsoid::pack_border_bonus(int n, int *list, double *buf) { - int i,j,m; - double *shape,*quat; + int i, j, m; + double *shape, *quat; m = 0; for (i = 0; i < n; i++) { j = list[i]; - if (ellipsoid[j] < 0) buf[m++] = ubuf(0).d; + if (ellipsoid[j] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; shape = bonus[ellipsoid[j]].shape; @@ -222,14 +218,15 @@ int AtomVecEllipsoid::pack_border_bonus(int n, int *list, double *buf) int AtomVecEllipsoid::unpack_border_bonus(int n, int first, double *buf) { - int i,j,m,last; - double *shape,*quat; + int i, j, m, last; + double *shape, *quat; m = 0; last = first + n; for (i = first; i < last; i++) { ellipsoid[i] = (int) ubuf(buf[m++]).i; - if (ellipsoid[i] == 0) ellipsoid[i] = -1; + if (ellipsoid[i] == 0) + ellipsoid[i] = -1; else { j = nlocal_bonus + nghost_bonus; if (j == nmax_bonus) grow_bonus(); @@ -260,7 +257,8 @@ int AtomVecEllipsoid::pack_exchange_bonus(int i, double *buf) { int m = 0; - if (ellipsoid[i] < 0) buf[m++] = ubuf(0).d; + if (ellipsoid[i] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; int j = ellipsoid[i]; @@ -285,7 +283,8 @@ int AtomVecEllipsoid::unpack_exchange_bonus(int ilocal, double *buf) int m = 0; ellipsoid[ilocal] = (int) ubuf(buf[m++]).i; - if (ellipsoid[ilocal] == 0) ellipsoid[ilocal] = -1; + if (ellipsoid[ilocal] == 0) + ellipsoid[ilocal] = -1; else { if (nlocal_bonus == nmax_bonus) grow_bonus(); double *shape = bonus[nlocal_bonus].shape; @@ -316,8 +315,10 @@ int AtomVecEllipsoid::size_restart_bonus() int n = 0; int nlocal = atom->nlocal; for (i = 0; i < nlocal; i++) { - if (ellipsoid[i] >= 0) n += size_restart_bonus_one; - else n++; + if (ellipsoid[i] >= 0) + n += size_restart_bonus_one; + else + n++; } return n; @@ -333,7 +334,8 @@ int AtomVecEllipsoid::pack_restart_bonus(int i, double *buf) { int m = 0; - if (ellipsoid[i] < 0) buf[m++] = ubuf(0).d; + if (ellipsoid[i] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; int j = ellipsoid[i]; @@ -358,7 +360,8 @@ int AtomVecEllipsoid::unpack_restart_bonus(int ilocal, double *buf) int m = 0; ellipsoid[ilocal] = (int) ubuf(buf[m++]).i; - if (ellipsoid[ilocal] == 0) ellipsoid[ilocal] = -1; + if (ellipsoid[ilocal] == 0) + ellipsoid[ilocal] = -1; else { if (nlocal_bonus == nmax_bonus) grow_bonus(); double *shape = bonus[nlocal_bonus].shape; @@ -381,32 +384,31 @@ int AtomVecEllipsoid::unpack_restart_bonus(int ilocal, double *buf) unpack one line from Ellipsoids section of data file ------------------------------------------------------------------------- */ -void AtomVecEllipsoid::data_atom_bonus(int m, const std::vector & values) +void AtomVecEllipsoid::data_atom_bonus(int m, const std::vector &values) { - if (ellipsoid[m]) - error->one(FLERR,"Assigning ellipsoid parameters to non-ellipsoid atom"); + if (ellipsoid[m]) error->one(FLERR, "Assigning ellipsoid parameters to non-ellipsoid atom"); if (nlocal_bonus == nmax_bonus) grow_bonus(); double *shape = bonus[nlocal_bonus].shape; int ivalue = 1; - shape[0] = 0.5 * utils::numeric(FLERR,values[ivalue++],true,lmp); - shape[1] = 0.5 * utils::numeric(FLERR,values[ivalue++],true,lmp); - shape[2] = 0.5 * utils::numeric(FLERR,values[ivalue++],true,lmp); + shape[0] = 0.5 * utils::numeric(FLERR, values[ivalue++], true, lmp); + shape[1] = 0.5 * utils::numeric(FLERR, values[ivalue++], true, lmp); + shape[2] = 0.5 * utils::numeric(FLERR, values[ivalue++], true, lmp); if (shape[0] <= 0.0 || shape[1] <= 0.0 || shape[2] <= 0.0) - error->one(FLERR,"Invalid shape in Ellipsoids section of data file"); + error->one(FLERR, "Invalid shape in Ellipsoids section of data file"); double *quat = bonus[nlocal_bonus].quat; - quat[0] = utils::numeric(FLERR,values[ivalue++],true,lmp); - quat[1] = utils::numeric(FLERR,values[ivalue++],true,lmp); - quat[2] = utils::numeric(FLERR,values[ivalue++],true,lmp); - quat[3] = utils::numeric(FLERR,values[ivalue++],true,lmp); + quat[0] = utils::numeric(FLERR, values[ivalue++], true, lmp); + quat[1] = utils::numeric(FLERR, values[ivalue++], true, lmp); + quat[2] = utils::numeric(FLERR, values[ivalue++], true, lmp); + quat[3] = utils::numeric(FLERR, values[ivalue++], true, lmp); MathExtra::qnormalize(quat); // reset ellipsoid mass // previously stored density in rmass - rmass[m] *= 4.0*MY_PI/3.0 * shape[0]*shape[1]*shape[2]; + rmass[m] *= 4.0 * MY_PI / 3.0 * shape[0] * shape[1] * shape[2]; bonus[nlocal_bonus].ilocal = m; ellipsoid[m] = nlocal_bonus++; @@ -419,7 +421,7 @@ void AtomVecEllipsoid::data_atom_bonus(int m, const std::vector & v double AtomVecEllipsoid::memory_usage_bonus() { double bytes = 0; - bytes += nmax_bonus*sizeof(Bonus); + bytes += nmax_bonus * sizeof(Bonus); return bytes; } @@ -441,13 +443,15 @@ void AtomVecEllipsoid::create_atom_post(int ilocal) void AtomVecEllipsoid::data_atom_post(int ilocal) { ellipsoid_flag = ellipsoid[ilocal]; - if (ellipsoid_flag == 0) ellipsoid_flag = -1; - else if (ellipsoid_flag == 1) ellipsoid_flag = 0; - else error->one(FLERR,"Invalid ellipsoid flag in Atoms section of data file"); + if (ellipsoid_flag == 0) + ellipsoid_flag = -1; + else if (ellipsoid_flag == 1) + ellipsoid_flag = 0; + else + error->one(FLERR, "Invalid ellipsoid flag in Atoms section of data file"); ellipsoid[ilocal] = ellipsoid_flag; - if (rmass[ilocal] <= 0.0) - error->one(FLERR,"Invalid density in Atoms section of data file"); + if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file"); angmom[ilocal][0] = 0.0; angmom[ilocal][1] = 0.0; @@ -465,12 +469,14 @@ void AtomVecEllipsoid::pack_data_pre(int ilocal) ellipsoid_flag = atom->ellipsoid[ilocal]; rmass_one = atom->rmass[ilocal]; - if (ellipsoid_flag < 0) ellipsoid[ilocal] = 0; - else ellipsoid[ilocal] = 1; + if (ellipsoid_flag < 0) + ellipsoid[ilocal] = 0; + else + ellipsoid[ilocal] = 1; if (ellipsoid_flag >= 0) { shape = bonus[ellipsoid_flag].shape; - rmass[ilocal] /= 4.0*MY_PI/3.0 * shape[0]*shape[1]*shape[2]; + rmass[ilocal] /= 4.0 * MY_PI / 3.0 * shape[0] * shape[1] * shape[2]; } } @@ -491,7 +497,7 @@ void AtomVecEllipsoid::pack_data_post(int ilocal) int AtomVecEllipsoid::pack_data_bonus(double *buf, int /*flag*/) { - int i,j; + int i, j; tagint *tag = atom->tag; int nlocal = atom->nlocal; @@ -502,14 +508,15 @@ int AtomVecEllipsoid::pack_data_bonus(double *buf, int /*flag*/) if (buf) { buf[m++] = ubuf(tag[i]).d; j = ellipsoid[i]; - buf[m++] = 2.0*bonus[j].shape[0]; - buf[m++] = 2.0*bonus[j].shape[1]; - buf[m++] = 2.0*bonus[j].shape[2]; + buf[m++] = 2.0 * bonus[j].shape[0]; + buf[m++] = 2.0 * bonus[j].shape[1]; + buf[m++] = 2.0 * bonus[j].shape[2]; buf[m++] = bonus[j].quat[0]; buf[m++] = bonus[j].quat[1]; buf[m++] = bonus[j].quat[2]; buf[m++] = bonus[j].quat[3]; - } else m += size_data_bonus; + } else + m += size_data_bonus; } return m; @@ -523,8 +530,8 @@ void AtomVecEllipsoid::write_data_bonus(FILE *fp, int n, double *buf, int /*flag { int i = 0; while (i < n) { - fmt::print(fp,"{} {} {} {} {} {} {} {}\n",ubuf(buf[i]).i, - buf[i+1],buf[i+2],buf[i+3],buf[i+4],buf[i+5],buf[i+6],buf[i+7]); + fmt::print(fp, "{} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3], + buf[i + 4], buf[i + 5], buf[i + 6], buf[i + 7]); i += size_data_bonus; } } @@ -552,7 +559,7 @@ void AtomVecEllipsoid::set_shape(int i, double shapex, double shapey, double sha bonus[nlocal_bonus].ilocal = i; ellipsoid[i] = nlocal_bonus++; } else if (shapex == 0.0 && shapey == 0.0 && shapez == 0.0) { - copy_bonus_all(nlocal_bonus-1,ellipsoid[i]); + copy_bonus_all(nlocal_bonus - 1, ellipsoid[i]); nlocal_bonus--; ellipsoid[i] = -1; } else { diff --git a/src/atom_vec_hybrid.cpp b/src/atom_vec_hybrid.cpp index dd83619da8..0d24486c86 100644 --- a/src/atom_vec_hybrid.cpp +++ b/src/atom_vec_hybrid.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -19,12 +18,12 @@ #include "error.h" #include "tokenizer.h" +#include #include using namespace LAMMPS_NS; -#define NFIELDSTRINGS 12 // # of field strings -enum{ELLIPSOID,LINE,TRIANGLE,BODY}; // also in WriteData +enum { ELLIPSOID, LINE, TRIANGLE, BODY }; // also in WriteData /* ---------------------------------------------------------------------- */ @@ -33,22 +32,16 @@ AtomVecHybrid::AtomVecHybrid(LAMMPS *lmp) : AtomVec(lmp) nstyles = 0; styles = nullptr; keywords = nullptr; - fieldstrings = nullptr; bonus_flag = 0; nstyles_bonus = 0; styles_bonus = nullptr; - // these strings will be concatenated from sub-style strings + // field strings will be concatenated from sub-style strings // fields_data_atom & fields_data_vel start with fields common to all styles - fields_grow = fields_copy = fields_comm = fields_comm_vel = (char *) ""; - fields_reverse = fields_border = fields_border_vel = (char *) ""; - fields_exchange = fields_restart = fields_create = (char *) ""; - fields_data_atom = (char *) "id type x"; - fields_data_vel = (char *) "id v"; - - fields_allocated = 0; + fields_data_atom = {"id", "type", "x"}; + fields_data_vel = {"id", "v"}; } /* ---------------------------------------------------------------------- */ @@ -56,28 +49,10 @@ AtomVecHybrid::AtomVecHybrid(LAMMPS *lmp) : AtomVec(lmp) AtomVecHybrid::~AtomVecHybrid() { for (int k = 0; k < nstyles; k++) delete styles[k]; - delete [] styles; - for (int k = 0; k < nstyles; k++) delete [] keywords[k]; - delete [] keywords; - delete [] styles_bonus; - - if (!fields_allocated) return; - - delete [] fields_grow; - delete [] fields_copy; - delete [] fields_comm; - delete [] fields_comm_vel; - delete [] fields_reverse; - delete [] fields_border; - delete [] fields_border_vel; - delete [] fields_exchange; - delete [] fields_restart; - delete [] fields_create; - delete [] fields_data_atom; - delete [] fields_data_vel; - - for (int k = 0; k < nstyles; k++) delete [] fieldstrings[k].fstr; - delete [] fieldstrings; + delete[] styles; + for (int k = 0; k < nstyles; k++) delete[] keywords[k]; + delete[] keywords; + delete[] styles_bonus; } /* ---------------------------------------------------------------------- @@ -92,28 +67,27 @@ void AtomVecHybrid::process_args(int narg, char **arg) // allocate list of sub-styles as big as possibly needed if no extra args - styles = new AtomVec*[narg]; - keywords = new char*[narg]; + styles = new AtomVec *[narg]; + keywords = new char *[narg]; // allocate each sub-style // call process_args() with set of args that are not atom style names // use known_style() to determine which args these are - int i,k,jarg,dummy; - + int dummy; int iarg = 0; nstyles = 0; while (iarg < narg) { - if (strcmp(arg[iarg],"hybrid") == 0) - error->all(FLERR,"Atom style hybrid cannot have hybrid as an argument"); - for (i = 0; i < nstyles; i++) - if (strcmp(arg[iarg],keywords[i]) == 0) - error->all(FLERR,"Atom style hybrid cannot use same atom style twice"); - styles[nstyles] = atom->new_avec(arg[iarg],1,dummy); + if (strcmp(arg[iarg], "hybrid") == 0) + error->all(FLERR, "Atom style hybrid cannot have hybrid as an argument"); + for (int i = 0; i < nstyles; i++) + if (strcmp(arg[iarg], keywords[i]) == 0) + error->all(FLERR, "Atom style hybrid cannot use same atom style twice"); + styles[nstyles] = atom->new_avec(arg[iarg], 1, dummy); keywords[nstyles] = utils::strdup(arg[iarg]); - jarg = iarg + 1; + int jarg = iarg + 1; while (jarg < narg && !known_style(arg[jarg])) jarg++; - styles[nstyles]->process_args(jarg-iarg-1,&arg[iarg+1]); + styles[nstyles]->process_args(jarg - iarg - 1, &arg[iarg + 1]); iarg = jarg; nstyles++; } @@ -124,20 +98,19 @@ void AtomVecHybrid::process_args(int narg, char **arg) molecular = Atom::ATOMIC; maxexchange = 0; - for (k = 0; k < nstyles; k++) { + for (int k = 0; k < nstyles; k++) { if ((styles[k]->molecular == Atom::MOLECULAR && molecular == Atom::TEMPLATE) || (styles[k]->molecular == Atom::TEMPLATE && molecular == Atom::MOLECULAR)) - error->all(FLERR, - "Cannot mix molecular and molecule template atom styles"); - molecular = MAX(molecular,styles[k]->molecular); + error->all(FLERR, "Cannot mix molecular and molecule template atom styles"); + molecular = MAX(molecular, styles[k]->molecular); - bonds_allow = MAX(bonds_allow,styles[k]->bonds_allow); - angles_allow = MAX(angles_allow,styles[k]->angles_allow); - dihedrals_allow = MAX(dihedrals_allow,styles[k]->dihedrals_allow); - impropers_allow = MAX(impropers_allow,styles[k]->impropers_allow); - mass_type = MAX(mass_type,styles[k]->mass_type); - dipole_type = MAX(dipole_type,styles[k]->dipole_type); - forceclearflag = MAX(forceclearflag,styles[k]->forceclearflag); + bonds_allow = MAX(bonds_allow, styles[k]->bonds_allow); + angles_allow = MAX(angles_allow, styles[k]->angles_allow); + dihedrals_allow = MAX(dihedrals_allow, styles[k]->dihedrals_allow); + impropers_allow = MAX(impropers_allow, styles[k]->impropers_allow); + mass_type = MAX(mass_type, styles[k]->mass_type); + dipole_type = MAX(dipole_type, styles[k]->dipole_type); + forceclearflag = MAX(forceclearflag, styles[k]->forceclearflag); maxexchange += styles[k]->maxexchange; if (styles[k]->molecular == Atom::TEMPLATE) onemols = styles[k]->onemols; @@ -148,95 +121,71 @@ void AtomVecHybrid::process_args(int narg, char **arg) int mass_pertype = 0; int mass_peratom = 0; - for (k = 0; k < nstyles; k++) { + for (int k = 0; k < nstyles; k++) { if (styles[k]->mass_type == 0) mass_peratom = 1; if (styles[k]->mass_type == 1) mass_pertype = 1; } if (mass_pertype && mass_peratom && comm->me == 0) - error->warning(FLERR, "Atom style hybrid defines both, per-type " + error->warning(FLERR, + "Atom style hybrid defines both, per-type " "and per-atom masses; both must be set, but only " "per-atom masses will be used"); // free allstyles created by build_styles() - for (i = 0; i < nallstyles; i++) delete [] allstyles[i]; - delete [] allstyles; - - // set field strings from all substyles - - fieldstrings = new FieldStrings[nstyles]; - - for (k = 0; k < nstyles; k++) { - fieldstrings[k].fstr = new char*[NFIELDSTRINGS]; - fieldstrings[k].fstr[0] = styles[k]->fields_grow; - fieldstrings[k].fstr[1] = styles[k]->fields_copy; - fieldstrings[k].fstr[2] = styles[k]->fields_comm; - fieldstrings[k].fstr[3] = styles[k]->fields_comm_vel; - fieldstrings[k].fstr[4] = styles[k]->fields_reverse; - fieldstrings[k].fstr[5] = styles[k]->fields_border; - fieldstrings[k].fstr[6] = styles[k]->fields_border_vel; - fieldstrings[k].fstr[7] = styles[k]->fields_exchange; - fieldstrings[k].fstr[8] = styles[k]->fields_restart; - fieldstrings[k].fstr[9] = styles[k]->fields_create; - fieldstrings[k].fstr[10] = styles[k]->fields_data_atom; - fieldstrings[k].fstr[11] = styles[k]->fields_data_vel; - } + for (int i = 0; i < nallstyles; i++) delete[] allstyles[i]; + delete[] allstyles; // merge field strings from all sub-styles // save concat_grow to check for duplicates of special-case fields - char *concat_grow;; - char *dummyptr = nullptr; + std::vector concat_grow; + std::vector concat_dummy; - fields_grow = merge_fields(0,fields_grow,1,concat_grow); - fields_copy = merge_fields(1,fields_copy,0,dummyptr); - fields_comm = merge_fields(2,fields_comm,0,dummyptr); - fields_comm_vel = merge_fields(3,fields_comm_vel,0,dummyptr); - fields_reverse = merge_fields(4,fields_reverse,0,dummyptr); - fields_border = merge_fields(5,fields_border,0,dummyptr); - fields_border_vel = merge_fields(6,fields_border_vel,0,dummyptr); - fields_exchange = merge_fields(7,fields_exchange,0,dummyptr); - fields_restart = merge_fields(8,fields_restart,0,dummyptr); - fields_create = merge_fields(9,fields_create,0,dummyptr); - fields_data_atom = merge_fields(10,fields_data_atom,0,dummyptr); - fields_data_vel = merge_fields(11,fields_data_vel,0,dummyptr); - - fields_allocated = 1; + for (int k = 0; k < nstyles; k++) { + merge_fields(fields_grow, styles[k]->fields_grow, 1, concat_grow); + merge_fields(fields_copy, styles[k]->fields_copy, 0, concat_dummy); + merge_fields(fields_comm, styles[k]->fields_comm, 0, concat_dummy); + merge_fields(fields_comm_vel, styles[k]->fields_comm_vel, 0, concat_dummy); + merge_fields(fields_reverse, styles[k]->fields_reverse, 0, concat_dummy); + merge_fields(fields_border, styles[k]->fields_border, 0, concat_dummy); + merge_fields(fields_border_vel, styles[k]->fields_border_vel, 0, concat_dummy); + merge_fields(fields_exchange, styles[k]->fields_exchange, 0, concat_dummy); + merge_fields(fields_restart, styles[k]->fields_restart, 0, concat_dummy); + merge_fields(fields_create, styles[k]->fields_create, 0, concat_dummy); + merge_fields(fields_data_atom, styles[k]->fields_data_atom, 0, concat_dummy); + merge_fields(fields_data_vel, styles[k]->fields_data_vel, 0, concat_dummy); + } // check concat_grow for multiple special-case fields // may cause issues with style-specific create_atom() and data_atom() methods // issue warnings if appear in multiple sub-styles - const char *dupfield[] = {"radius","rmass"}; - int ndupfield = 2; - char *ptr; + std::vector dupfield = {"radius", "rmass"}; - for (int idup = 0; idup < ndupfield; idup++) { - auto dup = (char *) dupfield[idup]; - ptr = strstr(concat_grow,dup); - if ((ptr && strstr(ptr+1,dup)) && (comm->me == 0)) - error->warning(FLERR,fmt::format("Per-atom {} is used in multiple sub-" - "styles; must be used consistently",dup)); + for (const auto &idup : dupfield) { + if ((comm->me == 0) && (std::count(concat_grow.begin(), concat_grow.end(), idup) > 1)) + error->warning(FLERR, + "Per-atom field {} is used in multiple sub-styles; must be used consistently", + idup); } - delete [] concat_grow; - // set bonus_flag if any substyle has bonus data // set nstyles_bonus & styles_bonus // sum two sizes over contributions from each substyle with bonus data. nstyles_bonus = 0; - for (k = 0; k < nstyles; k++) + for (int k = 0; k < nstyles; k++) if (styles[k]->bonus_flag) nstyles_bonus++; if (nstyles_bonus) { bonus_flag = 1; - styles_bonus = new AtomVec*[nstyles_bonus]; + styles_bonus = new AtomVec *[nstyles_bonus]; nstyles_bonus = 0; size_forward_bonus = 0; size_border_bonus = 0; - for (k = 0; k < nstyles; k++) { + for (int k = 0; k < nstyles; k++) { if (styles[k]->bonus_flag) { styles_bonus[nstyles_bonus++] = styles[k]; size_forward_bonus += styles[k]->size_forward_bonus; @@ -270,23 +219,21 @@ void AtomVecHybrid::grow_pointers() void AtomVecHybrid::force_clear(int n, size_t nbytes) { for (int k = 0; k < nstyles; k++) - if (styles[k]->forceclearflag) styles[k]->force_clear(n,nbytes); + if (styles[k]->forceclearflag) styles[k]->force_clear(n, nbytes); } /* ---------------------------------------------------------------------- */ void AtomVecHybrid::copy_bonus(int i, int j, int delflag) { - for (int k = 0; k < nstyles_bonus; k++) - styles_bonus[k]->copy_bonus(i,j,delflag); + for (int k = 0; k < nstyles_bonus; k++) styles_bonus[k]->copy_bonus(i, j, delflag); } /* ---------------------------------------------------------------------- */ void AtomVecHybrid::clear_bonus() { - for (int k = 0; k < nstyles_bonus; k++) - styles_bonus[k]->clear_bonus(); + for (int k = 0; k < nstyles_bonus; k++) styles_bonus[k]->clear_bonus(); } /* ---------------------------------------------------------------------- */ @@ -294,8 +241,7 @@ void AtomVecHybrid::clear_bonus() int AtomVecHybrid::pack_comm_bonus(int n, int *list, double *buf) { int m = 0; - for (int k = 0; k < nstyles_bonus; k++) - m += styles_bonus[k]->pack_comm_bonus(n,list,buf); + for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_comm_bonus(n, list, buf); return m; } @@ -303,8 +249,7 @@ int AtomVecHybrid::pack_comm_bonus(int n, int *list, double *buf) void AtomVecHybrid::unpack_comm_bonus(int n, int first, double *buf) { - for (int k = 0; k < nstyles_bonus; k++) - styles_bonus[k]->unpack_comm_bonus(n,first,buf); + for (int k = 0; k < nstyles_bonus; k++) styles_bonus[k]->unpack_comm_bonus(n, first, buf); } /* ---------------------------------------------------------------------- */ @@ -312,8 +257,7 @@ void AtomVecHybrid::unpack_comm_bonus(int n, int first, double *buf) int AtomVecHybrid::pack_border_bonus(int n, int *list, double *buf) { int m = 0; - for (int k = 0; k < nstyles_bonus; k++) - m += styles_bonus[k]->pack_border_bonus(n,list,buf); + for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_border_bonus(n, list, buf); return m; } @@ -322,8 +266,7 @@ int AtomVecHybrid::pack_border_bonus(int n, int *list, double *buf) int AtomVecHybrid::unpack_border_bonus(int n, int first, double *buf) { int m = 0; - for (int k = 0; k < nstyles_bonus; k++) - m += styles_bonus[k]->unpack_border_bonus(n,first,buf); + for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->unpack_border_bonus(n, first, buf); return m; } @@ -332,8 +275,7 @@ int AtomVecHybrid::unpack_border_bonus(int n, int first, double *buf) int AtomVecHybrid::pack_exchange_bonus(int i, double *buf) { int m = 0; - for (int k = 0; k < nstyles_bonus; k++) - m += styles_bonus[k]->pack_exchange_bonus(i,buf); + for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_exchange_bonus(i, buf); return m; } @@ -342,8 +284,7 @@ int AtomVecHybrid::pack_exchange_bonus(int i, double *buf) int AtomVecHybrid::unpack_exchange_bonus(int ilocal, double *buf) { int m = 0; - for (int k = 0; k < nstyles_bonus; k++) - m += styles_bonus[k]->unpack_exchange_bonus(ilocal,buf); + for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->unpack_exchange_bonus(ilocal, buf); return m; } @@ -352,8 +293,7 @@ int AtomVecHybrid::unpack_exchange_bonus(int ilocal, double *buf) int AtomVecHybrid::size_restart_bonus() { int n = 0; - for (int k = 0; k < nstyles_bonus; k++) - n += styles_bonus[k]->size_restart_bonus(); + for (int k = 0; k < nstyles_bonus; k++) n += styles_bonus[k]->size_restart_bonus(); return n; } @@ -362,8 +302,7 @@ int AtomVecHybrid::size_restart_bonus() int AtomVecHybrid::pack_restart_bonus(int i, double *buf) { int m = 0; - for (int k = 0; k < nstyles_bonus; k++) - m += styles_bonus[k]->pack_restart_bonus(i,buf); + for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->pack_restart_bonus(i, buf); return m; } @@ -372,8 +311,7 @@ int AtomVecHybrid::pack_restart_bonus(int i, double *buf) int AtomVecHybrid::unpack_restart_bonus(int ilocal, double *buf) { int m = 0; - for (int k = 0; k < nstyles_bonus; k++) - m += styles_bonus[k]->unpack_restart_bonus(ilocal,buf); + for (int k = 0; k < nstyles_bonus; k++) m += styles_bonus[k]->unpack_restart_bonus(ilocal, buf); return m; } @@ -382,8 +320,7 @@ int AtomVecHybrid::unpack_restart_bonus(int ilocal, double *buf) double AtomVecHybrid::memory_usage_bonus() { double bytes = 0; - for (int k = 0; k < nstyles_bonus; k++) - bytes += styles_bonus[k]->memory_usage_bonus(); + for (int k = 0; k < nstyles_bonus; k++) bytes += styles_bonus[k]->memory_usage_bonus(); return bytes; } @@ -393,8 +330,7 @@ double AtomVecHybrid::memory_usage_bonus() void AtomVecHybrid::pack_restart_pre(int ilocal) { - for (int k = 0; k < nstyles; k++) - styles[k]->pack_restart_pre(ilocal); + for (int k = 0; k < nstyles; k++) styles[k]->pack_restart_pre(ilocal); } /* ---------------------------------------------------------------------- @@ -403,8 +339,7 @@ void AtomVecHybrid::pack_restart_pre(int ilocal) void AtomVecHybrid::pack_restart_post(int ilocal) { - for (int k = 0; k < nstyles; k++) - styles[k]->pack_restart_post(ilocal); + for (int k = 0; k < nstyles; k++) styles[k]->pack_restart_post(ilocal); } /* ---------------------------------------------------------------------- @@ -413,8 +348,7 @@ void AtomVecHybrid::pack_restart_post(int ilocal) void AtomVecHybrid::unpack_restart_init(int ilocal) { - for (int k = 0; k < nstyles; k++) - styles[k]->unpack_restart_init(ilocal); + for (int k = 0; k < nstyles; k++) styles[k]->unpack_restart_init(ilocal); } /* ---------------------------------------------------------------------- @@ -423,8 +357,7 @@ void AtomVecHybrid::unpack_restart_init(int ilocal) void AtomVecHybrid::create_atom_post(int ilocal) { - for (int k = 0; k < nstyles; k++) - styles[k]->create_atom_post(ilocal); + for (int k = 0; k < nstyles; k++) styles[k]->create_atom_post(ilocal); } /* ---------------------------------------------------------------------- @@ -434,16 +367,15 @@ void AtomVecHybrid::create_atom_post(int ilocal) void AtomVecHybrid::data_atom_post(int ilocal) { - for (int k = 0; k < nstyles; k++) - styles[k]->data_atom_post(ilocal); + for (int k = 0; k < nstyles; k++) styles[k]->data_atom_post(ilocal); } /* ---------------------------------------------------------------------- modify what AtomVec::data_bonds() just unpacked or initialize other bond quantities ------------------------------------------------------------------------- */ -void AtomVecHybrid::data_bonds_post(int m, int num_bond, tagint atom1, - tagint atom2, tagint id_offset) +void AtomVecHybrid::data_bonds_post(int m, int num_bond, tagint atom1, tagint atom2, + tagint id_offset) { for (int k = 0; k < nstyles; k++) styles[k]->data_bonds_post(m, num_bond, atom1, atom2, id_offset); @@ -455,8 +387,7 @@ void AtomVecHybrid::data_bonds_post(int m, int num_bond, tagint atom1, void AtomVecHybrid::pack_data_pre(int ilocal) { - for (int k = 0; k < nstyles; k++) - styles[k]->pack_data_pre(ilocal); + for (int k = 0; k < nstyles; k++) styles[k]->pack_data_pre(ilocal); } /* ---------------------------------------------------------------------- @@ -465,8 +396,7 @@ void AtomVecHybrid::pack_data_pre(int ilocal) void AtomVecHybrid::pack_data_post(int ilocal) { - for (int k = 0; k < nstyles; k++) - styles[k]->pack_data_post(ilocal); + for (int k = 0; k < nstyles; k++) styles[k]->pack_data_post(ilocal); } /* ---------------------------------------------------------------------- @@ -476,12 +406,12 @@ void AtomVecHybrid::pack_data_post(int ilocal) int AtomVecHybrid::pack_data_bonus(double *buf, int flag) { for (int k = 0; k < nstyles; k++) { - if (flag == ELLIPSOID && strcmp(keywords[k],"ellipsoid") != 0) continue; - if (flag == LINE && strcmp(keywords[k],"line") != 0) continue; - if (flag == TRIANGLE && strcmp(keywords[k],"tri") != 0) continue; - if (flag == BODY && strcmp(keywords[k],"body") != 0) continue; + if (flag == ELLIPSOID && strcmp(keywords[k], "ellipsoid") != 0) continue; + if (flag == LINE && strcmp(keywords[k], "line") != 0) continue; + if (flag == TRIANGLE && strcmp(keywords[k], "tri") != 0) continue; + if (flag == BODY && strcmp(keywords[k], "body") != 0) continue; - return styles[k]->pack_data_bonus(buf,flag); + return styles[k]->pack_data_bonus(buf, flag); } return 0; } @@ -493,12 +423,12 @@ int AtomVecHybrid::pack_data_bonus(double *buf, int flag) void AtomVecHybrid::write_data_bonus(FILE *fp, int n, double *buf, int flag) { for (int k = 0; k < nstyles; k++) { - if (flag == ELLIPSOID && strcmp(keywords[k],"ellipsoid") != 0) continue; - if (flag == LINE && strcmp(keywords[k],"line") != 0) continue; - if (flag == TRIANGLE && strcmp(keywords[k],"tri") != 0) continue; - if (flag == BODY && strcmp(keywords[k],"body") != 0) continue; + if (flag == ELLIPSOID && strcmp(keywords[k], "ellipsoid") != 0) continue; + if (flag == LINE && strcmp(keywords[k], "line") != 0) continue; + if (flag == TRIANGLE && strcmp(keywords[k], "tri") != 0) continue; + if (flag == BODY && strcmp(keywords[k], "body") != 0) continue; - styles[k]->write_data_bonus(fp,n,buf,flag); + styles[k]->write_data_bonus(fp, n, buf, flag); } } @@ -508,11 +438,11 @@ void AtomVecHybrid::write_data_bonus(FILE *fp, int n, double *buf, int flag) return -1 if name is unknown to any sub-styles ------------------------------------------------------------------------- */ -int AtomVecHybrid::property_atom(char *name) +int AtomVecHybrid::property_atom(const std::string &name) { for (int k = 0; k < nstyles; k++) { int index = styles[k]->property_atom(name); - if (index >= 0) return index*nstyles + k; + if (index >= 0) return index * nstyles + k; } return -1; } @@ -522,12 +452,11 @@ int AtomVecHybrid::property_atom(char *name) index maps to data specific to this atom style ------------------------------------------------------------------------- */ -void AtomVecHybrid::pack_property_atom(int multiindex, double *buf, - int nvalues, int groupbit) +void AtomVecHybrid::pack_property_atom(int multiindex, double *buf, int nvalues, int groupbit) { int k = multiindex % nstyles; - int index = multiindex/nstyles; - styles[k]->pack_property_atom(index,buf,nvalues,groupbit); + int index = multiindex / nstyles; + styles[k]->pack_property_atom(index, buf, nvalues, groupbit); } // ---------------------------------------------------------------------- @@ -535,48 +464,21 @@ void AtomVecHybrid::pack_property_atom(int multiindex, double *buf, // ---------------------------------------------------------------------- /* ---------------------------------------------------------------------- - merge fields and remove duplicate fields - concat = root + Inum fields string from all substyles - return dedup = concat with duplicate fields removed + merge fields into root vector and remove duplicate fields if concat_flag set, also return concat (w/ duplicates) - so caller can check for problematic fields, call will free it + so caller can check for problematic fields ------------------------------------------------------------------------- */ -char *AtomVecHybrid::merge_fields(int inum, char *root, - int concat_flag, char *&concat_str) +void AtomVecHybrid::merge_fields(std::vector &root, + const std::vector &fields, int concat_flag, + std::vector &concat) { - // create vector with all words combined + // grow vector with all words combined with dedup and - std::string concat; - if (root) concat += root; - for (int k = 0; k < nstyles; k++) { - if (concat.size() > 0) concat += " "; - concat += fieldstrings[k].fstr[inum]; + for (const auto &field : fields) { + if (concat_flag) concat.push_back(field); + if (std::find(root.begin(), root.end(), field) == root.end()) root.push_back(field); } - if (concat_flag) concat_str = utils::strdup(concat); - - // remove duplicate words without changing the order - - auto words = Tokenizer(concat, " ").as_vector(); - std::vector 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; #define ATOM_CLASS -#define AtomStyle(key,Class) nallstyles++; -#include "style_atom.h" // IWYU pragma: keep +#define AtomStyle(key, Class) nallstyles++; +#include "style_atom.h" // IWYU pragma: keep #undef AtomStyle #undef ATOM_CLASS - allstyles = new char*[nallstyles]; + allstyles = new char *[nallstyles]; nallstyles = 0; #define ATOM_CLASS -#define AtomStyle(key,Class) \ +#define AtomStyle(key, Class) \ allstyles[nallstyles] = utils::strdup(#key); \ nallstyles++; -#include "style_atom.h" // IWYU pragma: keep +#include "style_atom.h" // IWYU pragma: keep #undef AtomStyle #undef ATOM_CLASS } @@ -611,6 +513,6 @@ void AtomVecHybrid::build_styles() int AtomVecHybrid::known_style(char *str) { for (int i = 0; i < nallstyles; i++) - if (strcmp(str,allstyles[i]) == 0) return 1; + if (strcmp(str, allstyles[i]) == 0) return 1; return 0; } diff --git a/src/atom_vec_hybrid.h b/src/atom_vec_hybrid.h index 8d1a791044..ef5589484f 100644 --- a/src/atom_vec_hybrid.h +++ b/src/atom_vec_hybrid.h @@ -64,23 +64,18 @@ class AtomVecHybrid : public AtomVec { int pack_data_bonus(double *, int) override; void write_data_bonus(FILE *, int, double *, int) override; - int property_atom(char *) override; + int property_atom(const std::string &) override; void pack_property_atom(int, double *, int, int) override; private: int nallstyles; char **allstyles; - int fields_allocated; - - struct FieldStrings { - char **fstr; - }; - FieldStrings *fieldstrings; int nstyles_bonus; class AtomVec **styles_bonus; - char *merge_fields(int, char *, int, char *&); + void merge_fields(std::vector &, const std::vector &, + int, std::vector &); void build_styles(); int known_style(char *); }; diff --git a/src/atom_vec_line.cpp b/src/atom_vec_line.cpp index e15bc61f2f..cd8fa2563b 100644 --- a/src/atom_vec_line.cpp +++ b/src/atom_vec_line.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -23,12 +22,11 @@ #include "modify.h" #include -#include using namespace LAMMPS_NS; -using namespace MathConst; +using MathConst::MY_PI; -#define EPSILON 0.001 +static constexpr double EPSILON = 0.001; /* ---------------------------------------------------------------------- */ @@ -55,18 +53,18 @@ AtomVecLine::AtomVecLine(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "molecule radius rmass omega torque line"; - fields_copy = (char *) "molecule radius rmass omega"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) "omega"; - fields_reverse = (char *) "torque"; - fields_border = (char *) "molecule radius rmass"; - fields_border_vel = (char *) "molecule radius rmass omega"; - fields_exchange = (char *) "molecule radius rmass omega"; - fields_restart = (char *) "molecule radius rmass omega"; - fields_create = (char *) "molecule radius rmass omega line"; - fields_data_atom = (char *) "id molecule type line rmass x"; - fields_data_vel = (char *) "id v omega"; + fields_grow = {"molecule", "radius", "rmass", "omega", "torque", "line"}; + fields_copy = {"molecule", "radius", "rmass", "omega"}; + fields_comm = {}; + fields_comm_vel = {"omega"}; + fields_reverse = {"torque"}; + fields_border = {"molecule", "radius", "rmass"}; + fields_border_vel = {"molecule", "radius", "rmass", "omega"}; + fields_exchange = {"molecule", "radius", "rmass", "omega"}; + fields_restart = {"molecule", "radius", "rmass", "omega"}; + fields_create = {"molecule", "radius", "rmass", "omega", "line"}; + fields_data_atom = {"id", "molecule", "type", "line", "rmass", "x"}; + fields_data_vel = {"id", "v", "omega"}; setup_fields(); } @@ -85,7 +83,7 @@ void AtomVecLine::init() AtomVec::init(); if (domain->dimension != 2) - error->all(FLERR,"Atom_style line can only be used in 2d simulations"); + error->all(FLERR, "Atom_style line can only be used in 2d simulations"); } /* ---------------------------------------------------------------------- @@ -108,11 +106,9 @@ void AtomVecLine::grow_pointers() void AtomVecLine::grow_bonus() { nmax_bonus = grow_nmax_bonus(nmax_bonus); - if (nmax_bonus < 0) - error->one(FLERR,"Per-processor system is too big"); + if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big"); - bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus), - "atom:bonus"); + bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom:bonus"); } /* ---------------------------------------------------------------------- @@ -124,7 +120,7 @@ void AtomVecLine::copy_bonus(int i, int j, int delflag) // if deleting atom J via delflag and J has bonus data, then delete it if (delflag && line[j] >= 0) { - copy_bonus_all(nlocal_bonus-1,line[j]); + copy_bonus_all(nlocal_bonus - 1, line[j]); nlocal_bonus--; } @@ -143,7 +139,7 @@ void AtomVecLine::copy_bonus(int i, int j, int delflag) void AtomVecLine::copy_bonus_all(int i, int j) { line[bonus[i].ilocal] = j; - memcpy(&bonus[j],&bonus[i],sizeof(Bonus)); + memcpy(&bonus[j], &bonus[i], sizeof(Bonus)); } /* ---------------------------------------------------------------------- @@ -164,7 +160,7 @@ void AtomVecLine::clear_bonus() int AtomVecLine::pack_comm_bonus(int n, int *list, double *buf) { - int i,j,m; + int i, j, m; m = 0; for (i = 0; i < n; i++) { @@ -179,7 +175,7 @@ int AtomVecLine::pack_comm_bonus(int n, int *list, double *buf) void AtomVecLine::unpack_comm_bonus(int n, int first, double *buf) { - int i,m,last; + int i, m, last; m = 0; last = first + n; @@ -192,12 +188,13 @@ void AtomVecLine::unpack_comm_bonus(int n, int first, double *buf) int AtomVecLine::pack_border_bonus(int n, int *list, double *buf) { - int i,j,m; + int i, j, m; m = 0; for (i = 0; i < n; i++) { j = list[i]; - if (line[j] < 0) buf[m++] = ubuf(0).d; + if (line[j] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; buf[m++] = bonus[line[j]].length; @@ -212,13 +209,14 @@ int AtomVecLine::pack_border_bonus(int n, int *list, double *buf) int AtomVecLine::unpack_border_bonus(int n, int first, double *buf) { - int i,j,m,last; + int i, j, m, last; m = 0; last = first + n; for (i = first; i < last; i++) { line[i] = (int) ubuf(buf[m++]).i; - if (line[i] == 0) line[i] = -1; + if (line[i] == 0) + line[i] = -1; else { j = nlocal_bonus + nghost_bonus; if (j == nmax_bonus) grow_bonus(); @@ -242,7 +240,8 @@ int AtomVecLine::pack_exchange_bonus(int i, double *buf) { int m = 0; - if (line[i] < 0) buf[m++] = ubuf(0).d; + if (line[i] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; int j = line[i]; @@ -260,7 +259,8 @@ int AtomVecLine::unpack_exchange_bonus(int ilocal, double *buf) int m = 0; line[ilocal] = (int) ubuf(buf[m++]).i; - if (line[ilocal] == 0) line[ilocal] = -1; + if (line[ilocal] == 0) + line[ilocal] = -1; else { if (nlocal_bonus == nmax_bonus) grow_bonus(); bonus[nlocal_bonus].length = buf[m++]; @@ -284,8 +284,10 @@ int AtomVecLine::size_restart_bonus() int n = 0; int nlocal = atom->nlocal; for (i = 0; i < nlocal; i++) { - if (line[i] >= 0) n += size_restart_bonus_one; - else n++; + if (line[i] >= 0) + n += size_restart_bonus_one; + else + n++; } return n; @@ -301,7 +303,8 @@ int AtomVecLine::pack_restart_bonus(int i, double *buf) { int m = 0; - if (line[i] < 0) buf[m++] = ubuf(0).d; + if (line[i] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; int j = line[i]; @@ -321,7 +324,8 @@ int AtomVecLine::unpack_restart_bonus(int ilocal, double *buf) int m = 0; line[ilocal] = (int) ubuf(buf[m++]).i; - if (line[ilocal] == 0) line[ilocal] = -1; + if (line[ilocal] == 0) + line[ilocal] = -1; else { if (nlocal_bonus == nmax_bonus) grow_bonus(); bonus[nlocal_bonus].length = buf[m++]; @@ -339,31 +343,32 @@ int AtomVecLine::unpack_restart_bonus(int ilocal, double *buf) void AtomVecLine::data_atom_bonus(int m, const std::vector &values) { - if (line[m]) error->one(FLERR,"Assigning line parameters to non-line atom"); + if (line[m]) error->one(FLERR, "Assigning line parameters to non-line atom"); if (nlocal_bonus == nmax_bonus) grow_bonus(); int ivalue = 1; - double x1 = utils::numeric(FLERR,values[ivalue++],true,lmp); - double y1 = utils::numeric(FLERR,values[ivalue++],true,lmp); - double x2 = utils::numeric(FLERR,values[ivalue++],true,lmp); - double y2 = utils::numeric(FLERR,values[ivalue++],true,lmp); + double x1 = utils::numeric(FLERR, values[ivalue++], true, lmp); + double y1 = utils::numeric(FLERR, values[ivalue++], true, lmp); + double x2 = utils::numeric(FLERR, values[ivalue++], true, lmp); + double y2 = utils::numeric(FLERR, values[ivalue++], true, lmp); double dx = x2 - x1; double dy = y2 - y1; - double length = sqrt(dx*dx + dy*dy); + double length = sqrt(dx * dx + dy * dy); bonus[nlocal_bonus].length = length; - if (dy >= 0.0) bonus[nlocal_bonus].theta = acos(dx/length); - else bonus[nlocal_bonus].theta = -acos(dx/length); + if (dy >= 0.0) + bonus[nlocal_bonus].theta = acos(dx / length); + else + bonus[nlocal_bonus].theta = -acos(dx / length); - double xc = 0.5*(x1+x2); - double yc = 0.5*(y1+y2); + double xc = 0.5 * (x1 + x2); + double yc = 0.5 * (y1 + y2); dx = xc - x[m][0]; dy = yc - x[m][1]; - double delta = sqrt(dx*dx + dy*dy); + double delta = sqrt(dx * dx + dy * dy); - if (delta/length > EPSILON) - error->one(FLERR,"Inconsistent line segment in data file"); + if (delta / length > EPSILON) error->one(FLERR, "Inconsistent line segment in data file"); x[m][0] = xc; x[m][1] = yc; @@ -385,7 +390,7 @@ void AtomVecLine::data_atom_bonus(int m, const std::vector &values) double AtomVecLine::memory_usage_bonus() { double bytes = 0; - bytes += (double)nmax_bonus*sizeof(Bonus); + bytes += (double) nmax_bonus * sizeof(Bonus); return bytes; } @@ -398,7 +403,7 @@ void AtomVecLine::create_atom_post(int ilocal) { double radius_one = 0.5; radius[ilocal] = radius_one; - rmass[ilocal] = 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one; + rmass[ilocal] = 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one; line[ilocal] = -1; } @@ -410,19 +415,22 @@ void AtomVecLine::create_atom_post(int ilocal) void AtomVecLine::data_atom_post(int ilocal) { line_flag = line[ilocal]; - if (line_flag == 0) line_flag = -1; - else if (line_flag == 1) line_flag = 0; - else error->one(FLERR,"Invalid line flag in Atoms section of data file"); + if (line_flag == 0) + line_flag = -1; + else if (line_flag == 1) + line_flag = 0; + else + error->one(FLERR, "Invalid line flag in Atoms section of data file"); line[ilocal] = line_flag; - if (rmass[ilocal] <= 0.0) - error->one(FLERR,"Invalid density in Atoms section of data file"); + if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file"); if (line_flag < 0) { double radius_one = 0.5; radius[ilocal] = radius_one; - rmass[ilocal] *= 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one; - } else radius[ilocal] = 0.0; + rmass[ilocal] *= 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one; + } else + radius[ilocal] = 0.0; omega[ilocal][0] = 0.0; omega[ilocal][1] = 0.0; @@ -438,13 +446,16 @@ void AtomVecLine::pack_data_pre(int ilocal) line_flag = line[ilocal]; rmass_one = rmass[ilocal]; - if (line_flag < 0) line[ilocal] = 0; - else line[ilocal] = 1; + if (line_flag < 0) + line[ilocal] = 0; + else + line[ilocal] = 1; if (line_flag < 0) { double radius_one = radius[ilocal]; - rmass[ilocal] /= 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one; - } else rmass[ilocal] /= bonus[line_flag].length; + rmass[ilocal] /= 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one; + } else + rmass[ilocal] /= bonus[line_flag].length; } /* ---------------------------------------------------------------------- @@ -464,9 +475,9 @@ void AtomVecLine::pack_data_post(int ilocal) int AtomVecLine::pack_data_bonus(double *buf, int /*flag*/) { - int i,j; - double length,theta; - double xc,yc,x1,x2,y1,y2; + int i, j; + double length, theta; + double xc, yc, x1, x2, y1, y2; double **x = atom->x; tagint *tag = atom->tag; @@ -482,15 +493,16 @@ int AtomVecLine::pack_data_bonus(double *buf, int /*flag*/) theta = bonus[j].theta; xc = x[i][0]; yc = x[i][1]; - x1 = xc - 0.5*cos(theta)*length; - y1 = yc - 0.5*sin(theta)*length; - x2 = xc + 0.5*cos(theta)*length; - y2 = yc + 0.5*sin(theta)*length; + x1 = xc - 0.5 * cos(theta) * length; + y1 = yc - 0.5 * sin(theta) * length; + x2 = xc + 0.5 * cos(theta) * length; + y2 = yc + 0.5 * sin(theta) * length; buf[m++] = x1; buf[m++] = y1; buf[m++] = x2; buf[m++] = y2; - } else m += size_data_bonus; + } else + m += size_data_bonus; } return m; } @@ -503,8 +515,8 @@ void AtomVecLine::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/) { int i = 0; while (i < n) { - fmt::print(fp,"{} {} {} {} {}\n",ubuf(buf[i]).i, - buf[i+1],buf[i+2],buf[i+3],buf[i+4]); + fmt::print(fp, "{} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], buf[i + 3], + buf[i + 4]); i += size_data_bonus; } } @@ -525,10 +537,11 @@ void AtomVecLine::set_length(int i, double value) bonus[nlocal_bonus].ilocal = i; line[i] = nlocal_bonus++; } else if (value == 0.0) { - copy_bonus_all(nlocal_bonus-1,line[i]); + copy_bonus_all(nlocal_bonus - 1, line[i]); nlocal_bonus--; line[i] = -1; - } else bonus[line[i]].length = value; + } else + bonus[line[i]].length = value; // also set radius = half of length // unless value = 0.0, then set diameter = 1.0 @@ -536,40 +549,3 @@ void AtomVecLine::set_length(int i, double value) radius[i] = 0.5 * value; if (value == 0.0) radius[i] = 0.5; } - -/* ---------------------------------------------------------------------- - check consistency of internal Bonus data structure - n = # of atoms in regular structure to check against -------------------------------------------------------------------------- */ - -/* -void AtomVecLine::consistency_check(int n, char *str) -{ - int iflag = 0; - int count = 0; - for (int i = 0; i < n; i++) { - - if (line[i] >= 0) { - count++; - if (line[i] >= nlocal_bonus) iflag++; - if (bonus[line[i]].ilocal != i) iflag++; - //if (comm->me == 1 && update->ntimestep == 873) - // printf("CCHK %s: %d %d: %d %d: %d %d\n", - // str,i,n,line[i],nlocal_bonus,bonus[line[i]].ilocal,iflag); - } - } - - if (iflag) { - printf("BAD vecline ptrs: %s: %d %d: %d\n",str,comm->me, - update->ntimestep,iflag); - MPI_Abort(world,1); - } - - if (count != nlocal_bonus) { - char msg[128]; - printf("BAD vecline count: %s: %d %d: %d %d\n", - str,comm->me,update->ntimestep,count,nlocal_bonus); - MPI_Abort(world,1); - } -} -*/ diff --git a/src/atom_vec_sphere.cpp b/src/atom_vec_sphere.cpp index dead605920..a03b2911c9 100644 --- a/src/atom_vec_sphere.cpp +++ b/src/atom_vec_sphere.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -21,8 +20,6 @@ #include "math_const.h" #include "modify.h" -#include - using namespace LAMMPS_NS; using namespace MathConst; @@ -34,26 +31,25 @@ AtomVecSphere::AtomVecSphere(LAMMPS *lmp) : AtomVec(lmp) molecular = Atom::ATOMIC; atom->sphere_flag = 1; - atom->radius_flag = atom->rmass_flag = atom->omega_flag = - atom->torque_flag = 1; + atom->radius_flag = atom->rmass_flag = atom->omega_flag = atom->torque_flag = 1; // strings with peratom variables to include in each AtomVec method // strings cannot contain fields in corresponding AtomVec default strings // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "radius rmass omega torque"; - fields_copy = (char *) "radius rmass omega"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) "omega"; - fields_reverse = (char *) "torque"; - fields_border = (char *) "radius rmass"; - fields_border_vel = (char *) "radius rmass omega"; - fields_exchange = (char *) "radius rmass omega"; - fields_restart = (char *) "radius rmass omega"; - fields_create = (char *) "radius rmass omega"; - fields_data_atom = (char *) "id type radius rmass x"; - fields_data_vel = (char *) "id v omega"; + fields_grow = {"radius", "rmass", "omega", "torque"}; + fields_copy = {"radius", "rmass", "omega"}; + fields_comm = {}; + fields_comm_vel = {"omega"}; + fields_reverse = {"torque"}; + fields_border = {"radius", "rmass"}; + fields_border_vel = {"radius", "rmass", "omega"}; + fields_exchange = {"radius", "rmass", "omega"}; + fields_restart = {"radius", "rmass", "omega"}; + fields_create = {"radius", "rmass", "omega"}; + fields_data_atom = {"id", "type", "radius", "rmass", "x"}; + fields_data_vel = {"id", "v", "omega"}; } /* ---------------------------------------------------------------------- @@ -63,21 +59,19 @@ AtomVecSphere::AtomVecSphere(LAMMPS *lmp) : AtomVec(lmp) void AtomVecSphere::process_args(int narg, char **arg) { - if (narg != 0 && narg != 1) - error->all(FLERR,"Illegal atom_style sphere command"); + if (narg != 0 && narg != 1) error->all(FLERR, "Illegal atom_style sphere command"); radvary = 0; if (narg == 1) { - radvary = utils::numeric(FLERR,arg[0],true,lmp); - if (radvary < 0 || radvary > 1) - error->all(FLERR,"Illegal atom_style sphere command"); + radvary = utils::numeric(FLERR, arg[0], true, lmp); + if (radvary < 0 || radvary > 1) error->all(FLERR, "Illegal atom_style sphere command"); } // dynamic particle radius and mass must be communicated every step if (radvary) { - fields_comm = (char *) "radius rmass"; - fields_comm_vel = (char *) "radius rmass omega"; + fields_comm = {"radius", "rmass"}; + fields_comm_vel = {"radius", "rmass", "omega"}; } // delay setting up of fields until now @@ -94,11 +88,10 @@ void AtomVecSphere::init() // check if optional radvary setting should have been set to 1 for (int i = 0; i < modify->nfix; i++) - if (strcmp(modify->fix[i]->style,"adapt") == 0) { - auto fix = dynamic_cast( modify->fix[i]); + if (strcmp(modify->fix[i]->style, "adapt") == 0) { + auto fix = dynamic_cast(modify->fix[i]); if (fix->diamflag && radvary == 0) - error->all(FLERR,"Fix adapt changes particle radii " - "but atom_style sphere is not dynamic"); + error->all(FLERR, "Fix adapt changes particle radii but atom_style sphere is not dynamic"); } } @@ -121,7 +114,7 @@ void AtomVecSphere::grow_pointers() void AtomVecSphere::create_atom_post(int ilocal) { radius[ilocal] = 0.5; - rmass[ilocal] = 4.0*MY_PI/3.0 * 0.5*0.5*0.5; + rmass[ilocal] = 4.0 * MY_PI / 3.0 * 0.5 * 0.5 * 0.5; } /* ---------------------------------------------------------------------- @@ -133,11 +126,9 @@ void AtomVecSphere::data_atom_post(int ilocal) { radius_one = 0.5 * atom->radius[ilocal]; radius[ilocal] = radius_one; - if (radius_one > 0.0) - rmass[ilocal] *= 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one; + if (radius_one > 0.0) rmass[ilocal] *= 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one; - if (rmass[ilocal] <= 0.0) - error->one(FLERR,"Invalid density in Atoms section of data file"); + if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file"); omega[ilocal][0] = 0.0; omega[ilocal][1] = 0.0; @@ -154,9 +145,8 @@ void AtomVecSphere::pack_data_pre(int ilocal) rmass_one = rmass[ilocal]; radius[ilocal] *= 2.0; - if (radius_one!= 0.0) - rmass[ilocal] = - rmass_one / (4.0*MY_PI/3.0 * radius_one*radius_one*radius_one); + if (radius_one != 0.0) + rmass[ilocal] = rmass_one / (4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one); } /* ---------------------------------------------------------------------- diff --git a/src/atom_vec_tri.cpp b/src/atom_vec_tri.cpp index 4b1ee0d921..6cd9127504 100644 --- a/src/atom_vec_tri.cpp +++ b/src/atom_vec_tri.cpp @@ -1,4 +1,3 @@ -// clang-format off /* ---------------------------------------------------------------------- LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator https://www.lammps.org/, Sandia National Laboratories @@ -19,18 +18,17 @@ #include "error.h" #include "fix.h" #include "math_const.h" -#include "math_extra.h" #include "math_eigen.h" +#include "math_extra.h" #include "memory.h" #include "modify.h" #include -#include using namespace LAMMPS_NS; -using namespace MathConst; +using MathConst::MY_PI; -#define EPSILON 0.001 +static constexpr double EPSILON = 0.001; /* ---------------------------------------------------------------------- */ @@ -58,18 +56,18 @@ AtomVecTri::AtomVecTri(LAMMPS *lmp) : AtomVec(lmp) // order of fields in a string does not matter // except: fields_data_atom & fields_data_vel must match data file - fields_grow = (char *) "molecule radius rmass omega angmom torque tri"; - fields_copy = (char *) "molecule radius rmass omega angmom"; - fields_comm = (char *) ""; - fields_comm_vel = (char *) "omega angmom"; - fields_reverse = (char *) "torque"; - fields_border = (char *) "molecule radius rmass"; - fields_border_vel = (char *) "molecule radius rmass omega"; - fields_exchange = (char *) "molecule radius rmass omega angmom"; - fields_restart = (char *) "molecule radius rmass omega angmom"; - fields_create = (char *) "molecule radius rmass omega angmom tri"; - fields_data_atom = (char *) "id molecule type tri rmass x"; - fields_data_vel = (char *) "id v omega angmom"; + fields_grow = {"molecule", "radius", "rmass", "omega", "angmom", "torque", "tri"}; + fields_copy = {"molecule", "radius", "rmass", "omega", "angmom"}; + fields_comm = {}; + fields_comm_vel = {"omega", "angmom"}; + fields_reverse = {"torque"}; + fields_border = {"molecule", "radius", "rmass"}; + fields_border_vel = {"molecule", "radius", "rmass", "omega"}; + fields_exchange = {"molecule", "radius", "rmass", "omega", "angmom"}; + fields_restart = {"molecule", "radius", "rmass", "omega", "angmom"}; + fields_create = {"molecule", "radius", "rmass", "omega", "angmom", "tri"}; + fields_data_atom = {"id", "molecule", "type", "tri", "rmass", "x"}; + fields_data_vel = {"id", "v", "omega", "angmom"}; setup_fields(); } @@ -88,7 +86,7 @@ void AtomVecTri::init() AtomVec::init(); if (domain->dimension != 3) - error->all(FLERR,"Atom_style tri can only be used in 3d simulations"); + error->all(FLERR, "Atom_style tri can only be used in 3d simulations"); } /* ---------------------------------------------------------------------- @@ -112,11 +110,9 @@ void AtomVecTri::grow_pointers() void AtomVecTri::grow_bonus() { nmax_bonus = grow_nmax_bonus(nmax_bonus); - if (nmax_bonus < 0) - error->one(FLERR,"Per-processor system is too big"); + if (nmax_bonus < 0) error->one(FLERR, "Per-processor system is too big"); - bonus = (Bonus *) memory->srealloc(bonus,nmax_bonus*sizeof(Bonus), - "atom:bonus"); + bonus = (Bonus *) memory->srealloc(bonus, nmax_bonus * sizeof(Bonus), "atom:bonus"); } /* ---------------------------------------------------------------------- @@ -129,7 +125,7 @@ void AtomVecTri::copy_bonus(int i, int j, int delflag) // if deleting atom J via delflag and J has bonus data, then delete it if (delflag && tri[j] >= 0) { - copy_bonus_all(nlocal_bonus-1,tri[j]); + copy_bonus_all(nlocal_bonus - 1, tri[j]); nlocal_bonus--; } @@ -148,7 +144,7 @@ void AtomVecTri::copy_bonus(int i, int j, int delflag) void AtomVecTri::copy_bonus_all(int i, int j) { tri[bonus[i].ilocal] = j; - memcpy(&bonus[j],&bonus[i],sizeof(Bonus)); + memcpy(&bonus[j], &bonus[i], sizeof(Bonus)); } /* ---------------------------------------------------------------------- @@ -169,7 +165,7 @@ void AtomVecTri::clear_bonus() int AtomVecTri::pack_comm_bonus(int n, int *list, double *buf) { - int i,j,m; + int i, j, m; double *quat; m = 0; @@ -191,7 +187,7 @@ int AtomVecTri::pack_comm_bonus(int n, int *list, double *buf) void AtomVecTri::unpack_comm_bonus(int n, int first, double *buf) { - int i,m,last; + int i, m, last; double *quat; m = 0; @@ -211,13 +207,14 @@ void AtomVecTri::unpack_comm_bonus(int n, int first, double *buf) int AtomVecTri::pack_border_bonus(int n, int *list, double *buf) { - int i,j,m; - double *quat,*c1,*c2,*c3,*inertia; + int i, j, m; + double *quat, *c1, *c2, *c3, *inertia; m = 0; for (i = 0; i < n; i++) { j = list[i]; - if (tri[j] < 0) buf[m++] = ubuf(0).d; + if (tri[j] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; quat = bonus[tri[j]].quat; @@ -251,14 +248,15 @@ int AtomVecTri::pack_border_bonus(int n, int *list, double *buf) int AtomVecTri::unpack_border_bonus(int n, int first, double *buf) { - int i,j,m,last; - double *quat,*c1,*c2,*c3,*inertia; + int i, j, m, last; + double *quat, *c1, *c2, *c3, *inertia; m = 0; last = first + n; for (i = first; i < last; i++) { tri[i] = (int) ubuf(buf[m++]).i; - if (tri[i] == 0) tri[i] = -1; + if (tri[i] == 0) + tri[i] = -1; else { j = nlocal_bonus + nghost_bonus; if (j == nmax_bonus) grow_bonus(); @@ -301,7 +299,8 @@ int AtomVecTri::pack_exchange_bonus(int i, double *buf) { int m = 0; - if (tri[i] < 0) buf[m++] = ubuf(0).d; + if (tri[i] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; int j = tri[i]; @@ -338,7 +337,8 @@ int AtomVecTri::unpack_exchange_bonus(int ilocal, double *buf) int m = 0; tri[ilocal] = (int) ubuf(buf[m++]).i; - if (tri[ilocal] == 0) tri[ilocal] = -1; + if (tri[ilocal] == 0) + tri[ilocal] = -1; else { if (nlocal_bonus == nmax_bonus) grow_bonus(); double *quat = bonus[nlocal_bonus].quat; @@ -381,8 +381,10 @@ int AtomVecTri::size_restart_bonus() int n = 0; int nlocal = atom->nlocal; for (i = 0; i < nlocal; i++) { - if (tri[i] >= 0) n += size_restart_bonus_one; - else n++; + if (tri[i] >= 0) + n += size_restart_bonus_one; + else + n++; } return n; @@ -396,7 +398,8 @@ int AtomVecTri::pack_restart_bonus(int i, double *buf) { int m = 0; - if (tri[i] < 0) buf[m++] = ubuf(0).d; + if (tri[i] < 0) + buf[m++] = ubuf(0).d; else { buf[m++] = ubuf(1).d; int j = tri[i]; @@ -435,7 +438,8 @@ int AtomVecTri::unpack_restart_bonus(int ilocal, double *buf) int m = 0; tri[ilocal] = (int) ubuf(buf[m++]).i; - if (tri[ilocal] == 0) tri[ilocal] = -1; + if (tri[ilocal] == 0) + tri[ilocal] = -1; else { if (nlocal_bonus == nmax_bonus) grow_bonus(); double *quat = bonus[nlocal_bonus].quat; @@ -472,52 +476,51 @@ int AtomVecTri::unpack_restart_bonus(int ilocal, double *buf) void AtomVecTri::data_atom_bonus(int m, const std::vector &values) { - if (tri[m]) error->one(FLERR,"Assigning tri parameters to non-tri atom"); + if (tri[m]) error->one(FLERR, "Assigning tri parameters to non-tri atom"); if (nlocal_bonus == nmax_bonus) grow_bonus(); - double c1[3],c2[3],c3[3]; + double c1[3], c2[3], c3[3]; int ivalue = 1; - c1[0] = utils::numeric(FLERR,values[ivalue++],true,lmp); - c1[1] = utils::numeric(FLERR,values[ivalue++],true,lmp); - c1[2] = utils::numeric(FLERR,values[ivalue++],true,lmp); - c2[0] = utils::numeric(FLERR,values[ivalue++],true,lmp); - c2[1] = utils::numeric(FLERR,values[ivalue++],true,lmp); - c2[2] = utils::numeric(FLERR,values[ivalue++],true,lmp); - c3[0] = utils::numeric(FLERR,values[ivalue++],true,lmp); - c3[1] = utils::numeric(FLERR,values[ivalue++],true,lmp); - c3[2] = utils::numeric(FLERR,values[ivalue++],true,lmp); + c1[0] = utils::numeric(FLERR, values[ivalue++], true, lmp); + c1[1] = utils::numeric(FLERR, values[ivalue++], true, lmp); + c1[2] = utils::numeric(FLERR, values[ivalue++], true, lmp); + c2[0] = utils::numeric(FLERR, values[ivalue++], true, lmp); + c2[1] = utils::numeric(FLERR, values[ivalue++], true, lmp); + c2[2] = utils::numeric(FLERR, values[ivalue++], true, lmp); + c3[0] = utils::numeric(FLERR, values[ivalue++], true, lmp); + c3[1] = utils::numeric(FLERR, values[ivalue++], true, lmp); + c3[2] = utils::numeric(FLERR, values[ivalue++], true, lmp); // check for duplicate points if (c1[0] == c2[0] && c1[1] == c2[1] && c1[2] == c2[2]) - error->one(FLERR,"Invalid shape in Triangles section of data file"); + error->one(FLERR, "Invalid shape in Triangles section of data file"); if (c1[0] == c3[0] && c1[1] == c3[1] && c1[2] == c3[2]) - error->one(FLERR,"Invalid shape in Triangles section of data file"); + error->one(FLERR, "Invalid shape in Triangles section of data file"); if (c2[0] == c3[0] && c2[1] == c3[1] && c2[2] == c3[2]) - error->one(FLERR,"Invalid shape in Triangles section of data file"); + error->one(FLERR, "Invalid shape in Triangles section of data file"); // size = length of one edge - double c2mc1[3],c3mc1[3]; - MathExtra::sub3(c2,c1,c2mc1); - MathExtra::sub3(c3,c1,c3mc1); - double size = MAX(MathExtra::len3(c2mc1),MathExtra::len3(c3mc1)); + double c2mc1[3], c3mc1[3]; + MathExtra::sub3(c2, c1, c2mc1); + MathExtra::sub3(c3, c1, c3mc1); + double size = MAX(MathExtra::len3(c2mc1), MathExtra::len3(c3mc1)); // centroid = 1/3 of sum of vertices double centroid[3]; - centroid[0] = (c1[0]+c2[0]+c3[0]) / 3.0; - centroid[1] = (c1[1]+c2[1]+c3[1]) / 3.0; - centroid[2] = (c1[2]+c2[2]+c3[2]) / 3.0; + centroid[0] = (c1[0] + c2[0] + c3[0]) / 3.0; + centroid[1] = (c1[1] + c2[1] + c3[1]) / 3.0; + centroid[2] = (c1[2] + c2[2] + c3[2]) / 3.0; double dx = centroid[0] - x[m][0]; double dy = centroid[1] - x[m][1]; double dz = centroid[2] - x[m][2]; - double delta = sqrt(dx*dx + dy*dy + dz*dz); + double delta = sqrt(dx * dx + dy * dy + dz * dz); - if (delta/size > EPSILON) - error->one(FLERR,"Inconsistent triangle in data file"); + if (delta / size > EPSILON) error->one(FLERR, "Inconsistent triangle in data file"); x[m][0] = centroid[0]; x[m][1] = centroid[1]; @@ -528,29 +531,29 @@ void AtomVecTri::data_atom_bonus(int m, const std::vector &values) // tri area = 0.5 len(U x V), where U,V are edge vectors from one vertex double c4[3]; - MathExtra::sub3(c1,centroid,c4); + MathExtra::sub3(c1, centroid, c4); radius[m] = MathExtra::lensq3(c4); - MathExtra::sub3(c2,centroid,c4); - radius[m] = MAX(radius[m],MathExtra::lensq3(c4)); - MathExtra::sub3(c3,centroid,c4); - radius[m] = MAX(radius[m],MathExtra::lensq3(c4)); + MathExtra::sub3(c2, centroid, c4); + radius[m] = MAX(radius[m], MathExtra::lensq3(c4)); + MathExtra::sub3(c3, centroid, c4); + radius[m] = MAX(radius[m], MathExtra::lensq3(c4)); radius[m] = sqrt(radius[m]); double norm[3]; - MathExtra::cross3(c2mc1,c3mc1,norm); + MathExtra::cross3(c2mc1, c3mc1, norm); double area = 0.5 * MathExtra::len3(norm); rmass[m] *= area; // inertia = inertia tensor of triangle as 6-vector in Voigt ordering double inertia[6]; - MathExtra::inertia_triangle(c1,c2,c3,rmass[m],inertia); + MathExtra::inertia_triangle(c1, c2, c3, rmass[m], inertia); // diagonalize inertia tensor via Jacobi rotations // bonus[].inertia = 3 eigenvalues = principal moments of inertia // evectors and exzy_space = 3 evectors = principal axes of triangle - double tensor[3][3],evectors[3][3]; + double tensor[3][3], evectors[3][3]; tensor[0][0] = inertia[0]; tensor[1][1] = inertia[1]; tensor[2][2] = inertia[2]; @@ -558,10 +561,10 @@ void AtomVecTri::data_atom_bonus(int m, const std::vector &values) tensor[0][2] = tensor[2][0] = inertia[4]; tensor[0][1] = tensor[1][0] = inertia[5]; - int ierror = MathEigen::jacobi3(tensor,bonus[nlocal_bonus].inertia,evectors); - if (ierror) error->one(FLERR,"Insufficient Jacobi rotations for triangle"); + int ierror = MathEigen::jacobi3(tensor, bonus[nlocal_bonus].inertia, evectors); + if (ierror) error->one(FLERR, "Insufficient Jacobi rotations for triangle"); - double ex_space[3],ey_space[3],ez_space[3]; + double ex_space[3], ey_space[3], ez_space[3]; ex_space[0] = evectors[0][0]; ex_space[1] = evectors[1][0]; ex_space[2] = evectors[2][0]; @@ -575,26 +578,23 @@ void AtomVecTri::data_atom_bonus(int m, const std::vector &values) // enforce 3 orthogonal vectors as a right-handed coordinate system // flip 3rd vector if needed - MathExtra::cross3(ex_space,ey_space,norm); - if (MathExtra::dot3(norm,ez_space) < 0.0) MathExtra::negate3(ez_space); + MathExtra::cross3(ex_space, ey_space, norm); + if (MathExtra::dot3(norm, ez_space) < 0.0) MathExtra::negate3(ez_space); // create initial quaternion - MathExtra::exyz_to_q(ex_space,ey_space,ez_space,bonus[nlocal_bonus].quat); + MathExtra::exyz_to_q(ex_space, ey_space, ez_space, bonus[nlocal_bonus].quat); // bonus c1,c2,c3 = displacement of c1,c2,c3 from centroid // in basis of principal axes double disp[3]; - MathExtra::sub3(c1,centroid,disp); - MathExtra::transpose_matvec(ex_space,ey_space,ez_space, - disp,bonus[nlocal_bonus].c1); - MathExtra::sub3(c2,centroid,disp); - MathExtra::transpose_matvec(ex_space,ey_space,ez_space, - disp,bonus[nlocal_bonus].c2); - MathExtra::sub3(c3,centroid,disp); - MathExtra::transpose_matvec(ex_space,ey_space,ez_space, - disp,bonus[nlocal_bonus].c3); + MathExtra::sub3(c1, centroid, disp); + MathExtra::transpose_matvec(ex_space, ey_space, ez_space, disp, bonus[nlocal_bonus].c1); + MathExtra::sub3(c2, centroid, disp); + MathExtra::transpose_matvec(ex_space, ey_space, ez_space, disp, bonus[nlocal_bonus].c2); + MathExtra::sub3(c3, centroid, disp); + MathExtra::transpose_matvec(ex_space, ey_space, ez_space, disp, bonus[nlocal_bonus].c3); bonus[nlocal_bonus].ilocal = m; tri[m] = nlocal_bonus++; @@ -607,7 +607,7 @@ void AtomVecTri::data_atom_bonus(int m, const std::vector &values) double AtomVecTri::memory_usage_bonus() { double bytes = 0; - bytes += (double)nmax_bonus*sizeof(Bonus); + bytes += (double) nmax_bonus * sizeof(Bonus); return bytes; } @@ -620,7 +620,7 @@ void AtomVecTri::create_atom_post(int ilocal) { double radius_one = 0.5; radius[ilocal] = radius_one; - rmass[ilocal] = 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one; + rmass[ilocal] = 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one; tri[ilocal] = -1; } @@ -632,19 +632,22 @@ void AtomVecTri::create_atom_post(int ilocal) void AtomVecTri::data_atom_post(int ilocal) { tri_flag = tri[ilocal]; - if (tri_flag == 0) tri_flag = -1; - else if (tri_flag == 1) tri_flag = 0; - else error->one(FLERR,"Invalid tri flag in Atoms section of data file"); + if (tri_flag == 0) + tri_flag = -1; + else if (tri_flag == 1) + tri_flag = 0; + else + error->one(FLERR, "Invalid tri flag in Atoms section of data file"); tri[ilocal] = tri_flag; - if (rmass[ilocal] <= 0.0) - error->one(FLERR,"Invalid density in Atoms section of data file"); + if (rmass[ilocal] <= 0.0) error->one(FLERR, "Invalid density in Atoms section of data file"); if (tri_flag < 0) { double radius_one = 0.5; radius[ilocal] = radius_one; - rmass[ilocal] *= 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one; - } else radius[ilocal] = 0.0; + rmass[ilocal] *= 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one; + } else + radius[ilocal] = 0.0; omega[ilocal][0] = 0.0; omega[ilocal][1] = 0.0; @@ -663,17 +666,19 @@ void AtomVecTri::pack_data_pre(int ilocal) tri_flag = tri[ilocal]; rmass_one = rmass[ilocal]; - if (tri_flag < 0) tri[ilocal] = 0; - else tri[ilocal] = 1; + if (tri_flag < 0) + tri[ilocal] = 0; + else + tri[ilocal] = 1; if (tri_flag < 0) { double radius_one = radius[ilocal]; - rmass[ilocal] /= 4.0*MY_PI/3.0 * radius_one*radius_one*radius_one; + rmass[ilocal] /= 4.0 * MY_PI / 3.0 * radius_one * radius_one * radius_one; } else { - double c2mc1[3],c3mc1[3],norm[3]; - MathExtra::sub3(bonus[tri_flag].c2,bonus[tri_flag].c1,c2mc1); - MathExtra::sub3(bonus[tri_flag].c3,bonus[tri_flag].c1,c3mc1); - MathExtra::cross3(c2mc1,c3mc1,norm); + double c2mc1[3], c3mc1[3], norm[3]; + MathExtra::sub3(bonus[tri_flag].c2, bonus[tri_flag].c1, c2mc1); + MathExtra::sub3(bonus[tri_flag].c3, bonus[tri_flag].c1, c3mc1); + MathExtra::cross3(c2mc1, c3mc1, norm); double area = 0.5 * MathExtra::len3(norm); rmass[ilocal] /= area; } @@ -696,9 +701,9 @@ void AtomVecTri::pack_data_post(int ilocal) int AtomVecTri::pack_data_bonus(double *buf, int /*flag*/) { - int i,j; - double xc,yc,zc; - double dc1[3],dc2[3],dc3[3]; + int i, j; + double xc, yc, zc; + double dc1[3], dc2[3], dc3[3]; double p[3][3]; double **x = atom->x; @@ -711,10 +716,10 @@ int AtomVecTri::pack_data_bonus(double *buf, int /*flag*/) if (buf) { buf[m++] = ubuf(tag[i]).d; j = tri[i]; - MathExtra::quat_to_mat(bonus[j].quat,p); - MathExtra::matvec(p,bonus[j].c1,dc1); - MathExtra::matvec(p,bonus[j].c2,dc2); - MathExtra::matvec(p,bonus[j].c3,dc3); + MathExtra::quat_to_mat(bonus[j].quat, p); + MathExtra::matvec(p, bonus[j].c1, dc1); + MathExtra::matvec(p, bonus[j].c2, dc2); + MathExtra::matvec(p, bonus[j].c3, dc3); xc = x[i][0]; yc = x[i][1]; zc = x[i][2]; @@ -727,7 +732,8 @@ int AtomVecTri::pack_data_bonus(double *buf, int /*flag*/) buf[m++] = xc + dc3[0]; buf[m++] = yc + dc3[1]; buf[m++] = zc + dc3[2]; - } else m += size_data_bonus; + } else + m += size_data_bonus; } return m; } @@ -740,9 +746,8 @@ void AtomVecTri::write_data_bonus(FILE *fp, int n, double *buf, int /*flag*/) { int i = 0; while (i < n) { - fmt::print(fp,"{} {} {} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, - buf[i+1],buf[i+2],buf[i+3],buf[i+4],buf[i+5],buf[i+6], - buf[i+7],buf[i+8],buf[i+9]); + fmt::print(fp, "{} {} {} {} {} {} {} {} {} {}\n", ubuf(buf[i]).i, buf[i + 1], buf[i + 2], + buf[i + 3], buf[i + 4], buf[i + 5], buf[i + 6], buf[i + 7], buf[i + 8], buf[i + 9]); i += size_data_bonus; } } @@ -770,24 +775,24 @@ void AtomVecTri::set_equilateral(int i, double size) quat[1] = 0.0; quat[2] = 0.0; quat[3] = 0.0; - c1[0] = -size/2.0; - c1[1] = -sqrt(3.0)/2.0 * size / 3.0; + c1[0] = -size / 2.0; + c1[1] = -sqrt(3.0) / 2.0 * size / 3.0; c1[2] = 0.0; - c2[0] = size/2.0; - c2[1] = -sqrt(3.0)/2.0 * size / 3.0; + c2[0] = size / 2.0; + c2[1] = -sqrt(3.0) / 2.0 * size / 3.0; c2[2] = 0.0; c3[0] = 0.0; - c3[1] = sqrt(3.0)/2.0 * size * 2.0/3.0; + c3[1] = sqrt(3.0) / 2.0 * size * 2.0 / 3.0; c3[2] = 0.0; - inertia[0] = sqrt(3.0)/96.0 * size*size*size*size; - inertia[1] = sqrt(3.0)/96.0 * size*size*size*size; - inertia[2] = sqrt(3.0)/48.0 * size*size*size*size; + inertia[0] = sqrt(3.0) / 96.0 * size * size * size * size; + inertia[1] = sqrt(3.0) / 96.0 * size * size * size * size; + inertia[2] = sqrt(3.0) / 48.0 * size * size * size * size; radius[i] = MathExtra::len3(c1); bonus[nlocal_bonus].ilocal = i; tri[i] = nlocal_bonus++; } else if (size == 0.0) { radius[i] = 0.5; - copy_bonus_all(nlocal_bonus-1,tri[i]); + copy_bonus_all(nlocal_bonus - 1, tri[i]); nlocal_bonus--; tri[i] = -1; } else { @@ -795,18 +800,18 @@ void AtomVecTri::set_equilateral(int i, double size) double *c2 = bonus[tri[i]].c2; double *c3 = bonus[tri[i]].c3; double *inertia = bonus[tri[i]].inertia; - c1[0] = -size/2.0; - c1[1] = -sqrt(3.0)/2.0 * size / 3.0; + c1[0] = -size / 2.0; + c1[1] = -sqrt(3.0) / 2.0 * size / 3.0; c1[2] = 0.0; - c2[0] = size/2.0; - c2[1] = -sqrt(3.0)/2.0 * size / 3.0; + c2[0] = size / 2.0; + c2[1] = -sqrt(3.0) / 2.0 * size / 3.0; c2[2] = 0.0; c3[0] = 0.0; - c3[1] = sqrt(3.0)/2.0 * size * 2.0/3.0; + c3[1] = sqrt(3.0) / 2.0 * size * 2.0 / 3.0; c3[2] = 0.0; - inertia[0] = sqrt(3.0)/96.0 * size*size*size*size; - inertia[1] = sqrt(3.0)/96.0 * size*size*size*size; - inertia[2] = sqrt(3.0)/48.0 * size*size*size*size; + inertia[0] = sqrt(3.0) / 96.0 * size * size * size * size; + inertia[1] = sqrt(3.0) / 96.0 * size * size * size * size; + inertia[2] = sqrt(3.0) / 48.0 * size * size * size * size; radius[i] = MathExtra::len3(c1); } }