src/kernel/topdirs.c

   1 /*
   2  * $Id$
   3  *
   4  *       This source code is part of
   5  *
   6  *        G   R   O   M   A   C   S
   7  *
   8  * GROningen MAchine for Chemical Simulations
   9  *
  10  *               VERSION 2.0
  11  *
  12  * Copyright (c) 1991-1999
  13  * BIOSON Research Institute, Dept. of Biophysical Chemistry
  14  * University of Groningen, The Netherlands
  15  *
  16  * Please refer to:
  17  * GROMACS: A message-passing parallel molecular dynamics implementation
  18  * H.J.C. Berendsen, D. van der Spoel and R. van Drunen
  19  * Comp. Phys. Comm. 91, 43-56 (1995)
  20  *
  21  * Also check out our WWW page:
  22  * http://md.chem.rug.nl/~gmx
  23  * or e-mail to:
  24  * gromacs@chem.rug.nl
  25  *
  26  * And Hey:
  27  * GRowing Old MAkes el Chrono Sweat
  28  */
  29 static char *SRCID_topdirs_c = "$Id$";
  30
  31 #include <stdio.h>
  32 #include <stdarg.h>
  33
  34 #include "sysstuff.h"
  35 #include "smalloc.h"
  36 #include "macros.h"
  37 #include "string2.h"
  38 #include "topdirs.h"
  39
  40 int ifunc_index(directive d,int type)
  41 {
  42   switch (d) {
  43   case d_bondtypes:
  44   case d_bonds:
  45     if (type == 1)
  46       return F_BONDS;
  47     else if (type == 2)
  48       return F_G96BONDS;
  49     else if (type == 3)
  50       return F_MORSE;
  51     else
  52       fatal_error(0,"Invalid bond type %d",type);
  53   case d_angles:
  54   case d_angletypes:
  55     if (type == 1)
  56       return F_ANGLES;
  57     else if (type == 2)
  58       return F_G96ANGLES;
  59     else
  60       fatal_error(0,"Invalid angle type %d",type);
  61   case d_pairs:
  62   case d_pairtypes:
  63     return F_LJ14;
  64   case d_dihedrals:
  65   case d_dihedraltypes:
  66     switch (type) {
  67     case 1:
  68       return F_PDIHS;
  69     case 2:
  70       return F_IDIHS;
  71     case 3:
  72       return F_RBDIHS;
  73     default:
  74       fatal_error(0,"Invalid dihedral type %d",type);
  75     }
  76     break;
  77   case d_nonbond_params:
  78     if (type == 1)
  79       return F_LJ;
  80     else
  81       return F_BHAM;
  82   case d_dum2:
  83     return F_DUMMY2;
  84   case d_dum3:
  85     switch (type) {
  86     case 1:
  87       return F_DUMMY3;
  88     case 2:
  89       return F_DUMMY3FD;
  90     case 3:
  91       return F_DUMMY3FAD;
  92     case 4:
  93       return F_DUMMY3OUT;
  94     default:
  95       fatal_error(0,"Invalid dummies3 type %d",type);
  96     }
  97   case d_dum4:
  98     return F_DUMMY4FD;
  99   case d_constraints:
 100   case d_constrainttypes:
 101     switch (type) {
 102     case 1:
 103       return F_SHAKE;
 104     case 2:
 105       return F_SHAKENC;
 106     default:
 107       fatal_error(0,"Invalid constraints type %d",type);
 108     }
 109   case d_settles:
 110     return F_SETTLE;
 111   case d_position_restraints:
 112     switch (type) {
 113     case 1:
 114       return F_POSRES;
 115     case 2:
 116       return F_WPOL;
 117     default:
 118       fatal_error(0,"Invalid position restraint type %d",type);
 119     }
 120   case d_angle_restraints:
 121     return F_ANGRES;
 122   case d_angle_restraints_z:
 123     return F_ANGRESZ;
 124   case d_distance_restraints:
 125     return F_DISRES;
 126   default:
 127     fatal_error(0,"invalid directive %s in ifunc_index (%s:%s)",
 128                 dir2str(d),__FILE__,__LINE__);
 129   }
 130   return -1;
 131 }
 132
 133 char *dir2str (directive d)
 134 {
 135   if (d < d_maxdir)
 136     return ds[d];
 137   else
 138     return ds[d_maxdir];
 139 }
 140
 141 directive str2dir (char *dstr)
 142 {
 143   directive d;
 144
 145   for (d=(directive)0; (d<d_maxdir); d++)
 146     if (gmx_strcasecmp(dstr,dir2str(d)) == 0)
 147       return d;
 148
 149   return d_invalid;
 150 }
 151
 152 static directive **necessary = NULL;
 153
 154 static void set_nec(directive **n, ...)
 155 /* Must always have at least one extra argument */
 156 {
 157   va_list   ap;
 158   int       ind=0;
 159   directive d;
 160
 161   va_start(ap,n);
 162   do {
 163     d=va_arg(ap,directive);
 164     srenew(*n,++ind);
 165     (*n)[ind-1]=d;
 166   } while (d != d_none);
 167   va_end(ap);
 168 }
 169
 170 void DS_Init(DirStack **DS)
 171 {
 172   if (necessary==NULL) {
 173     int i;
 174
 175     snew(necessary,d_maxdir);
 176     set_nec(&(necessary[d_defaults]),d_none);
 177     set_nec(&(necessary[d_atomtypes]),d_defaults,d_none);
 178     set_nec(&(necessary[d_bondtypes]),d_atomtypes,d_none);
 179     set_nec(&(necessary[d_constrainttypes]),d_atomtypes,d_none);
 180     set_nec(&(necessary[d_pairtypes]),d_atomtypes,d_none);
 181     set_nec(&(necessary[d_angletypes]),d_atomtypes,d_none);
 182     set_nec(&(necessary[d_dihedraltypes]),d_atomtypes,d_none);
 183     set_nec(&(necessary[d_nonbond_params]),d_atomtypes,d_none);
 184     set_nec(&(necessary[d_blocktype]),d_atomtypes,d_none);
 185     set_nec(&(necessary[d_moleculetype]),d_atomtypes,d_none);
 186     set_nec(&(necessary[d_atoms]),d_blocktype,d_moleculetype,d_none);
 187     set_nec(&(necessary[d_dum2]),d_atoms,d_none);
 188     set_nec(&(necessary[d_dum3]),d_atoms,d_none);
 189     set_nec(&(necessary[d_dum4]),d_atoms,d_none);
 190     set_nec(&(necessary[d_bonds]),d_atoms,d_none);
 191     set_nec(&(necessary[d_exclusions]),d_bonds,d_constraints,d_settles,d_none);
 192     set_nec(&(necessary[d_pairs]),d_atoms,d_none);
 193     set_nec(&(necessary[d_angles]),d_atoms,d_none);
 194     set_nec(&(necessary[d_dihedrals]),d_atoms,d_none);
 195     set_nec(&(necessary[d_constraints]),d_atoms,d_none);
 196     set_nec(&(necessary[d_settles]),d_atoms,d_none);
 197     set_nec(&(necessary[d_system]),d_moleculetype,d_none);
 198     set_nec(&(necessary[d_molecules]),d_system,d_none);
 199     set_nec(&(necessary[d_position_restraints]),d_atoms,d_none);
 200     set_nec(&(necessary[d_angle_restraints]),d_atoms,d_none);
 201     set_nec(&(necessary[d_angle_restraints_z]),d_atoms,d_none);
 202     set_nec(&(necessary[d_distance_restraints]),d_atoms,d_none);
 203     for(i=0; (i<d_maxdir); i++) {
 204       if (debug)
 205         fprintf(debug,"%20s:  ",dir2str((directive)i));
 206       if(necessary[i]) {
 207         directive d;
 208         int       j=0;
 209         do {
 210           d=necessary[i][j++];
 211           if (debug)
 212             fprintf(debug,"%20s  ",dir2str(d));
 213         } while (d!=d_none);
 214       }
 215       if (debug)
 216         fprintf(debug,"\n");
 217     }
 218   }
 219   *DS = NULL;
 220
 221 }
 222
 223 void DS_Done (DirStack **DS)
 224 {
 225   DirStack *D;
 226
 227   while (*DS != NULL) {
 228     D = *DS;
 229     *DS = (*DS)->prev;
 230     sfree (D);
 231   }
 232 }
 233
 234 void DS_Push (DirStack **DS, directive d)
 235 {
 236   DirStack *D;
 237
 238   snew(D,1);
 239   D->d = d;
 240   D->prev = *DS;
 241   *DS = D;
 242 }
 243
 244 int DS_Search(DirStack *DS, directive d)
 245 {
 246   DirStack *D;
 247
 248   D = DS;
 249   while ((D != NULL) && (D->d != d))
 250     D = D->prev;
 251
 252   return (D != NULL);
 253 }
 254
 255 int DS_Check_Order(DirStack *DS,directive d)
 256 {
 257   directive d0;
 258   int       i=0;
 259
 260   if (necessary[d][0] == d_none)
 261     return TRUE;
 262   else {
 263     do {
 264       d0=necessary[d][i++];
 265       if (DS_Search(DS,d0))
 266         return TRUE;
 267     } while(d0!=d_none);
 268   }
 269   return FALSE;
 270 }
 271
 272
 273