diff --git a/src/compute_property_local.cpp b/src/compute_property_local.cpp new file mode 100644 index 0000000000..22a2228292 --- /dev/null +++ b/src/compute_property_local.cpp @@ -0,0 +1,671 @@ +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + http://lammps.sandia.gov, Sandia National Laboratories + Steve Plimpton, sjplimp@sandia.gov + + 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 "string.h" +#include "compute_property_local.h" +#include "atom.h" +#include "update.h" +#include "force.h" +#include "domain.h" +#include "memory.h" +#include "error.h" + +using namespace LAMMPS_NS; + +// customize by adding keyword +// same list as in dump_custom.cpp + +enum{ID,MOL,TYPE,MASS, + X,Y,Z,XS,YS,ZS,XSTRI,YSTRI,ZSTRI,XU,YU,ZU,XUTRI,YUTRI,ZUTRI,IX,IY,IZ, + VX,VY,VZ,FX,FY,FZ, + Q,MUX,MUY,MUZ,RADIUS,OMEGAX,OMEGAY,OMEGAZ,ANGMOMX,ANGMOMY,ANGMOMZ, + QUATW,QUATI,QUATJ,QUATK,TQX,TQY,TQZ}; +enum{NONE,BOND,ANGLE,DIHEDRAL,IMPROPER}; + +#define DELTA 10000 + +/* ---------------------------------------------------------------------- */ + +ComputePropertyLocal::ComputePropertyLocal(LAMMPS *lmp, int narg, char **arg) : + Compute(lmp, narg, arg) +{ + if (narg < 4) error->all("Illegal compute property/atom command"); + + local_flag = 1; + nvalues = narg - 3; + if (nvalues == 1) size_local_cols = 0; + else size_local_cols = nvalues; + + pack_choice = new FnPtrPack[nvalues]; + + kindflag = NONE; + + int i; + for (int iarg = 3; iarg < narg; iarg++) { + i = iarg-3; + + if (strcmp(arg[iarg],"batom1") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_batom1; + if (kindflag != NONE && kindflag != BOND) + error->all("Compute property/local cannot use these inputs together"); + kindflag = BOND; + } else if (strcmp(arg[iarg],"batom2") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_batom2; + if (kindflag != NONE && kindflag != BOND) + error->all("Compute property/local cannot use these inputs together"); + kindflag = BOND; + } else if (strcmp(arg[iarg],"btype") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_btype; + if (kindflag != NONE && kindflag != BOND) + error->all("Compute property/local cannot use these inputs together"); + kindflag = BOND; + + } else if (strcmp(arg[iarg],"aatom1") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_aatom1; + if (kindflag != NONE && kindflag != ANGLE) + error->all("Compute property/local cannot use these inputs together"); + kindflag = ANGLE; + } else if (strcmp(arg[iarg],"aatom2") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_aatom2; + if (kindflag != NONE && kindflag != ANGLE) + error->all("Compute property/local cannot use these inputs together"); + kindflag = ANGLE; + } else if (strcmp(arg[iarg],"aatom3") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_aatom3; + if (kindflag != NONE && kindflag != ANGLE) + error->all("Compute property/local cannot use these inputs together"); + kindflag = ANGLE; + } else if (strcmp(arg[iarg],"atype") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_atype; + if (kindflag != NONE && kindflag != ANGLE) + error->all("Compute property/local cannot use these inputs together"); + kindflag = ANGLE; + + } else if (strcmp(arg[iarg],"datom1") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_datom1; + if (kindflag != NONE && kindflag != DIHEDRAL) + error->all("Compute property/local cannot use these inputs together"); + kindflag = DIHEDRAL; + } else if (strcmp(arg[iarg],"datom2") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_datom2; + if (kindflag != NONE && kindflag != DIHEDRAL) + error->all("Compute property/local cannot use these inputs together"); + kindflag = DIHEDRAL; + } else if (strcmp(arg[iarg],"datom3") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_datom3; + if (kindflag != NONE && kindflag != DIHEDRAL) + error->all("Compute property/local cannot use these inputs together"); + kindflag = DIHEDRAL; + } else if (strcmp(arg[iarg],"datom4") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_datom3; + if (kindflag != NONE && kindflag != DIHEDRAL) + error->all("Compute property/local cannot use these inputs together"); + kindflag = DIHEDRAL; + } else if (strcmp(arg[iarg],"dtype") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_dtype; + if (kindflag != NONE && kindflag != DIHEDRAL) + error->all("Compute property/local cannot use these inputs together"); + kindflag = DIHEDRAL; + + } else if (strcmp(arg[iarg],"iatom1") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_iatom1; + if (kindflag != NONE && kindflag != IMPROPER) + error->all("Compute property/local cannot use these inputs together"); + kindflag = IMPROPER; + } else if (strcmp(arg[iarg],"iatom2") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_iatom2; + if (kindflag != NONE && kindflag != IMPROPER) + error->all("Compute property/local cannot use these inputs together"); + kindflag = IMPROPER; + } else if (strcmp(arg[iarg],"iatom3") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_iatom3; + if (kindflag != NONE && kindflag != IMPROPER) + error->all("Compute property/local cannot use these inputs together"); + kindflag = IMPROPER; + } else if (strcmp(arg[iarg],"iatom4") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_iatom3; + if (kindflag != NONE && kindflag != IMPROPER) + error->all("Compute property/local cannot use these inputs together"); + kindflag = IMPROPER; + } else if (strcmp(arg[iarg],"itype") == 0) { + pack_choice[i] = &ComputePropertyLocal::pack_itype; + if (kindflag != NONE && kindflag != IMPROPER) + error->all("Compute property/local cannot use these inputs together"); + kindflag = IMPROPER; + + } else error->all("Invalid keyword in compute property/local command"); + } + + nmax = 0; + vector = NULL; + array = NULL; + indices = NULL; +} + +/* ---------------------------------------------------------------------- */ + +ComputePropertyLocal::~ComputePropertyLocal() +{ + delete [] pack_choice; + memory->sfree(vector); + memory->destroy_2d_double_array(array); + memory->destroy_2d_int_array(indices); +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::init() +{ + // do initial memory allocation so that memory_usage() is correct + + if (kindflag == BOND) ncount = count_bonds(0); + else if (kindflag == ANGLE) ncount = count_angles(0); + else if (kindflag == DIHEDRAL) ncount = count_dihedrals(0); + else if (kindflag == IMPROPER) ncount = count_impropers(0); + + if (ncount > nmax) reallocate(ncount); +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::compute_local() +{ + invoked_local = update->ntimestep; + + // count local entries and generate list of indices + + if (kindflag == BOND) ncount = count_bonds(0); + else if (kindflag == ANGLE) ncount = count_angles(0); + else if (kindflag == DIHEDRAL) ncount = count_dihedrals(0); + else if (kindflag == IMPROPER) ncount = count_impropers(0); + + if (ncount > nmax) reallocate(ncount); + + if (kindflag == BOND) ncount = count_bonds(1); + else if (kindflag == ANGLE) ncount = count_angles(1); + else if (kindflag == DIHEDRAL) ncount = count_dihedrals(1); + else if (kindflag == IMPROPER) ncount = count_impropers(1); + + // fill vector or array with local values + + if (nvalues == 1) { + buf = vector; + (this->*pack_choice[0])(0); + } else { + buf = array[0]; + for (int n = 0; n < nvalues; n++) + (this->*pack_choice[n])(n); + } +} + +/* ---------------------------------------------------------------------- + count bonds on this proc + only count bond once if newton_bond is off + all atoms in interaction must be in group + all atoms in interaction must be known to proc + if bond is deleted (type = 0), do not count + if bond is turned off (type < 0), still count +------------------------------------------------------------------------- */ + +int ComputePropertyLocal::count_bonds(int flag) +{ + int *num_bond = atom->num_bond; + int **bond_atom = atom->bond_atom; + int **bond_type = atom->bond_type; + int *tag = atom->tag; + int *mask = atom->mask; + int nlocal = atom->nlocal; + int newton_bond = force->newton_bond; + + int i,atom1,atom2; + + int m = 0; + for (atom1 = 0; atom1 < nlocal; atom1++) { + if (!(mask[atom1] & groupbit)) continue; + for (i = 0; i < num_bond[atom1]; i++) { + atom2 = atom->map(bond_atom[atom1][i]); + if (atom2 < 0 || !(mask[atom2] & groupbit)) continue; + if (newton_bond == 0 && tag[atom1] > tag[atom2]) continue; + if (bond_type[atom1][i] == 0) continue; + + if (flag) { + indices[m][0] = atom1; + indices[m][1] = i; + } + m++; + } + } + return m; +} + +/* ---------------------------------------------------------------------- + count angles on this proc + only count if 2nd atom is the one storing the angle + all atoms in interaction must be in group + all atoms in interaction must be known to proc +------------------------------------------------------------------------- */ + +int ComputePropertyLocal::count_angles(int flag) +{ + int *num_angle = atom->num_angle; + int **angle_atom1 = atom->angle_atom1; + int **angle_atom2 = atom->angle_atom2; + int **angle_atom3 = atom->angle_atom3; + int **angle_type = atom->angle_type; + int *tag = atom->tag; + int *mask = atom->mask; + int nlocal = atom->nlocal; + + int i,atom1,atom2,atom3; + + int m = 0; + for (atom2 = 0; atom2 < nlocal; atom2++) { + if (!(mask[atom2] & groupbit)) continue; + for (i = 0; i < num_angle[atom2]; i++) { + if (tag[atom2] != angle_atom2[atom2][i]) continue; + atom1 = atom->map(angle_atom1[atom2][i]); + if (atom1 < 0 || !(mask[atom1] & groupbit)) continue; + atom3 = atom->map(angle_atom3[atom2][i]); + if (atom3 < 0 || !(mask[atom3] & groupbit)) continue; + + if (flag) { + indices[m][0] = atom2; + indices[m][1] = i; + } + m++; + } + } + return m; +} + +/* ---------------------------------------------------------------------- + count dihedrals on this proc + only count if 2nd atom is the one storing the dihedral + all atoms in interaction must be in group + all atoms in interaction must be known to proc +------------------------------------------------------------------------- */ + +int ComputePropertyLocal::count_dihedrals(int flag) +{ + int *num_dihedral = atom->num_dihedral; + int **dihedral_atom1 = atom->dihedral_atom1; + int **dihedral_atom2 = atom->dihedral_atom2; + int **dihedral_atom3 = atom->dihedral_atom3; + int **dihedral_atom4 = atom->dihedral_atom4; + int **dihedral_type = atom->dihedral_type; + int *tag = atom->tag; + int *mask = atom->mask; + int nlocal = atom->nlocal; + + int i,atom1,atom2,atom3,atom4; + + int m = 0; + for (atom2 = 0; atom2 < nlocal; atom2++) { + if (!(mask[atom2] & groupbit)) continue; + for (i = 0; i < num_dihedral[atom2]; i++) { + if (tag[atom2] != dihedral_atom2[atom2][i]) continue; + atom1 = atom->map(dihedral_atom1[atom2][i]); + if (atom1 < 0 || !(mask[atom1] & groupbit)) continue; + atom3 = atom->map(dihedral_atom3[atom2][i]); + if (atom3 < 0 || !(mask[atom3] & groupbit)) continue; + atom4 = atom->map(dihedral_atom4[atom2][i]); + if (atom4 < 0 || !(mask[atom4] & groupbit)) continue; + + if (flag) { + indices[m][0] = atom2; + indices[m][1] = i; + } + m++; + } + } + return m; +} + +/* ---------------------------------------------------------------------- + count impropers on this proc + only count if 2nd atom is the one storing the improper + all atoms in interaction must be in group + all atoms in interaction must be known to proc +------------------------------------------------------------------------- */ + +int ComputePropertyLocal::count_impropers(int flag) +{ + int *num_improper = atom->num_improper; + int **improper_atom1 = atom->improper_atom1; + int **improper_atom2 = atom->improper_atom2; + int **improper_atom3 = atom->improper_atom3; + int **improper_atom4 = atom->improper_atom4; + int **improper_type = atom->improper_type; + int *tag = atom->tag; + int *mask = atom->mask; + int nlocal = atom->nlocal; + + int i,atom1,atom2,atom3,atom4; + + int m = 0; + for (atom2 = 0; atom2 < nlocal; atom2++) { + if (!(mask[atom2] & groupbit)) continue; + for (i = 0; i < num_improper[atom2]; i++) { + if (tag[atom2] != improper_atom2[atom2][i]) continue; + atom1 = atom->map(improper_atom1[atom2][i]); + if (atom1 < 0 || !(mask[atom1] & groupbit)) continue; + atom3 = atom->map(improper_atom3[atom2][i]); + if (atom3 < 0 || !(mask[atom3] & groupbit)) continue; + atom4 = atom->map(improper_atom4[atom2][i]); + if (atom4 < 0 || !(mask[atom4] & groupbit)) continue; + + if (flag) { + indices[m][0] = atom2; + indices[m][1] = i; + } + m++; + } + } + return m; +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::reallocate(int n) +{ + // grow vector or array and indices array + + size_local_rows = n; + + while (nmax < n) nmax += DELTA; + if (nvalues == 1) { + memory->sfree(vector); + vector = (double *) memory->smalloc(nmax*sizeof(double), + "property/local:vector"); + vector_local = vector; + } else { + memory->destroy_2d_double_array(array); + array = memory->create_2d_double_array(nmax,nvalues, + "property/local:array"); + array_local = array; + } + + memory->destroy_2d_int_array(indices); + indices = memory->create_2d_int_array(nmax,2,"property/local:indices"); +} + +/* ---------------------------------------------------------------------- + memory usage of local data +------------------------------------------------------------------------- */ + +double ComputePropertyLocal::memory_usage() +{ + double bytes = nmax*nvalues * sizeof(double); + bytes += nmax*2 * sizeof(int); + return bytes; +} + +/* ---------------------------------------------------------------------- + one method for every keyword compute property/local can output + the atom property is packed into buf starting at n with stride nvalues + customize a new keyword by adding a method +------------------------------------------------------------------------- */ + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_batom1(int n) +{ + int i; + int *tag = atom->tag; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + buf[n] = tag[i]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_batom2(int n) +{ + int i,j; + int **bond_atom = atom->bond_atom; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = bond_atom[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_btype(int n) +{ + int i,j; + int **bond_type = atom->bond_type; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = bond_type[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_aatom1(int n) +{ + int i,j; + int **angle_atom1 = atom->angle_atom1; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = angle_atom1[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_aatom2(int n) +{ + int i,j; + int **angle_atom2 = atom->angle_atom2; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = angle_atom2[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_aatom3(int n) +{ + int i,j; + int **angle_atom3 = atom->angle_atom3; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = angle_atom3[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_atype(int n) +{ + int i,j; + int **angle_type = atom->angle_type; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = angle_type[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_datom1(int n) +{ + int i,j; + int **dihedral_atom1 = atom->dihedral_atom1; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = dihedral_atom1[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_datom2(int n) +{ + int i,j; + int **dihedral_atom2 = atom->dihedral_atom2; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = dihedral_atom2[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_datom3(int n) +{ + int i,j; + int **dihedral_atom3 = atom->dihedral_atom3; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = dihedral_atom3[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_datom4(int n) +{ + int i,j; + int **dihedral_atom4 = atom->dihedral_atom4; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = dihedral_atom4[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_dtype(int n) +{ + int i,j; + int **dihedral_type = atom->dihedral_type; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = dihedral_type[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_iatom1(int n) +{ + int i,j; + int **improper_atom1 = atom->improper_atom1; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = improper_atom1[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_iatom2(int n) +{ + int i,j; + int **improper_atom2 = atom->improper_atom2; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = improper_atom2[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_iatom3(int n) +{ + int i,j; + int **improper_atom3 = atom->improper_atom3; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = improper_atom3[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_iatom4(int n) +{ + int i,j; + int **improper_atom4 = atom->improper_atom4; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = improper_atom4[i][j]; + n += nvalues; + } +} + +/* ---------------------------------------------------------------------- */ + +void ComputePropertyLocal::pack_itype(int n) +{ + int i,j; + int **improper_type = atom->improper_type; + + for (int m = 0; m < ncount; m++) { + i = indices[m][0]; + j = indices[m][1]; + buf[n] = improper_type[i][j]; + n += nvalues; + } +} diff --git a/src/compute_property_local.h b/src/compute_property_local.h new file mode 100644 index 0000000000..634a1cec35 --- /dev/null +++ b/src/compute_property_local.h @@ -0,0 +1,73 @@ +/* ---------------------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + http://lammps.sandia.gov, Sandia National Laboratories + Steve Plimpton, sjplimp@sandia.gov + + 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. +------------------------------------------------------------------------- */ + +#ifndef COMPUTE_PROPERTY_LOCAL_H +#define COMPUTE_PROPERTY_LOCAL_H + +#include "compute.h" + +namespace LAMMPS_NS { + +class ComputePropertyLocal : public Compute { + public: + ComputePropertyLocal(class LAMMPS *, int, char **); + ~ComputePropertyLocal(); + void init(); + void compute_local(); + double memory_usage(); + + private: + int nvalues,kindflag; + + int nmax; + double *vector; + double **array; + double *buf; + + int ncount; + int **indices; + + int count_bonds(int); + int count_angles(int); + int count_dihedrals(int); + int count_impropers(int); + void reallocate(int); + + typedef void (ComputePropertyLocal::*FnPtrPack)(int); + FnPtrPack *pack_choice; // ptrs to pack functions + + void pack_batom1(int); + void pack_batom2(int); + void pack_btype(int); + + void pack_aatom1(int); + void pack_aatom2(int); + void pack_aatom3(int); + void pack_atype(int); + + void pack_datom1(int); + void pack_datom2(int); + void pack_datom3(int); + void pack_datom4(int); + void pack_dtype(int); + + void pack_iatom1(int); + void pack_iatom2(int); + void pack_iatom3(int); + void pack_iatom4(int); + void pack_itype(int); +}; + +} + +#endif diff --git a/src/dump_custom.cpp b/src/dump_custom.cpp index a079d8d76f..a8afb023e6 100644 --- a/src/dump_custom.cpp +++ b/src/dump_custom.cpp @@ -31,7 +31,7 @@ using namespace LAMMPS_NS; // customize by adding keyword -// same as in compute_property.cpp, also customize that command +// same list as in compute_property.cpp, also customize that command enum{ID,MOL,TYPE,MASS, X,Y,Z,XS,YS,ZS,XSTRI,YSTRI,ZSTRI,XU,YU,ZU,XUTRI,YUTRI,ZUTRI,IX,IY,IZ, diff --git a/src/style.h b/src/style.h index fb7ced7e8e..c30212c9aa 100644 --- a/src/style.h +++ b/src/style.h @@ -95,6 +95,7 @@ CommandStyle(write_restart,WriteRestart) #include "compute_reduce_region.h" #include "compute_erotate_sphere.h" #include "compute_property_atom.h" +#include "compute_property_local.h" #include "compute_stress_atom.h" #include "compute_temp.h" #include "compute_temp_com.h" @@ -126,6 +127,7 @@ ComputeStyle(reduce,ComputeReduce) ComputeStyle(reduce/region,ComputeReduceRegion) ComputeStyle(erotate/sphere,ComputeERotateSphere) ComputeStyle(property/atom,ComputePropertyAtom) +ComputeStyle(property/local,ComputePropertyLocal) ComputeStyle(stress/atom,ComputeStressAtom) ComputeStyle(temp,ComputeTemp) ComputeStyle(temp/com,ComputeTempCOM)