ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 855
Committed: Thu Nov 6 22:01:37 2003 UTC (20 years, 8 months ago) by mmeineke
File size: 28927 byte(s)
Log Message: 
added the following parameters to BASS:
   * useInitialExtendedSystemState
   * orthoBoxTolerance
   * useIntiTime => useInitialTime

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