ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1093
Committed: Wed Mar 17 14:22:59 2004 UTC (20 years, 3 months ago) by tim
File size: 38257 byte(s)
Log Message: 
incorporate SMD into ZConstraint,it does not sound a good choice, next commit will seperate SMD and ZConstraint

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