Esempio n. 1
0
static void clean_dih(t_param *dih, int *ndih,t_param idih[],int nidih,
		      t_atoms *atoms,bool bAlldih, bool bRemoveDih)
{
  int  i,j,k,l;
  int  *index,nind;
  bool bIsSet,bKeep;
  int  bestl,nh,minh;
  
  snew(index,*ndih+1);
  if (bAlldih) {
    fprintf(stderr,"Keeping all generated dihedrals\n");
    nind = *ndih;
    for(i=0; i<nind; i++) 
      index[i] = i;
    index[nind] = *ndih;
  } else {
    /* Make an index of all dihedrals over each bond */
    nind = 0;
    for(i=0; i<*ndih; i++) 
      if (!remove_dih(dih,i,*ndih)) 
	index[nind++]=i;
    index[nind] = *ndih;
  }

  /* if we don't want all dihedrals, we need to select the ones with the 
   *  fewest hydrogens
   */
  
  k=0;
  for(i=0; i<nind; i++) {
    bIsSet = (dih[index[i]].c[MAXFORCEPARAM-1] != NOTSET);
    bKeep = TRUE;
    if (!bIsSet && bRemoveDih)
      /* remove the dihedral if there is an improper on the same bond */
      for(j=0; (j<nidih) && bKeep; j++)
	bKeep = !deq(&dih[index[i]],&idih[j]);

    if (bKeep) {
      /* Now select the "fittest" dihedral:
       * the one with as few hydrogens as possible 
       */
      
      /* Best choice to get dihedral from */
      bestl=index[i];
      if (!bAlldih && !bIsSet) {
	/* Minimum number of hydrogens for i and l atoms */
	minh=2;
	for(l=index[i]; (l<index[i+1]) && deq(&dih[index[i]],&dih[l]); l++) {
	  if ((nh=n_hydro(dih[l].a,atoms->atomname)) < minh) {
	    minh=nh;
	    bestl=l;
	  }
	  if (minh == 0)
	    break;
	}
      }
      if (k != bestl)
	cpparam(&(dih[k]),&dih[bestl]);
      k++;
    }
  }

  for (i=k; i<*ndih; i++)
    strcpy(dih[i].s,"");
  *ndih = k;

  sfree(index);
}
Esempio n. 2
0
/* 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);
}