ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/io/Globals.cpp
Revision: 3
Committed: Fri Sep 24 16:27:58 2004 UTC (20 years, 7 months ago) by tim
File size: 44315 byte(s)
Log Message: 
change the #include in source files

File Contents

# User Rev Content
1 gezelter 2 #include <stdlib.h>
2     #include <stdio.h>
3     #include <string.h>
4    
5 tim 3 #include "io/Globals.hpp"
6     #include "utils/simError.h"
7 gezelter 2 #ifdef IS_MPI
8 tim 3 #include "io/mpiBASS.h"
9 gezelter 2 #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     #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_RCUT 17
39     #define G_RSW 18
40     #define G_DIELECTRIC 19
41     #define G_TEMPSET 20
42     #define G_THERMALTIME 21
43     #define G_USEPBC 22
44     #define G_MIXINGRULE 23
45     #define G_USERF 24
46     #define G_TARGETPRESSURE 25
47     #define G_TAUTHERMOSTAT 26
48     #define G_TAUBAROSTAT 27
49     #define G_ZCONSTIME 28
50     #define G_NZCONSTRAINTS 29
51     #define G_ZCONSTOL 30
52     #define G_ZCONSFORCEPOLICY 31
53     #define G_SEED 32
54     #define G_RESETTIME 33
55     #define G_USEINITTIME 34
56     #define G_USEINIT_XS_STATE 35
57     #define G_ORTHOBOXTOLERANCE 36
58     #define G_MINIMIZER 37
59     #define G_MIN_MAXITER 38
60     #define G_MIN_WRITEFRQ 39
61     #define G_MIN_STEPSIZE 40
62     #define G_MIN_FTOL 41
63     #define G_MIN_GTOL 42
64     #define G_MIN_LSTOL 43
65     #define G_MIN_LSMAXITER 44
66     #define G_ZCONSGAP 45
67     #define G_ZCONSFIXTIME 46
68     #define G_ZCONSUSINGSMD 47
69     #define G_USE_SOLID_THERM_INT 48
70     #define G_USE_LIQUID_THERM_INT 49
71     #define G_THERM_INT_LAMBDA 50
72     #define G_THERM_INT_K 51
73     #define G_FORCEFIELD_VARIANT 52
74    
75     Globals::Globals(){
76     initalize();
77     }
78    
79     Globals::~Globals(){
80     int i;
81    
82     for( i=0; i<hash_size; i++ ){
83     if( command_table[i] != NULL ) delete command_table[i];
84     }
85     delete[] command_table;
86    
87     if( components != NULL ){
88     for( i=0; i<n_components; i++ ) delete components[i];
89     delete[] components;
90     }
91     }
92    
93     void Globals::initalize(){
94     int i;
95    
96     hash_size = 23;
97     hash_shift = 4;
98    
99     components = NULL;
100    
101     command_table = new LinkedCommand*[hash_size];
102     for( i=0; i<hash_size; i++ ) command_table[i] = NULL;
103    
104     addHash( "forceField", G_FORCEFIELD );
105     addHash( "nComponents", G_NCOMPONENTS );
106     addHash( "targetTemp", G_TARGETTEMP );
107     addHash( "ensemble", G_ENSEMBLE );
108    
109     addHash( "dt", G_DT );
110     addHash( "runTime", G_RUNTIME );
111    
112     addHash( "initialConfig", G_INITIALCONFIG );
113     addHash( "finalConfig", G_FINALCONFIG );
114     addHash( "nMol", G_NMOL );
115     addHash( "density", G_DENSITY );
116     addHash( "box", G_BOX );
117     addHash( "boxX", G_BOXX );
118     addHash( "boxY", G_BOXY );
119     addHash( "boxZ", G_BOXZ );
120     addHash( "sampleTime", G_SAMPLETIME );
121     addHash( "resetTime", G_RESETTIME );
122     addHash( "statusTime", G_STATUSTIME );
123     addHash( "cutoffRadius", G_RCUT );
124     addHash( "switchingRadius", G_RSW );
125     addHash( "dielectric", G_DIELECTRIC );
126     addHash( "tempSet", G_TEMPSET );
127     addHash( "thermalTime", G_THERMALTIME );
128     addHash( "mixingRule", G_MIXINGRULE);
129     addHash( "usePeriodicBoundaryConditions", G_USEPBC);
130     addHash( "useReactionField", G_USERF );
131     addHash( "targetPressure", G_TARGETPRESSURE);
132     addHash( "tauThermostat", G_TAUTHERMOSTAT);
133     addHash( "tauBarostat", G_TAUBAROSTAT);
134     addHash( "zconsTime", G_ZCONSTIME);
135     addHash( "nZconstraints", G_NZCONSTRAINTS);
136     addHash( "zconsTol", G_ZCONSTOL);
137     addHash( "zconsForcePolicy", G_ZCONSFORCEPOLICY);
138     addHash( "seed", G_SEED);
139     addHash( "useInitialTime", G_USEINITTIME);
140     addHash( "useInitialExtendedSystemState", G_USEINIT_XS_STATE);
141     addHash( "orthoBoxTolerance", G_ORTHOBOXTOLERANCE);
142     addHash( "minimizer", G_MINIMIZER);
143     addHash( "minimizerMaxIter", G_MIN_MAXITER);
144     addHash( "minimizerWriteFrq", G_MIN_WRITEFRQ);
145     addHash( "minimizerStepSize", G_MIN_STEPSIZE);
146     addHash( "minimizerFTol", G_MIN_FTOL);
147     addHash( "minimizerGTol", G_MIN_GTOL);
148     addHash( "minimizerLSTol", G_MIN_LSTOL);
149     addHash( "minimizerLSMaxIter", G_MIN_LSMAXITER);
150     addHash( "zconsGap", G_ZCONSGAP);
151     addHash( "zconsFixtime", G_ZCONSFIXTIME);
152     addHash( "zconsUsingSMD", G_ZCONSUSINGSMD);
153     addHash( "useSolidThermInt", G_USE_SOLID_THERM_INT);
154     addHash( "useLiquidThermInt", G_USE_LIQUID_THERM_INT);
155     addHash( "thermodynamicIntegrationLambda", G_THERM_INT_LAMBDA);
156     addHash( "thermodynamicIntegrationK", G_THERM_INT_K);
157     addHash( "forceFieldVariant", G_FORCEFIELD_VARIANT);
158    
159     strcpy( mixingRule,"standard"); //default mixing rules to standard.
160     usePBC = 1; //default periodic boundry conditions to on
161     useRF = 0;
162     useInitTime = 0; // default to pull init time from the init file
163     useInitXSstate = 0; // default to pull the extended state from the init file
164     orthoBoxTolerance = 1E-6;
165     useSolidThermInt = 0; // default solid-state thermodynamic integration to off
166     useLiquidThermInt = 0; // default liquid thermodynamic integration to off
167    
168     have_force_field = 0;
169     have_n_components = 0;
170     have_target_temp = 0;
171     have_ensemble = 0;
172     have_dt = 0;
173     have_run_time = 0;
174    
175     have_initial_config = 0;
176     have_final_config = 0;
177     have_n_mol = 0;
178     have_density = 0;
179     have_box = 0;
180     have_box_x = 0;
181     have_box_y = 0;
182     have_box_y = 0;
183     have_box_z = 0;
184     have_sample_time = 0;
185     have_status_time = 0;
186     have_reset_time = 0;
187     have_thermal_time = 0;
188     have_rcut = 0;
189     have_rsw = 0;
190     have_dielectric = 0;
191     have_tempSet = 0;
192     have_target_pressure =0;
193     have_q_mass = 0;
194     have_tau_thermostat = 0;
195     have_tau_barostat = 0;
196     have_zcons_time = 0;
197     have_n_zConstraints = 0;
198     have_zConstraints = 0;
199     have_zcons_tol = 0;
200     have_zcons_gap = 0;
201     have_zcons_fixtime = 0;
202     have_zcons_using_smd = 0;
203     have_seed = 0;
204     have_minimizer = 0;
205     have_minimizer_maxiteration = 0;
206     have_minimizer_writefrq = 0;
207     have_minimizer_stepsize = 0;
208     have_minimizer_ftol = 0;
209     have_minimizer_gtol = 0;
210     have_minimizer_ls_tol = 0;
211     have_minimizer_ls_maxiteration = 0;
212     have_thermodynamic_integration_lambda = 0;
213     have_thermodynamic_integration_k = 0;
214     have_forcefield_variant = 0;
215    
216     }
217    
218     int Globals::newComponent( event* the_event ){
219    
220     current_component = new Component;
221     int index = the_event->evt.blk_index;
222     char err[200];
223    
224     if( have_n_components && index < n_components )
225     components[index] = current_component;
226     else{
227     if( have_n_components ){
228     sprintf( err, "meta-data parsing error: %d out of nComponents range",
229     index );
230     the_event->err_msg = strdup( err );
231     return 0;
232     }
233     else{
234     the_event->err_msg = strdup("meta-data parsing error: nComponents not given before"
235     " first component declaration." );
236     return 0;
237     }
238     }
239    
240     return 1;
241     }
242    
243    
244    
245     int Globals::componentAssign( event* the_event ){
246    
247     switch( the_event->evt.asmt.asmt_type ){
248    
249     case STRING:
250     return current_component->assignString( the_event->evt.asmt.lhs,
251     the_event->evt.asmt.rhs.sval,
252     &(the_event->err_msg));
253     break;
254    
255     case DOUBLE:
256     return current_component->assignDouble( the_event->evt.asmt.lhs,
257     the_event->evt.asmt.rhs.dval,
258     &(the_event->err_msg));
259     break;
260    
261     case INT:
262     return current_component->assignInt( the_event->evt.asmt.lhs,
263     the_event->evt.asmt.rhs.ival,
264     &(the_event->err_msg));
265     break;
266    
267     default:
268     the_event->err_msg = strdup( "Globals error. Invalid component"
269     " assignment type" );
270     return 0;
271     break;
272     }
273     return 0;
274     }
275    
276     int Globals::componentEnd( event* the_event ){
277    
278     the_event->err_msg = current_component->checkMe();
279     if( the_event->err_msg != NULL ) return 0;
280    
281     return 1;
282     }
283    
284     int Globals::newZconstraint( event* the_event ){
285    
286    
287     int index = the_event->evt.blk_index;
288     char err[200];
289     current_zConstraint = new ZconStamp( index );
290    
291     have_zConstraints = 1;
292    
293     if( have_n_zConstraints && index < n_zConstraints )
294     zConstraints[index] = current_zConstraint;
295     else{
296     if( have_n_zConstraints ){
297     sprintf( err, "meta-data parsing error: %d out of nZconstraints range",
298     index );
299     the_event->err_msg = strdup( err );
300     return 0;
301     }
302     else{
303     the_event->err_msg = strdup("meta-data parsing error: nZconstraints"
304     " not given before"
305     " first zConstraint declaration." );
306     return 0;
307     }
308     }
309    
310     return 1;
311     }
312    
313    
314    
315     int Globals::zConstraintAssign( event* the_event ){
316    
317     switch( the_event->evt.asmt.asmt_type ){
318    
319     case STRING:
320     return current_zConstraint->assignString( the_event->evt.asmt.lhs,
321     the_event->evt.asmt.rhs.sval,
322     &(the_event->err_msg));
323     break;
324    
325     case DOUBLE:
326     return current_zConstraint->assignDouble( the_event->evt.asmt.lhs,
327     the_event->evt.asmt.rhs.dval,
328     &(the_event->err_msg));
329     break;
330    
331     case INT:
332     return current_zConstraint->assignInt( the_event->evt.asmt.lhs,
333     the_event->evt.asmt.rhs.ival,
334     &(the_event->err_msg));
335     break;
336    
337     default:
338     the_event->err_msg = strdup( "Globals error. Invalid zConstraint"
339     " assignment type" );
340     return 0;
341     break;
342     }
343     return 0;
344     }
345    
346     int Globals::zConstraintEnd( event* the_event ){
347    
348     the_event->err_msg = current_zConstraint->checkMe();
349     if( the_event->err_msg != NULL ) return 0;
350    
351     return 1;
352     }
353    
354     int Globals::globalAssign( event* the_event ){
355    
356     int key;
357     int token;
358     interface_assign_type the_type = the_event->evt.asmt.asmt_type;
359     char* lhs = the_event->evt.asmt.lhs;
360     char err[300];
361    
362     token = 0;
363     key = hash( lhs );
364     if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
365    
366     if( token ){
367    
368     switch( token ){
369    
370     case G_FORCEFIELD:
371     if( the_type == STRING ){
372     strcpy( force_field, the_event->evt.asmt.rhs.sval );
373     have_force_field = 1;
374     return 1;
375     }
376    
377     the_event->err_msg =
378     strdup( "Error in parsing meta-data file!\n\tforceField was not a string assignment.\n" );
379     return 0;
380     break;
381    
382     case G_NCOMPONENTS:
383     if( the_type == STRING ){
384     the_event->err_msg =
385     strdup("Error in parsing meta-data file!\n\tnComponents is not a double or an int.\n" );
386     return 0;
387     }
388    
389     else if( the_type == DOUBLE ){
390     n_components = (int)the_event->evt.asmt.rhs.dval;
391     components = new Component*[n_components];
392     have_n_components = 1;
393     return 1;
394     }
395    
396     else{
397     n_components = the_event->evt.asmt.rhs.ival;
398     components = new Component*[n_components];
399     have_n_components = 1;
400     return 1;
401     }
402     break;
403    
404     case G_NZCONSTRAINTS:
405     if( the_type == STRING ){
406     the_event->err_msg =
407     strdup("Error in parsing meta-data file!\n\tnZconstraints is not a double or an int.\n" );
408     return 0;
409     }
410    
411     else if( the_type == DOUBLE ){
412     n_zConstraints = (int)the_event->evt.asmt.rhs.dval;
413     zConstraints = new ZconStamp*[n_zConstraints];
414     have_n_zConstraints = 1;
415     return 1;
416     }
417    
418     else{
419     n_zConstraints = the_event->evt.asmt.rhs.ival;
420     zConstraints = new ZconStamp*[n_zConstraints];
421     have_n_zConstraints = 1;
422     return 1;
423     }
424     break;
425    
426     case G_TARGETTEMP:
427     switch( the_type ){
428    
429     case STRING:
430     the_event->err_msg =
431     strdup( "Error in parsing meta-data file!\n\ttargetTemp is not a double or int.\n" );
432     return 0;
433     break;
434    
435     case DOUBLE:
436     target_temp = the_event->evt.asmt.rhs.dval;
437     have_target_temp = 1;
438     return 1;
439     break;
440    
441     case INT:
442     target_temp = (double)the_event->evt.asmt.rhs.ival;
443     have_target_temp = 1;
444     return 1;
445     break;
446    
447     default:
448     the_event->err_msg =
449     strdup( "Error in parsing meta-data file!\n\ttargetTemp unrecognized.\n" );
450     return 0;
451     break;
452     }
453     break;
454    
455     case G_ORTHOBOXTOLERANCE:
456     switch( the_type ){
457    
458     case STRING:
459     the_event->err_msg =
460     strdup( "Error in parsing meta-data file!\n\torthoBoxTolerance is not a double or int.\n" );
461     return 0;
462     break;
463    
464     case DOUBLE:
465     orthoBoxTolerance = the_event->evt.asmt.rhs.dval;
466     have_target_temp = 1;
467     return 1;
468     break;
469    
470     case INT:
471     orthoBoxTolerance = (double)the_event->evt.asmt.rhs.ival;
472     have_target_temp = 1;
473     return 1;
474     break;
475    
476     default:
477     the_event->err_msg =
478     strdup( "Global error.orthoBoxTolerance unrecognized.\n" );
479     return 0;
480     break;
481     }
482     break;
483    
484     case G_ENSEMBLE:
485     if( the_type == STRING ){
486     strcpy( ensemble, the_event->evt.asmt.rhs.sval );
487     have_ensemble = 1;
488     return 1;
489     }
490    
491     the_event->err_msg =
492     strdup( "Error in parsing meta-data file!\n\tensemble was not assigned to a string\n" );
493     return 0;
494     break;
495    
496     case G_MIXINGRULE:
497     if( the_type == STRING ){
498     strcpy( mixingRule, the_event->evt.asmt.rhs.sval );
499     return 1;
500     }
501    
502     the_event->err_msg =
503     strdup( "Error in parsing meta-data file!\n\tmixing rule was not assigned to a string\n" );
504     return 0;
505     break;
506    
507     case G_DT:
508     switch( the_type ){
509    
510     case STRING:
511     the_event->err_msg =
512     strdup( "Error in parsing meta-data file!\n\tdt is not a double or int.\n" );
513     return 0;
514     break;
515    
516     case DOUBLE:
517     dt = the_event->evt.asmt.rhs.dval;
518     have_dt = 1;
519     return 1;
520     break;
521    
522     case INT:
523     dt = (double)the_event->evt.asmt.rhs.ival;
524     have_dt = 1;
525     return 1;
526     break;
527    
528     default:
529     the_event->err_msg =
530     strdup( "Error in parsing meta-data file!\n\tdt unrecognized.\n" );
531     return 0;
532     break;
533     }
534     break;
535    
536     case G_RUNTIME:
537     switch( the_type ){
538    
539     case STRING:
540     the_event->err_msg =
541     strdup( "Error in parsing meta-data file!\n\trunTime is not a double or int.\n" );
542     return 0;
543     break;
544    
545     case DOUBLE:
546     run_time = the_event->evt.asmt.rhs.dval;
547     have_run_time = 1;
548     return 1;
549     break;
550    
551     case INT:
552     run_time = (double)the_event->evt.asmt.rhs.ival;
553     have_run_time = 1;
554     return 1;
555     break;
556    
557     default:
558     the_event->err_msg =
559     strdup( "Error in parsing meta-data file!\n\trunTime unrecognized.\n" );
560     return 0;
561     break;
562     }
563     break;
564    
565     case G_INITIALCONFIG:
566     if( the_type == STRING ){
567     strcpy( initial_config, the_event->evt.asmt.rhs.sval );
568     have_initial_config = 1;
569     return 1;
570     }
571    
572     the_event->err_msg =
573     strdup( "Error in parsing meta-data file!\n\tinitialConfig was not a string assignment.\n" );
574     return 0;
575     break;
576    
577     case G_FINALCONFIG:
578     if( the_type == STRING ){
579     strcpy( final_config, the_event->evt.asmt.rhs.sval );
580     have_final_config = 1;
581     return 1;
582     }
583    
584     the_event->err_msg =
585     strdup( "Error in parsing meta-data file!\n\tfinalConfig was not a string assignment.\n" );
586     return 0;
587     break;
588    
589     case G_NMOL:
590     switch( the_type ){
591    
592     case STRING:
593     the_event->err_msg =
594     strdup( "Error in parsing meta-data file!\n\tnMol is not a double or int.\n" );
595     return 0;
596     break;
597    
598     case DOUBLE:
599     n_mol = (int)the_event->evt.asmt.rhs.dval;
600     have_n_mol = 1;
601     return 1;
602     break;
603    
604     case INT:
605     n_mol = the_event->evt.asmt.rhs.ival;
606     have_n_mol = 1;
607     return 1;
608     break;
609    
610     default:
611     the_event->err_msg =
612     strdup( "Error in parsing meta-data file!\n\tnMol unrecognized.\n" );
613     return 0;
614     break;
615     }
616     break;
617    
618     case G_DENSITY:
619     switch( the_type ){
620    
621     case STRING:
622     the_event->err_msg =
623     strdup( "Error in parsing meta-data file!\n\tdensity is not a double or int.\n" );
624     return 0;
625     break;
626    
627     case DOUBLE:
628     density = the_event->evt.asmt.rhs.dval;
629     have_density = 1;
630     return 1;
631     break;
632    
633     case INT:
634     density = (double)the_event->evt.asmt.rhs.ival;
635     have_density = 1;
636     return 1;
637     break;
638    
639     default:
640     the_event->err_msg =
641     strdup( "Error in parsing meta-data file!\n\tdensity unrecognized.\n" );
642     return 0;
643     break;
644     }
645     break;
646    
647     case G_BOX:
648     switch( the_type ){
649    
650     case STRING:
651     the_event->err_msg =
652     strdup( "Error in parsing meta-data file!\n\tbox is not a double or int.\n" );
653     return 0;
654     break;
655    
656     case DOUBLE:
657     box = the_event->evt.asmt.rhs.dval;
658     have_box = 1;
659     return 1;
660     break;
661    
662     case INT:
663     box = (double)the_event->evt.asmt.rhs.ival;
664     have_box = 1;
665     return 1;
666     break;
667    
668     default:
669     the_event->err_msg =
670     strdup( "Error in parsing meta-data file!\n\tbox unrecognized.\n" );
671     return 0;
672     break;
673     }
674     break;
675    
676     case G_BOXX:
677     switch( the_type ){
678    
679     case STRING:
680     the_event->err_msg =
681     strdup( "Error in parsing meta-data file!\n\tboxX is not a double or int.\n" );
682     return 0;
683     break;
684    
685     case DOUBLE:
686     box_x = the_event->evt.asmt.rhs.dval;
687     have_box_x = 1;
688     return 1;
689     break;
690    
691     case INT:
692     box_x = (double)the_event->evt.asmt.rhs.ival;
693     have_box_x = 1;
694     return 1;
695     break;
696    
697     default:
698     the_event->err_msg =
699     strdup( "Error in parsing meta-data file!\n\tboxX unrecognized.\n" );
700     return 0;
701     break;
702     }
703     break;
704    
705     case G_BOXY:
706     switch( the_type ){
707    
708     case STRING:
709     the_event->err_msg =
710     strdup( "Error in parsing meta-data file!\n\tboxY is not a double or int.\n" );
711     return 0;
712     break;
713    
714     case DOUBLE:
715     box_y = the_event->evt.asmt.rhs.dval;
716     have_box_y = 1;
717     return 1;
718     break;
719    
720     case INT:
721     box_y = (double)the_event->evt.asmt.rhs.ival;
722     have_box_y = 1;
723     return 1;
724     break;
725    
726     default:
727     the_event->err_msg =
728     strdup( "Error in parsing meta-data file!\n\tboxY unrecognized.\n" );
729     return 0;
730     break;
731     }
732     break;
733    
734     case G_BOXZ:
735     switch( the_type ){
736    
737     case STRING:
738     the_event->err_msg =
739     strdup( "Error in parsing meta-data file!\n\tboxZ is not a double or int.\n" );
740     return 0;
741     break;
742    
743     case DOUBLE:
744     box_z = the_event->evt.asmt.rhs.dval;
745     have_box_z = 1;
746     return 1;
747     break;
748    
749     case INT:
750     box_z = (double)the_event->evt.asmt.rhs.ival;
751     have_box_z = 1;
752     return 1;
753     break;
754    
755     default:
756     the_event->err_msg =
757     strdup( "Error in parsing meta-data file!\n\tboxZ unrecognized.\n" );
758     return 0;
759     break;
760     }
761     break;
762    
763     case G_SAMPLETIME:
764     switch( the_type ){
765    
766     case STRING:
767     the_event->err_msg =
768     strdup( "Error in parsing meta-data file!\n\tsampleTime is not a double or int.\n" );
769     return 0;
770     break;
771    
772     case DOUBLE:
773     sample_time = the_event->evt.asmt.rhs.dval;
774     have_sample_time = 1;
775     return 1;
776     break;
777    
778     case INT:
779     sample_time = (double)the_event->evt.asmt.rhs.ival;
780     have_sample_time = 1;
781     return 1;
782     break;
783    
784     default:
785     the_event->err_msg =
786     strdup( "Error in parsing meta-data file!\n\tsampleTime unrecognized.\n" );
787     return 0;
788     break;
789     }
790     break;
791    
792     case G_STATUSTIME:
793     switch( the_type ){
794    
795     case STRING:
796     the_event->err_msg =
797     strdup( "Error in parsing meta-data file!\n\tstatusTime is not a double or int.\n" );
798     return 0;
799     break;
800    
801     case DOUBLE:
802     status_time = the_event->evt.asmt.rhs.dval;
803     have_status_time = 1;
804     return 1;
805     break;
806    
807     case INT:
808     status_time = (double)the_event->evt.asmt.rhs.ival;
809     have_status_time = 1;
810     return 1;
811     break;
812    
813     default:
814     the_event->err_msg =
815     strdup( "Error in parsing meta-data file!\n\tstatusTime unrecognized.\n" );
816     return 0;
817     break;
818     }
819     break;
820    
821     case G_RESETTIME:
822     switch( the_type ){
823    
824     case STRING:
825     the_event->err_msg =
826     strdup( "Error in parsing meta-data file!\n\tresetTime is not a double or int.\n" );
827     return 0;
828     break;
829    
830     case DOUBLE:
831     resetTime = the_event->evt.asmt.rhs.dval;
832     have_reset_time = 1;
833     return 1;
834     break;
835    
836     case INT:
837     resetTime = (double)the_event->evt.asmt.rhs.ival;
838     have_reset_time = 1;
839     return 1;
840     break;
841    
842     default:
843     the_event->err_msg =
844     strdup( "Error in parsing meta-data file!\n\tresetTime unrecognized.\n" );
845     return 0;
846     break;
847     }
848     break;
849    
850     case G_THERMALTIME:
851     switch( the_type ){
852    
853     case STRING:
854     the_event->err_msg =
855     strdup( "Error in parsing meta-data file!\n\tthermalTime is not a double or int.\n" );
856     return 0;
857     break;
858    
859     case DOUBLE:
860     thermal_time = the_event->evt.asmt.rhs.dval;
861     have_thermal_time = 1;
862     return 1;
863     break;
864    
865     case INT:
866     thermal_time = (double)the_event->evt.asmt.rhs.ival;
867     have_thermal_time = 1;
868     return 1;
869     break;
870    
871     default:
872     the_event->err_msg =
873     strdup( "Error in parsing meta-data file!\n\tthermalTime unrecognized.\n" );
874     return 0;
875     break;
876     }
877     break;
878    
879     case G_RCUT:
880     switch( the_type ){
881    
882     case STRING:
883     the_event->err_msg =
884     strdup( "Error in parsing meta-data file!\n\tcutoffRadius is not a double or int.\n" );
885     return 0;
886     break;
887    
888     case DOUBLE:
889     rcut = the_event->evt.asmt.rhs.dval;
890     have_rcut = 1;
891     return 1;
892     break;
893    
894     case INT:
895     rcut = (double)the_event->evt.asmt.rhs.ival;
896     have_rcut = 1;
897     return 1;
898     break;
899    
900     default:
901     the_event->err_msg =
902     strdup( "Error in parsing meta-data file!\n\tcutoffRadius unrecognized.\n" );
903     return 0;
904     break;
905     }
906     break;
907    
908     case G_RSW:
909     switch( the_type ){
910    
911     case STRING:
912     the_event->err_msg =
913     strdup( "Error in parsing meta-data file!\n\tswitchingRadius is not a double or int.\n" );
914     return 0;
915     break;
916    
917     case DOUBLE:
918     rsw = the_event->evt.asmt.rhs.dval;
919     have_rsw = 1;
920     return 1;
921     break;
922    
923     case INT:
924     rsw = (double)the_event->evt.asmt.rhs.ival;
925     have_rsw = 1;
926     return 1;
927     break;
928    
929     default:
930     the_event->err_msg =
931     strdup( "Error in parsing meta-data file!\n\tswitchingRadius unrecognized.\n" );
932     return 0;
933     break;
934     }
935     break;
936    
937     case G_DIELECTRIC:
938     switch( the_type ){
939    
940     case STRING:
941     the_event->err_msg =
942     strdup( "Error in parsing meta-data file!\n\tdielectric is not a double or int.\n" );
943     return 0;
944     break;
945    
946     case DOUBLE:
947     dielectric = the_event->evt.asmt.rhs.dval;
948     have_dielectric = 1;
949     return 1;
950     break;
951    
952     case INT:
953     dielectric = (double)the_event->evt.asmt.rhs.ival;
954     have_dielectric = 1;
955     return 1;
956     break;
957    
958     default:
959     the_event->err_msg =
960     strdup( "Error in parsing meta-data file!\n\tdielectric unrecognized.\n" );
961     return 0;
962     break;
963     }
964     break;
965    
966     case G_TEMPSET:
967     if( the_type == STRING ){
968    
969     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
970     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
971     else{
972     the_event->err_msg =
973     strdup( "Error in parsing meta-data file!\n\ttempSet was not \"true\" or \"false\".\n" );
974     return 0;
975     }
976     have_tempSet = 1;
977     return 1;
978     }
979    
980     the_event->err_msg =
981     strdup( "Error in parsing meta-data file!\n\ttempSet was not \"true\" or \"false\".\n" );
982     return 0;
983     break;
984    
985     case G_USEINITTIME:
986     if( the_type == STRING ){
987    
988     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useInitTime = 1;
989     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useInitTime = 0;
990     else{
991     the_event->err_msg =
992     strdup( "Error in parsing meta-data file!\n\tuseInitTime was not \"true\" or \"false\".\n" );
993     return 0;
994     }
995     return 1;
996     }
997    
998     the_event->err_msg =
999     strdup( "Error in parsing meta-data file!\n\tuseInitTime was not \"true\" or \"false\".\n" );
1000     return 0;
1001     break;
1002    
1003     case G_USEINIT_XS_STATE:
1004     if( the_type == STRING ){
1005    
1006     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval ))
1007     useInitXSstate = 1;
1008     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval ))
1009     useInitXSstate = 0;
1010     else{
1011     the_event->err_msg =
1012     strdup( "Error in parsing meta-data file!\n\tuseInitExtendedSystemState was not \"true\" or \"false\".\n" );
1013     return 0;
1014     }
1015     return 1;
1016     }
1017    
1018     the_event->err_msg =
1019     strdup( "Error in parsing meta-data file!\n\tuseInitExtendedSystemState was not \"true\" or \"false\".\n" );
1020     return 0;
1021     break;
1022    
1023     case G_USEPBC:
1024     if( the_type == STRING ){
1025    
1026     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
1027     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
1028     else{
1029     the_event->err_msg =
1030     strdup( "Error in parsing meta-data file!\n\tusePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
1031     return 0;
1032     }
1033     return 1;
1034     }
1035    
1036     the_event->err_msg =
1037     strdup( "Error in parsing meta-data file!\n\tusePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
1038     return 0;
1039     break;
1040    
1041     case G_USERF:
1042     if( the_type == STRING ){
1043    
1044     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
1045     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0;
1046     else{
1047     the_event->err_msg =
1048     strdup( "Error in parsing meta-data file!\n\tuseReactionField was not \"true\" or \"false\".\n" );
1049     return 0;
1050     }
1051     return 1;
1052     }
1053    
1054     the_event->err_msg =
1055     strdup( "Error in parsing meta-data file!\n\tuseReactionField was not \"true\" or \"false\".\n" );
1056     return 0;
1057     break;
1058    
1059     case G_TARGETPRESSURE:
1060     switch( the_type ){
1061    
1062     case STRING:
1063     the_event->err_msg =
1064     strdup( "Error in parsing meta-data file!\n\ttargetPressure is not a double or int.\n" );
1065     return 0;
1066     break;
1067    
1068     case DOUBLE:
1069     target_pressure = the_event->evt.asmt.rhs.dval;
1070     have_target_pressure = 1;
1071     return 1;
1072     break;
1073    
1074     case INT:
1075     target_pressure = (double)the_event->evt.asmt.rhs.ival;
1076     have_target_pressure = 1;
1077     return 1;
1078     break;
1079    
1080     default:
1081     the_event->err_msg =
1082     strdup( "Error in parsing meta-data file!\n\ttargetPressure unrecognized.\n" );
1083     return 0;
1084     break;
1085     }
1086     break;
1087    
1088     case G_TAUTHERMOSTAT:
1089     switch( the_type ){
1090    
1091     case STRING:
1092     the_event->err_msg =
1093     strdup( "Error in parsing meta-data file!\n\ttauThermostat is not a double or int.\n" );
1094     return 0;
1095     break;
1096    
1097     case DOUBLE:
1098     tau_thermostat = the_event->evt.asmt.rhs.dval;
1099     have_tau_thermostat = 1;
1100     return 1;
1101     break;
1102    
1103     case INT:
1104     tau_thermostat = (double)the_event->evt.asmt.rhs.ival;
1105     have_tau_thermostat = 1;
1106     return 1;
1107     break;
1108    
1109     default:
1110     the_event->err_msg =
1111     strdup( "Error in parsing meta-data file!\n\ttauThermostat unrecognized.\n" );
1112     return 0;
1113     break;
1114     }
1115     break;
1116    
1117     case G_TAUBAROSTAT:
1118     switch( the_type ){
1119    
1120     case STRING:
1121     the_event->err_msg =
1122     strdup( "Error in parsing meta-data file!\n\ttauBarostat is not a double or int.\n" );
1123     return 0;
1124     break;
1125    
1126     case DOUBLE:
1127     tau_barostat = the_event->evt.asmt.rhs.dval;
1128     have_tau_barostat = 1;
1129     return 1;
1130     break;
1131    
1132     case INT:
1133     tau_barostat = (double)the_event->evt.asmt.rhs.ival;
1134     have_tau_barostat = 1;
1135     return 1;
1136     break;
1137    
1138     default:
1139     the_event->err_msg =
1140     strdup( "Error in parsing meta-data file!\n\ttauBarostat unrecognized.\n" );
1141     return 0;
1142     break;
1143     }
1144     break;
1145    
1146     case G_ZCONSTIME:
1147     switch( the_type ){
1148    
1149     case STRING:
1150     the_event->err_msg =
1151     strdup( "Error in parsing meta-data file!\n\tzcons_time is not a double or int.\n" );
1152     return 0;
1153     break;
1154    
1155     case DOUBLE:
1156     zcons_time = the_event->evt.asmt.rhs.dval;
1157     have_zcons_time = 1;
1158     return 1;
1159     break;
1160    
1161     case INT:
1162     zcons_time = (double)the_event->evt.asmt.rhs.ival;
1163     have_zcons_time = 1;
1164     return 1;
1165     break;
1166    
1167     default:
1168     the_event->err_msg =
1169     strdup( "Error in parsing meta-data file!\n\tzcons_time unrecognized.\n" );
1170     return 0;
1171     break;
1172     }
1173     break;
1174    
1175     case G_ZCONSTOL:
1176     switch( the_type ){
1177    
1178     case STRING:
1179     the_event->err_msg =
1180     strdup( "Error in parsing meta-data file!\n\tzcons_tol is not a double or int.\n" );
1181     return 0;
1182     break;
1183    
1184     case DOUBLE:
1185     zcons_tol = the_event->evt.asmt.rhs.dval;
1186     have_zcons_tol = 1;
1187     return 1;
1188     break;
1189    
1190     case INT:
1191     zcons_tol = (double)the_event->evt.asmt.rhs.ival;
1192     have_zcons_tol = 1;
1193     return 1;
1194     break;
1195    
1196     default:
1197     the_event->err_msg =
1198     strdup( "Error in parsing meta-data file!\n\tzcons_ol unrecognized.\n" );
1199     return 0;
1200     break;
1201     }
1202     break;
1203    
1204     case G_ZCONSFORCEPOLICY:
1205     switch( the_type ){
1206    
1207     case STRING:
1208     strcpy(zconsForcePolicy, the_event->evt.asmt.rhs.sval);
1209    
1210     for(int i = 0; zconsForcePolicy[i] != '\0'; i++)
1211     {
1212     zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1213     }
1214     have_zcons_force_policy = 1;
1215     return 1;
1216     break;
1217    
1218     case DOUBLE:
1219     the_event->err_msg =
1220     strdup( "Error in parsing meta-data file!\n\tzconsForcePolicy is not a double or int.\n" );
1221     return 0;
1222     break;
1223    
1224     case INT:
1225     the_event->err_msg =
1226     strdup( "Error in parsing meta-data file!\n\tzconsForcePolicy is not a double or int.\n" );
1227     return 0;
1228     break;
1229    
1230     default:
1231     the_event->err_msg =
1232     strdup( "Error in parsing meta-data file!\n\tzconsForcePolicy unrecognized.\n" );
1233     return 0;
1234     break;
1235     }
1236     break;
1237    
1238     case G_ZCONSGAP:
1239     switch( the_type ){
1240    
1241     case STRING:
1242     the_event->err_msg =
1243     strdup( "Error in parsing meta-data file!\n\tzcons_gap is not a double or int.\n" );
1244     return 0;
1245     break;
1246    
1247     case DOUBLE:
1248     zcons_gap = the_event->evt.asmt.rhs.dval;
1249     have_zcons_gap= 1;
1250     return 1;
1251     break;
1252    
1253     case INT:
1254     zcons_gap= (double)the_event->evt.asmt.rhs.ival;
1255     have_zcons_gap= 1;
1256     return 1;
1257     break;
1258    
1259     default:
1260     the_event->err_msg =
1261     strdup( "Error in parsing meta-data file!\n\tzcons_gap unrecognized.\n" );
1262     return 0;
1263     break;
1264     }
1265     break;
1266    
1267     case G_ZCONSFIXTIME:
1268     switch( the_type ){
1269    
1270     case STRING:
1271     the_event->err_msg =
1272     strdup( "Error in parsing meta-data file!\n\tzcons_fixtime is not a double or int.\n" );
1273     return 0;
1274     break;
1275    
1276     case DOUBLE:
1277     zcons_fixtime= the_event->evt.asmt.rhs.dval;
1278     have_zcons_fixtime= 1;
1279     return 1;
1280     break;
1281    
1282     case INT:
1283     zcons_fixtime= (double)the_event->evt.asmt.rhs.ival;
1284     have_zcons_fixtime= 1;
1285     return 1;
1286     break;
1287    
1288     default:
1289     the_event->err_msg =
1290     strdup( "Error in parsing meta-data file!\n\tzcons_fixtime unrecognized.\n" );
1291     return 0;
1292     break;
1293     }
1294     break;
1295    
1296     case G_ZCONSUSINGSMD:
1297     switch( the_type ){
1298    
1299     case STRING:
1300     the_event->err_msg =
1301     strdup( "Error in parsing meta-data file!\n\tzcons_fixtime is not an int.\n" );
1302     return 0;
1303     break;
1304    
1305     case DOUBLE:
1306     the_event->err_msg =
1307     strdup( "Error in parsing meta-data file!\n\tzcons_fixtime is not an int.\n" );
1308     return 0;
1309     break;
1310    
1311     case INT:
1312     zcons_using_smd= the_event->evt.asmt.rhs.ival;
1313     have_zcons_using_smd= 1;
1314     return 1;
1315     break;
1316    
1317     default:
1318     the_event->err_msg =
1319     strdup( "Error in parsing meta-data file!\n\tzcons_usingsmd unrecognized.\n" );
1320     return 0;
1321     break;
1322     }
1323     break;
1324    
1325     case G_MINIMIZER:
1326     switch( the_type ){
1327    
1328     case STRING:
1329     strcpy(minimizer_name, the_event->evt.asmt.rhs.sval);
1330    
1331     for(int i = 0; zconsForcePolicy[i] != '\0'; i++){
1332     zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1333     }
1334     have_minimizer= 1;
1335     return 1;
1336     break;
1337    
1338     case DOUBLE:
1339     the_event->err_msg =
1340     strdup( "Error in parsing meta-data file!\n\tminimizer_name is not a double or int.\n" );
1341     return 0;
1342     break;
1343    
1344     case INT:
1345     the_event->err_msg =
1346     strdup( "Error in parsing meta-data file!\n\tminimizer_name is not a double or int.\n" );
1347     return 0;
1348     break;
1349    
1350     default:
1351     the_event->err_msg =
1352     strdup( "Error in parsing meta-data file!\n\tminimizer_name unrecognized.\n" );
1353     return 0;
1354     break;
1355     }
1356     break;
1357    
1358     case G_MIN_MAXITER:
1359     switch( the_type ){
1360    
1361     case STRING:
1362     the_event->err_msg =
1363     strdup( "Error in parsing meta-data file!\n\tminimizer_maxiteration is not a double or int.\n" );
1364     return 1;
1365     break;
1366    
1367     case DOUBLE:
1368     minimizer_maxiteration = (int)the_event->evt.asmt.rhs.dval;
1369     have_minimizer_maxiteration = 1;
1370     return 1;
1371     break;
1372    
1373     case INT:
1374     minimizer_maxiteration = the_event->evt.asmt.rhs.ival;
1375     have_minimizer_maxiteration = 1;
1376     return 1;
1377     break;
1378    
1379     default:
1380     the_event->err_msg =
1381     strdup( "Error in parsing meta-data file!\n\tminimizer_maxiteration unrecognized.\n" );
1382     return 0;
1383     break;
1384     }
1385     break;
1386    
1387     case G_MIN_WRITEFRQ:
1388     switch( the_type ){
1389    
1390     case STRING:
1391     the_event->err_msg =
1392     strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq is not a double or int.\n" );
1393     return 1;
1394     break;
1395    
1396     case DOUBLE:
1397     minimizer_writefrq= the_event->evt.asmt.rhs.dval;
1398     have_minimizer_writefrq = 1;
1399     return 1;
1400     break;
1401    
1402     case INT:
1403     minimizer_writefrq= the_event->evt.asmt.rhs.ival;
1404     have_minimizer_writefrq = 1;
1405     return 1;
1406     break;
1407    
1408     default:
1409     the_event->err_msg =
1410     strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq unrecognized.\n" );
1411     return 0;
1412     break;
1413     }
1414     break;
1415    
1416     case G_MIN_STEPSIZE:
1417     switch( the_type ){
1418    
1419     case STRING:
1420     the_event->err_msg =
1421     strdup( "Error in parsing meta-data file!\n\tminimizer_resetfrq is not a double or int.\n" );
1422     return 1;
1423     break;
1424    
1425     case DOUBLE:
1426     minimizer_stepsize= the_event->evt.asmt.rhs.dval;
1427     have_minimizer_stepsize = 1;
1428     return 1;
1429     break;
1430    
1431     case INT:
1432     minimizer_stepsize= the_event->evt.asmt.rhs.ival;
1433     have_minimizer_stepsize = 1;
1434     return 1;
1435     break;
1436    
1437     default:
1438     the_event->err_msg =
1439     strdup( "Error in parsing meta-data file!\n\tminimizer_resetfrq unrecognized.\n" );
1440     return 0;
1441     break;
1442     }
1443     break;
1444    
1445     case G_MIN_FTOL:
1446     switch( the_type ){
1447    
1448     case STRING:
1449     the_event->err_msg =
1450     strdup( "Error in parsing meta-data file!\n\tminimizer_ftol is not a double or int.\n" );
1451     return 1;
1452     break;
1453    
1454     case DOUBLE:
1455     minimizer_ftol= the_event->evt.asmt.rhs.dval;
1456     have_minimizer_ftol = 1;
1457     return 1;
1458     break;
1459    
1460     case INT:
1461     minimizer_ftol= the_event->evt.asmt.rhs.ival;
1462     have_minimizer_ftol = 1;
1463     return 1;
1464     break;
1465    
1466     default:
1467     the_event->err_msg =
1468     strdup( "Error in parsing meta-data file!\n\tminimizer_ftol unrecognized.\n" );
1469     return 0;
1470     break;
1471     }
1472     break;
1473    
1474     case G_MIN_GTOL:
1475     switch( the_type ){
1476    
1477     case STRING:
1478     the_event->err_msg =
1479     strdup( "Error in parsing meta-data file!\n\tminimizer_gtol is not a double or int.\n" );
1480     return 1;
1481     break;
1482    
1483     case DOUBLE:
1484     minimizer_gtol= the_event->evt.asmt.rhs.dval;
1485     have_minimizer_gtol = 1;
1486     return 1;
1487     break;
1488    
1489     case INT:
1490     minimizer_gtol= the_event->evt.asmt.rhs.ival;
1491     have_minimizer_gtol = 1;
1492     return 1;
1493     break;
1494    
1495     default:
1496     the_event->err_msg =
1497     strdup( "Error in parsing meta-data file!\n\tminimizer_gtol unrecognized.\n" );
1498     return 0;
1499     break;
1500     }
1501     break;
1502    
1503     case G_MIN_LSMAXITER:
1504     switch( the_type ){
1505    
1506     case STRING:
1507     the_event->err_msg =
1508     strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration is not a double or int.\n" );
1509     return 1;
1510     break;
1511    
1512     case DOUBLE:
1513     minimizer_ls_maxiteration = the_event->evt.asmt.rhs.dval;
1514     have_minimizer_ls_maxiteration = 1;
1515     return 1;
1516     break;
1517    
1518     case INT:
1519     minimizer_ls_maxiteration = the_event->evt.asmt.rhs.ival;
1520     have_minimizer_ls_maxiteration = 1;
1521     return 1;
1522     break;
1523    
1524     default:
1525     the_event->err_msg =
1526     strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration unrecognized.\n" );
1527     return 0;
1528     break;
1529     }
1530     break;
1531    
1532     case G_MIN_LSTOL:
1533     switch( the_type ){
1534    
1535     case STRING:
1536     the_event->err_msg =
1537     strdup( "Error in parsing meta-data file!\n\tminimizer_ls_tol is not a double or int.\n" );
1538     return 1;
1539     break;
1540    
1541     case DOUBLE:
1542     minimizer_ls_tol= the_event->evt.asmt.rhs.dval;
1543     have_minimizer_ls_tol = 1;
1544     return 1;
1545     break;
1546    
1547     case INT:
1548     minimizer_ls_tol= the_event->evt.asmt.rhs.ival;
1549     have_minimizer_ls_tol = 1;
1550     return 1;
1551     break;
1552    
1553     default:
1554     the_event->err_msg =
1555     strdup( "Error in parsing meta-data file!\n\tminimizer_ls_tol unrecognized.\n" );
1556     return 0;
1557     break;
1558     }
1559     break;
1560    
1561     // add more token cases here.
1562     case G_SEED:
1563     switch( the_type ){
1564    
1565     case STRING:
1566     the_event->err_msg =
1567     strdup( "Error in parsing meta-data file!\n\tseed is not a string.\n" );
1568     return 0;
1569     return 0;
1570     break;
1571    
1572     case DOUBLE:
1573     have_seed = 1;
1574     seed = (int)the_event->evt.asmt.rhs.dval;
1575     return 1;
1576     break;
1577    
1578     case INT:
1579     have_seed = 1;
1580     seed = the_event->evt.asmt.rhs.ival ;
1581     return 1;
1582     break;
1583    
1584     default:
1585     the_event->err_msg =
1586     strdup( "Error in parsing meta-data file!\n\tseed unrecognized.\n" );
1587     return 0;
1588     break;
1589     }
1590     break;
1591    
1592     case G_USE_SOLID_THERM_INT:
1593     if( the_type == STRING ){
1594    
1595     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useSolidThermInt = 1;
1596     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useSolidThermInt = 0;
1597     else{
1598     the_event->err_msg =
1599     strdup( "Error in parsing meta-data file!\n\tuseSolidThermInt was not \"true\" or \"false\".\n" );
1600     return 0;
1601     }
1602     return 1;
1603     }
1604    
1605     the_event->err_msg =
1606     strdup( "Error in parsing meta-data file!\n\tuseSolidThermInt was not \"true\" or \"false\".\n" );
1607     return 0;
1608     break;
1609    
1610     case G_USE_LIQUID_THERM_INT:
1611     if( the_type == STRING ){
1612    
1613     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useLiquidThermInt = 1;
1614     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useLiquidThermInt = 0;
1615     else{
1616     the_event->err_msg =
1617     strdup( "Error in parsing meta-data file!\n\tuseLiquidThermInt was not \"true\" or \"false\".\n" );
1618     return 0;
1619     }
1620     return 1;
1621     }
1622    
1623     the_event->err_msg =
1624     strdup( "Error in parsing meta-data file!\n\tuseLiquidThermInt was not \"true\" or \"false\".\n" );
1625     return 0;
1626     break;
1627    
1628     case G_THERM_INT_LAMBDA:
1629     switch( the_type ){
1630    
1631     case STRING:
1632     the_event->err_msg =
1633     strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationLambda is not a double or int.\n" );
1634     return 1;
1635     break;
1636    
1637     case DOUBLE:
1638     thermodynamic_integration_lambda = the_event->evt.asmt.rhs.dval;
1639     have_thermodynamic_integration_lambda = 1;
1640     return 1;
1641     break;
1642    
1643     case INT:
1644     thermodynamic_integration_lambda = (double)the_event->evt.asmt.rhs.dval;
1645     have_thermodynamic_integration_lambda = 1;
1646     return 1;
1647     break;
1648    
1649     default:
1650     the_event->err_msg =
1651     strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationLambda unrecognized.\n" );
1652     return 0;
1653     break;
1654     }
1655     break;
1656    
1657     case G_THERM_INT_K:
1658     switch( the_type ){
1659    
1660     case STRING:
1661     the_event->err_msg =
1662     strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationK is not a double or int.\n" );
1663     return 1;
1664     break;
1665    
1666     case DOUBLE:
1667     thermodynamic_integration_k = the_event->evt.asmt.rhs.dval;
1668     have_thermodynamic_integration_k = 1;
1669     return 1;
1670     break;
1671    
1672     case INT:
1673     thermodynamic_integration_k = (double)the_event->evt.asmt.rhs.dval;
1674     have_thermodynamic_integration_k = 1;
1675     return 1;
1676     break;
1677    
1678     default:
1679     the_event->err_msg =
1680     strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationK unrecognized.\n" );
1681     return 0;
1682     break;
1683     }
1684     break;
1685     case G_FORCEFIELD_VARIANT:
1686     if( the_type == STRING ){
1687     strcpy( forcefield_variant, the_event->evt.asmt.rhs.sval );
1688     have_forcefield_variant = 1;
1689     return 1;
1690     }
1691    
1692     the_event->err_msg =
1693     strdup( "Error in parsing meta-data file!\n\tforceFieldVariant was not a string assignment.\n" );
1694     return 0;
1695     break;
1696     // add more token cases here.
1697     }
1698     }
1699    
1700     switch( the_type ){
1701    
1702     case STRING:
1703     sprintf( err,
1704     "\tUnrecognized assignment:\n"
1705     "\t\t-> %s = %s\n",
1706     lhs, the_event->evt.asmt.rhs.sval );
1707     break;
1708    
1709     case DOUBLE:
1710     sprintf( err,
1711     "\tUnrecognized assignment:\n"
1712     "\t\t-> %s = %lf\n",
1713     lhs, the_event->evt.asmt.rhs.dval );
1714     break;
1715    
1716     case INT:
1717     sprintf( err,
1718     "\tUnrecognized assignment:\n"
1719     "\t\t-> %s = %d\n",
1720     lhs, the_event->evt.asmt.rhs.ival );
1721     break;
1722    
1723     default:
1724     sprintf( err,
1725     "\tUnrecognized assignment:\n"
1726     "\t\t-> %s = ?\n",
1727     lhs );
1728     break;
1729     }
1730    
1731     the_event->err_msg = strdup( err );
1732     return 0;
1733     }
1734    
1735     char* Globals::checkMe( void ){
1736    
1737     char err[300];
1738     short int have_err = 0;
1739    
1740     strcpy( err, "The following required keywords are missing:\n" );
1741    
1742     if( !have_force_field ){
1743     strcat( err, "\t\t->forceField\n" );
1744     have_err= 1;
1745     }
1746    
1747     if( !have_n_components ){
1748     strcat( err, "\t\t->nComponents\n" );
1749     have_err= 1;
1750     }
1751    
1752    
1753     if ( !have_ensemble ) {
1754     // I'm not doing MD:
1755     if ( !have_minimizer ) {
1756     // I'm not doing MD or minimization:
1757     strcat( err, "\t\t->either ensemble or minimizer must be set!\n" );
1758     have_err = 1;
1759     } else {
1760     // I'm a minimizer:
1761     }
1762     } else {
1763     // I *am* doing MD:
1764     if( !have_dt ){
1765     strcat( err, "\t\t->dt (timestep in fs)\n" );
1766     have_err= 1;
1767     }
1768     if( !have_run_time ){
1769     strcat( err, "\t\t->runTime (total run time in fs)\n" );
1770     have_err= 1;
1771     }
1772     }
1773    
1774     if( have_err ) return strdup( err );
1775    
1776     return NULL;
1777     }
1778    
1779     int Globals::globalEnd( event* the_event ){
1780    
1781     the_event->err_msg = checkMe();
1782     if( the_event->err_msg != NULL ) return 0;
1783    
1784     return 1;
1785     }
1786    
1787     int Globals::hash( char* text ){
1788    
1789     register unsigned short int i = 0; // loop counter
1790     int key = 0; // the hash key
1791    
1792     while( text[i] != '\0' ){
1793    
1794     key = ( ( key << hash_shift ) + text[i] ) % hash_size;
1795    
1796     i++;
1797     }
1798    
1799     if( key < 0 ){
1800    
1801     // if the key is less than zero, we've had an overflow error
1802    
1803     sprintf( painCave.errMsg,
1804     "There has been an overflow error in the Globals' hash key.");
1805     painCave.isFatal = 1;
1806     simError();
1807     #ifdef IS_MPI
1808     if( painCave.isEventLoop ){
1809     if( worldRank == 0 ) mpiInterfaceExit();
1810     }
1811     #endif //is_mpi
1812     }
1813    
1814     return key;
1815     }
1816    
1817     void Globals::addHash( char* text, int token ){
1818    
1819     int key;
1820     LinkedCommand* the_element;
1821    
1822     the_element = new LinkedCommand;
1823     the_element->setValues( text, token );
1824    
1825     key = hash( text );
1826    
1827     the_element->setNext( command_table[key] );
1828     command_table[key] = the_element;
1829     }