ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1153
Committed: Tue May 11 04:21:52 2004 UTC (20 years, 2 months ago) by gezelter
File size: 37863 byte(s)
Log Message: 
BASS changes for adding CutoffGroups to molecules.  Also restructured
the plethora of cutoff radii into one cutoffRadius and one
switchingRadius.  Also removed the useMolecularCutoffs keyword

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