ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE_old/src/mdtools/libBASS/Globals.cpp
Revision: 267
Committed: Thu Feb 13 20:37:36 2003 UTC (21 years, 6 months ago) by mmeineke
File size: 16716 byte(s)
Log Message: 
Successfully added all the source for libBASS

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