ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 689
Committed: Tue Aug 12 19:56:49 2003 UTC (20 years, 10 months ago) by tim
File size: 24746 byte(s)
Log Message: 
debugging globals

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