SimulationCore.h

Go to the documentation of this file.

/***************************************************************************
 * File:        ./SimulationCore.h
 * Author:      Ronni Grapenthin, GEOPHYSICAL INSTITUTE, UAF
 * Created:     20.02.2007
 * Licence:     GPLv2
 *
 * #########################################################################
 *
 * CrusDe, simulation framework for crustal deformation studies
 * Copyright (C) 2007 Ronni Grapenthin
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; version 2
 * of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 ****************************************************************************/


#ifndef simulationCore_h        
#define simulationCore_h

#include <cstdlib>
#include <iostream>
#include <map>
#include <vector>
#include <list>
#include <cassert>
#include <string>
#include "constants.h"
#include "config.h"
#include "crusde_api.h"
#include "exceptions.h"

using namespace std;

class LoadHistoryPlugin;
class InputHandler;
class Plugin;
class DataOutPlugin;
class LoadPlugin;
class GreensFunction;
class ExperimentManager;
class PluginManager;
class LoadFunction;
class ParamWrapper;


struct s_parameters {                           
        map< unsigned int, multimap< string, ParamWrapper* > > load;
        map< unsigned int, multimap< string, ParamWrapper* > > loadhistory;
        map< unsigned int, multimap< string, ParamWrapper* > > crustaldecay;
        multimap<string, ParamWrapper* > green; 
        multimap<string, ParamWrapper* > kernel;        
        multimap<string, ParamWrapper* > datahandler;
        multimap<string, ParamWrapper* > postprocessor;
};


class SimulationCore /*:        public PluginAPI, 
                        public PluginSimulationCore,*/ {
        
        InputHandler      *com_port;        
        ExperimentManager *exp_man;         
        PluginManager     *plugin_man;      
        Plugin            *pl_kernel;       
        DataOutPlugin     *pl_out;          
        GreensFunction    *greens_function; 
        LoadFunction      *load_function;   
        unsigned int load_function_component;
                
        /*experiment setup data that needs to be available for all participants*/
        int x_west;
        int x_east;
        int y_south;
        int y_north;
        int gridsize;
        
        int modelstep;         
        int modeltime;         
        int num_timesteps;     
        int num_timeincrement; 
        int stepsize;                        
        int quadrant;                           
        int dimensions;         
        
        int x_index;
        int y_index;
        int z_index;
        
        map<int*, int> add_field_map;
        
        double **model_data;
        
        list<Plugin*>::iterator pl_iter;
        
        list<Plugin*> requested_plugin_list; 
        list<Plugin*> pl_list_postprocess;   
        string  root_dir;

        int operator_space_x;
        int operator_space_y;
        bool operator_space_set;

        unsigned int num_load_components;

        bool quiet;
                                                           
        static SimulationCore   *pSimulationCore;       

        SimulationCore(int argc, char** argv) throw(SeriousException);
        SimulationCore(const SimulationCore& x); 
        SimulationCore const &operator=(SimulationCore const &rvalue);

/************************/              
/**** PUBLIC SECTION ****/
/************************/              
    public:
        static s_parameters     s_params;                       /* */

        ~SimulationCore();
                
        void exec();
        void init();
        void terminate();
        
        void abort(string msg);
                
        static SimulationCore* instance(int argc, char** argv) throw(){
                if(!pSimulationCore){ 
                        try{
                                pSimulationCore = new SimulationCore(argc, argv); 
                        }
                        catch(SeriousException e)
                        {
                                crusde_error("%s \nAborting...", e.what()); 
                        }
                        catch(...)
                        {
                                crusde_error("An unrecognized error occured while trying to build the SimulationCore.\nAborting..."); 
                        }
                }
                
                return pSimulationCore;
        }

        static SimulationCore* instance() throw() {
                if(pSimulationCore)
                        return pSimulationCore;
                else{
                        //must not call crusde_error, otherwise infinite loop
                        cerr << "Call instance(argc, argv) first!" << endl;
                        return NULL; 
                }
        }
        
        GreensFunction* greensFunction(){ return greens_function;}
        LoadFunction*   loadFunction(){ return load_function;}
        DataOutPlugin*  dataOutPlugin(){ return pl_out;}

        /* we want to allow for multiple loads with independent parameters and all that, so they need to be identifiable*/
        unsigned int getLoadFunctionComponent();
        void setLoadFunctionComponent(unsigned int i);

        unsigned int getNumberOfLoadComponents();

        void registerParam(ParamWrapper *param, const char* name, PluginCategory category);
        
        const char* outFile();

        int sizeX();
        int sizeY();
        int sizeT();
        int gridSize();
        int minX();
        int minY();
        int modelTime();
        int modelStep();
        int stepSize();
        int xIndex();
        int yIndex();
        int zIndex();

        int getDimensions();
        int getTimesteps();
        int displacementDimensions();
//      double constrainLoadHeight(double, int);
        
        int getQuadrant();
        void setQuadrant(int);
        void setModelData(double**);
        double** getModelData();
        void runExperimentManager();
        void runPluginManager();
        void installPlugin(string);
        PluginManager* pluginManager();
        list<string> getRegisteredParameters(PluginCategory cat);
        void deleteRegistrees();
        list<string> getRequestedNames();
        void deleteRequests();

    int getOperatorSpaceX();
    int getOperatorSpaceY();
    void setOperatorSpace(int, int);
    bool operatorSpaceIsSet();
        
        string getPluginFilename(string, string) throw (DatabaseError);
        void registerOutputField(int *output_index, FieldName field);

        string currentJob();

        void setQuiet(bool);
        bool isQuiet();

        //these functions enable re-use of plug-ins within the same category
        green_exec_function          addGreenPlugin(string plugin) throw (FileNotFound, runtime_error);
        load_exec_function           addLoadPlugin(string plugin) throw (FileNotFound, runtime_error);
        run_function                 addKernelPlugin(string plugin) throw (FileNotFound, runtime_error);
        run_function                 addPostprocessorPlugin(string plugin) throw (FileNotFound, runtime_error);
        loadhistory_exec_function    addLoadHistoryPlugin(string plugin) throw (FileNotFound, runtime_error);
        crustaldecay_exec_function   addCrustalDecayPlugin(string plugin) throw (FileNotFound, runtime_error);

};

#endif // simulationCore_h

---