ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1188
Committed: Sat May 22 18:17:05 2004 UTC (20 years, 1 month ago) by chrisfen
File size: 40371 byte(s)
Log Message: 
Added Bass keyword useThermInt.

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