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

File Contents

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