ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1181
Committed: Thu May 20 20:27:26 2004 UTC (20 years, 1 month ago) by chrisfen
File size: 39626 byte(s)
Log Message: 
Hopefully this commit included the bass keywords

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