ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 704
Committed: Wed Aug 20 19:11:51 2003 UTC (20 years, 10 months ago) by tim
File size: 26187 byte(s)
Log Message: 
bug fixed in ghost bend class

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