ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 481
Committed: Tue Apr 8 21:35:49 2003 UTC (21 years, 3 months ago) by gezelter
File size: 21831 byte(s)
Log Message: 
Fixes for NPT / NVT

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