ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1137
Committed: Wed Apr 28 21:39:12 2004 UTC (20 years, 4 months ago) by gezelter
File size: 39182 byte(s)
Log Message: 
useMolecularCutoffs added to Globals

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