ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1137
Committed: Wed Apr 28 21:39:12 2004 UTC (20 years, 2 months ago) by gezelter
File size: 39182 byte(s)
Log Message: 
useMolecularCutoffs added to Globals

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