abstract_state_worker.hpp

#ifndef STATE_WORKER_ABSTRACT_HPP
#define STATE_WORKER_ABSTRACT_HPP

#include "executable.hpp"
#include "state.hpp"

class state_worker: public executable_Object{
public:

    ~state_worker() throw() {};
    
    typedef STD_TR1::shared_ptr<const state_worker> const_ref;
    typedef STD_TR1::shared_ptr<state_worker> ref;

    // to create output filename
//    void process_wv(MPI_Comm comm, const state s){process_wv_(comm,s);};
    void process_wvs(MPI_Comm comm, const state_collection::const_ref sc){
    process_wvs_(comm,sc);};

    void process_geometry(const std::string& filen,
              const STD_TR1::shared_ptr<const Rectangle>& rect
    );

    void process_potential(const std::string& filen,
               const STD_TR1::shared_ptr<const Rectangle>& rect
    );

    int n_start() { return n_start_;};

    void prepare_wv(
    const STD_TR1::shared_ptr<const Rectangle>& r){ prepare_Image_(r);};
protected:

    t_filename_list_ref get_filenames(MPI_Comm,
                      const std::string& head,
                      const std::string& getfilen,
                      const std::string& identifier) const;
private:
    size_t n_start_;

    bool write_potential_;
    bool write_geometry_;

    bool subtr_average_;
    bool subtr_minimum_;

    bool set_pos_;

    virtual void process_wvs_(MPI_Comm, const state_collection::const_ref);

    virtual void process_wv_(MPI_Comm, const state s) = 0;

    virtual void init_state_worker() = 0;

    virtual void prepare_Image_(const STD_TR1::shared_ptr<const Rectangle>&) = 0;

    void init();

    void reinit_param(const std::string& param_name);    
    void perform_(MPI_Comm comm);
};

class selective_state_worker: public state_worker{
private:

    typedef std::vector<state_worker::ref> state_worker_List;
    STD_TR1::shared_ptr<state_worker_List> state_workers;
    
    void process_wvs_(MPI_Comm, const state_collection::const_ref);
    void process_wv_(MPI_Comm, const state);
    void init_state_worker();

    virtual bool include_state( const state s ) = 0;
    
    virtual void init_condition() = 0;
   
};

class two_state_combiner: public state_worker{
protected:
    std::map<int, complex > evals;
    std::map<int, const complex* > state_pointers;

    Rectangle_const_ref geometry;

    size_t N;

    typedef std::pair<int,int> tworkpair;

    std::set<tworkpair> work_pairs;

    std::set<int> needed;

private:

    state_collection::ref second_set_states;
    
    std::vector<int> allstates;
    
    virtual void setup_calculation() = 0;
    virtual void perform_work(MPI_Comm) = 0;

    void setup_workpairs_needed(MPI_Comm comm, int);

    void distribute_simple(MPI_Comm comm);
    void distribute_mincomm(MPI_Comm comm);

    void init_second(MPI_Comm comm);

    void process_wvs_( 
    MPI_Comm comm,
    const state_collection::const_ref states);

    void process_wv_(MPI_Comm, const state);
};

#endif