executable.hpp

#ifndef EXECUTABLE_OBJECT_HPP
#define EXECUTABLE_OBJECT_HPP

#include "parallel.hpp"
#include "input_file.hpp"
#include <vector>
#include <list>

class executable_Object: public loadable_Object{
public:
    typedef STD_TR1::shared_ptr< executable_Object > ref;

    ~executable_Object() throw() {};

// Prepare for up to N calls to perform, where reinitialize_param (see below)
//  will be called after each run
// Due to parallelization, not all N calls might be done by this thread
    void setup_data( const std::string& f, size_t n );
//  reinit all dependencies on the param param_name (e.g. EF). This
// The new value of the param will be set beforehand with set_param
    void reinitialize_param(const std::string& param_name)
    { reinit_param(param_name);};
// Do one run
    void perform( MPI_Comm comm, size_t rd );
//  Post-Process data, close files etc, after the N runs. Communicator will be global
// communicator of all the processes 
    void post_process( MPI_Comm comm, const std::vector<int>& thread_ids ){
    thread_ids_=&thread_ids;
    post_process_(comm);};

// Set up, do one run, and post_process
    void perform( MPI_Comm comm, const std::string& f);

protected:

    // get filen from xml
    const std::string& get_filen() const { return filen;}; 
    // get filen plus run_id 
    std::string get_id_filen() const;
    size_t get_run_id() const { return run_id;}; 
    size_t get_N() const { return N;};

    int get_thread_id(int i) const { return (*thread_ids_)[i];};
    
private:
    const std::vector<int>* thread_ids_;
    
    std::string filen;
    size_t run_id;
    size_t N;

    virtual void setup_data_() D_ABSTRACT(setup_data);  

    virtual void reinit_param(const std::string& param_name) D_ABSTRACT(reinit_param);
    virtual void perform_(MPI_Comm comm) D_ABSTRACT(perform);
    
    virtual void post_process_(MPI_Comm comm) D_ABSTRACT(post_process);
};

class message;

#endif