ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1260
Committed: Fri Jun 11 14:13:54 2004 UTC (20 years ago) by gezelter
File size: 41917 byte(s)
Log Message: 
Added forceFieldVariant global

File Contents

# User Rev Content
1 gezelter 828 #include <stdlib.h>
2     #include <stdio.h>
3     #include <string.h>
4 mmeineke 377
5     #include "Globals.hpp"
6     #include "simError.h"
7     #ifdef IS_MPI
8     #include "mpiBASS.h"
9     #endif // is_mpi
10    
11     /*
12     * The following section lists all of the defined tokens for the
13     * gloabal assignment statements. All are prefixed with a G_ to avoid
14     * stepping on any previously defined enumerations.
15     *
16     * NOTE: tokens start at 1, 0 is a resrved token number
17     */
18    
19     //required parameters
20 gezelter 957 #define G_FORCEFIELD 1
21     #define G_NCOMPONENTS 2
22     #define G_TARGETTEMP 3
23     #define G_ENSEMBLE 4
24     #define G_DT 5
25     #define G_RUNTIME 6
26 mmeineke 377
27     //optional parameters
28 gezelter 957 #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 gezelter 1153 #define G_RCUT 17
39     #define G_RSW 18
40     #define G_DIELECTRIC 19
41     #define G_TEMPSET 20
42     #define G_THERMALTIME 21
43     #define G_USEPBC 22
44     #define G_MIXINGRULE 23
45 gezelter 957 #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     #define G_RESETTIME 33
55     #define G_USEINITTIME 34
56     #define G_USEINIT_XS_STATE 35
57 mmeineke 855 #define G_ORTHOBOXTOLERANCE 36
58 gezelter 1153 #define G_MINIMIZER 37
59     #define G_MIN_MAXITER 38
60     #define G_MIN_WRITEFRQ 39
61     #define G_MIN_STEPSIZE 40
62     #define G_MIN_FTOL 41
63     #define G_MIN_GTOL 42
64     #define G_MIN_LSTOL 43
65     #define G_MIN_LSMAXITER 44
66     #define G_ZCONSGAP 45
67     #define G_ZCONSFIXTIME 46
68     #define G_ZCONSUSINGSMD 47
69 chrisfen 1210 #define G_USE_SOLID_THERM_INT 48
70     #define G_USE_LIQUID_THERM_INT 49
71     #define G_THERM_INT_LAMBDA 50
72     #define G_THERM_INT_K 51
73 gezelter 1260 #define G_FORCEFIELD_VARIANT 52
74 mmeineke 377
75     Globals::Globals(){
76    
77     int i;
78 gezelter 747
79     hash_size = 23;
80     hash_shift = 4;
81 mmeineke 377
82     components = NULL;
83    
84     command_table = new LinkedCommand*[hash_size];
85     for( i=0; i<hash_size; i++ ) command_table[i] = NULL;
86    
87     addHash( "forceField", G_FORCEFIELD );
88     addHash( "nComponents", G_NCOMPONENTS );
89     addHash( "targetTemp", G_TARGETTEMP );
90     addHash( "ensemble", G_ENSEMBLE );
91    
92     addHash( "dt", G_DT );
93     addHash( "runTime", G_RUNTIME );
94    
95     addHash( "initialConfig", G_INITIALCONFIG );
96     addHash( "finalConfig", G_FINALCONFIG );
97     addHash( "nMol", G_NMOL );
98     addHash( "density", G_DENSITY );
99     addHash( "box", G_BOX );
100     addHash( "boxX", G_BOXX );
101     addHash( "boxY", G_BOXY );
102     addHash( "boxZ", G_BOXZ );
103     addHash( "sampleTime", G_SAMPLETIME );
104 mmeineke 745 addHash( "resetTime", G_RESETTIME );
105 mmeineke 377 addHash( "statusTime", G_STATUSTIME );
106 gezelter 1153 addHash( "cutoffRadius", G_RCUT );
107     addHash( "switchingRadius", G_RSW );
108 mmeineke 377 addHash( "dielectric", G_DIELECTRIC );
109     addHash( "tempSet", G_TEMPSET );
110     addHash( "thermalTime", G_THERMALTIME );
111     addHash( "mixingRule", G_MIXINGRULE);
112 gezelter 394 addHash( "usePeriodicBoundaryConditions", G_USEPBC);
113     addHash( "useReactionField", G_USERF );
114 gezelter 465 addHash( "targetPressure", G_TARGETPRESSURE);
115 gezelter 481 addHash( "tauThermostat", G_TAUTHERMOSTAT);
116     addHash( "tauBarostat", G_TAUBAROSTAT);
117 mmeineke 675 addHash( "zconsTime", G_ZCONSTIME);
118     addHash( "nZconstraints", G_NZCONSTRAINTS);
119 mmeineke 745 addHash( "zconsTol", G_ZCONSTOL);
120     addHash( "zconsForcePolicy", G_ZCONSFORCEPOLICY);
121     addHash( "seed", G_SEED);
122 mmeineke 855 addHash( "useInitialTime", G_USEINITTIME);
123     addHash( "useInitialExtendedSystemState", G_USEINIT_XS_STATE);
124     addHash( "orthoBoxTolerance", G_ORTHOBOXTOLERANCE);
125 chrisfen 1209 addHash( "minimizer", G_MINIMIZER);
126     addHash( "minMaxIter", G_MIN_MAXITER);
127     addHash( "minWriteFrq", G_MIN_WRITEFRQ);
128     addHash( "minStepSize", G_MIN_STEPSIZE);
129     addHash( "minFTol", G_MIN_FTOL);
130     addHash( "minGTol", G_MIN_GTOL);
131     addHash( "minLSTol", G_MIN_LSTOL);
132     addHash( "minLSMaxIter", G_MIN_LSMAXITER);
133     addHash( "zconsGap", G_ZCONSGAP);
134     addHash( "zconsFixtime", G_ZCONSFIXTIME);
135     addHash( "zconsUsingSMD", G_ZCONSUSINGSMD);
136     addHash( "useSolidThermInt", G_USE_SOLID_THERM_INT);
137 chrisfen 1210 addHash( "useLiquidThermInt", G_USE_LIQUID_THERM_INT);
138 chrisfen 1209 addHash( "thermodynamicIntegrationLambda", G_THERM_INT_LAMBDA);
139     addHash( "thermodynamicIntegrationK", G_THERM_INT_K);
140 gezelter 1260 addHash( "forceFieldVariant", G_FORCEFIELD_VARIANT);
141 mmeineke 377
142     strcpy( mixingRule,"standard"); //default mixing rules to standard.
143     usePBC = 1; //default periodic boundry conditions to on
144 gezelter 394 useRF = 0;
145 mmeineke 1135 useInitTime = 0; // default to pull init time from the init file
146     useInitXSstate = 0; // default to pull the extended state from the init file
147 mmeineke 855 orthoBoxTolerance = 1E-6;
148 chrisfen 1209 useSolidThermInt = 0; // default solid-state thermodynamic integration to off
149 chrisfen 1210 useLiquidThermInt = 0; // default liquid thermodynamic integration to off
150 mmeineke 855
151 mmeineke 377 have_force_field = 0;
152     have_n_components = 0;
153     have_target_temp = 0;
154     have_ensemble = 0;
155     have_dt = 0;
156     have_run_time = 0;
157    
158     have_initial_config = 0;
159     have_final_config = 0;
160     have_n_mol = 0;
161     have_density = 0;
162     have_box = 0;
163     have_box_x = 0;
164     have_box_y = 0;
165     have_box_y = 0;
166     have_box_z = 0;
167     have_sample_time = 0;
168     have_status_time = 0;
169 mmeineke 745 have_reset_time = 0;
170 mmeineke 377 have_thermal_time = 0;
171 gezelter 1153 have_rcut = 0;
172     have_rsw = 0;
173 mmeineke 377 have_dielectric = 0;
174     have_tempSet = 0;
175 gezelter 465 have_target_pressure =0;
176 gezelter 474 have_q_mass = 0;
177 gezelter 481 have_tau_thermostat = 0;
178 mmeineke 675 have_tau_barostat = 0;
179 tim 682 have_zcons_time = 0;
180 mmeineke 675 have_n_zConstraints = 0;
181     have_zConstraints = 0;
182 tim 682 have_zcons_tol = 0;
183 tim 1093 have_zcons_gap = 0;
184     have_zcons_fixtime = 0;
185     have_zcons_using_smd = 0;
186 tim 704 have_seed = 0;
187 gezelter 1099 have_minimizer = 0;
188     have_minimizer_maxiteration = 0;
189     have_minimizer_writefrq = 0;
190     have_minimizer_stepsize = 0;
191     have_minimizer_ftol = 0;
192     have_minimizer_gtol = 0;
193     have_minimizer_ls_tol = 0;
194     have_minimizer_ls_maxiteration = 0;
195 chrisfen 1188 have_thermodynamic_integration_lambda = 0;
196     have_thermodynamic_integration_k = 0;
197 gezelter 1260 have_forcefield_variant = 0;
198 mmeineke 377
199 tim 689 }
200    
201 mmeineke 377 Globals::~Globals(){
202     int i;
203    
204     for( i=0; i<hash_size; i++ ){
205     if( command_table[i] != NULL ) delete command_table[i];
206     }
207     delete[] command_table;
208    
209     if( components != NULL ){
210     for( i=0; i<n_components; i++ ) delete components[i];
211     delete[] components;
212     }
213     }
214    
215     int Globals::newComponent( event* the_event ){
216    
217     current_component = new Component;
218     int index = the_event->evt.blk_index;
219     char err[200];
220    
221     if( have_n_components && index < n_components )
222     components[index] = current_component;
223     else{
224     if( have_n_components ){
225     sprintf( err, "Globals error, %d out of nComponents range",
226     index );
227     the_event->err_msg = strdup( err );
228     return 0;
229     }
230     else{
231     the_event->err_msg = strdup("Globals error, nComponents not given before"
232     "first component declaration." );
233     return 0;
234     }
235     }
236    
237     return 1;
238     }
239    
240    
241    
242     int Globals::componentAssign( event* the_event ){
243    
244     switch( the_event->evt.asmt.asmt_type ){
245    
246     case STRING:
247     return current_component->assignString( the_event->evt.asmt.lhs,
248     the_event->evt.asmt.rhs.sval,
249     &(the_event->err_msg));
250     break;
251    
252     case DOUBLE:
253     return current_component->assignDouble( the_event->evt.asmt.lhs,
254     the_event->evt.asmt.rhs.dval,
255     &(the_event->err_msg));
256     break;
257    
258     case INT:
259     return current_component->assignInt( the_event->evt.asmt.lhs,
260     the_event->evt.asmt.rhs.ival,
261     &(the_event->err_msg));
262     break;
263    
264     default:
265     the_event->err_msg = strdup( "Globals error. Invalid component"
266     " assignment type" );
267     return 0;
268     break;
269     }
270     return 0;
271     }
272    
273 mmeineke 675 int Globals::componentEnd( event* the_event ){
274 mmeineke 377
275 mmeineke 675 the_event->err_msg = current_component->checkMe();
276     if( the_event->err_msg != NULL ) return 0;
277    
278 mmeineke 377 return 1;
279     }
280    
281 mmeineke 675 int Globals::newZconstraint( event* the_event ){
282    
283 mmeineke 377
284 mmeineke 675 int index = the_event->evt.blk_index;
285     char err[200];
286     current_zConstraint = new ZconStamp( index );
287    
288     have_zConstraints = 1;
289    
290     if( have_n_zConstraints && index < n_zConstraints )
291     zConstraints[index] = current_zConstraint;
292     else{
293     if( have_n_zConstraints ){
294     sprintf( err, "Globals error, %d out of nZconstraints range",
295     index );
296     the_event->err_msg = strdup( err );
297     return 0;
298     }
299     else{
300     the_event->err_msg = strdup("Globals error, nZconstraints"
301     " not given before"
302     " first zConstraint declaration." );
303     return 0;
304     }
305     }
306    
307     return 1;
308     }
309    
310    
311    
312     int Globals::zConstraintAssign( event* the_event ){
313    
314     switch( the_event->evt.asmt.asmt_type ){
315    
316     case STRING:
317     return current_zConstraint->assignString( the_event->evt.asmt.lhs,
318 tim 689 the_event->evt.asmt.rhs.sval,
319     &(the_event->err_msg));
320 mmeineke 675 break;
321    
322     case DOUBLE:
323     return current_zConstraint->assignDouble( the_event->evt.asmt.lhs,
324 tim 689 the_event->evt.asmt.rhs.dval,
325     &(the_event->err_msg));
326 mmeineke 675 break;
327    
328     case INT:
329     return current_zConstraint->assignInt( the_event->evt.asmt.lhs,
330 tim 689 the_event->evt.asmt.rhs.ival,
331     &(the_event->err_msg));
332 mmeineke 675 break;
333    
334     default:
335     the_event->err_msg = strdup( "Globals error. Invalid zConstraint"
336     " assignment type" );
337     return 0;
338     break;
339     }
340     return 0;
341     }
342    
343     int Globals::zConstraintEnd( event* the_event ){
344    
345     the_event->err_msg = current_zConstraint->checkMe();
346 mmeineke 377 if( the_event->err_msg != NULL ) return 0;
347    
348     return 1;
349     }
350    
351     int Globals::globalAssign( event* the_event ){
352    
353     int key;
354     int token;
355     interface_assign_type the_type = the_event->evt.asmt.asmt_type;
356     char* lhs = the_event->evt.asmt.lhs;
357     char err[300];
358    
359     token = 0;
360     key = hash( lhs );
361     if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
362    
363     if( token ){
364    
365     switch( token ){
366    
367     case G_FORCEFIELD:
368     if( the_type == STRING ){
369     strcpy( force_field, the_event->evt.asmt.rhs.sval );
370     have_force_field = 1;
371     return 1;
372     }
373    
374     the_event->err_msg =
375     strdup( "Global error. forceField was not a string assignment.\n" );
376     return 0;
377     break;
378    
379     case G_NCOMPONENTS:
380     if( the_type == STRING ){
381     the_event->err_msg =
382     strdup("Global error. nComponents is not a double or an int.\n" );
383     return 0;
384     }
385    
386     else if( the_type == DOUBLE ){
387     n_components = (int)the_event->evt.asmt.rhs.dval;
388     components = new Component*[n_components];
389     have_n_components = 1;
390     return 1;
391     }
392    
393     else{
394     n_components = the_event->evt.asmt.rhs.ival;
395     components = new Component*[n_components];
396     have_n_components = 1;
397     return 1;
398     }
399     break;
400 mmeineke 675
401     case G_NZCONSTRAINTS:
402     if( the_type == STRING ){
403     the_event->err_msg =
404     strdup("Global error. nZconstraints is not a double or an int.\n" );
405     return 0;
406     }
407 mmeineke 377
408 mmeineke 675 else if( the_type == DOUBLE ){
409     n_zConstraints = (int)the_event->evt.asmt.rhs.dval;
410     zConstraints = new ZconStamp*[n_zConstraints];
411     have_n_zConstraints = 1;
412     return 1;
413     }
414    
415     else{
416     n_zConstraints = the_event->evt.asmt.rhs.ival;
417     zConstraints = new ZconStamp*[n_zConstraints];
418     have_n_zConstraints = 1;
419     return 1;
420     }
421     break;
422    
423 mmeineke 377 case G_TARGETTEMP:
424     switch( the_type ){
425    
426     case STRING:
427     the_event->err_msg =
428     strdup( "Global error. targetTemp is not a double or int.\n" );
429     return 0;
430     break;
431    
432     case DOUBLE:
433     target_temp = the_event->evt.asmt.rhs.dval;
434     have_target_temp = 1;
435     return 1;
436     break;
437    
438     case INT:
439     target_temp = (double)the_event->evt.asmt.rhs.ival;
440     have_target_temp = 1;
441     return 1;
442     break;
443    
444     default:
445     the_event->err_msg =
446     strdup( "Global error. targetTemp unrecognized.\n" );
447     return 0;
448     break;
449     }
450     break;
451 mmeineke 855
452     case G_ORTHOBOXTOLERANCE:
453     switch( the_type ){
454    
455     case STRING:
456     the_event->err_msg =
457     strdup( "Global error. orthoBoxTolerance is not a double or int.\n" );
458     return 0;
459     break;
460    
461     case DOUBLE:
462     orthoBoxTolerance = the_event->evt.asmt.rhs.dval;
463     have_target_temp = 1;
464     return 1;
465     break;
466    
467     case INT:
468     orthoBoxTolerance = (double)the_event->evt.asmt.rhs.ival;
469     have_target_temp = 1;
470     return 1;
471     break;
472    
473     default:
474     the_event->err_msg =
475     strdup( "Global error.orthoBoxTolerance unrecognized.\n" );
476     return 0;
477     break;
478     }
479     break;
480 mmeineke 377
481     case G_ENSEMBLE:
482     if( the_type == STRING ){
483     strcpy( ensemble, the_event->evt.asmt.rhs.sval );
484     have_ensemble = 1;
485     return 1;
486     }
487    
488     the_event->err_msg =
489     strdup( "Global error. ensemble was not assigned to a string\n" );
490     return 0;
491     break;
492    
493     case G_MIXINGRULE:
494     if( the_type == STRING ){
495     strcpy( mixingRule, the_event->evt.asmt.rhs.sval );
496     return 1;
497     }
498    
499     the_event->err_msg =
500     strdup( "Global error. mixing rule was not assigned to a string\n" );
501     return 0;
502     break;
503    
504     case G_DT:
505     switch( the_type ){
506    
507     case STRING:
508     the_event->err_msg =
509     strdup( "Global error. dt is not a double or int.\n" );
510     return 0;
511     break;
512    
513     case DOUBLE:
514     dt = the_event->evt.asmt.rhs.dval;
515     have_dt = 1;
516     return 1;
517     break;
518    
519     case INT:
520     dt = (double)the_event->evt.asmt.rhs.ival;
521     have_dt = 1;
522     return 1;
523     break;
524    
525     default:
526     the_event->err_msg =
527     strdup( "Global error. dt unrecognized.\n" );
528     return 0;
529     break;
530     }
531     break;
532    
533     case G_RUNTIME:
534     switch( the_type ){
535    
536     case STRING:
537     the_event->err_msg =
538     strdup( "Global error. runTime is not a double or int.\n" );
539     return 0;
540     break;
541    
542     case DOUBLE:
543     run_time = the_event->evt.asmt.rhs.dval;
544     have_run_time = 1;
545     return 1;
546     break;
547    
548     case INT:
549     run_time = (double)the_event->evt.asmt.rhs.ival;
550     have_run_time = 1;
551     return 1;
552     break;
553    
554     default:
555     the_event->err_msg =
556     strdup( "Global error. runTime unrecognized.\n" );
557     return 0;
558     break;
559     }
560     break;
561    
562     case G_INITIALCONFIG:
563     if( the_type == STRING ){
564     strcpy( initial_config, the_event->evt.asmt.rhs.sval );
565     have_initial_config = 1;
566     return 1;
567     }
568    
569     the_event->err_msg =
570     strdup( "Global error. initialConfig was not a string assignment.\n" );
571     return 0;
572     break;
573    
574     case G_FINALCONFIG:
575     if( the_type == STRING ){
576     strcpy( final_config, the_event->evt.asmt.rhs.sval );
577     have_final_config = 1;
578     return 1;
579     }
580    
581     the_event->err_msg =
582     strdup( "Global error. finalConfig was not a string assignment.\n" );
583     return 0;
584     break;
585    
586     case G_NMOL:
587     switch( the_type ){
588    
589     case STRING:
590     the_event->err_msg =
591     strdup( "Global error. nMol is not a double or int.\n" );
592     return 0;
593     break;
594    
595     case DOUBLE:
596     n_mol = (int)the_event->evt.asmt.rhs.dval;
597     have_n_mol = 1;
598     return 1;
599     break;
600    
601     case INT:
602     n_mol = the_event->evt.asmt.rhs.ival;
603     have_n_mol = 1;
604     return 1;
605     break;
606    
607     default:
608     the_event->err_msg =
609     strdup( "Global error. nMol unrecognized.\n" );
610     return 0;
611     break;
612     }
613     break;
614    
615     case G_DENSITY:
616     switch( the_type ){
617    
618     case STRING:
619     the_event->err_msg =
620     strdup( "Global error. density is not a double or int.\n" );
621     return 0;
622     break;
623    
624     case DOUBLE:
625     density = the_event->evt.asmt.rhs.dval;
626     have_density = 1;
627     return 1;
628     break;
629    
630     case INT:
631     density = (double)the_event->evt.asmt.rhs.ival;
632     have_density = 1;
633     return 1;
634     break;
635    
636     default:
637     the_event->err_msg =
638     strdup( "Global error. density unrecognized.\n" );
639     return 0;
640     break;
641     }
642     break;
643    
644     case G_BOX:
645     switch( the_type ){
646    
647     case STRING:
648     the_event->err_msg =
649     strdup( "Global error. box is not a double or int.\n" );
650     return 0;
651     break;
652    
653     case DOUBLE:
654     box = the_event->evt.asmt.rhs.dval;
655     have_box = 1;
656     return 1;
657     break;
658    
659     case INT:
660     box = (double)the_event->evt.asmt.rhs.ival;
661     have_box = 1;
662     return 1;
663     break;
664    
665     default:
666     the_event->err_msg =
667     strdup( "Global error. box unrecognized.\n" );
668     return 0;
669     break;
670     }
671     break;
672    
673     case G_BOXX:
674     switch( the_type ){
675    
676     case STRING:
677     the_event->err_msg =
678     strdup( "Global error. boxX is not a double or int.\n" );
679     return 0;
680     break;
681    
682     case DOUBLE:
683     box_x = the_event->evt.asmt.rhs.dval;
684     have_box_x = 1;
685     return 1;
686     break;
687    
688     case INT:
689     box_x = (double)the_event->evt.asmt.rhs.ival;
690     have_box_x = 1;
691     return 1;
692     break;
693    
694     default:
695     the_event->err_msg =
696     strdup( "Global error. boxX unrecognized.\n" );
697     return 0;
698     break;
699     }
700     break;
701    
702     case G_BOXY:
703     switch( the_type ){
704    
705     case STRING:
706     the_event->err_msg =
707     strdup( "Global error. boxY is not a double or int.\n" );
708     return 0;
709     break;
710    
711     case DOUBLE:
712     box_y = the_event->evt.asmt.rhs.dval;
713     have_box_y = 1;
714     return 1;
715     break;
716    
717     case INT:
718     box_y = (double)the_event->evt.asmt.rhs.ival;
719     have_box_y = 1;
720     return 1;
721     break;
722    
723     default:
724     the_event->err_msg =
725     strdup( "Global error. boxY unrecognized.\n" );
726     return 0;
727     break;
728     }
729     break;
730    
731     case G_BOXZ:
732     switch( the_type ){
733    
734     case STRING:
735     the_event->err_msg =
736     strdup( "Global error. boxZ is not a double or int.\n" );
737     return 0;
738     break;
739    
740     case DOUBLE:
741     box_z = the_event->evt.asmt.rhs.dval;
742     have_box_z = 1;
743     return 1;
744     break;
745    
746     case INT:
747     box_z = (double)the_event->evt.asmt.rhs.ival;
748     have_box_z = 1;
749     return 1;
750     break;
751    
752     default:
753     the_event->err_msg =
754     strdup( "Global error. boxZ unrecognized.\n" );
755     return 0;
756     break;
757     }
758     break;
759    
760     case G_SAMPLETIME:
761     switch( the_type ){
762    
763     case STRING:
764     the_event->err_msg =
765     strdup( "Global error. sampleTime is not a double or int.\n" );
766     return 0;
767     break;
768    
769     case DOUBLE:
770     sample_time = the_event->evt.asmt.rhs.dval;
771     have_sample_time = 1;
772     return 1;
773     break;
774    
775     case INT:
776     sample_time = (double)the_event->evt.asmt.rhs.ival;
777     have_sample_time = 1;
778     return 1;
779     break;
780    
781     default:
782     the_event->err_msg =
783     strdup( "Global error. sampleTime unrecognized.\n" );
784     return 0;
785     break;
786     }
787     break;
788    
789     case G_STATUSTIME:
790     switch( the_type ){
791    
792     case STRING:
793     the_event->err_msg =
794     strdup( "Global error. statusTime is not a double or int.\n" );
795     return 0;
796     break;
797    
798     case DOUBLE:
799     status_time = the_event->evt.asmt.rhs.dval;
800     have_status_time = 1;
801     return 1;
802     break;
803    
804     case INT:
805     status_time = (double)the_event->evt.asmt.rhs.ival;
806     have_status_time = 1;
807     return 1;
808     break;
809    
810     default:
811     the_event->err_msg =
812     strdup( "Global error. statusTime unrecognized.\n" );
813     return 0;
814     break;
815     }
816     break;
817    
818 mmeineke 745 case G_RESETTIME:
819     switch( the_type ){
820    
821     case STRING:
822     the_event->err_msg =
823     strdup( "Global error. resetTime is not a double or int.\n" );
824     return 0;
825     break;
826    
827     case DOUBLE:
828     resetTime = the_event->evt.asmt.rhs.dval;
829     have_reset_time = 1;
830     return 1;
831     break;
832    
833     case INT:
834     resetTime = (double)the_event->evt.asmt.rhs.ival;
835     have_reset_time = 1;
836     return 1;
837     break;
838    
839     default:
840     the_event->err_msg =
841     strdup( "Global error. resetTime unrecognized.\n" );
842     return 0;
843     break;
844     }
845     break;
846    
847 tim 689 case G_THERMALTIME:
848 mmeineke 377 switch( the_type ){
849    
850     case STRING:
851     the_event->err_msg =
852     strdup( "Global error. thermalTime is not a double or int.\n" );
853     return 0;
854     break;
855    
856     case DOUBLE:
857     thermal_time = the_event->evt.asmt.rhs.dval;
858     have_thermal_time = 1;
859     return 1;
860     break;
861    
862     case INT:
863     thermal_time = (double)the_event->evt.asmt.rhs.ival;
864     have_thermal_time = 1;
865     return 1;
866     break;
867    
868     default:
869     the_event->err_msg =
870     strdup( "Global error. thermalTime unrecognized.\n" );
871     return 0;
872     break;
873     }
874     break;
875    
876 gezelter 1153 case G_RCUT:
877 mmeineke 377 switch( the_type ){
878    
879     case STRING:
880     the_event->err_msg =
881 gezelter 1153 strdup( "Global error. cutoffRadius is not a double or int.\n" );
882 mmeineke 377 return 0;
883     break;
884    
885     case DOUBLE:
886 gezelter 1153 rcut = the_event->evt.asmt.rhs.dval;
887     have_rcut = 1;
888 mmeineke 377 return 1;
889     break;
890    
891     case INT:
892 gezelter 1153 rcut = (double)the_event->evt.asmt.rhs.ival;
893     have_rcut = 1;
894 mmeineke 377 return 1;
895     break;
896    
897     default:
898     the_event->err_msg =
899 gezelter 1153 strdup( "Global error. cutoffRadius unrecognized.\n" );
900 mmeineke 377 return 0;
901     break;
902     }
903     break;
904 gezelter 394
905 gezelter 1153 case G_RSW:
906 gezelter 394 switch( the_type ){
907    
908     case STRING:
909     the_event->err_msg =
910 gezelter 1153 strdup( "Global error. switchingRadius is not a double or int.\n" );
911 gezelter 394 return 0;
912     break;
913    
914     case DOUBLE:
915 gezelter 1153 rsw = the_event->evt.asmt.rhs.dval;
916     have_rsw = 1;
917 gezelter 394 return 1;
918     break;
919    
920     case INT:
921 gezelter 1153 rsw = (double)the_event->evt.asmt.rhs.ival;
922     have_rsw = 1;
923 gezelter 394 return 1;
924     break;
925    
926     default:
927     the_event->err_msg =
928 gezelter 1153 strdup( "Global error. switchingRadius unrecognized.\n" );
929 gezelter 394 return 0;
930     break;
931     }
932     break;
933 mmeineke 377
934     case G_DIELECTRIC:
935     switch( the_type ){
936    
937     case STRING:
938     the_event->err_msg =
939     strdup( "Global error. dielectric is not a double or int.\n" );
940     return 0;
941     break;
942    
943     case DOUBLE:
944     dielectric = the_event->evt.asmt.rhs.dval;
945     have_dielectric = 1;
946     return 1;
947     break;
948    
949     case INT:
950     dielectric = (double)the_event->evt.asmt.rhs.ival;
951     have_dielectric = 1;
952     return 1;
953     break;
954    
955     default:
956     the_event->err_msg =
957     strdup( "Global error. dielectric unrecognized.\n" );
958     return 0;
959     break;
960     }
961     break;
962    
963     case G_TEMPSET:
964     if( the_type == STRING ){
965    
966 gezelter 465 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
967     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
968 mmeineke 377 else{
969     the_event->err_msg =
970     strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
971     return 0;
972     }
973     have_tempSet = 1;
974     return 1;
975     }
976    
977     the_event->err_msg =
978     strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
979     return 0;
980     break;
981 mmeineke 811
982     case G_USEINITTIME:
983     if( the_type == STRING ){
984    
985     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useInitTime = 1;
986     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useInitTime = 0;
987     else{
988     the_event->err_msg =
989     strdup( "Global error. useInitTime was not \"true\" or \"false\".\n" );
990     return 0;
991     }
992     return 1;
993     }
994 mmeineke 377
995 mmeineke 811 the_event->err_msg =
996     strdup( "Global error. useInitTime was not \"true\" or \"false\".\n" );
997     return 0;
998     break;
999 mmeineke 855
1000     case G_USEINIT_XS_STATE:
1001     if( the_type == STRING ){
1002    
1003     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval ))
1004     useInitXSstate = 1;
1005     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval ))
1006     useInitXSstate = 0;
1007     else{
1008     the_event->err_msg =
1009     strdup( "Global error. useInitExtendedSystemState was not \"true\" or \"false\".\n" );
1010     return 0;
1011     }
1012     return 1;
1013     }
1014 mmeineke 811
1015 mmeineke 855 the_event->err_msg =
1016     strdup( "Global error. useInitExtendedSystemState was not \"true\" or \"false\".\n" );
1017     return 0;
1018     break;
1019    
1020 mmeineke 377 case G_USEPBC:
1021     if( the_type == STRING ){
1022    
1023 gezelter 465 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
1024     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
1025 mmeineke 377 else{
1026     the_event->err_msg =
1027 gezelter 394 strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
1028 mmeineke 377 return 0;
1029     }
1030     return 1;
1031     }
1032    
1033     the_event->err_msg =
1034 gezelter 394 strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
1035 mmeineke 377 return 0;
1036     break;
1037 gezelter 394
1038     case G_USERF:
1039     if( the_type == STRING ){
1040    
1041 gezelter 465 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
1042     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0;
1043 gezelter 394 else{
1044     the_event->err_msg =
1045     strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
1046     return 0;
1047     }
1048     return 1;
1049     }
1050    
1051     the_event->err_msg =
1052     strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
1053     return 0;
1054     break;
1055    
1056 gezelter 465 case G_TARGETPRESSURE:
1057     switch( the_type ){
1058    
1059     case STRING:
1060     the_event->err_msg =
1061     strdup( "Global error. targetPressure is not a double or int.\n" );
1062     return 0;
1063     break;
1064    
1065     case DOUBLE:
1066     target_pressure = the_event->evt.asmt.rhs.dval;
1067     have_target_pressure = 1;
1068     return 1;
1069     break;
1070    
1071     case INT:
1072     target_pressure = (double)the_event->evt.asmt.rhs.ival;
1073     have_target_pressure = 1;
1074     return 1;
1075     break;
1076    
1077     default:
1078     the_event->err_msg =
1079     strdup( "Global error. targetPressure unrecognized.\n" );
1080     return 0;
1081     break;
1082     }
1083     break;
1084 gezelter 394
1085 gezelter 481 case G_TAUTHERMOSTAT:
1086 gezelter 474 switch( the_type ){
1087    
1088     case STRING:
1089     the_event->err_msg =
1090 gezelter 481 strdup( "Global error. tauThermostat is not a double or int.\n" );
1091 gezelter 474 return 0;
1092     break;
1093    
1094     case DOUBLE:
1095 gezelter 481 tau_thermostat = the_event->evt.asmt.rhs.dval;
1096     have_tau_thermostat = 1;
1097 gezelter 474 return 1;
1098     break;
1099    
1100     case INT:
1101 gezelter 481 tau_thermostat = (double)the_event->evt.asmt.rhs.ival;
1102     have_tau_thermostat = 1;
1103 gezelter 474 return 1;
1104     break;
1105    
1106     default:
1107     the_event->err_msg =
1108 gezelter 481 strdup( "Global error. tauThermostat unrecognized.\n" );
1109 gezelter 474 return 0;
1110     break;
1111     }
1112     break;
1113    
1114 gezelter 481 case G_TAUBAROSTAT:
1115     switch( the_type ){
1116    
1117     case STRING:
1118     the_event->err_msg =
1119     strdup( "Global error. tauBarostat is not a double or int.\n" );
1120     return 0;
1121     break;
1122    
1123     case DOUBLE:
1124     tau_barostat = the_event->evt.asmt.rhs.dval;
1125     have_tau_barostat = 1;
1126     return 1;
1127     break;
1128    
1129     case INT:
1130     tau_barostat = (double)the_event->evt.asmt.rhs.ival;
1131     have_tau_barostat = 1;
1132     return 1;
1133     break;
1134    
1135     default:
1136     the_event->err_msg =
1137     strdup( "Global error. tauBarostat unrecognized.\n" );
1138     return 0;
1139     break;
1140     }
1141     break;
1142 tim 659
1143 tim 689 case G_ZCONSTIME:
1144 tim 659 switch( the_type ){
1145    
1146     case STRING:
1147     the_event->err_msg =
1148     strdup( "Global error. zcons_time is not a double or int.\n" );
1149     return 0;
1150     break;
1151    
1152     case DOUBLE:
1153     zcons_time = the_event->evt.asmt.rhs.dval;
1154 tim 682 have_zcons_time = 1;
1155 tim 659 return 1;
1156     break;
1157    
1158     case INT:
1159     zcons_time = (double)the_event->evt.asmt.rhs.ival;
1160 tim 682 have_zcons_time = 1;
1161 tim 659 return 1;
1162     break;
1163    
1164     default:
1165     the_event->err_msg =
1166     strdup( "Global error. zcons_time unrecognized.\n" );
1167     return 0;
1168     break;
1169     }
1170     break;
1171 tim 682
1172 tim 689 case G_ZCONSTOL:
1173 tim 682 switch( the_type ){
1174    
1175     case STRING:
1176     the_event->err_msg =
1177     strdup( "Global error. zcons_tol is not a double or int.\n" );
1178     return 0;
1179     break;
1180    
1181     case DOUBLE:
1182     zcons_tol = the_event->evt.asmt.rhs.dval;
1183     have_zcons_tol = 1;
1184     return 1;
1185     break;
1186    
1187     case INT:
1188     zcons_tol = (double)the_event->evt.asmt.rhs.ival;
1189     have_zcons_tol = 1;
1190     return 1;
1191     break;
1192    
1193     default:
1194     the_event->err_msg =
1195     strdup( "Global error. zcons_ol unrecognized.\n" );
1196     return 0;
1197     break;
1198     }
1199     break;
1200 tim 659
1201 tim 699 case G_ZCONSFORCEPOLICY:
1202     switch( the_type ){
1203    
1204     case STRING:
1205     strcpy(zconsForcePolicy, the_event->evt.asmt.rhs.sval);
1206 gezelter 481
1207 tim 699 for(int i = 0; zconsForcePolicy[i] != '\0'; i++)
1208     {
1209     zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1210     }
1211     have_zcons_force_policy = 1;
1212     return 1;
1213     break;
1214    
1215     case DOUBLE:
1216     the_event->err_msg =
1217     strdup( "Global error. zconsForcePolicy is not a double or int.\n" );
1218     return 0;
1219     break;
1220    
1221     case INT:
1222     the_event->err_msg =
1223     strdup( "Global error. zconsForcePolicy is not a double or int.\n" );
1224     return 0;
1225     break;
1226    
1227     default:
1228     the_event->err_msg =
1229     strdup( "Global error. zconsForcePolicy unrecognized.\n" );
1230     return 0;
1231     break;
1232     }
1233     break;
1234 tim 1091
1235     case G_ZCONSGAP:
1236     switch( the_type ){
1237    
1238     case STRING:
1239     the_event->err_msg =
1240     strdup( "Global error. zcons_gap is not a double or int.\n" );
1241     return 0;
1242     break;
1243    
1244     case DOUBLE:
1245     zcons_gap = the_event->evt.asmt.rhs.dval;
1246     have_zcons_gap= 1;
1247     return 1;
1248     break;
1249    
1250     case INT:
1251     zcons_gap= (double)the_event->evt.asmt.rhs.ival;
1252     have_zcons_gap= 1;
1253     return 1;
1254     break;
1255    
1256     default:
1257     the_event->err_msg =
1258     strdup( "Global error. zcons_gap unrecognized.\n" );
1259     return 0;
1260     break;
1261     }
1262     break;
1263 tim 1031
1264 tim 1091 case G_ZCONSFIXTIME:
1265     switch( the_type ){
1266    
1267     case STRING:
1268     the_event->err_msg =
1269     strdup( "Global error. zcons_fixtime is not a double or int.\n" );
1270     return 0;
1271     break;
1272    
1273     case DOUBLE:
1274     zcons_fixtime= the_event->evt.asmt.rhs.dval;
1275     have_zcons_fixtime= 1;
1276     return 1;
1277     break;
1278    
1279     case INT:
1280     zcons_fixtime= (double)the_event->evt.asmt.rhs.ival;
1281     have_zcons_fixtime= 1;
1282     return 1;
1283     break;
1284    
1285     default:
1286     the_event->err_msg =
1287     strdup( "Global error. zcons_fixtime unrecognized.\n" );
1288     return 0;
1289     break;
1290     }
1291     break;
1292 tim 1093
1293     case G_ZCONSUSINGSMD:
1294     switch( the_type ){
1295    
1296     case STRING:
1297     the_event->err_msg =
1298     strdup( "Global error. zcons_fixtime is not an int.\n" );
1299     return 0;
1300     break;
1301    
1302     case DOUBLE:
1303     the_event->err_msg =
1304     strdup( "Global error. zcons_fixtime is not an int.\n" );
1305     return 0;
1306     break;
1307    
1308     case INT:
1309     zcons_using_smd= the_event->evt.asmt.rhs.ival;
1310     have_zcons_using_smd= 1;
1311     return 1;
1312     break;
1313    
1314     default:
1315     the_event->err_msg =
1316     strdup( "Global error. zcons_usingsmd unrecognized.\n" );
1317     return 0;
1318     break;
1319     }
1320     break;
1321 tim 1091
1322 tim 1031 case G_MINIMIZER:
1323     switch( the_type ){
1324    
1325     case STRING:
1326     strcpy(minimizer_name, the_event->evt.asmt.rhs.sval);
1327    
1328     for(int i = 0; zconsForcePolicy[i] != '\0'; i++){
1329     zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1330     }
1331     have_minimizer= 1;
1332     return 1;
1333     break;
1334    
1335     case DOUBLE:
1336     the_event->err_msg =
1337     strdup( "Global error. minimizer_name is not a double or int.\n" );
1338     return 0;
1339     break;
1340    
1341     case INT:
1342     the_event->err_msg =
1343     strdup( "Global error. minimizer_name is not a double or int.\n" );
1344     return 0;
1345     break;
1346    
1347     default:
1348     the_event->err_msg =
1349     strdup( "Global error. minimizer_name unrecognized.\n" );
1350     return 0;
1351     break;
1352     }
1353     break;
1354    
1355     case G_MIN_MAXITER:
1356     switch( the_type ){
1357    
1358     case STRING:
1359     the_event->err_msg =
1360     strdup( "Global error. minimizer_maxiteration is not a double or int.\n" );
1361     return 1;
1362     break;
1363    
1364     case DOUBLE:
1365 gezelter 1252 minimizer_maxiteration = (int)the_event->evt.asmt.rhs.dval;
1366 tim 1031 have_minimizer_maxiteration = 1;
1367     return 1;
1368     break;
1369    
1370     case INT:
1371     minimizer_maxiteration = the_event->evt.asmt.rhs.ival;
1372     have_minimizer_maxiteration = 1;
1373     return 1;
1374     break;
1375    
1376     default:
1377     the_event->err_msg =
1378     strdup( "Global error. minimizer_maxiteration unrecognized.\n" );
1379     return 0;
1380     break;
1381     }
1382     break;
1383    
1384     case G_MIN_WRITEFRQ:
1385     switch( the_type ){
1386    
1387     case STRING:
1388     the_event->err_msg =
1389     strdup( "Global error. minimizer_writefrq is not a double or int.\n" );
1390     return 1;
1391     break;
1392    
1393     case DOUBLE:
1394     minimizer_writefrq= the_event->evt.asmt.rhs.dval;
1395     have_minimizer_writefrq = 1;
1396     return 1;
1397     break;
1398    
1399     case INT:
1400     minimizer_writefrq= the_event->evt.asmt.rhs.ival;
1401     have_minimizer_writefrq = 1;
1402     return 1;
1403     break;
1404    
1405     default:
1406     the_event->err_msg =
1407     strdup( "Global error. minimizer_writefrq unrecognized.\n" );
1408     return 0;
1409     break;
1410     }
1411     break;
1412    
1413 tim 1066 case G_MIN_STEPSIZE:
1414 tim 1031 switch( the_type ){
1415    
1416     case STRING:
1417     the_event->err_msg =
1418     strdup( "Global error. minimizer_resetfrq is not a double or int.\n" );
1419     return 1;
1420     break;
1421    
1422     case DOUBLE:
1423 tim 1066 minimizer_stepsize= the_event->evt.asmt.rhs.dval;
1424     have_minimizer_stepsize = 1;
1425 tim 1031 return 1;
1426     break;
1427    
1428     case INT:
1429 tim 1066 minimizer_stepsize= the_event->evt.asmt.rhs.ival;
1430     have_minimizer_stepsize = 1;
1431 tim 1031 return 1;
1432     break;
1433    
1434     default:
1435     the_event->err_msg =
1436     strdup( "Global error. minimizer_resetfrq unrecognized.\n" );
1437     return 0;
1438     break;
1439     }
1440     break;
1441    
1442     case G_MIN_FTOL:
1443     switch( the_type ){
1444    
1445     case STRING:
1446     the_event->err_msg =
1447     strdup( "Global error. minimizer_ftol is not a double or int.\n" );
1448     return 1;
1449     break;
1450    
1451     case DOUBLE:
1452     minimizer_ftol= the_event->evt.asmt.rhs.dval;
1453     have_minimizer_ftol = 1;
1454     return 1;
1455     break;
1456    
1457     case INT:
1458     minimizer_ftol= the_event->evt.asmt.rhs.ival;
1459     have_minimizer_ftol = 1;
1460     return 1;
1461     break;
1462    
1463     default:
1464     the_event->err_msg =
1465     strdup( "Global error. minimizer_ftol unrecognized.\n" );
1466     return 0;
1467     break;
1468     }
1469     break;
1470    
1471     case G_MIN_GTOL:
1472     switch( the_type ){
1473    
1474     case STRING:
1475     the_event->err_msg =
1476     strdup( "Global error. minimizer_gtol is not a double or int.\n" );
1477     return 1;
1478     break;
1479    
1480     case DOUBLE:
1481     minimizer_gtol= the_event->evt.asmt.rhs.dval;
1482     have_minimizer_gtol = 1;
1483     return 1;
1484     break;
1485    
1486     case INT:
1487     minimizer_gtol= the_event->evt.asmt.rhs.ival;
1488     have_minimizer_gtol = 1;
1489     return 1;
1490     break;
1491    
1492     default:
1493     the_event->err_msg =
1494     strdup( "Global error. minimizer_gtol unrecognized.\n" );
1495     return 0;
1496     break;
1497     }
1498     break;
1499    
1500     case G_MIN_LSMAXITER:
1501     switch( the_type ){
1502    
1503     case STRING:
1504     the_event->err_msg =
1505     strdup( "Global error. minimizer_ls_maxiteration is not a double or int.\n" );
1506     return 1;
1507     break;
1508    
1509     case DOUBLE:
1510     minimizer_ls_maxiteration = the_event->evt.asmt.rhs.dval;
1511     have_minimizer_ls_maxiteration = 1;
1512     return 1;
1513     break;
1514    
1515     case INT:
1516     minimizer_ls_maxiteration = the_event->evt.asmt.rhs.ival;
1517     have_minimizer_ls_maxiteration = 1;
1518     return 1;
1519     break;
1520    
1521     default:
1522     the_event->err_msg =
1523     strdup( "Global error. minimizer_ls_maxiteration unrecognized.\n" );
1524     return 0;
1525     break;
1526     }
1527     break;
1528    
1529     case G_MIN_LSTOL:
1530     switch( the_type ){
1531    
1532     case STRING:
1533     the_event->err_msg =
1534     strdup( "Global error. minimizer_ls_tol is not a double or int.\n" );
1535     return 1;
1536     break;
1537    
1538     case DOUBLE:
1539     minimizer_ls_tol= the_event->evt.asmt.rhs.dval;
1540     have_minimizer_ls_tol = 1;
1541     return 1;
1542     break;
1543    
1544     case INT:
1545     minimizer_ls_tol= the_event->evt.asmt.rhs.ival;
1546     have_minimizer_ls_tol = 1;
1547     return 1;
1548     break;
1549    
1550     default:
1551     the_event->err_msg =
1552     strdup( "Global error. minimizer_ls_tol unrecognized.\n" );
1553     return 0;
1554     break;
1555     }
1556     break;
1557    
1558 mmeineke 655 // add more token cases here.
1559 tim 704 case G_SEED:
1560     switch( the_type ){
1561    
1562     case STRING:
1563     the_event->err_msg =
1564     strdup( "Global error. seed is not a string.\n" );
1565     return 0;
1566     return 0;
1567     break;
1568    
1569     case DOUBLE:
1570     have_seed = 1;
1571     seed = (int)the_event->evt.asmt.rhs.dval;
1572     return 1;
1573     break;
1574    
1575     case INT:
1576     have_seed = 1;
1577     seed = the_event->evt.asmt.rhs.ival ;
1578     return 1;
1579     break;
1580    
1581     default:
1582     the_event->err_msg =
1583     strdup( "Global error. seed unrecognized.\n" );
1584     return 0;
1585     break;
1586     }
1587     break;
1588 chrisfen 1181
1589 chrisfen 1209 case G_USE_SOLID_THERM_INT:
1590 chrisfen 1188 if( the_type == STRING ){
1591    
1592 chrisfen 1209 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useSolidThermInt = 1;
1593     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useSolidThermInt = 0;
1594 chrisfen 1188 else{
1595     the_event->err_msg =
1596 chrisfen 1209 strdup( "Global error. useSolidThermInt was not \"true\" or \"false\".\n" );
1597 chrisfen 1188 return 0;
1598     }
1599     return 1;
1600     }
1601    
1602     the_event->err_msg =
1603 chrisfen 1209 strdup( "Global error. useSolidThermInt was not \"true\" or \"false\".\n" );
1604 chrisfen 1188 return 0;
1605     break;
1606    
1607 chrisfen 1210 case G_USE_LIQUID_THERM_INT:
1608     if( the_type == STRING ){
1609    
1610     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useLiquidThermInt = 1;
1611     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useLiquidThermInt = 0;
1612     else{
1613     the_event->err_msg =
1614     strdup( "Global error. useLiquidThermInt was not \"true\" or \"false\".\n" );
1615     return 0;
1616     }
1617     return 1;
1618     }
1619    
1620     the_event->err_msg =
1621     strdup( "Global error. useLiquidThermInt was not \"true\" or \"false\".\n" );
1622     return 0;
1623     break;
1624    
1625 chrisfen 1181 case G_THERM_INT_LAMBDA:
1626     switch( the_type ){
1627    
1628     case STRING:
1629     the_event->err_msg =
1630     strdup( "Global error. thermodynamicIntegrationLambda is not a double or int.\n" );
1631     return 1;
1632     break;
1633    
1634     case DOUBLE:
1635     thermodynamic_integration_lambda = the_event->evt.asmt.rhs.dval;
1636     have_thermodynamic_integration_lambda = 1;
1637     return 1;
1638     break;
1639    
1640     case INT:
1641     thermodynamic_integration_lambda = (double)the_event->evt.asmt.rhs.dval;
1642     have_thermodynamic_integration_lambda = 1;
1643     return 1;
1644     break;
1645    
1646     default:
1647     the_event->err_msg =
1648     strdup( "Global error. thermodynamicIntegrationLambda unrecognized.\n" );
1649     return 0;
1650     break;
1651     }
1652     break;
1653    
1654     case G_THERM_INT_K:
1655     switch( the_type ){
1656    
1657     case STRING:
1658     the_event->err_msg =
1659     strdup( "Global error. thermodynamicIntegrationK is not a double or int.\n" );
1660     return 1;
1661     break;
1662    
1663     case DOUBLE:
1664     thermodynamic_integration_k = the_event->evt.asmt.rhs.dval;
1665     have_thermodynamic_integration_k = 1;
1666     return 1;
1667     break;
1668    
1669     case INT:
1670     thermodynamic_integration_k = (double)the_event->evt.asmt.rhs.dval;
1671     have_thermodynamic_integration_k = 1;
1672     return 1;
1673     break;
1674    
1675     default:
1676     the_event->err_msg =
1677     strdup( "Global error. thermodynamicIntegrationK unrecognized.\n" );
1678     return 0;
1679     break;
1680     }
1681     break;
1682 gezelter 1260 case G_FORCEFIELD_VARIANT:
1683     if( the_type == STRING ){
1684     strcpy( forcefield_variant, the_event->evt.asmt.rhs.sval );
1685     have_forcefield_variant = 1;
1686     return 1;
1687     }
1688    
1689     the_event->err_msg =
1690     strdup( "Global error. forceFieldVariant was not a string assignment.\n" );
1691     return 0;
1692     break;
1693     // add more token cases here.
1694 mmeineke 377 }
1695     }
1696    
1697     switch( the_type ){
1698    
1699     case STRING:
1700     sprintf( err,
1701     "Global error. Unrecognized assignment:\n"
1702     "\t-> %s = %s\n",
1703     lhs, the_event->evt.asmt.rhs.sval );
1704     break;
1705    
1706     case DOUBLE:
1707     sprintf( err,
1708     "Global error. Unrecognized assignment:\n"
1709     "\t-> %s = %lf\n",
1710     lhs, the_event->evt.asmt.rhs.dval );
1711     break;
1712    
1713     case INT:
1714     sprintf( err,
1715     "Global error. Unrecognized assignment:\n"
1716     "\t-> %s = %d\n",
1717     lhs, the_event->evt.asmt.rhs.ival );
1718     break;
1719    
1720     default:
1721     sprintf( err,
1722     "Global error. Unrecognized assignment:\n"
1723     "\t-> %s = ?\n",
1724     lhs );
1725     break;
1726     }
1727    
1728     the_event->err_msg = strdup( err );
1729     return 0;
1730     }
1731    
1732     char* Globals::checkMe( void ){
1733    
1734     char err[300];
1735     short int have_err = 0;
1736    
1737     strcpy( err, "Global error. The following are required:\n" );
1738    
1739     if( !have_force_field ){
1740     strcat( err, "\t->forceField\n" );
1741     have_err= 1;
1742     }
1743    
1744     if( !have_n_components ){
1745     strcat( err, "\t->nComponents\n" );
1746     have_err= 1;
1747     }
1748    
1749     if( !have_target_temp ){
1750     strcat( err, "\t->targetTemp\n" );
1751     have_err= 1;
1752     }
1753    
1754 tim 1035 if(!have_minimizer)
1755     if( !have_ensemble ){
1756     strcat( err, "\t->ensemble\n" );
1757     have_err= 1;
1758     }
1759 mmeineke 377
1760     if( !have_dt ){
1761     strcat( err, "\t->dt\n" );
1762     have_err= 1;
1763     }
1764    
1765     if( !have_run_time ){
1766     strcat( err, "\t->runTime\n" );
1767     have_err= 1;
1768     }
1769    
1770     if( have_err ) return strdup( err );
1771    
1772     return NULL;
1773     }
1774    
1775     int Globals::globalEnd( event* the_event ){
1776    
1777     the_event->err_msg = checkMe();
1778     if( the_event->err_msg != NULL ) return 0;
1779    
1780     return 1;
1781     }
1782    
1783     int Globals::hash( char* text ){
1784    
1785     register unsigned short int i = 0; // loop counter
1786     int key = 0; // the hash key
1787    
1788     while( text[i] != '\0' ){
1789    
1790     key = ( ( key << hash_shift ) + text[i] ) % hash_size;
1791    
1792     i++;
1793     }
1794    
1795     if( key < 0 ){
1796    
1797     // if the key is less than zero, we've had an overflow error
1798    
1799     sprintf( painCave.errMsg,
1800     "There has been an overflow error in the Globals' hash key.");
1801     painCave.isFatal = 1;
1802     simError();
1803     #ifdef IS_MPI
1804     if( painCave.isEventLoop ){
1805     if( worldRank == 0 ) mpiInterfaceExit();
1806     }
1807     #endif //is_mpi
1808     }
1809    
1810     return key;
1811     }
1812    
1813     void Globals::addHash( char* text, int token ){
1814    
1815     int key;
1816     LinkedCommand* the_element;
1817    
1818     the_element = new LinkedCommand;
1819     the_element->setValues( text, token );
1820    
1821     key = hash( text );
1822     the_element->setNext( command_table[key] );
1823     command_table[key] = the_element;
1824     }