ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 957
Committed: Mon Jan 19 16:08:21 2004 UTC (20 years, 5 months ago) by gezelter
File size: 29670 byte(s)
Log Message: 
BASS changes to add RigidBodies and LJrcut

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