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