ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 704
Committed: Wed Aug 20 19:11:51 2003 UTC (20 years, 11 months ago) by tim
File size: 26187 byte(s)
Log Message: 
bug fixed in ghost bend class

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