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