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