ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1035
Committed: Fri Feb 6 21:37:59 2004 UTC (20 years, 5 months ago) by tim
File size: 35992 byte(s)
Log Message: 
Single version of energy minimization for argon is working, need to add constraint

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