static void shell_pos_sd(FILE *log,rvec xcur[],rvec xnew[],rvec f[],
int ns,t_shell s[],int count)
{
int i,shell,d;
real dx,df,k_est;
#ifdef PRINT_STEP
real step_min,step_max;
step_min = 1e30;
step_max = 0;
#endif
for(i=0; (i<ns); i++) {
shell = s[i].shell;
if (count == 1) {
for(d=0; d<DIM; d++) {
s[i].step[d] = s[i].k_1;
#ifdef PRINT_STEP
step_min = min(step_min,s[i].step[d]);
step_max = max(step_max,s[i].step[d]);
#endif
}
} else {
for(d=0; d<DIM; d++) {
dx = xcur[shell][d] - s[i].xold[d];
df = f[shell][d] - s[i].fold[d];
if (dx != 0 && df != 0) {
k_est = -dx/df;
if (k_est >= 2*s[i].step[d]) {
s[i].step[d] *= 1.2;
} else if (k_est <= 0) {
s[i].step[d] *= 0.8;
} else {
s[i].step[d] = 0.8*s[i].step[d] + 0.2*k_est;
}
} else if (dx != 0) {
s[i].step[d] *= 1.2;
}
#ifdef PRINT_STEP
step_min = min(step_min,s[i].step[d]);
step_max = max(step_max,s[i].step[d]);
#endif
}
}
copy_rvec(xcur[shell],s[i].xold);
copy_rvec(f[shell], s[i].fold);
do_1pos3(xnew[shell],xcur[shell],f[shell],s[i].step);
if (gmx_debug_at) {
fprintf(debug,"shell[%d] = %d\n",i,shell);
pr_rvec(debug,0,"fshell",f[shell],DIM,TRUE);
pr_rvec(debug,0,"xold",xcur[shell],DIM,TRUE);
pr_rvec(debug,0,"step",s[i].step,DIM,TRUE);
pr_rvec(debug,0,"xnew",xnew[shell],DIM,TRUE);
}
}
#ifdef PRINT_STEP
printf("step %.3e %.3e\n",step_min,step_max);
#endif
}
static void pr_pullgrp(FILE *fp,int indent,int g,t_pullgrp *pg)
{
pr_indent(fp,indent);
fprintf(fp,"pull-group %d:\n",g);
indent += 2;
pr_ivec_block(fp,indent,"atom",pg->ind,pg->nat,TRUE);
pr_rvec(fp,indent,"weight",pg->weight,pg->nweight,TRUE);
PI("pbcatom",pg->pbcatom);
pr_rvec(fp,indent,"vec",pg->vec,DIM,TRUE);
pr_rvec(fp,indent,"init",pg->init,DIM,TRUE);
PR("rate",pg->rate);
PR("k",pg->k);
PR("kB",pg->kB);
}
static void calc_angles(FILE *log,t_pbc *pbc,
int n3,atom_id index[],real ang[],rvec x_s[])
{
int i,ix,t1,t2;
rvec r_ij,r_kj;
real costh;
for(i=ix=0; (ix<n3); i++,ix+=3)
ang[i]=bond_angle(x_s[index[ix]],x_s[index[ix+1]],x_s[index[ix+2]],
pbc,r_ij,r_kj,&costh,&t1,&t2);
if (debug) {
fprintf(debug,"Angle[0]=%g, costh=%g, index0 = %d, %d, %d\n",
ang[0],costh,index[0],index[1],index[2]);
pr_rvec(debug,0,"rij",r_ij,DIM,TRUE);
pr_rvec(debug,0,"rkj",r_kj,DIM,TRUE);
}
}
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 pr_qm_opts(FILE *fp,int indent,const char *title,t_grpopts *opts)
{
int i,m,j;
fprintf(fp,"%s:\n",title);
pr_int(fp,indent,"ngQM",opts->ngQM);
if (opts->ngQM > 0) {
pr_ivec(fp,indent,"QMmethod",opts->QMmethod,opts->ngQM,FALSE);
pr_ivec(fp,indent,"QMbasis",opts->QMbasis,opts->ngQM,FALSE);
pr_ivec(fp,indent,"QMcharge",opts->QMcharge,opts->ngQM,FALSE);
pr_ivec(fp,indent,"QMmult",opts->QMmult,opts->ngQM,FALSE);
pr_bvec(fp,indent,"bSH",opts->bSH,opts->ngQM,FALSE);
pr_ivec(fp,indent,"CASorbitals",opts->CASorbitals,opts->ngQM,FALSE);
pr_ivec(fp,indent,"CASelectrons",opts->CASelectrons,opts->ngQM,FALSE);
pr_rvec(fp,indent,"SAon",opts->SAon,opts->ngQM,FALSE);
pr_rvec(fp,indent,"SAon",opts->SAon,opts->ngQM,FALSE);
pr_ivec(fp,indent,"SAsteps",opts->SAsteps,opts->ngQM,FALSE);
pr_bvec(fp,indent,"bOPT",opts->bOPT,opts->ngQM,FALSE);
pr_bvec(fp,indent,"bTS",opts->bTS,opts->ngQM,FALSE);
}
}
static void shell_pos_sd(rvec xcur[], rvec xnew[], rvec f[],
int ns, t_shell s[], int count)
{
const real step_scale_min = 0.8,
step_scale_increment = 0.2,
step_scale_max = 1.2,
step_scale_multiple = (step_scale_max - step_scale_min) / step_scale_increment;
int i, shell, d;
real dx, df, k_est;
#ifdef PRINT_STEP
real step_min, step_max;
step_min = 1e30;
step_max = 0;
#endif
for (i = 0; (i < ns); i++)
{
shell = s[i].shell;
if (count == 1)
{
for (d = 0; d < DIM; d++)
{
s[i].step[d] = s[i].k_1;
#ifdef PRINT_STEP
step_min = min(step_min, s[i].step[d]);
step_max = max(step_max, s[i].step[d]);
#endif
}
}
else
{
for (d = 0; d < DIM; d++)
{
dx = xcur[shell][d] - s[i].xold[d];
df = f[shell][d] - s[i].fold[d];
/* -dx/df gets used to generate an interpolated value, but would
* cause a NaN if df were binary-equal to zero. Values close to
* zero won't cause problems (because of the min() and max()), so
* just testing for binary inequality is OK. */
if (0.0 != df)
{
k_est = -dx/df;
/* Scale the step size by a factor interpolated from
* step_scale_min to step_scale_max, as k_est goes from 0 to
* step_scale_multiple * s[i].step[d] */
s[i].step[d] =
step_scale_min * s[i].step[d] +
step_scale_increment * min(step_scale_multiple * s[i].step[d], max(k_est, 0));
}
else
{
/* Here 0 == df */
if (gmx_numzero(dx)) /* 0 == dx */
{
/* Likely this will never happen, but if it does just
* don't scale the step. */
}
else /* 0 != dx */
{
s[i].step[d] *= step_scale_max;
}
}
#ifdef PRINT_STEP
step_min = min(step_min, s[i].step[d]);
step_max = max(step_max, s[i].step[d]);
#endif
}
}
copy_rvec(xcur[shell], s[i].xold);
copy_rvec(f[shell], s[i].fold);
do_1pos3(xnew[shell], xcur[shell], f[shell], s[i].step);
if (gmx_debug_at)
{
fprintf(debug, "shell[%d] = %d\n", i, shell);
pr_rvec(debug, 0, "fshell", f[shell], DIM, TRUE);
pr_rvec(debug, 0, "xold", xcur[shell], DIM, TRUE);
pr_rvec(debug, 0, "step", s[i].step, DIM, TRUE);
pr_rvec(debug, 0, "xnew", xnew[shell], DIM, TRUE);
}
}
#ifdef PRINT_STEP
printf("step %.3e %.3e\n", step_min, step_max);
#endif
}
void pr_inputrec(FILE *fp,int indent,const char *title,t_inputrec *ir,
gmx_bool bMDPformat)
{
const char *infbuf="inf";
int i;
if (available(fp,ir,indent,title)) {
if (!bMDPformat)
indent=pr_title(fp,indent,title);
PS("integrator",EI(ir->eI));
PSTEP("nsteps",ir->nsteps);
PSTEP("init-step",ir->init_step);
PS("ns-type",ENS(ir->ns_type));
PI("nstlist",ir->nstlist);
PI("ndelta",ir->ndelta);
PI("nstcomm",ir->nstcomm);
PS("comm-mode",ECOM(ir->comm_mode));
PI("nstlog",ir->nstlog);
PI("nstxout",ir->nstxout);
PI("nstvout",ir->nstvout);
PI("nstfout",ir->nstfout);
PI("nstcalcenergy",ir->nstcalcenergy);
PI("nstenergy",ir->nstenergy);
PI("nstxtcout",ir->nstxtcout);
PR("init-t",ir->init_t);
PR("delta-t",ir->delta_t);
PR("xtcprec",ir->xtcprec);
PI("nkx",ir->nkx);
PI("nky",ir->nky);
PI("nkz",ir->nkz);
PI("pme-order",ir->pme_order);
PR("ewald-rtol",ir->ewald_rtol);
PR("ewald-geometry",ir->ewald_geometry);
PR("epsilon-surface",ir->epsilon_surface);
PS("optimize-fft",BOOL(ir->bOptFFT));
PS("ePBC",EPBC(ir->ePBC));
PS("bPeriodicMols",BOOL(ir->bPeriodicMols));
PS("bContinuation",BOOL(ir->bContinuation));
PS("bShakeSOR",BOOL(ir->bShakeSOR));
PS("etc",ETCOUPLTYPE(ir->etc));
PI("nsttcouple",ir->nsttcouple);
PS("epc",EPCOUPLTYPE(ir->epc));
PS("epctype",EPCOUPLTYPETYPE(ir->epct));
PI("nstpcouple",ir->nstpcouple);
PR("tau-p",ir->tau_p);
pr_matrix(fp,indent,"ref-p",ir->ref_p,bMDPformat);
pr_matrix(fp,indent,"compress",ir->compress,bMDPformat);
PS("refcoord-scaling",EREFSCALINGTYPE(ir->refcoord_scaling));
if (bMDPformat)
fprintf(fp,"posres-com = %g %g %g\n",ir->posres_com[XX],
ir->posres_com[YY],ir->posres_com[ZZ]);
else
pr_rvec(fp,indent,"posres-com",ir->posres_com,DIM,TRUE);
if (bMDPformat)
fprintf(fp,"posres-comB = %g %g %g\n",ir->posres_comB[XX],
ir->posres_comB[YY],ir->posres_comB[ZZ]);
else
pr_rvec(fp,indent,"posres-comB",ir->posres_comB,DIM,TRUE);
PI("andersen-seed",ir->andersen_seed);
PR("rlist",ir->rlist);
PR("rlistlong",ir->rlistlong);
PR("rtpi",ir->rtpi);
PS("coulombtype",EELTYPE(ir->coulombtype));
PR("rcoulomb-switch",ir->rcoulomb_switch);
PR("rcoulomb",ir->rcoulomb);
PS("vdwtype",EVDWTYPE(ir->vdwtype));
PR("rvdw-switch",ir->rvdw_switch);
PR("rvdw",ir->rvdw);
if (ir->epsilon_r != 0)
PR("epsilon-r",ir->epsilon_r);
else
PS("epsilon-r",infbuf);
if (ir->epsilon_rf != 0)
PR("epsilon-rf",ir->epsilon_rf);
else
PS("epsilon-rf",infbuf);
PR("tabext",ir->tabext);
PS("implicit-solvent",EIMPLICITSOL(ir->implicit_solvent));
PS("gb-algorithm",EGBALGORITHM(ir->gb_algorithm));
PR("gb-epsilon-solvent",ir->gb_epsilon_solvent);
PI("nstgbradii",ir->nstgbradii);
PR("rgbradii",ir->rgbradii);
PR("gb-saltconc",ir->gb_saltconc);
PR("gb-obc-alpha",ir->gb_obc_alpha);
PR("gb-obc-beta",ir->gb_obc_beta);
PR("gb-obc-gamma",ir->gb_obc_gamma);
PR("gb-dielectric-offset",ir->gb_dielectric_offset);
PS("sa-algorithm",ESAALGORITHM(ir->gb_algorithm));
PR("sa-surface-tension",ir->sa_surface_tension);
PS("DispCorr",EDISPCORR(ir->eDispCorr));
PS("free-energy",EFEPTYPE(ir->efep));
PR("init-lambda",ir->init_lambda);
PR("delta-lambda",ir->delta_lambda);
if (!bMDPformat)
{
PI("n-foreign-lambda",ir->n_flambda);
}
if (ir->n_flambda > 0)
{
pr_indent(fp,indent);
fprintf(fp,"foreign-lambda%s",bMDPformat ? " = " : ":");
for(i=0; i<ir->n_flambda; i++)
{
fprintf(fp," %10g",ir->flambda[i]);
}
fprintf(fp,"\n");
}
PR("sc-alpha",ir->sc_alpha);
PI("sc-power",ir->sc_power);
PR("sc-sigma",ir->sc_sigma);
PR("sc-sigma-min",ir->sc_sigma_min);
PI("nstdhdl", ir->nstdhdl);
PS("separate-dhdl-file", SEPDHDLFILETYPE(ir->separate_dhdl_file));
PS("dhdl-derivatives", DHDLDERIVATIVESTYPE(ir->dhdl_derivatives));
PI("dh-hist-size", ir->dh_hist_size);
PD("dh-hist-spacing", ir->dh_hist_spacing);
PI("nwall",ir->nwall);
PS("wall-type",EWALLTYPE(ir->wall_type));
PI("wall-atomtype[0]",ir->wall_atomtype[0]);
PI("wall-atomtype[1]",ir->wall_atomtype[1]);
PR("wall-density[0]",ir->wall_density[0]);
PR("wall-density[1]",ir->wall_density[1]);
PR("wall-ewald-zfac",ir->wall_ewald_zfac);
PS("pull",EPULLTYPE(ir->ePull));
if (ir->ePull != epullNO)
pr_pull(fp,indent,ir->pull);
PS("rotation",BOOL(ir->bRot));
if (ir->bRot)
pr_rot(fp,indent,ir->rot);
PS("disre",EDISRETYPE(ir->eDisre));
PS("disre-weighting",EDISREWEIGHTING(ir->eDisreWeighting));
PS("disre-mixed",BOOL(ir->bDisreMixed));
PR("dr-fc",ir->dr_fc);
PR("dr-tau",ir->dr_tau);
PR("nstdisreout",ir->nstdisreout);
PR("orires-fc",ir->orires_fc);
PR("orires-tau",ir->orires_tau);
PR("nstorireout",ir->nstorireout);
PR("dihre-fc",ir->dihre_fc);
PR("em-stepsize",ir->em_stepsize);
PR("em-tol",ir->em_tol);
PI("niter",ir->niter);
PR("fc-stepsize",ir->fc_stepsize);
PI("nstcgsteep",ir->nstcgsteep);
PI("nbfgscorr",ir->nbfgscorr);
PS("ConstAlg",ECONSTRTYPE(ir->eConstrAlg));
PR("shake-tol",ir->shake_tol);
PI("lincs-order",ir->nProjOrder);
PR("lincs-warnangle",ir->LincsWarnAngle);
PI("lincs-iter",ir->nLincsIter);
PR("bd-fric",ir->bd_fric);
PI("ld-seed",ir->ld_seed);
PR("cos-accel",ir->cos_accel);
pr_matrix(fp,indent,"deform",ir->deform,bMDPformat);
PS("adress",BOOL(ir->bAdress));
if (ir->bAdress){
PS("adress_type",EADRESSTYPE(ir->adress->type));
PR("adress_const_wf",ir->adress->const_wf);
PR("adress_ex_width",ir->adress->ex_width);
PR("adress_hy_width",ir->adress->hy_width);
PS("adress_interface_correction",EADRESSICTYPE(ir->adress->icor));
PS("adress_site",EADRESSSITETYPE(ir->adress->site));
PR("adress_ex_force_cap",ir->adress->ex_forcecap);
PS("adress_do_hybridpairs", BOOL(ir->adress->do_hybridpairs));
pr_rvec(fp,indent,"adress_reference_coords",ir->adress->refs,DIM,TRUE);
}
PI("userint1",ir->userint1);
PI("userint2",ir->userint2);
PI("userint3",ir->userint3);
PI("userint4",ir->userint4);
PR("userreal1",ir->userreal1);
PR("userreal2",ir->userreal2);
PR("userreal3",ir->userreal3);
PR("userreal4",ir->userreal4);
pr_grp_opts(fp,indent,"grpopts",&(ir->opts),bMDPformat);
pr_cosine(fp,indent,"efield-x",&(ir->ex[XX]),bMDPformat);
pr_cosine(fp,indent,"efield-xt",&(ir->et[XX]),bMDPformat);
pr_cosine(fp,indent,"efield-y",&(ir->ex[YY]),bMDPformat);
pr_cosine(fp,indent,"efield-yt",&(ir->et[YY]),bMDPformat);
pr_cosine(fp,indent,"efield-z",&(ir->ex[ZZ]),bMDPformat);
pr_cosine(fp,indent,"efield-zt",&(ir->et[ZZ]),bMDPformat);
PS("bQMMM",BOOL(ir->bQMMM));
PI("QMconstraints",ir->QMconstraints);
PI("QMMMscheme",ir->QMMMscheme);
PR("scalefactor",ir->scalefactor);
pr_qm_opts(fp,indent,"qm-opts",&(ir->opts));
}
}
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 init_pppm(FILE *log,t_commrec *cr,t_nsborder *nsb,
bool bVerbose,bool bOld,rvec box,char *ghatfn,t_inputrec *ir)
{
int nx,ny,nz,m,porder;
ivec grids;
real r1,rc;
const real tol = 1e-5;
rvec spacing;
#ifdef WITHOUT_FFTW
fatal_error(0,"PPPM used, but GROMACS was compiled without FFTW support!\n");
#endif
if (cr != NULL) {
if (cr->nnodes > 1)
fprintf(log,"Initializing parallel PPPM.\n");
}
fprintf(log,"Will use the PPPM algorithm for long-range electrostatics\n");
if (!fexist(ghatfn)) {
beta[XX]=beta[YY]=beta[ZZ]= 1.85;
nx = ir->nkx;
ny = ir->nky;
nz = ir->nkz;
fprintf(log,"Generating Ghat function\n");
fprintf(log,"Grid size is %d x %d x %d\n",nx,ny,nz);
if ((nx < 4) || (ny < 4) || (nz < 4))
fatal_error(0,"Grid must be at least 4 points in all directions");
ghat = mk_rgrid(nx,ny,nz);
mk_ghat(NULL,nx,ny,nz,ghat,box,ir->rcoulomb_switch,ir->rcoulomb,TRUE,bOld);
if (bVerbose)
pr_scalar_gk("generghat.xvg",nx,ny,nz,box,ghat);
}
else {
fprintf(stderr,"Reading Ghat function from %s\n",ghatfn);
ghat = rd_ghat(log,ghatfn,grids,spacing,beta,&porder,&r1,&rc);
/* Check whether cut-offs correspond */
if ((fabs(r1-ir->rcoulomb_switch)>tol) || (fabs(rc-ir->rcoulomb)>tol)) {
fprintf(log,"rcoulomb_switch = %10.3e rcoulomb = %10.3e"
" r1 = %10.3e rc = %10.3e\n",
ir->rcoulomb_switch,ir->rcoulomb,r1,rc);
fflush(log);
fatal_error(0,"Cut-off lengths in tpb file and Ghat file %s "
"do not match\nCheck your log file!",ghatfn);
}
/* Check whether boxes correspond */
for(m=0; (m<DIM); m++)
if (fabs(box[m]-grids[m]*spacing[m]) > tol) {
pr_rvec(log,0,"box",box,DIM);
pr_rvec(log,0,"grid-spacing",spacing,DIM);
pr_ivec(log,0,"grid size",grids,DIM);
fflush(log);
fatal_error(0,"Box sizes in tpb file and Ghat file %s do not match\n"
"Check your log file!",ghatfn);
}
if (porder != 2)
fatal_error(0,"porder = %d, should be 2 in %s",porder,ghatfn);
nx = grids[XX];
ny = grids[YY];
nz = grids[ZZ];
if (bVerbose)
pr_scalar_gk("optimghat.xvg",nx,ny,nz,box,ghat);
}
/* Now setup the FFT things */
grid = mk_fftgrid(log,PAR(cr),nx,ny,nz,ir->bOptFFT);
}
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);
}
int gmx_pppm_init(FILE *log, t_commrec *cr,
const output_env_t oenv, gmx_bool bVerbose,
gmx_bool bOld, matrix box,
char *ghatfn, t_inputrec *ir,
gmx_bool bReproducible)
{
int nx,ny,nz,m,porder;
ivec grids;
real r1,rc;
const real tol = 1e-5;
rvec box_diag,spacing;
#ifdef DISABLE_PPPM
gmx_fatal(FARGS,"PPPM is not functional in the current version, we plan to implement PPPM through a small modification of the PME code.");
return -1;
#else
#ifdef GMX_WITHOUT_FFTW
gmx_fatal(FARGS,"PPPM used, but GROMACS was compiled without FFTW support!\n");
#endif
if (log) {
if (cr != NULL) {
if (cr->nnodes > 1)
fprintf(log,"Initializing parallel PPPM.\n");
}
fprintf(log,
"Will use the PPPM algorithm for long-range electrostatics\n");
}
for(m=0; m<DIM; m++)
box_diag[m] = box[m][m];
if (!gmx_fexist(ghatfn)) {
beta[XX]=beta[YY]=beta[ZZ]= 1.85;
nx = ir->nkx;
ny = ir->nky;
nz = ir->nkz;
if (log) {
fprintf(log,"Generating Ghat function\n");
fprintf(log,"Grid size is %d x %d x %d\n",nx,ny,nz);
}
if ((nx < 4) || (ny < 4) || (nz < 4))
gmx_fatal(FARGS,"Grid must be at least 4 points in all directions");
ghat = mk_rgrid(nx,ny,nz);
mk_ghat(NULL,nx,ny,nz,ghat,box_diag,
ir->rcoulomb_switch,ir->rcoulomb,TRUE,bOld);
if (bVerbose)
pr_scalar_gk("generghat.xvg",oenv,nx,ny,nz,box_diag,ghat);
}
else {
fprintf(stderr,"Reading Ghat function from %s\n",ghatfn);
ghat = rd_ghat(log,oenv,ghatfn,grids,spacing,beta,&porder,&r1,&rc);
/* Check whether cut-offs correspond */
if ((fabs(r1-ir->rcoulomb_switch)>tol) || (fabs(rc-ir->rcoulomb)>tol)) {
if (log) {
fprintf(log,"rcoulomb_switch = %10.3e rcoulomb = %10.3e"
" r1 = %10.3e rc = %10.3e\n",
ir->rcoulomb_switch,ir->rcoulomb,r1,rc);
fflush(log);
}
gmx_fatal(FARGS,"Cut-off lengths in tpb file and Ghat file %s "
"do not match\nCheck your log file!",ghatfn);
}
/* Check whether boxes correspond */
for(m=0; (m<DIM); m++)
if (fabs(box_diag[m]-grids[m]*spacing[m]) > tol) {
if (log) {
pr_rvec(log,0,"box",box_diag,DIM,TRUE);
pr_rvec(log,0,"grid-spacing",spacing,DIM,TRUE);
pr_ivec(log,0,"grid size",grids,DIM,TRUE);
fflush(log);
}
gmx_fatal(FARGS,"Box sizes in tpb file and Ghat file %s do not match\n"
"Check your log file!",ghatfn);
}
if (porder != 2)
gmx_fatal(FARGS,"porder = %d, should be 2 in %s",porder,ghatfn);
nx = grids[XX];
ny = grids[YY];
nz = grids[ZZ];
if (bVerbose)
pr_scalar_gk("optimghat.xvg",oenv,nx,ny,nz,box_diag,ghat);
}
/* Now setup the FFT things */
#ifdef GMX_MPI
cr->mpi_comm_mygroup=cr->mpi_comm_mysim;
#endif
grid = mk_fftgrid(nx,ny,nz,NULL,NULL,cr,bReproducible);
return 0;
#endif
}
gmx_bool print_ga(FILE *fp, t_genalg *ga, real msf, tensor pres, rvec scale,
real energy, t_range range[], real tol)
{
static int nfeval = 0; /* number of function evaluations */
static gmx_bool bImproved;
real trial_cost;
real cvar; /* computes the cost variance */
real cmean; /* mean cost */
int i, j;
real **pswap;
trial_cost = cost(pres, msf, energy);
if (nfeval < ga->NP)
{
ga->cost[nfeval] = trial_cost;
ga->msf[nfeval] = msf;
ga->energy[nfeval] = energy;
copy_mat(pres, ga->pres[nfeval]);
copy_rvec(scale, ga->scale[nfeval]);
if (debug)
{
pr_rvec(debug, 0, "scale", scale, DIM, TRUE);
pr_rvec(debug, 0, "pold ", ga->pold[nfeval]+4, DIM, TRUE);
}
nfeval++;
return FALSE;
}
/* When we get here we have done an initial evaluation for all
* animals in the population
*/
if (ga->ipop == 0)
{
bImproved = FALSE;
}
/* First iteration after first round of trials */
if (nfeval == ga->NP)
{
/* Evaluate who is ga->best */
ga->imin = 0;
for (j = 1; (j < ga->NP); j++)
{
if (ga->cost[j] < ga->cost[ga->imin])
{
ga->imin = j;
}
}
assignd(ga->D, ga->best, ga->pold[ga->imin]);
/* save best member ever */
assignd(ga->D, ga->bestit, ga->pold[ga->imin]);
/* save best member of generation */
}
if (trial_cost < ga->cost[ga->ipop])
{
if (trial_cost < ga->cost[ga->imin])
{
/* Was this a new minimum? */
/* if so, reset cmin to new low...*/
ga->imin = ga->ipop;
assignd(ga->D, ga->best, ga->tmp);
bImproved = TRUE;
}
/* improved objective function value ? */
ga->cost[ga->ipop] = trial_cost;
ga->msf[ga->ipop] = msf;
ga->energy[ga->ipop] = energy;
copy_mat(pres, ga->pres[ga->ipop]);
copy_rvec(scale, ga->scale[ga->ipop]);
assignd(ga->D, ga->pnew[ga->ipop], ga->tmp);
}
else
{
/* replace target with old value */
assignd(ga->D, ga->pnew[ga->ipop], ga->pold[ga->ipop]);
}
/* #define SCALE_DEBUG*/
#ifdef SCALE_DEBUG
if (ga->D > 5)
{
rvec dscale;
rvec_sub(ga->scale[ga->imin], &(ga->best[ga->D-3]), dscale);
if (norm(dscale) > 0)
{
pr_rvec(fp, 0, "scale", scale, DIM, TRUE);
pr_rvec(fp, 0, "best ", &(ga->best[ga->D-3]), DIM, TRUE);
fprintf(fp, "imin = %d, ipop = %d, nfeval = %d\n", ga->imin,
ga->ipop, nfeval);
gmx_fatal(FARGS, "Scale inconsistency");
}
}
#endif
/* Increase population member count */
ga->ipop++;
/* End mutation loop through population? */
if (ga->ipop == ga->NP)
{
/* Save ga->best population member of current iteration */
assignd(ga->D, ga->bestit, ga->best);
/* swap population arrays. New generation becomes old one */
pswap = ga->pold;
ga->pold = ga->pnew;
ga->pnew = pswap;
/*----Compute the energy variance (just for monitoring purposes)-----------*/
/* compute the mean value first */
cmean = 0.0;
for (j = 0; (j < ga->NP); j++)
{
cmean += ga->cost[j];
}
cmean = cmean/ga->NP;
/* now the variance */
cvar = 0.0;
for (j = 0; (j < ga->NP); j++)
{
cvar += sqr(ga->cost[j] - cmean);
}
cvar = cvar/(ga->NP-1);
/*----Output part----------------------------------------------------------*/
if (1 || bImproved || (nfeval == ga->NP))
{
fprintf(fp, "\nGen: %5d\n Cost: %12.3e <Cost>: %12.3e\n"
" Ener: %8.4f RMSF: %8.3f Pres: %8.1f %8.1f %8.1f (%8.1f)\n"
" Box-Scale: %15.10f %15.10f %15.10f\n",
ga->gen, ga->cost[ga->imin], cmean, ga->energy[ga->imin],
sqrt(ga->msf[ga->imin]), ga->pres[ga->imin][XX][XX],
ga->pres[ga->imin][YY][YY], ga->pres[ga->imin][ZZ][ZZ],
trace(ga->pres[ga->imin])/3.0,
ga->scale[ga->imin][XX], ga->scale[ga->imin][YY],
ga->scale[ga->imin][ZZ]);
for (j = 0; (j < ga->D); j++)
{
fprintf(fp, "\tbest[%d]=%-15.10f\n", j, ga->best[j]);
}
if (ga->cost[ga->imin] < tol)
{
for (i = 0; (i < ga->NP); i++)
{
fprintf(fp, "Animal: %3d Cost:%8.3f Ener: %8.3f RMSF: %8.3f%s\n",
i, ga->cost[i], ga->energy[i], sqrt(ga->msf[i]),
(i == ga->imin) ? " ***" : "");
for (j = 0; (j < ga->D); j++)
{
fprintf(fp, "\tParam[%d][%d]=%15.10g\n", i, j, ga->pold[i][j]);
}
}
return TRUE;
}
fflush(fp);
}
}
nfeval++;
return FALSE;
}
static void mol_quad(int k0,int k1,rvec x[],t_atom atom[],rvec quad)
{
int i,k,m,n,niter;
real q,r2,mass,masstot;
rvec com; /* center of mass */
rvec r; /* distance of atoms to center of mass */
real rcom_m,rcom_n;
double **inten;
double dd[DIM],**ev,tmp;
snew(inten,DIM);
snew(ev,DIM);
for(i=0; (i<DIM); i++) {
snew(inten[i],DIM);
snew(ev[i],DIM);
dd[i]=0.0;
}
/* Compute center of mass */
clear_rvec(com);
masstot = 0.0;
for(k=k0; (k<k1); k++) {
mass = atom[k].m;
masstot += mass;
for(i=0; (i<DIM); i++)
com[i] += mass*x[k][i];
}
svmul((1.0/masstot),com,com);
/* We want traceless quadrupole moments, so let us calculate the complete
* quadrupole moment tensor and diagonalize this tensor to get
* the individual components on the diagonal.
*/
#define delta(a,b) (( a == b ) ? 1.0 : 0.0)
for(m=0; (m<DIM); m++)
for(n=0; (n<DIM); n++)
inten[m][n] = 0;
for(k=k0; (k<k1); k++) { /* loop over atoms in a molecule */
q = (atom[k].q)*100.0;
rvec_sub(x[k],com,r);
r2 = iprod(r,r);
for(m=0; (m<DIM); m++)
for(n=0; (n<DIM); n++)
inten[m][n] += 0.5*q*(3.0*r[m]*r[n] - r2*delta(m,n))*EANG2CM*CM2D;
}
if (debug)
for(i=0; (i<DIM); i++)
fprintf(debug,"Q[%d] = %8.3f %8.3f %8.3f\n",
i,inten[i][XX],inten[i][YY],inten[i][ZZ]);
/* We've got the quadrupole tensor, now diagonalize the sucker */
jacobi(inten,3,dd,ev,&niter);
if (debug) {
for(i=0; (i<DIM); i++)
fprintf(debug,"ev[%d] = %8.3f %8.3f %8.3f\n",
i,ev[i][XX],ev[i][YY],ev[i][ZZ]);
for(i=0; (i<DIM); i++)
fprintf(debug,"Q'[%d] = %8.3f %8.3f %8.3f\n",
i,inten[i][XX],inten[i][YY],inten[i][ZZ]);
}
/* Sort the eigenvalues, for water we know that the order is as follows:
*
* Q_yy, Q_zz, Q_xx
*
* At the moment I have no idea how this will work out for other molecules...
*/
#define SWAP(i) \
if (dd[i+1] > dd[i]) { \
tmp=dd[i]; \
dd[i]=dd[i+1]; \
dd[i+1]=tmp; \
}
SWAP(0);
SWAP(1);
SWAP(0);
for(m=0; (m<DIM); m++) {
quad[0]=dd[2]; /* yy */
quad[1]=dd[0]; /* zz */
quad[2]=dd[1]; /* xx */
}
if (debug)
pr_rvec(debug,0,"Quadrupole",quad,DIM,TRUE);
/* clean-up */
for(i=0; (i<DIM); i++) {
sfree(inten[i]);
sfree(ev[i]);
}
sfree(inten);
sfree(ev);
}
void pr_inputrec(FILE *fp,int indent,const char *title,t_inputrec *ir,
bool bMDPformat)
{
char *infbuf="inf";
if (available(fp,ir,indent,title)) {
if (!bMDPformat)
indent=pr_title(fp,indent,title);
PS("integrator",EI(ir->eI));
PI("nsteps",ir->nsteps);
PI("init_step",ir->init_step);
PS("ns_type",ENS(ir->ns_type));
PI("nstlist",ir->nstlist);
PI("ndelta",ir->ndelta);
PI("nstcomm",ir->nstcomm);
PS("comm_mode",ECOM(ir->comm_mode));
PI("nstlog",ir->nstlog);
PI("nstxout",ir->nstxout);
PI("nstvout",ir->nstvout);
PI("nstfout",ir->nstfout);
PI("nstenergy",ir->nstenergy);
PI("nstxtcout",ir->nstxtcout);
PR("init_t",ir->init_t);
PR("delta_t",ir->delta_t);
PR("xtcprec",ir->xtcprec);
PI("nkx",ir->nkx);
PI("nky",ir->nky);
PI("nkz",ir->nkz);
PI("pme_order",ir->pme_order);
PR("ewald_rtol",ir->ewald_rtol);
PR("ewald_geometry",ir->ewald_geometry);
PR("epsilon_surface",ir->epsilon_surface);
PS("optimize_fft",BOOL(ir->bOptFFT));
PS("ePBC",EPBC(ir->ePBC));
PS("bPeriodicMols",BOOL(ir->bPeriodicMols));
PS("bContinuation",BOOL(ir->bContinuation));
PS("bShakeSOR",BOOL(ir->bShakeSOR));
PS("etc",ETCOUPLTYPE(ir->etc));
PS("epc",EPCOUPLTYPE(ir->epc));
PS("epctype",EPCOUPLTYPETYPE(ir->epct));
PR("tau_p",ir->tau_p);
pr_matrix(fp,indent,"ref_p",ir->ref_p,bMDPformat);
pr_matrix(fp,indent,"compress",ir->compress,bMDPformat);
PS("refcoord_scaling",EREFSCALINGTYPE(ir->refcoord_scaling));
if (bMDPformat)
fprintf(fp,"posres_com = %g %g %g\n",ir->posres_com[XX],
ir->posres_com[YY],ir->posres_com[ZZ]);
else
pr_rvec(fp,indent,"posres_com",ir->posres_com,DIM,TRUE);
if (bMDPformat)
fprintf(fp,"posres_comB = %g %g %g\n",ir->posres_comB[XX],
ir->posres_comB[YY],ir->posres_comB[ZZ]);
else
pr_rvec(fp,indent,"posres_comB",ir->posres_comB,DIM,TRUE);
PI("andersen_seed",ir->andersen_seed);
PR("rlist",ir->rlist);
PR("rtpi",ir->rtpi);
PS("coulombtype",EELTYPE(ir->coulombtype));
PR("rcoulomb_switch",ir->rcoulomb_switch);
PR("rcoulomb",ir->rcoulomb);
PS("vdwtype",EVDWTYPE(ir->vdwtype));
PR("rvdw_switch",ir->rvdw_switch);
PR("rvdw",ir->rvdw);
if (ir->epsilon_r != 0)
PR("epsilon_r",ir->epsilon_r);
else
PS("epsilon_r",infbuf);
if (ir->epsilon_rf != 0)
PR("epsilon_rf",ir->epsilon_rf);
else
PS("epsilon_rf",infbuf);
PR("tabext",ir->tabext);
PS("implicit_solvent",EIMPLICITSOL(ir->implicit_solvent));
PS("gb_algorithm",EGBALGORITHM(ir->gb_algorithm));
PR("gb_epsilon_solvent",ir->gb_epsilon_solvent);
PI("nstgbradii",ir->nstgbradii);
PR("rgbradii",ir->rgbradii);
PR("gb_saltconc",ir->gb_saltconc);
PR("gb_obc_alpha",ir->gb_obc_alpha);
PR("gb_obc_beta",ir->gb_obc_beta);
PR("gb_obc_gamma",ir->gb_obc_gamma);
PR("sa_surface_tension",ir->sa_surface_tension);
PS("DispCorr",EDISPCORR(ir->eDispCorr));
PS("free_energy",EFEPTYPE(ir->efep));
PR("init_lambda",ir->init_lambda);
PR("sc_alpha",ir->sc_alpha);
PI("sc_power",ir->sc_power);
PR("sc_sigma",ir->sc_sigma);
PR("delta_lambda",ir->delta_lambda);
PI("nwall",ir->nwall);
PS("wall_type",EWALLTYPE(ir->wall_type));
PI("wall_atomtype[0]",ir->wall_atomtype[0]);
PI("wall_atomtype[1]",ir->wall_atomtype[1]);
PR("wall_density[0]",ir->wall_density[0]);
PR("wall_density[1]",ir->wall_density[1]);
PR("wall_ewald_zfac",ir->wall_ewald_zfac);
PS("pull",EPULLTYPE(ir->ePull));
if (ir->ePull != epullNO)
pr_pull(fp,indent,ir->pull);
PS("disre",EDISRETYPE(ir->eDisre));
PS("disre_weighting",EDISREWEIGHTING(ir->eDisreWeighting));
PS("disre_mixed",BOOL(ir->bDisreMixed));
PR("dr_fc",ir->dr_fc);
PR("dr_tau",ir->dr_tau);
PR("nstdisreout",ir->nstdisreout);
PR("orires_fc",ir->orires_fc);
PR("orires_tau",ir->orires_tau);
PR("nstorireout",ir->nstorireout);
PR("dihre-fc",ir->dihre_fc);
PR("em_stepsize",ir->em_stepsize);
PR("em_tol",ir->em_tol);
PI("niter",ir->niter);
PR("fc_stepsize",ir->fc_stepsize);
PI("nstcgsteep",ir->nstcgsteep);
PI("nbfgscorr",ir->nbfgscorr);
PS("ConstAlg",ECONSTRTYPE(ir->eConstrAlg));
PR("shake_tol",ir->shake_tol);
PI("lincs_order",ir->nProjOrder);
PR("lincs_warnangle",ir->LincsWarnAngle);
PI("lincs_iter",ir->nLincsIter);
PR("bd_fric",ir->bd_fric);
PI("ld_seed",ir->ld_seed);
PR("cos_accel",ir->cos_accel);
pr_matrix(fp,indent,"deform",ir->deform,bMDPformat);
PI("userint1",ir->userint1);
PI("userint2",ir->userint2);
PI("userint3",ir->userint3);
PI("userint4",ir->userint4);
PR("userreal1",ir->userreal1);
PR("userreal2",ir->userreal2);
PR("userreal3",ir->userreal3);
PR("userreal4",ir->userreal4);
pr_grp_opts(fp,indent,"grpopts",&(ir->opts),bMDPformat);
pr_cosine(fp,indent,"efield-x",&(ir->ex[XX]),bMDPformat);
pr_cosine(fp,indent,"efield-xt",&(ir->et[XX]),bMDPformat);
pr_cosine(fp,indent,"efield-y",&(ir->ex[YY]),bMDPformat);
pr_cosine(fp,indent,"efield-yt",&(ir->et[YY]),bMDPformat);
pr_cosine(fp,indent,"efield-z",&(ir->ex[ZZ]),bMDPformat);
pr_cosine(fp,indent,"efield-zt",&(ir->et[ZZ]),bMDPformat);
PS("bQMMM",BOOL(ir->bQMMM));
PI("QMconstraints",ir->QMconstraints);
PI("QMMMscheme",ir->QMMMscheme);
PR("scalefactor",ir->scalefactor);
pr_qm_opts(fp,indent,"qm_opts",&(ir->opts));
}
}
