ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 745
Committed: Thu Sep 4 21:48:07 2003 UTC (20 years, 10 months ago) by mmeineke
File size: 26802 byte(s)
Log Message: 
added resetTime to the Global namespace.

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