void list_xtc(const char *fn) { t_fileio *xd; int indent; char buf[256]; rvec *x; matrix box; int nframe, natoms, step; real prec, time; gmx_bool bOK; xd = open_xtc(fn, "r"); read_first_xtc(xd, &natoms, &step, &time, box, &x, &prec, &bOK); nframe = 0; do { sprintf(buf, "%s frame %d", fn, nframe); indent = 0; indent = pr_title(stdout, indent, buf); pr_indent(stdout, indent); fprintf(stdout, "natoms=%10d step=%10d time=%12.7e prec=%10g\n", natoms, step, time, prec); pr_rvecs(stdout, indent, "box", box, DIM); pr_rvecs(stdout, indent, "x", x, natoms); nframe++; } while (read_next_xtc(xd, natoms, &step, &time, box, x, &prec, &bOK)); if (!bOK) { fprintf(stderr, "\nWARNING: Incomplete frame at time %g\n", time); } sfree(x); close_xtc(xd); }
/* Check whether the box is unchanged */ static void check_box_unchanged(matrix f_box, matrix box, char fn[], warninp_t wi) { int i, ii; gmx_bool bSame = TRUE; char warn_buf[STRLEN]; for (i = 0; i < DIM; i++) { for (ii = 0; ii < DIM; ii++) { if (f_box[i][ii] != box[i][ii]) { bSame = FALSE; } } } if (!bSame) { sprintf(warn_buf, "%s Box size in reference file %s differs from actual box size!", RotStr, fn); warning(wi, warn_buf); pr_rvecs(stderr, 0, "Your box is:", box, 3); pr_rvecs(stderr, 0, "Box in file:", f_box, 3); } }
static void sum_forces(int start,int end,rvec f[],rvec flr[]) { int i; if (gmx_debug_at) { pr_rvecs(debug,0,"fsr",f+start,end-start); pr_rvecs(debug,0,"flr",flr+start,end-start); } for(i=start; (i<end); i++) rvec_inc(f[i],flr[i]); }
static void list_trn(char *fn) { int fpread,fpwrite,nframe,indent; char buf[256]; rvec *x,*v,*f; matrix box; t_trnheader trn; bool bOK; fpread = open_trn(fn,"r"); fpwrite = open_tpx(NULL,"w"); gmx_fio_setdebug(fpwrite,TRUE); nframe = 0; while (fread_trnheader(fpread,&trn,&bOK)) { snew(x,trn.natoms); snew(v,trn.natoms); snew(f,trn.natoms); if (fread_htrn(fpread,&trn, trn.box_size ? box : NULL, trn.x_size ? x : NULL, trn.v_size ? v : NULL, trn.f_size ? f : NULL)) { sprintf(buf,"%s frame %d",fn,nframe); indent=0; indent=pr_title(stdout,indent,buf); pr_indent(stdout,indent); fprintf(stdout,"natoms=%10d step=%10d time=%12.7e lambda=%10g\n", trn.natoms,trn.step,trn.t,trn.lambda); if (trn.box_size) pr_rvecs(stdout,indent,"box",box,DIM); if (trn.x_size) pr_rvecs(stdout,indent,"x",x,trn.natoms); if (trn.v_size) pr_rvecs(stdout,indent,"v",v,trn.natoms); if (trn.f_size) pr_rvecs(stdout,indent,"f",f,trn.natoms); } else fprintf(stderr,"\nWARNING: Incomplete frame: nr %d, t=%g\n", nframe,trn.t); sfree(x); sfree(v); sfree(f); nframe++; } if (!bOK) fprintf(stderr,"\nWARNING: Incomplete frame header: nr %d, t=%g\n", nframe,trn.t); close_tpx(fpwrite); close_trn(fpread); }
static void dump_it_all(FILE *fp,char *title, int natoms,rvec x[],rvec xp[],rvec v[],rvec f[]) { #ifdef DEBUG if (fp) { fprintf(fp,"%s\n",title); pr_rvecs(fp,0,"x",x,natoms); pr_rvecs(fp,0,"xp",xp,natoms); pr_rvecs(fp,0,"v",v,natoms); pr_rvecs(fp,0,"f",f,natoms); } #endif }
static int correct_box_elem(FILE *fplog, int step, tensor box, int v, int d) { int shift, maxshift = 10; shift = 0; /* correct elem d of vector v with vector d */ while (box[v][d] > BOX_MARGIN_CORRECT*0.5*box[d][d]) { if (fplog) { fprintf(fplog, "Step %d: correcting invalid box:\n", step); pr_rvecs(fplog, 0, "old box", box, DIM); } rvec_dec(box[v], box[d]); shift--; if (fplog) { pr_rvecs(fplog, 0, "new box", box, DIM); } if (shift <= -maxshift) { gmx_fatal(FARGS, "Box was shifted at least %d times. Please see log-file.", maxshift); } } while (box[v][d] < -BOX_MARGIN_CORRECT*0.5*box[d][d]) { if (fplog) { fprintf(fplog, "Step %d: correcting invalid box:\n", step); pr_rvecs(fplog, 0, "old box", box, DIM); } rvec_inc(box[v], box[d]); shift++; if (fplog) { pr_rvecs(fplog, 0, "new box", box, DIM); } if (shift >= maxshift) { gmx_fatal(FARGS, "Box was shifted at least %d times. Please see log-file.", maxshift); } } return shift; }
void calc_force(int natom,rvec f[],rvec fff[]) { int i,j,m; int jindex[] = { 0, 5, 10}; rvec dx,df; real msf1,msf2; for(j=0; (j<2); j++) { clear_rvec(fff[j]); for(i=jindex[j]; (i<jindex[j+1]); i++) { for(m=0; (m<DIM); m++) { fff[j][m] += f[i][m]; } } } msf1 = iprod(fff[0],fff[0]); msf2 = iprod(fff[1],fff[1]); if (debug) { pr_rvecs(debug,0,"force",f,natom); fprintf(debug,"FMOL: %10.3f %10.3f %10.3f %10.3f %10.3f %10.3f\n", fff[0][XX],fff[0][YY],fff[0][ZZ],fff[1][XX],fff[1][YY],fff[1][ZZ]); fprintf(debug,"RMSF: %10.3e %10.3e\n",msf1,msf2); } }
static void calc_virial(FILE *fplog,int start,int homenr,rvec x[],rvec f[], tensor vir_part,t_graph *graph,matrix box, t_nrnb *nrnb,const t_forcerec *fr,int ePBC) { int i,j; tensor virtest; /* The short-range virial from surrounding boxes */ clear_mat(vir_part); calc_vir(fplog,SHIFTS,fr->shift_vec,fr->fshift,vir_part,ePBC==epbcSCREW,box); inc_nrnb(nrnb,eNR_VIRIAL,SHIFTS); /* Calculate partial virial, for local atoms only, based on short range. * Total virial is computed in global_stat, called from do_md */ f_calc_vir(fplog,start,start+homenr,x,f,vir_part,graph,box); inc_nrnb(nrnb,eNR_VIRIAL,homenr); /* Add position restraint contribution */ for(i=0; i<DIM; i++) { vir_part[i][i] += fr->vir_diag_posres[i]; } /* Add wall contribution */ for(i=0; i<DIM; i++) { vir_part[i][ZZ] += fr->vir_wall_z[i]; } if (debug) pr_rvecs(debug,0,"vir_part",vir_part,DIM); }
static void pr_matrix(FILE *fp,int indent,const char *title,rvec *m, gmx_bool bMDPformat) { if (bMDPformat) fprintf(fp,"%-10s = %g %g %g %g %g %g\n",title, m[XX][XX],m[YY][YY],m[ZZ][ZZ],m[XX][YY],m[XX][ZZ],m[YY][ZZ]); else pr_rvecs(fp,indent,title,m,DIM); }
void init_parallel(FILE *log,char *tpxfile,t_commrec *cr, t_inputrec *inputrec,gmx_mtop_t *mtop, t_state *state, int list) { int step; real t; char buf[256]; if (MASTER(cr)) { init_inputrec(inputrec); read_tpx_state(tpxfile,&step,&t,inputrec,state,NULL,mtop); /* When we will be doing domain decomposition with separate PME nodes * the rng entries will be too large, we correct for this later. */ set_state_entries(state,inputrec,cr->nnodes); } bcast_ir_mtop(cr,inputrec,mtop); if (inputrec->eI == eiBD || EI_SD(inputrec->eI)) { /* Make sure the random seeds are different on each node */ inputrec->ld_seed += cr->nodeid; } /* Printing */ if (list!=0 && log!=NULL) { if (list&LIST_INPUTREC) pr_inputrec(log,0,"parameters of the run",inputrec,FALSE); if (list&LIST_X) pr_rvecs(log,0,"box",state->box,DIM); if (list&LIST_X) pr_rvecs(log,0,"box_rel",state->box_rel,DIM); if (list&LIST_V) pr_rvecs(log,0,"boxv",state->boxv,DIM); if (list&LIST_X) pr_rvecs(log,0,int_title("x",0,buf,255),state->x,state->natoms); if (list&LIST_V) pr_rvecs(log,0,int_title("v",0,buf,255),state->v,state->natoms); if (list&LIST_TOP) pr_mtop(log,0,int_title("topology",cr->nodeid,buf,255),mtop,TRUE); fflush(log); } }
static void pr_molblock(FILE *fp,int indent,const char *title, gmx_molblock_t *molb,int n, gmx_moltype_t *molt, gmx_bool bShowNumbers) { indent = pr_title_n(fp,indent,title,n); (void) pr_indent(fp,indent); (void) fprintf(fp,"%-20s = %d \"%s\"\n", "moltype",molb->type,*(molt[molb->type].name)); pr_int(fp,indent,"#molecules",molb->nmol); pr_int(fp,indent,"#atoms_mol",molb->natoms_mol); pr_int(fp,indent,"#posres_xA",molb->nposres_xA); if (molb->nposres_xA > 0) { pr_rvecs(fp,indent,"posres_xA",molb->posres_xA,molb->nposres_xA); } pr_int(fp,indent,"#posres_xB",molb->nposres_xB); if (molb->nposres_xB > 0) { pr_rvecs(fp,indent,"posres_xB",molb->posres_xB,molb->nposres_xB); } }
static void check_pbc(FILE *fp,rvec x[],int shell) { int m,now; now = shell-4; for(m=0; (m<DIM); m++) if (fabs(x[shell][m]-x[now][m]) > 0.3) { pr_rvecs(fp,0,"SHELL-X",x+now,5); break; } }
real calc_pres(int ePBC,int nwall,matrix box,tensor ekin,tensor vir, tensor pres,real Elr) { int n,m; real fac,Plr; if (ePBC==epbcNONE || (ePBC==epbcXY && nwall!=2)) clear_mat(pres); else { /* Uitzoeken welke ekin hier van toepassing is, zie Evans & Morris - E. * Wrs. moet de druktensor gecorrigeerd worden voor de netto stroom in * het systeem... */ /* Long range correction for periodic systems, see * Neumann et al. JCP * divide by 6 because it is multiplied by fac later on. * If Elr = 0, no correction is made. */ /* This formula should not be used with Ewald or PME, * where the full long-range virial is calculated. EL 990823 */ Plr = Elr/6.0; fac=PRESFAC*2.0/det(box); for(n=0; (n<DIM); n++) for(m=0; (m<DIM); m++) pres[n][m]=(ekin[n][m]-vir[n][m]+Plr)*fac; if (debug) { pr_rvecs(debug,0,"PC: pres",pres,DIM); pr_rvecs(debug,0,"PC: ekin",ekin,DIM); pr_rvecs(debug,0,"PC: vir ",vir, DIM); pr_rvecs(debug,0,"PC: box ",box, DIM); } } return trace(pres)/3.0; }
void list_xtc(char *fn, bool bXVG) { int xd,indent; char buf[256]; rvec *x; matrix box; int nframe,natoms,step; real prec,time; bool bOK; xd = open_xtc(fn,"r"); read_first_xtc(xd,&natoms,&step,&time,box,&x,&prec,&bOK); nframe=0; do { if (bXVG) { int i,d; fprintf(stdout,"%g",time); for(i=0; i<natoms; i++) for(d=0; d<DIM; d++) fprintf(stdout," %g",x[i][d]); fprintf(stdout,"\n"); } else { sprintf(buf,"%s frame %d",fn,nframe); indent=0; indent=pr_title(stdout,indent,buf); pr_indent(stdout,indent); fprintf(stdout,"natoms=%10d step=%10d time=%12.7e prec=%10g\n", natoms,step,time,prec); pr_rvecs(stdout,indent,"box",box,DIM); pr_rvecs(stdout,indent,"x",x,natoms); } nframe++; } while (read_next_xtc(xd,natoms,&step,&time,box,x,&prec,&bOK)); if (!bOK) fprintf(stderr,"\nWARNING: Incomplete frame at time %g\n",time); close_xtc(xd); }
real calc_gyro(rvec x[], int gnx, atom_id index[], t_atom atom[], real tm, rvec gvec, rvec d, gmx_bool bQ, gmx_bool bRot, gmx_bool bMOI, matrix trans) { int i, ii, m; real gyro, dx2, m0, Itot; rvec comp; if (bRot) { principal_comp(gnx, index, atom, x, trans, d); Itot = norm(d); if (bMOI) { return Itot; } for (m = 0; (m < DIM); m++) { d[m] = std::sqrt(d[m]/tm); } #ifdef DEBUG pr_rvecs(stderr, 0, "trans", trans, DIM); #endif /* rotate_atoms(gnx,index,x,trans); */ } clear_rvec(comp); for (i = 0; (i < gnx); i++) { ii = index[i]; if (bQ) { m0 = std::abs(atom[ii].q); } else { m0 = atom[ii].m; } for (m = 0; (m < DIM); m++) { dx2 = x[ii][m]*x[ii][m]; comp[m] += dx2*m0; } } gyro = comp[XX]+comp[YY]+comp[ZZ]; for (m = 0; (m < DIM); m++) { gvec[m] = std::sqrt((gyro-comp[m])/tm); } return std::sqrt(gyro/tm); }
void calc_virial(FILE *log,int start,int homenr,rvec x[],rvec f[], tensor vir_part,tensor pme_vir, t_graph *graph,matrix box, t_nrnb *nrnb,t_forcerec *fr,bool bTweak) { int i,j; tensor virtest; /* Now it is time for the short range virial. At this timepoint vir_part * already contains the virial from surrounding boxes. * Calculate partial virial, for local atoms only, based on short range. * Total virial is computed in global_stat, called from do_md */ f_calc_vir(log,start,start+homenr,x,f,vir_part,graph,box); inc_nrnb(nrnb,eNR_VIRIAL,homenr); /* Add up the long range forces if necessary */ /* if (!bTweak) { sum_lrforces(f,fr,start,homenr); }*/ /* Add up virial if necessary */ if (EEL_LR(fr->eeltype) && (fr->eeltype != eelPPPM)) { if (debug && bTweak) { clear_mat(virtest); f_calc_vir(log,start,start+homenr,x,fr->f_pme,virtest,graph,box); pr_rvecs(debug,0,"virtest",virtest,DIM); pr_rvecs(debug,0,"pme_vir",pme_vir,DIM); } /* PPPM virial sucks */ if (!bTweak) for(i=0; (i<DIM); i++) for(j=0; (j<DIM); j++) vir_part[i][j]+=pme_vir[i][j]; } if (debug) pr_rvecs(debug,0,"vir_part",vir_part,DIM); }
void calc_angles_dihs(t_params *ang, t_params *dih, rvec x[], gmx_bool bPBC, matrix box) { int i, ai, aj, ak, al, t1, t2, t3; rvec r_ij, r_kj, r_kl, m, n; real sign, th, costh, ph; t_pbc pbc; if (bPBC) { set_pbc(&pbc, epbcXYZ, box); } if (debug) { pr_rvecs(debug, 0, "X2TOP", box, DIM); } for (i = 0; (i < ang->nr); i++) { ai = ang->param[i].AI; aj = ang->param[i].AJ; ak = ang->param[i].AK; th = RAD2DEG*bond_angle(x[ai], x[aj], x[ak], bPBC ? &pbc : NULL, r_ij, r_kj, &costh, &t1, &t2); if (debug) { fprintf(debug, "X2TOP: ai=%3d aj=%3d ak=%3d r_ij=%8.3f r_kj=%8.3f th=%8.3f\n", ai, aj, ak, norm(r_ij), norm(r_kj), th); } ang->param[i].C0 = th; } for (i = 0; (i < dih->nr); i++) { ai = dih->param[i].AI; aj = dih->param[i].AJ; ak = dih->param[i].AK; al = dih->param[i].AL; ph = RAD2DEG*dih_angle(x[ai], x[aj], x[ak], x[al], bPBC ? &pbc : NULL, r_ij, r_kj, r_kl, m, n, &sign, &t1, &t2, &t3); if (debug) { fprintf(debug, "X2TOP: ai=%3d aj=%3d ak=%3d al=%3d r_ij=%8.3f r_kj=%8.3f r_kl=%8.3f ph=%8.3f\n", ai, aj, ak, al, norm(r_ij), norm(r_kj), norm(r_kl), ph); } dih->param[i].C0 = ph; } }
static void pr_rotgrp(FILE *fp,int indent,int g,t_rotgrp *rotg) { pr_indent(fp,indent); fprintf(fp,"rotation_group %d:\n",g); indent += 2; PS("type",EROTGEOM(rotg->eType)); PS("massw",BOOL(rotg->bMassW)); pr_ivec_block(fp,indent,"atom",rotg->ind,rotg->nat,TRUE); pr_rvecs(fp,indent,"x_ref",rotg->x_ref,rotg->nat); pr_rvec(fp,indent,"vec",rotg->vec,DIM,TRUE); pr_rvec(fp,indent,"pivot",rotg->pivot,DIM,TRUE); PR("rate",rotg->rate); PR("k",rotg->k); PR("slab_dist",rotg->slab_dist); PR("min_gaussian",rotg->min_gaussian); PR("epsilon",rotg->eps); PS("fit_method",EROTFIT(rotg->eFittype)); PI("potfitangle_nstep",rotg->PotAngle_nstep); PR("potfitangle_step",rotg->PotAngle_step); }
void dump_pbc(FILE *fp, t_pbc *pbc) { rvec sum_box; fprintf(fp, "ePBCDX = %d\n", pbc->ePBCDX); pr_rvecs(fp, 0, "box", pbc->box, DIM); pr_rvecs(fp, 0, "fbox_diag", &pbc->fbox_diag, 1); pr_rvecs(fp, 0, "hbox_diag", &pbc->hbox_diag, 1); pr_rvecs(fp, 0, "mhbox_diag", &pbc->mhbox_diag, 1); rvec_add(pbc->hbox_diag, pbc->mhbox_diag, sum_box); pr_rvecs(fp, 0, "sum of the above two", &sum_box, 1); fprintf(fp, "max_cutoff2 = %g\n", pbc->max_cutoff2); fprintf(fp, "ntric_vec = %d\n", pbc->ntric_vec); if (pbc->ntric_vec > 0) { pr_ivecs(fp, 0, "tric_shift", pbc->tric_shift, pbc->ntric_vec, FALSE); pr_rvecs(fp, 0, "tric_vec", pbc->tric_vec, pbc->ntric_vec); } }
static void list_trr(const char *fn) { t_fileio *fpread; int nframe, indent; char buf[256]; rvec *x, *v, *f; matrix box; gmx_trr_header_t trrheader; gmx_bool bOK; fpread = gmx_trr_open(fn, "r"); nframe = 0; while (gmx_trr_read_frame_header(fpread, &trrheader, &bOK)) { snew(x, trrheader.natoms); snew(v, trrheader.natoms); snew(f, trrheader.natoms); if (gmx_trr_read_frame_data(fpread, &trrheader, trrheader.box_size ? box : NULL, trrheader.x_size ? x : NULL, trrheader.v_size ? v : NULL, trrheader.f_size ? f : NULL)) { sprintf(buf, "%s frame %d", fn, nframe); indent = 0; indent = pr_title(stdout, indent, buf); pr_indent(stdout, indent); fprintf(stdout, "natoms=%10d step=%10d time=%12.7e lambda=%10g\n", trrheader.natoms, trrheader.step, trrheader.t, trrheader.lambda); if (trrheader.box_size) { pr_rvecs(stdout, indent, "box", box, DIM); } if (trrheader.x_size) { pr_rvecs(stdout, indent, "x", x, trrheader.natoms); } if (trrheader.v_size) { pr_rvecs(stdout, indent, "v", v, trrheader.natoms); } if (trrheader.f_size) { pr_rvecs(stdout, indent, "f", f, trrheader.natoms); } } else { fprintf(stderr, "\nWARNING: Incomplete frame: nr %d, t=%g\n", nframe, trrheader.t); } sfree(x); sfree(v); sfree(f); nframe++; } if (!bOK) { fprintf(stderr, "\nWARNING: Incomplete frame header: nr %d, t=%g\n", nframe, trrheader.t); } gmx_trr_close(fpread); }
void check_cm_grp(FILE *fp, t_vcm *vcm, t_inputrec *ir, real Temp_Max) { int m, g; real ekcm, ekrot, tm, tm_1, Temp_cm; rvec jcm; tensor Icm; /* First analyse the total results */ if (vcm->mode != ecmNO) { for (g = 0; (g < vcm->nr); g++) { tm = vcm->group_mass[g]; if (tm != 0) { tm_1 = 1.0/tm; svmul(tm_1, vcm->group_p[g], vcm->group_v[g]); } /* Else it's zero anyway! */ } if (vcm->mode == ecmANGULAR) { for (g = 0; (g < vcm->nr); g++) { tm = vcm->group_mass[g]; if (tm != 0) { tm_1 = 1.0/tm; /* Compute center of mass for this group */ for (m = 0; (m < DIM); m++) { vcm->group_x[g][m] *= tm_1; } /* Subtract the center of mass contribution to the * angular momentum */ cprod(vcm->group_x[g], vcm->group_v[g], jcm); for (m = 0; (m < DIM); m++) { vcm->group_j[g][m] -= tm*jcm[m]; } /* Subtract the center of mass contribution from the inertia * tensor (this is not as trivial as it seems, but due to * some cancellation we can still do it, even in parallel). */ clear_mat(Icm); update_tensor(vcm->group_x[g], tm, Icm); m_sub(vcm->group_i[g], Icm, vcm->group_i[g]); /* Compute angular velocity, using matrix operation * Since J = I w * we have * w = I^-1 J */ get_minv(vcm->group_i[g], Icm); mvmul(Icm, vcm->group_j[g], vcm->group_w[g]); } /* Else it's zero anyway! */ } } } for (g = 0; (g < vcm->nr); g++) { ekcm = 0; if (vcm->group_mass[g] != 0 && vcm->group_ndf[g] > 0) { for (m = 0; m < vcm->ndim; m++) { ekcm += sqr(vcm->group_v[g][m]); } ekcm *= 0.5*vcm->group_mass[g]; Temp_cm = 2*ekcm/vcm->group_ndf[g]; if ((Temp_cm > Temp_Max) && fp) { fprintf(fp, "Large VCM(group %s): %12.5f, %12.5f, %12.5f, Temp-cm: %12.5e\n", vcm->group_name[g], vcm->group_v[g][XX], vcm->group_v[g][YY], vcm->group_v[g][ZZ], Temp_cm); } if (vcm->mode == ecmANGULAR) { ekrot = 0.5*iprod(vcm->group_j[g], vcm->group_w[g]); if ((ekrot > 1) && fp && !EI_RANDOM(ir->eI)) { /* if we have an integrator that may not conserve momenta, skip */ tm = vcm->group_mass[g]; fprintf(fp, "Group %s with mass %12.5e, Ekrot %12.5e Det(I) = %12.5e\n", vcm->group_name[g], tm, ekrot, det(vcm->group_i[g])); fprintf(fp, " COM: %12.5f %12.5f %12.5f\n", vcm->group_x[g][XX], vcm->group_x[g][YY], vcm->group_x[g][ZZ]); fprintf(fp, " P: %12.5f %12.5f %12.5f\n", vcm->group_p[g][XX], vcm->group_p[g][YY], vcm->group_p[g][ZZ]); fprintf(fp, " V: %12.5f %12.5f %12.5f\n", vcm->group_v[g][XX], vcm->group_v[g][YY], vcm->group_v[g][ZZ]); fprintf(fp, " J: %12.5f %12.5f %12.5f\n", vcm->group_j[g][XX], vcm->group_j[g][YY], vcm->group_j[g][ZZ]); fprintf(fp, " w: %12.5f %12.5f %12.5f\n", vcm->group_w[g][XX], vcm->group_w[g][YY], vcm->group_w[g][ZZ]); pr_rvecs(fp, 0, "Inertia tensor", vcm->group_i[g], DIM); } } } } }
static void do_my_pme(FILE *fp,real tm,gmx_bool bVerbose,t_inputrec *ir, rvec x[],rvec xbuf[],rvec f[], real charge[],real qbuf[],real qqbuf[], matrix box,gmx_bool bSort, t_commrec *cr,t_nsborder *nsb,t_nrnb *nrnb, t_block *excl,real qtot, t_forcerec *fr,int index[],FILE *fp_xvg, int ngroups,unsigned short cENER[]) { real ener,vcorr,q,xx,dvdl=0,vdip,vcharge; tensor vir,vir_corr,vir_tot; rvec mu_tot[2]; int i,m,ii,ig,jg; real **epme,*qptr; /* Initiate local variables */ fr->f_el_recip = f; clear_mat(vir); clear_mat(vir_corr); if (ngroups > 1) { fprintf(fp,"There are %d energy groups\n",ngroups); snew(epme,ngroups); for(i=0; (i<ngroups); i++) snew(epme[i],ngroups); } /* Put x is in the box, this part needs to be parallellized properly */ /*put_atoms_in_box(box,nsb->natoms,x);*/ /* Here sorting of X (and q) is done. * Alternatively, one could just put the atoms in one of the * cr->nnodes slabs. That is much cheaper than sorting. */ for(i=0; (i<nsb->natoms); i++) index[i] = i; if (bSort) { xptr = x; qsort(index,nsb->natoms,sizeof(index[0]),comp_xptr); xptr = NULL; /* To trap unintentional use of the ptr */ } /* After sorting we only need the part that is to be computed on * this processor. We also compute the mu_tot here (system dipole) */ clear_rvec(mu_tot[0]); for(i=START(nsb); (i<START(nsb)+HOMENR(nsb)); i++) { ii = index[i]; q = charge[ii]; qbuf[i] = q; for(m=0; (m<DIM); m++) { xx = x[ii][m]; xbuf[i][m] = xx; mu_tot[0][m] += q*xx; } clear_rvec(f[ii]); } copy_rvec(mu_tot[0],mu_tot[1]); if (debug) { pr_rvec(debug,0,"qbuf",qbuf,nsb->natoms,TRUE); pr_rvecs(debug,0,"xbuf",xbuf,nsb->natoms); pr_rvecs(debug,0,"box",box,DIM); } for(ig=0; (ig<ngroups); ig++) { for(jg=ig; (jg<ngroups); jg++) { if (ngroups > 1) { for(i=START(nsb); (i<START(nsb)+HOMENR(nsb)); i++) { if ((cENER[i] == ig) || (cENER[i] == jg)) qqbuf[i] = qbuf[i]; else qqbuf[i] = 0; } qptr = qqbuf; } else qptr = qbuf; ener = do_pme(fp,bVerbose,ir,xbuf,f,qptr,qptr,box,cr, nsb,nrnb,vir,fr->ewaldcoeff,FALSE,0,&dvdl,FALSE); vcorr = ewald_LRcorrection(fp,nsb,cr,fr,qptr,qptr,excl,xbuf,box,mu_tot, ir->ewald_geometry,ir->epsilon_surface, 0,&dvdl,&vdip,&vcharge); gmx_sum(1,&ener,cr); gmx_sum(1,&vcorr,cr); if (ngroups > 1) epme[ig][jg] = ener+vcorr; } } if (ngroups > 1) { if (fp_xvg) fprintf(fp_xvg,"%10.3f",tm); for(ig=0; (ig<ngroups); ig++) { for(jg=ig; (jg<ngroups); jg++) { if (ig != jg) epme[ig][jg] -= epme[ig][ig]+epme[jg][jg]; if (fp_xvg) fprintf(fp_xvg," %12.5e",epme[ig][jg]); } } if (fp_xvg) fprintf(fp_xvg,"\n"); } else { fprintf(fp,"Time: %10.3f Energy: %12.5e Correction: %12.5e Total: %12.5e\n", tm,ener,vcorr,ener+vcorr); if (fp_xvg) fprintf(fp_xvg,"%10.3f %12.5e %12.5e %12.5e\n",tm,ener+vcorr,vdip,vcharge); if (bVerbose) { m_add(vir,vir_corr,vir_tot); gmx_sum(9,vir_tot[0],cr); pr_rvecs(fp,0,"virial",vir_tot,DIM); } fflush(fp); } }
void do_force_lowlevel(t_forcerec *fr, t_inputrec *ir, t_idef *idef, t_commrec *cr, t_nrnb *nrnb, gmx_wallcycle_t wcycle, t_mdatoms *md, rvec x[], history_t *hist, rvec f[], rvec f_longrange[], gmx_enerdata_t *enerd, t_fcdata *fcd, gmx_localtop_t *top, gmx_genborn_t *born, gmx_bool bBornRadii, matrix box, t_lambda *fepvals, real *lambda, t_graph *graph, t_blocka *excl, rvec mu_tot[], int flags, float *cycles_pme) { int i, j; int donb_flags; gmx_bool bSB; int pme_flags; matrix boxs; rvec box_size; t_pbc pbc; real dvdl_dum[efptNR], dvdl_nb[efptNR]; #ifdef GMX_MPI double t0 = 0.0, t1, t2, t3; /* time measurement for coarse load balancing */ #endif set_pbc(&pbc, fr->ePBC, box); /* reset free energy components */ for (i = 0; i < efptNR; i++) { dvdl_nb[i] = 0; dvdl_dum[i] = 0; } /* Reset box */ for (i = 0; (i < DIM); i++) { box_size[i] = box[i][i]; } debug_gmx(); /* do QMMM first if requested */ if (fr->bQMMM) { enerd->term[F_EQM] = calculate_QMMM(cr, x, f, fr); } /* Call the short range functions all in one go. */ #ifdef GMX_MPI /*#define TAKETIME ((cr->npmenodes) && (fr->timesteps < 12))*/ #define TAKETIME FALSE if (TAKETIME) { MPI_Barrier(cr->mpi_comm_mygroup); t0 = MPI_Wtime(); } #endif if (ir->nwall) { /* foreign lambda component for walls */ real dvdl_walls = do_walls(ir, fr, box, md, x, f, lambda[efptVDW], enerd->grpp.ener[egLJSR], nrnb); enerd->dvdl_lin[efptVDW] += dvdl_walls; } /* If doing GB, reset dvda and calculate the Born radii */ if (ir->implicit_solvent) { wallcycle_sub_start(wcycle, ewcsNONBONDED); for (i = 0; i < born->nr; i++) { fr->dvda[i] = 0; } if (bBornRadii) { calc_gb_rad(cr, fr, ir, top, x, &(fr->gblist), born, md, nrnb); } wallcycle_sub_stop(wcycle, ewcsNONBONDED); } where(); /* We only do non-bonded calculation with group scheme here, the verlet * calls are done from do_force_cutsVERLET(). */ if (fr->cutoff_scheme == ecutsGROUP && (flags & GMX_FORCE_NONBONDED)) { donb_flags = 0; /* Add short-range interactions */ donb_flags |= GMX_NONBONDED_DO_SR; /* Currently all group scheme kernels always calculate (shift-)forces */ if (flags & GMX_FORCE_FORCES) { donb_flags |= GMX_NONBONDED_DO_FORCE; } if (flags & GMX_FORCE_VIRIAL) { donb_flags |= GMX_NONBONDED_DO_SHIFTFORCE; } if (flags & GMX_FORCE_ENERGY) { donb_flags |= GMX_NONBONDED_DO_POTENTIAL; } if (flags & GMX_FORCE_DO_LR) { donb_flags |= GMX_NONBONDED_DO_LR; } wallcycle_sub_start(wcycle, ewcsNONBONDED); do_nonbonded(fr, x, f, f_longrange, md, excl, &enerd->grpp, nrnb, lambda, dvdl_nb, -1, -1, donb_flags); /* If we do foreign lambda and we have soft-core interactions * we have to recalculate the (non-linear) energies contributions. */ if (fepvals->n_lambda > 0 && (flags & GMX_FORCE_DHDL) && fepvals->sc_alpha != 0) { for (i = 0; i < enerd->n_lambda; i++) { real lam_i[efptNR]; for (j = 0; j < efptNR; j++) { lam_i[j] = (i == 0 ? lambda[j] : fepvals->all_lambda[j][i-1]); } reset_foreign_enerdata(enerd); do_nonbonded(fr, x, f, f_longrange, md, excl, &(enerd->foreign_grpp), nrnb, lam_i, dvdl_dum, -1, -1, (donb_flags & ~GMX_NONBONDED_DO_FORCE) | GMX_NONBONDED_DO_FOREIGNLAMBDA); sum_epot(&(enerd->foreign_grpp), enerd->foreign_term); enerd->enerpart_lambda[i] += enerd->foreign_term[F_EPOT]; } } wallcycle_sub_stop(wcycle, ewcsNONBONDED); where(); } /* If we are doing GB, calculate bonded forces and apply corrections * to the solvation forces */ /* MRS: Eventually, many need to include free energy contribution here! */ if (ir->implicit_solvent) { wallcycle_sub_start(wcycle, ewcsLISTED); calc_gb_forces(cr, md, born, top, x, f, fr, idef, ir->gb_algorithm, ir->sa_algorithm, nrnb, &pbc, graph, enerd); wallcycle_sub_stop(wcycle, ewcsLISTED); } #ifdef GMX_MPI if (TAKETIME) { t1 = MPI_Wtime(); fr->t_fnbf += t1-t0; } #endif if (fepvals->sc_alpha != 0) { enerd->dvdl_nonlin[efptVDW] += dvdl_nb[efptVDW]; } else { enerd->dvdl_lin[efptVDW] += dvdl_nb[efptVDW]; } if (fepvals->sc_alpha != 0) /* even though coulomb part is linear, we already added it, beacuse we need to go through the vdw calculation anyway */ { enerd->dvdl_nonlin[efptCOUL] += dvdl_nb[efptCOUL]; } else { enerd->dvdl_lin[efptCOUL] += dvdl_nb[efptCOUL]; } debug_gmx(); if (debug) { pr_rvecs(debug, 0, "fshift after SR", fr->fshift, SHIFTS); } /* Shift the coordinates. Must be done before listed forces and PPPM, * but is also necessary for SHAKE and update, therefore it can NOT * go when no listed forces have to be evaluated. * * The shifting and PBC code is deliberately not timed, since with * the Verlet scheme it only takes non-zero time with triclinic * boxes, and even then the time is around a factor of 100 less * than the next smallest counter. */ /* Here sometimes we would not need to shift with NBFonly, * but we do so anyhow for consistency of the returned coordinates. */ if (graph) { shift_self(graph, box, x); if (TRICLINIC(box)) { inc_nrnb(nrnb, eNR_SHIFTX, 2*graph->nnodes); } else { inc_nrnb(nrnb, eNR_SHIFTX, graph->nnodes); } } /* Check whether we need to do listed interactions or correct for exclusions */ if (fr->bMolPBC && ((flags & GMX_FORCE_LISTED) || EEL_RF(fr->eeltype) || EEL_FULL(fr->eeltype) || EVDW_PME(fr->vdwtype))) { /* TODO There are no electrostatics methods that require this transformation, when using the Verlet scheme, so update the above conditional. */ /* Since all atoms are in the rectangular or triclinic unit-cell, * only single box vector shifts (2 in x) are required. */ set_pbc_dd(&pbc, fr->ePBC, cr->dd, TRUE, box); } debug_gmx(); do_force_listed(wcycle, box, ir->fepvals, cr->ms, idef, (const rvec *) x, hist, f, fr, &pbc, graph, enerd, nrnb, lambda, md, fcd, DOMAINDECOMP(cr) ? cr->dd->gatindex : NULL, flags); where(); *cycles_pme = 0; clear_mat(fr->vir_el_recip); clear_mat(fr->vir_lj_recip); /* Do long-range electrostatics and/or LJ-PME, including related short-range * corrections. */ if (EEL_FULL(fr->eeltype) || EVDW_PME(fr->vdwtype)) { int status = 0; real Vlr_q = 0, Vlr_lj = 0, Vcorr_q = 0, Vcorr_lj = 0; real dvdl_long_range_q = 0, dvdl_long_range_lj = 0; bSB = (ir->nwall == 2); if (bSB) { copy_mat(box, boxs); svmul(ir->wall_ewald_zfac, boxs[ZZ], boxs[ZZ]); box_size[ZZ] *= ir->wall_ewald_zfac; } if (EEL_PME_EWALD(fr->eeltype) || EVDW_PME(fr->vdwtype)) { real dvdl_long_range_correction_q = 0; real dvdl_long_range_correction_lj = 0; /* With the Verlet scheme exclusion forces are calculated * in the non-bonded kernel. */ /* The TPI molecule does not have exclusions with the rest * of the system and no intra-molecular PME grid * contributions will be calculated in * gmx_pme_calc_energy. */ if ((ir->cutoff_scheme == ecutsGROUP && fr->n_tpi == 0) || ir->ewald_geometry != eewg3D || ir->epsilon_surface != 0) { int nthreads, t; wallcycle_sub_start(wcycle, ewcsEWALD_CORRECTION); if (fr->n_tpi > 0) { gmx_fatal(FARGS, "TPI with PME currently only works in a 3D geometry with tin-foil boundary conditions"); } nthreads = gmx_omp_nthreads_get(emntBonded); #pragma omp parallel for num_threads(nthreads) schedule(static) for (t = 0; t < nthreads; t++) { int i; rvec *fnv; tensor *vir_q, *vir_lj; real *Vcorrt_q, *Vcorrt_lj, *dvdlt_q, *dvdlt_lj; if (t == 0) { fnv = fr->f_novirsum; vir_q = &fr->vir_el_recip; vir_lj = &fr->vir_lj_recip; Vcorrt_q = &Vcorr_q; Vcorrt_lj = &Vcorr_lj; dvdlt_q = &dvdl_long_range_correction_q; dvdlt_lj = &dvdl_long_range_correction_lj; } else { fnv = fr->f_t[t].f; vir_q = &fr->f_t[t].vir_q; vir_lj = &fr->f_t[t].vir_lj; Vcorrt_q = &fr->f_t[t].Vcorr_q; Vcorrt_lj = &fr->f_t[t].Vcorr_lj; dvdlt_q = &fr->f_t[t].dvdl[efptCOUL]; dvdlt_lj = &fr->f_t[t].dvdl[efptVDW]; for (i = 0; i < fr->natoms_force; i++) { clear_rvec(fnv[i]); } clear_mat(*vir_q); clear_mat(*vir_lj); } *dvdlt_q = 0; *dvdlt_lj = 0; ewald_LRcorrection(fr->excl_load[t], fr->excl_load[t+1], cr, t, fr, md->chargeA, md->chargeB, md->sqrt_c6A, md->sqrt_c6B, md->sigmaA, md->sigmaB, md->sigma3A, md->sigma3B, md->nChargePerturbed || md->nTypePerturbed, ir->cutoff_scheme != ecutsVERLET, excl, x, bSB ? boxs : box, mu_tot, ir->ewald_geometry, ir->epsilon_surface, fnv, *vir_q, *vir_lj, Vcorrt_q, Vcorrt_lj, lambda[efptCOUL], lambda[efptVDW], dvdlt_q, dvdlt_lj); } if (nthreads > 1) { reduce_thread_forces(fr->natoms_force, fr->f_novirsum, fr->vir_el_recip, fr->vir_lj_recip, &Vcorr_q, &Vcorr_lj, &dvdl_long_range_correction_q, &dvdl_long_range_correction_lj, nthreads, fr->f_t); } wallcycle_sub_stop(wcycle, ewcsEWALD_CORRECTION); } if (EEL_PME_EWALD(fr->eeltype) && fr->n_tpi == 0) { /* This is not in a subcounter because it takes a negligible and constant-sized amount of time */ Vcorr_q += ewald_charge_correction(cr, fr, lambda[efptCOUL], box, &dvdl_long_range_correction_q, fr->vir_el_recip); } enerd->dvdl_lin[efptCOUL] += dvdl_long_range_correction_q; enerd->dvdl_lin[efptVDW] += dvdl_long_range_correction_lj; if ((EEL_PME(fr->eeltype) || EVDW_PME(fr->vdwtype)) && (cr->duty & DUTY_PME)) { /* Do reciprocal PME for Coulomb and/or LJ. */ assert(fr->n_tpi >= 0); if (fr->n_tpi == 0 || (flags & GMX_FORCE_STATECHANGED)) { pme_flags = GMX_PME_SPREAD | GMX_PME_SOLVE; if (EEL_PME(fr->eeltype)) { pme_flags |= GMX_PME_DO_COULOMB; } if (EVDW_PME(fr->vdwtype)) { pme_flags |= GMX_PME_DO_LJ; } if (flags & GMX_FORCE_FORCES) { pme_flags |= GMX_PME_CALC_F; } if (flags & GMX_FORCE_VIRIAL) { pme_flags |= GMX_PME_CALC_ENER_VIR; } if (fr->n_tpi > 0) { /* We don't calculate f, but we do want the potential */ pme_flags |= GMX_PME_CALC_POT; } wallcycle_start(wcycle, ewcPMEMESH); status = gmx_pme_do(fr->pmedata, 0, md->homenr - fr->n_tpi, x, fr->f_novirsum, md->chargeA, md->chargeB, md->sqrt_c6A, md->sqrt_c6B, md->sigmaA, md->sigmaB, bSB ? boxs : box, cr, DOMAINDECOMP(cr) ? dd_pme_maxshift_x(cr->dd) : 0, DOMAINDECOMP(cr) ? dd_pme_maxshift_y(cr->dd) : 0, nrnb, wcycle, fr->vir_el_recip, fr->ewaldcoeff_q, fr->vir_lj_recip, fr->ewaldcoeff_lj, &Vlr_q, &Vlr_lj, lambda[efptCOUL], lambda[efptVDW], &dvdl_long_range_q, &dvdl_long_range_lj, pme_flags); *cycles_pme = wallcycle_stop(wcycle, ewcPMEMESH); if (status != 0) { gmx_fatal(FARGS, "Error %d in reciprocal PME routine", status); } /* We should try to do as little computation after * this as possible, because parallel PME synchronizes * the nodes, so we want all load imbalance of the * rest of the force calculation to be before the PME * call. DD load balancing is done on the whole time * of the force call (without PME). */ } if (fr->n_tpi > 0) { if (EVDW_PME(ir->vdwtype)) { gmx_fatal(FARGS, "Test particle insertion not implemented with LJ-PME"); } /* Determine the PME grid energy of the test molecule * with the PME grid potential of the other charges. */ gmx_pme_calc_energy(fr->pmedata, fr->n_tpi, x + md->homenr - fr->n_tpi, md->chargeA + md->homenr - fr->n_tpi, &Vlr_q); } } } if (!EEL_PME(fr->eeltype) && EEL_PME_EWALD(fr->eeltype)) { Vlr_q = do_ewald(ir, x, fr->f_novirsum, md->chargeA, md->chargeB, box_size, cr, md->homenr, fr->vir_el_recip, fr->ewaldcoeff_q, lambda[efptCOUL], &dvdl_long_range_q, fr->ewald_table); } /* Note that with separate PME nodes we get the real energies later */ enerd->dvdl_lin[efptCOUL] += dvdl_long_range_q; enerd->dvdl_lin[efptVDW] += dvdl_long_range_lj; enerd->term[F_COUL_RECIP] = Vlr_q + Vcorr_q; enerd->term[F_LJ_RECIP] = Vlr_lj + Vcorr_lj; if (debug) { fprintf(debug, "Vlr_q = %g, Vcorr_q = %g, Vlr_corr_q = %g\n", Vlr_q, Vcorr_q, enerd->term[F_COUL_RECIP]); pr_rvecs(debug, 0, "vir_el_recip after corr", fr->vir_el_recip, DIM); pr_rvecs(debug, 0, "fshift after LR Corrections", fr->fshift, SHIFTS); fprintf(debug, "Vlr_lj: %g, Vcorr_lj = %g, Vlr_corr_lj = %g\n", Vlr_lj, Vcorr_lj, enerd->term[F_LJ_RECIP]); pr_rvecs(debug, 0, "vir_lj_recip after corr", fr->vir_lj_recip, DIM); } } else { /* Is there a reaction-field exclusion correction needed? */ if (EEL_RF(fr->eeltype) && eelRF_NEC != fr->eeltype) { /* With the Verlet scheme, exclusion forces are calculated * in the non-bonded kernel. */ if (ir->cutoff_scheme != ecutsVERLET) { real dvdl_rf_excl = 0; enerd->term[F_RF_EXCL] = RF_excl_correction(fr, graph, md, excl, x, f, fr->fshift, &pbc, lambda[efptCOUL], &dvdl_rf_excl); enerd->dvdl_lin[efptCOUL] += dvdl_rf_excl; } } } where(); debug_gmx(); if (debug) { print_nrnb(debug, nrnb); } debug_gmx(); #ifdef GMX_MPI if (TAKETIME) { t2 = MPI_Wtime(); MPI_Barrier(cr->mpi_comm_mygroup); t3 = MPI_Wtime(); fr->t_wait += t3-t2; if (fr->timesteps == 11) { char buf[22]; fprintf(stderr, "* PP load balancing info: rank %d, step %s, rel wait time=%3.0f%% , load string value: %7.2f\n", cr->nodeid, gmx_step_str(fr->timesteps, buf), 100*fr->t_wait/(fr->t_wait+fr->t_fnbf), (fr->t_fnbf+fr->t_wait)/fr->t_fnbf); } fr->timesteps++; } #endif if (debug) { pr_rvecs(debug, 0, "fshift after bondeds", fr->fshift, SHIFTS); } }
int relax_shell_flexcon(FILE *fplog, t_commrec *cr, gmx_bool bVerbose, gmx_int64_t mdstep, t_inputrec *inputrec, gmx_bool bDoNS, int force_flags, gmx_localtop_t *top, gmx_constr_t constr, gmx_enerdata_t *enerd, t_fcdata *fcd, t_state *state, rvec f[], tensor force_vir, t_mdatoms *md, t_nrnb *nrnb, gmx_wallcycle_t wcycle, t_graph *graph, gmx_groups_t *groups, struct gmx_shellfc *shfc, t_forcerec *fr, gmx_bool bBornRadii, double t, rvec mu_tot, gmx_bool *bConverged, gmx_vsite_t *vsite, FILE *fp_field) { int nshell; t_shell *shell; t_idef *idef; rvec *pos[2], *force[2], *acc_dir = NULL, *x_old = NULL; real Epot[2], df[2]; rvec dx; real sf_dir, invdt; real ftol, xiH, xiS, dum = 0; char sbuf[22]; gmx_bool bCont, bInit; int nat, dd_ac0, dd_ac1 = 0, i; int start = 0, homenr = md->homenr, end = start+homenr, cg0, cg1; int nflexcon, g, number_steps, d, Min = 0, count = 0; #define Try (1-Min) /* At start Try = 1 */ bCont = (mdstep == inputrec->init_step) && inputrec->bContinuation; bInit = (mdstep == inputrec->init_step) || shfc->bRequireInit; ftol = inputrec->em_tol; number_steps = inputrec->niter; nshell = shfc->nshell; shell = shfc->shell; nflexcon = shfc->nflexcon; idef = &top->idef; if (DOMAINDECOMP(cr)) { nat = dd_natoms_vsite(cr->dd); if (nflexcon > 0) { dd_get_constraint_range(cr->dd, &dd_ac0, &dd_ac1); nat = max(nat, dd_ac1); } } else { nat = state->natoms; } if (nat > shfc->x_nalloc) { /* Allocate local arrays */ shfc->x_nalloc = over_alloc_dd(nat); for (i = 0; (i < 2); i++) { srenew(shfc->x[i], shfc->x_nalloc); srenew(shfc->f[i], shfc->x_nalloc); } } for (i = 0; (i < 2); i++) { pos[i] = shfc->x[i]; force[i] = shfc->f[i]; } /* When we had particle decomposition, this code only worked with * PD when all particles involved with each shell were in the same * charge group. Not sure if this is still relevant. */ if (bDoNS && inputrec->ePBC != epbcNONE && !DOMAINDECOMP(cr)) { /* This is the only time where the coordinates are used * before do_force is called, which normally puts all * charge groups in the box. */ cg0 = 0; cg1 = top->cgs.nr; put_charge_groups_in_box(fplog, cg0, cg1, fr->ePBC, state->box, &(top->cgs), state->x, fr->cg_cm); if (graph) { mk_mshift(fplog, graph, fr->ePBC, state->box, state->x); } } /* After this all coordinate arrays will contain whole molecules */ if (graph) { shift_self(graph, state->box, state->x); } if (nflexcon) { if (nat > shfc->flex_nalloc) { shfc->flex_nalloc = over_alloc_dd(nat); srenew(shfc->acc_dir, shfc->flex_nalloc); srenew(shfc->x_old, shfc->flex_nalloc); } acc_dir = shfc->acc_dir; x_old = shfc->x_old; for (i = 0; i < homenr; i++) { for (d = 0; d < DIM; d++) { shfc->x_old[i][d] = state->x[start+i][d] - state->v[start+i][d]*inputrec->delta_t; } } } /* Do a prediction of the shell positions */ if (shfc->bPredict && !bCont) { predict_shells(fplog, state->x, state->v, inputrec->delta_t, nshell, shell, md->massT, NULL, bInit); } /* do_force expected the charge groups to be in the box */ if (graph) { unshift_self(graph, state->box, state->x); } /* Calculate the forces first time around */ if (gmx_debug_at) { pr_rvecs(debug, 0, "x b4 do_force", state->x + start, homenr); } do_force(fplog, cr, inputrec, mdstep, nrnb, wcycle, top, groups, state->box, state->x, &state->hist, force[Min], force_vir, md, enerd, fcd, state->lambda, graph, fr, vsite, mu_tot, t, fp_field, NULL, bBornRadii, (bDoNS ? GMX_FORCE_NS : 0) | force_flags); sf_dir = 0; if (nflexcon) { init_adir(fplog, shfc, constr, idef, inputrec, cr, dd_ac1, mdstep, md, start, end, shfc->x_old-start, state->x, state->x, force[Min], shfc->acc_dir-start, fr->bMolPBC, state->box, state->lambda, &dum, nrnb); for (i = start; i < end; i++) { sf_dir += md->massT[i]*norm2(shfc->acc_dir[i-start]); } } Epot[Min] = enerd->term[F_EPOT]; df[Min] = rms_force(cr, shfc->f[Min], nshell, shell, nflexcon, &sf_dir, &Epot[Min]); df[Try] = 0; if (debug) { fprintf(debug, "df = %g %g\n", df[Min], df[Try]); } if (gmx_debug_at) { pr_rvecs(debug, 0, "force0", force[Min], md->nr); } if (nshell+nflexcon > 0) { /* Copy x to pos[Min] & pos[Try]: during minimization only the * shell positions are updated, therefore the other particles must * be set here. */ memcpy(pos[Min], state->x, nat*sizeof(state->x[0])); memcpy(pos[Try], state->x, nat*sizeof(state->x[0])); } if (bVerbose && MASTER(cr)) { print_epot(stdout, mdstep, 0, Epot[Min], df[Min], nflexcon, sf_dir); } if (debug) { fprintf(debug, "%17s: %14.10e\n", interaction_function[F_EKIN].longname, enerd->term[F_EKIN]); fprintf(debug, "%17s: %14.10e\n", interaction_function[F_EPOT].longname, enerd->term[F_EPOT]); fprintf(debug, "%17s: %14.10e\n", interaction_function[F_ETOT].longname, enerd->term[F_ETOT]); fprintf(debug, "SHELLSTEP %s\n", gmx_step_str(mdstep, sbuf)); } /* First check whether we should do shells, or whether the force is * low enough even without minimization. */ *bConverged = (df[Min] < ftol); for (count = 1; (!(*bConverged) && (count < number_steps)); count++) { if (vsite) { construct_vsites(vsite, pos[Min], inputrec->delta_t, state->v, idef->iparams, idef->il, fr->ePBC, fr->bMolPBC, cr, state->box); } if (nflexcon) { init_adir(fplog, shfc, constr, idef, inputrec, cr, dd_ac1, mdstep, md, start, end, x_old-start, state->x, pos[Min], force[Min], acc_dir-start, fr->bMolPBC, state->box, state->lambda, &dum, nrnb); directional_sd(pos[Min], pos[Try], acc_dir-start, start, end, fr->fc_stepsize); } /* New positions, Steepest descent */ shell_pos_sd(pos[Min], pos[Try], force[Min], nshell, shell, count); /* do_force expected the charge groups to be in the box */ if (graph) { unshift_self(graph, state->box, pos[Try]); } if (gmx_debug_at) { pr_rvecs(debug, 0, "RELAX: pos[Min] ", pos[Min] + start, homenr); pr_rvecs(debug, 0, "RELAX: pos[Try] ", pos[Try] + start, homenr); } /* Try the new positions */ do_force(fplog, cr, inputrec, 1, nrnb, wcycle, top, groups, state->box, pos[Try], &state->hist, force[Try], force_vir, md, enerd, fcd, state->lambda, graph, fr, vsite, mu_tot, t, fp_field, NULL, bBornRadii, force_flags); if (gmx_debug_at) { pr_rvecs(debug, 0, "RELAX: force[Min]", force[Min] + start, homenr); pr_rvecs(debug, 0, "RELAX: force[Try]", force[Try] + start, homenr); } sf_dir = 0; if (nflexcon) { init_adir(fplog, shfc, constr, idef, inputrec, cr, dd_ac1, mdstep, md, start, end, x_old-start, state->x, pos[Try], force[Try], acc_dir-start, fr->bMolPBC, state->box, state->lambda, &dum, nrnb); for (i = start; i < end; i++) { sf_dir += md->massT[i]*norm2(acc_dir[i-start]); } } Epot[Try] = enerd->term[F_EPOT]; df[Try] = rms_force(cr, force[Try], nshell, shell, nflexcon, &sf_dir, &Epot[Try]); if (debug) { fprintf(debug, "df = %g %g\n", df[Min], df[Try]); } if (debug) { if (gmx_debug_at) { pr_rvecs(debug, 0, "F na do_force", force[Try] + start, homenr); } if (gmx_debug_at) { fprintf(debug, "SHELL ITER %d\n", count); dump_shells(debug, pos[Try], force[Try], ftol, nshell, shell); } } if (bVerbose && MASTER(cr)) { print_epot(stdout, mdstep, count, Epot[Try], df[Try], nflexcon, sf_dir); } *bConverged = (df[Try] < ftol); if ((df[Try] < df[Min])) { if (debug) { fprintf(debug, "Swapping Min and Try\n"); } if (nflexcon) { /* Correct the velocities for the flexible constraints */ invdt = 1/inputrec->delta_t; for (i = start; i < end; i++) { for (d = 0; d < DIM; d++) { state->v[i][d] += (pos[Try][i][d] - pos[Min][i][d])*invdt; } } } Min = Try; } else { decrease_step_size(nshell, shell); } } if (MASTER(cr) && !(*bConverged)) { /* Note that the energies and virial are incorrect when not converged */ if (fplog) { fprintf(fplog, "step %s: EM did not converge in %d iterations, RMS force %.3f\n", gmx_step_str(mdstep, sbuf), number_steps, df[Min]); } fprintf(stderr, "step %s: EM did not converge in %d iterations, RMS force %.3f\n", gmx_step_str(mdstep, sbuf), number_steps, df[Min]); } /* Copy back the coordinates and the forces */ memcpy(state->x, pos[Min], nat*sizeof(state->x[0])); memcpy(f, force[Min], nat*sizeof(f[0])); return count; }
void do_force_lowlevel(FILE *fplog, gmx_large_int_t step, t_forcerec *fr, t_inputrec *ir, t_idef *idef, t_commrec *cr, t_nrnb *nrnb, gmx_wallcycle_t wcycle, t_mdatoms *md, t_grpopts *opts, rvec x[], history_t *hist, rvec f[], rvec f_longrange[], gmx_enerdata_t *enerd, t_fcdata *fcd, gmx_mtop_t *mtop, gmx_localtop_t *top, gmx_genborn_t *born, t_atomtypes *atype, gmx_bool bBornRadii, matrix box, t_lambda *fepvals, real *lambda, t_graph *graph, t_blocka *excl, rvec mu_tot[], int flags, float *cycles_pme) { int i, j, status; int donb_flags; gmx_bool bDoEpot, bSepDVDL, bSB; int pme_flags; matrix boxs; rvec box_size; real Vsr, Vlr, Vcorr = 0; t_pbc pbc; real dvdgb; char buf[22]; double clam_i, vlam_i; real dvdl_dum[efptNR], dvdl, dvdl_nb[efptNR], lam_i[efptNR]; real dvdlsum; #ifdef GMX_MPI double t0 = 0.0, t1, t2, t3; /* time measurement for coarse load balancing */ #endif #define PRINT_SEPDVDL(s, v, dvdlambda) if (bSepDVDL) {fprintf(fplog, sepdvdlformat, s, v, dvdlambda); } GMX_MPE_LOG(ev_force_start); set_pbc(&pbc, fr->ePBC, box); /* reset free energy components */ for (i = 0; i < efptNR; i++) { dvdl_nb[i] = 0; dvdl_dum[i] = 0; } /* Reset box */ for (i = 0; (i < DIM); i++) { box_size[i] = box[i][i]; } bSepDVDL = (fr->bSepDVDL && do_per_step(step, ir->nstlog)); debug_gmx(); /* do QMMM first if requested */ if (fr->bQMMM) { enerd->term[F_EQM] = calculate_QMMM(cr, x, f, fr, md); } if (bSepDVDL) { fprintf(fplog, "Step %s: non-bonded V and dVdl for node %d:\n", gmx_step_str(step, buf), cr->nodeid); } /* Call the short range functions all in one go. */ GMX_MPE_LOG(ev_do_fnbf_start); #ifdef GMX_MPI /*#define TAKETIME ((cr->npmenodes) && (fr->timesteps < 12))*/ #define TAKETIME FALSE if (TAKETIME) { MPI_Barrier(cr->mpi_comm_mygroup); t0 = MPI_Wtime(); } #endif if (ir->nwall) { /* foreign lambda component for walls */ dvdl = do_walls(ir, fr, box, md, x, f, lambda[efptVDW], enerd->grpp.ener[egLJSR], nrnb); PRINT_SEPDVDL("Walls", 0.0, dvdl); enerd->dvdl_lin[efptVDW] += dvdl; } /* If doing GB, reset dvda and calculate the Born radii */ if (ir->implicit_solvent) { wallcycle_sub_start(wcycle, ewcsNONBONDED); for (i = 0; i < born->nr; i++) { fr->dvda[i] = 0; } if (bBornRadii) { calc_gb_rad(cr, fr, ir, top, atype, x, &(fr->gblist), born, md, nrnb); } wallcycle_sub_stop(wcycle, ewcsNONBONDED); } where(); /* We only do non-bonded calculation with group scheme here, the verlet * calls are done from do_force_cutsVERLET(). */ if (fr->cutoff_scheme == ecutsGROUP && (flags & GMX_FORCE_NONBONDED)) { donb_flags = 0; /* Add short-range interactions */ donb_flags |= GMX_NONBONDED_DO_SR; if (flags & GMX_FORCE_FORCES) { donb_flags |= GMX_NONBONDED_DO_FORCE; } if (flags & GMX_FORCE_ENERGY) { donb_flags |= GMX_NONBONDED_DO_POTENTIAL; } if (flags & GMX_FORCE_DO_LR) { donb_flags |= GMX_NONBONDED_DO_LR; } wallcycle_sub_start(wcycle, ewcsNONBONDED); do_nonbonded(cr, fr, x, f, f_longrange, md, excl, &enerd->grpp, box_size, nrnb, lambda, dvdl_nb, -1, -1, donb_flags); /* If we do foreign lambda and we have soft-core interactions * we have to recalculate the (non-linear) energies contributions. */ if (fepvals->n_lambda > 0 && (flags & GMX_FORCE_DHDL) && fepvals->sc_alpha != 0) { for (i = 0; i < enerd->n_lambda; i++) { for (j = 0; j < efptNR; j++) { lam_i[j] = (i == 0 ? lambda[j] : fepvals->all_lambda[j][i-1]); } reset_foreign_enerdata(enerd); do_nonbonded(cr, fr, x, f, f_longrange, md, excl, &(enerd->foreign_grpp), box_size, nrnb, lam_i, dvdl_dum, -1, -1, (donb_flags & ~GMX_NONBONDED_DO_FORCE) | GMX_NONBONDED_DO_FOREIGNLAMBDA); sum_epot(&ir->opts, &(enerd->foreign_grpp), enerd->foreign_term); enerd->enerpart_lambda[i] += enerd->foreign_term[F_EPOT]; } } wallcycle_sub_stop(wcycle, ewcsNONBONDED); where(); } /* If we are doing GB, calculate bonded forces and apply corrections * to the solvation forces */ /* MRS: Eventually, many need to include free energy contribution here! */ if (ir->implicit_solvent) { wallcycle_sub_start(wcycle, ewcsBONDED); calc_gb_forces(cr, md, born, top, atype, x, f, fr, idef, ir->gb_algorithm, ir->sa_algorithm, nrnb, bBornRadii, &pbc, graph, enerd); wallcycle_sub_stop(wcycle, ewcsBONDED); } #ifdef GMX_MPI if (TAKETIME) { t1 = MPI_Wtime(); fr->t_fnbf += t1-t0; } #endif if (fepvals->sc_alpha != 0) { enerd->dvdl_nonlin[efptVDW] += dvdl_nb[efptVDW]; } else { enerd->dvdl_lin[efptVDW] += dvdl_nb[efptVDW]; } if (fepvals->sc_alpha != 0) /* even though coulomb part is linear, we already added it, beacuse we need to go through the vdw calculation anyway */ { enerd->dvdl_nonlin[efptCOUL] += dvdl_nb[efptCOUL]; } else { enerd->dvdl_lin[efptCOUL] += dvdl_nb[efptCOUL]; } Vsr = 0; if (bSepDVDL) { for (i = 0; i < enerd->grpp.nener; i++) { Vsr += (fr->bBHAM ? enerd->grpp.ener[egBHAMSR][i] : enerd->grpp.ener[egLJSR][i]) + enerd->grpp.ener[egCOULSR][i] + enerd->grpp.ener[egGB][i]; } dvdlsum = dvdl_nb[efptVDW] + dvdl_nb[efptCOUL]; PRINT_SEPDVDL("VdW and Coulomb SR particle-p.", Vsr, dvdlsum); } debug_gmx(); GMX_MPE_LOG(ev_do_fnbf_finish); if (debug) { pr_rvecs(debug, 0, "fshift after SR", fr->fshift, SHIFTS); } /* Shift the coordinates. Must be done before bonded forces and PPPM, * but is also necessary for SHAKE and update, therefore it can NOT * go when no bonded forces have to be evaluated. */ /* Here sometimes we would not need to shift with NBFonly, * but we do so anyhow for consistency of the returned coordinates. */ if (graph) { shift_self(graph, box, x); if (TRICLINIC(box)) { inc_nrnb(nrnb, eNR_SHIFTX, 2*graph->nnodes); } else { inc_nrnb(nrnb, eNR_SHIFTX, graph->nnodes); } } /* Check whether we need to do bondeds or correct for exclusions */ if (fr->bMolPBC && ((flags & GMX_FORCE_BONDED) || EEL_RF(fr->eeltype) || EEL_FULL(fr->eeltype))) { /* Since all atoms are in the rectangular or triclinic unit-cell, * only single box vector shifts (2 in x) are required. */ set_pbc_dd(&pbc, fr->ePBC, cr->dd, TRUE, box); } debug_gmx(); if (flags & GMX_FORCE_BONDED) { GMX_MPE_LOG(ev_calc_bonds_start); wallcycle_sub_start(wcycle, ewcsBONDED); calc_bonds(fplog, cr->ms, idef, x, hist, f, fr, &pbc, graph, enerd, nrnb, lambda, md, fcd, DOMAINDECOMP(cr) ? cr->dd->gatindex : NULL, atype, born, flags, fr->bSepDVDL && do_per_step(step, ir->nstlog), step); /* Check if we have to determine energy differences * at foreign lambda's. */ if (fepvals->n_lambda > 0 && (flags & GMX_FORCE_DHDL) && idef->ilsort != ilsortNO_FE) { if (idef->ilsort != ilsortFE_SORTED) { gmx_incons("The bonded interactions are not sorted for free energy"); } for (i = 0; i < enerd->n_lambda; i++) { reset_foreign_enerdata(enerd); for (j = 0; j < efptNR; j++) { lam_i[j] = (i == 0 ? lambda[j] : fepvals->all_lambda[j][i-1]); } calc_bonds_lambda(fplog, idef, x, fr, &pbc, graph, &(enerd->foreign_grpp), enerd->foreign_term, nrnb, lam_i, md, fcd, DOMAINDECOMP(cr) ? cr->dd->gatindex : NULL); sum_epot(&ir->opts, &(enerd->foreign_grpp), enerd->foreign_term); enerd->enerpart_lambda[i] += enerd->foreign_term[F_EPOT]; } } debug_gmx(); GMX_MPE_LOG(ev_calc_bonds_finish); wallcycle_sub_stop(wcycle, ewcsBONDED); } where(); *cycles_pme = 0; if (EEL_FULL(fr->eeltype)) { bSB = (ir->nwall == 2); if (bSB) { copy_mat(box, boxs); svmul(ir->wall_ewald_zfac, boxs[ZZ], boxs[ZZ]); box_size[ZZ] *= ir->wall_ewald_zfac; } clear_mat(fr->vir_el_recip); if (fr->bEwald) { Vcorr = 0; dvdl = 0; /* With the Verlet scheme exclusion forces are calculated * in the non-bonded kernel. */ /* The TPI molecule does not have exclusions with the rest * of the system and no intra-molecular PME grid contributions * will be calculated in gmx_pme_calc_energy. */ if ((ir->cutoff_scheme == ecutsGROUP && fr->n_tpi == 0) || ir->ewald_geometry != eewg3D || ir->epsilon_surface != 0) { int nthreads, t; wallcycle_sub_start(wcycle, ewcsEWALD_CORRECTION); if (fr->n_tpi > 0) { gmx_fatal(FARGS, "TPI with PME currently only works in a 3D geometry with tin-foil boundary conditions"); } nthreads = gmx_omp_nthreads_get(emntBonded); #pragma omp parallel for num_threads(nthreads) schedule(static) for (t = 0; t < nthreads; t++) { int s, e, i; rvec *fnv; tensor *vir; real *Vcorrt, *dvdlt; if (t == 0) { fnv = fr->f_novirsum; vir = &fr->vir_el_recip; Vcorrt = &Vcorr; dvdlt = &dvdl; } else { fnv = fr->f_t[t].f; vir = &fr->f_t[t].vir; Vcorrt = &fr->f_t[t].Vcorr; dvdlt = &fr->f_t[t].dvdl[efptCOUL]; for (i = 0; i < fr->natoms_force; i++) { clear_rvec(fnv[i]); } clear_mat(*vir); } *dvdlt = 0; *Vcorrt = ewald_LRcorrection(fplog, fr->excl_load[t], fr->excl_load[t+1], cr, t, fr, md->chargeA, md->nChargePerturbed ? md->chargeB : NULL, ir->cutoff_scheme != ecutsVERLET, excl, x, bSB ? boxs : box, mu_tot, ir->ewald_geometry, ir->epsilon_surface, fnv, *vir, lambda[efptCOUL], dvdlt); } if (nthreads > 1) { reduce_thread_forces(fr->natoms_force, fr->f_novirsum, fr->vir_el_recip, &Vcorr, efptCOUL, &dvdl, nthreads, fr->f_t); } wallcycle_sub_stop(wcycle, ewcsEWALD_CORRECTION); } if (fr->n_tpi == 0) { Vcorr += ewald_charge_correction(cr, fr, lambda[efptCOUL], box, &dvdl, fr->vir_el_recip); } PRINT_SEPDVDL("Ewald excl./charge/dip. corr.", Vcorr, dvdl); enerd->dvdl_lin[efptCOUL] += dvdl; } status = 0; Vlr = 0; dvdl = 0; switch (fr->eeltype) { case eelPME: case eelPMESWITCH: case eelPMEUSER: case eelPMEUSERSWITCH: case eelP3M_AD: if (cr->duty & DUTY_PME) { assert(fr->n_tpi >= 0); if (fr->n_tpi == 0 || (flags & GMX_FORCE_STATECHANGED)) { pme_flags = GMX_PME_SPREAD_Q | GMX_PME_SOLVE; if (flags & GMX_FORCE_FORCES) { pme_flags |= GMX_PME_CALC_F; } if (flags & (GMX_FORCE_VIRIAL | GMX_FORCE_ENERGY)) { pme_flags |= GMX_PME_CALC_ENER_VIR; } if (fr->n_tpi > 0) { /* We don't calculate f, but we do want the potential */ pme_flags |= GMX_PME_CALC_POT; } wallcycle_start(wcycle, ewcPMEMESH); status = gmx_pme_do(fr->pmedata, md->start, md->homenr - fr->n_tpi, x, fr->f_novirsum, md->chargeA, md->chargeB, bSB ? boxs : box, cr, DOMAINDECOMP(cr) ? dd_pme_maxshift_x(cr->dd) : 0, DOMAINDECOMP(cr) ? dd_pme_maxshift_y(cr->dd) : 0, nrnb, wcycle, fr->vir_el_recip, fr->ewaldcoeff, &Vlr, lambda[efptCOUL], &dvdl, pme_flags); *cycles_pme = wallcycle_stop(wcycle, ewcPMEMESH); /* We should try to do as little computation after * this as possible, because parallel PME synchronizes * the nodes, so we want all load imbalance of the rest * of the force calculation to be before the PME call. * DD load balancing is done on the whole time of * the force call (without PME). */ } if (fr->n_tpi > 0) { /* Determine the PME grid energy of the test molecule * with the PME grid potential of the other charges. */ gmx_pme_calc_energy(fr->pmedata, fr->n_tpi, x + md->homenr - fr->n_tpi, md->chargeA + md->homenr - fr->n_tpi, &Vlr); } PRINT_SEPDVDL("PME mesh", Vlr, dvdl); } break; case eelEWALD: Vlr = do_ewald(fplog, FALSE, ir, x, fr->f_novirsum, md->chargeA, md->chargeB, box_size, cr, md->homenr, fr->vir_el_recip, fr->ewaldcoeff, lambda[efptCOUL], &dvdl, fr->ewald_table); PRINT_SEPDVDL("Ewald long-range", Vlr, dvdl); break; default: gmx_fatal(FARGS, "No such electrostatics method implemented %s", eel_names[fr->eeltype]); } if (status != 0) { gmx_fatal(FARGS, "Error %d in long range electrostatics routine %s", status, EELTYPE(fr->eeltype)); } /* Note that with separate PME nodes we get the real energies later */ enerd->dvdl_lin[efptCOUL] += dvdl; enerd->term[F_COUL_RECIP] = Vlr + Vcorr; if (debug) { fprintf(debug, "Vlr = %g, Vcorr = %g, Vlr_corr = %g\n", Vlr, Vcorr, enerd->term[F_COUL_RECIP]); pr_rvecs(debug, 0, "vir_el_recip after corr", fr->vir_el_recip, DIM); pr_rvecs(debug, 0, "fshift after LR Corrections", fr->fshift, SHIFTS); } } else { if (EEL_RF(fr->eeltype)) { /* With the Verlet scheme exclusion forces are calculated * in the non-bonded kernel. */ if (ir->cutoff_scheme != ecutsVERLET && fr->eeltype != eelRF_NEC) { dvdl = 0; enerd->term[F_RF_EXCL] = RF_excl_correction(fplog, fr, graph, md, excl, x, f, fr->fshift, &pbc, lambda[efptCOUL], &dvdl); } enerd->dvdl_lin[efptCOUL] += dvdl; PRINT_SEPDVDL("RF exclusion correction", enerd->term[F_RF_EXCL], dvdl); } } where(); debug_gmx(); if (debug) { print_nrnb(debug, nrnb); } debug_gmx(); #ifdef GMX_MPI if (TAKETIME) { t2 = MPI_Wtime(); MPI_Barrier(cr->mpi_comm_mygroup); t3 = MPI_Wtime(); fr->t_wait += t3-t2; if (fr->timesteps == 11) { fprintf(stderr, "* PP load balancing info: node %d, step %s, rel wait time=%3.0f%% , load string value: %7.2f\n", cr->nodeid, gmx_step_str(fr->timesteps, buf), 100*fr->t_wait/(fr->t_wait+fr->t_fnbf), (fr->t_fnbf+fr->t_wait)/fr->t_fnbf); } fr->timesteps++; } #endif if (debug) { pr_rvecs(debug, 0, "fshift after bondeds", fr->fshift, SHIFTS); } GMX_MPE_LOG(ev_force_finish); }
void do_force_lowlevel(t_forcerec *fr, t_inputrec *ir, t_idef *idef, t_commrec *cr, t_nrnb *nrnb, gmx_wallcycle_t wcycle, t_mdatoms *md, rvec x[], history_t *hist, rvec f[], rvec f_longrange[], gmx_enerdata_t *enerd, t_fcdata *fcd, gmx_localtop_t *top, gmx_genborn_t *born, gmx_bool bBornRadii, matrix box, t_lambda *fepvals, real *lambda, t_graph *graph, t_blocka *excl, rvec mu_tot[], int flags, float *cycles_pme) { int i, j; int donb_flags; gmx_bool bSB; int pme_flags; matrix boxs; rvec box_size; t_pbc pbc; real dvdl_dum[efptNR], dvdl_nb[efptNR]; #ifdef GMX_MPI double t0 = 0.0, t1, t2, t3; /* time measurement for coarse load balancing */ #endif set_pbc(&pbc, fr->ePBC, box); /* reset free energy components */ for (i = 0; i < efptNR; i++) { dvdl_nb[i] = 0; dvdl_dum[i] = 0; } /* Reset box */ for (i = 0; (i < DIM); i++) { box_size[i] = box[i][i]; } debug_gmx(); /* do QMMM first if requested */ if (fr->bQMMM) { enerd->term[F_EQM] = calculate_QMMM(cr, x, f, fr); } /* Call the short range functions all in one go. */ #ifdef GMX_MPI /*#define TAKETIME ((cr->npmenodes) && (fr->timesteps < 12))*/ #define TAKETIME FALSE if (TAKETIME) { MPI_Barrier(cr->mpi_comm_mygroup); t0 = MPI_Wtime(); } #endif if (ir->nwall) { /* foreign lambda component for walls */ real dvdl_walls = do_walls(ir, fr, box, md, x, f, lambda[efptVDW], enerd->grpp.ener[egLJSR], nrnb); enerd->dvdl_lin[efptVDW] += dvdl_walls; } /* If doing GB, reset dvda and calculate the Born radii */ if (ir->implicit_solvent) { wallcycle_sub_start(wcycle, ewcsNONBONDED); for (i = 0; i < born->nr; i++) { fr->dvda[i] = 0; } if (bBornRadii) { calc_gb_rad(cr, fr, ir, top, x, &(fr->gblist), born, md, nrnb); } wallcycle_sub_stop(wcycle, ewcsNONBONDED); } where(); /* We only do non-bonded calculation with group scheme here, the verlet * calls are done from do_force_cutsVERLET(). */ if (fr->cutoff_scheme == ecutsGROUP && (flags & GMX_FORCE_NONBONDED)) { donb_flags = 0; /* Add short-range interactions */ donb_flags |= GMX_NONBONDED_DO_SR; /* Currently all group scheme kernels always calculate (shift-)forces */ if (flags & GMX_FORCE_FORCES) { donb_flags |= GMX_NONBONDED_DO_FORCE; } if (flags & GMX_FORCE_VIRIAL) { donb_flags |= GMX_NONBONDED_DO_SHIFTFORCE; } if (flags & GMX_FORCE_ENERGY) { donb_flags |= GMX_NONBONDED_DO_POTENTIAL; } if (flags & GMX_FORCE_DO_LR) { donb_flags |= GMX_NONBONDED_DO_LR; } wallcycle_sub_start(wcycle, ewcsNONBONDED); do_nonbonded(fr, x, f, f_longrange, md, excl, &enerd->grpp, nrnb, lambda, dvdl_nb, -1, -1, donb_flags); /* If we do foreign lambda and we have soft-core interactions * we have to recalculate the (non-linear) energies contributions. */ if (fepvals->n_lambda > 0 && (flags & GMX_FORCE_DHDL) && fepvals->sc_alpha != 0) { for (i = 0; i < enerd->n_lambda; i++) { real lam_i[efptNR]; for (j = 0; j < efptNR; j++) { lam_i[j] = (i == 0 ? lambda[j] : fepvals->all_lambda[j][i-1]); } reset_foreign_enerdata(enerd); do_nonbonded(fr, x, f, f_longrange, md, excl, &(enerd->foreign_grpp), nrnb, lam_i, dvdl_dum, -1, -1, (donb_flags & ~GMX_NONBONDED_DO_FORCE) | GMX_NONBONDED_DO_FOREIGNLAMBDA); sum_epot(&(enerd->foreign_grpp), enerd->foreign_term); enerd->enerpart_lambda[i] += enerd->foreign_term[F_EPOT]; } } wallcycle_sub_stop(wcycle, ewcsNONBONDED); where(); } /* If we are doing GB, calculate bonded forces and apply corrections * to the solvation forces */ /* MRS: Eventually, many need to include free energy contribution here! */ if (ir->implicit_solvent) { wallcycle_sub_start(wcycle, ewcsLISTED); calc_gb_forces(cr, md, born, top, x, f, fr, idef, ir->gb_algorithm, ir->sa_algorithm, nrnb, &pbc, graph, enerd); wallcycle_sub_stop(wcycle, ewcsLISTED); } #ifdef GMX_MPI if (TAKETIME) { t1 = MPI_Wtime(); fr->t_fnbf += t1-t0; } #endif if (fepvals->sc_alpha != 0) { enerd->dvdl_nonlin[efptVDW] += dvdl_nb[efptVDW]; } else { enerd->dvdl_lin[efptVDW] += dvdl_nb[efptVDW]; } if (fepvals->sc_alpha != 0) /* even though coulomb part is linear, we already added it, beacuse we need to go through the vdw calculation anyway */ { enerd->dvdl_nonlin[efptCOUL] += dvdl_nb[efptCOUL]; } else { enerd->dvdl_lin[efptCOUL] += dvdl_nb[efptCOUL]; } debug_gmx(); if (debug) { pr_rvecs(debug, 0, "fshift after SR", fr->fshift, SHIFTS); } /* Shift the coordinates. Must be done before listed forces and PPPM, * but is also necessary for SHAKE and update, therefore it can NOT * go when no listed forces have to be evaluated. * * The shifting and PBC code is deliberately not timed, since with * the Verlet scheme it only takes non-zero time with triclinic * boxes, and even then the time is around a factor of 100 less * than the next smallest counter. */ /* Here sometimes we would not need to shift with NBFonly, * but we do so anyhow for consistency of the returned coordinates. */ if (graph) { shift_self(graph, box, x); if (TRICLINIC(box)) { inc_nrnb(nrnb, eNR_SHIFTX, 2*graph->nnodes); } else { inc_nrnb(nrnb, eNR_SHIFTX, graph->nnodes); } } /* Check whether we need to do listed interactions or correct for exclusions */ if (fr->bMolPBC && ((flags & GMX_FORCE_LISTED) || EEL_RF(fr->eeltype) || EEL_FULL(fr->eeltype) || EVDW_PME(fr->vdwtype))) { /* TODO There are no electrostatics methods that require this transformation, when using the Verlet scheme, so update the above conditional. */ /* Since all atoms are in the rectangular or triclinic unit-cell, * only single box vector shifts (2 in x) are required. */ set_pbc_dd(&pbc, fr->ePBC, cr->dd, TRUE, box); } debug_gmx(); do_force_listed(wcycle, box, ir->fepvals, cr->ms, idef, (const rvec *) x, hist, f, fr, &pbc, graph, enerd, nrnb, lambda, md, fcd, DOMAINDECOMP(cr) ? cr->dd->gatindex : NULL, flags); where(); *cycles_pme = 0; clear_mat(fr->vir_el_recip); clear_mat(fr->vir_lj_recip); /* Do long-range electrostatics and/or LJ-PME, including related short-range * corrections. */ if (EEL_FULL(fr->eeltype) || EVDW_PME(fr->vdwtype)) { int status = 0; real Vlr_q = 0, Vlr_lj = 0, Vcorr_q = 0, Vcorr_lj = 0; real dvdl_long_range_q = 0, dvdl_long_range_lj = 0; bSB = (ir->nwall == 2); if (bSB) { copy_mat(box, boxs); svmul(ir->wall_ewald_zfac, boxs[ZZ], boxs[ZZ]); box_size[ZZ] *= ir->wall_ewald_zfac; } if (EEL_PME_EWALD(fr->eeltype) || EVDW_PME(fr->vdwtype)) { real dvdl_long_range_correction_q = 0; real dvdl_long_range_correction_lj = 0; /* With the Verlet scheme exclusion forces are calculated * in the non-bonded kernel. */ /* The TPI molecule does not have exclusions with the rest * of the system and no intra-molecular PME grid * contributions will be calculated in * gmx_pme_calc_energy. */ if ((ir->cutoff_scheme == ecutsGROUP && fr->n_tpi == 0) || ir->ewald_geometry != eewg3D || ir->epsilon_surface != 0) { int nthreads, t; wallcycle_sub_start(wcycle, ewcsEWALD_CORRECTION); if (fr->n_tpi > 0) { gmx_fatal(FARGS, "TPI with PME currently only works in a 3D geometry with tin-foil boundary conditions"); } nthreads = fr->nthread_ewc; #pragma omp parallel for num_threads(nthreads) schedule(static) for (t = 0; t < nthreads; t++) { try { tensor *vir_q, *vir_lj; real *Vcorrt_q, *Vcorrt_lj, *dvdlt_q, *dvdlt_lj; if (t == 0) { vir_q = &fr->vir_el_recip; vir_lj = &fr->vir_lj_recip; Vcorrt_q = &Vcorr_q; Vcorrt_lj = &Vcorr_lj; dvdlt_q = &dvdl_long_range_correction_q; dvdlt_lj = &dvdl_long_range_correction_lj; } else { vir_q = &fr->ewc_t[t].vir_q; vir_lj = &fr->ewc_t[t].vir_lj; Vcorrt_q = &fr->ewc_t[t].Vcorr_q; Vcorrt_lj = &fr->ewc_t[t].Vcorr_lj; dvdlt_q = &fr->ewc_t[t].dvdl[efptCOUL]; dvdlt_lj = &fr->ewc_t[t].dvdl[efptVDW]; clear_mat(*vir_q); clear_mat(*vir_lj); } *dvdlt_q = 0; *dvdlt_lj = 0; /* Threading is only supported with the Verlet cut-off * scheme and then only single particle forces (no * exclusion forces) are calculated, so we can store * the forces in the normal, single fr->f_novirsum array. */ ewald_LRcorrection(fr->excl_load[t], fr->excl_load[t+1], cr, t, fr, md->chargeA, md->chargeB, md->sqrt_c6A, md->sqrt_c6B, md->sigmaA, md->sigmaB, md->sigma3A, md->sigma3B, md->nChargePerturbed || md->nTypePerturbed, ir->cutoff_scheme != ecutsVERLET, excl, x, bSB ? boxs : box, mu_tot, ir->ewald_geometry, ir->epsilon_surface, fr->f_novirsum, *vir_q, *vir_lj, Vcorrt_q, Vcorrt_lj, lambda[efptCOUL], lambda[efptVDW], dvdlt_q, dvdlt_lj); } GMX_CATCH_ALL_AND_EXIT_WITH_FATAL_ERROR; } if (nthreads > 1) { reduce_thread_energies(fr->vir_el_recip, fr->vir_lj_recip, &Vcorr_q, &Vcorr_lj, &dvdl_long_range_correction_q, &dvdl_long_range_correction_lj, nthreads, fr->ewc_t); } wallcycle_sub_stop(wcycle, ewcsEWALD_CORRECTION); }
void virial(FILE *fp,gmx_bool bFull,int nmol,rvec x[],matrix box,real rcut, gmx_bool bYaw,real q[],gmx_bool bLJ) { int i,j,im,jm,natmol,ik,jk,m,ninter; rvec dx,f,ftot,dvir,vir,pres,xcmi,xcmj,*force; real dx6,dx2,dx1,fscal,c6,c12,vcoul,v12,v6,vctot,v12tot,v6tot; t_pbc pbc; set_pbc(&pbc,box); fprintf(fp,"%3s - %3s: %6s %6s %6s %6s %8s %8s %8s\n", "ai","aj","dx","dy","dz","|d|","virx","viry","virz"); clear_rvec(ftot); clear_rvec(vir); ninter = 0; vctot = 0; v12tot = 0; v6tot = 0; natmol = bYaw ? 5 : 3; snew(force,nmol*natmol); for(i=0; (i<nmol); i++) { im = natmol*i; /* Center of geometry */ clear_rvec(xcmi); for(ik=0; (ik<natmol); ik++) rvec_inc(xcmi,x[im+ik]); for(m=0; (m<DIM); m++) xcmi[m] /= natmol; for(j=i+1; (j<nmol); j++) { jm = natmol*j; /* Center of geometry */ clear_rvec(xcmj); for(jk=0; (jk<natmol); jk++) rvec_inc(xcmj,x[jm+jk]); for(m=0; (m<DIM); m++) xcmj[m] /= natmol; /* First check COM-COM distance */ pbc_dx(&pbc,xcmi,xcmj,dx); if (norm(dx) < rcut) { ninter++; /* Neirest neighbour molecules! */ clear_rvec(dvir); for(ik=0; (ik<natmol); ik++) { for(jk=0; (jk<natmol); jk++) { pbc_dx(&pbc,x[im+ik],x[jm+jk],dx); dx2 = iprod(dx,dx); dx1 = sqrt(dx2); vcoul = q[ik]*q[jk]*ONE_4PI_EPS0/dx1; vctot += vcoul; if (bLJ) { if (bYaw) { c6 = yaw_lj[ik][2*jk]; c12 = yaw_lj[ik][2*jk+1]; } else { c6 = spc_lj[ik][2*jk]; c12 = spc_lj[ik][2*jk+1]; } dx6 = dx2*dx2*dx2; v6 = c6/dx6; v12 = c12/(dx6*dx6); v6tot -= v6; v12tot+= v12; fscal = (vcoul+12*v12-6*v6)/dx2; } else fscal = vcoul/dx2; for(m=0; (m<DIM); m++) { f[m] = dx[m]*fscal; dvir[m] -= 0.5*dx[m]*f[m]; } rvec_inc(force[ik+im],f); rvec_dec(force[jk+jm],f); /*if (bFull) fprintf(fp,"%3s%4d-%3s%4d: %6.3f %6.3f %6.3f %6.3f" " %8.3f %8.3f %8.3f\n", watname[ik],im+ik,watname[jk],jm+jk, dx[XX],dx[YY],dx[ZZ],norm(dx), dvir[XX],dvir[YY],dvir[ZZ]);*/ } } if (bFull) fprintf(fp,"%3s%4d-%3s%4d: " " %8.3f %8.3f %8.3f\n", "SOL",i,"SOL",j,dvir[XX],dvir[YY],dvir[ZZ]); rvec_inc(vir,dvir); } } } fprintf(fp,"There were %d interactions between the %d molecules (%.2f %%)\n", ninter,nmol,(real)ninter/(0.5*nmol*(nmol-1))); fprintf(fp,"Vcoul: %10.4e V12: %10.4e V6: %10.4e Vtot: %10.4e (kJ/mol)\n", vctot/nmol,v12tot/nmol,v6tot/nmol,(vctot+v12tot+v6tot)/nmol); pr_rvec(fp,0,"vir ",vir,DIM,TRUE); for(m=0; (m<DIM); m++) pres[m] = -2*PRESFAC/(det(box))*vir[m]; pr_rvec(fp,0,"pres",pres,DIM,TRUE); pr_rvecs(fp,0,"force",force,natmol*nmol); sfree(force); }
static void list_trn(char *fn) { static real mass[5] = { 15.9994, 1.008, 1.008, 0.0, 0.0 }; int i,j=0,m,fpread,fpwrite,nframe; rvec *x,*v,*f,fmol[2],xcm[2],torque[j],dx; real mmm,len; matrix box; t_trnheader trn; gmx_bool bOK; printf("Going to open %s\n",fn); fpread = open_trn(fn,"r"); fpwrite = open_tpx(NULL,"w"); gmx_fio_setdebug(fpwrite,TRUE); mmm=mass[0]+2*mass[1]; for(i=0; (i<5); i++) mass[i] /= mmm; nframe = 0; while (fread_trnheader(fpread,&trn,&bOK)) { snew(x,trn.natoms); snew(v,trn.natoms); snew(f,trn.natoms); if (fread_htrn(fpread,&trn, trn.box_size ? box : NULL, trn.x_size ? x : NULL, trn.v_size ? v : NULL, trn.f_size ? f : NULL)) { if (trn.x_size && trn.f_size) { printf("There are %d atoms\n",trn.natoms); for(j=0; (j<2); j++) { clear_rvec(xcm[j]); clear_rvec(fmol[j]); clear_rvec(torque[j]); for(i=5*j; (i<5*j+5); i++) { rvec_inc(fmol[j],f[i]); for(m=0; (m<DIM); m++) xcm[j][m] += mass[i%5]*x[i][m]; } for(i=5*j; (i<5*j+5); i++) { rvec_dec(x[i],xcm[j]); cprod(x[i],f[i],dx); rvec_inc(torque[j],dx); rvec_inc(x[i],xcm[j]); } } pr_rvecs(stdout,0,"FMOL ",fmol,2); pr_rvecs(stdout,0,"TORQUE",torque,2); printf("Distance matrix Water1-Water2\n%5s",""); for(j=0; (j<5); j++) printf(" %10s",nm[j]); printf("\n"); for(j=0; (j<5); j++) { printf("%5s",nm[j]); for(i=5; (i<10); i++) { rvec_sub(x[i],x[j],dx); len = sqrt(iprod(dx,dx)); printf(" %10.7f",len); } printf("\n"); } } } sfree(x); sfree(v); sfree(f); nframe++; } if (!bOK) fprintf(stderr,"\nWARNING: Incomplete frame header: nr %d, t=%g\n", nframe,trn.t); close_tpx(fpwrite); close_trn(fpread); }
static void list_tpx(const char *fn, gmx_bool bShowNumbers, const char *mdpfn, gmx_bool bSysTop) { FILE *gp; int fp, indent, i, j, **gcount, atot; t_state state; rvec *f = NULL; t_inputrec ir; t_tpxheader tpx; gmx_mtop_t mtop; gmx_groups_t *groups; t_topology top; read_tpxheader(fn, &tpx, TRUE, NULL, NULL); read_tpx_state(fn, tpx.bIr ? &ir : NULL, &state, tpx.bF ? f : NULL, tpx.bTop ? &mtop : NULL); if (mdpfn && tpx.bIr) { gp = gmx_fio_fopen(mdpfn, "w"); pr_inputrec(gp, 0, NULL, &(ir), TRUE); gmx_fio_fclose(gp); } if (!mdpfn) { if (bSysTop) { top = gmx_mtop_t_to_t_topology(&mtop); } if (available(stdout, &tpx, 0, fn)) { indent = 0; indent = pr_title(stdout, indent, fn); pr_inputrec(stdout, 0, "inputrec", tpx.bIr ? &(ir) : NULL, FALSE); indent = 0; pr_header(stdout, indent, "header", &(tpx)); if (!bSysTop) { pr_mtop(stdout, indent, "topology", &(mtop), bShowNumbers); } else { pr_top(stdout, indent, "topology", &(top), bShowNumbers); } pr_rvecs(stdout, indent, "box", tpx.bBox ? state.box : NULL, DIM); pr_rvecs(stdout, indent, "box_rel", tpx.bBox ? state.box_rel : NULL, DIM); pr_rvecs(stdout, indent, "boxv", tpx.bBox ? state.boxv : NULL, DIM); pr_rvecs(stdout, indent, "pres_prev", tpx.bBox ? state.pres_prev : NULL, DIM); pr_rvecs(stdout, indent, "svir_prev", tpx.bBox ? state.svir_prev : NULL, DIM); pr_rvecs(stdout, indent, "fvir_prev", tpx.bBox ? state.fvir_prev : NULL, DIM); /* leave nosehoover_xi in for now to match the tpr version */ pr_doubles(stdout, indent, "nosehoover_xi", state.nosehoover_xi, state.ngtc); /*pr_doubles(stdout,indent,"nosehoover_vxi",state.nosehoover_vxi,state.ngtc);*/ /*pr_doubles(stdout,indent,"therm_integral",state.therm_integral,state.ngtc);*/ pr_rvecs(stdout, indent, "x", tpx.bX ? state.x : NULL, state.natoms); pr_rvecs(stdout, indent, "v", tpx.bV ? state.v : NULL, state.natoms); if (tpx.bF) { pr_rvecs(stdout, indent, "f", f, state.natoms); } } groups = &mtop.groups; snew(gcount, egcNR); for (i = 0; (i < egcNR); i++) { snew(gcount[i], groups->grps[i].nr); } for (i = 0; (i < mtop.natoms); i++) { for (j = 0; (j < egcNR); j++) { gcount[j][ggrpnr(groups, j, i)]++; } } printf("Group statistics\n"); for (i = 0; (i < egcNR); i++) { atot = 0; printf("%-12s: ", gtypes[i]); for (j = 0; (j < groups->grps[i].nr); j++) { printf(" %5d", gcount[i][j]); atot += gcount[i][j]; } printf(" (total %d atoms)\n", atot); sfree(gcount[i]); } sfree(gcount); } done_state(&state); sfree(f); }
void do_force_lowlevel(FILE *fplog, gmx_large_int_t step, t_forcerec *fr, t_inputrec *ir, t_idef *idef, t_commrec *cr, t_nrnb *nrnb, gmx_wallcycle_t wcycle, t_mdatoms *md, t_grpopts *opts, rvec x[], history_t *hist, rvec f[], gmx_enerdata_t *enerd, t_fcdata *fcd, gmx_mtop_t *mtop, gmx_localtop_t *top, gmx_genborn_t *born, t_atomtypes *atype, gmx_bool bBornRadii, matrix box, real lambda, t_graph *graph, t_blocka *excl, rvec mu_tot[], int flags, float *cycles_pme) { int i,status; int donb_flags; gmx_bool bDoEpot,bSepDVDL,bSB; int pme_flags; matrix boxs; rvec box_size; real dvdlambda,Vsr,Vlr,Vcorr=0,vdip,vcharge; t_pbc pbc; real dvdgb; char buf[22]; gmx_enerdata_t ed_lam; double lam_i; real dvdl_dum; #ifdef GMX_MPI double t0=0.0,t1,t2,t3; /* time measurement for coarse load balancing */ #endif #define PRINT_SEPDVDL(s,v,dvdl) if (bSepDVDL) fprintf(fplog,sepdvdlformat,s,v,dvdl); GMX_MPE_LOG(ev_force_start); set_pbc(&pbc,fr->ePBC,box); /* Reset box */ for(i=0; (i<DIM); i++) { box_size[i]=box[i][i]; } bSepDVDL=(fr->bSepDVDL && do_per_step(step,ir->nstlog)); debug_gmx(); /* do QMMM first if requested */ if(fr->bQMMM) { enerd->term[F_EQM] = calculate_QMMM(cr,x,f,fr,md); } if (bSepDVDL) { fprintf(fplog,"Step %s: non-bonded V and dVdl for node %d:\n", gmx_step_str(step,buf),cr->nodeid); } /* Call the short range functions all in one go. */ GMX_MPE_LOG(ev_do_fnbf_start); dvdlambda = 0; #ifdef GMX_MPI /*#define TAKETIME ((cr->npmenodes) && (fr->timesteps < 12))*/ #define TAKETIME FALSE if (TAKETIME) { MPI_Barrier(cr->mpi_comm_mygroup); t0=MPI_Wtime(); } #endif if (ir->nwall) { dvdlambda = do_walls(ir,fr,box,md,x,f,lambda, enerd->grpp.ener[egLJSR],nrnb); PRINT_SEPDVDL("Walls",0.0,dvdlambda); enerd->dvdl_lin += dvdlambda; } /* If doing GB, reset dvda and calculate the Born radii */ if (ir->implicit_solvent) { /* wallcycle_start(wcycle,ewcGB); */ for(i=0; i<born->nr; i++) { fr->dvda[i]=0; } if(bBornRadii) { calc_gb_rad(cr,fr,ir,top,atype,x,&(fr->gblist),born,md,nrnb); } /* wallcycle_stop(wcycle, ewcGB); */ } where(); donb_flags = 0; if (flags & GMX_FORCE_FORCES) { donb_flags |= GMX_DONB_FORCES; } do_nonbonded(cr,fr,x,f,md,excl, fr->bBHAM ? enerd->grpp.ener[egBHAMSR] : enerd->grpp.ener[egLJSR], enerd->grpp.ener[egCOULSR], enerd->grpp.ener[egGB],box_size,nrnb, lambda,&dvdlambda,-1,-1,donb_flags); /* If we do foreign lambda and we have soft-core interactions * we have to recalculate the (non-linear) energies contributions. */ if (ir->n_flambda > 0 && (flags & GMX_FORCE_DHDL) && ir->sc_alpha != 0) { init_enerdata(mtop->groups.grps[egcENER].nr,ir->n_flambda,&ed_lam); for(i=0; i<enerd->n_lambda; i++) { lam_i = (i==0 ? lambda : ir->flambda[i-1]); dvdl_dum = 0; reset_enerdata(&ir->opts,fr,TRUE,&ed_lam,FALSE); do_nonbonded(cr,fr,x,f,md,excl, fr->bBHAM ? ed_lam.grpp.ener[egBHAMSR] : ed_lam.grpp.ener[egLJSR], ed_lam.grpp.ener[egCOULSR], enerd->grpp.ener[egGB], box_size,nrnb, lam_i,&dvdl_dum,-1,-1, GMX_DONB_FOREIGNLAMBDA); sum_epot(&ir->opts,&ed_lam); enerd->enerpart_lambda[i] += ed_lam.term[F_EPOT]; } destroy_enerdata(&ed_lam); } where(); /* If we are doing GB, calculate bonded forces and apply corrections * to the solvation forces */ if (ir->implicit_solvent) { calc_gb_forces(cr,md,born,top,atype,x,f,fr,idef, ir->gb_algorithm,ir->sa_algorithm,nrnb,bBornRadii,&pbc,graph,enerd); } #ifdef GMX_MPI if (TAKETIME) { t1=MPI_Wtime(); fr->t_fnbf += t1-t0; } #endif if (ir->sc_alpha != 0) { enerd->dvdl_nonlin += dvdlambda; } else { enerd->dvdl_lin += dvdlambda; } Vsr = 0; if (bSepDVDL) { for(i=0; i<enerd->grpp.nener; i++) { Vsr += (fr->bBHAM ? enerd->grpp.ener[egBHAMSR][i] : enerd->grpp.ener[egLJSR][i]) + enerd->grpp.ener[egCOULSR][i] + enerd->grpp.ener[egGB][i]; } } PRINT_SEPDVDL("VdW and Coulomb SR particle-p.",Vsr,dvdlambda); debug_gmx(); GMX_MPE_LOG(ev_do_fnbf_finish); if (debug) { pr_rvecs(debug,0,"fshift after SR",fr->fshift,SHIFTS); } /* Shift the coordinates. Must be done before bonded forces and PPPM, * but is also necessary for SHAKE and update, therefore it can NOT * go when no bonded forces have to be evaluated. */ /* Here sometimes we would not need to shift with NBFonly, * but we do so anyhow for consistency of the returned coordinates. */ if (graph) { shift_self(graph,box,x); if (TRICLINIC(box)) { inc_nrnb(nrnb,eNR_SHIFTX,2*graph->nnodes); } else { inc_nrnb(nrnb,eNR_SHIFTX,graph->nnodes); } } /* Check whether we need to do bondeds or correct for exclusions */ if (fr->bMolPBC && ((flags & GMX_FORCE_BONDED) || EEL_RF(fr->eeltype) || EEL_FULL(fr->eeltype))) { /* Since all atoms are in the rectangular or triclinic unit-cell, * only single box vector shifts (2 in x) are required. */ set_pbc_dd(&pbc,fr->ePBC,cr->dd,TRUE,box); } debug_gmx(); if (flags & GMX_FORCE_BONDED) { GMX_MPE_LOG(ev_calc_bonds_start); calc_bonds(fplog,cr->ms, idef,x,hist,f,fr,&pbc,graph,enerd,nrnb,lambda,md,fcd, DOMAINDECOMP(cr) ? cr->dd->gatindex : NULL, atype, born, fr->bSepDVDL && do_per_step(step,ir->nstlog),step); /* Check if we have to determine energy differences * at foreign lambda's. */ if (ir->n_flambda > 0 && (flags & GMX_FORCE_DHDL) && idef->ilsort != ilsortNO_FE) { if (idef->ilsort != ilsortFE_SORTED) { gmx_incons("The bonded interactions are not sorted for free energy"); } init_enerdata(mtop->groups.grps[egcENER].nr,ir->n_flambda,&ed_lam); for(i=0; i<enerd->n_lambda; i++) { lam_i = (i==0 ? lambda : ir->flambda[i-1]); dvdl_dum = 0; reset_enerdata(&ir->opts,fr,TRUE,&ed_lam,FALSE); calc_bonds_lambda(fplog, idef,x,fr,&pbc,graph,&ed_lam,nrnb,lam_i,md, fcd, DOMAINDECOMP(cr) ? cr->dd->gatindex : NULL); sum_epot(&ir->opts,&ed_lam); enerd->enerpart_lambda[i] += ed_lam.term[F_EPOT]; } destroy_enerdata(&ed_lam); } debug_gmx(); GMX_MPE_LOG(ev_calc_bonds_finish); } where(); *cycles_pme = 0; if (EEL_FULL(fr->eeltype)) { bSB = (ir->nwall == 2); if (bSB) { copy_mat(box,boxs); svmul(ir->wall_ewald_zfac,boxs[ZZ],boxs[ZZ]); box_size[ZZ] *= ir->wall_ewald_zfac; } clear_mat(fr->vir_el_recip); if (fr->bEwald) { if (fr->n_tpi == 0) { dvdlambda = 0; Vcorr = ewald_LRcorrection(fplog,md->start,md->start+md->homenr, cr,fr, md->chargeA, md->nChargePerturbed ? md->chargeB : NULL, excl,x,bSB ? boxs : box,mu_tot, ir->ewald_geometry, ir->epsilon_surface, lambda,&dvdlambda,&vdip,&vcharge); PRINT_SEPDVDL("Ewald excl./charge/dip. corr.",Vcorr,dvdlambda); enerd->dvdl_lin += dvdlambda; } else { if (ir->ewald_geometry != eewg3D || ir->epsilon_surface != 0) { gmx_fatal(FARGS,"TPI with PME currently only works in a 3D geometry with tin-foil boundary conditions"); } /* The TPI molecule does not have exclusions with the rest * of the system and no intra-molecular PME grid contributions * will be calculated in gmx_pme_calc_energy. */ Vcorr = 0; } } else { Vcorr = shift_LRcorrection(fplog,md->start,md->homenr,cr,fr, md->chargeA,excl,x,TRUE,box, fr->vir_el_recip); } dvdlambda = 0; status = 0; switch (fr->eeltype) { case eelPPPM: status = gmx_pppm_do(fplog,fr->pmedata,FALSE,x,fr->f_novirsum, md->chargeA, box_size,fr->phi,cr,md->start,md->homenr, nrnb,ir->pme_order,&Vlr); break; case eelPME: case eelPMESWITCH: case eelPMEUSER: case eelPMEUSERSWITCH: if (cr->duty & DUTY_PME) { if (fr->n_tpi == 0 || (flags & GMX_FORCE_STATECHANGED)) { pme_flags = GMX_PME_SPREAD_Q | GMX_PME_SOLVE; if (flags & GMX_FORCE_FORCES) { pme_flags |= GMX_PME_CALC_F; } if (flags & GMX_FORCE_VIRIAL) { pme_flags |= GMX_PME_CALC_ENER_VIR; } if (fr->n_tpi > 0) { /* We don't calculate f, but we do want the potential */ pme_flags |= GMX_PME_CALC_POT; } wallcycle_start(wcycle,ewcPMEMESH); status = gmx_pme_do(fr->pmedata, md->start,md->homenr - fr->n_tpi, x,fr->f_novirsum, md->chargeA,md->chargeB, bSB ? boxs : box,cr, DOMAINDECOMP(cr) ? dd_pme_maxshift_x(cr->dd) : 0, DOMAINDECOMP(cr) ? dd_pme_maxshift_y(cr->dd) : 0, nrnb,wcycle, fr->vir_el_recip,fr->ewaldcoeff, &Vlr,lambda,&dvdlambda, pme_flags); *cycles_pme = wallcycle_stop(wcycle,ewcPMEMESH); /* We should try to do as little computation after * this as possible, because parallel PME synchronizes * the nodes, so we want all load imbalance of the rest * of the force calculation to be before the PME call. * DD load balancing is done on the whole time of * the force call (without PME). */ } if (fr->n_tpi > 0) { /* Determine the PME grid energy of the test molecule * with the PME grid potential of the other charges. */ gmx_pme_calc_energy(fr->pmedata,fr->n_tpi, x + md->homenr - fr->n_tpi, md->chargeA + md->homenr - fr->n_tpi, &Vlr); } PRINT_SEPDVDL("PME mesh",Vlr,dvdlambda); } else { /* Energies and virial are obtained later from the PME nodes */ /* but values have to be zeroed out here */ Vlr=0.0; } break; case eelEWALD: Vlr = do_ewald(fplog,FALSE,ir,x,fr->f_novirsum, md->chargeA,md->chargeB, box_size,cr,md->homenr, fr->vir_el_recip,fr->ewaldcoeff, lambda,&dvdlambda,fr->ewald_table); PRINT_SEPDVDL("Ewald long-range",Vlr,dvdlambda); break; default: Vlr = 0; gmx_fatal(FARGS,"No such electrostatics method implemented %s", eel_names[fr->eeltype]); } if (status != 0) { gmx_fatal(FARGS,"Error %d in long range electrostatics routine %s", status,EELTYPE(fr->eeltype)); } enerd->dvdl_lin += dvdlambda; enerd->term[F_COUL_RECIP] = Vlr + Vcorr; if (debug) { fprintf(debug,"Vlr = %g, Vcorr = %g, Vlr_corr = %g\n", Vlr,Vcorr,enerd->term[F_COUL_RECIP]); pr_rvecs(debug,0,"vir_el_recip after corr",fr->vir_el_recip,DIM); pr_rvecs(debug,0,"fshift after LR Corrections",fr->fshift,SHIFTS); } } else { if (EEL_RF(fr->eeltype)) { dvdlambda = 0; if (fr->eeltype != eelRF_NEC) { enerd->term[F_RF_EXCL] = RF_excl_correction(fplog,fr,graph,md,excl,x,f, fr->fshift,&pbc,lambda,&dvdlambda); } enerd->dvdl_lin += dvdlambda; PRINT_SEPDVDL("RF exclusion correction", enerd->term[F_RF_EXCL],dvdlambda); } } where(); debug_gmx(); if (debug) { print_nrnb(debug,nrnb); } debug_gmx(); #ifdef GMX_MPI if (TAKETIME) { t2=MPI_Wtime(); MPI_Barrier(cr->mpi_comm_mygroup); t3=MPI_Wtime(); fr->t_wait += t3-t2; if (fr->timesteps == 11) { fprintf(stderr,"* PP load balancing info: node %d, step %s, rel wait time=%3.0f%% , load string value: %7.2f\n", cr->nodeid, gmx_step_str(fr->timesteps,buf), 100*fr->t_wait/(fr->t_wait+fr->t_fnbf), (fr->t_fnbf+fr->t_wait)/fr->t_fnbf); } fr->timesteps++; } #endif if (debug) { pr_rvecs(debug,0,"fshift after bondeds",fr->fshift,SHIFTS); } GMX_MPE_LOG(ev_force_finish); }