ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1091
Committed: Tue Mar 16 19:22:56 2004 UTC (20 years, 3 months ago) by tim
File size: 37433 byte(s)
Log Message: 
ZConstraint now can support sequential moving. Refactorying is needed to support SMD in ZConstraint

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