ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 655
Committed: Tue Jul 29 16:32:06 2003 UTC (20 years, 11 months ago) by mmeineke
File size: 21277 byte(s)
Log Message: 
*** empty log message ***

File Contents

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