508 lines
16 KiB
C++
508 lines
16 KiB
C++
/* ----------------------------------------------------------------------
|
|
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
|
https://www.lammps.org/, Sandia National Laboratories
|
|
LAMMPS development team: developers@lammps.org
|
|
|
|
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
|
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
|
certain rights in this software. This software is distributed under
|
|
the GNU General Public License.
|
|
|
|
See the README file in the top-level LAMMPS directory.
|
|
------------------------------------------------------------------------- */
|
|
|
|
#include "compute_centroid_stress_atom.h"
|
|
|
|
#include "angle.h"
|
|
#include "atom.h"
|
|
#include "bond.h"
|
|
#include "citeme.h"
|
|
#include "comm.h"
|
|
#include "dihedral.h"
|
|
#include "error.h"
|
|
#include "fix.h"
|
|
#include "force.h"
|
|
#include "improper.h"
|
|
#include "kspace.h"
|
|
#include "memory.h"
|
|
#include "modify.h"
|
|
#include "pair.h"
|
|
#include "update.h"
|
|
|
|
#include <cstring>
|
|
|
|
using namespace LAMMPS_NS;
|
|
|
|
enum { NOBIAS, BIAS };
|
|
|
|
static const char cite_centroid_angle_improper_dihedral[] =
|
|
"compute centroid/stress/atom for angles, impropers and dihedrals: "
|
|
"doi:10.1103/PhysRevE.99.051301\n\n"
|
|
"@article{Surblys2019,\n"
|
|
" title = {Application of Atomic Stress to Compute Heat Flux via Molecular\n"
|
|
" Dynamics for Systems With Many-Body Interactions},\n"
|
|
" author = {Surblys, Donatas and Matsubara, Hiroki and Kikugawa, Gota and Ohara, Taku},\n"
|
|
" journal = {Physical Review~E},\n"
|
|
" volume = {99},\n"
|
|
" issue = {5},\n"
|
|
" pages = {051301},\n"
|
|
" year = {2019},\n"
|
|
" doi = {10.1103/PhysRevE.99.051301},\n"
|
|
" url = {https://link.aps.org/doi/10.1103/PhysRevE.99.051301}\n"
|
|
"}\n\n";
|
|
|
|
static const char cite_centroid_shake_rigid[] =
|
|
"compute centroid/stress/atom for constrained dynamics: doi:10.1063/5.0070930\n\n"
|
|
"@article{Surblys2021,\n"
|
|
" author = {Surblys, Donatas and Matsubara, Hiroki and Kikugawa, Gota and Ohara, Taku},\n"
|
|
" journal = {Journal of Applied Physics},\n"
|
|
" title = {Methodology and Meaning of Computing Heat Flux via Atomic Stress in Systems with\n"
|
|
" Constraint Dynamics},\n"
|
|
" volume = {130},\n"
|
|
" number = {21},\n"
|
|
" pages = {215104},\n"
|
|
" year = {2021},\n"
|
|
" doi = {10.1063/5.0070930},\n"
|
|
" url = {https://doi.org/10.1063/5.0070930},\n"
|
|
"}\n\n";
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
ComputeCentroidStressAtom::ComputeCentroidStressAtom(LAMMPS *lmp, int narg, char **arg) :
|
|
Compute(lmp, narg, arg), id_temp(nullptr), stress(nullptr)
|
|
{
|
|
if (narg < 4) error->all(FLERR, "Illegal compute centroid/stress/atom command");
|
|
|
|
peratom_flag = 1;
|
|
size_peratom_cols = 9;
|
|
pressatomflag = 2;
|
|
timeflag = 1;
|
|
comm_reverse = 9;
|
|
|
|
// store temperature ID used by stress computation
|
|
// ensure it is valid for temperature computation
|
|
|
|
if (strcmp(arg[3], "NULL") == 0)
|
|
id_temp = nullptr;
|
|
else {
|
|
id_temp = utils::strdup(arg[3]);
|
|
|
|
auto compute = modify->get_compute_by_id(id_temp);
|
|
if (!compute)
|
|
error->all(FLERR, "Could not find compute centroid/stress/atom temperature ID {}", id_temp);
|
|
if (compute->tempflag == 0)
|
|
error->all(FLERR, "Compute centroid/stress/atom temperature ID does not compute temperature");
|
|
}
|
|
|
|
// process optional args
|
|
|
|
if (narg == 4) {
|
|
keflag = 1;
|
|
pairflag = 1;
|
|
bondflag = angleflag = dihedralflag = improperflag = 1;
|
|
kspaceflag = 1;
|
|
fixflag = 1;
|
|
} else {
|
|
keflag = 0;
|
|
pairflag = 0;
|
|
bondflag = angleflag = dihedralflag = improperflag = 0;
|
|
kspaceflag = 0;
|
|
fixflag = 0;
|
|
int iarg = 4;
|
|
while (iarg < narg) {
|
|
if (strcmp(arg[iarg], "ke") == 0)
|
|
keflag = 1;
|
|
else if (strcmp(arg[iarg], "pair") == 0)
|
|
pairflag = 1;
|
|
else if (strcmp(arg[iarg], "bond") == 0)
|
|
bondflag = 1;
|
|
else if (strcmp(arg[iarg], "angle") == 0)
|
|
angleflag = 1;
|
|
else if (strcmp(arg[iarg], "dihedral") == 0)
|
|
dihedralflag = 1;
|
|
else if (strcmp(arg[iarg], "improper") == 0)
|
|
improperflag = 1;
|
|
else if (strcmp(arg[iarg], "kspace") == 0)
|
|
kspaceflag = 1;
|
|
else if (strcmp(arg[iarg], "fix") == 0)
|
|
fixflag = 1;
|
|
else if (strcmp(arg[iarg], "virial") == 0) {
|
|
pairflag = 1;
|
|
bondflag = angleflag = dihedralflag = improperflag = 1;
|
|
kspaceflag = fixflag = 1;
|
|
} else
|
|
error->all(FLERR, "Illegal compute centroid/stress/atom command");
|
|
iarg++;
|
|
}
|
|
}
|
|
|
|
nmax = 0;
|
|
|
|
if (lmp->citeme) {
|
|
if (angleflag || dihedralflag || improperflag)
|
|
lmp->citeme->add(cite_centroid_angle_improper_dihedral);
|
|
if (fixflag) lmp->citeme->add(cite_centroid_shake_rigid);
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
ComputeCentroidStressAtom::~ComputeCentroidStressAtom()
|
|
{
|
|
delete[] id_temp;
|
|
memory->destroy(stress);
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
void ComputeCentroidStressAtom::init()
|
|
{
|
|
// set temperature compute, must be done in init()
|
|
// fixes could have changed or compute_modify could have changed it
|
|
|
|
if (id_temp) {
|
|
temperature = modify->get_compute_by_id(id_temp);
|
|
if (!temperature)
|
|
error->all(FLERR, "Could not find compute centroid/stress/atom temperature ID {}", id_temp);
|
|
if (temperature->tempbias)
|
|
biasflag = BIAS;
|
|
else
|
|
biasflag = NOBIAS;
|
|
} else
|
|
biasflag = NOBIAS;
|
|
|
|
// check if force components and fixes support centroid atom stress
|
|
// all bond styles support it as CENTROID_SAME
|
|
|
|
if (pairflag && force->pair)
|
|
if (force->pair->centroidstressflag == CENTROID_NOTAVAIL)
|
|
error->all(FLERR, "Pair style does not support compute centroid/stress/atom");
|
|
|
|
if (angleflag && force->angle)
|
|
if (force->angle->centroidstressflag == CENTROID_NOTAVAIL)
|
|
error->all(FLERR, "Angle style does not support compute centroid/stress/atom");
|
|
|
|
if (dihedralflag && force->dihedral)
|
|
if (force->dihedral->centroidstressflag == CENTROID_NOTAVAIL)
|
|
error->all(FLERR, "Dihedral style does not support compute centroid/stress/atom");
|
|
|
|
if (improperflag && force->improper)
|
|
if (force->improper->centroidstressflag == CENTROID_NOTAVAIL)
|
|
error->all(FLERR, "Improper style does not support compute centroid/stress/atom");
|
|
|
|
if (kspaceflag && force->kspace)
|
|
if (force->kspace->centroidstressflag == CENTROID_NOTAVAIL)
|
|
error->all(FLERR, "KSpace style does not support compute centroid/stress/atom");
|
|
|
|
if (fixflag) {
|
|
for (auto &ifix : modify->get_fix_list())
|
|
if (ifix->virial_peratom_flag && (ifix->centroidstressflag == CENTROID_NOTAVAIL))
|
|
error->all(FLERR, "Fix {} does not support compute centroid/stress/atom", ifix->style);
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
void ComputeCentroidStressAtom::compute_peratom()
|
|
{
|
|
int i, j;
|
|
double onemass;
|
|
|
|
invoked_peratom = update->ntimestep;
|
|
if (update->vflag_atom != invoked_peratom)
|
|
error->all(FLERR, "Per-atom virial was not tallied on needed timestep");
|
|
|
|
// grow local stress array if necessary
|
|
// needs to be atom->nmax in length
|
|
|
|
if (atom->nmax > nmax) {
|
|
memory->destroy(stress);
|
|
nmax = atom->nmax;
|
|
memory->create(stress, nmax, 9, "centroid/stress/atom:stress");
|
|
array_atom = stress;
|
|
}
|
|
|
|
// npair includes ghosts if either newton flag is set
|
|
// b/c some bonds/dihedrals call pair::ev_tally with pairwise info
|
|
// nbond includes ghosts if newton_bond is set
|
|
// ntotal includes ghosts if either newton flag is set
|
|
// KSpace includes ghosts if tip4pflag is set
|
|
|
|
int nlocal = atom->nlocal;
|
|
int npair = nlocal;
|
|
int nbond = nlocal;
|
|
int ntotal = nlocal;
|
|
int nkspace = nlocal;
|
|
if (force->newton) npair += atom->nghost;
|
|
if (force->newton_bond) nbond += atom->nghost;
|
|
if (force->newton) ntotal += atom->nghost;
|
|
if (force->kspace && force->kspace->tip4pflag) nkspace += atom->nghost;
|
|
|
|
// clear local stress array
|
|
|
|
for (i = 0; i < ntotal; i++)
|
|
for (j = 0; j < 9; j++) stress[i][j] = 0.0;
|
|
|
|
// add in per-atom contributions from all force components and fixes
|
|
|
|
// pair styles are either CENTROID_SAME or CENTROID_AVAIL or CENTROID_NOTAVAIL
|
|
|
|
if (pairflag && force->pair && force->pair->compute_flag) {
|
|
if (force->pair->centroidstressflag == CENTROID_AVAIL) {
|
|
double **cvatom = force->pair->cvatom;
|
|
for (i = 0; i < npair; i++)
|
|
for (j = 0; j < 9; j++) stress[i][j] += cvatom[i][j];
|
|
} else {
|
|
double **vatom = force->pair->vatom;
|
|
for (i = 0; i < npair; i++) {
|
|
for (j = 0; j < 6; j++) stress[i][j] += vatom[i][j];
|
|
for (j = 6; j < 9; j++) stress[i][j] += vatom[i][j - 3];
|
|
}
|
|
}
|
|
}
|
|
|
|
// per-atom virial and per-atom centroid virial are the same for bonds
|
|
// bond styles are all CENTROID_SAME
|
|
// angle, dihedral, improper styles are CENTROID_AVAIL or CENTROID_NOTAVAIL
|
|
// KSpace styles are all CENTROID_NOTAVAIL, placeholder CENTROID_SAME below
|
|
|
|
if (bondflag && force->bond) {
|
|
double **vatom = force->bond->vatom;
|
|
for (i = 0; i < nbond; i++) {
|
|
for (j = 0; j < 6; j++) stress[i][j] += vatom[i][j];
|
|
for (j = 6; j < 9; j++) stress[i][j] += vatom[i][j - 3];
|
|
}
|
|
}
|
|
|
|
if (angleflag && force->angle) {
|
|
double **cvatom = force->angle->cvatom;
|
|
for (i = 0; i < nbond; i++)
|
|
for (j = 0; j < 9; j++) stress[i][j] += cvatom[i][j];
|
|
}
|
|
|
|
if (dihedralflag && force->dihedral) {
|
|
double **cvatom = force->dihedral->cvatom;
|
|
for (i = 0; i < nbond; i++)
|
|
for (j = 0; j < 9; j++) stress[i][j] += cvatom[i][j];
|
|
}
|
|
|
|
if (improperflag && force->improper) {
|
|
double **cvatom = force->improper->cvatom;
|
|
for (i = 0; i < nbond; i++)
|
|
for (j = 0; j < 9; j++) stress[i][j] += cvatom[i][j];
|
|
}
|
|
|
|
if (kspaceflag && force->kspace && force->kspace->compute_flag) {
|
|
double **vatom = force->kspace->vatom;
|
|
for (i = 0; i < nkspace; i++) {
|
|
for (j = 0; j < 6; j++) stress[i][j] += vatom[i][j];
|
|
for (j = 6; j < 9; j++) stress[i][j] += vatom[i][j - 3];
|
|
}
|
|
}
|
|
|
|
// add in per-atom contributions from relevant fixes
|
|
// skip if vatom = nullptr
|
|
// possible during setup phase if fix has not initialized its vatom yet
|
|
// e.g. fix ave/chunk defined before fix shake,
|
|
// and fix ave/chunk uses a per-atom stress from this compute as input
|
|
// fix styles are CENTROID_SAME, CENTROID_AVAIL or CENTROID_NOTAVAIL
|
|
|
|
if (fixflag) {
|
|
for (auto &ifix : modify->get_fix_list())
|
|
if (ifix->virial_peratom_flag && ifix->thermo_virial) {
|
|
if (ifix->centroidstressflag == CENTROID_AVAIL) {
|
|
double **cvatom = ifix->cvatom;
|
|
if (cvatom)
|
|
for (i = 0; i < nlocal; i++)
|
|
for (j = 0; j < 9; j++) stress[i][j] += cvatom[i][j];
|
|
} else {
|
|
double **vatom = ifix->vatom;
|
|
if (vatom)
|
|
for (i = 0; i < nlocal; i++) {
|
|
for (j = 0; j < 6; j++) stress[i][j] += vatom[i][j];
|
|
for (j = 6; j < 9; j++) stress[i][j] += vatom[i][j - 3];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// communicate ghost virials between neighbor procs
|
|
|
|
if (force->newton || (force->kspace && force->kspace->tip4pflag && force->kspace->compute_flag))
|
|
comm->reverse_comm(this);
|
|
|
|
// zero virial of atoms not in group
|
|
// only do this after comm since ghost contributions must be included
|
|
|
|
int *mask = atom->mask;
|
|
|
|
for (i = 0; i < nlocal; i++)
|
|
if (!(mask[i] & groupbit)) {
|
|
stress[i][0] = 0.0;
|
|
stress[i][1] = 0.0;
|
|
stress[i][2] = 0.0;
|
|
stress[i][3] = 0.0;
|
|
stress[i][4] = 0.0;
|
|
stress[i][5] = 0.0;
|
|
stress[i][6] = 0.0;
|
|
stress[i][7] = 0.0;
|
|
stress[i][8] = 0.0;
|
|
}
|
|
|
|
// include kinetic energy term for each atom in group
|
|
// apply temperature bias is applicable
|
|
// mvv2e converts mv^2 to energy
|
|
|
|
if (keflag) {
|
|
double **v = atom->v;
|
|
double *mass = atom->mass;
|
|
double *rmass = atom->rmass;
|
|
int *type = atom->type;
|
|
double mvv2e = force->mvv2e;
|
|
|
|
if (biasflag == NOBIAS) {
|
|
if (rmass) {
|
|
for (i = 0; i < nlocal; i++)
|
|
if (mask[i] & groupbit) {
|
|
onemass = mvv2e * rmass[i];
|
|
stress[i][0] += onemass * v[i][0] * v[i][0];
|
|
stress[i][1] += onemass * v[i][1] * v[i][1];
|
|
stress[i][2] += onemass * v[i][2] * v[i][2];
|
|
stress[i][3] += onemass * v[i][0] * v[i][1];
|
|
stress[i][4] += onemass * v[i][0] * v[i][2];
|
|
stress[i][5] += onemass * v[i][1] * v[i][2];
|
|
stress[i][6] += onemass * v[i][1] * v[i][0];
|
|
stress[i][7] += onemass * v[i][2] * v[i][0];
|
|
stress[i][8] += onemass * v[i][2] * v[i][1];
|
|
}
|
|
|
|
} else {
|
|
for (i = 0; i < nlocal; i++)
|
|
if (mask[i] & groupbit) {
|
|
onemass = mvv2e * mass[type[i]];
|
|
stress[i][0] += onemass * v[i][0] * v[i][0];
|
|
stress[i][1] += onemass * v[i][1] * v[i][1];
|
|
stress[i][2] += onemass * v[i][2] * v[i][2];
|
|
stress[i][3] += onemass * v[i][0] * v[i][1];
|
|
stress[i][4] += onemass * v[i][0] * v[i][2];
|
|
stress[i][5] += onemass * v[i][1] * v[i][2];
|
|
stress[i][6] += onemass * v[i][1] * v[i][0];
|
|
stress[i][7] += onemass * v[i][2] * v[i][0];
|
|
stress[i][8] += onemass * v[i][2] * v[i][1];
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
// invoke temperature if it hasn't been already
|
|
// this ensures bias factor is pre-computed
|
|
|
|
if (keflag && temperature->invoked_scalar != update->ntimestep) temperature->compute_scalar();
|
|
|
|
if (rmass) {
|
|
for (i = 0; i < nlocal; i++)
|
|
if (mask[i] & groupbit) {
|
|
temperature->remove_bias(i, v[i]);
|
|
onemass = mvv2e * rmass[i];
|
|
stress[i][0] += onemass * v[i][0] * v[i][0];
|
|
stress[i][1] += onemass * v[i][1] * v[i][1];
|
|
stress[i][2] += onemass * v[i][2] * v[i][2];
|
|
stress[i][3] += onemass * v[i][0] * v[i][1];
|
|
stress[i][4] += onemass * v[i][0] * v[i][2];
|
|
stress[i][5] += onemass * v[i][1] * v[i][2];
|
|
stress[i][6] += onemass * v[i][1] * v[i][0];
|
|
stress[i][7] += onemass * v[i][2] * v[i][0];
|
|
stress[i][8] += onemass * v[i][2] * v[i][1];
|
|
temperature->restore_bias(i, v[i]);
|
|
}
|
|
|
|
} else {
|
|
for (i = 0; i < nlocal; i++)
|
|
if (mask[i] & groupbit) {
|
|
temperature->remove_bias(i, v[i]);
|
|
onemass = mvv2e * mass[type[i]];
|
|
stress[i][0] += onemass * v[i][0] * v[i][0];
|
|
stress[i][1] += onemass * v[i][1] * v[i][1];
|
|
stress[i][2] += onemass * v[i][2] * v[i][2];
|
|
stress[i][3] += onemass * v[i][0] * v[i][1];
|
|
stress[i][4] += onemass * v[i][0] * v[i][2];
|
|
stress[i][5] += onemass * v[i][1] * v[i][2];
|
|
stress[i][6] += onemass * v[i][1] * v[i][0];
|
|
stress[i][7] += onemass * v[i][2] * v[i][0];
|
|
stress[i][8] += onemass * v[i][2] * v[i][1];
|
|
temperature->restore_bias(i, v[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert to stress*volume units = -pressure*volume
|
|
|
|
double nktv2p = -force->nktv2p;
|
|
for (i = 0; i < nlocal; i++)
|
|
if (mask[i] & groupbit) {
|
|
stress[i][0] *= nktv2p;
|
|
stress[i][1] *= nktv2p;
|
|
stress[i][2] *= nktv2p;
|
|
stress[i][3] *= nktv2p;
|
|
stress[i][4] *= nktv2p;
|
|
stress[i][5] *= nktv2p;
|
|
stress[i][6] *= nktv2p;
|
|
stress[i][7] *= nktv2p;
|
|
stress[i][8] *= nktv2p;
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
int ComputeCentroidStressAtom::pack_reverse_comm(int n, int first, double *buf)
|
|
{
|
|
int i, m, last;
|
|
|
|
m = 0;
|
|
last = first + n;
|
|
for (i = first; i < last; i++) {
|
|
buf[m++] = stress[i][0];
|
|
buf[m++] = stress[i][1];
|
|
buf[m++] = stress[i][2];
|
|
buf[m++] = stress[i][3];
|
|
buf[m++] = stress[i][4];
|
|
buf[m++] = stress[i][5];
|
|
buf[m++] = stress[i][6];
|
|
buf[m++] = stress[i][7];
|
|
buf[m++] = stress[i][8];
|
|
}
|
|
return m;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
void ComputeCentroidStressAtom::unpack_reverse_comm(int n, int *list, double *buf)
|
|
{
|
|
int i, j, m;
|
|
|
|
m = 0;
|
|
for (i = 0; i < n; i++) {
|
|
j = list[i];
|
|
stress[j][0] += buf[m++];
|
|
stress[j][1] += buf[m++];
|
|
stress[j][2] += buf[m++];
|
|
stress[j][3] += buf[m++];
|
|
stress[j][4] += buf[m++];
|
|
stress[j][5] += buf[m++];
|
|
stress[j][6] += buf[m++];
|
|
stress[j][7] += buf[m++];
|
|
stress[j][8] += buf[m++];
|
|
}
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
memory usage of local atom-based array
|
|
------------------------------------------------------------------------- */
|
|
|
|
double ComputeCentroidStressAtom::memory_usage()
|
|
{
|
|
double bytes = (double) nmax * 9 * sizeof(double);
|
|
return bytes;
|
|
}
|