ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 828
Committed: Tue Oct 28 16:03:06 2003 UTC (20 years, 8 months ago) by gezelter
File size: 27500 byte(s)
Log Message: 
replace c++ header stuff with more portable c header stuff
Also, mod file fixes and portability changes

File Contents

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