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 3.1
  11  * Copyright (c) 1991-2001, University of Groningen, The Netherlands
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * If you want to redistribute modifications, please consider that
  18  * scientific software is very special. Version control is crucial -
  19  * bugs must be traceable. We will be happy to consider code for
  20  * inclusion in the official distribution, but derived work must not
  21  * be called official GROMACS. Details are found in the README & COPYING
  22  * files - if they are missing, get the official version at www.gromacs.org.
  23  *
  24  * To help us fund GROMACS development, we humbly ask that you cite
  25  * the papers on the package - you can find them in the top README file.
  26  *
  27  * For more info, check our website at http://www.gromacs.org
  28  *
  29  * And Hey:
  30  * Gromacs Runs One Microsecond At Cannonball Speeds
  31  */
  32 static char *SRCID_topdirs_c = "$Id$";
  33 #include <stdio.h>
  34 #include <stdarg.h>
  35
  36 #include "sysstuff.h"
  37 #include "smalloc.h"
  38 #include "macros.h"
  39 #include "string2.h"
  40 #include "topdirs.h"
  41
  42 int ifunc_index(directive d,int type)
  43 {
  44   switch (d) {
  45   case d_bondtypes:
  46   case d_bonds:
  47     if (type == 1)
  48       return F_BONDS;
  49     else if (type == 2)
  50       return F_G96BONDS;
  51     else if (type == 3)
  52       return F_MORSE;
  53     else if (type == 4)
  54       return F_CUBICBONDS;
  55     else if (type == 5)
  56       return F_CONNBONDS;
  57     else if (type == 6)
  58       return F_HARMONIC;
  59     else
  60       fatal_error(0,"Invalid bond type %d",type);
  61   case d_angles:
  62   case d_angletypes:
  63     if (type == 1)
  64       return F_ANGLES;
  65     else if (type == 2)
  66       return F_G96ANGLES;
  67     else
  68       fatal_error(0,"Invalid angle type %d",type);
  69   case d_pairs:
  70   case d_pairtypes:
  71     return F_LJ14;
  72   case d_dihedrals:
  73   case d_dihedraltypes:
  74     switch (type) {
  75     case 1:
  76       return F_PDIHS;
  77     case 2:
  78       return F_IDIHS;
  79     case 3:
  80       return F_RBDIHS;
  81     default:
  82       fatal_error(0,"Invalid dihedral type %d",type);
  83     }
  84     break;
  85   case d_nonbond_params:
  86     if (type == 1)
  87       return F_LJ;
  88     else
  89       return F_BHAM;
  90   case d_dum2:
  91     return F_DUMMY2;
  92   case d_dum3:
  93     switch (type) {
  94     case 1:
  95       return F_DUMMY3;
  96     case 2:
  97       return F_DUMMY3FD;
  98     case 3:
  99       return F_DUMMY3FAD;
 100     case 4:
 101       return F_DUMMY3OUT;
 102     default:
 103       fatal_error(0,"Invalid dummies3 type %d",type);
 104     }
 105   case d_dum4:
 106     return F_DUMMY4FD;
 107   case d_constraints:
 108   case d_constrainttypes:
 109     switch (type) {
 110     case 1:
 111       return F_SHAKE;
 112     case 2:
 113       return F_SHAKENC;
 114     default:
 115       fatal_error(0,"Invalid constraints type %d",type);
 116     }
 117   case d_settles:
 118     return F_SETTLE;
 119   case d_position_restraints:
 120     switch (type) {
 121     case 1:
 122       return F_POSRES;
 123     case 2:
 124       return F_WPOL;
 125     default:
 126       fatal_error(0,"Invalid position restraint type %d",type);
 127     }
 128   case d_angle_restraints:
 129     return F_ANGRES;
 130   case d_angle_restraints_z:
 131     return F_ANGRESZ;
 132   case d_distance_restraints:
 133     return F_DISRES;
 134   case d_orientation_restraints:
 135     return F_ORIRES;
 136   default:
 137     fatal_error(0,"invalid directive %s in ifunc_index (%s:%s)",
 138                 dir2str(d),__FILE__,__LINE__);
 139   }
 140   return -1;
 141 }
 142
 143 char *dir2str (directive d)
 144 {
 145   if (d < d_maxdir)
 146     return ds[d];
 147   else
 148     return ds[d_maxdir];
 149 }
 150
 151 directive str2dir (char *dstr)
 152 {
 153   directive d;
 154
 155   for (d=(directive)0; (d<d_maxdir); d++)
 156     if (strcasecmp_min(dstr,dir2str(d)) == 0)
 157       return d;
 158
 159   return d_invalid;
 160 }
 161
 162 static directive **necessary = NULL;
 163
 164 static void set_nec(directive **n, ...)
 165 /* Must always have at least one extra argument */
 166 {
 167   va_list   ap;
 168   int       ind=0;
 169   directive d;
 170
 171   va_start(ap,n);
 172   do {
 173     d=va_arg(ap,directive);
 174     srenew(*n,++ind);
 175     (*n)[ind-1]=d;
 176   } while (d != d_none);
 177   va_end(ap);
 178 }
 179
 180 void DS_Init(DirStack **DS)
 181 {
 182   if (necessary==NULL) {
 183     int i;
 184
 185     snew(necessary,d_maxdir);
 186     set_nec(&(necessary[d_defaults]),d_none);
 187     set_nec(&(necessary[d_atomtypes]),d_defaults,d_none);
 188     set_nec(&(necessary[d_bondtypes]),d_atomtypes,d_none);
 189     set_nec(&(necessary[d_constrainttypes]),d_atomtypes,d_none);
 190     set_nec(&(necessary[d_pairtypes]),d_atomtypes,d_none);
 191     set_nec(&(necessary[d_angletypes]),d_atomtypes,d_none);
 192     set_nec(&(necessary[d_dihedraltypes]),d_atomtypes,d_none);
 193     set_nec(&(necessary[d_nonbond_params]),d_atomtypes,d_none);
 194     set_nec(&(necessary[d_blocktype]),d_atomtypes,d_none);
 195     set_nec(&(necessary[d_moleculetype]),d_atomtypes,d_none);
 196     set_nec(&(necessary[d_atoms]),d_blocktype,d_moleculetype,d_none);
 197     set_nec(&(necessary[d_dum2]),d_atoms,d_none);
 198     set_nec(&(necessary[d_dum3]),d_atoms,d_none);
 199     set_nec(&(necessary[d_dum4]),d_atoms,d_none);
 200     set_nec(&(necessary[d_bonds]),d_atoms,d_none);
 201     set_nec(&(necessary[d_exclusions]),d_bonds,d_constraints,d_settles,d_none);
 202     set_nec(&(necessary[d_pairs]),d_atoms,d_none);
 203     set_nec(&(necessary[d_angles]),d_atoms,d_none);
 204     set_nec(&(necessary[d_dihedrals]),d_atoms,d_none);
 205     set_nec(&(necessary[d_constraints]),d_atoms,d_none);
 206     set_nec(&(necessary[d_settles]),d_atoms,d_none);
 207     set_nec(&(necessary[d_system]),d_moleculetype,d_none);
 208     set_nec(&(necessary[d_molecules]),d_system,d_none);
 209     set_nec(&(necessary[d_position_restraints]),d_atoms,d_none);
 210     set_nec(&(necessary[d_angle_restraints]),d_atoms,d_none);
 211     set_nec(&(necessary[d_angle_restraints_z]),d_atoms,d_none);
 212     set_nec(&(necessary[d_distance_restraints]),d_atoms,d_none);
 213     set_nec(&(necessary[d_orientation_restraints]),d_atoms,d_none);
 214     for(i=0; (i<d_maxdir); i++) {
 215       if (debug)
 216         fprintf(debug,"%20s:  ",dir2str((directive)i));
 217       if(necessary[i]) {
 218         directive d;
 219         int       j=0;
 220         do {
 221           d=necessary[i][j++];
 222           if (debug)
 223             fprintf(debug,"%20s  ",dir2str(d));
 224         } while (d!=d_none);
 225       }
 226       if (debug)
 227         fprintf(debug,"\n");
 228     }
 229   }
 230   *DS = NULL;
 231
 232 }
 233
 234 void DS_Done (DirStack **DS)
 235 {
 236   DirStack *D;
 237
 238   while (*DS != NULL) {
 239     D = *DS;
 240     *DS = (*DS)->prev;
 241     sfree (D);
 242   }
 243 }
 244
 245 void DS_Push (DirStack **DS, directive d)
 246 {
 247   DirStack *D;
 248
 249   snew(D,1);
 250   D->d = d;
 251   D->prev = *DS;
 252   *DS = D;
 253 }
 254
 255 int DS_Search(DirStack *DS, directive d)
 256 {
 257   DirStack *D;
 258
 259   D = DS;
 260   while ((D != NULL) && (D->d != d))
 261     D = D->prev;
 262
 263   return (D != NULL);
 264 }
 265
 266 int DS_Check_Order(DirStack *DS,directive d)
 267 {
 268   directive d0;
 269   int       i=0;
 270
 271   /* Check if parameter definitions appear after a moleculetype directive */
 272   if (d<d_moleculetype && DS_Search(DS,d_moleculetype))
 273     return FALSE;
 274
 275   /* Check if all the necessary directives have appeared before directive d */
 276   if (necessary[d][0] == d_none)
 277     return TRUE;
 278   else {
 279     do {
 280       d0=necessary[d][i++];
 281       if (DS_Search(DS,d0))
 282         return TRUE;
 283     } while(d0!=d_none);
 284   }
 285   return FALSE;
 286 }
 287
 288
 289