static int dcomp(const void *d1, const void *d2)
{
const t_param *p1, *p2;
int dc;
p1 = static_cast<const t_param *>(d1);
p2 = static_cast<const t_param *>(d2);
/* First sort by J & K (the two central) atoms */
if ((dc = (p1->aj()-p2->aj())) != 0)
{
return dc;
}
else if ((dc = (p1->ak()-p2->ak())) != 0)
{
return dc;
}
/* Then make sure to put rtp dihedrals before generated ones */
else if (was_dihedral_set_in_rtp(p1) &&
!was_dihedral_set_in_rtp(p2))
{
return -1;
}
else if (!was_dihedral_set_in_rtp(p1) &&
was_dihedral_set_in_rtp(p2))
{
return 1;
}
/* Then sort by I and J (two outer) atoms */
else if ((dc = (p1->ai()-p2->ai())) != 0)
{
return dc;
}
else if ((dc = (p1->al()-p2->al())) != 0)
{
return dc;
}
else
{
// AMBER force fields with type 9 dihedrals can reach here, where we sort on
// the contents of the string that names the macro for the parameters.
return strcmp(p1->s, p2->s);
}
}
static int dcomp(const void *d1, const void *d2)
{
t_param *p1, *p2;
int dc;
p1 = (t_param *)d1;
p2 = (t_param *)d2;
/* First sort by J & K (the two central) atoms */
if ((dc = (p1->aj()-p2->aj())) != 0)
{
return dc;
}
else if ((dc = (p1->ak()-p2->ak())) != 0)
{
return dc;
}
/* Then make sure to put rtp dihedrals before generated ones */
else if (was_dihedral_set_in_rtp(p1) &&
!was_dihedral_set_in_rtp(p2))
{
return -1;
}
else if (!was_dihedral_set_in_rtp(p1) &&
was_dihedral_set_in_rtp(p2))
{
return 1;
}
/* Finally, sort by I and J (two outer) atoms */
else if ((dc = (p1->ai()-p2->ai())) != 0)
{
return dc;
}
else
{
return (p1->al()-p2->al());
}
}
/* Clean up the dihedrals (both generated and read from the .rtp
* file). */
static void clean_dih(t_param *dih, int *ndih, t_param improper[], int nimproper,
t_atoms *atoms, gmx_bool bKeepAllGeneratedDihedrals,
gmx_bool bRemoveDihedralIfWithImproper)
{
int i, j, k, l;
int *index, nind;
/* Construct the list of the indices of the dihedrals
* (i.e. generated or read) that might be kept. */
snew(index, *ndih+1);
if (bKeepAllGeneratedDihedrals)
{
fprintf(stderr, "Keeping all generated dihedrals\n");
nind = *ndih;
for (i = 0; i < nind; i++)
{
index[i] = i;
}
index[nind] = *ndih;
}
else
{
nind = 0;
/* Check if generated dihedral i should be removed. The
* dihedrals have been sorted by dcomp() above, so all those
* on the same two central atoms are together, with those from
* the .rtp file preceding those that were automatically
* generated. We remove the latter if the former exist. */
for (i = 0; i < *ndih; i++)
{
/* Keep the dihedrals that were defined in the .rtp file,
* and the dihedrals that were generated and different
* from the last one (whether it was generated or not). */
if (was_dihedral_set_in_rtp(&dih[i]) ||
0 == i ||
!is_dihedral_on_same_bond(&dih[i], &dih[i-1]))
{
index[nind++] = i;
}
}
index[nind] = *ndih;
}
k = 0;
for (i = 0; i < nind; i++)
{
gmx_bool bWasSetInRTP = was_dihedral_set_in_rtp(&dih[index[i]]);
gmx_bool bKeep = TRUE;
if (!bWasSetInRTP && bRemoveDihedralIfWithImproper)
{
/* Remove the dihedral if there is an improper on the same
* bond. */
for (j = 0; j < nimproper && bKeep; j++)
{
bKeep = !is_dihedral_on_same_bond(&dih[index[i]], &improper[j]);
}
}
if (bKeep)
{
/* If we don't want all dihedrals, we want to select the
* ones with the fewest hydrogens. Note that any generated
* dihedrals on the same bond as an .rtp dihedral may have
* been already pruned above in the construction of
* index[]. However, their parameters are still present,
* and l is looping over this dihedral and all of its
* pruned siblings. */
int bestl = index[i];
if (!bKeepAllGeneratedDihedrals && !bWasSetInRTP)
{
/* Minimum number of hydrogens for i and l atoms */
int minh = 2;
for (l = index[i];
(l < index[i+1] &&
is_dihedral_on_same_bond(&dih[index[i]], &dih[l]));
l++)
{
int nh = n_hydro(dih[l].a, atoms->atomname);
if (nh < minh)
{
minh = nh;
bestl = l;
}
if (0 == minh)
{
break;
}
}
}
if (k != bestl)
{
cpparam(&dih[k], &dih[bestl]);
}
k++;
}
}
for (i = k; i < *ndih; i++)
{
strcpy(dih[i].s, "");
}
*ndih = k;
sfree(index);
}
