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

Got rid of non-standard character and cleared unneeded spaces.

Browse Source 
git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@8772 f3b2605a-c512-4ea7-a41b-209d697bcdaa
This commit is contained in:
pscrozi
2012-09-11 15:02:56 +00:00
parent 9fe1ae2936
commit 277244a376
1 changed files with 31 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
src/KSPACE/pppm.cpp
View File

@ -321,7 +321,7 @@ void PPPM::init()
// calculate the final accuracy // calculate the final accuracy
double estimated_accuracy = final_accuracy(); double estimated_accuracy = final_accuracy();
// print stats // print stats
int ngrid_max,nfft_both_max,nbuf_max; int ngrid_max,nfft_both_max,nbuf_max;
@ -456,7 +456,7 @@ void PPPM::setup()
} }
} }
} }
if (differentiation_flag == 1) { if (differentiation_flag == 1) {
compute_gf_ad(); compute_gf_ad();
} else { } else {
@ -631,7 +631,7 @@ void PPPM::allocate()
memory->create3d_offset(vdz_brick,nzlo_out,nzhi_out,nylo_out,nyhi_out, memory->create3d_offset(vdz_brick,nzlo_out,nzhi_out,nylo_out,nyhi_out,
nxlo_out,nxhi_out,"pppm:vdz_brick"); nxlo_out,nxhi_out,"pppm:vdz_brick");
} }
// summation coeffs // summation coeffs
memory->create(gf_b,order,"pppm:gf_b"); memory->create(gf_b,order,"pppm:gf_b");
@ -751,11 +751,11 @@ void PPPM::deallocate_peratom()
if (differentiation_flag != 1) if (differentiation_flag != 1)
memory->destroy3d_offset(u_brick,nzlo_out,nylo_out,nxlo_out); memory->destroy3d_offset(u_brick,nzlo_out,nylo_out,nxlo_out);
memory->destroy(buf3); memory->destroy(buf3);
memory->destroy(buf4); memory->destroy(buf4);
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
set size of FFT grid (nx,ny,nz_pppm) set size of FFT grid (nx,ny,nz_pppm)
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
@ -792,43 +792,43 @@ void PPPM::set_grid()
// reduce it until accuracy target is met // reduce it until accuracy target is met
if (!gridflag) { if (!gridflag) {
if (differentiation_flag == 1) { if (differentiation_flag == 1) {
h = h_x = h_y = h_z = 4.0/g_ewald; h = h_x = h_y = h_z = 4.0/g_ewald;
int count = 0; int count = 0;
while (1) { while (1) {
// set grid dimension // set grid dimension
nx_pppm = static_cast<int> (xprd/h_x); nx_pppm = static_cast<int> (xprd/h_x);
ny_pppm = static_cast<int> (yprd/h_y); ny_pppm = static_cast<int> (yprd/h_y);
nz_pppm = static_cast<int> (zprd_slab/h_z); nz_pppm = static_cast<int> (zprd_slab/h_z);
if (nx_pppm <= 1) nx_pppm = 2; if (nx_pppm <= 1) nx_pppm = 2;
if (ny_pppm <= 1) ny_pppm = 2; if (ny_pppm <= 1) ny_pppm = 2;
if (nz_pppm <= 1) nz_pppm = 2; if (nz_pppm <= 1) nz_pppm = 2;
//set local grid dimension //set local grid dimension
int npey_fft,npez_fft; int npey_fft,npez_fft;
if (nz_pppm >= nprocs) { if (nz_pppm >= nprocs) {
npey_fft = 1; npey_fft = 1;
npez_fft = nprocs; npez_fft = nprocs;
} else procs2grid2d(nprocs,ny_pppm,nz_pppm,&npey_fft,&npez_fft); } else procs2grid2d(nprocs,ny_pppm,nz_pppm,&npey_fft,&npez_fft);
int me_y = me % npey_fft; int me_y = me % npey_fft;
int me_z = me / npey_fft; int me_z = me / npey_fft;
nxlo_fft = 0; nxlo_fft = 0;
nxhi_fft = nx_pppm - 1; nxhi_fft = nx_pppm - 1;
nylo_fft = me_y*ny_pppm/npey_fft; nylo_fft = me_y*ny_pppm/npey_fft;
nyhi_fft = (me_y+1)*ny_pppm/npey_fft - 1; nyhi_fft = (me_y+1)*ny_pppm/npey_fft - 1;
nzlo_fft = me_z*nz_pppm/npez_fft; nzlo_fft = me_z*nz_pppm/npez_fft;
nzhi_fft = (me_z+1)*nz_pppm/npez_fft - 1; nzhi_fft = (me_z+1)*nz_pppm/npez_fft - 1;
double df_kspace = compute_df_kspace(); double df_kspace = compute_df_kspace();
count++; count++;
// break loop if the accuracy has been reached or // break loop if the accuracy has been reached or
// too many loops have been performed // too many loops have been performed
@ -1039,20 +1039,20 @@ double PPPM::estimate_ik_error(double h, double prd, bigint natoms)
void PPPM::adjust_gewald() void PPPM::adjust_gewald()
{ {
double dx; double dx;
for (int i = 0; i < LARGE; i++) { for (int i = 0; i < LARGE; i++) {
dx = newton_raphson_f() / derivf(); dx = newton_raphson_f() / derivf();
g_ewald -= dx; g_ewald -= dx;
if (fabs(newton_raphson_f()) < SMALL) return; if (fabs(newton_raphson_f()) < SMALL) return;
} }
char str[128]; char str[128];
sprintf(str, "Could not compute g_ewald"); sprintf(str, "Could not compute g_ewald");
error->all(FLERR, str); error->all(FLERR, str);
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
Calculate f(x) using Newton<EFBFBD>Raphson solver Calculate f(x) using Newton-Raphson solver
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
double PPPM::newton_raphson_f() double PPPM::newton_raphson_f()
@ -1102,12 +1102,12 @@ double PPPM::final_accuracy()
double zprd = domain->zprd; double zprd = domain->zprd;
double zprd_slab = zprd*slab_volfactor; double zprd_slab = zprd*slab_volfactor;
bigint natoms = atom->natoms; bigint natoms = atom->natoms;
double df_kspace = compute_df_kspace(); double df_kspace = compute_df_kspace();
double q2_over_sqrt = q2 / sqrt(natoms*cutoff*xprd*yprd*zprd_slab); double q2_over_sqrt = q2 / sqrt(natoms*cutoff*xprd*yprd*zprd_slab);
double df_rspace = 2.0 * q2_over_sqrt * exp(-g_ewald*g_ewald*cutoff*cutoff); double df_rspace = 2.0 * q2_over_sqrt * exp(-g_ewald*g_ewald*cutoff*cutoff);
double df_table = estimate_table_accuracy(q2_over_sqrt,df_rspace); double df_table = estimate_table_accuracy(q2_over_sqrt,df_rspace);
double estimated_accuracy = sqrt(df_kspace*df_kspace + df_rspace*df_rspace + double estimated_accuracy = sqrt(df_kspace*df_kspace + df_rspace*df_rspace +
df_table*df_table); df_table*df_table);
return estimated_accuracy; return estimated_accuracy;
@ -1123,7 +1123,7 @@ void PPPM::set_fft_parameters()
// nlo_in,nhi_in = lower/upper limits of the 3d sub-brick of // nlo_in,nhi_in = lower/upper limits of the 3d sub-brick of
// global PPPM grid that I own without ghost cells // global PPPM grid that I own without ghost cells
// for slab PPPM, assign z grid as if it were not extended // for slab PPPM, assign z grid as if it were not extended
nxlo_in = static_cast<int> (comm->xsplit[comm->myloc[0]] * nx_pppm); nxlo_in = static_cast<int> (comm->xsplit[comm->myloc[0]] * nx_pppm);
nxhi_in = static_cast<int> (comm->xsplit[comm->myloc[0]+1] * nx_pppm) - 1; nxhi_in = static_cast<int> (comm->xsplit[comm->myloc[0]+1] * nx_pppm) - 1;
@ -1133,7 +1133,7 @@ void PPPM::set_fft_parameters()
nzlo_in = static_cast<int> nzlo_in = static_cast<int>
(comm->zsplit[comm->myloc[2]] * nz_pppm/slab_volfactor); (comm->zsplit[comm->myloc[2]] * nz_pppm/slab_volfactor);
nzhi_in = static_cast<int> nzhi_in = static_cast<int>
(comm->zsplit[comm->myloc[2]+1] * nz_pppm/slab_volfactor) - 1; (comm->zsplit[comm->myloc[2]+1] * nz_pppm/slab_volfactor) - 1;
// nlower,nupper = stencil size for mapping particles to PPPM grid // nlower,nupper = stencil size for mapping particles to PPPM grid
@ -1147,7 +1147,7 @@ void PPPM::set_fft_parameters()
else shift = OFFSET; else shift = OFFSET;
if (order % 2) shiftone = 0.0; if (order % 2) shiftone = 0.0;
else shiftone = 0.5; else shiftone = 0.5;
// nlo_out,nhi_out = lower/upper limits of the 3d sub-brick of // nlo_out,nhi_out = lower/upper limits of the 3d sub-brick of
// global PPPM grid that my particles can contribute charge to // global PPPM grid that my particles can contribute charge to
// effectively nlo_in,nhi_in + ghost cells // effectively nlo_in,nhi_in + ghost cells
@ -1172,7 +1172,7 @@ void PPPM::set_fft_parameters()
sublo = domain->sublo_lamda; sublo = domain->sublo_lamda;
subhi = domain->subhi_lamda; subhi = domain->subhi_lamda;
} }
double xprd = prd[0]; double xprd = prd[0];
double yprd = prd[1]; double yprd = prd[1];
double zprd = prd[2]; double zprd = prd[2];
@ -1186,7 +1186,7 @@ void PPPM::set_fft_parameters()
dist[1] = cuthalf/domain->prd[1]; dist[1] = cuthalf/domain->prd[1];
dist[2] = cuthalf/domain->prd[2]; dist[2] = cuthalf/domain->prd[2];
} }
int nlo,nhi; int nlo,nhi;
nlo = static_cast<int> ((sublo[0]-dist[0]-boxlo[0]) * nlo = static_cast<int> ((sublo[0]-dist[0]-boxlo[0]) *
@ -1226,7 +1226,7 @@ void PPPM::set_fft_parameters()
// that overlay domain I own // that overlay domain I own
// proc in that direction tells me via sendrecv() // proc in that direction tells me via sendrecv()
// if no neighbor proc, value is from self since I have ghosts regardless // if no neighbor proc, value is from self since I have ghosts regardless
int nplanes; int nplanes;
MPI_Status status; MPI_Status status;
@ -1271,7 +1271,7 @@ void PPPM::set_fft_parameters()
&nzlo_ghost,1,MPI_INT,comm->procneigh[2][0],0, &nzlo_ghost,1,MPI_INT,comm->procneigh[2][0],0,
world,&status); world,&status);
else nzlo_ghost = nplanes; else nzlo_ghost = nplanes;
// decomposition of FFT mesh // decomposition of FFT mesh
// global indices range from 0 to N-1 // global indices range from 0 to N-1
// proc owns entire x-dimension, clump of columns in y,z dimensions // proc owns entire x-dimension, clump of columns in y,z dimensions
@ -1299,7 +1299,7 @@ void PPPM::set_fft_parameters()
nzhi_fft = (me_z+1)*nz_pppm/npez_fft - 1; nzhi_fft = (me_z+1)*nz_pppm/npez_fft - 1;
// PPPM grid for this proc, including ghosts // PPPM grid for this proc, including ghosts
ngrid = (nxhi_out-nxlo_out+1) * (nyhi_out-nylo_out+1) * ngrid = (nxhi_out-nxlo_out+1) * (nyhi_out-nylo_out+1) *
(nzhi_out-nzlo_out+1); (nzhi_out-nzlo_out+1);
@ -1393,7 +1393,7 @@ void PPPM::compute_gf_ik()
if (triclinic == 0) prd = domain->prd; if (triclinic == 0) prd = domain->prd;
else prd = domain->prd_lamda; else prd = domain->prd_lamda;
double xprd = prd[0]; double xprd = prd[0];
double yprd = prd[1]; double yprd = prd[1];
double zprd = prd[2]; double zprd = prd[2];
@ -1401,7 +1401,7 @@ void PPPM::compute_gf_ik()
double unitkx = (MY_2PI/xprd); double unitkx = (MY_2PI/xprd);
double unitky = (MY_2PI/yprd); double unitky = (MY_2PI/yprd);
double unitkz = (MY_2PI/zprd_slab); double unitkz = (MY_2PI/zprd_slab);
int nbx = static_cast<int> ((g_ewald*xprd/(MY_PI*nx_pppm)) * int nbx = static_cast<int> ((g_ewald*xprd/(MY_PI*nx_pppm)) *
pow(-log(EPS_HOC),0.25)); pow(-log(EPS_HOC),0.25));
int nby = static_cast<int> ((g_ewald*yprd/(MY_PI*ny_pppm)) * int nby = static_cast<int> ((g_ewald*yprd/(MY_PI*ny_pppm)) *
@ -1643,7 +1643,7 @@ void PPPM::compute_sf_precoeff()
if (argz != 0.0) wz0[i+2] = pow(sin(argz)/argz,order); if (argz != 0.0) wz0[i+2] = pow(sin(argz)/argz,order);
argz = 0.5*qz1/nz_pppm; argz = 0.5*qz1/nz_pppm;
if (argz != 0.0) wz1[i+2] = pow(sin(argz)/argz,order); if (argz != 0.0) wz1[i+2] = pow(sin(argz)/argz,order);
argz = 0.5*qz2/nz_pppm; argz = 0.5*qz2/nz_pppm;
if (argz != 0.0) wz2[i+2] = pow(sin(argz)/argz,order); if (argz != 0.0) wz2[i+2] = pow(sin(argz)/argz,order);
} }
@ -1681,8 +1681,6 @@ void PPPM::compute_sf_precoeff()
} }
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
ghost-swap to accumulate full density in brick decomposition ghost-swap to accumulate full density in brick decomposition
remap density from 3d brick decomposition to FFT decomposition remap density from 3d brick decomposition to FFT decomposition