ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 855
Committed: Thu Nov 6 22:01:37 2003 UTC (20 years, 8 months ago) by mmeineke
File size: 28927 byte(s)
Log Message: 
added the following parameters to BASS:
   * useInitialExtendedSystemState
   * orthoBoxTolerance
   * useIntiTime => useInitialTime

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     #define G_FORCEFIELD 1
21     #define G_NCOMPONENTS 2
22     #define G_TARGETTEMP 3
23     #define G_ENSEMBLE 4
24     #define G_DT 5
25     #define G_RUNTIME 6
26    
27     //optional parameters
28 gezelter 481 #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 gezelter 465 #define G_TARGETPRESSURE 25
47 gezelter 579 #define G_TAUTHERMOSTAT 26
48     #define G_TAUBAROSTAT 27
49 tim 659 #define G_ZCONSTIME 28
50 mmeineke 675 #define G_NZCONSTRAINTS 29
51 mmeineke 745 #define G_ZCONSTOL 30
52 tim 699 #define G_ZCONSFORCEPOLICY 31
53 mmeineke 745 #define G_SEED 32
54     #define G_RESETTIME 33
55 mmeineke 811 #define G_USEINITTIME 34
56 mmeineke 855 #define G_USEINIT_XS_STATE 35
57     #define G_ORTHOBOXTOLERANCE 36
58 mmeineke 377
59 mmeineke 855
60 mmeineke 377 Globals::Globals(){
61    
62     int i;
63 gezelter 747
64     hash_size = 23;
65     hash_shift = 4;
66 mmeineke 377
67     components = NULL;
68    
69     command_table = new LinkedCommand*[hash_size];
70     for( i=0; i<hash_size; i++ ) command_table[i] = NULL;
71    
72     addHash( "forceField", G_FORCEFIELD );
73     addHash( "nComponents", G_NCOMPONENTS );
74     addHash( "targetTemp", G_TARGETTEMP );
75     addHash( "ensemble", G_ENSEMBLE );
76    
77     addHash( "dt", G_DT );
78     addHash( "runTime", G_RUNTIME );
79    
80     addHash( "initialConfig", G_INITIALCONFIG );
81     addHash( "finalConfig", G_FINALCONFIG );
82     addHash( "nMol", G_NMOL );
83     addHash( "density", G_DENSITY );
84     addHash( "box", G_BOX );
85     addHash( "boxX", G_BOXX );
86     addHash( "boxY", G_BOXY );
87     addHash( "boxZ", G_BOXZ );
88     addHash( "sampleTime", G_SAMPLETIME );
89 mmeineke 745 addHash( "resetTime", G_RESETTIME );
90 mmeineke 377 addHash( "statusTime", G_STATUSTIME );
91 gezelter 394 addHash( "electrostaticCutoffRadius", G_ECR );
92 mmeineke 377 addHash( "dielectric", G_DIELECTRIC );
93     addHash( "tempSet", G_TEMPSET );
94     addHash( "thermalTime", G_THERMALTIME );
95     addHash( "mixingRule", G_MIXINGRULE);
96 gezelter 394 addHash( "usePeriodicBoundaryConditions", G_USEPBC);
97     addHash( "electrostaticSkinThickness", G_EST );
98     addHash( "useReactionField", G_USERF );
99 gezelter 465 addHash( "targetPressure", G_TARGETPRESSURE);
100 gezelter 481 addHash( "tauThermostat", G_TAUTHERMOSTAT);
101     addHash( "tauBarostat", G_TAUBAROSTAT);
102 mmeineke 675 addHash( "zconsTime", G_ZCONSTIME);
103     addHash( "nZconstraints", G_NZCONSTRAINTS);
104 mmeineke 745 addHash( "zconsTol", G_ZCONSTOL);
105     addHash( "zconsForcePolicy", G_ZCONSFORCEPOLICY);
106     addHash( "seed", G_SEED);
107 mmeineke 855 addHash( "useInitialTime", G_USEINITTIME);
108     addHash( "useInitialExtendedSystemState", G_USEINIT_XS_STATE);
109     addHash( "orthoBoxTolerance", G_ORTHOBOXTOLERANCE);
110 tim 682
111 tim 699
112 mmeineke 377 // define some default values
113    
114     strcpy( mixingRule,"standard"); //default mixing rules to standard.
115     usePBC = 1; //default periodic boundry conditions to on
116 gezelter 394 useRF = 0;
117 mmeineke 811 useInitTime = 1; // default to pull init time from the init file
118 mmeineke 855 useInitXSstate = 1; // default to pull the extended state from the init file
119     orthoBoxTolerance = 1E-6;
120    
121 mmeineke 377 have_force_field = 0;
122     have_n_components = 0;
123     have_target_temp = 0;
124     have_ensemble = 0;
125     have_dt = 0;
126     have_run_time = 0;
127    
128     have_initial_config = 0;
129     have_final_config = 0;
130     have_n_mol = 0;
131     have_density = 0;
132     have_box = 0;
133     have_box_x = 0;
134     have_box_y = 0;
135     have_box_y = 0;
136     have_box_z = 0;
137     have_sample_time = 0;
138     have_status_time = 0;
139 mmeineke 745 have_reset_time = 0;
140 mmeineke 377 have_thermal_time = 0;
141 gezelter 394 have_ecr = 0;
142 mmeineke 377 have_dielectric = 0;
143     have_tempSet = 0;
144 gezelter 394 have_est = 0;
145 gezelter 465 have_target_pressure =0;
146 gezelter 474 have_q_mass = 0;
147 gezelter 481 have_tau_thermostat = 0;
148 mmeineke 675 have_tau_barostat = 0;
149 tim 682 have_zcons_time = 0;
150 mmeineke 675 have_n_zConstraints = 0;
151     have_zConstraints = 0;
152 tim 682 have_zcons_tol = 0;
153 tim 704 have_seed = 0;
154 mmeineke 377
155 tim 689 }
156    
157 mmeineke 377 Globals::~Globals(){
158     int i;
159    
160     for( i=0; i<hash_size; i++ ){
161     if( command_table[i] != NULL ) delete command_table[i];
162     }
163     delete[] command_table;
164    
165     if( components != NULL ){
166     for( i=0; i<n_components; i++ ) delete components[i];
167     delete[] components;
168     }
169     }
170    
171     int Globals::newComponent( event* the_event ){
172    
173     current_component = new Component;
174     int index = the_event->evt.blk_index;
175     char err[200];
176    
177     if( have_n_components && index < n_components )
178     components[index] = current_component;
179     else{
180     if( have_n_components ){
181     sprintf( err, "Globals error, %d out of nComponents range",
182     index );
183     the_event->err_msg = strdup( err );
184     return 0;
185     }
186     else{
187     the_event->err_msg = strdup("Globals error, nComponents not given before"
188     "first component declaration." );
189     return 0;
190     }
191     }
192    
193     return 1;
194     }
195    
196    
197    
198     int Globals::componentAssign( event* the_event ){
199    
200     switch( the_event->evt.asmt.asmt_type ){
201    
202     case STRING:
203     return current_component->assignString( the_event->evt.asmt.lhs,
204     the_event->evt.asmt.rhs.sval,
205     &(the_event->err_msg));
206     break;
207    
208     case DOUBLE:
209     return current_component->assignDouble( the_event->evt.asmt.lhs,
210     the_event->evt.asmt.rhs.dval,
211     &(the_event->err_msg));
212     break;
213    
214     case INT:
215     return current_component->assignInt( the_event->evt.asmt.lhs,
216     the_event->evt.asmt.rhs.ival,
217     &(the_event->err_msg));
218     break;
219    
220     default:
221     the_event->err_msg = strdup( "Globals error. Invalid component"
222     " assignment type" );
223     return 0;
224     break;
225     }
226     return 0;
227     }
228    
229 mmeineke 675 int Globals::componentEnd( event* the_event ){
230 mmeineke 377
231 mmeineke 675 the_event->err_msg = current_component->checkMe();
232     if( the_event->err_msg != NULL ) return 0;
233    
234 mmeineke 377 return 1;
235     }
236    
237 mmeineke 675 int Globals::newZconstraint( event* the_event ){
238    
239 mmeineke 377
240 mmeineke 675 int index = the_event->evt.blk_index;
241     char err[200];
242     current_zConstraint = new ZconStamp( index );
243    
244     have_zConstraints = 1;
245    
246     if( have_n_zConstraints && index < n_zConstraints )
247     zConstraints[index] = current_zConstraint;
248     else{
249     if( have_n_zConstraints ){
250     sprintf( err, "Globals error, %d out of nZconstraints range",
251     index );
252     the_event->err_msg = strdup( err );
253     return 0;
254     }
255     else{
256     the_event->err_msg = strdup("Globals error, nZconstraints"
257     " not given before"
258     " first zConstraint declaration." );
259     return 0;
260     }
261     }
262    
263     return 1;
264     }
265    
266    
267    
268     int Globals::zConstraintAssign( event* the_event ){
269    
270     switch( the_event->evt.asmt.asmt_type ){
271    
272     case STRING:
273     return current_zConstraint->assignString( the_event->evt.asmt.lhs,
274 tim 689 the_event->evt.asmt.rhs.sval,
275     &(the_event->err_msg));
276 mmeineke 675 break;
277    
278     case DOUBLE:
279     return current_zConstraint->assignDouble( the_event->evt.asmt.lhs,
280 tim 689 the_event->evt.asmt.rhs.dval,
281     &(the_event->err_msg));
282 mmeineke 675 break;
283    
284     case INT:
285     return current_zConstraint->assignInt( the_event->evt.asmt.lhs,
286 tim 689 the_event->evt.asmt.rhs.ival,
287     &(the_event->err_msg));
288 mmeineke 675 break;
289    
290     default:
291     the_event->err_msg = strdup( "Globals error. Invalid zConstraint"
292     " assignment type" );
293     return 0;
294     break;
295     }
296     return 0;
297     }
298    
299     int Globals::zConstraintEnd( event* the_event ){
300    
301     the_event->err_msg = current_zConstraint->checkMe();
302 mmeineke 377 if( the_event->err_msg != NULL ) return 0;
303    
304     return 1;
305     }
306    
307     int Globals::globalAssign( event* the_event ){
308    
309     int key;
310     int token;
311     interface_assign_type the_type = the_event->evt.asmt.asmt_type;
312     char* lhs = the_event->evt.asmt.lhs;
313     char err[300];
314    
315     token = 0;
316     key = hash( lhs );
317     if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
318    
319     if( token ){
320    
321     switch( token ){
322    
323     case G_FORCEFIELD:
324     if( the_type == STRING ){
325     strcpy( force_field, the_event->evt.asmt.rhs.sval );
326     have_force_field = 1;
327     return 1;
328     }
329    
330     the_event->err_msg =
331     strdup( "Global error. forceField was not a string assignment.\n" );
332     return 0;
333     break;
334    
335     case G_NCOMPONENTS:
336     if( the_type == STRING ){
337     the_event->err_msg =
338     strdup("Global error. nComponents is not a double or an int.\n" );
339     return 0;
340     }
341    
342     else if( the_type == DOUBLE ){
343     n_components = (int)the_event->evt.asmt.rhs.dval;
344     components = new Component*[n_components];
345     have_n_components = 1;
346     return 1;
347     }
348    
349     else{
350     n_components = the_event->evt.asmt.rhs.ival;
351     components = new Component*[n_components];
352     have_n_components = 1;
353     return 1;
354     }
355     break;
356 mmeineke 675
357     case G_NZCONSTRAINTS:
358     if( the_type == STRING ){
359     the_event->err_msg =
360     strdup("Global error. nZconstraints is not a double or an int.\n" );
361     return 0;
362     }
363 mmeineke 377
364 mmeineke 675 else if( the_type == DOUBLE ){
365     n_zConstraints = (int)the_event->evt.asmt.rhs.dval;
366     zConstraints = new ZconStamp*[n_zConstraints];
367     have_n_zConstraints = 1;
368     return 1;
369     }
370    
371     else{
372     n_zConstraints = the_event->evt.asmt.rhs.ival;
373     zConstraints = new ZconStamp*[n_zConstraints];
374     have_n_zConstraints = 1;
375     return 1;
376     }
377     break;
378    
379 mmeineke 377 case G_TARGETTEMP:
380     switch( the_type ){
381    
382     case STRING:
383     the_event->err_msg =
384     strdup( "Global error. targetTemp is not a double or int.\n" );
385     return 0;
386     break;
387    
388     case DOUBLE:
389     target_temp = the_event->evt.asmt.rhs.dval;
390     have_target_temp = 1;
391     return 1;
392     break;
393    
394     case INT:
395     target_temp = (double)the_event->evt.asmt.rhs.ival;
396     have_target_temp = 1;
397     return 1;
398     break;
399    
400     default:
401     the_event->err_msg =
402     strdup( "Global error. targetTemp unrecognized.\n" );
403     return 0;
404     break;
405     }
406     break;
407 mmeineke 855
408     case G_ORTHOBOXTOLERANCE:
409     switch( the_type ){
410    
411     case STRING:
412     the_event->err_msg =
413     strdup( "Global error. orthoBoxTolerance is not a double or int.\n" );
414     return 0;
415     break;
416    
417     case DOUBLE:
418     orthoBoxTolerance = the_event->evt.asmt.rhs.dval;
419     have_target_temp = 1;
420     return 1;
421     break;
422    
423     case INT:
424     orthoBoxTolerance = (double)the_event->evt.asmt.rhs.ival;
425     have_target_temp = 1;
426     return 1;
427     break;
428    
429     default:
430     the_event->err_msg =
431     strdup( "Global error.orthoBoxTolerance unrecognized.\n" );
432     return 0;
433     break;
434     }
435     break;
436 mmeineke 377
437     case G_ENSEMBLE:
438     if( the_type == STRING ){
439     strcpy( ensemble, the_event->evt.asmt.rhs.sval );
440     have_ensemble = 1;
441     return 1;
442     }
443    
444     the_event->err_msg =
445     strdup( "Global error. ensemble was not assigned to a string\n" );
446     return 0;
447     break;
448    
449     case G_MIXINGRULE:
450     if( the_type == STRING ){
451     strcpy( mixingRule, the_event->evt.asmt.rhs.sval );
452     return 1;
453     }
454    
455     the_event->err_msg =
456     strdup( "Global error. mixing rule was not assigned to a string\n" );
457     return 0;
458     break;
459    
460     case G_DT:
461     switch( the_type ){
462    
463     case STRING:
464     the_event->err_msg =
465     strdup( "Global error. dt is not a double or int.\n" );
466     return 0;
467     break;
468    
469     case DOUBLE:
470     dt = the_event->evt.asmt.rhs.dval;
471     have_dt = 1;
472     return 1;
473     break;
474    
475     case INT:
476     dt = (double)the_event->evt.asmt.rhs.ival;
477     have_dt = 1;
478     return 1;
479     break;
480    
481     default:
482     the_event->err_msg =
483     strdup( "Global error. dt unrecognized.\n" );
484     return 0;
485     break;
486     }
487     break;
488    
489     case G_RUNTIME:
490     switch( the_type ){
491    
492     case STRING:
493     the_event->err_msg =
494     strdup( "Global error. runTime is not a double or int.\n" );
495     return 0;
496     break;
497    
498     case DOUBLE:
499     run_time = the_event->evt.asmt.rhs.dval;
500     have_run_time = 1;
501     return 1;
502     break;
503    
504     case INT:
505     run_time = (double)the_event->evt.asmt.rhs.ival;
506     have_run_time = 1;
507     return 1;
508     break;
509    
510     default:
511     the_event->err_msg =
512     strdup( "Global error. runTime unrecognized.\n" );
513     return 0;
514     break;
515     }
516     break;
517    
518     case G_INITIALCONFIG:
519     if( the_type == STRING ){
520     strcpy( initial_config, the_event->evt.asmt.rhs.sval );
521     have_initial_config = 1;
522     return 1;
523     }
524    
525     the_event->err_msg =
526     strdup( "Global error. initialConfig was not a string assignment.\n" );
527     return 0;
528     break;
529    
530     case G_FINALCONFIG:
531     if( the_type == STRING ){
532     strcpy( final_config, the_event->evt.asmt.rhs.sval );
533     have_final_config = 1;
534     return 1;
535     }
536    
537     the_event->err_msg =
538     strdup( "Global error. finalConfig was not a string assignment.\n" );
539     return 0;
540     break;
541    
542     case G_NMOL:
543     switch( the_type ){
544    
545     case STRING:
546     the_event->err_msg =
547     strdup( "Global error. nMol is not a double or int.\n" );
548     return 0;
549     break;
550    
551     case DOUBLE:
552     n_mol = (int)the_event->evt.asmt.rhs.dval;
553     have_n_mol = 1;
554     return 1;
555     break;
556    
557     case INT:
558     n_mol = the_event->evt.asmt.rhs.ival;
559     have_n_mol = 1;
560     return 1;
561     break;
562    
563     default:
564     the_event->err_msg =
565     strdup( "Global error. nMol unrecognized.\n" );
566     return 0;
567     break;
568     }
569     break;
570    
571     case G_DENSITY:
572     switch( the_type ){
573    
574     case STRING:
575     the_event->err_msg =
576     strdup( "Global error. density is not a double or int.\n" );
577     return 0;
578     break;
579    
580     case DOUBLE:
581     density = the_event->evt.asmt.rhs.dval;
582     have_density = 1;
583     return 1;
584     break;
585    
586     case INT:
587     density = (double)the_event->evt.asmt.rhs.ival;
588     have_density = 1;
589     return 1;
590     break;
591    
592     default:
593     the_event->err_msg =
594     strdup( "Global error. density unrecognized.\n" );
595     return 0;
596     break;
597     }
598     break;
599    
600     case G_BOX:
601     switch( the_type ){
602    
603     case STRING:
604     the_event->err_msg =
605     strdup( "Global error. box is not a double or int.\n" );
606     return 0;
607     break;
608    
609     case DOUBLE:
610     box = the_event->evt.asmt.rhs.dval;
611     have_box = 1;
612     return 1;
613     break;
614    
615     case INT:
616     box = (double)the_event->evt.asmt.rhs.ival;
617     have_box = 1;
618     return 1;
619     break;
620    
621     default:
622     the_event->err_msg =
623     strdup( "Global error. box unrecognized.\n" );
624     return 0;
625     break;
626     }
627     break;
628    
629     case G_BOXX:
630     switch( the_type ){
631    
632     case STRING:
633     the_event->err_msg =
634     strdup( "Global error. boxX is not a double or int.\n" );
635     return 0;
636     break;
637    
638     case DOUBLE:
639     box_x = the_event->evt.asmt.rhs.dval;
640     have_box_x = 1;
641     return 1;
642     break;
643    
644     case INT:
645     box_x = (double)the_event->evt.asmt.rhs.ival;
646     have_box_x = 1;
647     return 1;
648     break;
649    
650     default:
651     the_event->err_msg =
652     strdup( "Global error. boxX unrecognized.\n" );
653     return 0;
654     break;
655     }
656     break;
657    
658     case G_BOXY:
659     switch( the_type ){
660    
661     case STRING:
662     the_event->err_msg =
663     strdup( "Global error. boxY is not a double or int.\n" );
664     return 0;
665     break;
666    
667     case DOUBLE:
668     box_y = the_event->evt.asmt.rhs.dval;
669     have_box_y = 1;
670     return 1;
671     break;
672    
673     case INT:
674     box_y = (double)the_event->evt.asmt.rhs.ival;
675     have_box_y = 1;
676     return 1;
677     break;
678    
679     default:
680     the_event->err_msg =
681     strdup( "Global error. boxY unrecognized.\n" );
682     return 0;
683     break;
684     }
685     break;
686    
687     case G_BOXZ:
688     switch( the_type ){
689    
690     case STRING:
691     the_event->err_msg =
692     strdup( "Global error. boxZ is not a double or int.\n" );
693     return 0;
694     break;
695    
696     case DOUBLE:
697     box_z = the_event->evt.asmt.rhs.dval;
698     have_box_z = 1;
699     return 1;
700     break;
701    
702     case INT:
703     box_z = (double)the_event->evt.asmt.rhs.ival;
704     have_box_z = 1;
705     return 1;
706     break;
707    
708     default:
709     the_event->err_msg =
710     strdup( "Global error. boxZ unrecognized.\n" );
711     return 0;
712     break;
713     }
714     break;
715    
716     case G_SAMPLETIME:
717     switch( the_type ){
718    
719     case STRING:
720     the_event->err_msg =
721     strdup( "Global error. sampleTime is not a double or int.\n" );
722     return 0;
723     break;
724    
725     case DOUBLE:
726     sample_time = the_event->evt.asmt.rhs.dval;
727     have_sample_time = 1;
728     return 1;
729     break;
730    
731     case INT:
732     sample_time = (double)the_event->evt.asmt.rhs.ival;
733     have_sample_time = 1;
734     return 1;
735     break;
736    
737     default:
738     the_event->err_msg =
739     strdup( "Global error. sampleTime unrecognized.\n" );
740     return 0;
741     break;
742     }
743     break;
744    
745     case G_STATUSTIME:
746     switch( the_type ){
747    
748     case STRING:
749     the_event->err_msg =
750     strdup( "Global error. statusTime is not a double or int.\n" );
751     return 0;
752     break;
753    
754     case DOUBLE:
755     status_time = the_event->evt.asmt.rhs.dval;
756     have_status_time = 1;
757     return 1;
758     break;
759    
760     case INT:
761     status_time = (double)the_event->evt.asmt.rhs.ival;
762     have_status_time = 1;
763     return 1;
764     break;
765    
766     default:
767     the_event->err_msg =
768     strdup( "Global error. statusTime unrecognized.\n" );
769     return 0;
770     break;
771     }
772     break;
773    
774 mmeineke 745 case G_RESETTIME:
775     switch( the_type ){
776    
777     case STRING:
778     the_event->err_msg =
779     strdup( "Global error. resetTime is not a double or int.\n" );
780     return 0;
781     break;
782    
783     case DOUBLE:
784     resetTime = the_event->evt.asmt.rhs.dval;
785     have_reset_time = 1;
786     return 1;
787     break;
788    
789     case INT:
790     resetTime = (double)the_event->evt.asmt.rhs.ival;
791     have_reset_time = 1;
792     return 1;
793     break;
794    
795     default:
796     the_event->err_msg =
797     strdup( "Global error. resetTime unrecognized.\n" );
798     return 0;
799     break;
800     }
801     break;
802    
803 tim 689 case G_THERMALTIME:
804 mmeineke 377 switch( the_type ){
805    
806     case STRING:
807     the_event->err_msg =
808     strdup( "Global error. thermalTime is not a double or int.\n" );
809     return 0;
810     break;
811    
812     case DOUBLE:
813     thermal_time = the_event->evt.asmt.rhs.dval;
814     have_thermal_time = 1;
815     return 1;
816     break;
817    
818     case INT:
819     thermal_time = (double)the_event->evt.asmt.rhs.ival;
820     have_thermal_time = 1;
821     return 1;
822     break;
823    
824     default:
825     the_event->err_msg =
826     strdup( "Global error. thermalTime unrecognized.\n" );
827     return 0;
828     break;
829     }
830     break;
831    
832 gezelter 394 case G_ECR:
833 mmeineke 377 switch( the_type ){
834    
835     case STRING:
836     the_event->err_msg =
837 gezelter 394 strdup( "Global error. electrostaticCutoffRadius is not a double or int.\n" );
838 mmeineke 377 return 0;
839     break;
840    
841     case DOUBLE:
842 gezelter 394 ecr = the_event->evt.asmt.rhs.dval;
843     have_ecr = 1;
844 mmeineke 377 return 1;
845     break;
846    
847     case INT:
848 gezelter 394 ecr = (double)the_event->evt.asmt.rhs.ival;
849     have_ecr = 1;
850 mmeineke 377 return 1;
851     break;
852    
853     default:
854     the_event->err_msg =
855 gezelter 394 strdup( "Global error. electrostaticCutoffRadius unrecognized.\n" );
856 mmeineke 377 return 0;
857     break;
858     }
859     break;
860 gezelter 394
861     case G_EST:
862     switch( the_type ){
863    
864     case STRING:
865     the_event->err_msg =
866     strdup( "Global error. electrostaticSkinThickness is not a double or int.\n" );
867     return 0;
868     break;
869    
870     case DOUBLE:
871     est = the_event->evt.asmt.rhs.dval;
872     have_est = 1;
873     return 1;
874     break;
875    
876     case INT:
877     est = (double)the_event->evt.asmt.rhs.ival;
878     have_est = 1;
879     return 1;
880     break;
881    
882     default:
883     the_event->err_msg =
884     strdup( "Global error. electrostaticSkinThickness unrecognized.\n" );
885     return 0;
886     break;
887     }
888     break;
889 mmeineke 377
890     case G_DIELECTRIC:
891     switch( the_type ){
892    
893     case STRING:
894     the_event->err_msg =
895     strdup( "Global error. dielectric is not a double or int.\n" );
896     return 0;
897     break;
898    
899     case DOUBLE:
900     dielectric = the_event->evt.asmt.rhs.dval;
901     have_dielectric = 1;
902     return 1;
903     break;
904    
905     case INT:
906     dielectric = (double)the_event->evt.asmt.rhs.ival;
907     have_dielectric = 1;
908     return 1;
909     break;
910    
911     default:
912     the_event->err_msg =
913     strdup( "Global error. dielectric unrecognized.\n" );
914     return 0;
915     break;
916     }
917     break;
918    
919     case G_TEMPSET:
920     if( the_type == STRING ){
921    
922 gezelter 465 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
923     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
924 mmeineke 377 else{
925     the_event->err_msg =
926     strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
927     return 0;
928     }
929     have_tempSet = 1;
930     return 1;
931     }
932    
933     the_event->err_msg =
934     strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
935     return 0;
936     break;
937 mmeineke 811
938     case G_USEINITTIME:
939     if( the_type == STRING ){
940    
941     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useInitTime = 1;
942     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useInitTime = 0;
943     else{
944     the_event->err_msg =
945     strdup( "Global error. useInitTime was not \"true\" or \"false\".\n" );
946     return 0;
947     }
948     return 1;
949     }
950 mmeineke 377
951 mmeineke 811 the_event->err_msg =
952     strdup( "Global error. useInitTime was not \"true\" or \"false\".\n" );
953     return 0;
954     break;
955 mmeineke 855
956     case G_USEINIT_XS_STATE:
957     if( the_type == STRING ){
958    
959     if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval ))
960     useInitXSstate = 1;
961     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval ))
962     useInitXSstate = 0;
963     else{
964     the_event->err_msg =
965     strdup( "Global error. useInitExtendedSystemState was not \"true\" or \"false\".\n" );
966     return 0;
967     }
968     return 1;
969     }
970 mmeineke 811
971 mmeineke 855 the_event->err_msg =
972     strdup( "Global error. useInitExtendedSystemState was not \"true\" or \"false\".\n" );
973     return 0;
974     break;
975    
976 mmeineke 377 case G_USEPBC:
977     if( the_type == STRING ){
978    
979 gezelter 465 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
980     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
981 mmeineke 377 else{
982     the_event->err_msg =
983 gezelter 394 strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
984 mmeineke 377 return 0;
985     }
986     return 1;
987     }
988    
989     the_event->err_msg =
990 gezelter 394 strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
991 mmeineke 377 return 0;
992     break;
993 gezelter 394
994     case G_USERF:
995     if( the_type == STRING ){
996    
997 gezelter 465 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
998     else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0;
999 gezelter 394 else{
1000     the_event->err_msg =
1001     strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
1002     return 0;
1003     }
1004     return 1;
1005     }
1006    
1007     the_event->err_msg =
1008     strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
1009     return 0;
1010     break;
1011    
1012 gezelter 465 case G_TARGETPRESSURE:
1013     switch( the_type ){
1014    
1015     case STRING:
1016     the_event->err_msg =
1017     strdup( "Global error. targetPressure is not a double or int.\n" );
1018     return 0;
1019     break;
1020    
1021     case DOUBLE:
1022     target_pressure = the_event->evt.asmt.rhs.dval;
1023     have_target_pressure = 1;
1024     return 1;
1025     break;
1026    
1027     case INT:
1028     target_pressure = (double)the_event->evt.asmt.rhs.ival;
1029     have_target_pressure = 1;
1030     return 1;
1031     break;
1032    
1033     default:
1034     the_event->err_msg =
1035     strdup( "Global error. targetPressure unrecognized.\n" );
1036     return 0;
1037     break;
1038     }
1039     break;
1040 gezelter 394
1041 gezelter 481 case G_TAUTHERMOSTAT:
1042 gezelter 474 switch( the_type ){
1043    
1044     case STRING:
1045     the_event->err_msg =
1046 gezelter 481 strdup( "Global error. tauThermostat is not a double or int.\n" );
1047 gezelter 474 return 0;
1048     break;
1049    
1050     case DOUBLE:
1051 gezelter 481 tau_thermostat = the_event->evt.asmt.rhs.dval;
1052     have_tau_thermostat = 1;
1053 gezelter 474 return 1;
1054     break;
1055    
1056     case INT:
1057 gezelter 481 tau_thermostat = (double)the_event->evt.asmt.rhs.ival;
1058     have_tau_thermostat = 1;
1059 gezelter 474 return 1;
1060     break;
1061    
1062     default:
1063     the_event->err_msg =
1064 gezelter 481 strdup( "Global error. tauThermostat unrecognized.\n" );
1065 gezelter 474 return 0;
1066     break;
1067     }
1068     break;
1069    
1070 gezelter 481 case G_TAUBAROSTAT:
1071     switch( the_type ){
1072    
1073     case STRING:
1074     the_event->err_msg =
1075     strdup( "Global error. tauBarostat is not a double or int.\n" );
1076     return 0;
1077     break;
1078    
1079     case DOUBLE:
1080     tau_barostat = the_event->evt.asmt.rhs.dval;
1081     have_tau_barostat = 1;
1082     return 1;
1083     break;
1084    
1085     case INT:
1086     tau_barostat = (double)the_event->evt.asmt.rhs.ival;
1087     have_tau_barostat = 1;
1088     return 1;
1089     break;
1090    
1091     default:
1092     the_event->err_msg =
1093     strdup( "Global error. tauBarostat unrecognized.\n" );
1094     return 0;
1095     break;
1096     }
1097     break;
1098 tim 659
1099 tim 689 case G_ZCONSTIME:
1100 tim 659 switch( the_type ){
1101    
1102     case STRING:
1103     the_event->err_msg =
1104     strdup( "Global error. zcons_time is not a double or int.\n" );
1105     return 0;
1106     break;
1107    
1108     case DOUBLE:
1109     zcons_time = the_event->evt.asmt.rhs.dval;
1110 tim 682 have_zcons_time = 1;
1111 tim 659 return 1;
1112     break;
1113    
1114     case INT:
1115     zcons_time = (double)the_event->evt.asmt.rhs.ival;
1116 tim 682 have_zcons_time = 1;
1117 tim 659 return 1;
1118     break;
1119    
1120     default:
1121     the_event->err_msg =
1122     strdup( "Global error. zcons_time unrecognized.\n" );
1123     return 0;
1124     break;
1125     }
1126     break;
1127 tim 682
1128 tim 689 case G_ZCONSTOL:
1129 tim 682 switch( the_type ){
1130    
1131     case STRING:
1132     the_event->err_msg =
1133     strdup( "Global error. zcons_tol is not a double or int.\n" );
1134     return 0;
1135     break;
1136    
1137     case DOUBLE:
1138     zcons_tol = the_event->evt.asmt.rhs.dval;
1139     have_zcons_tol = 1;
1140     return 1;
1141     break;
1142    
1143     case INT:
1144     zcons_tol = (double)the_event->evt.asmt.rhs.ival;
1145     have_zcons_tol = 1;
1146     return 1;
1147     break;
1148    
1149     default:
1150     the_event->err_msg =
1151     strdup( "Global error. zcons_ol unrecognized.\n" );
1152     return 0;
1153     break;
1154     }
1155     break;
1156 tim 659
1157 tim 699 case G_ZCONSFORCEPOLICY:
1158     switch( the_type ){
1159    
1160     case STRING:
1161     strcpy(zconsForcePolicy, the_event->evt.asmt.rhs.sval);
1162 gezelter 481
1163 tim 699 for(int i = 0; zconsForcePolicy[i] != '\0'; i++)
1164     {
1165     zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1166     }
1167     have_zcons_force_policy = 1;
1168     return 1;
1169     break;
1170    
1171     case DOUBLE:
1172     the_event->err_msg =
1173     strdup( "Global error. zconsForcePolicy is not a double or int.\n" );
1174     return 0;
1175     break;
1176    
1177     case INT:
1178     the_event->err_msg =
1179     strdup( "Global error. zconsForcePolicy is not a double or int.\n" );
1180     return 0;
1181     break;
1182    
1183     default:
1184     the_event->err_msg =
1185     strdup( "Global error. zconsForcePolicy unrecognized.\n" );
1186     return 0;
1187     break;
1188     }
1189     break;
1190 mmeineke 655 // add more token cases here.
1191 tim 704 case G_SEED:
1192     switch( the_type ){
1193    
1194     case STRING:
1195     the_event->err_msg =
1196     strdup( "Global error. seed is not a string.\n" );
1197     return 0;
1198     return 0;
1199     break;
1200    
1201     case DOUBLE:
1202     have_seed = 1;
1203     seed = (int)the_event->evt.asmt.rhs.dval;
1204     return 1;
1205     break;
1206    
1207     case INT:
1208     have_seed = 1;
1209     seed = the_event->evt.asmt.rhs.ival ;
1210     return 1;
1211     break;
1212    
1213     default:
1214     the_event->err_msg =
1215     strdup( "Global error. seed unrecognized.\n" );
1216     return 0;
1217     break;
1218     }
1219     break;
1220     // add more token cases here.
1221 mmeineke 655
1222 mmeineke 377 }
1223     }
1224    
1225     switch( the_type ){
1226    
1227     case STRING:
1228     sprintf( err,
1229     "Global error. Unrecognized assignment:\n"
1230     "\t-> %s = %s\n",
1231     lhs, the_event->evt.asmt.rhs.sval );
1232     break;
1233    
1234     case DOUBLE:
1235     sprintf( err,
1236     "Global error. Unrecognized assignment:\n"
1237     "\t-> %s = %lf\n",
1238     lhs, the_event->evt.asmt.rhs.dval );
1239     break;
1240    
1241     case INT:
1242     sprintf( err,
1243     "Global error. Unrecognized assignment:\n"
1244     "\t-> %s = %d\n",
1245     lhs, the_event->evt.asmt.rhs.ival );
1246     break;
1247    
1248     default:
1249     sprintf( err,
1250     "Global error. Unrecognized assignment:\n"
1251     "\t-> %s = ?\n",
1252     lhs );
1253     break;
1254     }
1255    
1256     the_event->err_msg = strdup( err );
1257     return 0;
1258     }
1259    
1260     char* Globals::checkMe( void ){
1261    
1262     char err[300];
1263     short int have_err = 0;
1264    
1265     strcpy( err, "Global error. The following are required:\n" );
1266    
1267     if( !have_force_field ){
1268     strcat( err, "\t->forceField\n" );
1269     have_err= 1;
1270     }
1271    
1272     if( !have_n_components ){
1273     strcat( err, "\t->nComponents\n" );
1274     have_err= 1;
1275     }
1276    
1277     if( !have_target_temp ){
1278     strcat( err, "\t->targetTemp\n" );
1279     have_err= 1;
1280     }
1281    
1282     if( !have_ensemble ){
1283     strcat( err, "\t->ensemble\n" );
1284     have_err= 1;
1285     }
1286    
1287     if( !have_dt ){
1288     strcat( err, "\t->dt\n" );
1289     have_err= 1;
1290     }
1291    
1292     if( !have_run_time ){
1293     strcat( err, "\t->runTime\n" );
1294     have_err= 1;
1295     }
1296    
1297     if( have_err ) return strdup( err );
1298    
1299     return NULL;
1300     }
1301    
1302     int Globals::globalEnd( event* the_event ){
1303    
1304     the_event->err_msg = checkMe();
1305     if( the_event->err_msg != NULL ) return 0;
1306    
1307     return 1;
1308     }
1309    
1310     int Globals::hash( char* text ){
1311    
1312     register unsigned short int i = 0; // loop counter
1313     int key = 0; // the hash key
1314    
1315     while( text[i] != '\0' ){
1316    
1317     key = ( ( key << hash_shift ) + text[i] ) % hash_size;
1318    
1319     i++;
1320     }
1321    
1322     if( key < 0 ){
1323    
1324     // if the key is less than zero, we've had an overflow error
1325    
1326     sprintf( painCave.errMsg,
1327     "There has been an overflow error in the Globals' hash key.");
1328     painCave.isFatal = 1;
1329     simError();
1330     #ifdef IS_MPI
1331     if( painCave.isEventLoop ){
1332     if( worldRank == 0 ) mpiInterfaceExit();
1333     }
1334     #endif //is_mpi
1335     }
1336    
1337     return key;
1338     }
1339    
1340     void Globals::addHash( char* text, int token ){
1341    
1342     int key;
1343     LinkedCommand* the_element;
1344    
1345     the_element = new LinkedCommand;
1346     the_element->setValues( text, token );
1347    
1348     key = hash( text );
1349     the_element->setNext( command_table[key] );
1350     command_table[key] = the_element;
1351     }