ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 659
Committed: Thu Jul 31 15:38:08 2003 UTC (22 years, 3 months ago) by tim
File size: 22455 byte(s)
Log Message: 
added z-constraint parameters to the globals

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