ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1209
Committed: Tue Jun 1 14:21:06 2004 UTC (20 years, 1 month ago) by chrisfen
File size: 40726 byte(s)
Log Message: 
Paving the way for separate solid and liquid thermodynamic integration routines

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