ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1091
Committed: Tue Mar 16 19:22:56 2004 UTC (20 years, 6 months ago) by tim
File size: 37433 byte(s)
Log Message: 
ZConstraint now can support sequential moving. Refactorying is needed to support SMD in ZConstraint

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