ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1153
Committed: Tue May 11 04:21:52 2004 UTC (20 years, 11 months ago) by gezelter
File size: 37863 byte(s)
Log Message: 
BASS changes for adding CutoffGroups to molecules.  Also restructured
the plethora of cutoff radii into one cutoffRadius and one
switchingRadius.  Also removed the useMolecularCutoffs keyword

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