int count_constraints(t_topology *top,t_commrec *cr)
{
int nc;
nc = top->idef.il[F_SETTLE].nr*3/2 + top->idef.il[F_SHAKE].nr/3;
if (PAR(cr))
gmx_sumi(1,&nc,cr);
return nc;
}
static void global_max(t_commrec *cr,int *n)
{
int *sum,i;
snew(sum,cr->nnodes);
sum[cr->nodeid] = *n;
gmx_sumi(cr->nnodes,sum,cr);
for(i=0; i<cr->nnodes; i++)
*n = max(*n,sum[i]);
sfree(sum);
}
void update_QMMMrec(t_commrec *cr,
t_forcerec *fr,
rvec x[],
t_mdatoms *md,
matrix box,
gmx_localtop_t *top)
{
/* updates the coordinates of both QM atoms and MM atoms and stores
* them in the QMMMrec.
*
* NOTE: is NOT yet working if there are no PBC. Also in ns.c, simple
* ns needs to be fixed!
*/
int
mm_max=0,mm_nr=0,mm_nr_new,i,j,is,k,shift;
t_j_particle
*mm_j_particles=NULL,*qm_i_particles=NULL;
t_QMMMrec
*qr;
t_nblist
QMMMlist;
rvec
dx,crd;
int
*MMatoms;
t_QMrec
*qm;
t_MMrec
*mm;
t_pbc
pbc;
int
*parallelMMarray=NULL;
real
c12au,c6au;
c6au = (HARTREE2KJ*AVOGADRO*pow(BOHR2NM,6));
c12au = (HARTREE2KJ*AVOGADRO*pow(BOHR2NM,12));
/* every cpu has this array. On every processor we fill this array
* with 1's and 0's. 1's indicate the atoms is a QM atom on the
* current cpu in a later stage these arrays are all summed. indexes
* > 0 indicate the atom is a QM atom. Every node therefore knows
* whcih atoms are part of the QM subsystem.
*/
/* copy some pointers */
qr = fr->qr;
mm = qr->mm;
QMMMlist = fr->QMMMlist;
/* init_pbc(box); needs to be called first, see pbc.h */
set_pbc_dd(&pbc,fr->ePBC,DOMAINDECOMP(cr) ? cr->dd : NULL,FALSE,box);
/* only in standard (normal) QMMM we need the neighbouring MM
* particles to provide a electric field of point charges for the QM
* atoms.
*/
if(qr->QMMMscheme==eQMMMschemenormal){ /* also implies 1 QM-layer */
/* we NOW create/update a number of QMMMrec entries:
*
* 1) the shiftQM, containing the shifts of the QM atoms
*
* 2) the indexMM array, containing the index of the MM atoms
*
* 3) the shiftMM, containing the shifts of the MM atoms
*
* 4) the shifted coordinates of the MM atoms
*
* the shifts are used for computing virial of the QM/MM particles.
*/
qm = qr->qm[0]; /* in case of normal QMMM, there is only one group */
snew(qm_i_particles,QMMMlist.nri);
if(QMMMlist.nri){
qm_i_particles[0].shift = XYZ2IS(0,0,0);
for(i=0;i<QMMMlist.nri;i++){
qm_i_particles[i].j = QMMMlist.iinr[i];
if(i){
qm_i_particles[i].shift = pbc_dx_aiuc(&pbc,x[QMMMlist.iinr[0]],
x[QMMMlist.iinr[i]],dx);
}
/* However, since nri >= nrQMatoms, we do a quicksort, and throw
* out double, triple, etc. entries later, as we do for the MM
* list too.
*/
/* compute the shift for the MM j-particles with respect to
* the QM i-particle and store them.
*/
crd[0] = IS2X(QMMMlist.shift[i]) + IS2X(qm_i_particles[i].shift);
crd[1] = IS2Y(QMMMlist.shift[i]) + IS2Y(qm_i_particles[i].shift);
crd[2] = IS2Z(QMMMlist.shift[i]) + IS2Z(qm_i_particles[i].shift);
is = XYZ2IS(crd[0],crd[1],crd[2]);
for(j=QMMMlist.jindex[i];
j<QMMMlist.jindex[i+1];
j++){
if(mm_nr >= mm_max){
mm_max += 1000;
srenew(mm_j_particles,mm_max);
}
mm_j_particles[mm_nr].j = QMMMlist.jjnr[j];
mm_j_particles[mm_nr].shift = is;
mm_nr++;
}
}
/* quicksort QM and MM shift arrays and throw away multiple entries */
qsort(qm_i_particles,QMMMlist.nri,
(size_t)sizeof(qm_i_particles[0]),
struct_comp);
qsort(mm_j_particles,mm_nr,
(size_t)sizeof(mm_j_particles[0]),
struct_comp);
/* remove multiples in the QM shift array, since in init_QMMM() we
* went through the atom numbers from 0 to md.nr, the order sorted
* here matches the one of QMindex already.
*/
j=0;
for(i=0;i<QMMMlist.nri;i++){
if (i==0 || qm_i_particles[i].j!=qm_i_particles[i-1].j){
qm_i_particles[j++] = qm_i_particles[i];
}
}
mm_nr_new = 0;
if(qm->bTS||qm->bOPT){
/* only remove double entries for the MM array */
for(i=0;i<mm_nr;i++){
if((i==0 || mm_j_particles[i].j!=mm_j_particles[i-1].j)
&& !md->bQM[mm_j_particles[i].j]){
mm_j_particles[mm_nr_new++] = mm_j_particles[i];
}
}
}
/* we also remove mm atoms that have no charges!
* actually this is already done in the ns.c
*/
else{
for(i=0;i<mm_nr;i++){
if((i==0 || mm_j_particles[i].j!=mm_j_particles[i-1].j)
&& !md->bQM[mm_j_particles[i].j]
&& (md->chargeA[mm_j_particles[i].j]
|| (md->chargeB && md->chargeB[mm_j_particles[i].j]))) {
mm_j_particles[mm_nr_new++] = mm_j_particles[i];
}
}
}
mm_nr = mm_nr_new;
/* store the data retrieved above into the QMMMrec
*/
k=0;
/* Keep the compiler happy,
* shift will always be set in the loop for i=0
*/
shift = 0;
for(i=0;i<qm->nrQMatoms;i++){
/* not all qm particles might have appeared as i
* particles. They might have been part of the same charge
* group for instance.
*/
if (qm->indexQM[i] == qm_i_particles[k].j) {
shift = qm_i_particles[k++].shift;
}
/* use previous shift, assuming they belong the same charge
* group anyway,
*/
qm->shiftQM[i] = shift;
}
}
/* parallel excecution */
if(PAR(cr)){
snew(parallelMMarray,2*(md->nr));
/* only MM particles have a 1 at their atomnumber. The second part
* of the array contains the shifts. Thus:
* p[i]=1/0 depending on wether atomnumber i is a MM particle in the QM
* step or not. p[i+md->nr] is the shift of atomnumber i.
*/
for(i=0;i<2*(md->nr);i++){
parallelMMarray[i]=0;
}
for(i=0;i<mm_nr;i++){
parallelMMarray[mm_j_particles[i].j]=1;
parallelMMarray[mm_j_particles[i].j+(md->nr)]=mm_j_particles[i].shift;
}
gmx_sumi(md->nr,parallelMMarray,cr);
mm_nr=0;
mm_max = 0;
for(i=0;i<md->nr;i++){
if(parallelMMarray[i]){
if(mm_nr >= mm_max){
mm_max += 1000;
srenew(mm->indexMM,mm_max);
srenew(mm->shiftMM,mm_max);
}
mm->indexMM[mm_nr] = i;
mm->shiftMM[mm_nr++]= parallelMMarray[i+md->nr]/parallelMMarray[i];
}
}
mm->nrMMatoms=mm_nr;
free(parallelMMarray);
}
/* serial execution */
else{
mm->nrMMatoms = mm_nr;
srenew(mm->shiftMM,mm_nr);
srenew(mm->indexMM,mm_nr);
for(i=0;i<mm_nr;i++){
mm->indexMM[i]=mm_j_particles[i].j;
mm->shiftMM[i]=mm_j_particles[i].shift;
}
}
/* (re) allocate memory for the MM coordiate array. The QM
* coordinate array was already allocated in init_QMMM, and is
* only (re)filled in the update_QMMM_coordinates routine
*/
srenew(mm->xMM,mm->nrMMatoms);
/* now we (re) fill the array that contains the MM charges with
* the forcefield charges. If requested, these charges will be
* scaled by a factor
*/
srenew(mm->MMcharges,mm->nrMMatoms);
for(i=0;i<mm->nrMMatoms;i++){/* no free energy yet */
mm->MMcharges[i]=md->chargeA[mm->indexMM[i]]*mm->scalefactor;
}
if(qm->bTS||qm->bOPT){
/* store (copy) the c6 and c12 parameters into the MMrec struct
*/
srenew(mm->c6,mm->nrMMatoms);
srenew(mm->c12,mm->nrMMatoms);
for (i=0;i<mm->nrMMatoms;i++){
mm->c6[i] = C6(fr->nbfp,top->idef.atnr,
md->typeA[mm->indexMM[i]],
md->typeA[mm->indexMM[i]])/c6au;
mm->c12[i] =C12(fr->nbfp,top->idef.atnr,
md->typeA[mm->indexMM[i]],
md->typeA[mm->indexMM[i]])/c12au;
}
punch_QMMM_excl(qr->qm[0],mm,&(top->excls));
}
/* the next routine fills the coordinate fields in the QMMM rec of
* both the qunatum atoms and the MM atoms, using the shifts
* calculated above.
*/
update_QMMM_coord(x,fr,qr->qm[0],qr->mm);
free(qm_i_particles);
free(mm_j_particles);
}
else { /* ONIOM */ /* ????? */
mm->nrMMatoms=0;
/* do for each layer */
for (j=0;j<qr->nrQMlayers;j++){
qm = qr->qm[j];
qm->shiftQM[0]=XYZ2IS(0,0,0);
for(i=1;i<qm->nrQMatoms;i++){
qm->shiftQM[i] = pbc_dx_aiuc(&pbc,x[qm->indexQM[0]],x[qm->indexQM[i]],
dx);
}
update_QMMM_coord(x,fr,qm,mm);
}
}
} /* update_QMMM_rec */
t_mdebin *init_mdebin(int fp_ene,t_groups *grps,t_atoms *atoms,t_idef *idef,
bool bLR,bool bLJLR,bool bBHAM,bool b14,bool bFEP,
bool bPcoupl,bool bDispCorr,bool bTriclinic, bool bNoseHoover,t_commrec *cr)
{
char *ener_nm[F_NRE];
static char *vir_nm[] = {
"Vir-XX", "Vir-XY", "Vir-XZ",
"Vir-YX", "Vir-YY", "Vir-YZ",
"Vir-ZX", "Vir-ZY", "Vir-ZZ"
};
static char *sv_nm[] = {
"ShakeVir-XX", "ShakeVir-XY", "ShakeVir-XZ",
"ShakeVir-YX", "ShakeVir-YY", "ShakeVir-YZ",
"ShakeVir-ZX", "ShakeVir-ZY", "ShakeVir-ZZ"
};
static char *fv_nm[] = {
"ForceVir-XX", "ForceVir-XY", "ForceVir-XZ",
"ForceVir-YX", "ForceVir-YY", "ForceVir-YZ",
"ForceVir-ZX", "ForceVir-ZY", "ForceVir-ZZ"
};
static char *pres_nm[] = {
"Pres-XX (bar)","Pres-XY (bar)","Pres-XZ (bar)",
"Pres-YX (bar)","Pres-YY (bar)","Pres-YZ (bar)",
"Pres-ZX (bar)","Pres-ZY (bar)","Pres-ZZ (bar)"
};
static char *surft_nm[] = {
"#Surf*SurfTen"
};
static char *mu_nm[] = {
"Mu-X", "Mu-Y", "Mu-Z"
};
static char *vcos_nm[] = {
"2CosZ*Vel-X"
};
static char *visc_nm[] = {
"1/Viscosity (SI)"
};
static char **grpnms;
char **gnm;
char buf[256];
t_mdebin *md;
int i,j,ni,nj,n,k,kk;
for(i=0; i<F_NRE; i++) {
bEner[i] = FALSE;
if (i == F_LJ)
bEner[i] = !bBHAM;
else if (i == F_BHAM)
bEner[i] = bBHAM;
else if (i == F_LR)
bEner[i] = bLR;
else if (i == F_LJLR)
bEner[i] = bLJLR;
else if (i == F_LJ14)
bEner[i] = b14;
else if (i == F_COUL14)
bEner[i] = b14;
else if ((i == F_DVDL) || (i == F_DVDLKIN))
bEner[i] = bFEP;
else if ((strstr(interaction_function[i].name,"DUM") != NULL) ||
(i == F_SHAKE) || (i == F_SETTLE))
bEner[i] = FALSE;
else if ((i == F_SR) || (i == F_EPOT) || (i == F_ETOT) || (i == F_EKIN) ||
(i == F_TEMP) || (i == F_PRES))
bEner[i] = TRUE;
else if ((i == F_DISPCORR) && bDispCorr)
bEner[i] = TRUE;
else if (i == F_DISRESVIOL)
bEner[i] = (idef->il[F_DISRES].nr > 0);
else if (i == F_ORIRESDEV)
bEner[i] = (idef->il[F_ORIRES].nr > 0);
else if (i == F_CONNBONDS)
bEner[i] = FALSE;
else
bEner[i] = (idef->il[i].nr > 0);
}
if (PAR(cr))
gmx_sumi(F_NRE,bEner,cr);
for(i=0; i<F_NRE; i++)
if (bEner[i]) {
ener_nm[f_nre]=interaction_function[i].longname;
f_nre++;
}
bShake = (idef->il[F_SHAKE].nr > 0) || (idef->il[F_SETTLE].nr > 0);
if (bShake)
#ifdef SPEC_CPU
bShake = FALSE;
#else
bShake = (getenv("SHAKEVIR") != NULL);
#endif
bPC = bPcoupl;
bTricl = bTriclinic;
/* Energy monitoring */
snew(md,1);
md->ebin = mk_ebin();
md->ie = get_ebin_space(md->ebin,f_nre,ener_nm);
if (bPC)
md->ib = get_ebin_space(md->ebin, bTricl ? NTRICLBOXS :
NBOXS, bTricl ? tricl_boxs_nm : boxs_nm);
if (bShake) {
md->isvir = get_ebin_space(md->ebin,asize(sv_nm),sv_nm);
md->ifvir = get_ebin_space(md->ebin,asize(fv_nm),fv_nm);
}
md->ivir = get_ebin_space(md->ebin,asize(vir_nm),vir_nm);
md->ipres = get_ebin_space(md->ebin,asize(pres_nm),pres_nm);
md->isurft = get_ebin_space(md->ebin,asize(surft_nm),surft_nm);
md->imu = get_ebin_space(md->ebin,asize(mu_nm),mu_nm);
if (fabs(grps->cosacc.cos_accel)>GMX_REAL_MIN) {
md->ivcos = get_ebin_space(md->ebin,asize(vcos_nm),vcos_nm);
md->ivisc = get_ebin_space(md->ebin,asize(visc_nm),visc_nm);
}
if (bLR)
bEInd[egLR] = TRUE;
if (bLJLR)
bEInd[egLJLR] = TRUE;
if (bBHAM) {
bEInd[egLJ] = FALSE;
bEInd[egBHAM] = TRUE;
}
if (b14) {
bEInd[egLJ14] = TRUE;
bEInd[egCOUL14] = TRUE;
}
md->nEc=0;
for(i=0; (i<egNR); i++)
if (bEInd[i])
md->nEc++;
n=atoms->grps[egcENER].nr;
md->nEg=n;
md->nE=(n*(n+1))/2;
snew(md->igrp,md->nE);
if (md->nE > 1) {
n=0;
snew(gnm,md->nEc);
for(k=0; (k<md->nEc); k++)
snew(gnm[k],STRLEN);
for(i=0; (i<atoms->grps[egcENER].nr); i++) {
ni=atoms->grps[egcENER].nm_ind[i];
for(j=i; (j<atoms->grps[egcENER].nr); j++) {
nj=atoms->grps[egcENER].nm_ind[j];
for(k=kk=0; (k<egNR); k++) {
if (bEInd[k]) {
sprintf(gnm[kk],"%s:%s-%s",egrp_nm[k],
*(atoms->grpname[ni]),*(atoms->grpname[nj]));
kk++;
}
}
md->igrp[n]=get_ebin_space(md->ebin,md->nEc,gnm);
n++;
}
}
for(k=0; (k<md->nEc); k++)
sfree(gnm[k]);
sfree(gnm);
assert(n==md->nE);
}
md->nTC=atoms->grps[egcTC].nr;
snew(grpnms,2*md->nTC);
for(i=0; (i<md->nTC); i++) {
ni=atoms->grps[egcTC].nm_ind[i];
sprintf(buf,"T-%s",*(atoms->grpname[ni]));
grpnms[2*i]=strdup(buf);
if(bNoseHoover)
sprintf(buf,"Xi-%s",*(atoms->grpname[ni]));
else
sprintf(buf,"Lamb-%s",*(atoms->grpname[ni]));
grpnms[2*i+1]=strdup(buf);
}
md->itc=get_ebin_space(md->ebin,2*md->nTC,grpnms);
sfree(grpnms);
md->nU=atoms->grps[egcACC].nr;
if (md->nU > 1) {
snew(grpnms,3*md->nU);
for(i=0; (i<md->nU); i++) {
ni=atoms->grps[egcACC].nm_ind[i];
sprintf(buf,"Ux-%s",*(atoms->grpname[ni]));
grpnms[3*i+XX]=strdup(buf);
sprintf(buf,"Uy-%s",*(atoms->grpname[ni]));
grpnms[3*i+YY]=strdup(buf);
sprintf(buf,"Uz-%s",*(atoms->grpname[ni]));
grpnms[3*i+ZZ]=strdup(buf);
}
md->iu=get_ebin_space(md->ebin,3*md->nU,grpnms);
sfree(grpnms);
}
if (fp_ene != -1)
do_enxnms(fp_ene,&md->ebin->nener,&md->ebin->enm);
#ifdef DEBUG
for(i=0; (i<md->ebin->nener); i++)
fprintf(stdlog,"%5d %20s\n",i,md->ebin->enm[i]);
#endif
return md;
}
