ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 957
Committed: Mon Jan 19 16:08:21 2004 UTC (20 years, 5 months ago) by gezelter
File size: 29670 byte(s)
Log Message: 
BASS changes to add RigidBodies and LJrcut

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