ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 675
Committed: Mon Aug 11 19:38:44 2003 UTC (20 years, 10 months ago) by mmeineke
File size: 24031 byte(s)
Log Message: 
Added zConstraint into the BASS language syntax.

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