ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 828
Committed: Tue Oct 28 16:03:06 2003 UTC (20 years, 8 months ago) by gezelter
File size: 27500 byte(s)
Log Message: 
replace c++ header stuff with more portable c header stuff
Also, mod file fixes and portability changes

File Contents

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