ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE_old/src/mdtools/libBASS/Globals.cpp
Revision: 285
Committed: Wed Feb 26 18:45:57 2003 UTC (21 years, 6 months ago) by mmeineke
File size: 17734 byte(s)
Log Message: 
OOPSE has been braought up to date with the mdtools devfelopment tree. mdtools should no longer be used. All development should take place in the OOPSE tree.

File Contents

# User Rev Content
1 mmeineke 267 #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     #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_RRF 17
39     #define G_DIELECTRIC 18
40     #define G_TEMPSET 19
41     #define G_THERMALTIME 20
42 mmeineke 285 #define G_USEPBC 21
43     #define G_MIXINGRULE 22
44 mmeineke 267
45    
46     Globals::Globals(){
47    
48     int i;
49    
50     components = NULL;
51    
52     command_table = new LinkedCommand*[hash_size];
53     for( i=0; i<hash_size; i++ ) command_table[i] = NULL;
54    
55     addHash( "forceField", G_FORCEFIELD );
56     addHash( "nComponents", G_NCOMPONENTS );
57     addHash( "targetTemp", G_TARGETTEMP );
58     addHash( "ensemble", G_ENSEMBLE );
59 mmeineke 285
60 mmeineke 267 addHash( "dt", G_DT );
61     addHash( "runTime", G_RUNTIME );
62    
63     addHash( "initialConfig", G_INITIALCONFIG );
64     addHash( "finalConfig", G_FINALCONFIG );
65     addHash( "nMol", G_NMOL );
66     addHash( "density", G_DENSITY );
67     addHash( "box", G_BOX );
68     addHash( "boxX", G_BOXX );
69     addHash( "boxY", G_BOXY );
70     addHash( "boxZ", G_BOXZ );
71     addHash( "sampleTime", G_SAMPLETIME );
72     addHash( "statusTime", G_STATUSTIME );
73     addHash( "rRF", G_RRF );
74     addHash( "dielectric", G_DIELECTRIC );
75     addHash( "tempSet", G_TEMPSET );
76     addHash( "thermalTime", G_THERMALTIME );
77 mmeineke 285 addHash("mixingRule", G_MIXINGRULE);
78     mixingRule = "standard"; //default mixing rules to standard.
79     addHash("periodicBoundryConditions", G_USEPBC);
80     usePBC = 1; //default periodic boundry conditions to on
81    
82 mmeineke 267
83     have_force_field = 0;
84     have_n_components = 0;
85     have_target_temp = 0;
86     have_ensemble = 0;
87     have_dt = 0;
88     have_run_time = 0;
89    
90     have_initial_config = 0;
91     have_final_config = 0;
92     have_n_mol = 0;
93     have_density = 0;
94     have_box = 0;
95     have_box_x = 0;
96     have_box_y = 0;
97     have_box_y = 0;
98     have_box_z = 0;
99     have_sample_time = 0;
100     have_status_time = 0;
101     have_thermal_time = 0;
102     have_rrf = 0;
103     have_dielectric = 0;
104     have_tempSet = 0;
105 mmeineke 285 }
106 mmeineke 267
107     Globals::~Globals(){
108     int i;
109    
110     for( i=0; i<hash_size; i++ ){
111     if( command_table[i] != NULL ) delete command_table[i];
112     }
113     delete[] command_table;
114    
115     if( components != NULL ){
116     for( i=0; i<n_components; i++ ) delete components[i];
117     delete[] components;
118     }
119     }
120    
121     int Globals::newComponent( event* the_event ){
122    
123     current_component = new Component;
124     int index = the_event->evt.blk_index;
125     char err[200];
126    
127     if( have_n_components && index < n_components )
128     components[index] = current_component;
129     else{
130     if( have_n_components ){
131     sprintf( err, "Globals error, %d out of nComponents range",
132     index );
133     the_event->err_msg = strdup( err );
134     return 0;
135     }
136     else{
137     the_event->err_msg = strdup("Globals error, nComponents not given before"
138     "first component declaration." );
139     return 0;
140     }
141     }
142    
143     return 1;
144     }
145    
146    
147    
148     int Globals::componentAssign( event* the_event ){
149    
150     switch( the_event->evt.asmt.asmt_type ){
151    
152     case STRING:
153     return current_component->assignString( the_event->evt.asmt.lhs,
154     the_event->evt.asmt.rhs.sval,
155     &(the_event->err_msg));
156     break;
157    
158     case DOUBLE:
159     return current_component->assignDouble( the_event->evt.asmt.lhs,
160     the_event->evt.asmt.rhs.dval,
161     &(the_event->err_msg));
162     break;
163    
164     case INT:
165     return current_component->assignInt( the_event->evt.asmt.lhs,
166     the_event->evt.asmt.rhs.ival,
167     &(the_event->err_msg));
168     break;
169    
170     default:
171     the_event->err_msg = strdup( "Globals error. Invalid component"
172     " assignment type" );
173     return 0;
174     break;
175     }
176     return 0;
177     }
178    
179     int Globals::componentStartIndex( event* the_event ){
180    
181     current_component->startIndex( the_event->evt.si.array,
182     the_event->evt.si.n_elements );
183     return 1;
184     }
185    
186     int Globals::componentEnd( event* the_event ){
187    
188     the_event->err_msg = current_component->checkMe();
189     if( the_event->err_msg != NULL ) return 0;
190    
191     return 1;
192     }
193    
194     int Globals::globalAssign( event* the_event ){
195    
196     int key;
197     int token;
198     interface_assign_type the_type = the_event->evt.asmt.asmt_type;
199     char* lhs = the_event->evt.asmt.lhs;
200     char err[300];
201    
202     token = 0;
203     key = hash( lhs );
204     if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
205    
206     if( token ){
207    
208     switch( token ){
209    
210     case G_FORCEFIELD:
211     if( the_type == STRING ){
212     strcpy( force_field, the_event->evt.asmt.rhs.sval );
213     have_force_field = 1;
214     return 1;
215     }
216    
217     the_event->err_msg =
218     strdup( "Global error. forceField was not a string assignment.\n" );
219     return 0;
220     break;
221    
222     case G_NCOMPONENTS:
223     if( the_type == STRING ){
224     the_event->err_msg =
225     strdup("Global error. nComponents is not a double or an int.\n" );
226     return 0;
227     }
228    
229     else if( the_type == DOUBLE ){
230     n_components = (int)the_event->evt.asmt.rhs.dval;
231     components = new Component*[n_components];
232     have_n_components = 1;
233     return 1;
234     }
235    
236     else{
237     n_components = the_event->evt.asmt.rhs.ival;
238     components = new Component*[n_components];
239     have_n_components = 1;
240     return 1;
241     }
242     break;
243    
244     case G_TARGETTEMP:
245     switch( the_type ){
246    
247     case STRING:
248     the_event->err_msg =
249     strdup( "Global error. targetTemp is not a double or int.\n" );
250     return 0;
251     break;
252    
253     case DOUBLE:
254     target_temp = the_event->evt.asmt.rhs.dval;
255     have_target_temp = 1;
256     return 1;
257     break;
258    
259     case INT:
260     target_temp = (double)the_event->evt.asmt.rhs.ival;
261     have_target_temp = 1;
262     return 1;
263     break;
264    
265     default:
266     the_event->err_msg =
267     strdup( "Global error. targetTemp unrecognized.\n" );
268     return 0;
269     break;
270     }
271     break;
272    
273     case G_ENSEMBLE:
274     if( the_type == STRING ){
275     strcpy( ensemble, the_event->evt.asmt.rhs.sval );
276     have_ensemble = 1;
277     return 1;
278     }
279    
280     the_event->err_msg =
281     strdup( "Global error. ensemble was not assigned to a string\n" );
282     return 0;
283     break;
284 mmeineke 285
285     case G_MIXINGRULE:
286     if( the_type == STRING ){
287     strcpy( mixingRule, the_event->evt.asmt.rhs.sval );
288     return 1;
289     }
290 mmeineke 267
291 mmeineke 285 the_event->err_msg =
292     strdup( "Global error. mixing rule was not assigned to a string\n" );
293     return 0;
294     break;
295    
296 mmeineke 267 case G_DT:
297     switch( the_type ){
298    
299     case STRING:
300     the_event->err_msg =
301     strdup( "Global error. dt is not a double or int.\n" );
302     return 0;
303     break;
304    
305     case DOUBLE:
306     dt = the_event->evt.asmt.rhs.dval;
307     have_dt = 1;
308     return 1;
309     break;
310    
311     case INT:
312     dt = (double)the_event->evt.asmt.rhs.ival;
313     have_dt = 1;
314     return 1;
315     break;
316    
317     default:
318     the_event->err_msg =
319     strdup( "Global error. dt unrecognized.\n" );
320     return 0;
321     break;
322     }
323     break;
324    
325     case G_RUNTIME:
326     switch( the_type ){
327    
328     case STRING:
329     the_event->err_msg =
330     strdup( "Global error. runTime is not a double or int.\n" );
331     return 0;
332     break;
333    
334     case DOUBLE:
335     run_time = the_event->evt.asmt.rhs.dval;
336     have_run_time = 1;
337     return 1;
338     break;
339    
340     case INT:
341     run_time = (double)the_event->evt.asmt.rhs.ival;
342     have_run_time = 1;
343     return 1;
344     break;
345    
346     default:
347     the_event->err_msg =
348     strdup( "Global error. runTime unrecognized.\n" );
349     return 0;
350     break;
351     }
352     break;
353    
354     case G_INITIALCONFIG:
355     if( the_type == STRING ){
356     strcpy( initial_config, the_event->evt.asmt.rhs.sval );
357     have_initial_config = 1;
358     return 1;
359     }
360    
361     the_event->err_msg =
362     strdup( "Global error. initialConfig was not a string assignment.\n" );
363     return 0;
364     break;
365    
366     case G_FINALCONFIG:
367     if( the_type == STRING ){
368     strcpy( final_config, the_event->evt.asmt.rhs.sval );
369     have_final_config = 1;
370     return 1;
371     }
372    
373     the_event->err_msg =
374     strdup( "Global error. finalConfig was not a string assignment.\n" );
375     return 0;
376     break;
377    
378     case G_NMOL:
379     switch( the_type ){
380    
381     case STRING:
382     the_event->err_msg =
383     strdup( "Global error. nMol is not a double or int.\n" );
384     return 0;
385     break;
386    
387     case DOUBLE:
388     n_mol = (int)the_event->evt.asmt.rhs.dval;
389     have_n_mol = 1;
390     return 1;
391     break;
392    
393     case INT:
394     n_mol = the_event->evt.asmt.rhs.ival;
395     have_n_mol = 1;
396     return 1;
397     break;
398    
399     default:
400     the_event->err_msg =
401     strdup( "Global error. nMol unrecognized.\n" );
402     return 0;
403     break;
404     }
405     break;
406    
407     case G_DENSITY:
408     switch( the_type ){
409    
410     case STRING:
411     the_event->err_msg =
412     strdup( "Global error. density is not a double or int.\n" );
413     return 0;
414     break;
415    
416     case DOUBLE:
417     density = the_event->evt.asmt.rhs.dval;
418     have_density = 1;
419     return 1;
420     break;
421    
422     case INT:
423     density = (double)the_event->evt.asmt.rhs.ival;
424     have_density = 1;
425     return 1;
426     break;
427    
428     default:
429     the_event->err_msg =
430     strdup( "Global error. density unrecognized.\n" );
431     return 0;
432     break;
433     }
434     break;
435    
436     case G_BOX:
437     switch( the_type ){
438    
439     case STRING:
440     the_event->err_msg =
441     strdup( "Global error. box is not a double or int.\n" );
442     return 0;
443     break;
444    
445     case DOUBLE:
446     box = the_event->evt.asmt.rhs.dval;
447     have_box = 1;
448     return 1;
449     break;
450    
451     case INT:
452     box = (double)the_event->evt.asmt.rhs.ival;
453     have_box = 1;
454     return 1;
455     break;
456    
457     default:
458     the_event->err_msg =
459     strdup( "Global error. box unrecognized.\n" );
460     return 0;
461     break;
462     }
463     break;
464    
465     case G_BOXX:
466     switch( the_type ){
467    
468     case STRING:
469     the_event->err_msg =
470     strdup( "Global error. boxX is not a double or int.\n" );
471     return 0;
472     break;
473    
474     case DOUBLE:
475     box_x = the_event->evt.asmt.rhs.dval;
476     have_box_x = 1;
477     return 1;
478     break;
479    
480     case INT:
481     box_x = (double)the_event->evt.asmt.rhs.ival;
482     have_box_x = 1;
483     return 1;
484     break;
485    
486     default:
487     the_event->err_msg =
488     strdup( "Global error. boxX unrecognized.\n" );
489     return 0;
490     break;
491     }
492     break;
493    
494     case G_BOXY:
495     switch( the_type ){
496    
497     case STRING:
498     the_event->err_msg =
499     strdup( "Global error. boxY is not a double or int.\n" );
500     return 0;
501     break;
502    
503     case DOUBLE:
504     box_y = the_event->evt.asmt.rhs.dval;
505     have_box_y = 1;
506     return 1;
507     break;
508    
509     case INT:
510     box_y = (double)the_event->evt.asmt.rhs.ival;
511     have_box_y = 1;
512     return 1;
513     break;
514    
515     default:
516     the_event->err_msg =
517     strdup( "Global error. boxY unrecognized.\n" );
518     return 0;
519     break;
520     }
521     break;
522    
523     case G_BOXZ:
524     switch( the_type ){
525    
526     case STRING:
527     the_event->err_msg =
528     strdup( "Global error. boxZ is not a double or int.\n" );
529     return 0;
530     break;
531    
532     case DOUBLE:
533     box_z = the_event->evt.asmt.rhs.dval;
534     have_box_z = 1;
535     return 1;
536     break;
537    
538     case INT:
539     box_z = (double)the_event->evt.asmt.rhs.ival;
540     have_box_z = 1;
541     return 1;
542     break;
543    
544     default:
545     the_event->err_msg =
546     strdup( "Global error. boxZ unrecognized.\n" );
547     return 0;
548     break;
549     }
550     break;
551    
552     case G_SAMPLETIME:
553     switch( the_type ){
554    
555     case STRING:
556     the_event->err_msg =
557     strdup( "Global error. sampleTime is not a double or int.\n" );
558     return 0;
559     break;
560    
561     case DOUBLE:
562     sample_time = the_event->evt.asmt.rhs.dval;
563     have_sample_time = 1;
564     return 1;
565     break;
566    
567     case INT:
568     sample_time = (double)the_event->evt.asmt.rhs.ival;
569     have_sample_time = 1;
570     return 1;
571     break;
572    
573     default:
574     the_event->err_msg =
575     strdup( "Global error. sampleTime unrecognized.\n" );
576     return 0;
577     break;
578     }
579     break;
580    
581     case G_STATUSTIME:
582     switch( the_type ){
583    
584     case STRING:
585     the_event->err_msg =
586     strdup( "Global error. statusTime is not a double or int.\n" );
587     return 0;
588     break;
589    
590     case DOUBLE:
591     status_time = the_event->evt.asmt.rhs.dval;
592     have_status_time = 1;
593     return 1;
594     break;
595    
596     case INT:
597     status_time = (double)the_event->evt.asmt.rhs.ival;
598     have_status_time = 1;
599     return 1;
600     break;
601    
602     default:
603     the_event->err_msg =
604     strdup( "Global error. statusTime unrecognized.\n" );
605     return 0;
606     break;
607     }
608     break;
609    
610     case G_THERMALTIME:
611     switch( the_type ){
612    
613     case STRING:
614     the_event->err_msg =
615     strdup( "Global error. thermalTime is not a double or int.\n" );
616     return 0;
617     break;
618    
619     case DOUBLE:
620     thermal_time = the_event->evt.asmt.rhs.dval;
621     have_thermal_time = 1;
622     return 1;
623     break;
624    
625     case INT:
626     thermal_time = (double)the_event->evt.asmt.rhs.ival;
627     have_thermal_time = 1;
628     return 1;
629     break;
630    
631     default:
632     the_event->err_msg =
633     strdup( "Global error. thermalTime unrecognized.\n" );
634     return 0;
635     break;
636     }
637     break;
638    
639     case G_RRF:
640     switch( the_type ){
641    
642     case STRING:
643     the_event->err_msg =
644     strdup( "Global error. rRF is not a double or int.\n" );
645     return 0;
646     break;
647    
648     case DOUBLE:
649     rRF = the_event->evt.asmt.rhs.dval;
650     have_rrf = 1;
651     return 1;
652     break;
653    
654     case INT:
655     rRF = (double)the_event->evt.asmt.rhs.ival;
656     have_rrf = 1;
657     return 1;
658     break;
659    
660     default:
661     the_event->err_msg =
662     strdup( "Global error. rRF unrecognized.\n" );
663     return 0;
664     break;
665     }
666     break;
667    
668     case G_DIELECTRIC:
669     switch( the_type ){
670    
671     case STRING:
672     the_event->err_msg =
673     strdup( "Global error. dielectric is not a double or int.\n" );
674     return 0;
675     break;
676    
677     case DOUBLE:
678     dielectric = the_event->evt.asmt.rhs.dval;
679     have_dielectric = 1;
680     return 1;
681     break;
682    
683     case INT:
684     dielectric = (double)the_event->evt.asmt.rhs.ival;
685     have_dielectric = 1;
686     return 1;
687     break;
688    
689     default:
690     the_event->err_msg =
691     strdup( "Global error. dielectric unrecognized.\n" );
692     return 0;
693     break;
694     }
695     break;
696    
697     case G_TEMPSET:
698     if( the_type == STRING ){
699    
700     if( !strcmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
701     else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
702     else{
703     the_event->err_msg =
704     strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
705     return 0;
706     }
707     have_tempSet = 1;
708     return 1;
709     }
710    
711     the_event->err_msg =
712     strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
713     return 0;
714     break;
715 mmeineke 285
716     case G_USEPBC:
717     if( the_type == STRING ){
718    
719     if( !strcmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
720     else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
721     else{
722     the_event->err_msg =
723     strdup( "Global error. periodicBoundryConditions was not \"true\" or \"false\".\n" );
724     return 0;
725     }
726     return 1;
727     }
728    
729     the_event->err_msg =
730     strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
731     return 0;
732     break;
733 mmeineke 267 }
734     }
735    
736     switch( the_type ){
737    
738     case STRING:
739     sprintf( err,
740     "Global error. Unrecognized assignment:\n"
741     "\t-> %s = %s\n",
742     lhs, the_event->evt.asmt.rhs.sval );
743     break;
744    
745     case DOUBLE:
746     sprintf( err,
747     "Global error. Unrecognized assignment:\n"
748     "\t-> %s = %lf\n",
749     lhs, the_event->evt.asmt.rhs.dval );
750     break;
751    
752     case INT:
753     sprintf( err,
754     "Global error. Unrecognized assignment:\n"
755     "\t-> %s = %d\n",
756     lhs, the_event->evt.asmt.rhs.ival );
757     break;
758    
759     default:
760     sprintf( err,
761     "Global error. Unrecognized assignment:\n"
762     "\t-> %s = ?\n",
763     lhs );
764     break;
765     }
766    
767     the_event->err_msg = strdup( err );
768     return 0;
769     }
770    
771     char* Globals::checkMe( void ){
772    
773     char err[300];
774     short int have_err = 0;
775    
776     strcpy( err, "Global error. The following are required:\n" );
777    
778     if( !have_force_field ){
779     strcat( err, "\t->forceField\n" );
780     have_err= 1;
781     }
782    
783     if( !have_n_components ){
784     strcat( err, "\t->nComponents\n" );
785     have_err= 1;
786     }
787    
788     if( !have_target_temp ){
789     strcat( err, "\t->targetTemp\n" );
790     have_err= 1;
791     }
792    
793     if( !have_ensemble ){
794     strcat( err, "\t->ensemble\n" );
795     have_err= 1;
796     }
797    
798     if( !have_dt ){
799     strcat( err, "\t->dt\n" );
800     have_err= 1;
801     }
802    
803     if( !have_run_time ){
804     strcat( err, "\t->runTime\n" );
805     have_err= 1;
806     }
807    
808     if( have_err ) return strdup( err );
809    
810     return NULL;
811     }
812    
813     int Globals::globalEnd( event* the_event ){
814    
815     the_event->err_msg = checkMe();
816     if( the_event->err_msg != NULL ) return 0;
817    
818     return 1;
819     }
820    
821     int Globals::hash( char* text ){
822    
823     register unsigned short int i = 0; // loop counter
824     int key = 0; // the hash key
825    
826     while( text[i] != '\0' ){
827    
828     key = ( ( key << hash_shift ) + text[i] ) % hash_size;
829    
830     i++;
831     }
832    
833     if( key < 0 ){
834    
835     // if the key is less than zero, we've had an overflow error
836    
837     sprintf( painCave.errMsg,
838     "There has been an overflow error in the Globals' hash key.");
839     painCave.isFatal = 1;
840     simError();
841     #ifdef IS_MPI
842     if( painCave.isEventLoop ){
843     if( worldRank == 0 ) mpiInterfaceExit();
844     }
845     #endif //is_mpi
846     }
847    
848     return key;
849     }
850    
851     void Globals::addHash( char* text, int token ){
852    
853     int key;
854     LinkedCommand* the_element;
855    
856     the_element = new LinkedCommand;
857     the_element->setValues( text, token );
858    
859     key = hash( text );
860     the_element->setNext( command_table[key] );
861     command_table[key] = the_element;
862     }