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

more work on dump image

Browse Source
This commit is contained in:
Steve Plimpton
2022-11-22 16:40:39 -07:00
parent 3683f144a6
commit 9ab4c65f31
6 changed files with 300 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
src/dump_grid.cpp
View File

@ -77,6 +77,10 @@ DumpGrid::DumpGrid(LAMMPS *lmp, int narg, char **arg) :
dimension = domain->dimension; dimension = domain->dimension;
// for 2d, set nzgrid = 1 for dump grid and grid/vtk files
if (dimension == 2) nzgrid = 1;
// computes and fixes which the dump accesses // computes and fixes which the dump accesses
ncompute = 0; ncompute = 0;
@ -269,9 +273,9 @@ void DumpGrid::init_style()
int nxtmp,nytmp,nztmp; int nxtmp,nytmp,nztmp;
for (int i = 0; i < nfield; i++) { for (int i = 0; i < nfield; i++) {
if (dimension == 2) { if (dimension == 2) {
if (field2source[i] == COMPUTE) if (field2source[i] == COMPUTE)
grid2d = (Grid2d *) compute[field2index[i]]->get_grid_by_index(field2grid[i]); grid2d = (Grid2d *) compute[field2index[i]]->get_grid_by_index(field2grid[i]);
else else
grid2d = (Grid2d *) fix[field2index[i]]->get_grid_by_index(field2grid[i]); grid2d = (Grid2d *) fix[field2index[i]]->get_grid_by_index(field2grid[i]);
if (i == 0) grid2d->get_size(nxgrid,nygrid); if (i == 0) grid2d->get_size(nxgrid,nygrid);
else { else {
@ -651,146 +655,40 @@ int DumpGrid::parse_fields(int narg, char **arg)
char *id; char *id;
int igrid,idata,index; int igrid,idata,index;
int iflag = int iflag =
utils::check_grid_reference((char *) "Dump grid", utils::check_grid_reference((char *) "Dump grid",
arg[iarg],igrid,idata,index,lmp); arg[iarg],nevery,id,igrid,idata,index,lmp);
// arg is not a Grid reference // arg is not a valid Grid reference
// assume it's an additional dump grid option and return
if (iflag < 0) return iarg; if (iflag < 0) return iarg;
// grid reference is to a compute // grid reference is to a compute or fix
if (iflag == ArgInfo::COMPUTE) { if (iflag == ArgInfo::COMPUTE) {
auto icompute = lmp->modify->get_compute_by_id(id);
field2index[iarg] = add_compute(id,icompute);
// grid reference is to a fix field2source[iarg] = COMPUTE;
} else if (iflag == ArgInfo::FIX) { } else if (iflag == ArgInfo::FIX) {
auto ifix = modify->get_fix_by_id(id);
field2index[iarg] = add_fix(id,ifix);
field2source[iarg] = FIX;
} }
delete [] id;
argindex[iarg] = index;
vtype[iarg] = Dump::DOUBLE;
field2grid[iarg] = igrid;
field2data[iarg] = idata;
if (dimension == 2) pack_choice[iarg] = &DumpGrid::pack_grid2d;
else pack_choice[iarg] = &DumpGrid::pack_grid3d;
} }
return narg; return narg;
} }
/*
ArgInfo argi(arg[iarg], ArgInfo::COMPUTE | ArgInfo::FIX);
argindex[iarg] = argi.get_index1();
auto name = argi.get_name();
switch (argi.get_type()) {
case ArgInfo::UNKNOWN: {
error->all(FLERR,"Invalid attribute in dump grid command");
} break;
// compute value = c_ID
// if no trailing [], then arg is set to 0, else arg is int between []
case ArgInfo::COMPUTE: {
if (dimension == 2) pack_choice[iarg] = &DumpGrid::pack_grid2d;
else pack_choice[iarg] = &DumpGrid::pack_grid3d;
vtype[iarg] = Dump::DOUBLE;
field2source[iarg] = COMPUTE;
// split name = idcompute:gname:dname into 3 strings
auto words = utils::parse_gridid(FLERR,name,error);
const auto &idcompute = words[0];
const auto &gname = words[1];
const auto &dname = words[2];
auto icompute = modify->get_compute_by_id(idcompute);
if (!icompute) error->all(FLERR,"Could not find dump grid compute ID: {}",idcompute);
if (icompute->pergrid_flag == 0)
error->all(FLERR,"Dump grid compute {} does not compute per-grid info",idcompute);
int dim;
int igrid = icompute->get_grid_by_name(gname,dim);
if (igrid < 0)
error->all(FLERR,"Dump grid compute {} does not recognize grid name {}",idcompute,gname);
int ncol;
int idata = icompute->get_griddata_by_name(igrid,dname,ncol);
if (idata < 0)
error->all(FLERR,"Dump grid compute {} does not recognize data name {}",idcompute,dname);
if (argi.get_dim() == 0 && ncol)
error->all(FLERR,"Dump grid compute {} data {} is not per-grid vector",idcompute,dname);
if (argi.get_dim() && ncol == 0)
error->all(FLERR,"Dump grid compute {} data {} is not per-grid array",idcompute,dname);
if (argi.get_dim() && argi.get_index1() > ncol)
error->all(FLERR,"Dump grid compute {} array {} is accessed out-of-range",idcompute,dname);
field2index[iarg] = add_compute(idcompute,icompute);
field2grid[iarg] = igrid;
field2data[iarg] = idata;
} break;
// fix value = f_ID
// if no trailing [], then arg is set to 0, else arg is between []
case ArgInfo::FIX: {
if (dimension == 2) pack_choice[iarg] = &DumpGrid::pack_grid2d;
else pack_choice[iarg] = &DumpGrid::pack_grid3d;
vtype[iarg] = Dump::DOUBLE;
field2source[iarg] = FIX;
// split name = idfix:gname:dname into 3 strings
auto words = utils::parse_gridid(FLERR,name,error);
const auto &idfix = words[0];
const auto &gname = words[1];
const auto &dname = words[2];
auto ifix = modify->get_fix_by_id(idfix);
if (!ifix) error->all(FLERR,"Could not find dump grid fix ID: {}",idfix);
if (ifix->pergrid_flag == 0)
error->all(FLERR,"Dump grid fix {} does not compute per-grid info",idfix);
if (nevery % ifix->pergrid_freq)
error->all(FLERR,"Fix ID {} for dump grid not computed at compatible time",idfix);
int dim;
int igrid = ifix->get_grid_by_name(gname,dim);
if (igrid < 0)
error->all(FLERR,"Dump grid fix {} does not recognize grid name {}",idfix,gname);
int ncol;
int idata = ifix->get_griddata_by_name(igrid,dname,ncol);
if (idata < 0)
error->all(FLERR,"Dump grid fix {} does not recognize data name {}",idfix,dname);
if (argi.get_dim() == 0 && ncol)
error->all(FLERR,"Dump grid fix {} data {} is not per-grid vector",idfix,dname);
if (argi.get_dim() > 0 && ncol == 0)
error->all(FLERR,"Dump grid fix {} data {} is not per-grid array",idfix,dname);
if (argi.get_dim() > 0 && argi.get_index1() > ncol)
error->all(FLERR,"Dump grid fix {} array {} is accessed out-of-range",idfix,dname);
field2index[iarg] = add_fix(idfix,ifix);
field2grid[iarg] = igrid;
field2data[iarg] = idata;
} break;
// no match
default: {
return iarg;
} break;
}
}
return narg;
}
*/
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
add Compute to list of Compute objects used by dump add Compute to list of Compute objects used by dump
return index of where this Compute is in list return index of where this Compute is in list

247
src/dump_image.cpp
View File

@ -14,6 +14,7 @@
#include "dump_image.h" #include "dump_image.h"
#include "arg_info.h"
#include "atom.h" #include "atom.h"
#include "atom_vec.h" #include "atom_vec.h"
#include "atom_vec_body.h" #include "atom_vec_body.h"
@ -124,6 +125,8 @@ DumpImage::DumpImage(LAMMPS *lmp, int narg, char **arg) :
atomflag = YES; atomflag = YES;
gridflag = NO; gridflag = NO;
lineflag = triflag = bodyflag = fixflag = NO; lineflag = triflag = bodyflag = fixflag = NO;
id_grid_compute = id_grid_fix = nullptr;
if (atom->nbondtypes == 0) bondflag = NO; if (atom->nbondtypes == 0) bondflag = NO;
else { else {
bondflag = YES; bondflag = YES;
@ -188,8 +191,16 @@ DumpImage::DumpImage(LAMMPS *lmp, int narg, char **arg) :
int igrid,idata,index; int igrid,idata,index;
int iflag = int iflag =
utils::check_grid_reference((char *) "Dump image", utils::check_grid_reference((char *) "Dump image",
arg[iarg+1],igrid,idata,index,lmp); arg[iarg+1],nevery,id,
igrid,idata,index,lmp);
if (iflag < 0) error->all(FLERR,"Invalid grid reference in dump image command");
if (iflag == ArgInfo::COMPUTE) id_grid_compute = utils::strdup(id);
else if (iflag == ArgInfo::FIX) id_grid_fix = utils::strdup(id);
delete [] id;
grid_igrid = igrid;
grid_idata = idata;
grid_index = index;
iarg += 2; iarg += 2;
} else if (strcmp(arg[iarg],"line") == 0) { } else if (strcmp(arg[iarg],"line") == 0) {
@ -432,6 +443,9 @@ DumpImage::DumpImage(LAMMPS *lmp, int narg, char **arg) :
maxbufcopy = 0; maxbufcopy = 0;
chooseghost = nullptr; chooseghost = nullptr;
bufcopy = nullptr; bufcopy = nullptr;
maxgrid = 0;
gbuf = nullptr;
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -448,6 +462,7 @@ DumpImage::~DumpImage()
delete [] bcolortype; delete [] bcolortype;
memory->destroy(chooseghost); memory->destroy(chooseghost);
memory->destroy(bufcopy); memory->destroy(bufcopy);
memory->destroy(gbuf);
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -609,21 +624,33 @@ void DumpImage::write()
} }
// pack grid gbuf with grid cell values // pack grid gbuf with grid cell values
// ngrid_mine = # of grid cells this proc owns // ngrid = # of grid cells this proc owns
if (gridflag) { if (gridflag) {
if (domain->dimension == 2) { if (domain->dimension == 2) {
if (grid_compute) if (grid_compute)
grid2d = (Grid2d *) grid_compute->get_grid_by_index(grid_index); grid2d = (Grid2d *) grid_compute->get_grid_by_index(grid_igrid);
else if (grid_fix) else if (grid_fix)
grid2d = (Grid2d *) grid_fix->get_grid_by_index(grid_index); grid2d = (Grid2d *) grid_fix->get_grid_by_index(grid_igrid);
grid2d->get_size(nxgrid,nygrid);
grid2d->get_bounds_owned(nxlo_in,nxhi_in,nylo_in,nyhi_in); grid2d->get_bounds_owned(nxlo_in,nxhi_in,nylo_in,nyhi_in);
ngrid = (nxhi_in-nxlo_in+1) * (nyhi_in-nylo_in+1);
} else { } else {
if (grid_compute) if (grid_compute)
grid3d = (Grid3d *) grid_compute->get_grid_by_index(grid_index); grid3d = (Grid3d *) grid_compute->get_grid_by_index(grid_igrid);
else if (grid_fix) else if (grid_fix)
grid3d = (Grid3d *) grid_fix->get_grid_by_index(grid_index); grid3d = (Grid3d *) grid_fix->get_grid_by_index(grid_igrid);
grid3d->get_size(nxgrid,nygrid,nzgrid);
grid3d->get_bounds_owned(nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in); grid3d->get_bounds_owned(nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in);
ngrid = (nxhi_in-nxlo_in+1) * (nyhi_in-nylo_in+1) * (nzhi_in-nzlo_in+1);
}
// insure gbuf is large enough
if (ngrid > maxgrid) {
memory->destroy(gbuf);
maxgrid = ngrid;
memory->create(gbuf,maxgrid,"dump/image:gbuf");
} }
// invoke Compute for per-grid quantities // invoke Compute for per-grid quantities
@ -646,37 +673,65 @@ void DumpImage::write()
// access grid data and load gbuf // access grid data and load gbuf
/* if (domain->dimension == 2) {
if (index == 0) { if (grid_index == 0) {
double **vec2d; double **vec2d;
if (field2source[n] == COMPUTE) if (grid_compute)
vec2d = (double **) vec2d = (double **)
compute[field2index[n]]->get_griddata_by_index(field2data[n]); grid_compute->get_griddata_by_index(grid_idata);
else if (field2source[n] == FIX) else if (grid_fix)
vec2d = (double **) vec2d = (double **)
fix[field2index[n]]->get_griddata_by_index(field2data[n]); grid_fix->get_griddata_by_index(grid_idata);
for (int iy = nylo_in; iy <= nyhi_in; iy++) int n = 0;
for (int ix = nxlo_in; ix <= nxhi_in; ix++) { for (int iy = nylo_in; iy <= nyhi_in; iy++)
buf[n] = vec2d[iy][ix]; for (int ix = nxlo_in; ix <= nxhi_in; ix++)
n += size_one; gbuf[n++] = vec2d[iy][ix];
} else {
double ***array2d;
if (grid_compute)
array2d = (double ***)
grid_compute->get_griddata_by_index(grid_idata);
else if (grid_fix)
array2d = (double ***)
grid_fix->get_griddata_by_index(grid_idata);
int index = grid_index - 1;
int n = 0;
for (int iy = nylo_in; iy <= nyhi_in; iy++)
for (int ix = nxlo_in; ix <= nxhi_in; ix++)
gbuf[n++] = array2d[iy][ix][index];
}
} else if (domain->dimension == 3) {
if (grid_index == 0) {
double ***vec3d;
if (grid_compute)
vec3d = (double ***)
grid_compute->get_griddata_by_index(grid_idata);
else if (grid_fix)
vec3d = (double ***)
grid_fix->get_griddata_by_index(grid_idata);
int n = 0;
for (int iz = nzlo_in; iz <= nzhi_in; iz++)
for (int iy = nylo_in; iy <= nyhi_in; iy++)
for (int ix = nxlo_in; ix <= nxhi_in; ix++)
gbuf[n++] = vec3d[iz][iy][ix];
} }
} else { } else {
double ***array2d; double ****array3d;
if (field2source[n] == COMPUTE) if (grid_compute)
array2d = (double ***) array3d = (double ****)
compute[field2index[n]]->get_griddata_by_index(field2data[n]); grid_compute->get_griddata_by_index(grid_idata);
else if (field2source[n] == FIX) else if (grid_fix)
array2d = (double ***) array3d = (double ****)
fix[field2index[n]]->get_griddata_by_index(field2data[n]); grid_fix->get_griddata_by_index(grid_idata);
index--; int index = grid_index - 1;
for (int iy = nylo_in; iy <= nyhi_in; iy++) int n = 0;
for (int ix = nxlo_in; ix <= nxhi_in; ix++) { for (int iz = nzlo_in; iz <= nzhi_in; iz++)
buf[n] = array2d[iy][ix][index]; for (int iy = nylo_in; iy <= nyhi_in; iy++)
n += size_one; for (int ix = nxlo_in; ix <= nxhi_in; ix++)
} gbuf[n++] = array3d[iz][iy][ix][index];
} }
*/
} }
// set minmax color range if using dynamic grid color map // set minmax color range if using dynamic grid color map
@ -685,7 +740,7 @@ void DumpImage::write()
double two[2],twoall[2]; double two[2],twoall[2];
double lo = BIG; double lo = BIG;
double hi = -BIG; double hi = -BIG;
for (int i = 0; i < ngrid_owned; i++) { for (int i = 0; i < ngrid; i++) {
lo = MIN(lo,gbuf[i]); lo = MIN(lo,gbuf[i]);
hi = MAX(hi,gbuf[i]); hi = MAX(hi,gbuf[i]);
} }
@ -861,13 +916,46 @@ void DumpImage::create_image()
} }
// render my grid cells // render my grid cells
// 2 triangles for 2d rectangle, 12 triangles for 3d cube surface
// grid_cell_corners_2d/3d calculates orthogonal vs triclinic corner pts
// for 3d, outward normals on all 6 faces
if (gridflag) { if (gridflag) {
int n = 0;
if (domain->dimension == 2) {
// draw 2 or 12 triangles for (int iy = nylo_in; iy <= nyhi_in; iy++)
//image->draw_triangle(x,y,z,color); for (int ix = nxlo_in; ix <= nxhi_in; ix++) {
grid_cell_corners_2d(ix,iy);
color = image->map_value2color(1,gbuf[n++]);
image->draw_triangle(gcorners[0],gcorners[1],gcorners[3],color);
image->draw_triangle(gcorners[0],gcorners[3],gcorners[2],color);
}
} else {
for (int iz = nzlo_in; iz <= nzhi_in; iz++)
for (int iy = nylo_in; iy <= nyhi_in; iy++)
for (int ix = nxlo_in; ix <= nxhi_in; ix++) {
grid_cell_corners_3d(ix,iy,iz);
color = image->map_value2color(1,gbuf[n++]);
// lower x face
image->draw_triangle(gcorners[0],gcorners[4],gcorners[6],color);
image->draw_triangle(gcorners[0],gcorners[6],gcorners[2],color);
// upper x face
image->draw_triangle(gcorners[1],gcorners[5],gcorners[7],color);
image->draw_triangle(gcorners[1],gcorners[7],gcorners[3],color);
// lower y face
image->draw_triangle(gcorners[0],gcorners[1],gcorners[5],color);
image->draw_triangle(gcorners[0],gcorners[5],gcorners[4],color);
// upper y face
image->draw_triangle(gcorners[2],gcorners[6],gcorners[7],color);
image->draw_triangle(gcorners[2],gcorners[7],gcorners[3],color);
// lower z face
image->draw_triangle(gcorners[0],gcorners[2],gcorners[3],color);
image->draw_triangle(gcorners[0],gcorners[3],gcorners[1],color);
// upper z face
image->draw_triangle(gcorners[4],gcorners[5],gcorners[7],color);
image->draw_triangle(gcorners[4],gcorners[7],gcorners[6],color);
}
}
} }
// render atoms that are lines // render atoms that are lines
@ -1266,6 +1354,83 @@ void DumpImage::create_image()
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
void DumpImage::grid_cell_corners_2d(int ix, int iy)
{
double *boxlo = domain->boxlo;
double *prd = domain->prd;
if (!domain->triclinic) {
double xdelta = prd[0] / nxgrid;
double ydelta = prd[1] / nygrid;
int n = 0;
for (int y = 0; y < 2; y++)
for (int x = 0; x < 2; x++) {
gcorners[n][0] = boxlo[0] + (ix+x) * xdelta;
gcorners[n][1] = boxlo[1] + (iy+y) * ydelta;
n++;
}
} else {
double lamda[3],xone[3];
lamda[2] = 0.0;
double dx = 1.0 / nxgrid;
double dy = 1.0 / nygrid;
int n = 0;
for (int y = 0; y < 2; y++)
for (int x = 0; x < 2; x++) {
lamda[0] = (ix+x) * dx;
lamda[1] = (iy+y) * dy;
domain->lamda2x(lamda,gcorners[n++]);
}
}
}
/* ---------------------------------------------------------------------- */
void DumpImage::grid_cell_corners_3d(int ix, int iy, int iz)
{
double *boxlo = domain->boxlo;
double *prd = domain->prd;
if (!domain->triclinic) {
double xdelta = prd[0] / nxgrid;
double ydelta = prd[1] / nygrid;
double zdelta = prd[2] / nzgrid;
int n = 0;
for (int z = 0; z < 2; z++)
for (int y = 0; y < 2; y++)
for (int x = 0; x < 2; x++) {
gcorners[n][0] = boxlo[0] + (ix+x) * xdelta;
gcorners[n][1] = boxlo[1] + (iy+y) * ydelta;
gcorners[n][2] = boxlo[2] + (iz+z) * zdelta;
n++;
}
} else {
double lamda[3],xone[3];
double dx = 1.0 / nxgrid;
double dy = 1.0 / nygrid;
double dz = 1.0 / nzgrid;
int n = 0;
for (int z = 0; z < 2; z++)
for (int y = 0; y < 2; y++)
for (int x = 0; x < 2; x++) {
lamda[0] = (ix+x) * dx;
lamda[1] = (iy+y) * dy;
lamda[2] = (iz+z) * dz;
domain->lamda2x(lamda,gcorners[n++]);
}
}
}
/* ---------------------------------------------------------------------- */
int DumpImage::pack_forward_comm(int n, int *list, double *buf, int DumpImage::pack_forward_comm(int n, int *list, double *buf,
int /*pbc_flag*/, int * /*pbc*/) int /*pbc_flag*/, int * /*pbc*/)
{ {

10
src/dump_image.h
View File

@ -85,10 +85,12 @@ class DumpImage : public DumpCustom {
char *id_grid_compute,*id_grid_fix; char *id_grid_compute,*id_grid_fix;
class Compute *grid_compute; class Compute *grid_compute;
class Fix *grid_fix; class Fix *grid_fix;
int grid_index; int grid_igrid,grid_idata,grid_index;
double *gbuf; int nxgrid,nygrid,nzgrid;
int nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in; int nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in;
int ngrid_owned; double *gbuf;
int ngrid,maxgrid;
double gcorners[8][3];
class AtomVecLine *avec_line; // ptrs to atom style (sub)classes class AtomVecLine *avec_line; // ptrs to atom style (sub)classes
class AtomVecTri *avec_tri; class AtomVecTri *avec_tri;
@ -111,6 +113,8 @@ class DumpImage : public DumpCustom {
void box_bounds(); void box_bounds();
void create_image(); void create_image();
void grid_cell_corners_2d(int, int);
void grid_cell_corners_3d(int, int, int);
}; };
} // namespace LAMMPS_NS } // namespace LAMMPS_NS

131
src/fix_ave_grid.cpp
View File

@ -59,6 +59,11 @@ FixAveGrid::FixAveGrid(LAMMPS *lmp, int narg, char **arg) :
pergrid_freq = utils::inumeric(FLERR,arg[5],false,lmp); pergrid_freq = utils::inumeric(FLERR,arg[5],false,lmp);
time_depend = 1; time_depend = 1;
if (nevery <= 0 || nrepeat <= 0 || pergrid_freq <= 0)
error->all(FLERR,"Illegal fix ave/grid command");
if (pergrid_freq % nevery || nrepeat*nevery > pergrid_freq)
error->all(FLERR,"Illegal fix ave/grid command");
// NOTE: allow Dxyz as well at some point ? // NOTE: allow Dxyz as well at some point ?
nxgrid = utils::inumeric(FLERR,arg[6],false,lmp); nxgrid = utils::inumeric(FLERR,arg[6],false,lmp);
@ -135,21 +140,38 @@ FixAveGrid::FixAveGrid(LAMMPS *lmp, int narg, char **arg) :
modeatom = 1; modeatom = 1;
} else { } else {
// if arg is not a per-atom or per-grid value
// then it's an optional arg after the values
ArgInfo argi(arg[iarg]); ArgInfo argi(arg[iarg]);
if (argi.get_type() == ArgInfo::NONE || argi.get_type() == ArgInfo::UNKNOWN) break;
if (argi.get_dim() > 1) error->all(FLERR,"Invalid fix ave/grid command");
if (argi.get_type() == ArgInfo::NONE) break; // atom value has no colon
if ((argi.get_type() == ArgInfo::UNKNOWN) || (argi.get_dim() > 1))
error->all(FLERR,"Invalid fix ave/grid command");
which[nvalues] = argi.get_type(); if (!strchr(arg[iarg],':')) {
argindex[nvalues] = argi.get_index1(); modeatom = 1;
ids[nvalues] = argi.copy_name(); ids[nvalues] = argi.copy_name();
which[nvalues] = argi.get_type();
argindex[nvalues] = argi.get_index1();
if (strchr(ids[nvalues],':')) modegrid = 1; // per-grid value has colons
else modeatom = 1;
if (modegrid && which[nvalues] == ArgInfo::VARIABLE) } else {
error->all(FLERR,"Fix ave/grid cannot use variable for grid info"); modegrid = 1;
int igrid,idata,index;
int iflag =
utils::check_grid_reference((char *) "Fix ave/grid",
arg[iarg],nevery,ids[nvalues],igrid,idata,index,lmp);
if (iflag < 0) error->all(FLERR,"Invalid grid reference in fix ave/grid command");
which[nvalues] = iflag;
value2grid[nvalues] = igrid;
value2data[nvalues] = idata;
argindex[nvalues] = index;
}
} }
nvalues++; nvalues++;
@ -231,16 +253,11 @@ FixAveGrid::FixAveGrid(LAMMPS *lmp, int narg, char **arg) :
memory->sfree(earg); memory->sfree(earg);
} }
// setup and error check // more error checks
// for fix inputs, check that fix frequency is acceptable // for fix inputs, check that fix frequency is acceptable
dimension = domain->dimension; dimension = domain->dimension;
if (nevery <= 0 || nrepeat <= 0 || pergrid_freq <= 0)
error->all(FLERR,"Illegal fix ave/grid command");
if (pergrid_freq % nevery || nrepeat*nevery > pergrid_freq)
error->all(FLERR,"Illegal fix ave/grid command");
if (nxgrid < 1 || nygrid < 1 || nzgrid < 1) if (nxgrid < 1 || nygrid < 1 || nzgrid < 1)
error->all(FLERR,"Invalid fix ave/grid grid size"); error->all(FLERR,"Invalid fix ave/grid grid size");
if (dimension == 2 && nzgrid != 1) if (dimension == 2 && nzgrid != 1)
@ -306,88 +323,6 @@ FixAveGrid::FixAveGrid(LAMMPS *lmp, int narg, char **arg) :
} }
} }
// setup and error checks for GRID mode
if (modegrid) {
for (int i = 0; i < nvalues; i++) {
if (which[i] == ArgInfo::COMPUTE) {
auto words = utils::parse_grid_id(FLERR,ids[i],error);
const auto &idcompute = words[0];
const auto &gname = words[1];
const auto &dname = words[2];
delete[] ids[i];
ids[i] = utils::strdup(idcompute);
auto icompute = modify->get_compute_by_id(idcompute);
if (!icompute) error->all(FLERR,"Could not find fix ave/grid compute ID: {}",idcompute);
if (icompute->pergrid_flag == 0)
error->all(FLERR,"Fix ave/grid compute {} does not compute per-grid info",idcompute);
int dim;
int igrid = icompute->get_grid_by_name(gname,dim);
if (igrid < 0)
error->all(FLERR,"Fix ave/grid compute {} does not recognize grid name {}",
idcompute,gname);
int ncol;
int idata = icompute->get_griddata_by_name(igrid,dname,ncol);
if (idata < 0)
error->all(FLERR,"Fix ave/grid compute {} does not recognize data name {}",
idcompute,dname);
if (argindex[i] == 0 && ncol)
error->all(FLERR,"Fix ave/grid compute {} data {} is not per-grid vector",idcompute,dname);
if (argindex[i] && ncol == 0)
error->all(FLERR,"Fix ave/grid compute {} data {} is not per-grid array",idcompute,dname);
if (argindex[i] && argindex[i] > ncol)
error->all(FLERR,"Fix ave/grid compute {} array {} is accessed out-of-range",
idcompute,dname);
value2grid[i] = igrid;
value2data[i] = idata;
} else if (which[i] == ArgInfo::FIX) {
auto words = utils::parse_grid_id(FLERR,ids[i],error);
const auto &idfix = words[0];
const auto &gname = words[1];
const auto &dname = words[2];
delete[] ids[i];
ids[i] = utils::strdup(idfix);
Fix *ifix = modify->get_fix_by_id(idfix);
if (!ifix) error->all(FLERR,"Could not find fix ave/grid fix ID: {}",idfix);
if (ifix->pergrid_flag == 0)
error->all(FLERR,"Fix ave/grid fix {} does not compute per-grid info",idfix);
if (nevery % ifix->pergrid_freq)
error->all(FLERR, "Fix ID {} for fix grid/atom not computed at compatible time",idfix);
int dim;
int igrid = ifix->get_grid_by_name(gname,dim);
if (igrid < 0)
error->all(FLERR,"Fix ave/grid fix {} does not recognize grid name {}",idfix,gname);
int ncol;
int idata = ifix->get_griddata_by_name(igrid,dname,ncol);
if (idata < 0)
error->all(FLERR,"Fix ave/grid fix {} does not recognize data name {}",idfix,dname);
if (argindex[i] == 0 && ncol)
error->all(FLERR, "Fix ave/grid fix {} data {} is not per-grid vector",idfix,dname);
if (argindex[i] && ncol == 0)
error->all(FLERR,"Fix ave/grid fix {} data {} is not per-grid array",idfix,dname);
if (argindex[i] && argindex[i] > ncol)
error->all(FLERR,"Fix ave/grid fix {} array {} is accessed out-of-range",idfix,dname);
value2grid[i] = igrid;
value2data[i] = idata;
}
}
}
// instantiate Grid class and buffers // instantiate Grid class and buffers
// allocate/zero per-grid data // allocate/zero per-grid data

44
src/utils.cpp
View File

@ -877,8 +877,8 @@ char *utils::expand_type(const char *file, int line, const std::string &str, int
caller decides what to do if not COMPUTE or FIX caller decides what to do if not COMPUTE or FIX
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
int utils::check_grid_reference(char *errstr, char *ref, int &igrid, int &idata, int &index, int utils::check_grid_reference(char *errstr, char *ref, int nevery,
LAMMPS *lmp) char *&id, int &igrid, int &idata, int &index, LAMMPS *lmp)
{ {
ArgInfo argi(ref, ArgInfo::COMPUTE | ArgInfo::FIX); ArgInfo argi(ref, ArgInfo::COMPUTE | ArgInfo::FIX);
index = argi.get_index1(); index = argi.get_index1();
@ -902,28 +902,28 @@ int utils::check_grid_reference(char *errstr, char *ref, int &igrid, int &idata,
const auto &dname = words[2]; const auto &dname = words[2];
auto icompute = lmp->modify->get_compute_by_id(idcompute); auto icompute = lmp->modify->get_compute_by_id(idcompute);
if (!icompute) lmp->error->all(FLERR,"%s compute ID {} not found",errstr,idcompute); if (!icompute) lmp->error->all(FLERR,"{} compute ID {} not found",errstr,idcompute);
if (icompute->pergrid_flag == 0) if (icompute->pergrid_flag == 0)
lmp->error->all(FLERR,"%s compute {} does not compute per-grid info",errstr,idcompute); lmp->error->all(FLERR,"{} compute {} does not compute per-grid info",errstr,idcompute);
int dim; int dim;
igrid = icompute->get_grid_by_name(gname,dim); igrid = icompute->get_grid_by_name(gname,dim);
if (igrid < 0) if (igrid < 0)
lmp->error->all(FLERR,"%s compute {} does not recognize grid name {}",errstr,idcompute,gname); lmp->error->all(FLERR,"{} compute {} does not recognize grid name {}",errstr,idcompute,gname);
int ncol; int ncol;
idata = icompute->get_griddata_by_name(igrid,dname,ncol); idata = icompute->get_griddata_by_name(igrid,dname,ncol);
if (idata < 0) if (idata < 0)
lmp->error->all(FLERR,"%s compute {} does not recognize data name {}",errstr,idcompute,dname); lmp->error->all(FLERR,"{} compute {} does not recognize data name {}",errstr,idcompute,dname);
if (argi.get_dim() == 0 && ncol) if (argi.get_dim() == 0 && ncol)
lmp->error->all(FLERR,"%s compute {} data {} is not per-grid vector",errstr,idcompute,dname); lmp->error->all(FLERR,"{} compute {} data {} is not per-grid vector",errstr,idcompute,dname);
if (argi.get_dim() && ncol == 0) if (argi.get_dim() && ncol == 0)
lmp->error->all(FLERR,"%s compute {} data {} is not per-grid array",errstr,idcompute,dname); lmp->error->all(FLERR,"{} compute {} data {} is not per-grid array",errstr,idcompute,dname);
if (argi.get_dim() && argi.get_index1() > ncol) if (argi.get_dim() && argi.get_index1() > ncol)
lmp->error->all(FLERR,"%s compute {} array {} is accessed out-of-range",errstr,idcompute,dname); lmp->error->all(FLERR,"{} compute {} array {} is accessed out-of-range",errstr,idcompute,dname);
//id = utils::strdup(idcompute); id = utils::strdup(idcompute);
return ArgInfo::COMPUTE; return ArgInfo::COMPUTE;
} break; } break;
@ -939,30 +939,30 @@ int utils::check_grid_reference(char *errstr, char *ref, int &igrid, int &idata,
const auto &dname = words[2]; const auto &dname = words[2];
auto ifix = lmp->modify->get_fix_by_id(idfix); auto ifix = lmp->modify->get_fix_by_id(idfix);
if (!ifix) lmp->error->all(FLERR,"%s fix ID {} not found",errstr,idfix); if (!ifix) lmp->error->all(FLERR,"{} fix ID {} not found",errstr,idfix);
if (ifix->pergrid_flag == 0) if (ifix->pergrid_flag == 0)
lmp->error->all(FLERR,"%s fix {} does not compute per-grid info",errstr,idfix); lmp->error->all(FLERR,"{} fix {} does not compute per-grid info",errstr,idfix);
//if (nevery % ifix->pergrid_freq) if (nevery % ifix->pergrid_freq)
// lmp->error->all(FLERR,"%s fix {} not computed at compatible time",errstr,if); lmp->error->all(FLERR,"{} fix {} not computed at compatible time",errstr,idfix);
int dim; int dim;
int igrid = ifix->get_grid_by_name(gname,dim); igrid = ifix->get_grid_by_name(gname,dim);
if (igrid < 0) if (igrid < 0)
lmp->error->all(FLERR,"%s fix {} does not recognize grid name {}",errstr,idfix,gname); lmp->error->all(FLERR,"{} fix {} does not recognize grid name {}",errstr,idfix,gname);
int ncol; int ncol;
int idata = ifix->get_griddata_by_name(igrid,dname,ncol); idata = ifix->get_griddata_by_name(igrid,dname,ncol);
if (idata < 0) if (idata < 0)
lmp->error->all(FLERR,"%s fix {} does not recognize data name {}",errstr,idfix,dname); lmp->error->all(FLERR,"{} fix {} does not recognize data name {}",errstr,idfix,dname);
if (argi.get_dim() == 0 && ncol) if (argi.get_dim() == 0 && ncol)
lmp->error->all(FLERR,"%s fix {} data {} is not per-grid vector",errstr,idfix,dname); lmp->error->all(FLERR,"{} fix {} data {} is not per-grid vector",errstr,idfix,dname);
if (argi.get_dim() > 0 && ncol == 0) if (argi.get_dim() > 0 && ncol == 0)
lmp->error->all(FLERR,"%s fix {} data {} is not per-grid array",errstr,idfix,dname); lmp->error->all(FLERR,"{} fix {} data {} is not per-grid array",errstr,idfix,dname);
if (argi.get_dim() > 0 && argi.get_index1() > ncol) if (argi.get_dim() > 0 && argi.get_index1() > ncol)
lmp->error->all(FLERR,"%s fix {} array {} is accessed out-of-range",errstr,idfix,dname); lmp->error->all(FLERR,"{} fix {} array {} is accessed out-of-range",errstr,idfix,dname);
//id = utils::strdup(idfix); id = utils::strdup(idfix);
return ArgInfo::FIX; return ArgInfo::FIX;
} break; } break;
} }

4
src/utils.h
View File

@ -383,8 +383,8 @@ namespace utils {
int check_grid_reference(char *errstr, char *ref, int &igrid, int &idata, int &index, int check_grid_reference(char *errstr, char *ref, int nevery,
LAMMPS *lmp); char *& id, int &igrid, int &idata, int &index, LAMMPS *lmp);
/*! Parse grid reference into 3 sub-strings /*! Parse grid reference into 3 sub-strings