ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 655
Committed: Tue Jul 29 16:32:06 2003 UTC (20 years, 11 months ago) by mmeineke
File size: 21277 byte(s)
Log Message: 
*** empty log message ***

File Contents

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