ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 689
Committed: Tue Aug 12 19:56:49 2003 UTC (20 years, 10 months ago) by tim
File size: 24746 byte(s)
Log Message: 
debugging globals

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