ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 747
Committed: Fri Sep 5 21:28:52 2003 UTC (20 years, 9 months ago) by gezelter
File size: 26839 byte(s)
Log Message: 
Changes to autoconf / configure method of configuring OOPSE

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