ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
(Generate patch)

Comparing trunk/OOPSE/libBASS/Globals.cpp (file contents):
Revision 579 by gezelter, Wed Jul 9 13:56:27 2003 UTC vs.
Revision 704 by tim, Wed Aug 20 19:11:51 2003 UTC

# Line 46 | Line 46
46   #define G_TARGETPRESSURE 25
47   #define G_TAUTHERMOSTAT  26
48   #define G_TAUBAROSTAT    27
49 + #define G_ZCONSTIME      28
50 + #define G_NZCONSTRAINTS  29
51 + #define G_ZCONSTOL 30
52 + #define G_ZCONSFORCEPOLICY 31
53 + #define G_SEED                        32
54  
50 –
55   Globals::Globals(){
56    
57    int i;
# Line 86 | Line 90 | Globals::Globals(){
90    addHash( "targetPressure",                       G_TARGETPRESSURE);
91    addHash( "tauThermostat",                        G_TAUTHERMOSTAT);
92    addHash( "tauBarostat",                          G_TAUBAROSTAT);
93 <  
93 >  addHash( "zconsTime",                            G_ZCONSTIME);
94 >  addHash( "nZconstraints",                        G_NZCONSTRAINTS);
95 >  addHash( "zconsTol",                               G_ZCONSTOL);
96 >  addHash( "zconsForcePolicy",                    G_ZCONSFORCEPOLICY);
97 >  addHash( "seed",                                     G_SEED);
98 >        
99 >        
100    // define some default values
101  
102    strcpy( mixingRule,"standard");  //default mixing rules to standard.
# Line 119 | Line 129 | Globals::Globals(){
129    have_target_pressure =0;
130    have_q_mass =         0;
131    have_tau_thermostat = 0;
132 <  have_tau_barostat =   0;
133 < }
132 >  have_tau_barostat   = 0;
133 >  have_zcons_time     = 0;
134 >  have_n_zConstraints = 0;
135 >  have_zConstraints   = 0;
136 >  have_zcons_tol = 0;
137 >  have_seed = 0;
138  
139 + }
140 +
141   Globals::~Globals(){
142    int i;
143  
# Line 194 | Line 210 | int Globals::componentAssign( event* the_event ){
210    return 0;
211   }
212  
213 < int Globals::componentStartIndex( event* the_event ){
213 > int Globals::componentEnd( event* the_event ){
214  
215 <  current_component->startIndex( the_event->evt.si.array,
216 <                                 the_event->evt.si.n_elements );
215 >  the_event->err_msg = current_component->checkMe();
216 >  if( the_event->err_msg != NULL ) return 0;
217 >
218    return 1;
219   }
220  
221 < int Globals::componentEnd( event* the_event ){
221 > int Globals::newZconstraint( event* the_event ){
222 >  
223  
224 <  the_event->err_msg = current_component->checkMe();
224 >  int index = the_event->evt.blk_index;
225 >  char err[200];
226 >  current_zConstraint = new ZconStamp( index );
227 >  
228 >  have_zConstraints = 1;
229 >
230 >  if( have_n_zConstraints && index < n_zConstraints )
231 >    zConstraints[index] = current_zConstraint;
232 >  else{
233 >    if( have_n_zConstraints ){
234 >      sprintf( err, "Globals error, %d out of nZconstraints range",
235 >               index );
236 >      the_event->err_msg = strdup( err );
237 >      return 0;
238 >    }
239 >    else{
240 >      the_event->err_msg = strdup("Globals error, nZconstraints"
241 >                                  " not given before"
242 >                                  " first zConstraint declaration." );
243 >      return 0;
244 >    }
245 >  }  
246 >
247 >  return 1;
248 > }
249 >
250 >
251 >
252 > int Globals::zConstraintAssign( event* the_event ){
253 >
254 >  switch( the_event->evt.asmt.asmt_type ){
255 >    
256 >  case STRING:
257 >    return current_zConstraint->assignString( the_event->evt.asmt.lhs,
258 >                                              the_event->evt.asmt.rhs.sval,
259 >                                              &(the_event->err_msg));
260 >    break;
261 >    
262 >  case DOUBLE:
263 >    return current_zConstraint->assignDouble( the_event->evt.asmt.lhs,
264 >                                              the_event->evt.asmt.rhs.dval,
265 >                                              &(the_event->err_msg));
266 >    break;
267 >    
268 >  case INT:
269 >    return current_zConstraint->assignInt( the_event->evt.asmt.lhs,
270 >                                           the_event->evt.asmt.rhs.ival,
271 >                                           &(the_event->err_msg));
272 >    break;
273 >    
274 >  default:
275 >    the_event->err_msg = strdup( "Globals error. Invalid zConstraint"
276 >                                 " assignment type" );
277 >    return 0;
278 >    break;
279 >  }
280 >  return 0;
281 > }
282 >
283 > int Globals::zConstraintEnd( event* the_event ){
284 >
285 >  the_event->err_msg = current_zConstraint->checkMe();
286    if( the_event->err_msg != NULL ) return 0;
287  
288    return 1;
# Line 258 | Line 337 | int Globals::globalAssign( event* the_event ){
337          return 1;
338        }
339        break;
340 +
341 +    case G_NZCONSTRAINTS:
342 +      if( the_type == STRING ){
343 +        the_event->err_msg =
344 +          strdup("Global error. nZconstraints is not a double or an int.\n" );
345 +        return 0;
346 +      }
347        
348 +      else if( the_type == DOUBLE ){
349 +        n_zConstraints = (int)the_event->evt.asmt.rhs.dval;
350 +        zConstraints = new ZconStamp*[n_zConstraints];
351 +        have_n_zConstraints = 1;
352 +        return 1;
353 +      }
354 +      
355 +      else{
356 +        n_zConstraints = the_event->evt.asmt.rhs.ival;
357 +        zConstraints = new ZconStamp*[n_zConstraints];
358 +        have_n_zConstraints = 1;
359 +        return 1;
360 +      }
361 +      break;
362 +      
363      case G_TARGETTEMP:
364        switch( the_type ){
365          
# Line 625 | Line 726 | int Globals::globalAssign( event* the_event ){
726        }
727        break;
728  
729 <   case G_THERMALTIME:
729 >    case G_THERMALTIME:
730        switch( the_type ){
731          
732        case STRING:
# Line 878 | Line 979 | int Globals::globalAssign( event* the_event ){
979        default:
980          the_event->err_msg =
981            strdup( "Global error. tauBarostat unrecognized.\n" );
982 +        return 0;
983 +        break;
984 +      }
985 +      break;
986 +      
987 +    case G_ZCONSTIME:
988 +      switch( the_type ){
989 +        
990 +      case STRING:
991 +        the_event->err_msg =
992 +          strdup( "Global error. zcons_time is not a double or int.\n" );
993          return 0;
994          break;
995 +        
996 +      case DOUBLE:
997 +        zcons_time = the_event->evt.asmt.rhs.dval;
998 +        have_zcons_time = 1;
999 +        return 1;
1000 +        break;
1001 +        
1002 +      case INT:
1003 +        zcons_time = (double)the_event->evt.asmt.rhs.ival;
1004 +        have_zcons_time = 1;
1005 +        return 1;
1006 +        break;
1007 +        
1008 +      default:
1009 +        the_event->err_msg =
1010 +          strdup( "Global error. zcons_time unrecognized.\n" );
1011 +        return 0;
1012 +        break;
1013        }
1014        break;
1015  
1016 +    case G_ZCONSTOL:
1017 +      switch( the_type ){
1018 +        
1019 +      case STRING:
1020 +        the_event->err_msg =
1021 +          strdup( "Global error. zcons_tol is not a double or int.\n" );
1022 +        return 0;
1023 +        break;
1024 +        
1025 +      case DOUBLE:
1026 +        zcons_tol = the_event->evt.asmt.rhs.dval;
1027 +        have_zcons_tol = 1;
1028 +        return 1;
1029 +        break;
1030 +        
1031 +      case INT:
1032 +        zcons_tol = (double)the_event->evt.asmt.rhs.ival;
1033 +        have_zcons_tol = 1;
1034 +        return 1;
1035 +        break;
1036 +        
1037 +      default:
1038 +        the_event->err_msg =
1039 +          strdup( "Global error. zcons_ol unrecognized.\n" );
1040 +        return 0;
1041 +        break;
1042 +      }
1043 +      break;
1044 +  
1045 +    case G_ZCONSFORCEPOLICY:
1046 +      switch( the_type ){
1047 +        
1048 +      case STRING:
1049 +   strcpy(zconsForcePolicy, the_event->evt.asmt.rhs.sval);
1050 +
1051 +   for(int i = 0; zconsForcePolicy[i] != '\0'; i++)
1052 +        {
1053 +      zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1054 +   }
1055 +        have_zcons_force_policy = 1;
1056 +   return 1;
1057 +        break;
1058 +        
1059 +      case DOUBLE:
1060 +        the_event->err_msg =
1061 +          strdup( "Global error. zconsForcePolicy is not a double or int.\n" );
1062 +        return 0;
1063 +        break;
1064 +        
1065 +      case INT:
1066 +        the_event->err_msg =
1067 +          strdup( "Global error. zconsForcePolicy is not a double or int.\n" );
1068 +        return 0;
1069 +        break;
1070 +        
1071 +      default:
1072 +        the_event->err_msg =
1073 +          strdup( "Global error. zconsForcePolicy unrecognized.\n" );
1074 +        return 0;
1075 +        break;
1076 +      }
1077 +      break;
1078 +      // add more token cases here.
1079 +    case G_SEED:
1080 +      switch( the_type ){
1081 +        
1082 +      case STRING:
1083 +   the_event->err_msg =
1084 +          strdup( "Global error. seed is not a string.\n" );
1085 +        return 0;
1086 +   return 0;
1087 +        break;
1088 +        
1089 +      case DOUBLE:
1090 +   have_seed = 1;
1091 +   seed = (int)the_event->evt.asmt.rhs.dval;
1092 +        return 1;
1093 +        break;
1094 +        
1095 +      case INT:
1096 +   have_seed = 1;
1097 +   seed =  the_event->evt.asmt.rhs.ival ;
1098 +        return 1;
1099 +        break;
1100 +        
1101 +      default:
1102 +        the_event->err_msg =
1103 +          strdup( "Global error. seed unrecognized.\n" );
1104 +        return 0;
1105 +        break;
1106 +      }
1107 +      break;
1108 +      // add more token cases here.
1109 +
1110      }
1111    }
1112    

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines