ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 747
Committed: Fri Sep 5 21:28:52 2003 UTC (20 years, 10 months ago) by gezelter
File size: 26839 byte(s)
Log Message: 
Changes to autoconf / configure method of configuring OOPSE

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