ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1066
Committed: Tue Feb 24 16:36:33 2004 UTC (20 years, 4 months ago) by tim
File size: 35992 byte(s)
Log Message: 
*** empty log message ***

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