state.hpp

#ifndef PICTURE_HPP_FILE
#define PICTURE_HPP_FILE

#include <string>
#include <vector>
#include <complex>
#include <iostream>
#include <string>
#include <algorithm>
#include <list>

#include "rect_fwd.hpp"
#include "parallel.hpp"
#include "shared_ptr.hpp"

typedef std::list<std::string> t_filename_list;
typedef STD_TR1::shared_ptr<t_filename_list > t_filename_list_ref;

typedef std::complex<double> complex;
typedef std::vector<complex> Vector;

class state_collection;

class state{
public:

    size_t size() const;

    const std::string identifier() const;
    void set_identifier(const std::string&);

    Rectangle_const_ref geometry() const;

    const complex* raw_storage() const;
    complex* raw_storage();

    void write() const;

    double get_tag() const;
    void set_tag(double t);

    STD_TR1::shared_ptr<state_collection> get_state_collection(){ return sc;};

protected:

    state(size_t nr, STD_TR1::shared_ptr<state_collection> sc_):
    me(nr), sc(sc_){};

private:
    void load(std::istream&);

    friend class state_collection;
    
    size_t me;
    STD_TR1::shared_ptr<state_collection> sc;
};


class state_collection{
public:

    typedef STD_TR1::shared_ptr<      state_collection> ref;
    typedef STD_TR1::shared_ptr<const state_collection> const_ref;

    static
    ref create(MPI_Comm c);
    
    static
    ref create(MPI_Comm c, t_filename_list_ref files);

    std::string filename(size_t index) const;

    std::string minimal_identifier(const std::string& , size_t, size_t );

    const std::string& state_identifier(size_t index) const;
    Rectangle_const_ref state_geometry(size_t index) const;    
    size_t state_size(size_t index) const;

    state push_pointer(complex*);
    void pop_pointer();
    
    void add_empty_state(Rectangle_const_ref, 
             const std::string& identifier);
    void add_states(const t_filename_list_ref files);
    void add_states(Rectangle_const_ref, 
            Vector&, 
            const std::string& identifier);

    ref copy() const;

    template <class Pr>
    ref copy_if( Pr ) const;

    void clear();

    state get_state(size_t index);
    const state get_state(size_t index) const;    

    void write() const;
    void write(size_t index) const;

    size_t N() const { return states.size();};

    void set_write_out_immediately(bool woi){ write_out_immediately = woi;};

    void set_prefix(const std::string& s){prefix = s;};
    const std::string& get_prefix() const {return prefix;};

    double state_norm(int);

    void state_dot(int,int,complex& result); 

    void state_scale(int, complex alpha);

    void state_axpy(int i, int j, complex alpha);
    
    void state_copy(int i, int j);

/*    
extern "C" void FROM_F(wf_apply_h)(wavefunctions* wf, int& i, int& j) {
    wf->m->apply_H(wf->get_t(),wf->f(i),wf->f(j),wf->work());
}

extern "C" void FROM_F(wf_apply_dh)(wavefunctions* wf, int& i, int& j) {
    wf->m->apply_dH(wf->get_t(),wf->f(i),wf->f(j));
}

*/

    void state_maxpby(const complex* prefactors, int& istart, int& iend, complex& alpha, int& j);
    
private:
    bool write_out_immediately;

    std::string prefix;

    MPI_Comm comm;

    struct state_info{
    std::string identifier;
    double tag;
    complex* p;
    size_t size;
    Rectangle_const_ref geometry;

    complex* raw_storage() { return p;}; 
    const complex* raw_storage() const { return p;}; 
    };

    void check(size_t index) const;


    void write_state(std::ostream& os,
             const state_info& st) const;

    void load_state(state_info& st,
            std::string name,
            std::istream& is);

    state_collection();
    state_collection(const state_collection&);

    friend class state;

    std::vector<state_info> states;

    std::list< STD_TR1::shared_ptr<Vector> > state_data;

    STD_TR1::weak_ptr<state_collection> my_ptr;
};

template <class Pr>
STD_TR1::shared_ptr<state_collection> 
state_collection::copy_if( Pr pred ) const {

    auto clone = create(comm);

    clone->write_out_immediately = false;
    clone->prefix = prefix;

    std::copy(state_data.begin(), state_data.end(), std::back_inserter(clone->state_data));

    auto ins(std::back_inserter(clone->states));
    for (size_t i = 0; i < states.size(); ++i)
    if (pred(get_state(i))){
        *ins = states[i];
        ++ins;
    }

    return clone;
}    

#endif