* the research papers on the package. Check out http://www.gromacs.org.
*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include "gmxpre.h"
-#include <stdio.h>
-#include <time.h>
+#include "gromacs/legacyheaders/domdec.h"
+
+#include "config.h"
+
+#include <assert.h>
#include <math.h>
-#include <string.h>
+#include <stdio.h>
#include <stdlib.h>
-#include <assert.h>
+#include <string.h>
+#include <time.h>
+
+#include <algorithm>
-#include "typedefs.h"
-#include "gromacs/utility/smalloc.h"
-#include "gmx_fatal.h"
-#include "gmx_fatal_collective.h"
-#include "vec.h"
-#include "domdec.h"
-#include "domdec_network.h"
-#include "nrnb.h"
-#include "pbc.h"
-#include "chargegroup.h"
-#include "constr.h"
-#include "mdatoms.h"
-#include "names.h"
-#include "force.h"
-#include "pme.h"
-#include "mdrun.h"
-#include "nsgrid.h"
-#include "shellfc.h"
-#include "mtop_util.h"
-#include "gmx_ga2la.h"
-#include "macros.h"
-#include "nbnxn_search.h"
-#include "bondf.h"
-#include "gmx_omp_nthreads.h"
-#include "gpu_utils.h"
-
-#include "gromacs/fileio/futil.h"
#include "gromacs/fileio/gmxfio.h"
#include "gromacs/fileio/pdbio.h"
+#include "gromacs/imd/imd.h"
+#include "gromacs/legacyheaders/bonded-threading.h"
+#include "gromacs/legacyheaders/chargegroup.h"
+#include "gromacs/legacyheaders/constr.h"
+#include "gromacs/legacyheaders/domdec_network.h"
+#include "gromacs/legacyheaders/force.h"
+#include "gromacs/legacyheaders/gmx_ga2la.h"
+#include "gromacs/legacyheaders/gmx_omp_nthreads.h"
+#include "gromacs/legacyheaders/gpu_utils.h"
+#include "gromacs/legacyheaders/macros.h"
+#include "gromacs/legacyheaders/mdatoms.h"
+#include "gromacs/legacyheaders/mdrun.h"
+#include "gromacs/legacyheaders/names.h"
+#include "gromacs/legacyheaders/network.h"
+#include "gromacs/legacyheaders/nrnb.h"
+#include "gromacs/legacyheaders/nsgrid.h"
+#include "gromacs/legacyheaders/pme.h"
+#include "gromacs/legacyheaders/shellfc.h"
+#include "gromacs/legacyheaders/typedefs.h"
+#include "gromacs/listed-forces/bonded.h"
+#include "gromacs/math/vec.h"
+#include "gromacs/mdlib/nb_verlet.h"
+#include "gromacs/mdlib/nbnxn_search.h"
+#include "gromacs/pbcutil/ishift.h"
+#include "gromacs/pbcutil/pbc.h"
+#include "gromacs/pulling/pull.h"
+#include "gromacs/pulling/pull_rotation.h"
+#include "gromacs/swap/swapcoords.h"
#include "gromacs/timing/wallcycle.h"
+#include "gromacs/topology/mtop_util.h"
+#include "gromacs/utility/basenetwork.h"
+#include "gromacs/utility/fatalerror.h"
+#include "gromacs/utility/futil.h"
#include "gromacs/utility/gmxmpi.h"
-#include "gromacs/swap/swapcoords.h"
#include "gromacs/utility/qsort_threadsafe.h"
-#include "gromacs/pulling/pull.h"
-#include "gromacs/pulling/pull_rotation.h"
-#include "gromacs/imd/imd.h"
+#include "gromacs/utility/smalloc.h"
#define DDRANK(dd, rank) (rank)
#define DDMASTERRANK(dd) (dd->masterrank)
rvec *buf, *sbuf;
ivec vis;
int is;
- gmx_bool bPBC, bScrew;
+ gmx_bool bShiftForcesNeedPbc, bScrew;
comm = dd->comm;
buf = comm->vbuf.v;
- n = 0;
nzone = comm->zones.n/2;
nat_tot = dd->nat_tot;
for (d = dd->ndim-1; d >= 0; d--)
{
- bPBC = (dd->ci[dd->dim[d]] == 0);
- bScrew = (bPBC && dd->bScrewPBC && dd->dim[d] == XX);
+ /* Only forces in domains near the PBC boundaries need to
+ consider PBC in the treatment of fshift */
+ bShiftForcesNeedPbc = (dd->ci[dd->dim[d]] == 0);
+ bScrew = (bShiftForcesNeedPbc && dd->bScrewPBC && dd->dim[d] == XX);
if (fshift == NULL && !bScrew)
{
- bPBC = FALSE;
+ bShiftForcesNeedPbc = FALSE;
}
/* Determine which shift vector we need */
clear_ivec(vis);
index = ind->index;
/* Add the received forces */
n = 0;
- if (!bPBC)
+ if (!bShiftForcesNeedPbc)
{
for (i = 0; i < ind->nsend[nzone]; i++)
{
}
else if (!bScrew)
{
+ /* fshift should always be defined if this function is
+ * called when bShiftForcesNeedPbc is true */
+ assert(NULL != fshift);
for (i = 0; i < ind->nsend[nzone]; i++)
{
at0 = cgindex[index[i]];
buf = &comm->vbuf.v[0][0];
- n = 0;
nzone = comm->zones.n/2;
nat_tot = dd->nat_tot;
for (d = dd->ndim-1; d >= 0; d--)
static void dd_move_cellx(gmx_domdec_t *dd, gmx_ddbox_t *ddbox,
rvec cell_ns_x0, rvec cell_ns_x1)
{
- int d, d1, dim, dim1, pos, buf_size, i, j, k, p, npulse, npulse_min;
+ int d, d1, dim, pos, buf_size, i, j, p, npulse, npulse_min;
gmx_ddzone_t *zp;
gmx_ddzone_t buf_s[DDZONECOMM_MAXZONE];
gmx_ddzone_t buf_r[DDZONECOMM_MAXZONE];
if (bPBC)
{
/* Take the minimum to avoid double communication */
- npulse_min = min(npulse, dd->nc[dim]-1-npulse);
+ npulse_min = std::min(npulse, dd->nc[dim]-1-npulse);
}
else
{
{
for (d1 = d; d1 < dd->ndim-1; d1++)
{
- extr_s[d1][0] = max(extr_s[d1][0], extr_r[d1][0]);
- extr_s[d1][1] = min(extr_s[d1][1], extr_r[d1][1]);
- extr_s[d1][2] = min(extr_s[d1][2], extr_r[d1][2]);
+ extr_s[d1][0] = std::max(extr_s[d1][0], extr_r[d1][0]);
+ extr_s[d1][1] = std::min(extr_s[d1][1], extr_r[d1][1]);
+ extr_s[d1][2] = std::min(extr_s[d1][2], extr_r[d1][2]);
}
}
}
{
if (bUse)
{
- buf_e[i].min0 = min(buf_e[i].min0, buf_r[i].min0);
- buf_e[i].max1 = max(buf_e[i].max1, buf_r[i].max1);
- buf_e[i].min1 = min(buf_e[i].min1, buf_r[i].min1);
+ buf_e[i].min0 = std::min(buf_e[i].min0, buf_r[i].min0);
+ buf_e[i].max1 = std::max(buf_e[i].max1, buf_r[i].max1);
+ buf_e[i].min1 = std::min(buf_e[i].min1, buf_r[i].min1);
}
if (dd->ndim == 3 && d == 0 && i == buf_size - 1)
}
if (bUse && dh[d1] >= 0)
{
- buf_e[i].mch0 = max(buf_e[i].mch0, buf_r[i].mch0-dh[d1]);
- buf_e[i].mch1 = max(buf_e[i].mch1, buf_r[i].mch1-dh[d1]);
+ buf_e[i].mch0 = std::max(buf_e[i].mch0, buf_r[i].mch0-dh[d1]);
+ buf_e[i].mch1 = std::max(buf_e[i].mch1, buf_r[i].mch1-dh[d1]);
}
}
/* Copy the received buffer to the send buffer,
for (d1 = d; d1 < dd->ndim-1; d1++)
{
- extr_s[d1][1] = min(extr_s[d1][1], buf_e[pos].min0);
- extr_s[d1][0] = max(extr_s[d1][0], buf_e[pos].max1);
- extr_s[d1][2] = min(extr_s[d1][2], buf_e[pos].min1);
+ extr_s[d1][1] = std::min(extr_s[d1][1], buf_e[pos].min0);
+ extr_s[d1][0] = std::max(extr_s[d1][0], buf_e[pos].max1);
+ extr_s[d1][2] = std::min(extr_s[d1][2], buf_e[pos].min1);
pos++;
}
{
print_ddzone(debug, 1, i, 0, &comm->zone_d1[i]);
}
- cell_ns_x0[dim] = min(cell_ns_x0[dim], comm->zone_d1[i].min0);
- cell_ns_x1[dim] = max(cell_ns_x1[dim], comm->zone_d1[i].max1);
+ cell_ns_x0[dim] = std::min(cell_ns_x0[dim], comm->zone_d1[i].min0);
+ cell_ns_x1[dim] = std::max(cell_ns_x1[dim], comm->zone_d1[i].max1);
}
}
if (dd->ndim >= 3)
{
print_ddzone(debug, 2, i, j, &comm->zone_d2[i][j]);
}
- cell_ns_x0[dim] = min(cell_ns_x0[dim], comm->zone_d2[i][j].min0);
- cell_ns_x1[dim] = max(cell_ns_x1[dim], comm->zone_d2[i][j].max1);
+ cell_ns_x0[dim] = std::min(cell_ns_x0[dim], comm->zone_d2[i][j].min0);
+ cell_ns_x1[dim] = std::max(cell_ns_x1[dim], comm->zone_d2[i][j].max1);
}
}
}
void dd_collect_vec(gmx_domdec_t *dd,
t_state *state_local, rvec *lv, rvec *v)
{
- gmx_domdec_master_t *ma;
- int n, i, c, a, nalloc = 0;
- rvec *buf = NULL;
-
dd_collect_cg(dd, state_local);
if (dd->nnodes <= GMX_DD_NNODES_SENDRECV)
{
gmx_domdec_master_t *ma;
int *scounts = NULL, *disps = NULL;
- int n, i, c, a, nalloc = 0;
+ int n, i, c, a;
rvec *buf = NULL;
if (DDMASTER(dd))
snew(grid_r, 2*dd->nnodes);
}
- dd_gather(dd, 2*sizeof(rvec), grid_s[0], DDMASTER(dd) ? grid_r[0] : NULL);
+ dd_gather(dd, 2*sizeof(rvec), grid_s, DDMASTER(dd) ? grid_r : NULL);
if (DDMASTER(dd))
{
r = comm->cellsize_min[dd->dim[0]];
for (di = 1; di < dd->ndim; di++)
{
- r = min(r, comm->cellsize_min[dd->dim[di]]);
+ r = std::min(r, comm->cellsize_min[dd->dim[di]]);
}
if (comm->bBondComm)
{
- r = max(r, comm->cutoff_mbody);
+ r = std::max(r, comm->cutoff_mbody);
}
else
{
- r = min(r, comm->cutoff);
+ r = std::min(r, comm->cutoff);
}
}
}
r_mb = dd_cutoff_mbody(dd);
- return max(dd->comm->cutoff, r_mb);
+ return std::max(dd->comm->cutoff, r_mb);
}
static int gmx_ddcoord2pmeindex(t_commrec *cr, int x, int y, int z)
{
gmx_domdec_t *dd;
- ivec coords, coords_pme, nc;
+ ivec coords;
int slab;
dd = cr->dd;
{
gmx_domdec_t *dd;
gmx_domdec_comm_t *comm;
- ivec coord, coord_pme;
int i;
int pmenode = -1;
if (comm->bCartesianPP_PME)
{
#ifdef GMX_MPI
+ ivec coord, coord_pme;
MPI_Cart_coords(cr->mpi_comm_mysim, sim_nodeid, DIM, coord);
if (coord[comm->cartpmedim] < dd->nc[comm->cartpmedim])
{
static gmx_bool receive_vir_ener(t_commrec *cr)
{
gmx_domdec_comm_t *comm;
- int pmenode, coords[DIM], rank;
+ int pmenode;
gmx_bool bReceive;
bReceive = TRUE;
{
pmenode = dd_simnode2pmenode(cr, cr->sim_nodeid);
#ifdef GMX_MPI
+ ivec coords;
MPI_Cart_coords(cr->mpi_comm_mysim, cr->sim_nodeid, DIM, coords);
coords[comm->cartpmedim]++;
if (coords[comm->cartpmedim] < cr->dd->nc[comm->cartpmedim])
{
+ int rank;
MPI_Cart_rank(cr->mpi_comm_mysim, coords, &rank);
if (dd_simnode2pmenode(cr, rank) == pmenode)
{
{
int nzone, zone, zone1, cg0, cg1, cg1_p1, cg, cg_gl, a, a_gl;
int *zone2cg, *zone_ncg1, *index_gl, *gatindex;
- gmx_ga2la_t *ga2la;
- char *bLocalCG;
gmx_bool bCGs;
- bLocalCG = dd->comm->bLocalCG;
-
if (dd->nat_tot > dd->gatindex_nalloc)
{
dd->gatindex_nalloc = over_alloc_dd(dd->nat_tot);
static int check_bLocalCG(gmx_domdec_t *dd, int ncg_sys, const char *bLocalCG,
const char *where)
{
- int ncg, i, ngl, nerr;
+ int i, ngl, nerr;
nerr = 0;
if (bLocalCG == NULL)
/* The cut-off might have changed, e.g. by PME load balacning,
* from the value used to set comm->cellsize_min, so check it.
*/
- cellsize_min = max(cellsize_min, comm->cutoff/comm->cd[dim_ind].np_dlb);
+ cellsize_min = std::max(cellsize_min, comm->cutoff/comm->cd[dim_ind].np_dlb);
if (comm->bPMELoadBalDLBLimits)
{
/* Check for the cut-off limit set by the PME load balancing */
- cellsize_min = max(cellsize_min, comm->PMELoadBal_max_cutoff/comm->cd[dim_ind].np_dlb);
+ cellsize_min = std::max(cellsize_min, comm->PMELoadBal_max_cutoff/comm->cd[dim_ind].np_dlb);
}
}
{
if (comm->bPMELoadBalDLBLimits)
{
- cutoff = max(cutoff, comm->PMELoadBal_max_cutoff);
+ cutoff = std::max(cutoff, comm->PMELoadBal_max_cutoff);
}
- grid_jump_limit = max(grid_jump_limit,
- cutoff/comm->cd[dim_ind].np);
+ grid_jump_limit = std::max(grid_jump_limit,
+ cutoff/comm->cd[dim_ind].np);
}
return grid_jump_limit;
{
slab = pmeindex % ddpme->nslab;
}
- ddpme->pp_min[slab] = min(ddpme->pp_min[slab], xyz[dimind]);
- ddpme->pp_max[slab] = max(ddpme->pp_max[slab], xyz[dimind]);
+ ddpme->pp_min[slab] = std::min(ddpme->pp_min[slab], xyz[dimind]);
+ ddpme->pp_max[slab] = std::max(ddpme->pp_max[slab], xyz[dimind]);
}
}
{
npulse[d]++;
}
- cellsize_min[d] = min(cellsize_min[d], cellsize);
+ cellsize_min[d] = std::min(cellsize_min[d], cellsize);
}
if (setmode == setcellsizeslbLOCAL)
{
gmx_bool bUniform, gmx_int64_t step)
{
gmx_domdec_comm_t *comm;
- int ncd, d1, i, j, pos;
+ int ncd, d1, i, pos;
real *cell_size;
real load_aver, load_i, imbalance, change, change_max, sc;
real cellsize_limit_f, dist_min_f, dist_min_f_hard, space;
imbalance = (load_i - load_aver)/(load_aver > 0 ? load_aver : 1);
/* Determine the change of the cell size using underrelaxation */
change = -relax*imbalance;
- change_max = max(change_max, max(change, -change));
+ change_max = std::max(change_max, std::max(change, -change));
}
/* Limit the amount of scaling.
* We need to use the same rescaling for all cells in one row,
gmx_ddbox_t *ddbox)
{
gmx_domdec_comm_t *comm;
- int d1, dim1, pos;
+ int d1, pos;
comm = dd->comm;
{
gmx_domdec_master_t *ma;
int **tmp_ind = NULL, *tmp_nalloc = NULL;
- int i, icg, j, k, k0, k1, d, npbcdim;
+ int i, icg, j, k, k0, k1, d;
matrix tcm;
- rvec box_size, cg_cm;
+ rvec cg_cm;
ivec ind;
real nrcg, inv_ncg, pos_d;
atom_id *cgindex;
- gmx_bool bUnbounded, bScrew;
+ gmx_bool bScrew;
ma = dd->ma;
}
dd_scatterv(dd,
- DDMASTER(dd) ? ma->ibuf : NULL,
- DDMASTER(dd) ? ma->ibuf+dd->nnodes : NULL,
- DDMASTER(dd) ? ma->cg : NULL,
+ bMaster ? ma->ibuf : NULL,
+ bMaster ? ma->ibuf+dd->nnodes : NULL,
+ bMaster ? ma->cg : NULL,
dd->ncg_home*sizeof(int), dd->index_gl);
/* Determine the home charge group sizes */
int *move)
{
int npbcdim;
- int c, i, cg, k, k0, k1, d, dim, dim2, dir, d2, d3, d4, cell_d;
- int mc, cdd, nrcg, ncg_recv, nat_recv, nvs, nvr, nvec, vec;
+ int cg, k, k0, k1, d, dim, d2;
+ int mc, nrcg;
int flag;
gmx_bool bScrew;
ivec dev;
int *move;
int npbcdim;
int ncg[DIM*2], nat[DIM*2];
- int c, i, cg, k, k0, k1, d, dim, dim2, dir, d2, d3, d4, cell_d;
- int mc, cdd, nrcg, ncg_recv, nat_recv, nvs, nvr, nvec, vec;
+ int c, i, cg, k, d, dim, dim2, dir, d2, d3;
+ int mc, cdd, nrcg, ncg_recv, nvs, nvr, nvec, vec;
int sbuf[2], rbuf[2];
int home_pos_cg, home_pos_at, buf_pos;
int flag;
gmx_bool bV = FALSE, bSDX = FALSE, bCGP = FALSE;
- gmx_bool bScrew;
- ivec dev;
- real inv_ncg, pos_d;
+ real pos_d;
matrix tcm;
- rvec *cg_cm = NULL, cell_x0, cell_x1, limitd, limit0, limit1, cm_new;
+ rvec *cg_cm = NULL, cell_x0, cell_x1, limitd, limit0, limit1;
atom_id *cgindex;
cginfo_mb_t *cginfo_mb;
gmx_domdec_comm_t *comm;
{
dim = dd->dim[d];
ncg_recv = 0;
- nat_recv = 0;
nvr = 0;
for (dir = 0; dir < (dd->nc[dim] == 2 ? 1 : 2); dir++)
{
comm->cgcm_state[cdd], nvs,
comm->vbuf.v+nvr, i);
ncg_recv += rbuf[0];
- nat_recv += rbuf[1];
nvr += i;
}
gmx_domdec_comm_t *comm;
gmx_domdec_load_t *load;
gmx_domdec_root_t *root = NULL;
- int d, dim, cid, i, pos;
+ int d, dim, i, pos;
float cell_frac = 0, sbuf[DD_NLOAD_MAX];
gmx_bool bSepPME;
for (i = 0; i < dd->nc[dim]; i++)
{
load->sum += load->load[pos++];
- load->max = max(load->max, load->load[pos]);
+ load->max = std::max(load->max, load->load[pos]);
pos++;
if (dd->bGridJump)
{
/* This direction could not be load balanced properly,
* therefore we need to use the maximum iso the average load.
*/
- load->sum_m = max(load->sum_m, load->load[pos]);
+ load->sum_m = std::max(load->sum_m, load->load[pos]);
}
else
{
load->sum_m += load->load[pos];
}
pos++;
- load->cvol_min = min(load->cvol_min, load->load[pos]);
+ load->cvol_min = std::min(load->cvol_min, load->load[pos]);
pos++;
if (d < dd->ndim-1)
{
}
if (bSepPME)
{
- load->mdf = max(load->mdf, load->load[pos]);
+ load->mdf = std::max(load->mdf, load->load[pos]);
pos++;
- load->pme = max(load->pme, load->load[pos]);
+ load->pme = std::max(load->pme, load->load[pos]);
pos++;
}
}
void setup_dd_grid(FILE *fplog, gmx_domdec_t *dd)
{
- gmx_bool bZYX;
int d, dim, i, j, m;
ivec tmp, s;
int nzone, nzonep;
static void make_pp_communicator(FILE *fplog, t_commrec *cr, int gmx_unused reorder)
{
gmx_domdec_t *dd;
+ dd = cr->dd;
+
+#ifdef GMX_MPI
gmx_domdec_comm_t *comm;
- int i, rank, *buf;
+ int rank, *buf;
ivec periods;
-#ifdef GMX_MPI
MPI_Comm comm_cart;
-#endif
- dd = cr->dd;
comm = dd->comm;
-#ifdef GMX_MPI
if (comm->bCartesianPP)
{
/* Set up cartesian communication for the particle-particle part */
dd->nc[XX], dd->nc[YY], dd->nc[ZZ]);
}
- for (i = 0; i < DIM; i++)
+ for (int i = 0; i < DIM; i++)
{
periods[i] = TRUE;
}
/* Determine the master coordinates and rank.
* The DD master should be the same node as the master of this sim.
*/
- for (i = 0; i < dd->nnodes; i++)
+ for (int i = 0; i < dd->nnodes; i++)
{
if (comm->ddindex2simnodeid[i] == 0)
{
}
}
-static void receive_ddindex2simnodeid(t_commrec *cr)
+static void receive_ddindex2simnodeid(t_commrec gmx_unused *cr)
{
+#ifdef GMX_MPI
gmx_domdec_t *dd;
-
gmx_domdec_comm_t *comm;
- int *buf;
dd = cr->dd;
comm = dd->comm;
-#ifdef GMX_MPI
if (!comm->bCartesianPP_PME && comm->bCartesianPP)
{
+ int *buf;
snew(comm->ddindex2simnodeid, dd->nnodes);
snew(buf, dd->nnodes);
if (cr->duty & DUTY_PP)
{
buf[dd_index(dd->nc, dd->ci)] = cr->sim_nodeid;
}
-#ifdef GMX_MPI
/* Communicate the ddindex to simulation nodeid index */
MPI_Allreduce(buf, comm->ddindex2simnodeid, dd->nnodes, MPI_INT, MPI_SUM,
cr->mpi_comm_mysim);
-#endif
sfree(buf);
}
#endif
{
gmx_domdec_t *dd;
gmx_domdec_comm_t *comm;
- int i, rank;
+ int i;
gmx_bool bDiv[DIM];
- ivec periods;
#ifdef GMX_MPI
MPI_Comm comm_cart;
#endif
#ifdef GMX_MPI
if (comm->bCartesianPP_PME)
{
+ int rank;
+ ivec periods;
+
if (fplog)
{
fprintf(fplog, "Will use a Cartesian communicator for PP <-> PME: %d x %d x %d\n", comm->ntot[XX], comm->ntot[YY], comm->ntot[ZZ]);
}
MPI_Cart_create(cr->mpi_comm_mysim, DIM, comm->ntot, periods, reorder,
&comm_cart);
-
MPI_Comm_rank(comm_cart, &rank);
if (MASTERNODE(cr) && rank != 0)
{
for (i = 0; i < nc; i++)
{
dbl = 0;
- sscanf(size_string, "%lf%n", &dbl, &n);
+ sscanf(size_string, "%20lf%n", &dbl, &n);
if (dbl == 0)
{
gmx_fatal(FARGS, "Incorrect or not enough DD cell size entries for direction %s: '%s'", dir, size_string);
val = getenv(env_var);
if (val)
{
- if (sscanf(val, "%d", &nst) <= 0)
+ if (sscanf(val, "%20d", &nst) <= 0)
{
nst = 1;
}
{
d = dd->dim[di];
/* Check using the initial average cell size */
- r = min(r, ddbox->box_size[d]*ddbox->skew_fac[d]/dd->nc[d]);
+ r = std::min(r, ddbox->box_size[d]*ddbox->skew_fac[d]/dd->nc[d]);
}
return r;
const char *dlb_opt, gmx_bool bRecordLoad,
unsigned long Flags, t_inputrec *ir)
{
- gmx_domdec_t *dd;
int eDLB = -1;
char buf[STRLEN];
gmx_domdec_t *dd;
gmx_domdec_comm_t *comm;
int recload;
- int d, i, j;
real r_2b, r_mb, r_bonded = -1, r_bonded_limit = -1, limit, acs;
gmx_bool bC;
char buf[STRLEN];
+ const real tenPercentMargin = 1.1;
if (fplog)
{
* within nstlist steps. Since boundaries are allowed to displace by half
* a cell size, DD cells should be at least the size of the list buffer.
*/
- comm->cellsize_limit = max(comm->cellsize_limit,
- ir->rlistlong - max(ir->rvdw, ir->rcoulomb));
+ comm->cellsize_limit = std::max(comm->cellsize_limit,
+ ir->rlistlong - std::max(ir->rvdw, ir->rcoulomb));
if (comm->bInterCGBondeds)
{
}
else
{
- comm->cutoff = max(comm->cutoff, comm->cutoff_mbody);
+ comm->cutoff = std::max(comm->cutoff, comm->cutoff_mbody);
}
r_bonded_limit = comm->cutoff_mbody;
}
*/
if (Flags & MD_DDBONDCOMM)
{
- if (max(r_2b, r_mb) > comm->cutoff)
+ if (std::max(r_2b, r_mb) > comm->cutoff)
{
- r_bonded = max(r_2b, r_mb);
- r_bonded_limit = 1.1*r_bonded;
+ r_bonded = std::max(r_2b, r_mb);
+ r_bonded_limit = tenPercentMargin*r_bonded;
comm->bBondComm = TRUE;
}
else
{
r_bonded = r_mb;
- r_bonded_limit = min(1.1*r_bonded, comm->cutoff);
+ r_bonded_limit = std::min(tenPercentMargin*r_bonded, comm->cutoff);
}
/* We determine cutoff_mbody later */
}
/* No special bonded communication,
* simply increase the DD cut-off.
*/
- r_bonded_limit = 1.1*max(r_2b, r_mb);
+ r_bonded_limit = tenPercentMargin*std::max(r_2b, r_mb);
comm->cutoff_mbody = r_bonded_limit;
- comm->cutoff = max(comm->cutoff, comm->cutoff_mbody);
+ comm->cutoff = std::max(comm->cutoff, comm->cutoff_mbody);
}
}
- comm->cellsize_limit = max(comm->cellsize_limit, r_bonded_limit);
+ comm->cellsize_limit = std::max(comm->cellsize_limit, r_bonded_limit);
if (fplog)
{
fprintf(fplog,
"User supplied maximum distance required for P-LINCS: %.3f nm\n",
rconstr);
}
- comm->cellsize_limit = max(comm->cellsize_limit, rconstr);
+ comm->cellsize_limit = std::max(comm->cellsize_limit, rconstr);
comm->cgs_gl = gmx_mtop_global_cgs(mtop);
if (comm->eDLB != edlbNO)
{
/* Check if this does not limit the scaling */
- comm->cutoff_mbody = min(comm->cutoff_mbody, dlb_scale*acs);
+ comm->cutoff_mbody = std::min(comm->cutoff_mbody, dlb_scale*acs);
}
if (!comm->bBondComm)
{
/* Without bBondComm do not go beyond the n.b. cut-off */
- comm->cutoff_mbody = min(comm->cutoff_mbody, comm->cutoff);
+ comm->cutoff_mbody = std::min(comm->cutoff_mbody, comm->cutoff);
if (comm->cellsize_limit >= comm->cutoff)
{
/* We don't loose a lot of efficieny
}
}
/* Check if we did not end up below our original limit */
- comm->cutoff_mbody = max(comm->cutoff_mbody, r_bonded_limit);
+ comm->cutoff_mbody = std::max(comm->cutoff_mbody, r_bonded_limit);
if (comm->cutoff_mbody > comm->cellsize_limit)
{
cellsize_min = comm->cellsize_min[dd->dim[0]];
for (d = 1; d < dd->ndim; d++)
{
- cellsize_min = min(cellsize_min, comm->cellsize_min[dd->dim[d]]);
+ cellsize_min = std::min(cellsize_min, comm->cellsize_min[dd->dim[d]]);
}
if (cellsize_min < comm->cellsize_limit*1.05)
t_inputrec *ir, gmx_bool bBCheck, cginfo_mb_t *cginfo_mb)
{
gmx_domdec_comm_t *comm;
- gmx_bool bBondComm;
- int d;
dd_make_reverse_top(fplog, dd, mtop, vsite, ir, bBCheck);
limit = dd->comm->cellsize_min[XX];
for (d = 1; d < DIM; d++)
{
- limit = min(limit, dd->comm->cellsize_min[d]);
+ limit = std::min(limit, dd->comm->cellsize_min[d]);
}
}
{
fprintf(fplog, "%40s %-7s %6.3f nm\n",
"two-body bonded interactions", "(-rdd)",
- max(comm->cutoff, comm->cutoff_mbody));
+ std::max(comm->cutoff, comm->cutoff_mbody));
fprintf(fplog, "%40s %-7s %6.3f nm\n",
"multi-body bonded interactions", "(-rdd)",
- (comm->bBondComm || dd->bGridJump) ? comm->cutoff_mbody : min(comm->cutoff, limit));
+ (comm->bBondComm || dd->bGridJump) ? comm->cutoff_mbody : std::min(comm->cutoff, limit));
}
if (dd->vsite_comm)
{
/* Determine the maximum number of comm. pulses in one dimension */
- comm->cellsize_limit = max(comm->cellsize_limit, comm->cutoff_mbody);
+ comm->cellsize_limit = std::max(comm->cellsize_limit, comm->cutoff_mbody);
/* Determine the maximum required number of grid pulses */
if (comm->cellsize_limit >= comm->cutoff)
else
{
/* There is no cell size limit */
- npulse = max(dd->nc[XX]-1, max(dd->nc[YY]-1, dd->nc[ZZ]-1));
+ npulse = std::max(dd->nc[XX]-1, std::max(dd->nc[YY]-1, dd->nc[ZZ]-1));
}
if (!bNoCutOff && npulse > 1)
dim = dd->dim[d];
npulse_d = (int)(1 + dd->nc[dim]*comm->cutoff
/(ddbox->box_size[dim]*ddbox->skew_fac[dim]*dlb_scale));
- npulse_d_max = max(npulse_d_max, npulse_d);
+ npulse_d_max = std::max(npulse_d_max, npulse_d);
}
- npulse = min(npulse, npulse_d_max);
+ npulse = std::min(npulse, npulse_d_max);
}
/* This env var can override npulse */
comm->bVacDLBNoLimit = (ir->ePBC == epbcNONE);
for (d = 0; d < dd->ndim; d++)
{
- comm->cd[d].np_dlb = min(npulse, dd->nc[dd->dim[d]]-1);
+ comm->cd[d].np_dlb = std::min(npulse, dd->nc[dd->dim[d]]-1);
comm->cd[d].np_nalloc = comm->cd[d].np_dlb;
snew(comm->cd[d].ind, comm->cd[d].np_nalloc);
- comm->maxpulse = max(comm->maxpulse, comm->cd[d].np_dlb);
+ comm->maxpulse = std::max(comm->maxpulse, comm->cd[d].np_dlb);
if (comm->cd[d].np_dlb < dd->nc[dd->dim[d]]-1)
{
comm->bVacDLBNoLimit = FALSE;
/* cellsize_limit is set for LINCS in init_domain_decomposition */
if (!comm->bVacDLBNoLimit)
{
- comm->cellsize_limit = max(comm->cellsize_limit,
- comm->cutoff/comm->maxpulse);
+ comm->cellsize_limit = std::max(comm->cellsize_limit,
+ comm->cutoff/comm->maxpulse);
}
- comm->cellsize_limit = max(comm->cellsize_limit, comm->cutoff_mbody);
+ comm->cellsize_limit = std::max(comm->cellsize_limit, comm->cutoff_mbody);
/* Set the minimum cell size for each DD dimension */
for (d = 0; d < dd->ndim; d++)
{
}
if (comm->cutoff_mbody <= 0)
{
- comm->cutoff_mbody = min(comm->cutoff, comm->cellsize_limit);
+ comm->cutoff_mbody = std::min(comm->cutoff, comm->cellsize_limit);
}
if (comm->bDynLoadBal)
{
}
natoms_tot = comm->cgs_gl.index[comm->cgs_gl.nr];
- dd->ga2la = ga2la_init(natoms_tot, vol_frac*natoms_tot);
+ dd->ga2la = ga2la_init(natoms_tot, static_cast<int>(vol_frac*natoms_tot));
}
static gmx_bool test_dd_cutoff(t_commrec *cr,
c->c[1][1] = comm->cell_x0[dim1];
if (dd->bGridJump)
{
- c->c[1][1] = max(comm->cell_x0[dim1], comm->zone_d1[1].mch0);
+ c->c[1][1] = std::max(comm->cell_x0[dim1], comm->zone_d1[1].mch0);
if (bDistMB)
{
/* For the multi-body distance we need the maximum */
- c->bc[1] = max(comm->cell_x0[dim1], comm->zone_d1[1].p1_0);
+ c->bc[1] = std::max(comm->cell_x0[dim1], comm->zone_d1[1].p1_0);
}
}
/* Set the upper-right corner for rounding */
if (j >= 4)
{
c->c[2][j-4] =
- max(c->c[2][j-4],
- comm->zone_d2[zones->shift[i][dim0]][zones->shift[i][dim1]].mch0);
+ std::max(c->c[2][j-4],
+ comm->zone_d2[zones->shift[i][dim0]][zones->shift[i][dim1]].mch0);
}
}
}
{
for (j = 0; j < 2; j++)
{
- c->bc[2] = max(c->bc[2], comm->zone_d2[i][j].p1_0);
+ c->bc[2] = std::max(c->bc[2], comm->zone_d2[i][j].p1_0);
}
}
}
c->cr1[3] = comm->cell_x1[dim1];
if (dd->bGridJump)
{
- c->cr1[0] = max(comm->cell_x1[dim1], comm->zone_d1[1].mch1);
+ c->cr1[0] = std::max(comm->cell_x1[dim1], comm->zone_d1[1].mch1);
if (bDistMB)
{
/* For the multi-body distance we need the maximum */
- c->bcr1 = max(comm->cell_x1[dim1], comm->zone_d1[1].p1_1);
+ c->bcr1 = std::max(comm->cell_x1[dim1], comm->zone_d1[1].p1_1);
}
}
}
{
int dim_ind, dim, dim0, dim1, dim2, dimd, p, nat_tot;
int nzone, nzone_send, zone, zonei, cg0, cg1;
- int c, i, j, cg, cg_gl, nrcg;
+ int c, i, cg, cg_gl, nrcg;
int *zone_cg_range, pos_cg, *index_gl, *cgindex, *recv_i;
gmx_domdec_comm_t *comm;
gmx_domdec_zones_t *zones;
gmx_domdec_ind_t *ind;
cginfo_mb_t *cginfo_mb;
gmx_bool bBondComm, bDist2B, bDistMB, bDistBonded;
- real r_mb, r_comm2, r_scomm2, r_bcomm2, r_0, r_1, r2inc, inv_ncg;
+ real r_comm2, r_bcomm2;
dd_corners_t corners;
ivec tric_dist;
rvec *cg_cm, *normal, *v_d, *v_0 = NULL, *v_1 = NULL, *recv_vr;
for (dim_ind = 0; dim_ind < dd->ndim; dim_ind++)
{
- dim = dd->dim[dim_ind];
-
/* Check if we need to use triclinic distances */
tric_dist[dim_ind] = 0;
for (i = 0; i <= dim_ind; i++)
/* The rvec buffer is also required for atom buffers
* of size nrecv in dd_move_x and dd_move_f.
*/
- i = max(cd->ind[0].nrecv[nzone+1], ind->nrecv[nzone+1]);
+ i = std::max(cd->ind[0].nrecv[nzone+1], ind->nrecv[nzone+1]);
vec_rvec_check_alloc(&comm->vbuf2, i);
}
}
gmx_domdec_comm_t *comm;
gmx_domdec_zones_t *zones;
gmx_bool bDistMB;
- int z, zi, zj0, zj1, d, dim;
+ int z, zi, d, dim;
real rcs, rcmbs;
int i, j;
- real size_j, add_tric;
real vol;
comm = dd->comm;
* With multiple pulses this will lead
* to a larger zone then strictly necessary.
*/
- zones->size[z].x1[dim] = max(zones->size[z].x1[dim],
- zones->size[zi].x1[dim]+rcmbs);
+ zones->size[z].x1[dim] = std::max(zones->size[z].x1[dim],
+ zones->size[zi].x1[dim]+rcmbs);
}
}
}
{
if (zones->shift[z][dim] > 0)
{
- zones->size[z].x1[dim] = max(zones->size[z].x1[dim],
- zones->size[zi].x1[dim]+rcs);
+ zones->size[z].x1[dim] = std::max(zones->size[z].x1[dim],
+ zones->size[zi].x1[dim]+rcs);
}
}
}
{
for (i = 0; i < DIM; i++)
{
- corner_min[i] = min(corner_min[i], corner[i]);
- corner_max[i] = max(corner_max[i], corner[i]);
+ corner_min[i] = std::min(corner_min[i], corner[i]);
+ corner_max[i] = std::max(corner_max[i], corner[i]);
}
}
}
{
gmx_domdec_sort_t *sort;
gmx_cgsort_t *cgsort, *sort_i;
- int ncg_new, nsort2, nsort_new, i, *a, moved, *ibuf;
- int sort_last, sort_skip;
+ int ncg_new, nsort2, nsort_new, i, *a, moved;
sort = dd->comm->sort;
int ncg_home_old)
{
gmx_domdec_sort_t *sort;
- gmx_cgsort_t *cgsort, *sort_i;
+ gmx_cgsort_t *cgsort;
int *cgindex;
int ncg_new, i, *ibuf, cgsize;
rvec *vbuf;
t_block *cgs_gl;
gmx_int64_t step_pcoupl;
rvec cell_ns_x0, cell_ns_x1;
- int i, j, n, ncgindex_set, ncg_home_old = -1, ncg_moved, nat_f_novirsum;
+ int i, n, ncgindex_set, ncg_home_old = -1, ncg_moved, nat_f_novirsum;
gmx_bool bBoxChanged, bNStGlobalComm, bDoDLB, bCheckDLB, bTurnOnDLB, bLogLoad;
gmx_bool bRedist, bSortCG, bResortAll;
ivec ncells_old = {0, 0, 0}, ncells_new = {0, 0, 0}, np;
* so the extra communication cost is negligible.
*/
const int nddp_chk_dlb = 100;
-
bCheckDLB = (comm->n_load_collect == 0 ||
comm->n_load_have % nddp_chk_dlb == nddp_chk_dlb - 1);
}