ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 675
Committed: Mon Aug 11 19:38:44 2003 UTC (20 years, 11 months ago) by mmeineke
File size: 24031 byte(s)
Log Message: 
Added zConstraint into the BASS language syntax.

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