ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1135
Committed: Mon Apr 26 21:16:07 2004 UTC (20 years, 2 months ago) by mmeineke
File size: 38497 byte(s)
Log Message: 
modified the defaults for the system init time and system init state.

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