ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 682
Committed: Tue Aug 12 17:51:33 2003 UTC (20 years, 10 months ago) by tim
File size: 24689 byte(s)
Log Message: 
added harmonical potential to z-constraint method

File Contents

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