ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/mdtools/interface_implementation/Globals.cpp
Revision: 118
Committed: Wed Sep 25 22:51:14 2002 UTC (23 years, 1 month ago) by chuckv
File size: 16490 byte(s)
Log Message: 
begin the pain that is MPI.

abandon all hope ye who check out this branch..

P.S. we've added consistent BASS error checking

File Contents

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