ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1252
Committed: Mon Jun 7 14:26:33 2004 UTC (20 years, 1 month ago) by gezelter
File size: 41455 byte(s)
Log Message: 
Fixes from gcc -Wall

File Contents

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