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 378 by mmeineke, Fri Mar 21 17:42:12 2003 UTC vs.
Revision 704 by tim, Wed Aug 20 19:11:51 2003 UTC

# Line 25 | Line 25
25   #define G_RUNTIME     6
26  
27   //optional parameters
28 < #define G_INITIALCONFIG 7
29 < #define G_FINALCONFIG   8
30 < #define G_NMOL          9
31 < #define G_DENSITY       10
32 < #define G_BOX           11
33 < #define G_BOXX          12
34 < #define G_BOXY          13
35 < #define G_BOXZ          14
36 < #define G_SAMPLETIME    15
37 < #define G_STATUSTIME    16
38 < #define G_RRF           17
39 < #define G_DIELECTRIC    18
40 < #define G_TEMPSET       19
41 < #define G_THERMALTIME   20
42 < #define G_USEPBC 21
43 < #define G_MIXINGRULE 22
28 > #define G_INITIALCONFIG   7
29 > #define G_FINALCONFIG     8
30 > #define G_NMOL            9
31 > #define G_DENSITY        10
32 > #define G_BOX            11
33 > #define G_BOXX           12
34 > #define G_BOXY           13
35 > #define G_BOXZ           14
36 > #define G_SAMPLETIME     15
37 > #define G_STATUSTIME     16
38 > #define G_ECR            17
39 > #define G_DIELECTRIC     18
40 > #define G_TEMPSET        19
41 > #define G_THERMALTIME    20
42 > #define G_USEPBC         21
43 > #define G_MIXINGRULE     22
44 > #define G_EST            23
45 > #define G_USERF          24
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  
45 –
55   Globals::Globals(){
56    
57    int i;
# Line 70 | Line 79 | Globals::Globals(){
79    addHash( "boxZ",          G_BOXZ );
80    addHash( "sampleTime",    G_SAMPLETIME );
81    addHash( "statusTime",    G_STATUSTIME );
82 <  addHash( "rRF",           G_RRF );
82 >  addHash( "electrostaticCutoffRadius",            G_ECR );
83    addHash( "dielectric",    G_DIELECTRIC );
84    addHash( "tempSet",       G_TEMPSET );
85    addHash( "thermalTime",   G_THERMALTIME );
86    addHash( "mixingRule",    G_MIXINGRULE);
87 <  addHash( "periodicBox",   G_USEPBC);
88 <  
87 >  addHash( "usePeriodicBoundaryConditions",        G_USEPBC);
88 >  addHash( "electrostaticSkinThickness",           G_EST );
89 >  addHash( "useReactionField",                     G_USERF );
90 >  addHash( "targetPressure",                       G_TARGETPRESSURE);
91 >  addHash( "tauThermostat",                        G_TAUTHERMOSTAT);
92 >  addHash( "tauBarostat",                          G_TAUBAROSTAT);
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.
103    usePBC = 1; //default  periodic boundry conditions to on
104 +  useRF  = 0;
105    
85 –
106    have_force_field =  0;
107    have_n_components = 0;
108    have_target_temp =  0;
# Line 102 | Line 122 | Globals::Globals(){
122    have_sample_time =    0;
123    have_status_time =    0;
124    have_thermal_time =   0;
125 <  have_rrf =            0;
125 >  have_ecr =            0;
126    have_dielectric =     0;
127    have_tempSet =        0;
128 < }
128 >  have_est =            0;
129 >  have_target_pressure =0;
130 >  have_q_mass =         0;
131 >  have_tau_thermostat = 0;
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 179 | Line 210 | int Globals::componentStartIndex( 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 240 | Line 334 | int Globals::globalAssign( event* the_event ){
334          n_components = the_event->evt.asmt.rhs.ival;
335          components = new Component*[n_components];
336          have_n_components = 1;
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;
# Line 610 | 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 639 | Line 755 | int Globals::globalAssign( event* the_event ){
755        }
756        break;
757        
758 <    case G_RRF:
758 >    case G_ECR:
759        switch( the_type ){
760          
761        case STRING:
762          the_event->err_msg =
763 <          strdup( "Global error. rRF is not a double or int.\n" );
763 >          strdup( "Global error. electrostaticCutoffRadius is not a double or int.\n" );
764          return 0;
765          break;
766          
767        case DOUBLE:
768 <        rRF = the_event->evt.asmt.rhs.dval;
769 <        have_rrf = 1;
768 >        ecr = the_event->evt.asmt.rhs.dval;
769 >        have_ecr = 1;
770          return 1;
771          break;
772          
773        case INT:
774 <        rRF = (double)the_event->evt.asmt.rhs.ival;
775 <        have_rrf = 1;
774 >        ecr = (double)the_event->evt.asmt.rhs.ival;
775 >        have_ecr = 1;
776          return 1;
777          break;
778          
779        default:
780          the_event->err_msg =
781 <          strdup( "Global error. rRF unrecognized.\n" );
781 >          strdup( "Global error. electrostaticCutoffRadius unrecognized.\n" );
782          return 0;
783          break;
784        }
785        break;
786 +
787 +    case G_EST:
788 +      switch( the_type ){
789 +        
790 +      case STRING:
791 +        the_event->err_msg =
792 +          strdup( "Global error. electrostaticSkinThickness is not a double or int.\n" );
793 +        return 0;
794 +        break;
795 +        
796 +      case DOUBLE:
797 +        est = the_event->evt.asmt.rhs.dval;
798 +        have_est = 1;
799 +        return 1;
800 +        break;
801 +        
802 +      case INT:
803 +        est = (double)the_event->evt.asmt.rhs.ival;
804 +        have_est = 1;
805 +        return 1;
806 +        break;
807 +        
808 +      default:
809 +        the_event->err_msg =
810 +          strdup( "Global error. electrostaticSkinThickness unrecognized.\n" );
811 +        return 0;
812 +        break;
813 +      }
814 +      break;
815        
816      case G_DIELECTRIC:
817        switch( the_type ){
# Line 700 | Line 845 | int Globals::globalAssign( event* the_event ){
845      case G_TEMPSET:
846        if( the_type == STRING ){
847          
848 <        if( !strcmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
849 <        else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
848 >        if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
849 >        else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
850          else{
851            the_event->err_msg =
852              strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
# Line 719 | Line 864 | int Globals::globalAssign( event* the_event ){
864      case G_USEPBC:
865        if( the_type == STRING ){
866          
867 <        if( !strcmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
868 <        else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
867 >        if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
868 >        else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
869          else{
870            the_event->err_msg =
871 <            strdup( "Global error. periodicBoundryConditions was not \"true\" or \"false\".\n" );
871 >            strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
872            return 0;
873          }
874          return 1;
875        }
876        
877        the_event->err_msg =
878 <        strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
878 >        strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
879 >      return 0;
880 >      break;
881 >
882 >    case G_USERF:
883 >      if( the_type == STRING ){
884 >        
885 >        if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
886 >        else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0;
887 >        else{
888 >          the_event->err_msg =
889 >            strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
890 >          return 0;
891 >        }
892 >        return 1;
893 >      }
894 >      
895 >      the_event->err_msg =
896 >        strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
897        return 0;
898        break;
899 +
900 +    case G_TARGETPRESSURE:
901 +      switch( the_type ){
902 +        
903 +      case STRING:
904 +        the_event->err_msg =
905 +          strdup( "Global error. targetPressure is not a double or int.\n" );
906 +        return 0;
907 +        break;
908 +        
909 +      case DOUBLE:
910 +        target_pressure = the_event->evt.asmt.rhs.dval;
911 +        have_target_pressure = 1;
912 +        return 1;
913 +        break;
914 +        
915 +      case INT:
916 +        target_pressure = (double)the_event->evt.asmt.rhs.ival;
917 +        have_target_pressure = 1;
918 +        return 1;
919 +        break;
920 +        
921 +      default:
922 +        the_event->err_msg =
923 +          strdup( "Global error. targetPressure unrecognized.\n" );
924 +        return 0;
925 +        break;
926 +      }
927 +      break;
928 +
929 +    case G_TAUTHERMOSTAT:
930 +      switch( the_type ){
931 +        
932 +      case STRING:
933 +        the_event->err_msg =
934 +          strdup( "Global error. tauThermostat is not a double or int.\n" );
935 +        return 0;
936 +        break;
937 +        
938 +      case DOUBLE:
939 +        tau_thermostat = the_event->evt.asmt.rhs.dval;
940 +        have_tau_thermostat = 1;
941 +        return 1;
942 +        break;
943 +        
944 +      case INT:
945 +        tau_thermostat = (double)the_event->evt.asmt.rhs.ival;
946 +        have_tau_thermostat = 1;
947 +        return 1;
948 +        break;
949 +        
950 +      default:
951 +        the_event->err_msg =
952 +          strdup( "Global error. tauThermostat unrecognized.\n" );
953 +        return 0;
954 +        break;
955 +      }
956 +      break;
957 +
958 +    case G_TAUBAROSTAT:
959 +      switch( the_type ){
960 +        
961 +      case STRING:
962 +        the_event->err_msg =
963 +          strdup( "Global error. tauBarostat is not a double or int.\n" );
964 +        return 0;
965 +        break;
966 +        
967 +      case DOUBLE:
968 +        tau_barostat = the_event->evt.asmt.rhs.dval;
969 +        have_tau_barostat = 1;
970 +        return 1;
971 +        break;
972 +        
973 +      case INT:
974 +        tau_barostat = (double)the_event->evt.asmt.rhs.ival;
975 +        have_tau_barostat = 1;
976 +        return 1;
977 +        break;
978 +        
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