ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 745
Committed: Thu Sep 4 21:48:07 2003 UTC (20 years, 10 months ago) by mmeineke
File size: 26802 byte(s)
Log Message: 
added resetTime to the Global namespace.

File Contents

# Content
1 #include <cstdlib>
2 #include <cstdio>
3 #include <cstring>
4
5 #include "Globals.hpp"
6 #include "simError.h"
7 #ifdef IS_MPI
8 #include "mpiBASS.h"
9 #endif // is_mpi
10
11 /*
12 * The following section lists all of the defined tokens for the
13 * gloabal assignment statements. All are prefixed with a G_ to avoid
14 * stepping on any previously defined enumerations.
15 *
16 * NOTE: tokens start at 1, 0 is a resrved token number
17 */
18
19 //required parameters
20 #define G_FORCEFIELD 1
21 #define G_NCOMPONENTS 2
22 #define G_TARGETTEMP 3
23 #define G_ENSEMBLE 4
24 #define G_DT 5
25 #define G_RUNTIME 6
26
27 //optional parameters
28 #define G_INITIALCONFIG 7
29 #define G_FINALCONFIG 8
30 #define G_NMOL 9
31 #define G_DENSITY 10
32 #define G_BOX 11
33 #define G_BOXX 12
34 #define G_BOXY 13
35 #define G_BOXZ 14
36 #define G_SAMPLETIME 15
37 #define G_STATUSTIME 16
38 #define G_ECR 17
39 #define G_DIELECTRIC 18
40 #define G_TEMPSET 19
41 #define G_THERMALTIME 20
42 #define G_USEPBC 21
43 #define G_MIXINGRULE 22
44 #define G_EST 23
45 #define G_USERF 24
46 #define G_TARGETPRESSURE 25
47 #define G_TAUTHERMOSTAT 26
48 #define G_TAUBAROSTAT 27
49 #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
56 Globals::Globals(){
57
58 int i;
59
60 components = NULL;
61
62 command_table = new LinkedCommand*[hash_size];
63 for( i=0; i<hash_size; i++ ) command_table[i] = NULL;
64
65 addHash( "forceField", G_FORCEFIELD );
66 addHash( "nComponents", G_NCOMPONENTS );
67 addHash( "targetTemp", G_TARGETTEMP );
68 addHash( "ensemble", G_ENSEMBLE );
69
70 addHash( "dt", G_DT );
71 addHash( "runTime", G_RUNTIME );
72
73 addHash( "initialConfig", G_INITIALCONFIG );
74 addHash( "finalConfig", G_FINALCONFIG );
75 addHash( "nMol", G_NMOL );
76 addHash( "density", G_DENSITY );
77 addHash( "box", G_BOX );
78 addHash( "boxX", G_BOXX );
79 addHash( "boxY", G_BOXY );
80 addHash( "boxZ", G_BOXZ );
81 addHash( "sampleTime", G_SAMPLETIME );
82 addHash( "resetTime", G_RESETTIME );
83 addHash( "statusTime", G_STATUSTIME );
84 addHash( "electrostaticCutoffRadius", G_ECR );
85 addHash( "dielectric", G_DIELECTRIC );
86 addHash( "tempSet", G_TEMPSET );
87 addHash( "thermalTime", G_THERMALTIME );
88 addHash( "mixingRule", G_MIXINGRULE);
89 addHash( "usePeriodicBoundaryConditions", G_USEPBC);
90 addHash( "electrostaticSkinThickness", G_EST );
91 addHash( "useReactionField", G_USERF );
92 addHash( "targetPressure", G_TARGETPRESSURE);
93 addHash( "tauThermostat", G_TAUTHERMOSTAT);
94 addHash( "tauBarostat", G_TAUBAROSTAT);
95 addHash( "zconsTime", G_ZCONSTIME);
96 addHash( "nZconstraints", G_NZCONSTRAINTS);
97 addHash( "zconsTol", G_ZCONSTOL);
98 addHash( "zconsForcePolicy", G_ZCONSFORCEPOLICY);
99 addHash( "seed", G_SEED);
100
101
102 // define some default values
103
104 strcpy( mixingRule,"standard"); //default mixing rules to standard.
105 usePBC = 1; //default periodic boundry conditions to on
106 useRF = 0;
107
108 have_force_field = 0;
109 have_n_components = 0;
110 have_target_temp = 0;
111 have_ensemble = 0;
112 have_dt = 0;
113 have_run_time = 0;
114
115 have_initial_config = 0;
116 have_final_config = 0;
117 have_n_mol = 0;
118 have_density = 0;
119 have_box = 0;
120 have_box_x = 0;
121 have_box_y = 0;
122 have_box_y = 0;
123 have_box_z = 0;
124 have_sample_time = 0;
125 have_status_time = 0;
126 have_reset_time = 0;
127 have_thermal_time = 0;
128 have_ecr = 0;
129 have_dielectric = 0;
130 have_tempSet = 0;
131 have_est = 0;
132 have_target_pressure =0;
133 have_q_mass = 0;
134 have_tau_thermostat = 0;
135 have_tau_barostat = 0;
136 have_zcons_time = 0;
137 have_n_zConstraints = 0;
138 have_zConstraints = 0;
139 have_zcons_tol = 0;
140 have_seed = 0;
141
142 }
143
144 Globals::~Globals(){
145 int i;
146
147 for( i=0; i<hash_size; i++ ){
148 if( command_table[i] != NULL ) delete command_table[i];
149 }
150 delete[] command_table;
151
152 if( components != NULL ){
153 for( i=0; i<n_components; i++ ) delete components[i];
154 delete[] components;
155 }
156 }
157
158 int Globals::newComponent( event* the_event ){
159
160 current_component = new Component;
161 int index = the_event->evt.blk_index;
162 char err[200];
163
164 if( have_n_components && index < n_components )
165 components[index] = current_component;
166 else{
167 if( have_n_components ){
168 sprintf( err, "Globals error, %d out of nComponents range",
169 index );
170 the_event->err_msg = strdup( err );
171 return 0;
172 }
173 else{
174 the_event->err_msg = strdup("Globals error, nComponents not given before"
175 "first component declaration." );
176 return 0;
177 }
178 }
179
180 return 1;
181 }
182
183
184
185 int Globals::componentAssign( event* the_event ){
186
187 switch( the_event->evt.asmt.asmt_type ){
188
189 case STRING:
190 return current_component->assignString( the_event->evt.asmt.lhs,
191 the_event->evt.asmt.rhs.sval,
192 &(the_event->err_msg));
193 break;
194
195 case DOUBLE:
196 return current_component->assignDouble( the_event->evt.asmt.lhs,
197 the_event->evt.asmt.rhs.dval,
198 &(the_event->err_msg));
199 break;
200
201 case INT:
202 return current_component->assignInt( the_event->evt.asmt.lhs,
203 the_event->evt.asmt.rhs.ival,
204 &(the_event->err_msg));
205 break;
206
207 default:
208 the_event->err_msg = strdup( "Globals error. Invalid component"
209 " assignment type" );
210 return 0;
211 break;
212 }
213 return 0;
214 }
215
216 int Globals::componentEnd( event* the_event ){
217
218 the_event->err_msg = current_component->checkMe();
219 if( the_event->err_msg != NULL ) return 0;
220
221 return 1;
222 }
223
224 int Globals::newZconstraint( event* the_event ){
225
226
227 int index = the_event->evt.blk_index;
228 char err[200];
229 current_zConstraint = new ZconStamp( index );
230
231 have_zConstraints = 1;
232
233 if( have_n_zConstraints && index < n_zConstraints )
234 zConstraints[index] = current_zConstraint;
235 else{
236 if( have_n_zConstraints ){
237 sprintf( err, "Globals error, %d out of nZconstraints range",
238 index );
239 the_event->err_msg = strdup( err );
240 return 0;
241 }
242 else{
243 the_event->err_msg = strdup("Globals error, nZconstraints"
244 " not given before"
245 " first zConstraint declaration." );
246 return 0;
247 }
248 }
249
250 return 1;
251 }
252
253
254
255 int Globals::zConstraintAssign( event* the_event ){
256
257 switch( the_event->evt.asmt.asmt_type ){
258
259 case STRING:
260 return current_zConstraint->assignString( the_event->evt.asmt.lhs,
261 the_event->evt.asmt.rhs.sval,
262 &(the_event->err_msg));
263 break;
264
265 case DOUBLE:
266 return current_zConstraint->assignDouble( the_event->evt.asmt.lhs,
267 the_event->evt.asmt.rhs.dval,
268 &(the_event->err_msg));
269 break;
270
271 case INT:
272 return current_zConstraint->assignInt( the_event->evt.asmt.lhs,
273 the_event->evt.asmt.rhs.ival,
274 &(the_event->err_msg));
275 break;
276
277 default:
278 the_event->err_msg = strdup( "Globals error. Invalid zConstraint"
279 " assignment type" );
280 return 0;
281 break;
282 }
283 return 0;
284 }
285
286 int Globals::zConstraintEnd( event* the_event ){
287
288 the_event->err_msg = current_zConstraint->checkMe();
289 if( the_event->err_msg != NULL ) return 0;
290
291 return 1;
292 }
293
294 int Globals::globalAssign( event* the_event ){
295
296 int key;
297 int token;
298 interface_assign_type the_type = the_event->evt.asmt.asmt_type;
299 char* lhs = the_event->evt.asmt.lhs;
300 char err[300];
301
302 token = 0;
303 key = hash( lhs );
304 if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
305
306 if( token ){
307
308 switch( token ){
309
310 case G_FORCEFIELD:
311 if( the_type == STRING ){
312 strcpy( force_field, the_event->evt.asmt.rhs.sval );
313 have_force_field = 1;
314 return 1;
315 }
316
317 the_event->err_msg =
318 strdup( "Global error. forceField was not a string assignment.\n" );
319 return 0;
320 break;
321
322 case G_NCOMPONENTS:
323 if( the_type == STRING ){
324 the_event->err_msg =
325 strdup("Global error. nComponents is not a double or an int.\n" );
326 return 0;
327 }
328
329 else if( the_type == DOUBLE ){
330 n_components = (int)the_event->evt.asmt.rhs.dval;
331 components = new Component*[n_components];
332 have_n_components = 1;
333 return 1;
334 }
335
336 else{
337 n_components = the_event->evt.asmt.rhs.ival;
338 components = new Component*[n_components];
339 have_n_components = 1;
340 return 1;
341 }
342 break;
343
344 case G_NZCONSTRAINTS:
345 if( the_type == STRING ){
346 the_event->err_msg =
347 strdup("Global error. nZconstraints is not a double or an int.\n" );
348 return 0;
349 }
350
351 else if( the_type == DOUBLE ){
352 n_zConstraints = (int)the_event->evt.asmt.rhs.dval;
353 zConstraints = new ZconStamp*[n_zConstraints];
354 have_n_zConstraints = 1;
355 return 1;
356 }
357
358 else{
359 n_zConstraints = the_event->evt.asmt.rhs.ival;
360 zConstraints = new ZconStamp*[n_zConstraints];
361 have_n_zConstraints = 1;
362 return 1;
363 }
364 break;
365
366 case G_TARGETTEMP:
367 switch( the_type ){
368
369 case STRING:
370 the_event->err_msg =
371 strdup( "Global error. targetTemp is not a double or int.\n" );
372 return 0;
373 break;
374
375 case DOUBLE:
376 target_temp = the_event->evt.asmt.rhs.dval;
377 have_target_temp = 1;
378 return 1;
379 break;
380
381 case INT:
382 target_temp = (double)the_event->evt.asmt.rhs.ival;
383 have_target_temp = 1;
384 return 1;
385 break;
386
387 default:
388 the_event->err_msg =
389 strdup( "Global error. targetTemp unrecognized.\n" );
390 return 0;
391 break;
392 }
393 break;
394
395 case G_ENSEMBLE:
396 if( the_type == STRING ){
397 strcpy( ensemble, the_event->evt.asmt.rhs.sval );
398 have_ensemble = 1;
399 return 1;
400 }
401
402 the_event->err_msg =
403 strdup( "Global error. ensemble was not assigned to a string\n" );
404 return 0;
405 break;
406
407 case G_MIXINGRULE:
408 if( the_type == STRING ){
409 strcpy( mixingRule, the_event->evt.asmt.rhs.sval );
410 return 1;
411 }
412
413 the_event->err_msg =
414 strdup( "Global error. mixing rule was not assigned to a string\n" );
415 return 0;
416 break;
417
418 case G_DT:
419 switch( the_type ){
420
421 case STRING:
422 the_event->err_msg =
423 strdup( "Global error. dt is not a double or int.\n" );
424 return 0;
425 break;
426
427 case DOUBLE:
428 dt = the_event->evt.asmt.rhs.dval;
429 have_dt = 1;
430 return 1;
431 break;
432
433 case INT:
434 dt = (double)the_event->evt.asmt.rhs.ival;
435 have_dt = 1;
436 return 1;
437 break;
438
439 default:
440 the_event->err_msg =
441 strdup( "Global error. dt unrecognized.\n" );
442 return 0;
443 break;
444 }
445 break;
446
447 case G_RUNTIME:
448 switch( the_type ){
449
450 case STRING:
451 the_event->err_msg =
452 strdup( "Global error. runTime is not a double or int.\n" );
453 return 0;
454 break;
455
456 case DOUBLE:
457 run_time = the_event->evt.asmt.rhs.dval;
458 have_run_time = 1;
459 return 1;
460 break;
461
462 case INT:
463 run_time = (double)the_event->evt.asmt.rhs.ival;
464 have_run_time = 1;
465 return 1;
466 break;
467
468 default:
469 the_event->err_msg =
470 strdup( "Global error. runTime unrecognized.\n" );
471 return 0;
472 break;
473 }
474 break;
475
476 case G_INITIALCONFIG:
477 if( the_type == STRING ){
478 strcpy( initial_config, the_event->evt.asmt.rhs.sval );
479 have_initial_config = 1;
480 return 1;
481 }
482
483 the_event->err_msg =
484 strdup( "Global error. initialConfig was not a string assignment.\n" );
485 return 0;
486 break;
487
488 case G_FINALCONFIG:
489 if( the_type == STRING ){
490 strcpy( final_config, the_event->evt.asmt.rhs.sval );
491 have_final_config = 1;
492 return 1;
493 }
494
495 the_event->err_msg =
496 strdup( "Global error. finalConfig was not a string assignment.\n" );
497 return 0;
498 break;
499
500 case G_NMOL:
501 switch( the_type ){
502
503 case STRING:
504 the_event->err_msg =
505 strdup( "Global error. nMol is not a double or int.\n" );
506 return 0;
507 break;
508
509 case DOUBLE:
510 n_mol = (int)the_event->evt.asmt.rhs.dval;
511 have_n_mol = 1;
512 return 1;
513 break;
514
515 case INT:
516 n_mol = the_event->evt.asmt.rhs.ival;
517 have_n_mol = 1;
518 return 1;
519 break;
520
521 default:
522 the_event->err_msg =
523 strdup( "Global error. nMol unrecognized.\n" );
524 return 0;
525 break;
526 }
527 break;
528
529 case G_DENSITY:
530 switch( the_type ){
531
532 case STRING:
533 the_event->err_msg =
534 strdup( "Global error. density is not a double or int.\n" );
535 return 0;
536 break;
537
538 case DOUBLE:
539 density = the_event->evt.asmt.rhs.dval;
540 have_density = 1;
541 return 1;
542 break;
543
544 case INT:
545 density = (double)the_event->evt.asmt.rhs.ival;
546 have_density = 1;
547 return 1;
548 break;
549
550 default:
551 the_event->err_msg =
552 strdup( "Global error. density unrecognized.\n" );
553 return 0;
554 break;
555 }
556 break;
557
558 case G_BOX:
559 switch( the_type ){
560
561 case STRING:
562 the_event->err_msg =
563 strdup( "Global error. box is not a double or int.\n" );
564 return 0;
565 break;
566
567 case DOUBLE:
568 box = the_event->evt.asmt.rhs.dval;
569 have_box = 1;
570 return 1;
571 break;
572
573 case INT:
574 box = (double)the_event->evt.asmt.rhs.ival;
575 have_box = 1;
576 return 1;
577 break;
578
579 default:
580 the_event->err_msg =
581 strdup( "Global error. box unrecognized.\n" );
582 return 0;
583 break;
584 }
585 break;
586
587 case G_BOXX:
588 switch( the_type ){
589
590 case STRING:
591 the_event->err_msg =
592 strdup( "Global error. boxX is not a double or int.\n" );
593 return 0;
594 break;
595
596 case DOUBLE:
597 box_x = the_event->evt.asmt.rhs.dval;
598 have_box_x = 1;
599 return 1;
600 break;
601
602 case INT:
603 box_x = (double)the_event->evt.asmt.rhs.ival;
604 have_box_x = 1;
605 return 1;
606 break;
607
608 default:
609 the_event->err_msg =
610 strdup( "Global error. boxX unrecognized.\n" );
611 return 0;
612 break;
613 }
614 break;
615
616 case G_BOXY:
617 switch( the_type ){
618
619 case STRING:
620 the_event->err_msg =
621 strdup( "Global error. boxY is not a double or int.\n" );
622 return 0;
623 break;
624
625 case DOUBLE:
626 box_y = the_event->evt.asmt.rhs.dval;
627 have_box_y = 1;
628 return 1;
629 break;
630
631 case INT:
632 box_y = (double)the_event->evt.asmt.rhs.ival;
633 have_box_y = 1;
634 return 1;
635 break;
636
637 default:
638 the_event->err_msg =
639 strdup( "Global error. boxY unrecognized.\n" );
640 return 0;
641 break;
642 }
643 break;
644
645 case G_BOXZ:
646 switch( the_type ){
647
648 case STRING:
649 the_event->err_msg =
650 strdup( "Global error. boxZ is not a double or int.\n" );
651 return 0;
652 break;
653
654 case DOUBLE:
655 box_z = the_event->evt.asmt.rhs.dval;
656 have_box_z = 1;
657 return 1;
658 break;
659
660 case INT:
661 box_z = (double)the_event->evt.asmt.rhs.ival;
662 have_box_z = 1;
663 return 1;
664 break;
665
666 default:
667 the_event->err_msg =
668 strdup( "Global error. boxZ unrecognized.\n" );
669 return 0;
670 break;
671 }
672 break;
673
674 case G_SAMPLETIME:
675 switch( the_type ){
676
677 case STRING:
678 the_event->err_msg =
679 strdup( "Global error. sampleTime is not a double or int.\n" );
680 return 0;
681 break;
682
683 case DOUBLE:
684 sample_time = the_event->evt.asmt.rhs.dval;
685 have_sample_time = 1;
686 return 1;
687 break;
688
689 case INT:
690 sample_time = (double)the_event->evt.asmt.rhs.ival;
691 have_sample_time = 1;
692 return 1;
693 break;
694
695 default:
696 the_event->err_msg =
697 strdup( "Global error. sampleTime unrecognized.\n" );
698 return 0;
699 break;
700 }
701 break;
702
703 case G_STATUSTIME:
704 switch( the_type ){
705
706 case STRING:
707 the_event->err_msg =
708 strdup( "Global error. statusTime is not a double or int.\n" );
709 return 0;
710 break;
711
712 case DOUBLE:
713 status_time = the_event->evt.asmt.rhs.dval;
714 have_status_time = 1;
715 return 1;
716 break;
717
718 case INT:
719 status_time = (double)the_event->evt.asmt.rhs.ival;
720 have_status_time = 1;
721 return 1;
722 break;
723
724 default:
725 the_event->err_msg =
726 strdup( "Global error. statusTime unrecognized.\n" );
727 return 0;
728 break;
729 }
730 break;
731
732 case G_RESETTIME:
733 switch( the_type ){
734
735 case STRING:
736 the_event->err_msg =
737 strdup( "Global error. resetTime is not a double or int.\n" );
738 return 0;
739 break;
740
741 case DOUBLE:
742 resetTime = the_event->evt.asmt.rhs.dval;
743 have_reset_time = 1;
744 return 1;
745 break;
746
747 case INT:
748 resetTime = (double)the_event->evt.asmt.rhs.ival;
749 have_reset_time = 1;
750 return 1;
751 break;
752
753 default:
754 the_event->err_msg =
755 strdup( "Global error. resetTime unrecognized.\n" );
756 return 0;
757 break;
758 }
759 break;
760
761 case G_THERMALTIME:
762 switch( the_type ){
763
764 case STRING:
765 the_event->err_msg =
766 strdup( "Global error. thermalTime is not a double or int.\n" );
767 return 0;
768 break;
769
770 case DOUBLE:
771 thermal_time = the_event->evt.asmt.rhs.dval;
772 have_thermal_time = 1;
773 return 1;
774 break;
775
776 case INT:
777 thermal_time = (double)the_event->evt.asmt.rhs.ival;
778 have_thermal_time = 1;
779 return 1;
780 break;
781
782 default:
783 the_event->err_msg =
784 strdup( "Global error. thermalTime unrecognized.\n" );
785 return 0;
786 break;
787 }
788 break;
789
790 case G_ECR:
791 switch( the_type ){
792
793 case STRING:
794 the_event->err_msg =
795 strdup( "Global error. electrostaticCutoffRadius is not a double or int.\n" );
796 return 0;
797 break;
798
799 case DOUBLE:
800 ecr = the_event->evt.asmt.rhs.dval;
801 have_ecr = 1;
802 return 1;
803 break;
804
805 case INT:
806 ecr = (double)the_event->evt.asmt.rhs.ival;
807 have_ecr = 1;
808 return 1;
809 break;
810
811 default:
812 the_event->err_msg =
813 strdup( "Global error. electrostaticCutoffRadius unrecognized.\n" );
814 return 0;
815 break;
816 }
817 break;
818
819 case G_EST:
820 switch( the_type ){
821
822 case STRING:
823 the_event->err_msg =
824 strdup( "Global error. electrostaticSkinThickness is not a double or int.\n" );
825 return 0;
826 break;
827
828 case DOUBLE:
829 est = the_event->evt.asmt.rhs.dval;
830 have_est = 1;
831 return 1;
832 break;
833
834 case INT:
835 est = (double)the_event->evt.asmt.rhs.ival;
836 have_est = 1;
837 return 1;
838 break;
839
840 default:
841 the_event->err_msg =
842 strdup( "Global error. electrostaticSkinThickness unrecognized.\n" );
843 return 0;
844 break;
845 }
846 break;
847
848 case G_DIELECTRIC:
849 switch( the_type ){
850
851 case STRING:
852 the_event->err_msg =
853 strdup( "Global error. dielectric is not a double or int.\n" );
854 return 0;
855 break;
856
857 case DOUBLE:
858 dielectric = the_event->evt.asmt.rhs.dval;
859 have_dielectric = 1;
860 return 1;
861 break;
862
863 case INT:
864 dielectric = (double)the_event->evt.asmt.rhs.ival;
865 have_dielectric = 1;
866 return 1;
867 break;
868
869 default:
870 the_event->err_msg =
871 strdup( "Global error. dielectric unrecognized.\n" );
872 return 0;
873 break;
874 }
875 break;
876
877 case G_TEMPSET:
878 if( the_type == STRING ){
879
880 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
881 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
882 else{
883 the_event->err_msg =
884 strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
885 return 0;
886 }
887 have_tempSet = 1;
888 return 1;
889 }
890
891 the_event->err_msg =
892 strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
893 return 0;
894 break;
895
896 case G_USEPBC:
897 if( the_type == STRING ){
898
899 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
900 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
901 else{
902 the_event->err_msg =
903 strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
904 return 0;
905 }
906 return 1;
907 }
908
909 the_event->err_msg =
910 strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
911 return 0;
912 break;
913
914 case G_USERF:
915 if( the_type == STRING ){
916
917 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
918 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0;
919 else{
920 the_event->err_msg =
921 strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
922 return 0;
923 }
924 return 1;
925 }
926
927 the_event->err_msg =
928 strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
929 return 0;
930 break;
931
932 case G_TARGETPRESSURE:
933 switch( the_type ){
934
935 case STRING:
936 the_event->err_msg =
937 strdup( "Global error. targetPressure is not a double or int.\n" );
938 return 0;
939 break;
940
941 case DOUBLE:
942 target_pressure = the_event->evt.asmt.rhs.dval;
943 have_target_pressure = 1;
944 return 1;
945 break;
946
947 case INT:
948 target_pressure = (double)the_event->evt.asmt.rhs.ival;
949 have_target_pressure = 1;
950 return 1;
951 break;
952
953 default:
954 the_event->err_msg =
955 strdup( "Global error. targetPressure unrecognized.\n" );
956 return 0;
957 break;
958 }
959 break;
960
961 case G_TAUTHERMOSTAT:
962 switch( the_type ){
963
964 case STRING:
965 the_event->err_msg =
966 strdup( "Global error. tauThermostat is not a double or int.\n" );
967 return 0;
968 break;
969
970 case DOUBLE:
971 tau_thermostat = the_event->evt.asmt.rhs.dval;
972 have_tau_thermostat = 1;
973 return 1;
974 break;
975
976 case INT:
977 tau_thermostat = (double)the_event->evt.asmt.rhs.ival;
978 have_tau_thermostat = 1;
979 return 1;
980 break;
981
982 default:
983 the_event->err_msg =
984 strdup( "Global error. tauThermostat unrecognized.\n" );
985 return 0;
986 break;
987 }
988 break;
989
990 case G_TAUBAROSTAT:
991 switch( the_type ){
992
993 case STRING:
994 the_event->err_msg =
995 strdup( "Global error. tauBarostat is not a double or int.\n" );
996 return 0;
997 break;
998
999 case DOUBLE:
1000 tau_barostat = the_event->evt.asmt.rhs.dval;
1001 have_tau_barostat = 1;
1002 return 1;
1003 break;
1004
1005 case INT:
1006 tau_barostat = (double)the_event->evt.asmt.rhs.ival;
1007 have_tau_barostat = 1;
1008 return 1;
1009 break;
1010
1011 default:
1012 the_event->err_msg =
1013 strdup( "Global error. tauBarostat unrecognized.\n" );
1014 return 0;
1015 break;
1016 }
1017 break;
1018
1019 case G_ZCONSTIME:
1020 switch( the_type ){
1021
1022 case STRING:
1023 the_event->err_msg =
1024 strdup( "Global error. zcons_time is not a double or int.\n" );
1025 return 0;
1026 break;
1027
1028 case DOUBLE:
1029 zcons_time = the_event->evt.asmt.rhs.dval;
1030 have_zcons_time = 1;
1031 return 1;
1032 break;
1033
1034 case INT:
1035 zcons_time = (double)the_event->evt.asmt.rhs.ival;
1036 have_zcons_time = 1;
1037 return 1;
1038 break;
1039
1040 default:
1041 the_event->err_msg =
1042 strdup( "Global error. zcons_time unrecognized.\n" );
1043 return 0;
1044 break;
1045 }
1046 break;
1047
1048 case G_ZCONSTOL:
1049 switch( the_type ){
1050
1051 case STRING:
1052 the_event->err_msg =
1053 strdup( "Global error. zcons_tol is not a double or int.\n" );
1054 return 0;
1055 break;
1056
1057 case DOUBLE:
1058 zcons_tol = the_event->evt.asmt.rhs.dval;
1059 have_zcons_tol = 1;
1060 return 1;
1061 break;
1062
1063 case INT:
1064 zcons_tol = (double)the_event->evt.asmt.rhs.ival;
1065 have_zcons_tol = 1;
1066 return 1;
1067 break;
1068
1069 default:
1070 the_event->err_msg =
1071 strdup( "Global error. zcons_ol unrecognized.\n" );
1072 return 0;
1073 break;
1074 }
1075 break;
1076
1077 case G_ZCONSFORCEPOLICY:
1078 switch( the_type ){
1079
1080 case STRING:
1081 strcpy(zconsForcePolicy, the_event->evt.asmt.rhs.sval);
1082
1083 for(int i = 0; zconsForcePolicy[i] != '\0'; i++)
1084 {
1085 zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1086 }
1087 have_zcons_force_policy = 1;
1088 return 1;
1089 break;
1090
1091 case DOUBLE:
1092 the_event->err_msg =
1093 strdup( "Global error. zconsForcePolicy is not a double or int.\n" );
1094 return 0;
1095 break;
1096
1097 case INT:
1098 the_event->err_msg =
1099 strdup( "Global error. zconsForcePolicy is not a double or int.\n" );
1100 return 0;
1101 break;
1102
1103 default:
1104 the_event->err_msg =
1105 strdup( "Global error. zconsForcePolicy unrecognized.\n" );
1106 return 0;
1107 break;
1108 }
1109 break;
1110 // add more token cases here.
1111 case G_SEED:
1112 switch( the_type ){
1113
1114 case STRING:
1115 the_event->err_msg =
1116 strdup( "Global error. seed is not a string.\n" );
1117 return 0;
1118 return 0;
1119 break;
1120
1121 case DOUBLE:
1122 have_seed = 1;
1123 seed = (int)the_event->evt.asmt.rhs.dval;
1124 return 1;
1125 break;
1126
1127 case INT:
1128 have_seed = 1;
1129 seed = the_event->evt.asmt.rhs.ival ;
1130 return 1;
1131 break;
1132
1133 default:
1134 the_event->err_msg =
1135 strdup( "Global error. seed unrecognized.\n" );
1136 return 0;
1137 break;
1138 }
1139 break;
1140 // add more token cases here.
1141
1142 }
1143 }
1144
1145 switch( the_type ){
1146
1147 case STRING:
1148 sprintf( err,
1149 "Global error. Unrecognized assignment:\n"
1150 "\t-> %s = %s\n",
1151 lhs, the_event->evt.asmt.rhs.sval );
1152 break;
1153
1154 case DOUBLE:
1155 sprintf( err,
1156 "Global error. Unrecognized assignment:\n"
1157 "\t-> %s = %lf\n",
1158 lhs, the_event->evt.asmt.rhs.dval );
1159 break;
1160
1161 case INT:
1162 sprintf( err,
1163 "Global error. Unrecognized assignment:\n"
1164 "\t-> %s = %d\n",
1165 lhs, the_event->evt.asmt.rhs.ival );
1166 break;
1167
1168 default:
1169 sprintf( err,
1170 "Global error. Unrecognized assignment:\n"
1171 "\t-> %s = ?\n",
1172 lhs );
1173 break;
1174 }
1175
1176 the_event->err_msg = strdup( err );
1177 return 0;
1178 }
1179
1180 char* Globals::checkMe( void ){
1181
1182 char err[300];
1183 short int have_err = 0;
1184
1185 strcpy( err, "Global error. The following are required:\n" );
1186
1187 if( !have_force_field ){
1188 strcat( err, "\t->forceField\n" );
1189 have_err= 1;
1190 }
1191
1192 if( !have_n_components ){
1193 strcat( err, "\t->nComponents\n" );
1194 have_err= 1;
1195 }
1196
1197 if( !have_target_temp ){
1198 strcat( err, "\t->targetTemp\n" );
1199 have_err= 1;
1200 }
1201
1202 if( !have_ensemble ){
1203 strcat( err, "\t->ensemble\n" );
1204 have_err= 1;
1205 }
1206
1207 if( !have_dt ){
1208 strcat( err, "\t->dt\n" );
1209 have_err= 1;
1210 }
1211
1212 if( !have_run_time ){
1213 strcat( err, "\t->runTime\n" );
1214 have_err= 1;
1215 }
1216
1217 if( have_err ) return strdup( err );
1218
1219 return NULL;
1220 }
1221
1222 int Globals::globalEnd( event* the_event ){
1223
1224 the_event->err_msg = checkMe();
1225 if( the_event->err_msg != NULL ) return 0;
1226
1227 return 1;
1228 }
1229
1230 int Globals::hash( char* text ){
1231
1232 register unsigned short int i = 0; // loop counter
1233 int key = 0; // the hash key
1234
1235 while( text[i] != '\0' ){
1236
1237 key = ( ( key << hash_shift ) + text[i] ) % hash_size;
1238
1239 i++;
1240 }
1241
1242 if( key < 0 ){
1243
1244 // if the key is less than zero, we've had an overflow error
1245
1246 sprintf( painCave.errMsg,
1247 "There has been an overflow error in the Globals' hash key.");
1248 painCave.isFatal = 1;
1249 simError();
1250 #ifdef IS_MPI
1251 if( painCave.isEventLoop ){
1252 if( worldRank == 0 ) mpiInterfaceExit();
1253 }
1254 #endif //is_mpi
1255 }
1256
1257 return key;
1258 }
1259
1260 void Globals::addHash( char* text, int token ){
1261
1262 int key;
1263 LinkedCommand* the_element;
1264
1265 the_element = new LinkedCommand;
1266 the_element->setValues( text, token );
1267
1268 key = hash( text );
1269 the_element->setNext( command_table[key] );
1270 command_table[key] = the_element;
1271 }