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

# 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 481 #define G_QMASS 26
48     #define G_TAUTHERMOSTAT 27
49     #define G_TAUBAROSTAT 28
50 mmeineke 377
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 gezelter 394 addHash( "electrostaticCutoffRadius", G_ECR );
80 mmeineke 377 addHash( "dielectric", G_DIELECTRIC );
81     addHash( "tempSet", G_TEMPSET );
82     addHash( "thermalTime", G_THERMALTIME );
83     addHash( "mixingRule", G_MIXINGRULE);
84 gezelter 394 addHash( "usePeriodicBoundaryConditions", G_USEPBC);
85     addHash( "electrostaticSkinThickness", G_EST );
86     addHash( "useReactionField", G_USERF );
87 gezelter 465 addHash( "targetPressure", G_TARGETPRESSURE);
88 gezelter 474 addHash( "qMass", G_QMASS);
89 gezelter 481 addHash( "tauThermostat", G_TAUTHERMOSTAT);
90     addHash( "tauBarostat", G_TAUBAROSTAT);
91 mmeineke 377
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 gezelter 394 useRF = 0;
97 mmeineke 377
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 gezelter 394 have_ecr = 0;
118 mmeineke 377 have_dielectric = 0;
119     have_tempSet = 0;
120 gezelter 394 have_est = 0;
121 gezelter 465 have_target_pressure =0;
122 gezelter 474 have_q_mass = 0;
123 gezelter 481 have_tau_thermostat = 0;
124     have_tau_barostat = 0;
125 mmeineke 377 }
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 gezelter 394 case G_ECR:
660 mmeineke 377 switch( the_type ){
661    
662     case STRING:
663     the_event->err_msg =
664 gezelter 394 strdup( "Global error. electrostaticCutoffRadius is not a double or int.\n" );
665 mmeineke 377 return 0;
666     break;
667    
668     case DOUBLE:
669 gezelter 394 ecr = the_event->evt.asmt.rhs.dval;
670     have_ecr = 1;
671 mmeineke 377 return 1;
672     break;
673    
674     case INT:
675 gezelter 394 ecr = (double)the_event->evt.asmt.rhs.ival;
676     have_ecr = 1;
677 mmeineke 377 return 1;
678     break;
679    
680     default:
681     the_event->err_msg =
682 gezelter 394 strdup( "Global error. electrostaticCutoffRadius unrecognized.\n" );
683 mmeineke 377 return 0;
684     break;
685     }
686     break;
687 gezelter 394
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 mmeineke 377
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 gezelter 465 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 mmeineke 377 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 gezelter 465 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 mmeineke 377 else{
771     the_event->err_msg =
772 gezelter 394 strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
773 mmeineke 377 return 0;
774     }
775     return 1;
776     }
777    
778     the_event->err_msg =
779 gezelter 394 strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
780 mmeineke 377 return 0;
781     break;
782 gezelter 394
783     case G_USERF:
784     if( the_type == STRING ){
785    
786 gezelter 465 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 gezelter 394 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 gezelter 465 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 gezelter 394
830 gezelter 474 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 gezelter 481 case G_TAUTHERMOSTAT:
860 gezelter 474 switch( the_type ){
861    
862     case STRING:
863     the_event->err_msg =
864 gezelter 481 strdup( "Global error. tauThermostat is not a double or int.\n" );
865 gezelter 474 return 0;
866     break;
867    
868     case DOUBLE:
869 gezelter 481 tau_thermostat = the_event->evt.asmt.rhs.dval;
870     have_tau_thermostat = 1;
871 gezelter 474 return 1;
872     break;
873    
874     case INT:
875 gezelter 481 tau_thermostat = (double)the_event->evt.asmt.rhs.ival;
876     have_tau_thermostat = 1;
877 gezelter 474 return 1;
878     break;
879    
880     default:
881     the_event->err_msg =
882 gezelter 481 strdup( "Global error. tauThermostat unrecognized.\n" );
883 gezelter 474 return 0;
884     break;
885     }
886     break;
887    
888 gezelter 481 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 mmeineke 377 }
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     }