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

git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@11978 f3b2605a-c512-4ea7-a41b-209d697bcdaa

Browse Source
This commit is contained in:
sjplimp
2014-05-13 15:23:13 +00:00
parent d17e06c479
commit 6c06a66ae7
25 changed files with 512 additions and 2004 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/KSPACE/commgrid.cpp → src/KSPACE/gridcomm.cpp
View File

@ -12,7 +12,7 @@
------------------------------------------------------------------------- */
#include "mpi.h"
#include "commgrid.h"
#include "gridcomm.h"
#include "comm.h"
#include "kspace.h"
#include "memory.h"
@ -24,7 +24,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
CommGrid::CommGrid(LAMMPS *lmp, MPI_Comm gcomm, int forward, int reverse,
GridComm::GridComm(LAMMPS *lmp, MPI_Comm gcomm, int forward, int reverse,
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 pxlo, int pxhi, int pylo, int pyhi, int pzlo, int pzhi)
@ -71,10 +71,11 @@ CommGrid::CommGrid(LAMMPS *lmp, MPI_Comm gcomm, int forward, int reverse,
/* ---------------------------------------------------------------------- */
CommGrid::CommGrid(LAMMPS *lmp, MPI_Comm gcomm, int forward, int reverse,
GridComm::GridComm(LAMMPS *lmp, MPI_Comm gcomm, int forward, int reverse,
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_max, int oxhi_max, int oylo_max, int oyhi_max, int ozlo_max, int ozhi_max,
int oxlo_max, int oxhi_max, int oylo_max, int oyhi_max,
int ozlo_max, int ozhi_max,
int pxlo, int pxhi, int pylo, int pyhi, int pzlo, int pzhi)
: Pointers(lmp)
{
@ -119,7 +120,7 @@ CommGrid::CommGrid(LAMMPS *lmp, MPI_Comm gcomm, int forward, int reverse,
/* ---------------------------------------------------------------------- */
CommGrid::~CommGrid()
GridComm::~GridComm()
{
for (int i = 0; i < nswap; i++) {
memory->destroy(swap[i].packlist);
@ -140,7 +141,7 @@ CommGrid::~CommGrid()
if no neighbor proc, value is from self
------------------------------------------------------------------------- */
void CommGrid::ghost_notify()
void GridComm::ghost_notify()
{
int nplanes = inxlo - outxlo;
if (procxlo != me)
@ -184,7 +185,7 @@ void CommGrid::ghost_notify()
if yes, return 1, else return 0
------------------------------------------------------------------------- */
int CommGrid::ghost_overlap()
int GridComm::ghost_overlap()
{
int nearest = 0;
if (ghostxlo > inxhi-inxlo+1) nearest = 1;
@ -208,7 +209,7 @@ int CommGrid::ghost_overlap()
same swap list used by forward and reverse communication
------------------------------------------------------------------------- */
void CommGrid::setup()
void GridComm::setup()
{
int nsent,sendfirst,sendlast,recvfirst,recvlast;
int sendplanes,recvplanes;
@ -486,7 +487,7 @@ void CommGrid::setup()
use swap list in forward order to acquire copy of all needed ghost grid pts
------------------------------------------------------------------------- */
void CommGrid::forward_comm(KSpace *kspace, int which)
void GridComm::forward_comm(KSpace *kspace, int which)
{
for (int m = 0; m < nswap; m++) {
if (swap[m].sendproc == me)
@ -511,7 +512,7 @@ void CommGrid::forward_comm(KSpace *kspace, int which)
for each owned grid pt that some other proc has copy of as a ghost grid pt
------------------------------------------------------------------------- */
void CommGrid::reverse_comm(KSpace *kspace, int which)
void GridComm::reverse_comm(KSpace *kspace, int which)
{
for (int m = nswap-1; m >= 0; m--) {
if (swap[m].recvproc == me)
@ -537,7 +538,7 @@ void CommGrid::reverse_comm(KSpace *kspace, int which)
outzlo_max:outzhi_max)
------------------------------------------------------------------------- */
int CommGrid::indices(int *&list,
int GridComm::indices(int *&list,
int xlo, int xhi, int ylo, int yhi, int zlo, int zhi)
{
int nmax = (xhi-xlo+1) * (yhi-ylo+1) * (zhi-zlo+1);
@ -560,7 +561,7 @@ int CommGrid::indices(int *&list,
memory usage of send/recv bufs
------------------------------------------------------------------------- */
double CommGrid::memory_usage()
double GridComm::memory_usage()
{
double bytes = 2*nbuf * sizeof(double);
return bytes;

12
src/KSPACE/commgrid.h → src/KSPACE/gridcomm.h
View File

@ -11,8 +11,8 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#ifndef LMP_COMMGRID_H
#define LMP_COMMGRID_H
#ifndef LMP_GRIDCOMM_H
#define LMP_GRIDCOMM_H
#include "pointers.h"
@ -26,18 +26,18 @@ typedef double FFT_SCALAR;
namespace LAMMPS_NS {
class CommGrid : protected Pointers {
class GridComm : protected Pointers {
public:
CommGrid(class LAMMPS *, MPI_Comm, int, int,
GridComm(class LAMMPS *, MPI_Comm, int, int,
int, int, int, int, int, int,
int, int, int, int, int, int,
int, int, int, int, int, int);
CommGrid(class LAMMPS *, MPI_Comm, int, int,
GridComm(class LAMMPS *, MPI_Comm, int, int,
int, int, int, int, int, int,
int, int, int, int, int, int,
int, int, int, int, int, int,
int, int, int, int, int, int);
~CommGrid();
~GridComm();
void ghost_notify();
int ghost_overlap();
void setup();

14
src/KSPACE/msm.cpp
View File

@ -24,7 +24,7 @@
#include "msm.h"
#include "atom.h"
#include "comm.h"
#include "commgrid.h"
#include "gridcomm.h"
#include "neighbor.h"
#include "force.h"
#include "pair.h"
@ -639,7 +639,7 @@ void MSM::allocate()
int (*procneigh_all)[2] = comm->procneigh;
cg_all = new CommGrid(lmp,world,1,1,
cg_all = new GridComm(lmp,world,1,1,
nxlo_in[0],nxhi_in[0],nylo_in[0],nyhi_in[0],nzlo_in[0],nzhi_in[0],
nxlo_out_all,nxhi_out_all,nylo_out_all,nyhi_out_all,nzlo_out_all,nzhi_out_all,
nxlo_out[0],nxhi_out[0],nylo_out[0],nyhi_out[0],nzlo_out[0],nzhi_out[0],
@ -659,7 +659,7 @@ void MSM::allocate()
if (active_flag[n]) {
int **procneigh = procneigh_levels[n];
cg[n] = new CommGrid(lmp,world_levels[n],1,1,
cg[n] = new GridComm(lmp,world_levels[n],1,1,
nxlo_in[n],nxhi_in[n],nylo_in[n],nyhi_in[n],nzlo_in[n],nzhi_in[n],
nxlo_out[n],nxhi_out[n],nylo_out[n],nyhi_out[n],nzlo_out[n],nzhi_out[n],
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -708,7 +708,7 @@ void MSM::allocate_peratom()
int (*procneigh_all)[2] = comm->procneigh;
cg_peratom_all =
new CommGrid(lmp,world,6,6,
new GridComm(lmp,world,6,6,
nxlo_in[0],nxhi_in[0],nylo_in[0],nyhi_in[0],nzlo_in[0],nzhi_in[0],
nxlo_out_all,nxhi_out_all,nylo_out_all,nyhi_out_all,nzlo_out_all,nzhi_out_all,
nxlo_out[0],nxhi_out[0],nylo_out[0],nyhi_out[0],nzlo_out[0],nzhi_out[0],
@ -736,7 +736,7 @@ void MSM::allocate_peratom()
if (active_flag[n]) {
int **procneigh = procneigh_levels[n];
cg_peratom[n] =
new CommGrid(lmp,world_levels[n],6,6,
new GridComm(lmp,world_levels[n],6,6,
nxlo_in[n],nxhi_in[n],nylo_in[n],nyhi_in[n],nzlo_in[n],nzhi_in[n],
nxlo_out[n],nxhi_out[n],nylo_out[n],nyhi_out[n],nzlo_out[n],nzhi_out[n],
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -782,8 +782,8 @@ void MSM::allocate_levels()
{
ngrid = new int[levels];
cg = new CommGrid*[levels];
cg_peratom = new CommGrid*[levels];
cg = new GridComm*[levels];
cg_peratom = new GridComm*[levels];
memory->create(procneigh_levels,levels,3,2,"msm:procneigh_levels");
world_levels = new MPI_Comm[levels];

8
src/KSPACE/msm.h
View File

@ -81,10 +81,10 @@ class MSM : public KSpace {
int procgrid[3]; // procs assigned in each dim of 3d grid
int myloc[3]; // which proc I am in each dim
int ***procneigh_levels; // my 6 neighboring procs, 0/1 = left/right
class CommGrid **cg;
class CommGrid **cg_peratom;
class CommGrid *cg_all;
class CommGrid *cg_peratom_all;
class GridComm **cg;
class GridComm **cg_peratom;
class GridComm *cg_all;
class GridComm *cg_peratom_all;
int current_level;

3
src/KSPACE/msm_cg.cpp
View File

@ -21,9 +21,8 @@
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "atom.h"
#include "commgrid.h"
#include "gridcomm.h"
#include "domain.h"
#include "error.h"
#include "force.h"

14
src/KSPACE/pppm.cpp
View File

@ -27,7 +27,7 @@
#include "pppm.h"
#include "atom.h"
#include "comm.h"
#include "commgrid.h"
#include "gridcomm.h"
#include "neighbor.h"
#include "force.h"
#include "pair.h"
@ -272,7 +272,7 @@ void PPPM::init()
int (*procneigh)[2] = comm->procneigh;
CommGrid *cgtmp = NULL;
GridComm *cgtmp = NULL;
int iteration = 0;
while (order >= minorder) {
@ -285,7 +285,7 @@ void PPPM::init()
set_grid_local();
if (overlap_allowed) break;
cgtmp = new CommGrid(lmp,world,1,1,
cgtmp = new GridComm(lmp,world,1,1,
nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in,
nxlo_out,nxhi_out,nylo_out,nyhi_out,nzlo_out,nzhi_out,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -805,13 +805,13 @@ void PPPM::allocate()
int (*procneigh)[2] = comm->procneigh;
if (differentiation_flag == 1)
cg = new CommGrid(lmp,world,1,1,
cg = new GridComm(lmp,world,1,1,
nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in,
nxlo_out,nxhi_out,nylo_out,nyhi_out,nzlo_out,nzhi_out,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
procneigh[1][1],procneigh[2][0],procneigh[2][1]);
else
cg = new CommGrid(lmp,world,3,1,
cg = new GridComm(lmp,world,3,1,
nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in,
nxlo_out,nxhi_out,nylo_out,nyhi_out,nzlo_out,nzhi_out,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -901,14 +901,14 @@ void PPPM::allocate_peratom()
if (differentiation_flag == 1)
cg_peratom =
new CommGrid(lmp,world,6,1,
new GridComm(lmp,world,6,1,
nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in,
nxlo_out,nxhi_out,nylo_out,nyhi_out,nzlo_out,nzhi_out,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
procneigh[1][1],procneigh[2][0],procneigh[2][1]);
else
cg_peratom =
new CommGrid(lmp,world,7,1,
new GridComm(lmp,world,7,1,
nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in,
nxlo_out,nxhi_out,nylo_out,nyhi_out,nzlo_out,nzhi_out,
procneigh[0][0],procneigh[0][1],procneigh[1][0],

4
src/KSPACE/pppm.h
View File

@ -93,8 +93,8 @@ class PPPM : public KSpace {
class FFT3d *fft1,*fft2;
class Remap *remap;
class CommGrid *cg;
class CommGrid *cg_peratom;
class GridComm *cg;
class GridComm *cg_peratom;
int **part2grid; // storage for particle -> grid mapping
int nmax;

2
src/KSPACE/pppm_cg.cpp
View File

@ -22,7 +22,7 @@
#include "string.h"
#include "atom.h"
#include "commgrid.h"
#include "gridcomm.h"
#include "domain.h"
#include "error.h"
#include "force.h"

42
src/KSPACE/pppm_disp.cpp
View File

@ -26,7 +26,7 @@
#include "math_const.h"
#include "atom.h"
#include "comm.h"
#include "commgrid.h"
#include "gridcomm.h"
#include "neighbor.h"
#include "force.h"
#include "pair.h"
@ -348,7 +348,7 @@ void PPPMDisp::init()
int iteration = 0;
if (function[0]) {
CommGrid *cgtmp = NULL;
GridComm *cgtmp = NULL;
while (order >= minorder) {
if (iteration && me == 0)
@ -376,7 +376,7 @@ void PPPMDisp::init()
if (overlap_allowed) break;
cgtmp = new CommGrid(lmp, world,1,1,
cgtmp = new GridComm(lmp, world,1,1,
nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in,
nxlo_out,nxhi_out,nylo_out,nyhi_out,
nzlo_out,nzhi_out,
@ -445,7 +445,7 @@ void PPPMDisp::init()
iteration = 0;
if (function[1] + function[2] + function[3]) {
CommGrid *cgtmp = NULL;
GridComm *cgtmp = NULL;
while (order_6 >= minorder) {
if (iteration && me == 0)
@ -471,7 +471,7 @@ void PPPMDisp::init()
if (overlap_allowed) break;
cgtmp = new CommGrid(lmp,world,1,1,
cgtmp = new GridComm(lmp,world,1,1,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,
nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,
@ -1654,13 +1654,13 @@ void PPPMDisp::allocate()
// create ghost grid object for rho and electric field communication
if (differentiation_flag == 1)
cg = new CommGrid(lmp,world,1,1,
cg = new GridComm(lmp,world,1,1,
nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in,
nxlo_out,nxhi_out,nylo_out,nyhi_out,nzlo_out,nzhi_out,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
procneigh[1][1],procneigh[2][0],procneigh[2][1]);
else
cg = new CommGrid(lmp,world,3,1,
cg = new GridComm(lmp,world,3,1,
nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in,
nxlo_out,nxhi_out,nylo_out,nyhi_out,nzlo_out,nzhi_out,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -1733,13 +1733,13 @@ void PPPMDisp::allocate()
// create ghost grid object for rho and electric field communication
if (differentiation_flag == 1)
cg_6 = new CommGrid(lmp,world,1,1,
cg_6 = new GridComm(lmp,world,1,1,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
procneigh[1][1],procneigh[2][0],procneigh[2][1]);
else
cg_6 = new CommGrid(lmp,world,3,1,
cg_6 = new GridComm(lmp,world,3,1,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -1890,13 +1890,13 @@ void PPPMDisp::allocate()
if (differentiation_flag == 1)
cg_6 = new CommGrid(lmp,world,7,7,
cg_6 = new GridComm(lmp,world,7,7,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
procneigh[1][1],procneigh[2][0],procneigh[2][1]);
else
cg_6 = new CommGrid(lmp,world,21,7,
cg_6 = new GridComm(lmp,world,21,7,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -1969,13 +1969,13 @@ void PPPMDisp::allocate()
// create ghost grid object for rho and electric field communication
if (differentiation_flag == 1)
cg_6 = new CommGrid(lmp,world,nsplit_alloc,nsplit_alloc,
cg_6 = new GridComm(lmp,world,nsplit_alloc,nsplit_alloc,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
procneigh[1][1],procneigh[2][0],procneigh[2][1]);
else
cg_6 = new CommGrid(lmp,world,3*nsplit_alloc,nsplit_alloc,
cg_6 = new GridComm(lmp,world,3*nsplit_alloc,nsplit_alloc,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -2017,14 +2017,14 @@ void PPPMDisp::allocate_peratom()
if (differentiation_flag == 1)
cg_peratom =
new CommGrid(lmp,world,6,1,
new GridComm(lmp,world,6,1,
nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in,
nxlo_out,nxhi_out,nylo_out,nyhi_out,nzlo_out,nzhi_out,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
procneigh[1][1],procneigh[2][0],procneigh[2][1]);
else
cg_peratom =
new CommGrid(lmp,world,7,1,
new GridComm(lmp,world,7,1,
nxlo_in,nxhi_in,nylo_in,nyhi_in,nzlo_in,nzhi_in,
nxlo_out,nxhi_out,nylo_out,nyhi_out,nzlo_out,nzhi_out,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -2056,14 +2056,14 @@ void PPPMDisp::allocate_peratom()
if (differentiation_flag == 1)
cg_peratom_6 =
new CommGrid(lmp,world,6,1,
new GridComm(lmp,world,6,1,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
procneigh[1][1],procneigh[2][0],procneigh[2][1]);
else
cg_peratom_6 =
new CommGrid(lmp,world,7,1,
new GridComm(lmp,world,7,1,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -2185,14 +2185,14 @@ void PPPMDisp::allocate_peratom()
if (differentiation_flag == 1)
cg_peratom_6 =
new CommGrid(lmp,world,42,1,
new GridComm(lmp,world,42,1,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
procneigh[1][1],procneigh[2][0],procneigh[2][1]);
else
cg_peratom_6 =
new CommGrid(lmp,world,49,1,
new GridComm(lmp,world,49,1,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
@ -2223,14 +2223,14 @@ void PPPMDisp::allocate_peratom()
if (differentiation_flag == 1)
cg_peratom_6 =
new CommGrid(lmp,world,6*nsplit_alloc,1,
new GridComm(lmp,world,6*nsplit_alloc,1,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],
procneigh[1][1],procneigh[2][0],procneigh[2][1]);
else
cg_peratom_6 =
new CommGrid(lmp,world,7*nsplit_alloc,1,
new GridComm(lmp,world,7*nsplit_alloc,1,
nxlo_in_6,nxhi_in_6,nylo_in_6,nyhi_in_6,nzlo_in_6,nzhi_in_6,
nxlo_out_6,nxhi_out_6,nylo_out_6,nyhi_out_6,nzlo_out_6,nzhi_out_6,
procneigh[0][0],procneigh[0][1],procneigh[1][0],

8
src/KSPACE/pppm_disp.h
View File

@ -187,10 +187,10 @@ Variables needed for calculating the 1/r and 1/r^6 potential
class FFT3d *fft1_6, *fft2_6;
class Remap *remap;
class Remap *remap_6;
class CommGrid *cg;
class CommGrid *cg_peratom;
class CommGrid *cg_6;
class CommGrid *cg_peratom_6;
class GridComm *cg;
class GridComm *cg_peratom;
class GridComm *cg_6;
class GridComm *cg_peratom_6;
int **part2grid; // storage for particle -> grid mapping
int **part2grid_6;

2
src/KSPACE/pppm_stagger.cpp
View File

@ -23,7 +23,7 @@
#include "math.h"
#include "pppm_stagger.h"
#include "atom.h"
#include "commgrid.h"
#include "gridcomm.h"
#include "force.h"
#include "domain.h"
#include "memory.h"

2
src/USER-CUDA/comm_cuda.cpp
View File

@ -56,7 +56,7 @@ enum{SINGLE,MULTI};
setup MPI and allocate buffer space
------------------------------------------------------------------------- */
CommCuda::CommCuda(LAMMPS *lmp):Comm(lmp)
CommCuda::CommCuda(LAMMPS *lmp) : CommBrick(lmp)
{
cuda = lmp->cuda;
if(cuda == NULL)

4
src/USER-CUDA/comm_cuda.h
View File

@ -17,11 +17,11 @@
#include "pointers.h"
#include "cuda_data.h"
#include "comm.h"
#include "comm_brick.h"
namespace LAMMPS_NS {
class CommCuda : public Comm {
class CommCuda : public CommBrick {
public:
CommCuda(class LAMMPS *);
~CommCuda();

6
src/accelerator_cuda.h
View File

@ -31,7 +31,7 @@
// dummy interface to USER-CUDA
// needed for compiling when USER-CUDA is not installed
#include "comm.h"
#include "comm_brick.h"
#include "domain.h"
#include "neighbor.h"
#include "modify.h"
@ -52,9 +52,9 @@ class Cuda {
void uploadAll() {}
};
class CommCuda : public Comm {
class CommCuda : public CommBrick {
public:
CommCuda(class LAMMPS *lmp) : Comm(lmp) {}
CommCuda(class LAMMPS *lmp) : CommBrick(lmp) {}
~CommCuda() {}
};

6
src/accelerator_kokkos.h
View File

@ -32,7 +32,7 @@
// needed for compiling when KOKKOS is not installed
#include "atom.h"
#include "comm.h"
#include "comm_brick.h"
#include "domain.h"
#include "neighbor.h"
#include "modify.h"
@ -56,9 +56,9 @@ class AtomKokkos : public Atom {
~AtomKokkos() {}
};
class CommKokkos : public Comm {
class CommKokkos : public CommBrick {
public:
CommKokkos(class LAMMPS *lmp) : Comm(lmp) {}
CommKokkos(class LAMMPS *lmp) : CommBrick(lmp) {}
~CommKokkos() {}
};

214
src/balance.cpp
View File

@ -30,7 +30,8 @@
using namespace LAMMPS_NS;
enum{NONE,UNIFORM,USER,DYNAMIC};
enum{XYZ,SHIFT,RCB};
enum{NONE,UNIFORM,USER};
enum{X,Y,Z};
/* ---------------------------------------------------------------------- */
@ -44,7 +45,7 @@ Balance::Balance(LAMMPS *lmp) : Pointers(lmp)
memory->create(allproccount,nprocs,"balance:allproccount");
user_xsplit = user_ysplit = user_zsplit = NULL;
dflag = 0;
shift_allocate = 0;
fp = NULL;
firststep = 1;
@ -61,7 +62,7 @@ Balance::~Balance()
delete [] user_ysplit;
delete [] user_zsplit;
if (dflag) {
if (shift_allocate) {
delete [] bdim;
delete [] count;
delete [] sum;
@ -89,18 +90,21 @@ void Balance::command(int narg, char **arg)
// parse arguments
if (narg < 1) error->all(FLERR,"Illegal balance command");
if (narg < 2) error->all(FLERR,"Illegal balance command");
thresh = force->numeric(FLERR,arg[0]);
int dimension = domain->dimension;
int *procgrid = comm->procgrid;
style = -1;
xflag = yflag = zflag = NONE;
dflag = 0;
outflag = 0;
int iarg = 0;
int iarg = 1;
while (iarg < narg) {
if (strcmp(arg[iarg],"x") == 0) {
if (xflag == DYNAMIC) error->all(FLERR,"Illegal balance command");
if (style != -1 && style != XYZ)
error->all(FLERR,"Illegal balance command");
style = XYZ;
if (strcmp(arg[iarg+1],"uniform") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal balance command");
xflag = UNIFORM;
@ -118,7 +122,9 @@ void Balance::command(int narg, char **arg)
user_xsplit[procgrid[0]] = 1.0;
}
} else if (strcmp(arg[iarg],"y") == 0) {
if (yflag == DYNAMIC) error->all(FLERR,"Illegal balance command");
if (style != -1 && style != XYZ)
error->all(FLERR,"Illegal balance command");
style = XYZ;
if (strcmp(arg[iarg+1],"uniform") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal balance command");
yflag = UNIFORM;
@ -136,7 +142,9 @@ void Balance::command(int narg, char **arg)
user_ysplit[procgrid[1]] = 1.0;
}
} else if (strcmp(arg[iarg],"z") == 0) {
if (zflag == DYNAMIC) error->all(FLERR,"Illegal balance command");
if (style != -1 && style != XYZ)
error->all(FLERR,"Illegal balance command");
style = XYZ;
if (strcmp(arg[iarg+1],"uniform") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal balance command");
zflag = UNIFORM;
@ -154,22 +162,32 @@ void Balance::command(int narg, char **arg)
user_zsplit[procgrid[2]] = 1.0;
}
} else if (strcmp(arg[iarg],"dynamic") == 0) {
if (xflag != NONE || yflag != NONE || zflag != NONE)
error->all(FLERR,"Illegal balance command");
} else if (strcmp(arg[iarg],"shift") == 0) {
if (style != -1) error->all(FLERR,"Illegal balance command");
if (iarg+4 > narg) error->all(FLERR,"Illegal balance command");
dflag = 1;
xflag = yflag = DYNAMIC;
if (dimension == 3) zflag = DYNAMIC;
style = SHIFT;
if (strlen(arg[iarg+1]) > 3) error->all(FLERR,"Illegal balance command");
strcpy(bstr,arg[iarg+1]);
nitermax = force->inumeric(FLERR,arg[iarg+2]);
if (nitermax <= 0) error->all(FLERR,"Illegal balance command");
thresh = force->numeric(FLERR,arg[iarg+3]);
if (thresh < 1.0) error->all(FLERR,"Illegal balance command");
stopthresh = force->numeric(FLERR,arg[iarg+3]);
if (stopthresh < 1.0) error->all(FLERR,"Illegal balance command");
iarg += 4;
} else if (strcmp(arg[iarg],"out") == 0) {
} else if (strcmp(arg[iarg],"rcb") == 0) {
if (style != -1) error->all(FLERR,"Illegal balance command");
style = RCB;
iarg++;
} else break;
}
// optional keywords
outflag = 0;
while (iarg < narg) {
if (strcmp(arg[iarg],"out") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal balance command");
if (outflag) error->all(FLERR,"Illegal balance command");
outflag = 1;
@ -183,50 +201,58 @@ void Balance::command(int narg, char **arg)
// error check
if (zflag && dimension == 2)
error->all(FLERR,"Cannot balance in z dimension for 2d simulation");
if (style == XYZ) {
if (zflag != NONE && dimension == 2)
error->all(FLERR,"Cannot balance in z dimension for 2d simulation");
if (xflag == USER)
for (int i = 1; i <= procgrid[0]; i++)
if (user_xsplit[i-1] >= user_xsplit[i])
error->all(FLERR,"Illegal balance command");
if (yflag == USER)
for (int i = 1; i <= procgrid[1]; i++)
if (user_ysplit[i-1] >= user_ysplit[i])
error->all(FLERR,"Illegal balance command");
if (zflag == USER)
for (int i = 1; i <= procgrid[2]; i++)
if (user_zsplit[i-1] >= user_zsplit[i])
error->all(FLERR,"Illegal balance command");
if (xflag == USER)
for (int i = 1; i <= procgrid[0]; i++)
if (user_xsplit[i-1] >= user_xsplit[i])
error->all(FLERR,"Illegal balance command");
if (yflag == USER)
for (int i = 1; i <= procgrid[1]; i++)
if (user_ysplit[i-1] >= user_ysplit[i])
error->all(FLERR,"Illegal balance command");
if (zflag == USER)
for (int i = 1; i <= procgrid[2]; i++)
if (user_zsplit[i-1] >= user_zsplit[i])
error->all(FLERR,"Illegal balance command");
}
if (dflag) {
if (style == SHIFT) {
const int blen=strlen(bstr);
for (int i = 0; i < blen; i++) {
if (bstr[i] != 'x' && bstr[i] != 'y' && bstr[i] != 'z')
error->all(FLERR,"Balance dynamic string is invalid");
error->all(FLERR,"Balance shift string is invalid");
if (bstr[i] == 'z' && dimension == 2)
error->all(FLERR,"Balance dynamic string is invalid");
error->all(FLERR,"Balance shift string is invalid");
for (int j = i+1; j < blen; j++)
if (bstr[i] == bstr[j])
error->all(FLERR,"Balance dynamic string is invalid");
error->all(FLERR,"Balance shift string is invalid");
}
}
// insure atoms are in current box & update box via shrink-wrap
// no exchange() since doesn't matter if atoms are assigned to correct procs
// init entire system since comm->setup is done
// comm::init needs neighbor::init needs pair::init needs kspace::init, etc
lmp->init();
if (domain->triclinic) domain->x2lamda(atom->nlocal);
domain->pbc();
domain->reset_box();
comm->setup();
comm->exchange();
if (domain->triclinic) domain->lamda2x(atom->nlocal);
// imbinit = initial imbalance
// use current splits instead of nlocal since atoms may not be in sub-box
domain->x2lamda(atom->nlocal);
int maxinit;
double imbinit = imbalance_splits(maxinit);
domain->lamda2x(atom->nlocal);
double imbinit = imbalance_nlocal(maxinit);
// no load-balance if imbalance doesn't exceed threshhold
if (imbinit < thresh) return;
// debug output of initial state
@ -236,40 +262,55 @@ void Balance::command(int narg, char **arg)
int niter = 0;
// explicit setting of sub-domain sizes
// NOTE: if using XYZ or SHIFT and current partition is TILING,
// then need to create initial BRICK partition before performing LB
if (xflag == UNIFORM) {
for (int i = 0; i < procgrid[0]; i++)
comm->xsplit[i] = i * 1.0/procgrid[0];
comm->xsplit[procgrid[0]] = 1.0;
// perform load-balance
// style XYZ = explicit setting of cutting planes of logical 3d grid
if (style == XYZ) {
if (xflag == UNIFORM) {
for (int i = 0; i < procgrid[0]; i++)
comm->xsplit[i] = i * 1.0/procgrid[0];
comm->xsplit[procgrid[0]] = 1.0;
}
if (yflag == UNIFORM) {
for (int i = 0; i < procgrid[1]; i++)
comm->ysplit[i] = i * 1.0/procgrid[1];
comm->ysplit[procgrid[1]] = 1.0;
}
if (zflag == UNIFORM) {
for (int i = 0; i < procgrid[2]; i++)
comm->zsplit[i] = i * 1.0/procgrid[2];
comm->zsplit[procgrid[2]] = 1.0;
}
if (xflag == USER)
for (int i = 0; i <= procgrid[0]; i++) comm->xsplit[i] = user_xsplit[i];
if (yflag == USER)
for (int i = 0; i <= procgrid[1]; i++) comm->ysplit[i] = user_ysplit[i];
if (zflag == USER)
for (int i = 0; i <= procgrid[2]; i++) comm->zsplit[i] = user_zsplit[i];
}
if (yflag == UNIFORM) {
for (int i = 0; i < procgrid[1]; i++)
comm->ysplit[i] = i * 1.0/procgrid[1];
comm->ysplit[procgrid[1]] = 1.0;
}
// style SHIFT = adjust cutting planes of logical 3d grid
if (zflag == UNIFORM) {
for (int i = 0; i < procgrid[2]; i++)
comm->zsplit[i] = i * 1.0/procgrid[2];
comm->zsplit[procgrid[2]] = 1.0;
}
if (xflag == USER)
for (int i = 0; i <= procgrid[0]; i++) comm->xsplit[i] = user_xsplit[i];
if (yflag == USER)
for (int i = 0; i <= procgrid[1]; i++) comm->ysplit[i] = user_ysplit[i];
if (zflag == USER)
for (int i = 0; i <= procgrid[2]; i++) comm->zsplit[i] = user_zsplit[i];
// static load-balance of sub-domain sizes
if (dflag) {
if (style == SHIFT) {
static_setup(bstr);
niter = dynamic();
niter = shift();
}
// style RCB =
if (style == RCB) {
error->all(FLERR,"Balance rcb is not yet supported");
if (comm->style == 0)
error->all(FLERR,"Cannot use balance rcb with comm_style brick");
}
// output of final result
@ -279,15 +320,18 @@ void Balance::command(int narg, char **arg)
// reset comm->uniform flag if necessary
if (comm->uniform) {
if (xflag == USER || xflag == DYNAMIC) comm->uniform = 0;
if (yflag == USER || yflag == DYNAMIC) comm->uniform = 0;
if (zflag == USER || zflag == DYNAMIC) comm->uniform = 0;
if (style == SHIFT) comm->uniform = 0;
if (style == XYZ && xflag == USER) comm->uniform = 0;
if (style == XYZ && yflag == USER) comm->uniform = 0;
if (style == XYZ && zflag == USER) comm->uniform = 0;
} else {
if (dimension == 3) {
if (xflag == UNIFORM && yflag == UNIFORM && zflag == UNIFORM)
if (style == XYZ &&
xflag == UNIFORM && yflag == UNIFORM && zflag == UNIFORM)
comm->uniform = 1;
} else {
if (xflag == UNIFORM && yflag == UNIFORM) comm->uniform = 1;
if (style == XYZ && xflag == UNIFORM && yflag == UNIFORM)
comm->uniform = 1;
}
}
@ -431,6 +475,8 @@ double Balance::imbalance_splits(int &max)
void Balance::static_setup(char *str)
{
shift_allocate = 1;
ndim = strlen(str);
bdim = new int[ndim];
@ -456,17 +502,16 @@ void Balance::static_setup(char *str)
}
/* ----------------------------------------------------------------------
setup dynamic load balance operations
setup shift load balance operations
called from fix balance
set rho = 1 for dynamic balancing after call to dynamic_setup()
set rho = 1 for shift balancing after call to shift_setup()
------------------------------------------------------------------------- */
void Balance::dynamic_setup(char *str, int nitermax_in, double thresh_in)
void Balance::shift_setup(char *str, int nitermax_in, double thresh_in)
{
dflag = 1;
static_setup(str);
nitermax = nitermax_in;
thresh = thresh_in;
stopthresh = thresh_in;
rho = 1;
}
@ -477,7 +522,7 @@ void Balance::dynamic_setup(char *str, int nitermax_in, double thresh_in)
return niter = iteration count
------------------------------------------------------------------------- */
int Balance::dynamic()
int Balance::shift()
{
int i,j,k,m,np,max;
double *split = NULL;
@ -490,7 +535,7 @@ int Balance::dynamic()
// set delta for 1d balancing = root of threshhold
// root = # of dimensions being balanced on
double delta = pow(thresh,1.0/ndim) - 1.0;
double delta = pow(stopthresh,1.0/ndim) - 1.0;
int *procgrid = comm->procgrid;
// all balancing done in lamda coords
@ -624,7 +669,7 @@ int Balance::dynamic()
// this is a true 3d test of particle count per processor
double imbfactor = imbalance_splits(max);
if (imbfactor <= thresh) break;
if (imbfactor <= stopthresh) break;
}
// restore real coords
@ -867,6 +912,7 @@ void Balance::dumpout(bigint tstep, FILE *bfp)
debug output for Idim and count
only called by proc 0
------------------------------------------------------------------------- */
#ifdef BALANCE_DEBUG
void Balance::debug_output(int idim, int m, int np, double *split)
{

12
src/balance.h
View File

@ -30,22 +30,24 @@ class Balance : protected Pointers {
Balance(class LAMMPS *);
~Balance();
void command(int, char **);
void dynamic_setup(char *, int, double);
int dynamic();
void shift_setup(char *, int, double);
int shift();
double imbalance_nlocal(int &);
void dumpout(bigint, FILE *);
private:
int me,nprocs;
double thresh; // threshhold to perform LB
int style; // style of LB
int xflag,yflag,zflag; // xyz LB flags
double *user_xsplit,*user_ysplit,*user_zsplit; // params for xyz LB
int dflag; // dynamic LB flag
int nitermax; // params for dynamic LB
double thresh;
int nitermax; // params for shift LB
double stopthresh;
char bstr[4];
int shift_allocate; // 1 if SHIFT vectors have been allocated
int ndim; // length of balance string bstr
int *bdim; // XYZ for each character in bstr
bigint *count; // counts for slices in one dim

1863
src/comm.cpp
View File

File diff suppressed because it is too large Load Diff

175
src/comm.h
View File

@ -20,6 +20,10 @@ namespace LAMMPS_NS {
class Comm : protected Pointers {
public:
int style; // comm pattern: 0 = 6-way stencil, 1 = irregular tiling
int layout; // current proc domains: 0 = logical bricks, 1 = general tiling
// can do style=1 on layout=0, but not vice versa
int me,nprocs; // proc info
int procgrid[3]; // procs assigned in each dim of 3d grid
int user_procgrid[3]; // user request for procs in each dim
@ -42,63 +46,50 @@ class Comm : protected Pointers {
Comm(class LAMMPS *);
virtual ~Comm();
void modify_params(int, char **);
virtual void init();
void set_processors(int, char **); // set 3d processor grid attributes
virtual void set_proc_grid(int outflag = 1); // setup 3d grid of procs
virtual void setup(); // setup 3d comm pattern
virtual void forward_comm(int dummy = 0); // forward comm of atom coords
virtual void reverse_comm(); // reverse comm of forces
virtual void exchange(); // move atoms to new procs
virtual void borders(); // setup list of atoms to comm
virtual void forward_comm_pair(class Pair *); // forward comm from a Pair
virtual void reverse_comm_pair(class Pair *); // reverse comm from a Pair
virtual void forward_comm_fix(class Fix *); // forward comm from a Fix
virtual void reverse_comm_fix(class Fix *); // reverse comm from a Fix
virtual void forward_comm_variable_fix(class Fix *); // variable-size variant
virtual void reverse_comm_variable_fix(class Fix *); // variable-size variant
virtual void forward_comm_compute(class Compute *); // forward from a Compute
virtual void reverse_comm_compute(class Compute *); // reverse from a Compute
virtual void forward_comm_dump(class Dump *); // forward comm from a Dump
virtual void reverse_comm_dump(class Dump *); // reverse comm from a Dump
void forward_comm_array(int, double **); // forward comm of array
virtual void init() = 0;
virtual void setup() = 0; // setup 3d comm pattern
virtual void forward_comm(int dummy = 0) = 0; // forward comm of atom coords
virtual void reverse_comm() = 0; // reverse comm of forces
virtual void exchange() = 0; // move atoms to new procs
virtual void borders() = 0; // setup list of atoms to comm
int exchange_variable(int, double *, // exchange of info on neigh stencil
double *&);
void ring(int, int, void *, int, void (*)(int, char *), // ring comm
// forward/reverse comm from a Pair, Fix, Compute, Dump
virtual void forward_comm_pair(class Pair *) = 0;
virtual void reverse_comm_pair(class Pair *) = 0;
virtual void forward_comm_fix(class Fix *) = 0;
virtual void reverse_comm_fix(class Fix *) = 0;
virtual void forward_comm_variable_fix(class Fix *) = 0;
virtual void reverse_comm_variable_fix(class Fix *) = 0;
virtual void forward_comm_compute(class Compute *) = 0;
virtual void reverse_comm_compute(class Compute *) = 0;
virtual void forward_comm_dump(class Dump *) = 0;
virtual void reverse_comm_dump(class Dump *) = 0;
// forward comm of an array
// exchange of info on neigh stencil
// set processor mapping options
virtual void forward_comm_array(int, double **) = 0;
virtual int exchange_variable(int, double *, double *&) = 0;
virtual bigint memory_usage() = 0;
// non-virtual functions common to all Comm styles
void ring(int, int, void *, int, void (*)(int, char *),
void *, int self = 1);
int read_lines_from_file(FILE *, int, int, char *); // read/bcast file lines
int read_lines_from_file(FILE *, int, int, char *);
int read_lines_from_file_universe(FILE *, int, int, char *);
virtual void set(int, char **); // set communication style
void set_processors(int, char **); // set 3d processor grid attributes
virtual bigint memory_usage();
protected:
int style; // single vs multi-type comm
int nswap; // # of swaps to perform = sum of maxneed
int recvneed[3][2]; // # of procs away I recv atoms from
int sendneed[3][2]; // # of procs away I send atoms to
int maxneed[3]; // max procs away any proc needs, per dim
int triclinic; // 0 if domain is orthog, 1 if triclinic
int maxswap; // max # of swaps memory is allocated for
int size_forward; // # of per-atom datums in forward comm
int size_reverse; // # of datums in reverse comm
int size_border; // # of datums in forward border comm
int *sendnum,*recvnum; // # of atoms to send/recv in each swap
int *sendproc,*recvproc; // proc to send/recv to/from at each swap
int *size_forward_recv; // # of values to recv in each forward comm
int *size_reverse_send; // # to send in each reverse comm
int *size_reverse_recv; // # to recv in each reverse comm
double *slablo,*slabhi; // bounds of slab to send at each swap
double **multilo,**multihi; // bounds of slabs for multi-type swap
double **cutghostmulti; // cutghost on a per-type basis
int *pbc_flag; // general flag for sending atoms thru PBC
int **pbc; // dimension flags for PBC adjustments
int comm_x_only,comm_f_only; // 1 if only exchange x,f in for/rev comm
int map_style; // non-0 if global->local mapping is done
int bordergroup; // only communicate this group in borders
int mode; // 0 = single cutoff, 1 = multi-type cutoff
int bordergroup; // only communicate this group in borders
int gridflag; // option for creating 3d grid
int mapflag; // option for mapping procs to 3d grid
char xyz[4]; // xyz mapping of procs to 3d grid
@ -112,29 +103,6 @@ class Comm : protected Pointers {
int ncores; // # of cores per node
int coregrid[3]; // 3d grid of cores within a node
int user_coregrid[3]; // user request for cores in each dim
int *firstrecv; // where to put 1st recv atom in each swap
int **sendlist; // list of atoms to send in each swap
int *maxsendlist; // max size of send list for each swap
double *buf_send; // send buffer for all comm
double *buf_recv; // recv buffer for all comm
int maxsend,maxrecv; // current size of send/recv buffer
int maxforward,maxreverse; // max # of datums in forward/reverse comm
int maxexchange; // max # of datums/atom in exchange comm
int bufextra; // extra space beyond maxsend in send buffer
int updown(int, int, int, double, int, double *);
// compare cutoff to procs
virtual void grow_send(int, int); // reallocate send buffer
virtual void grow_recv(int); // free/allocate recv buffer
virtual void grow_list(int, int); // reallocate one sendlist
virtual void grow_swap(int); // grow swap and multi arrays
virtual void allocate_swap(int); // allocate swap arrays
virtual void allocate_multi(int); // allocate multi arrays
virtual void free_swap(); // free swap arrays
virtual void free_multi(); // free multi arrays
};
}
@ -143,67 +111,4 @@ class Comm : protected Pointers {
/* ERROR/WARNING messages:
W: OMP_NUM_THREADS environment is not set.
This environment variable must be set appropriately to use the
USER-OMP pacakge.
E: Bad grid of processors
The 3d grid of processors defined by the processors command does not
match the number of processors LAMMPS is being run on.
E: Processor count in z must be 1 for 2d simulation
Self-explanatory.
E: Illegal ... command
Self-explanatory. Check the input script syntax and compare to the
documentation for the command. You can use -echo screen as a
command-line option when running LAMMPS to see the offending line.
E: Invalid group in communicate command
Self-explanatory.
E: Communicate group != atom_modify first group
Self-explanatory.
E: Invalid cutoff in communicate command
Specified cutoff must be >= 0.0.
E: Specified processors != physical processors
The 3d grid of processors defined by the processors command does not
match the number of processors LAMMPS is being run on.
E: Cannot use processors part command without using partitions
See the command-line -partition switch.
E: Invalid partitions in processors part command
Valid partitions are numbered 1 to N and the sender and receiver
cannot be the same partition.
E: Sending partition in processors part command is already a sender
Cannot specify a partition to be a sender twice.
E: Receiving partition in processors part command is already a receiver
Cannot specify a partition to be a receiver twice.
E: Processors grid numa and map style are incompatible
Using numa for gstyle in the processors command requires using
cart for the map option.
E: Processors part option and grid style are incompatible
Cannot use gstyle numa or custom with the part option.
*/

61
src/fix_balance.cpp
View File

@ -27,12 +27,14 @@
using namespace LAMMPS_NS;
using namespace FixConst;
enum{SHIFT,RCB};
/* ---------------------------------------------------------------------- */
FixBalance::FixBalance(LAMMPS *lmp, int narg, char **arg) :
Fix(lmp, narg, arg)
{
if (narg < 7) error->all(FLERR,"Illegal fix balance command");
if (narg < 6) error->all(FLERR,"Illegal fix balance command");
box_change_domain = 1;
scalar_flag = 1;
@ -47,23 +49,24 @@ FixBalance::FixBalance(LAMMPS *lmp, int narg, char **arg) :
int dimension = domain->dimension;
nevery = force->inumeric(FLERR,arg[3]);
if (strlen(arg[4]) > 3) error->all(FLERR,"Illegal fix balance command");
strcpy(bstr,arg[4]);
nitermax = force->inumeric(FLERR,arg[5]);
thresh = force->numeric(FLERR,arg[6]);
if (nevery < 0) error->all(FLERR,"Illegal fix balance command");
thresh = force->numeric(FLERR,arg[4]);
if (nevery < 0 || nitermax <= 0 || thresh < 1.0)
error->all(FLERR,"Illegal fix balance command");
if (strcmp(arg[5],"shift") == 0) lbstyle = SHIFT;
else if (strcmp(arg[5],"rcb") == 0) lbstyle = RCB;
else error->all(FLERR,"Illegal fix balance command");
int blen = strlen(bstr);
for (int i = 0; i < blen; i++) {
if (bstr[i] != 'x' && bstr[i] != 'y' && bstr[i] != 'z')
error->all(FLERR,"Fix balance string is invalid");
if (bstr[i] == 'z' && dimension == 2)
error->all(FLERR,"Fix balance string is invalid for 2d simulation");
for (int j = i+1; j < blen; j++)
if (bstr[i] == bstr[j])
error->all(FLERR,"Fix balance string is invalid");
int iarg = 5;
if (lbstyle == SHIFT) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix balance command");
strcpy(bstr,arg[iarg+1]);
nitermax = force->inumeric(FLERR,arg[iarg+2]);
if (nitermax <= 0) error->all(FLERR,"Illegal fix balance command");
stopthresh = force->numeric(FLERR,arg[iarg+3]);
if (stopthresh < 1.0) error->all(FLERR,"Illegal fix balance command");
iarg += 4;
} else if (lbstyle == RCB) {
iarg++;
}
// optional args
@ -71,7 +74,6 @@ FixBalance::FixBalance(LAMMPS *lmp, int narg, char **arg) :
int outarg = 0;
fp = NULL;
int iarg = 7;
while (iarg < narg) {
if (strcmp(arg[iarg],"out") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix balance command");
@ -80,11 +82,27 @@ FixBalance::FixBalance(LAMMPS *lmp, int narg, char **arg) :
} else error->all(FLERR,"Illegal fix balance command");
}
// error check
if (lbstyle == SHIFT) {
int blen = strlen(bstr);
for (int i = 0; i < blen; i++) {
if (bstr[i] != 'x' && bstr[i] != 'y' && bstr[i] != 'z')
error->all(FLERR,"Fix balance shift string is invalid");
if (bstr[i] == 'z' && dimension == 2)
error->all(FLERR,"Fix balance shift string is invalid");
for (int j = i+1; j < blen; j++)
if (bstr[i] == bstr[j])
error->all(FLERR,"Fix balance shift string is invalid");
}
}
// create instance of Balance class and initialize it with params
// NOTE: do I need Balance instance if RCB?
// create instance of Irregular class
balance = new Balance(lmp);
balance->dynamic_setup(bstr,nitermax,thresh);
if (lbstyle == SHIFT) balance->shift_setup(bstr,nitermax,thresh);
irregular = new Irregular(lmp);
// output file
@ -216,13 +234,18 @@ void FixBalance::pre_neighbor()
void FixBalance::rebalance()
{
imbprev = imbnow;
itercount = balance->dynamic();
if (lbstyle == SHIFT) {
itercount = balance->shift();
} else if (lbstyle == RCB) {
}
// output of final result
if (fp) balance->dumpout(update->ntimestep,fp);
// reset comm->uniform flag
// NOTE: this needs to change with RCB
comm->uniform = 0;

4
src/fix_balance.h
View File

@ -40,9 +40,9 @@ class FixBalance : public Fix {
double memory_usage();
private:
int nevery,nitermax;
int nevery,lbstyle,nitermax;
double thresh,stopthresh;
char bstr[3];
double thresh;
FILE *fp;
double imbnow; // current imbalance factor

4
src/force.cpp
View File

@ -523,6 +523,10 @@ void Force::create_kspace(int narg, char **arg, const char *suffix)
kspace_style = new char[n];
strcpy(kspace_style,arg[0]);
}
if (comm->style == 1 && !kspace_match("ewald",0))
error->all(FLERR,
"Cannot yet use KSpace solver with grid with comm style tiled");
}
/* ----------------------------------------------------------------------

25
src/input.cpp
View File

@ -24,6 +24,8 @@
#include "atom.h"
#include "atom_vec.h"
#include "comm.h"
#include "comm_brick.h"
#include "comm_tiled.h"
#include "group.h"
#include "domain.h"
#include "output.h"
@ -553,7 +555,8 @@ int Input::execute_command()
else if (!strcmp(command,"bond_style")) bond_style();
else if (!strcmp(command,"boundary")) boundary();
else if (!strcmp(command,"box")) box();
else if (!strcmp(command,"communicate")) communicate();
else if (!strcmp(command,"comm_modify")) comm_modify();
else if (!strcmp(command,"comm_style")) comm_style();
else if (!strcmp(command,"compute")) compute();
else if (!strcmp(command,"compute_modify")) compute_modify();
else if (!strcmp(command,"dielectric")) dielectric();
@ -1145,9 +1148,25 @@ void Input::box()
/* ---------------------------------------------------------------------- */
void Input::communicate()
void Input::comm_modify()
{
comm->set(narg,arg);
comm->modify_params(narg,arg);
}
/* ---------------------------------------------------------------------- */
void Input::comm_style()
{
if (narg < 1) error->all(FLERR,"Illegal comm_style command");
if (strcmp(arg[0],"brick") == 0) {
if (comm->layout)
error->all(FLERR,
"Cannot switch to comm style brick from "
"irregular tiling of proc domains");
comm = new CommBrick(lmp);
} else if (strcmp(arg[0],"tiled") == 0) {
comm = new CommTiled(lmp);
} else error->all(FLERR,"Illegal comm_style command");
}
/* ---------------------------------------------------------------------- */

3
src/input.h
View File

@ -83,7 +83,8 @@ class Input : protected Pointers {
void bond_style();
void boundary();
void box();
void communicate();
void comm_modify();
void comm_style();
void compute();
void compute_modify();
void dielectric();

3
src/lammps.cpp
View File

@ -35,6 +35,7 @@
#include "update.h"
#include "neighbor.h"
#include "comm.h"
#include "comm_brick.h"
#include "domain.h"
#include "force.h"
#include "modify.h"
@ -558,7 +559,7 @@ void LAMMPS::create()
if (cuda) comm = new CommCuda(this);
else if (kokkos) comm = new CommKokkos(this);
else comm = new Comm(this);
else comm = new CommBrick(this);
if (cuda) neighbor = new NeighborCuda(this);
else if (kokkos) neighbor = new NeighborKokkos(this);