ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 693
Committed: Wed Aug 13 19:21:53 2003 UTC (20 years, 10 months ago) by tim
File size: 24704 byte(s)
Log Message: 
harmonic potential & z-contraint method

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