static void cppar(t_param p[], int np, t_params plist[], int ftype)
{
int i, j, nral, nrfp;
t_params *ps;
ps = &plist[ftype];
nral = NRAL(ftype);
nrfp = NRFP(ftype);
/* Keep old stuff */
pr_alloc(np, ps);
for (i = 0; (i < np); i++)
{
for (j = 0; (j < nral); j++)
{
ps->param[ps->nr].a[j] = p[i].a[j];
}
for (j = 0; (j < nrfp); j++)
{
ps->param[ps->nr].c[j] = p[i].c[j];
}
for (j = 0; (j < MAXSLEN); j++)
{
ps->param[ps->nr].s[j] = p[i].s[j];
}
ps->nr++;
}
}
static void gen_pairs(t_params *nbs,t_params *pairs,real fudge, int comb, gmx_bool bVerbose)
{
int i,j,ntp,nrfp,nrfpA,nrfpB,nnn;
real scaling;
ntp = nbs->nr;
nnn = sqrt(ntp);
nrfp = NRFP(F_LJ);
nrfpA = interaction_function[F_LJ14].nrfpA;
nrfpB = interaction_function[F_LJ14].nrfpB;
pairs->nr = ntp;
if ((nrfp != nrfpA) || (nrfpA != nrfpB))
gmx_incons("Number of force parameters in gen_pairs wrong");
fprintf(stderr,"Generating 1-4 interactions: fudge = %g\n",fudge);
if (debug) {
fprintf(debug,"Fudge factor for 1-4 interactions: %g\n",fudge);
fprintf(debug,"Holy Cow! there are %d types\n",ntp);
}
snew(pairs->param,pairs->nr);
for(i=0; (i<ntp); i++) {
/* Copy param.a */
pairs->param[i].a[0] = i / nnn;
pairs->param[i].a[1] = i % nnn;
/* Copy normal and FEP parameters and multiply by fudge factor */
for(j=0; (j<nrfp); j++) {
/* If we are using sigma/epsilon values, only the epsilon values
* should be scaled, but not sigma.
* The sigma values have even indices 0,2, etc.
*/
if ((comb == eCOMB_ARITHMETIC || comb == eCOMB_GEOM_SIG_EPS) && (j%2==0))
scaling = 1.0;
else
scaling = fudge;
pairs->param[i].c[j]=scaling*nbs->param[i].c[j];
pairs->param[i].c[nrfp+j]=scaling*nbs->param[i].c[j];
}
}
}
static void print_param(FILE *fp, int ftype, int i, t_param *param)
{
static int pass = 0;
static int prev_ftype= NOTSET;
static int prev_i = NOTSET;
int j;
if ( (ftype!=prev_ftype) || (i!=prev_i) ) {
pass = 0;
prev_ftype= ftype;
prev_i = i;
}
fprintf(fp,"(%d) plist[%s].param[%d]",
pass,interaction_function[ftype].name,i);
for(j=0; j<NRFP(ftype); j++)
fprintf(fp,".c[%d]=%g ",j,param->c[j]);
fprintf(fp,"\n");
pass++;
}
static int copy_nbparams(t_nbparam **param,int ftype,t_params *plist,int nr)
{
int i,j,f;
int nrfp,ncopy;
nrfp = NRFP(ftype);
ncopy = 0;
for(i=0; i<nr; i++)
for(j=0; j<=i; j++)
if (param[i][j].bSet) {
for(f=0; f<nrfp; f++) {
plist->param[nr*i+j].c[f] = param[i][j].c[f];
plist->param[nr*j+i].c[f] = param[i][j].c[f];
}
ncopy++;
}
return ncopy;
}
void renum_atype(t_params plist[], gmx_mtop_t *mtop,
int *wall_atomtype,
gpp_atomtype_t ga, gmx_bool bVerbose)
{
int i, j, k, l, molt, mi, mj, nat, nrfp, ftype, ntype;
t_atoms *atoms;
t_param *nbsnew;
int *typelist;
real *new_radius;
real *new_vol;
real *new_surftens;
real *new_gb_radius;
real *new_S_hct;
int *new_atomnumber;
char ***new_atomname;
ntype = get_atomtype_ntypes(ga);
snew(typelist, ntype);
if (bVerbose)
{
fprintf(stderr, "renumbering atomtypes...\n");
}
/* Since the bonded interactions have been assigned now,
* we want to reduce the number of atom types by merging
* ones with identical nonbonded interactions, in addition
* to removing unused ones.
*
* With Generalized-Born electrostatics, or implicit solvent
* we also check that the atomtype radius, effective_volume
* and surface tension match.
*
* With QM/MM we also check that the atom numbers match
*/
/* Get nonbonded interaction type */
if (plist[F_LJ].nr > 0)
{
ftype = F_LJ;
}
else
{
ftype = F_BHAM;
}
/* Renumber atomtypes by first making a list of which ones are actually used.
* We provide the list of nonbonded parameters so search_atomtypes
* can determine if two types should be merged.
*/
nat = 0;
for (molt = 0; molt < mtop->nmoltype; molt++)
{
atoms = &mtop->moltype[molt].atoms;
for (i = 0; (i < atoms->nr); i++)
{
atoms->atom[i].type =
search_atomtypes(ga, &nat, typelist, atoms->atom[i].type,
plist[ftype].param, ftype);
atoms->atom[i].typeB =
search_atomtypes(ga, &nat, typelist, atoms->atom[i].typeB,
plist[ftype].param, ftype);
}
}
for (i = 0; i < 2; i++)
{
if (wall_atomtype[i] >= 0)
{
wall_atomtype[i] = search_atomtypes(ga, &nat, typelist, wall_atomtype[i],
plist[ftype].param, ftype);
}
}
snew(new_radius, nat);
snew(new_vol, nat);
snew(new_surftens, nat);
snew(new_atomnumber, nat);
snew(new_gb_radius, nat);
snew(new_S_hct, nat);
snew(new_atomname, nat);
/* We now have a list of unique atomtypes in typelist */
if (debug)
{
pr_ivec(debug, 0, "typelist", typelist, nat, TRUE);
}
/* Renumber nlist */
nbsnew = NULL;
snew(nbsnew, plist[ftype].nr);
nrfp = NRFP(ftype);
for (i = k = 0; (i < nat); i++)
{
mi = typelist[i];
for (j = 0; (j < nat); j++, k++)
{
mj = typelist[j];
for (l = 0; (l < nrfp); l++)
{
nbsnew[k].c[l] = plist[ftype].param[ntype*mi+mj].c[l];
}
}
new_radius[i] = get_atomtype_radius(mi, ga);
new_vol[i] = get_atomtype_vol(mi, ga);
new_surftens[i] = get_atomtype_surftens(mi, ga);
new_atomnumber[i] = get_atomtype_atomnumber(mi, ga);
new_gb_radius[i] = get_atomtype_gb_radius(mi, ga);
new_S_hct[i] = get_atomtype_S_hct(mi, ga);
new_atomname[i] = ga->atomname[mi];
}
for (i = 0; (i < nat*nat); i++)
{
for (l = 0; (l < nrfp); l++)
{
plist[ftype].param[i].c[l] = nbsnew[i].c[l];
}
}
plist[ftype].nr = i;
mtop->ffparams.atnr = nat;
sfree(ga->radius);
sfree(ga->vol);
sfree(ga->surftens);
sfree(ga->atomnumber);
sfree(ga->gb_radius);
sfree(ga->S_hct);
/* Dangling atomname pointers ? */
sfree(ga->atomname);
ga->radius = new_radius;
ga->vol = new_vol;
ga->surftens = new_surftens;
ga->atomnumber = new_atomnumber;
ga->gb_radius = new_gb_radius;
ga->S_hct = new_S_hct;
ga->atomname = new_atomname;
ga->nr = nat;
sfree(nbsnew);
sfree(typelist);
}
static int search_atomtypes(gpp_atomtype_t ga, int *n, int typelist[],
int thistype,
t_param param[], int ftype)
{
int i, nn, nrfp, j, k, ntype, tli;
gmx_bool bFound = FALSE;
nn = *n;
nrfp = NRFP(ftype);
ntype = get_atomtype_ntypes(ga);
for (i = 0; (i < nn); i++)
{
if (typelist[i] == thistype)
{
/* This type number has already been added */
break;
}
/* Otherwise, check if the parameters are identical to any previously added type */
bFound = TRUE;
for (j = 0; j < ntype && bFound; j++)
{
/* Check nonbonded parameters */
for (k = 0; k < nrfp && bFound; k++)
{
bFound = (param[ntype*typelist[i]+j].c[k] == param[ntype*thistype+j].c[k]);
}
/* Check radius, volume, surftens */
tli = typelist[i];
bFound = bFound &&
(get_atomtype_radius(tli, ga) == get_atomtype_radius(thistype, ga)) &&
(get_atomtype_vol(tli, ga) == get_atomtype_vol(thistype, ga)) &&
(get_atomtype_surftens(tli, ga) == get_atomtype_surftens(thistype, ga)) &&
(get_atomtype_atomnumber(tli, ga) == get_atomtype_atomnumber(thistype, ga)) &&
(get_atomtype_gb_radius(tli, ga) == get_atomtype_gb_radius(thistype, ga)) &&
(get_atomtype_S_hct(tli, ga) == get_atomtype_S_hct(thistype, ga));
}
if (bFound)
{
break;
}
}
if (i == nn)
{
if (debug)
{
fprintf(debug, "Renumbering atomtype %d to %d\n", thistype, nn);
}
if (nn == ntype)
{
gmx_fatal(FARGS, "Atomtype horror n = %d, %s, %d", nn, __FILE__, __LINE__);
}
typelist[nn] = thistype;
nn++;
}
*n = nn;
return i;
}
void print_bt(FILE *out, directive d, gpp_atomtype_t at,
int ftype, int fsubtype, t_params plist[],
gmx_bool bFullDih)
{
/* This dihp is a DIRTY patch because the dih-types do not use
* all four atoms to determine the type.
*/
const int dihp[2][2] = { { 1, 2 }, { 0, 3 } };
t_params *bt;
int i, j, f, nral, nrfp;
gmx_bool bDih = FALSE, bSwapParity;
bt = &(plist[ftype]);
if (!bt->nr)
{
return;
}
f = 0;
switch (ftype)
{
case F_G96ANGLES:
f = 1;
break;
case F_G96BONDS:
f = 1;
break;
case F_MORSE:
f = 2;
break;
case F_CUBICBONDS:
f = 3;
break;
case F_CONNBONDS:
f = 4;
break;
case F_HARMONIC:
f = 5;
break;
case F_CROSS_BOND_ANGLES:
f = 2;
break;
case F_CROSS_BOND_BONDS:
f = 3;
break;
case F_UREY_BRADLEY:
f = 4;
break;
case F_PDIHS:
case F_RBDIHS:
case F_FOURDIHS:
bDih = TRUE;
break;
case F_IDIHS:
f = 1;
bDih = TRUE;
break;
case F_CONSTRNC:
f = 1;
break;
case F_VSITE3FD:
f = 1;
break;
case F_VSITE3FAD:
f = 2;
break;
case F_VSITE3OUT:
f = 3;
break;
case F_VSITE4FDN:
f = 1;
break;
case F_CMAP:
f = 1;
break;
default:
bDih = FALSE;
}
if (bFullDih)
{
bDih = FALSE;
}
if (fsubtype)
{
f = fsubtype-1;
}
nral = NRAL(ftype);
nrfp = NRFP(ftype);
/* header */
fprintf(out, "[ %s ]\n", dir2str(d));
fprintf(out, "; ");
if (!bDih)
{
fprintf (out, "%3s %4s", "ai", "aj");
for (j = 2; (j < nral); j++)
{
fprintf (out, " %3c%c", 'a', 'i'+j);
}
}
else
{
for (j = 0; (j < 2); j++)
{
fprintf (out, "%3c%c", 'a', 'i'+dihp[f][j]);
}
}
fprintf (out, " funct");
for (j = 0; (j < nrfp); j++)
{
fprintf (out, " %12c%1d", 'c', j);
}
fprintf (out, "\n");
/* print bondtypes */
for (i = 0; (i < bt->nr); i++)
{
bSwapParity = (bt->param[i].C0 == NOTSET) && (bt->param[i].C1 == -1);
if (!bDih)
{
for (j = 0; (j < nral); j++)
{
fprintf (out, "%5s ", get_atomtype_name(bt->param[i].a[j], at));
}
}
else
{
for (j = 0; (j < 2); j++)
{
fprintf (out, "%5s ", get_atomtype_name(bt->param[i].a[dihp[f][j]], at));
}
}
fprintf (out, "%5d ", bSwapParity ? -f-1 : f+1);
if (bt->param[i].s[0])
{
fprintf(out, " %s", bt->param[i].s);
}
else
{
for (j = 0; (j < nrfp && (bt->param[i].c[j] != NOTSET)); j++)
{
fprintf (out, "%13.6e ", bt->param[i].c[j]);
}
}
fprintf (out, "\n");
}
fprintf (out, "\n");
fflush (out);
}
int set_vsites(gmx_bool bVerbose, t_atoms *atoms, gpp_atomtype_t atype,
t_params plist[])
{
int i,j,ftype;
int nvsite,nrbond,nrang,nridih,nrset;
gmx_bool bFirst,bSet,bERROR;
at2vsitebond_t *at2vb;
t_mybonded *bonds;
t_mybonded *angles;
t_mybonded *idihs;
bFirst = TRUE;
bERROR = TRUE;
nvsite=0;
if (debug)
fprintf(debug, "\nCalculating parameters for virtual sites\n");
/* Make a reverse list to avoid ninteractions^2 operations */
at2vb = make_at2vsitebond(atoms->nr,plist);
for(ftype=0; (ftype<F_NRE); ftype++)
if ((interaction_function[ftype].flags & IF_VSITE) && ftype != F_VSITEN) {
nrset=0;
nvsite+=plist[ftype].nr;
for(i=0; (i<plist[ftype].nr); i++) {
/* check if all parameters are set */
bSet=TRUE;
for(j=0; j<NRFP(ftype) && bSet; j++)
bSet = plist[ftype].param[i].c[j]!=NOTSET;
if (debug) {
fprintf(debug,"bSet=%s ",bool_names[bSet]);
print_param(debug,ftype,i,&plist[ftype].param[i]);
}
if (!bSet) {
if (bVerbose && bFirst) {
fprintf(stderr,"Calculating parameters for virtual sites\n");
bFirst=FALSE;
}
nrbond=nrang=nridih=0;
bonds = NULL;
angles= NULL;
idihs = NULL;
nrset++;
/* now set the vsite parameters: */
get_bondeds(NRAL(ftype), plist[ftype].param[i].a, at2vb, plist,
&nrbond, &bonds, &nrang, &angles, &nridih, &idihs);
if (debug) {
fprintf(debug, "Found %d bonds, %d angles and %d idihs "
"for virtual site %u (%s)\n",nrbond,nrang,nridih,
plist[ftype].param[i].AI+1,
interaction_function[ftype].longname);
print_bad(debug, nrbond, bonds, nrang, angles, nridih, idihs);
} /* debug */
switch(ftype) {
case F_VSITE3:
bERROR =
calc_vsite3_param(atype, &(plist[ftype].param[i]), atoms,
nrbond, bonds, nrang, angles);
break;
case F_VSITE3FD:
bERROR =
calc_vsite3fd_param(&(plist[ftype].param[i]),
nrbond, bonds, nrang, angles);
break;
case F_VSITE3FAD:
bERROR =
calc_vsite3fad_param(&(plist[ftype].param[i]),
nrbond, bonds, nrang, angles);
break;
case F_VSITE3OUT:
bERROR =
calc_vsite3out_param(atype, &(plist[ftype].param[i]), atoms,
nrbond, bonds, nrang, angles);
break;
case F_VSITE4FD:
bERROR =
calc_vsite4fd_param(&(plist[ftype].param[i]),
nrbond, bonds, nrang, angles);
break;
case F_VSITE4FDN:
bERROR =
calc_vsite4fdn_param(&(plist[ftype].param[i]),
nrbond, bonds, nrang, angles);
break;
default:
gmx_fatal(FARGS,"Automatic parameter generation not supported "
"for %s atom %d",
interaction_function[ftype].longname,
plist[ftype].param[i].AI+1);
} /* switch */
if (bERROR)
gmx_fatal(FARGS,"Automatic parameter generation not supported "
"for %s atom %d for this bonding configuration",
interaction_function[ftype].longname,
plist[ftype].param[i].AI+1);
sfree(bonds);
sfree(angles);
sfree(idihs);
} /* if bSet */
} /* for i */
if (debug && plist[ftype].nr)
fprintf(stderr,"Calculated parameters for %d out of %d %s atoms\n",
nrset,plist[ftype].nr,interaction_function[ftype].longname);
} /* if IF_VSITE */
done_at2vsitebond(atoms->nr,at2vb);
return nvsite;
}
