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

programming style changes to reduce warnings from static code analysis

Browse Source
This commit is contained in:
Axel Kohlmeyer
2022-12-20 06:33:28 -05:00
parent 0f23659523
commit aba0ead71f
4 changed files with 102 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
src/dump_grid.cpp
View File

@ -189,7 +189,7 @@ void DumpGrid::init_style()
delete[] columns; delete[] columns;
std::string combined; std::string combined;
int icol = 0; int icol = 0;
for (auto item : utils::split_words(columns_default)) { for (const auto &item : utils::split_words(columns_default)) {
if (combined.size()) combined += " "; if (combined.size()) combined += " ";
if (keyword_user[icol].size()) combined += keyword_user[icol]; if (keyword_user[icol].size()) combined += keyword_user[icol];
else combined += item; else combined += item;
@ -506,12 +506,14 @@ int DumpGrid::count()
grid2d = (Grid2d *) compute[field2index[0]]->get_grid_by_index(field2grid[0]); grid2d = (Grid2d *) compute[field2index[0]]->get_grid_by_index(field2grid[0]);
else if (field2source[0] == FIX) else if (field2source[0] == FIX)
grid2d = (Grid2d *) fix[field2index[0]]->get_grid_by_index(field2grid[0]); grid2d = (Grid2d *) fix[field2index[0]]->get_grid_by_index(field2grid[0]);
else error->all(FLERR, "Unsupported grid data source type {}", field2source[0]);
grid2d->get_bounds_owned(nxlo_in,nxhi_in,nylo_in,nyhi_in); grid2d->get_bounds_owned(nxlo_in,nxhi_in,nylo_in,nyhi_in);
} else { } else {
if (field2source[0] == COMPUTE) if (field2source[0] == COMPUTE)
grid3d = (Grid3d *) compute[field2index[0]]->get_grid_by_index(field2grid[0]); grid3d = (Grid3d *) compute[field2index[0]]->get_grid_by_index(field2grid[0]);
else if (field2source[0] == FIX) else if (field2source[0] == FIX)
grid3d = (Grid3d *) fix[field2index[0]]->get_grid_by_index(field2grid[0]); grid3d = (Grid3d *) fix[field2index[0]]->get_grid_by_index(field2grid[0]);
else error->all(FLERR, "Unsupported grid data source type {}", field2source[0]);
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);
} }
@ -818,11 +820,10 @@ void DumpGrid::pack_grid2d(int n)
if (index == 0) { if (index == 0) {
double **vec2d; double **vec2d;
if (field2source[n] == COMPUTE) if (field2source[n] == COMPUTE)
vec2d = (double **) vec2d = (double **) compute[field2index[n]]->get_griddata_by_index(field2data[n]);
compute[field2index[n]]->get_griddata_by_index(field2data[n]);
else if (field2source[n] == FIX) else if (field2source[n] == FIX)
vec2d = (double **) vec2d = (double **) fix[field2index[n]]->get_griddata_by_index(field2data[n]);
fix[field2index[n]]->get_griddata_by_index(field2data[n]); else error->all(FLERR, "Unsupported grid data source type {}", field2source[n]);
for (int iy = nylo_in; iy <= nyhi_in; iy++) for (int iy = nylo_in; iy <= nyhi_in; iy++)
for (int ix = nxlo_in; ix <= nxhi_in; ix++) { for (int ix = nxlo_in; ix <= nxhi_in; ix++) {
buf[n] = vec2d[iy][ix]; buf[n] = vec2d[iy][ix];
@ -831,11 +832,10 @@ void DumpGrid::pack_grid2d(int n)
} else { } else {
double ***array2d; double ***array2d;
if (field2source[n] == COMPUTE) if (field2source[n] == COMPUTE)
array2d = (double ***) array2d = (double ***) compute[field2index[n]]->get_griddata_by_index(field2data[n]);
compute[field2index[n]]->get_griddata_by_index(field2data[n]);
else if (field2source[n] == FIX) else if (field2source[n] == FIX)
array2d = (double ***) array2d = (double ***) fix[field2index[n]]->get_griddata_by_index(field2data[n]);
fix[field2index[n]]->get_griddata_by_index(field2data[n]); else error->all(FLERR, "Unsupported grid data source type {}", field2source[n]);
index--; index--;
for (int iy = nylo_in; iy <= nyhi_in; iy++) for (int iy = nylo_in; iy <= nyhi_in; iy++)
for (int ix = nxlo_in; ix <= nxhi_in; ix++) { for (int ix = nxlo_in; ix <= nxhi_in; ix++) {
@ -854,11 +854,10 @@ void DumpGrid::pack_grid3d(int n)
if (index == 0) { if (index == 0) {
double ***vec3d; double ***vec3d;
if (field2source[n] == COMPUTE) if (field2source[n] == COMPUTE)
vec3d = (double ***) vec3d = (double ***) compute[field2index[n]]->get_griddata_by_index(field2data[n]);
compute[field2index[n]]->get_griddata_by_index(field2data[n]);
else if (field2source[n] == FIX) else if (field2source[n] == FIX)
vec3d = (double ***) vec3d = (double ***) fix[field2index[n]]->get_griddata_by_index(field2data[n]);
fix[field2index[n]]->get_griddata_by_index(field2data[n]); else error->all(FLERR, "Unsupported grid data source type {}", field2source[n]);
for (int iz = nzlo_in; iz <= nzhi_in; iz++) for (int iz = nzlo_in; iz <= nzhi_in; iz++)
for (int iy = nylo_in; iy <= nyhi_in; iy++) for (int iy = nylo_in; iy <= nyhi_in; iy++)
for (int ix = nxlo_in; ix <= nxhi_in; ix++) { for (int ix = nxlo_in; ix <= nxhi_in; ix++) {
@ -868,11 +867,10 @@ void DumpGrid::pack_grid3d(int n)
} else { } else {
double ****array3d; double ****array3d;
if (field2source[n] == COMPUTE) if (field2source[n] == COMPUTE)
array3d = (double ****) array3d = (double ****) compute[field2index[n]]->get_griddata_by_index(field2data[n]);
compute[field2index[n]]->get_griddata_by_index(field2data[n]);
else if (field2source[n] == FIX) else if (field2source[n] == FIX)
array3d = (double ****) array3d = (double ****) fix[field2index[n]]->get_griddata_by_index(field2data[n]);
fix[field2index[n]]->get_griddata_by_index(field2data[n]); else error->all(FLERR, "Unsupported grid data source type {}", field2source[n]);
index--; index--;
for (int iz = nzlo_in; iz <= nzhi_in; iz++) for (int iz = nzlo_in; iz <= nzhi_in; iz++)
for (int iy = nylo_in; iy <= nyhi_in; iy++) for (int iy = nylo_in; iy <= nyhi_in; iy++)

45
src/fix_ave_grid.cpp
View File

@ -45,13 +45,15 @@ static constexpr int OFFSET = 16384;
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
FixAveGrid::FixAveGrid(LAMMPS *lmp, int narg, char **arg) : FixAveGrid::FixAveGrid(LAMMPS *lmp, int narg, char **arg) :
Fix(lmp, narg, arg), Fix(lmp, narg, arg), id_bias(nullptr), which(nullptr), argindex(nullptr), ids(nullptr),
which(nullptr), argindex(nullptr), ids(nullptr), value2index(nullptr), value2grid(nullptr), value2data(nullptr), grid2d(nullptr), grid3d(nullptr),
value2index(nullptr), value2grid(nullptr), value2data(nullptr), grid_buf1(nullptr), grid_buf2(nullptr), grid_output(nullptr), grid_sample(nullptr),
grid2d(nullptr), grid3d(nullptr), grid_nfreq(nullptr), grid_running(nullptr), grid_window(nullptr), grid2d_previous(nullptr),
grid_buf1(nullptr), grid_buf2(nullptr) grid3d_previous(nullptr), grid_sample_previous(nullptr), grid_nfreq_previous(nullptr),
grid_running_previous(nullptr), grid_window_previous(nullptr), bin(nullptr), skip(nullptr),
vresult(nullptr)
{ {
if (narg < 10) error->all(FLERR,"Illegal fix ave/grid command"); if (narg < 10) utils::missing_cmd_args(FLERR,"fix ave/grid", error);
pergrid_flag = 1; pergrid_flag = 1;
nevery = utils::inumeric(FLERR,arg[3],false,lmp); nevery = utils::inumeric(FLERR,arg[3],false,lmp);
@ -258,7 +260,7 @@ FixAveGrid::FixAveGrid(LAMMPS *lmp, int narg, char **arg) :
dimension = domain->dimension; dimension = domain->dimension;
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)
error->all(FLERR,"Fix ave/grid grid Nz must be 1 for 2d simulation"); error->all(FLERR,"Fix ave/grid grid Nz must be 1 for 2d simulation");
@ -282,17 +284,13 @@ FixAveGrid::FixAveGrid(LAMMPS *lmp, int narg, char **arg) :
if (icompute < 0) if (icompute < 0)
error->all(FLERR,"Compute ID for fix ave/grid does not exist"); error->all(FLERR,"Compute ID for fix ave/grid does not exist");
if (modify->compute[icompute]->peratom_flag == 0) if (modify->compute[icompute]->peratom_flag == 0)
error->all(FLERR, error->all(FLERR, "Fix ave/atom compute does not calculate per-atom values");
"Fix ave/atom compute does not calculate per-atom values");
if (argindex[i] == 0 && if (argindex[i] == 0 &&
modify->compute[icompute]->size_peratom_cols != 0) modify->compute[icompute]->size_peratom_cols != 0)
error->all(FLERR,"Fix ave/atom compute does not " error->all(FLERR,"Fix ave/atom compute does not calculate a per-atom vector");
"calculate a per-atom vector");
if (argindex[i] && modify->compute[icompute]->size_peratom_cols == 0) if (argindex[i] && modify->compute[icompute]->size_peratom_cols == 0)
error->all(FLERR,"Fix ave/atom compute does not " error->all(FLERR,"Fix ave/atom compute does not calculate a per-atom array");
"calculate a per-atom array"); if (argindex[i] && argindex[i] > modify->compute[icompute]->size_peratom_cols)
if (argindex[i] &&
argindex[i] > modify->compute[icompute]->size_peratom_cols)
error->all(FLERR,"Fix ave/atom compute array is accessed out-of-range"); error->all(FLERR,"Fix ave/atom compute array is accessed out-of-range");
} else if (which[i] == ArgInfo::FIX) { } else if (which[i] == ArgInfo::FIX) {
@ -302,16 +300,13 @@ FixAveGrid::FixAveGrid(LAMMPS *lmp, int narg, char **arg) :
if (modify->fix[ifix]->peratom_flag == 0) if (modify->fix[ifix]->peratom_flag == 0)
error->all(FLERR,"Fix ave/atom fix does not calculate per-atom values"); error->all(FLERR,"Fix ave/atom fix does not calculate per-atom values");
if (argindex[i] == 0 && modify->fix[ifix]->size_peratom_cols != 0) if (argindex[i] == 0 && modify->fix[ifix]->size_peratom_cols != 0)
error->all(FLERR, error->all(FLERR, "Fix ave/atom fix does not calculate a per-atom vector");
"Fix ave/atom fix does not calculate a per-atom vector");
if (argindex[i] && modify->fix[ifix]->size_peratom_cols == 0) if (argindex[i] && modify->fix[ifix]->size_peratom_cols == 0)
error->all(FLERR, error->all(FLERR, "Fix ave/atom fix does not calculate a per-atom array");
"Fix ave/atom fix does not calculate a per-atom array");
if (argindex[i] && argindex[i] > modify->fix[ifix]->size_peratom_cols) if (argindex[i] && argindex[i] > modify->fix[ifix]->size_peratom_cols)
error->all(FLERR,"Fix ave/atom fix array is accessed out-of-range"); error->all(FLERR,"Fix ave/atom fix array is accessed out-of-range");
if (nevery % modify->fix[ifix]->peratom_freq) if (nevery % modify->fix[ifix]->peratom_freq)
error->all(FLERR, error->all(FLERR, "Fix for fix ave/atom not computed at compatible time");
"Fix for fix ave/atom not computed at compatible time");
} else if (which[i] == ArgInfo::VARIABLE) { } else if (which[i] == ArgInfo::VARIABLE) {
int ivariable = input->variable->find(ids[i]); int ivariable = input->variable->find(ids[i]);
@ -1798,7 +1793,7 @@ void FixAveGrid::pack_reverse_grid(int /*which*/, void *vbuf, int nlist, int *li
count = &grid_sample->count2d[nylo_out][nxlo_out]; count = &grid_sample->count2d[nylo_out][nxlo_out];
if (nvalues == 1) data = &grid_sample->vec2d[nylo_out][nxlo_out]; if (nvalues == 1) data = &grid_sample->vec2d[nylo_out][nxlo_out];
else data = &grid_sample->array2d[nylo_out][nxlo_out][0]; else data = &grid_sample->array2d[nylo_out][nxlo_out][0];
} else if (dimension == 3) { } else {
count = &grid_sample->count3d[nzlo_out][nylo_out][nxlo_out]; count = &grid_sample->count3d[nzlo_out][nylo_out][nxlo_out];
if (nvalues == 1) data = &grid_sample->vec3d[nzlo_out][nylo_out][nxlo_out]; if (nvalues == 1) data = &grid_sample->vec3d[nzlo_out][nylo_out][nxlo_out];
else data = &grid_sample->array3d[nzlo_out][nylo_out][nxlo_out][0]; else data = &grid_sample->array3d[nzlo_out][nylo_out][nxlo_out][0];
@ -1836,7 +1831,7 @@ void FixAveGrid::unpack_reverse_grid(int /*which*/, void *vbuf, int nlist, int *
count = &grid_sample->count2d[nylo_out][nxlo_out]; count = &grid_sample->count2d[nylo_out][nxlo_out];
if (nvalues == 1) data = &grid_sample->vec2d[nylo_out][nxlo_out]; if (nvalues == 1) data = &grid_sample->vec2d[nylo_out][nxlo_out];
else data = &grid_sample->array2d[nylo_out][nxlo_out][0]; else data = &grid_sample->array2d[nylo_out][nxlo_out][0];
} else if (dimension == 3) { } else {
count = &grid_sample->count3d[nzlo_out][nylo_out][nxlo_out]; count = &grid_sample->count3d[nzlo_out][nylo_out][nxlo_out];
if (nvalues == 1) data = &grid_sample->vec3d[nzlo_out][nylo_out][nxlo_out]; if (nvalues == 1) data = &grid_sample->vec3d[nzlo_out][nylo_out][nxlo_out];
else data = &grid_sample->array3d[nzlo_out][nylo_out][nxlo_out][0]; else data = &grid_sample->array3d[nzlo_out][nylo_out][nxlo_out][0];
@ -1921,7 +1916,7 @@ int FixAveGrid::pack_one_grid(GridData *grid, int index, double *buf)
count = &grid->count2d[nylo_out_previous][nxlo_out_previous]; count = &grid->count2d[nylo_out_previous][nxlo_out_previous];
if (nvalues == 1) data = &grid->vec2d[nylo_out_previous][nxlo_out_previous]; if (nvalues == 1) data = &grid->vec2d[nylo_out_previous][nxlo_out_previous];
else data = &grid->array2d[nylo_out_previous][nxlo_out_previous][0]; else data = &grid->array2d[nylo_out_previous][nxlo_out_previous][0];
} else if (dimension == 3) { } else {
count = &grid->count3d[nzlo_out_previous][nylo_out_previous][nxlo_out_previous]; count = &grid->count3d[nzlo_out_previous][nylo_out_previous][nxlo_out_previous];
if (nvalues == 1) data = &grid->vec3d[nzlo_out_previous][nylo_out_previous][nxlo_out_previous]; if (nvalues == 1) data = &grid->vec3d[nzlo_out_previous][nylo_out_previous][nxlo_out_previous];
else data = &grid->array3d[nzlo_out_previous][nylo_out_previous][nxlo_out_previous][0]; else data = &grid->array3d[nzlo_out_previous][nylo_out_previous][nxlo_out_previous][0];
@ -1952,7 +1947,7 @@ int FixAveGrid::unpack_one_grid(double *buf, GridData *grid, int index)
count = &grid->count2d[nylo_out][nxlo_out]; count = &grid->count2d[nylo_out][nxlo_out];
if (nvalues == 1) data = &grid->vec2d[nylo_out][nxlo_out]; if (nvalues == 1) data = &grid->vec2d[nylo_out][nxlo_out];
else data = &grid->array2d[nylo_out][nxlo_out][0]; else data = &grid->array2d[nylo_out][nxlo_out][0];
} else if (dimension == 3) { } else {
count = &grid->count3d[nzlo_out][nylo_out][nxlo_out]; count = &grid->count3d[nzlo_out][nylo_out][nxlo_out];
if (nvalues == 1) data = &grid->vec3d[nzlo_out][nylo_out][nxlo_out]; if (nvalues == 1) data = &grid->vec3d[nzlo_out][nylo_out][nxlo_out];
else data = &grid->array3d[nzlo_out][nylo_out][nxlo_out][0]; else data = &grid->array3d[nzlo_out][nylo_out][nxlo_out][0];

111
src/grid2d.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories https://www.lammps.org/, Sandia National Laboratories
@ -17,12 +16,12 @@
#include "comm.h" #include "comm.h"
#include "domain.h" #include "domain.h"
#include "error.h" #include "error.h"
#include "irregular.h"
#include "pair.h"
#include "kspace.h"
#include "fix.h" #include "fix.h"
#include "irregular.h"
#include "kspace.h"
#include "math_extra.h" #include "math_extra.h"
#include "memory.h" #include "memory.h"
#include "pair.h"
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
@ -47,11 +46,15 @@ static constexpr int OFFSET = 16384;
gnx,gny,gnz = global grid size gnx,gny,gnz = global grid size
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
Grid2d::Grid2d(LAMMPS *lmp, MPI_Comm gcomm, int gnx, int gny) : Pointers(lmp) Grid2d::Grid2d(LAMMPS *lmp, MPI_Comm gcomm, int gnx, int gny) :
Pointers(lmp), swap(nullptr), requests(nullptr), srequest(nullptr), rrequest(nullptr),
sresponse(nullptr), rresponse(nullptr), send(nullptr), recv(nullptr), copy(nullptr),
send_remap(nullptr), recv_remap(nullptr), overlap_procs(nullptr), xsplit(nullptr),
ysplit(nullptr), zsplit(nullptr), grid2proc(nullptr), rcbinfo(nullptr), overlap_list(nullptr)
{ {
gridcomm = gcomm; gridcomm = gcomm;
MPI_Comm_rank(gridcomm,&me); MPI_Comm_rank(gridcomm, &me);
MPI_Comm_size(gridcomm,&nprocs); MPI_Comm_size(gridcomm, &nprocs);
nx = gnx; nx = gnx;
ny = gny; ny = gny;
@ -81,14 +84,17 @@ Grid2d::Grid2d(LAMMPS *lmp, MPI_Comm gcomm, int gnx, int gny) : Pointers(lmp)
ghost indices can extend < 0 or >= N ghost indices can extend < 0 or >= N
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
Grid2d::Grid2d(LAMMPS *lmp, MPI_Comm gcomm, int gnx, int gny, Grid2d::Grid2d(LAMMPS *lmp, MPI_Comm gcomm, int gnx, int gny, int ixlo, int ixhi, int iylo,
int ixlo, int ixhi, int iylo, int iyhi, int iyhi, int oxlo, int oxhi, int oylo, int oyhi) :
int oxlo, int oxhi, int oylo, int oyhi) : Pointers(lmp),
Pointers(lmp) swap(nullptr), requests(nullptr), srequest(nullptr), rrequest(nullptr), sresponse(nullptr),
rresponse(nullptr), send(nullptr), recv(nullptr), copy(nullptr), send_remap(nullptr),
recv_remap(nullptr), overlap_procs(nullptr), xsplit(nullptr), ysplit(nullptr), zsplit(nullptr),
grid2proc(nullptr), rcbinfo(nullptr), overlap_list(nullptr)
{ {
gridcomm = gcomm; gridcomm = gcomm;
MPI_Comm_rank(gridcomm,&me); MPI_Comm_rank(gridcomm, &me);
MPI_Comm_size(gridcomm,&nprocs); MPI_Comm_size(gridcomm, &nprocs);
nx = gnx; nx = gnx;
ny = gny; ny = gny;
@ -123,18 +129,16 @@ Grid2d::~Grid2d()
} }
memory->sfree(swap); memory->sfree(swap);
delete [] xsplit; delete[] xsplit;
delete [] ysplit; delete[] ysplit;
memory->destroy(grid2proc); memory->destroy(grid2proc);
// tiled comm data structs // tiled comm data structs
for (int i = 0; i < nsend; i++) for (int i = 0; i < nsend; i++) memory->destroy(send[i].packlist);
memory->destroy(send[i].packlist);
memory->sfree(send); memory->sfree(send);
for (int i = 0; i < nrecv; i++) for (int i = 0; i < nrecv; i++) memory->destroy(recv[i].unpacklist);
memory->destroy(recv[i].unpacklist);
memory->sfree(recv); memory->sfree(recv);
for (int i = 0; i < ncopy; i++) { for (int i = 0; i < ncopy; i++) {
@ -143,8 +147,8 @@ Grid2d::~Grid2d()
} }
memory->sfree(copy); memory->sfree(copy);
delete [] requests; delete[] requests;
delete [] requests_remap; delete[] requests_remap;
memory->sfree(rcbinfo); memory->sfree(rcbinfo);
@ -223,8 +227,10 @@ void Grid2d::set_shift_atom(double shift_lo, double shift_hi)
void Grid2d::set_yfactor(double factor) void Grid2d::set_yfactor(double factor)
{ {
if (factor == 1.0) yextra = 0; if (factor == 1.0)
else yextra = 1; yextra = 0;
else
yextra = 1;
yfactor = factor; yfactor = factor;
} }
@ -262,20 +268,19 @@ void Grid2d::set_caller_grid(int fxlo, int fxhi, int fylo, int fyhi)
int Grid2d::identical(Grid2d *grid2) int Grid2d::identical(Grid2d *grid2)
{ {
int inxlo2,inxhi2,inylo2,inyhi2; int inxlo2, inxhi2, inylo2, inyhi2;
int outxlo2,outxhi2,outylo2,outyhi2; int outxlo2, outxhi2, outylo2, outyhi2;
grid2->get_bounds_owned(inxlo2,inxhi2,inylo2,inyhi2); grid2->get_bounds_owned(inxlo2, inxhi2, inylo2, inyhi2);
grid2->get_bounds_ghost(outxlo2,outxhi2,outylo2,outyhi2); grid2->get_bounds_ghost(outxlo2, outxhi2, outylo2, outyhi2);
int flag = 0; int flag = 0;
if (inxlo != inxlo2 || inxhi != inxhi2 || if ((inxlo != inxlo2) || (inxhi != inxhi2) || (inylo != inylo2) || (inyhi != inyhi2)) flag = 1;
inylo != inylo2 || inyhi != inyhi2) flag = 1; if ((outxlo != outxlo2) || (outxhi != outxhi2) || (outylo != outylo2) || (outyhi != outyhi2))
if (outxlo != outxlo2 || outxhi != outxhi2 || flag = 1;
outylo != outylo2 || outyhi != outyhi2) flag = 1;
int flagall; int flagall;
MPI_Allreduce(&flag,&flagall,1,MPI_INT,MPI_SUM,gridcomm); MPI_Allreduce(&flag, &flagall, 1, MPI_INT, MPI_SUM, gridcomm);
if (flagall) return 0; if (flagall) return 0;
return 1; return 1;
@ -324,28 +329,28 @@ void Grid2d::get_bounds_ghost(int &xlo, int &xhi, int &ylo, int &yhi)
since no grid comm is done across non-periodic boundaries since no grid comm is done across non-periodic boundaries
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void Grid2d::setup_grid(int &ixlo, int &ixhi, int &iylo, int &iyhi, void Grid2d::setup_grid(int &ixlo, int &ixhi, int &iylo, int &iyhi, int &oxlo, int &oxhi, int &oylo,
int &oxlo, int &oxhi, int &oylo, int &oyhi) int &oyhi)
{ {
// owned grid cells = those whose grid point is within proc subdomain // owned grid cells = those whose grid point is within proc subdomain
// shift_grid = 0.5 for grid point at cell center, 0.0 for lower-left corner // shift_grid = 0.5 for grid point at cell center, 0.0 for lower-left corner
double fraclo,frachi; double fraclo, frachi;
if (comm->layout != Comm::LAYOUT_TILED) { if (comm->layout != Comm::LAYOUT_TILED) {
fraclo = comm->xsplit[comm->myloc[0]]; fraclo = comm->xsplit[comm->myloc[0]];
frachi = comm->xsplit[comm->myloc[0]+1]; frachi = comm->xsplit[comm->myloc[0] + 1];
partition_grid(nx,fraclo,frachi,shift_grid,0,inxlo,inxhi); partition_grid(nx, fraclo, frachi, shift_grid, 0, inxlo, inxhi);
fraclo = comm->ysplit[comm->myloc[1]]; fraclo = comm->ysplit[comm->myloc[1]];
frachi = comm->ysplit[comm->myloc[1]+1]; frachi = comm->ysplit[comm->myloc[1] + 1];
partition_grid(ny,fraclo,frachi,shift_grid,yextra,inylo,inyhi); partition_grid(ny, fraclo, frachi, shift_grid, yextra, inylo, inyhi);
} else { } else {
fraclo = comm->mysplit[0][0]; fraclo = comm->mysplit[0][0];
frachi = comm->mysplit[0][1]; frachi = comm->mysplit[0][1];
partition_grid(nx,fraclo,frachi,shift_grid,0,inxlo,inxhi); partition_grid(nx, fraclo, frachi, shift_grid, 0, inxlo, inxhi);
fraclo = comm->mysplit[1][0]; fraclo = comm->mysplit[1][0];
frachi = comm->mysplit[1][1]; frachi = comm->mysplit[1][1];
partition_grid(ny,fraclo,frachi,shift_grid,yextra,inylo,inyhi); partition_grid(ny, fraclo, frachi, shift_grid, yextra, inylo, inyhi);
} }
// extend owned grid bounds with ghost grid cells in each direction // extend owned grid bounds with ghost grid cells in each direction
@ -379,8 +384,7 @@ void Grid2d::initialize()
// error check on size of grid stored by this proc // error check on size of grid stored by this proc
bigint total = (bigint) (outxhi - outxlo + 1) * (outyhi - outylo + 1); bigint total = (bigint) (outxhi - outxlo + 1) * (outyhi - outylo + 1);
if (total > MAXSMALLINT) if (total > MAXSMALLINT) error->one(FLERR, "Too many owned+ghost grid2d points");
error->one(FLERR, "Too many owned+ghost grid2d points");
// default = caller grid is allocated to ghost grid // default = caller grid is allocated to ghost grid
// used when computing pack/unpack lists in indices() // used when computing pack/unpack lists in indices()
@ -437,22 +441,23 @@ void Grid2d::initialize()
2 if test equalties insure a consistent decision as to which proc owns it 2 if test equalties insure a consistent decision as to which proc owns it
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void Grid2d::partition_grid(int ngrid, double fraclo, double frachi, void Grid2d::partition_grid(int ngrid, double fraclo, double frachi, double shift, int extra,
double shift, int extra, int &lo, int &hi) int &lo, int &hi)
{ {
if (extra == 0) { if (extra == 0) {
lo = static_cast<int> (fraclo * ngrid); lo = static_cast<int>(fraclo * ngrid);
while (lo+shift < fraclo*ngrid) lo++; while (lo + shift < fraclo * ngrid) lo++;
hi = static_cast<int> (frachi * ngrid); hi = static_cast<int>(frachi * ngrid);
while (hi+shift >= frachi*ngrid) hi--; while (hi + shift >= frachi * ngrid) hi--;
} else { } else {
lo = static_cast<int> (fraclo * ngrid/yfactor); lo = static_cast<int>(fraclo * ngrid / yfactor);
while (lo+shift < fraclo*ngrid/yfactor) lo++; while (lo + shift < fraclo * ngrid / yfactor) lo++;
hi = static_cast<int> (frachi * ngrid/yfactor); hi = static_cast<int>(frachi * ngrid / yfactor);
while (hi+shift >= frachi*ngrid/yfactor) hi--; while (hi + shift >= frachi * ngrid / yfactor) hi--;
} }
} }
// clang-format off
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
extend ghost grid cells in each direction beyond owned grid extend ghost grid cells in each direction beyond owned grid
indices into the global grid range from 0 to N-1 in each dim indices into the global grid range from 0 to N-1 in each dim

11
src/grid3d.cpp
View File

@ -48,7 +48,11 @@ static constexpr int OFFSET = 16384;
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
Grid3d::Grid3d(LAMMPS *lmp, MPI_Comm gcomm, int gnx, int gny, int gnz) : Grid3d::Grid3d(LAMMPS *lmp, MPI_Comm gcomm, int gnx, int gny, int gnz) :
Pointers(lmp) Pointers(lmp), swap(nullptr), requests(nullptr), srequest(nullptr), rrequest(nullptr),
sresponse(nullptr), rresponse(nullptr), send(nullptr), recv(nullptr), copy(nullptr),
send_remap(nullptr), recv_remap(nullptr), overlap_procs(nullptr), xsplit(nullptr),
ysplit(nullptr), zsplit(nullptr), grid2proc(nullptr), rcbinfo(nullptr), overlap_list(nullptr)
{ {
gridcomm = gcomm; gridcomm = gcomm;
MPI_Comm_rank(gridcomm,&me); MPI_Comm_rank(gridcomm,&me);
@ -87,7 +91,10 @@ Grid3d::Grid3d(LAMMPS *lmp, MPI_Comm gcomm, int gnx, int gny, int gnz) :
Grid3d::Grid3d(LAMMPS *lmp, MPI_Comm gcomm, int gnx, int gny, int gnz, Grid3d::Grid3d(LAMMPS *lmp, MPI_Comm gcomm, int gnx, int gny, int gnz,
int ixlo, int ixhi, int iylo, int iyhi, int izlo, int izhi, int ixlo, int ixhi, int iylo, int iyhi, int izlo, int izhi,
int oxlo, int oxhi, int oylo, int oyhi, int ozlo, int ozhi) : int oxlo, int oxhi, int oylo, int oyhi, int ozlo, int ozhi) :
Pointers(lmp) Pointers(lmp), swap(nullptr), requests(nullptr), srequest(nullptr), rrequest(nullptr),
sresponse(nullptr), rresponse(nullptr), send(nullptr), recv(nullptr), copy(nullptr),
send_remap(nullptr), recv_remap(nullptr), overlap_procs(nullptr), xsplit(nullptr),
ysplit(nullptr), zsplit(nullptr), grid2proc(nullptr), rcbinfo(nullptr), overlap_list(nullptr)
{ {
gridcomm = gcomm; gridcomm = gcomm;
MPI_Comm_rank(gridcomm,&me); MPI_Comm_rank(gridcomm,&me);