ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 682
Committed: Tue Aug 12 17:51:33 2003 UTC (22 years, 2 months ago) by tim
File size: 24689 byte(s)
Log Message: 
added harmonical potential to z-constraint method

File Contents

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