int main(int argc, char *argv[])
{
t_commrec *cr;
t_bin *rb;
double *r;
rvec *v;
int k, i, ni, mi, n, m;
cr = init_par(&argc, argv);
n = strtol(argv[1], NULL, 10);
m = strtol(argv[2], NULL, 10);
fprintf(stdlog, "n=%d\n", n);
rb = mk_bin();
snew(r, n);
snew(v, m);
for (k = 0; (k < 3); k++)
{
fprintf(stdlog, "\nk=%d\n", k);
reset_bin(rb);
for (i = 0; (i < n); i++)
{
r[i] = i+k;
}
for (i = 0; (i < m); i++)
{
v[i][XX] = 4*i+k;
v[i][YY] = 4*i+k+1;
v[i][ZZ] = 4*i+k+2;
}
ni = add_bind(stdlog, rb, n, r);
mi = add_binr(stdlog, rb, DIM*m, v[0]);
sum_bin(rb, cr);
extract_bind(rb, ni, n, r);
extract_binr(rb, mi, DIM*m, v[0]);
for (i = 0; (i < n); i++)
{
fprintf(stdlog, "r[%d] = %e\n", i, r[i]);
}
for (i = 0; (i < m); i++)
{
fprintf(stdlog, "v[%d] = (%e,%e,%e)\n", i, v[i][XX], v[i][YY], v[i][ZZ]);
}
}
fflush(stdlog);
return 0;
}
void accumulate_u(t_commrec *cr, t_grpopts *opts, gmx_ekindata_t *ekind)
{
/* This routine will only be called when it's necessary */
t_bin *rb;
int g;
rb = mk_bin();
for (g = 0; (g < opts->ngacc); g++)
{
add_binr(rb, DIM, ekind->grpstat[g].u);
}
sum_bin(rb, cr);
for (g = 0; (g < opts->ngacc); g++)
{
extract_binr(rb, DIM*g, DIM, ekind->grpstat[g].u);
}
destroy_bin(rb);
}
void accumulate_u(t_commrec *cr,t_grpopts *opts,gmx_ekindata_t *ekind)
{
/* This routine will only be called when it's necessary */
static t_bin *rb=NULL;
int g;
if (rb == NULL) {
rb=mk_bin();
}
else
reset_bin(rb);
for(g=0; (g<opts->ngacc); g++)
add_binr(rb,DIM,ekind->grpstat[g].u);
sum_bin(rb,cr);
for(g=0; (g<opts->ngacc); g++)
extract_binr(rb,DIM*g,DIM,ekind->grpstat[g].u);
}
void global_stat(FILE *log,
t_commrec *cr,real ener[],
tensor fvir,tensor svir,
t_grpopts *opts,t_groups *grps,
t_nrnb *mynrnb,t_nrnb nrnb[],
t_vcm *vcm,real *terminate)
{
static t_bin *rb=NULL;
static int *itc;
int iterminate,imu,ie,ifv,isv,icm,imass,ica;
int icj=-1,ici=-1,icx=-1;
int in[MAXNODES];
int inn[egNR];
int j;
if (rb==NULL) {
rb=mk_bin();
snew(itc,opts->ngtc);
}
else
reset_bin(rb);
/* Reset nrnb stuff */
for(j=0; (j<cr->nnodes); j++)
init_nrnb(&(nrnb[j]));
cp_nrnb(&(nrnb[cr->nodeid]),mynrnb);
/* This routine copies all the data to be summed to one big buffer
* using the t_bin struct.
*/
where();
ie = add_binr(log,rb,F_NRE,ener);
where();
ifv = add_binr(log,rb,DIM*DIM,fvir[0]);
where();
isv = add_binr(log,rb,DIM*DIM,svir[0]);
where();
for(j=0; (j<cr->nnodes); j++)
in[j] = add_bind(log,rb,eNRNB,nrnb[j].n);
where();
for(j=0; (j<opts->ngtc); j++)
itc[j]=add_binr(log,rb,DIM*DIM,grps->tcstat[j].ekin[0]);
where();
for(j=0; (j<egNR); j++)
inn[j]=add_binr(log,rb,grps->estat.nn,grps->estat.ee[j]);
where();
icm = add_binr(log,rb,DIM*vcm->nr,vcm->group_p[0]);
where();
imass = add_binr(log,rb,vcm->nr,vcm->group_mass);
where();
if (vcm->mode == ecmANGULAR) {
icj = add_binr(log,rb,DIM*vcm->nr,vcm->group_j[0]);
where();
icx = add_binr(log,rb,DIM*vcm->nr,vcm->group_x[0]);
where();
ici = add_binr(log,rb,DIM*DIM*vcm->nr,vcm->group_i[0][0]);
where();
}
ica = add_binr(log,rb,1,&(grps->cosacc.mvcos));
where();
iterminate = add_binr(log,rb,1,terminate);
/* Global sum it all */
sum_bin(rb,cr);
where();
/* Extract all the data locally */
extract_binr(rb,ie ,F_NRE,ener);
extract_binr(rb,ifv ,DIM*DIM,fvir[0]);
extract_binr(rb,isv ,DIM*DIM,svir[0]);
for(j=0; (j<cr->nnodes); j++)
extract_bind(rb,in[j],eNRNB,nrnb[j].n);
for(j=0; (j<opts->ngtc); j++)
extract_binr(rb,itc[j],DIM*DIM,grps->tcstat[j].ekin[0]);
for(j=0; (j<egNR); j++)
extract_binr(rb,inn[j],grps->estat.nn,grps->estat.ee[j]);
extract_binr(rb,icm,DIM*vcm->nr,vcm->group_p[0]);
where();
extract_binr(rb,imass,vcm->nr,vcm->group_mass);
where();
if (vcm->mode == ecmANGULAR) {
extract_binr(rb,icj,DIM*vcm->nr,vcm->group_j[0]);
where();
extract_binr(rb,icx,DIM*vcm->nr,vcm->group_x[0]);
where();
extract_binr(rb,ici,DIM*DIM*vcm->nr,vcm->group_i[0][0]);
where();
}
extract_binr(rb,ica,1,&(grps->cosacc.mvcos));
where();
extract_binr(rb,iterminate,1,terminate);
where();
/* Small hack for temp only */
ener[F_TEMP]/=cr->nnodes;
}
void global_stat(gmx_global_stat_t gs,
t_commrec *cr, gmx_enerdata_t *enerd,
tensor fvir, tensor svir, rvec mu_tot,
t_inputrec *inputrec,
gmx_ekindata_t *ekind, gmx_constr_t constr,
t_vcm *vcm,
int nsig, real *sig,
int *totalNumberOfBondedInteractions,
gmx_bool bSumEkinhOld, int flags)
/* instead of current system, gmx_booleans for summing virial, kinetic energy, and other terms */
{
t_bin *rb;
int *itc0, *itc1;
int ie = 0, ifv = 0, isv = 0, irmsd = 0, imu = 0;
int idedl = 0, idvdll = 0, idvdlnl = 0, iepl = 0, icm = 0, imass = 0, ica = 0, inb = 0;
int isig = -1;
int icj = -1, ici = -1, icx = -1;
int inn[egNR];
real copyenerd[F_NRE];
int nener, j;
real *rmsd_data = NULL;
double nb;
gmx_bool bVV, bTemp, bEner, bPres, bConstrVir, bEkinAveVel, bReadEkin;
bool checkNumberOfBondedInteractions = flags & CGLO_CHECK_NUMBER_OF_BONDED_INTERACTIONS;
bVV = EI_VV(inputrec->eI);
bTemp = flags & CGLO_TEMPERATURE;
bEner = flags & CGLO_ENERGY;
bPres = (flags & CGLO_PRESSURE);
bConstrVir = (flags & CGLO_CONSTRAINT);
bEkinAveVel = (inputrec->eI == eiVV || (inputrec->eI == eiVVAK && bPres));
bReadEkin = (flags & CGLO_READEKIN);
rb = gs->rb;
itc0 = gs->itc0;
itc1 = gs->itc1;
reset_bin(rb);
/* This routine copies all the data to be summed to one big buffer
* using the t_bin struct.
*/
/* First, we neeed to identify which enerd->term should be
communicated. Temperature and pressure terms should only be
communicated and summed when they need to be, to avoid repeating
the sums and overcounting. */
nener = filter_enerdterm(enerd->term, TRUE, copyenerd, bTemp, bPres, bEner);
/* First, the data that needs to be communicated with velocity verlet every time
This is just the constraint virial.*/
if (bConstrVir)
{
isv = add_binr(rb, DIM*DIM, svir[0]);
where();
}
/* We need the force virial and the kinetic energy for the first time through with velocity verlet */
if (bTemp || !bVV)
{
if (ekind)
{
for (j = 0; (j < inputrec->opts.ngtc); j++)
{
if (bSumEkinhOld)
{
itc0[j] = add_binr(rb, DIM*DIM, ekind->tcstat[j].ekinh_old[0]);
}
if (bEkinAveVel && !bReadEkin)
{
itc1[j] = add_binr(rb, DIM*DIM, ekind->tcstat[j].ekinf[0]);
}
else if (!bReadEkin)
{
itc1[j] = add_binr(rb, DIM*DIM, ekind->tcstat[j].ekinh[0]);
}
}
/* these probably need to be put into one of these categories */
where();
idedl = add_binr(rb, 1, &(ekind->dekindl));
where();
ica = add_binr(rb, 1, &(ekind->cosacc.mvcos));
where();
}
}
where();
if (bPres)
{
ifv = add_binr(rb, DIM*DIM, fvir[0]);
}
if (bEner)
{
where();
ie = add_binr(rb, nener, copyenerd);
where();
if (constr)
{
rmsd_data = constr_rmsd_data(constr);
if (rmsd_data)
{
irmsd = add_binr(rb, 2, rmsd_data);
}
}
if (!inputrecNeedMutot(inputrec))
{
imu = add_binr(rb, DIM, mu_tot);
where();
}
for (j = 0; (j < egNR); j++)
{
inn[j] = add_binr(rb, enerd->grpp.nener, enerd->grpp.ener[j]);
}
where();
if (inputrec->efep != efepNO)
{
idvdll = add_bind(rb, efptNR, enerd->dvdl_lin);
idvdlnl = add_bind(rb, efptNR, enerd->dvdl_nonlin);
if (enerd->n_lambda > 0)
{
iepl = add_bind(rb, enerd->n_lambda, enerd->enerpart_lambda);
}
}
}
if (vcm)
{
icm = add_binr(rb, DIM*vcm->nr, vcm->group_p[0]);
where();
imass = add_binr(rb, vcm->nr, vcm->group_mass);
where();
if (vcm->mode == ecmANGULAR)
{
icj = add_binr(rb, DIM*vcm->nr, vcm->group_j[0]);
where();
icx = add_binr(rb, DIM*vcm->nr, vcm->group_x[0]);
where();
ici = add_binr(rb, DIM*DIM*vcm->nr, vcm->group_i[0][0]);
where();
}
}
if (checkNumberOfBondedInteractions)
{
nb = cr->dd->nbonded_local;
inb = add_bind(rb, 1, &nb);
}
where();
if (nsig > 0)
{
isig = add_binr(rb, nsig, sig);
}
/* Global sum it all */
if (debug)
{
fprintf(debug, "Summing %d energies\n", rb->maxreal);
}
sum_bin(rb, cr);
where();
/* Extract all the data locally */
if (bConstrVir)
{
extract_binr(rb, isv, DIM*DIM, svir[0]);
}
/* We need the force virial and the kinetic energy for the first time through with velocity verlet */
if (bTemp || !bVV)
{
if (ekind)
{
for (j = 0; (j < inputrec->opts.ngtc); j++)
{
if (bSumEkinhOld)
{
extract_binr(rb, itc0[j], DIM*DIM, ekind->tcstat[j].ekinh_old[0]);
}
if (bEkinAveVel && !bReadEkin)
{
extract_binr(rb, itc1[j], DIM*DIM, ekind->tcstat[j].ekinf[0]);
}
else if (!bReadEkin)
{
extract_binr(rb, itc1[j], DIM*DIM, ekind->tcstat[j].ekinh[0]);
}
}
extract_binr(rb, idedl, 1, &(ekind->dekindl));
extract_binr(rb, ica, 1, &(ekind->cosacc.mvcos));
where();
}
}
if (bPres)
{
extract_binr(rb, ifv, DIM*DIM, fvir[0]);
}
if (bEner)
{
extract_binr(rb, ie, nener, copyenerd);
if (rmsd_data)
{
extract_binr(rb, irmsd, 2, rmsd_data);
}
if (!inputrecNeedMutot(inputrec))
{
extract_binr(rb, imu, DIM, mu_tot);
}
for (j = 0; (j < egNR); j++)
{
extract_binr(rb, inn[j], enerd->grpp.nener, enerd->grpp.ener[j]);
}
if (inputrec->efep != efepNO)
{
extract_bind(rb, idvdll, efptNR, enerd->dvdl_lin);
extract_bind(rb, idvdlnl, efptNR, enerd->dvdl_nonlin);
if (enerd->n_lambda > 0)
{
extract_bind(rb, iepl, enerd->n_lambda, enerd->enerpart_lambda);
}
}
where();
filter_enerdterm(copyenerd, FALSE, enerd->term, bTemp, bPres, bEner);
}
if (vcm)
{
extract_binr(rb, icm, DIM*vcm->nr, vcm->group_p[0]);
where();
extract_binr(rb, imass, vcm->nr, vcm->group_mass);
where();
if (vcm->mode == ecmANGULAR)
{
extract_binr(rb, icj, DIM*vcm->nr, vcm->group_j[0]);
where();
extract_binr(rb, icx, DIM*vcm->nr, vcm->group_x[0]);
where();
extract_binr(rb, ici, DIM*DIM*vcm->nr, vcm->group_i[0][0]);
where();
}
}
if (checkNumberOfBondedInteractions)
{
extract_bind(rb, inb, 1, &nb);
*totalNumberOfBondedInteractions = static_cast<int>(nb+0.5);
}
if (nsig > 0)
{
extract_binr(rb, isig, nsig, sig);
}
where();
}