ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 474
Committed: Mon Apr 7 21:42:19 2003 UTC (21 years, 2 months ago) by gezelter
File size: 21101 byte(s)
Log Message: 
Fixes for NPT and NVT

File Contents

# User Rev Content
1 mmeineke 377 #include <cstdlib>
2     #include <cstdio>
3     #include <cstring>
4    
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     #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    
27     //optional parameters
28     #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 394 #define G_ECR 17
39 mmeineke 377 #define G_DIELECTRIC 18
40     #define G_TEMPSET 19
41     #define G_THERMALTIME 20
42 gezelter 394 #define G_USEPBC 21
43     #define G_MIXINGRULE 22
44     #define G_EST 23
45     #define G_USERF 24
46 gezelter 465 #define G_TARGETPRESSURE 25
47 gezelter 474 #define G_QMASS 26
48     #define G_TAURELAX 27
49 mmeineke 377
50    
51     Globals::Globals(){
52    
53     int i;
54    
55     components = NULL;
56    
57     command_table = new LinkedCommand*[hash_size];
58     for( i=0; i<hash_size; i++ ) command_table[i] = NULL;
59    
60     addHash( "forceField", G_FORCEFIELD );
61     addHash( "nComponents", G_NCOMPONENTS );
62     addHash( "targetTemp", G_TARGETTEMP );
63     addHash( "ensemble", G_ENSEMBLE );
64    
65     addHash( "dt", G_DT );
66     addHash( "runTime", G_RUNTIME );
67    
68     addHash( "initialConfig", G_INITIALCONFIG );
69     addHash( "finalConfig", G_FINALCONFIG );
70     addHash( "nMol", G_NMOL );
71     addHash( "density", G_DENSITY );
72     addHash( "box", G_BOX );
73     addHash( "boxX", G_BOXX );
74     addHash( "boxY", G_BOXY );
75     addHash( "boxZ", G_BOXZ );
76     addHash( "sampleTime", G_SAMPLETIME );
77     addHash( "statusTime", G_STATUSTIME );
78 gezelter 394 addHash( "electrostaticCutoffRadius", G_ECR );
79 mmeineke 377 addHash( "dielectric", G_DIELECTRIC );
80     addHash( "tempSet", G_TEMPSET );
81     addHash( "thermalTime", G_THERMALTIME );
82     addHash( "mixingRule", G_MIXINGRULE);
83 gezelter 394 addHash( "usePeriodicBoundaryConditions", G_USEPBC);
84     addHash( "electrostaticSkinThickness", G_EST );
85     addHash( "useReactionField", G_USERF );
86 gezelter 465 addHash( "targetPressure", G_TARGETPRESSURE);
87 gezelter 474 addHash( "qMass", G_QMASS);
88     addHash( "tauRelax", G_TAURELAX);
89 mmeineke 377
90     // define some default values
91    
92     strcpy( mixingRule,"standard"); //default mixing rules to standard.
93     usePBC = 1; //default periodic boundry conditions to on
94 gezelter 394 useRF = 0;
95 mmeineke 377
96     have_force_field = 0;
97     have_n_components = 0;
98     have_target_temp = 0;
99     have_ensemble = 0;
100     have_dt = 0;
101     have_run_time = 0;
102    
103     have_initial_config = 0;
104     have_final_config = 0;
105     have_n_mol = 0;
106     have_density = 0;
107     have_box = 0;
108     have_box_x = 0;
109     have_box_y = 0;
110     have_box_y = 0;
111     have_box_z = 0;
112     have_sample_time = 0;
113     have_status_time = 0;
114     have_thermal_time = 0;
115 gezelter 394 have_ecr = 0;
116 mmeineke 377 have_dielectric = 0;
117     have_tempSet = 0;
118 gezelter 394 have_est = 0;
119 gezelter 465 have_target_pressure =0;
120 gezelter 474 have_q_mass = 0;
121     have_tau_relax = 0;
122 mmeineke 377 }
123    
124     Globals::~Globals(){
125     int i;
126    
127     for( i=0; i<hash_size; i++ ){
128     if( command_table[i] != NULL ) delete command_table[i];
129     }
130     delete[] command_table;
131    
132     if( components != NULL ){
133     for( i=0; i<n_components; i++ ) delete components[i];
134     delete[] components;
135     }
136     }
137    
138     int Globals::newComponent( event* the_event ){
139    
140     current_component = new Component;
141     int index = the_event->evt.blk_index;
142     char err[200];
143    
144     if( have_n_components && index < n_components )
145     components[index] = current_component;
146     else{
147     if( have_n_components ){
148     sprintf( err, "Globals error, %d out of nComponents range",
149     index );
150     the_event->err_msg = strdup( err );
151     return 0;
152     }
153     else{
154     the_event->err_msg = strdup("Globals error, nComponents not given before"
155     "first component declaration." );
156     return 0;
157     }
158     }
159    
160     return 1;
161     }
162    
163    
164    
165     int Globals::componentAssign( event* the_event ){
166    
167     switch( the_event->evt.asmt.asmt_type ){
168    
169     case STRING:
170     return current_component->assignString( the_event->evt.asmt.lhs,
171     the_event->evt.asmt.rhs.sval,
172     &(the_event->err_msg));
173     break;
174    
175     case DOUBLE:
176     return current_component->assignDouble( the_event->evt.asmt.lhs,
177     the_event->evt.asmt.rhs.dval,
178     &(the_event->err_msg));
179     break;
180    
181     case INT:
182     return current_component->assignInt( the_event->evt.asmt.lhs,
183     the_event->evt.asmt.rhs.ival,
184     &(the_event->err_msg));
185     break;
186    
187     default:
188     the_event->err_msg = strdup( "Globals error. Invalid component"
189     " assignment type" );
190     return 0;
191     break;
192     }
193     return 0;
194     }
195    
196     int Globals::componentStartIndex( event* the_event ){
197    
198     current_component->startIndex( the_event->evt.si.array,
199     the_event->evt.si.n_elements );
200     return 1;
201     }
202    
203     int Globals::componentEnd( event* the_event ){
204    
205     the_event->err_msg = current_component->checkMe();
206     if( the_event->err_msg != NULL ) return 0;
207    
208     return 1;
209     }
210    
211     int Globals::globalAssign( event* the_event ){
212    
213     int key;
214     int token;
215     interface_assign_type the_type = the_event->evt.asmt.asmt_type;
216     char* lhs = the_event->evt.asmt.lhs;
217     char err[300];
218    
219     token = 0;
220     key = hash( lhs );
221     if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
222    
223     if( token ){
224    
225     switch( token ){
226    
227     case G_FORCEFIELD:
228     if( the_type == STRING ){
229     strcpy( force_field, the_event->evt.asmt.rhs.sval );
230     have_force_field = 1;
231     return 1;
232     }
233    
234     the_event->err_msg =
235     strdup( "Global error. forceField was not a string assignment.\n" );
236     return 0;
237     break;
238    
239     case G_NCOMPONENTS:
240     if( the_type == STRING ){
241     the_event->err_msg =
242     strdup("Global error. nComponents is not a double or an int.\n" );
243     return 0;
244     }
245    
246     else if( the_type == DOUBLE ){
247     n_components = (int)the_event->evt.asmt.rhs.dval;
248     components = new Component*[n_components];
249     have_n_components = 1;
250     return 1;
251     }
252    
253     else{
254     n_components = the_event->evt.asmt.rhs.ival;
255     components = new Component*[n_components];
256     have_n_components = 1;
257     return 1;
258     }
259     break;
260    
261     case G_TARGETTEMP:
262     switch( the_type ){
263    
264     case STRING:
265     the_event->err_msg =
266     strdup( "Global error. targetTemp is not a double or int.\n" );
267     return 0;
268     break;
269    
270     case DOUBLE:
271     target_temp = the_event->evt.asmt.rhs.dval;
272     have_target_temp = 1;
273     return 1;
274     break;
275    
276     case INT:
277     target_temp = (double)the_event->evt.asmt.rhs.ival;
278     have_target_temp = 1;
279     return 1;
280     break;
281    
282     default:
283     the_event->err_msg =
284     strdup( "Global error. targetTemp unrecognized.\n" );
285     return 0;
286     break;
287     }
288     break;
289    
290     case G_ENSEMBLE:
291     if( the_type == STRING ){
292     strcpy( ensemble, the_event->evt.asmt.rhs.sval );
293     have_ensemble = 1;
294     return 1;
295     }
296    
297     the_event->err_msg =
298     strdup( "Global error. ensemble was not assigned to a string\n" );
299     return 0;
300     break;
301    
302     case G_MIXINGRULE:
303     if( the_type == STRING ){
304     strcpy( mixingRule, the_event->evt.asmt.rhs.sval );
305     return 1;
306     }
307    
308     the_event->err_msg =
309     strdup( "Global error. mixing rule was not assigned to a string\n" );
310     return 0;
311     break;
312    
313     case G_DT:
314     switch( the_type ){
315    
316     case STRING:
317     the_event->err_msg =
318     strdup( "Global error. dt is not a double or int.\n" );
319     return 0;
320     break;
321    
322     case DOUBLE:
323     dt = the_event->evt.asmt.rhs.dval;
324     have_dt = 1;
325     return 1;
326     break;
327    
328     case INT:
329     dt = (double)the_event->evt.asmt.rhs.ival;
330     have_dt = 1;
331     return 1;
332     break;
333    
334     default:
335     the_event->err_msg =
336     strdup( "Global error. dt unrecognized.\n" );
337     return 0;
338     break;
339     }
340     break;
341    
342     case G_RUNTIME:
343     switch( the_type ){
344    
345     case STRING:
346     the_event->err_msg =
347     strdup( "Global error. runTime is not a double or int.\n" );
348     return 0;
349     break;
350    
351     case DOUBLE:
352     run_time = the_event->evt.asmt.rhs.dval;
353     have_run_time = 1;
354     return 1;
355     break;
356    
357     case INT:
358     run_time = (double)the_event->evt.asmt.rhs.ival;
359     have_run_time = 1;
360     return 1;
361     break;
362    
363     default:
364     the_event->err_msg =
365     strdup( "Global error. runTime unrecognized.\n" );
366     return 0;
367     break;
368     }
369     break;
370    
371     case G_INITIALCONFIG:
372     if( the_type == STRING ){
373     strcpy( initial_config, the_event->evt.asmt.rhs.sval );
374     have_initial_config = 1;
375     return 1;
376     }
377    
378     the_event->err_msg =
379     strdup( "Global error. initialConfig was not a string assignment.\n" );
380     return 0;
381     break;
382    
383     case G_FINALCONFIG:
384     if( the_type == STRING ){
385     strcpy( final_config, the_event->evt.asmt.rhs.sval );
386     have_final_config = 1;
387     return 1;
388     }
389    
390     the_event->err_msg =
391     strdup( "Global error. finalConfig was not a string assignment.\n" );
392     return 0;
393     break;
394    
395     case G_NMOL:
396     switch( the_type ){
397    
398     case STRING:
399     the_event->err_msg =
400     strdup( "Global error. nMol is not a double or int.\n" );
401     return 0;
402     break;
403    
404     case DOUBLE:
405     n_mol = (int)the_event->evt.asmt.rhs.dval;
406     have_n_mol = 1;
407     return 1;
408     break;
409    
410     case INT:
411     n_mol = the_event->evt.asmt.rhs.ival;
412     have_n_mol = 1;
413     return 1;
414     break;
415    
416     default:
417     the_event->err_msg =
418     strdup( "Global error. nMol unrecognized.\n" );
419     return 0;
420     break;
421     }
422     break;
423    
424     case G_DENSITY:
425     switch( the_type ){
426    
427     case STRING:
428     the_event->err_msg =
429     strdup( "Global error. density is not a double or int.\n" );
430     return 0;
431     break;
432    
433     case DOUBLE:
434     density = the_event->evt.asmt.rhs.dval;
435     have_density = 1;
436     return 1;
437     break;
438    
439     case INT:
440     density = (double)the_event->evt.asmt.rhs.ival;
441     have_density = 1;
442     return 1;
443     break;
444    
445     default:
446     the_event->err_msg =
447     strdup( "Global error. density unrecognized.\n" );
448     return 0;
449     break;
450     }
451     break;
452    
453     case G_BOX:
454     switch( the_type ){
455    
456     case STRING:
457     the_event->err_msg =
458     strdup( "Global error. box is not a double or int.\n" );
459     return 0;
460     break;
461    
462     case DOUBLE:
463     box = the_event->evt.asmt.rhs.dval;
464     have_box = 1;
465     return 1;
466     break;
467    
468     case INT:
469     box = (double)the_event->evt.asmt.rhs.ival;
470     have_box = 1;
471     return 1;
472     break;
473    
474     default:
475     the_event->err_msg =
476     strdup( "Global error. box unrecognized.\n" );
477     return 0;
478     break;
479     }
480     break;
481    
482     case G_BOXX:
483     switch( the_type ){
484    
485     case STRING:
486     the_event->err_msg =
487     strdup( "Global error. boxX is not a double or int.\n" );
488     return 0;
489     break;
490    
491     case DOUBLE:
492     box_x = the_event->evt.asmt.rhs.dval;
493     have_box_x = 1;
494     return 1;
495     break;
496    
497     case INT:
498     box_x = (double)the_event->evt.asmt.rhs.ival;
499     have_box_x = 1;
500     return 1;
501     break;
502    
503     default:
504     the_event->err_msg =
505     strdup( "Global error. boxX unrecognized.\n" );
506     return 0;
507     break;
508     }
509     break;
510    
511     case G_BOXY:
512     switch( the_type ){
513    
514     case STRING:
515     the_event->err_msg =
516     strdup( "Global error. boxY is not a double or int.\n" );
517     return 0;
518     break;
519    
520     case DOUBLE:
521     box_y = the_event->evt.asmt.rhs.dval;
522     have_box_y = 1;
523     return 1;
524     break;
525    
526     case INT:
527     box_y = (double)the_event->evt.asmt.rhs.ival;
528     have_box_y = 1;
529     return 1;
530     break;
531    
532     default:
533     the_event->err_msg =
534     strdup( "Global error. boxY unrecognized.\n" );
535     return 0;
536     break;
537     }
538     break;
539    
540     case G_BOXZ:
541     switch( the_type ){
542    
543     case STRING:
544     the_event->err_msg =
545     strdup( "Global error. boxZ is not a double or int.\n" );
546     return 0;
547     break;
548    
549     case DOUBLE:
550     box_z = the_event->evt.asmt.rhs.dval;
551     have_box_z = 1;
552     return 1;
553     break;
554    
555     case INT:
556     box_z = (double)the_event->evt.asmt.rhs.ival;
557     have_box_z = 1;
558     return 1;
559     break;
560    
561     default:
562     the_event->err_msg =
563     strdup( "Global error. boxZ unrecognized.\n" );
564     return 0;
565     break;
566     }
567     break;
568    
569     case G_SAMPLETIME:
570     switch( the_type ){
571    
572     case STRING:
573     the_event->err_msg =
574     strdup( "Global error. sampleTime is not a double or int.\n" );
575     return 0;
576     break;
577    
578     case DOUBLE:
579     sample_time = the_event->evt.asmt.rhs.dval;
580     have_sample_time = 1;
581     return 1;
582     break;
583    
584     case INT:
585     sample_time = (double)the_event->evt.asmt.rhs.ival;
586     have_sample_time = 1;
587     return 1;
588     break;
589    
590     default:
591     the_event->err_msg =
592     strdup( "Global error. sampleTime unrecognized.\n" );
593     return 0;
594     break;
595     }
596     break;
597    
598     case G_STATUSTIME:
599     switch( the_type ){
600    
601     case STRING:
602     the_event->err_msg =
603     strdup( "Global error. statusTime is not a double or int.\n" );
604     return 0;
605     break;
606    
607     case DOUBLE:
608     status_time = the_event->evt.asmt.rhs.dval;
609     have_status_time = 1;
610     return 1;
611     break;
612    
613     case INT:
614     status_time = (double)the_event->evt.asmt.rhs.ival;
615     have_status_time = 1;
616     return 1;
617     break;
618    
619     default:
620     the_event->err_msg =
621     strdup( "Global error. statusTime unrecognized.\n" );
622     return 0;
623     break;
624     }
625     break;
626    
627     case G_THERMALTIME:
628     switch( the_type ){
629    
630     case STRING:
631     the_event->err_msg =
632     strdup( "Global error. thermalTime is not a double or int.\n" );
633     return 0;
634     break;
635    
636     case DOUBLE:
637     thermal_time = the_event->evt.asmt.rhs.dval;
638     have_thermal_time = 1;
639     return 1;
640     break;
641    
642     case INT:
643     thermal_time = (double)the_event->evt.asmt.rhs.ival;
644     have_thermal_time = 1;
645     return 1;
646     break;
647    
648     default:
649     the_event->err_msg =
650     strdup( "Global error. thermalTime unrecognized.\n" );
651     return 0;
652     break;
653     }
654     break;
655    
656 gezelter 394 case G_ECR:
657 mmeineke 377 switch( the_type ){
658    
659     case STRING:
660     the_event->err_msg =
661 gezelter 394 strdup( "Global error. electrostaticCutoffRadius is not a double or int.\n" );
662 mmeineke 377 return 0;
663     break;
664    
665     case DOUBLE:
666 gezelter 394 ecr = the_event->evt.asmt.rhs.dval;
667     have_ecr = 1;
668 mmeineke 377 return 1;
669     break;
670    
671     case INT:
672 gezelter 394 ecr = (double)the_event->evt.asmt.rhs.ival;
673     have_ecr = 1;
674 mmeineke 377 return 1;
675     break;
676    
677     default:
678     the_event->err_msg =
679 gezelter 394 strdup( "Global error. electrostaticCutoffRadius unrecognized.\n" );
680 mmeineke 377 return 0;
681     break;
682     }
683     break;
684 gezelter 394
685     case G_EST:
686     switch( the_type ){
687    
688     case STRING:
689     the_event->err_msg =
690     strdup( "Global error. electrostaticSkinThickness is not a double or int.\n" );
691     return 0;
692     break;
693    
694     case DOUBLE:
695     est = the_event->evt.asmt.rhs.dval;
696     have_est = 1;
697     return 1;
698     break;
699    
700     case INT:
701     est = (double)the_event->evt.asmt.rhs.ival;
702     have_est = 1;
703     return 1;
704     break;
705    
706     default:
707     the_event->err_msg =
708     strdup( "Global error. electrostaticSkinThickness unrecognized.\n" );
709     return 0;
710     break;
711     }
712     break;
713 mmeineke 377
714     case G_DIELECTRIC:
715     switch( the_type ){
716    
717     case STRING:
718     the_event->err_msg =
719     strdup( "Global error. dielectric is not a double or int.\n" );
720     return 0;
721     break;
722    
723     case DOUBLE:
724     dielectric = the_event->evt.asmt.rhs.dval;
725     have_dielectric = 1;
726     return 1;
727     break;
728    
729     case INT:
730     dielectric = (double)the_event->evt.asmt.rhs.ival;
731     have_dielectric = 1;
732     return 1;
733     break;
734    
735     default:
736     the_event->err_msg =
737     strdup( "Global error. dielectric unrecognized.\n" );
738     return 0;
739     break;
740     }
741     break;
742    
743     case G_TEMPSET:
744     if( the_type == STRING ){
745    
746 gezelter 465 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
747     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
748 mmeineke 377 else{
749     the_event->err_msg =
750     strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
751     return 0;
752     }
753     have_tempSet = 1;
754     return 1;
755     }
756    
757     the_event->err_msg =
758     strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
759     return 0;
760     break;
761    
762     case G_USEPBC:
763     if( the_type == STRING ){
764    
765 gezelter 465 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
766     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
767 mmeineke 377 else{
768     the_event->err_msg =
769 gezelter 394 strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
770 mmeineke 377 return 0;
771     }
772     return 1;
773     }
774    
775     the_event->err_msg =
776 gezelter 394 strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
777 mmeineke 377 return 0;
778     break;
779 gezelter 394
780     case G_USERF:
781     if( the_type == STRING ){
782    
783 gezelter 465 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
784     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0;
785 gezelter 394 else{
786     the_event->err_msg =
787     strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
788     return 0;
789     }
790     return 1;
791     }
792    
793     the_event->err_msg =
794     strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
795     return 0;
796     break;
797    
798 gezelter 465 case G_TARGETPRESSURE:
799     switch( the_type ){
800    
801     case STRING:
802     the_event->err_msg =
803     strdup( "Global error. targetPressure is not a double or int.\n" );
804     return 0;
805     break;
806    
807     case DOUBLE:
808     target_pressure = the_event->evt.asmt.rhs.dval;
809     have_target_pressure = 1;
810     return 1;
811     break;
812    
813     case INT:
814     target_pressure = (double)the_event->evt.asmt.rhs.ival;
815     have_target_pressure = 1;
816     return 1;
817     break;
818    
819     default:
820     the_event->err_msg =
821     strdup( "Global error. targetPressure unrecognized.\n" );
822     return 0;
823     break;
824     }
825     break;
826 gezelter 394
827 gezelter 474 case G_QMASS:
828     switch( the_type ){
829    
830     case STRING:
831     the_event->err_msg =
832     strdup( "Global error. qMass is not a double or int.\n" );
833     return 0;
834     break;
835    
836     case DOUBLE:
837     q_mass = the_event->evt.asmt.rhs.dval;
838     have_q_mass = 1;
839     return 1;
840     break;
841    
842     case INT:
843     q_mass = (double)the_event->evt.asmt.rhs.ival;
844     have_q_mass = 1;
845     return 1;
846     break;
847    
848     default:
849     the_event->err_msg =
850     strdup( "Global error. qMass unrecognized.\n" );
851     return 0;
852     break;
853     }
854     break;
855    
856     case G_TAURELAX:
857     switch( the_type ){
858    
859     case STRING:
860     the_event->err_msg =
861     strdup( "Global error. tauRelax is not a double or int.\n" );
862     return 0;
863     break;
864    
865     case DOUBLE:
866     tau_relax = the_event->evt.asmt.rhs.dval;
867     have_tau_relax = 1;
868     return 1;
869     break;
870    
871     case INT:
872     tau_relax = (double)the_event->evt.asmt.rhs.ival;
873     have_tau_relax = 1;
874     return 1;
875     break;
876    
877     default:
878     the_event->err_msg =
879     strdup( "Global error. tauRelax unrecognized.\n" );
880     return 0;
881     break;
882     }
883     break;
884    
885 mmeineke 377 }
886     }
887    
888     switch( the_type ){
889    
890     case STRING:
891     sprintf( err,
892     "Global error. Unrecognized assignment:\n"
893     "\t-> %s = %s\n",
894     lhs, the_event->evt.asmt.rhs.sval );
895     break;
896    
897     case DOUBLE:
898     sprintf( err,
899     "Global error. Unrecognized assignment:\n"
900     "\t-> %s = %lf\n",
901     lhs, the_event->evt.asmt.rhs.dval );
902     break;
903    
904     case INT:
905     sprintf( err,
906     "Global error. Unrecognized assignment:\n"
907     "\t-> %s = %d\n",
908     lhs, the_event->evt.asmt.rhs.ival );
909     break;
910    
911     default:
912     sprintf( err,
913     "Global error. Unrecognized assignment:\n"
914     "\t-> %s = ?\n",
915     lhs );
916     break;
917     }
918    
919     the_event->err_msg = strdup( err );
920     return 0;
921     }
922    
923     char* Globals::checkMe( void ){
924    
925     char err[300];
926     short int have_err = 0;
927    
928     strcpy( err, "Global error. The following are required:\n" );
929    
930     if( !have_force_field ){
931     strcat( err, "\t->forceField\n" );
932     have_err= 1;
933     }
934    
935     if( !have_n_components ){
936     strcat( err, "\t->nComponents\n" );
937     have_err= 1;
938     }
939    
940     if( !have_target_temp ){
941     strcat( err, "\t->targetTemp\n" );
942     have_err= 1;
943     }
944    
945     if( !have_ensemble ){
946     strcat( err, "\t->ensemble\n" );
947     have_err= 1;
948     }
949    
950     if( !have_dt ){
951     strcat( err, "\t->dt\n" );
952     have_err= 1;
953     }
954    
955     if( !have_run_time ){
956     strcat( err, "\t->runTime\n" );
957     have_err= 1;
958     }
959    
960     if( have_err ) return strdup( err );
961    
962     return NULL;
963     }
964    
965     int Globals::globalEnd( event* the_event ){
966    
967     the_event->err_msg = checkMe();
968     if( the_event->err_msg != NULL ) return 0;
969    
970     return 1;
971     }
972    
973     int Globals::hash( char* text ){
974    
975     register unsigned short int i = 0; // loop counter
976     int key = 0; // the hash key
977    
978     while( text[i] != '\0' ){
979    
980     key = ( ( key << hash_shift ) + text[i] ) % hash_size;
981    
982     i++;
983     }
984    
985     if( key < 0 ){
986    
987     // if the key is less than zero, we've had an overflow error
988    
989     sprintf( painCave.errMsg,
990     "There has been an overflow error in the Globals' hash key.");
991     painCave.isFatal = 1;
992     simError();
993     #ifdef IS_MPI
994     if( painCave.isEventLoop ){
995     if( worldRank == 0 ) mpiInterfaceExit();
996     }
997     #endif //is_mpi
998     }
999    
1000     return key;
1001     }
1002    
1003     void Globals::addHash( char* text, int token ){
1004    
1005     int key;
1006     LinkedCommand* the_element;
1007    
1008     the_element = new LinkedCommand;
1009     the_element->setValues( text, token );
1010    
1011     key = hash( text );
1012     the_element->setNext( command_table[key] );
1013     command_table[key] = the_element;
1014     }