generate_wavefunction.hpp

#ifndef GENERATE_WF_HPP
#define GENERATE_WF_HPP

#include <vector>
#include <list>

#include "my_mkl.hpp"
#include "executable.hpp"
#include "points.hpp"

#include <memory>

#include "state.hpp"

#include "abstract_state_worker.hpp"

class abstract_image_parser;


class Bild{
public:
    double d() const { return d_;};

    double width() const { return width_;};
    double length() const { return length_;};
    size_t nx() const { return nx_;};
    size_t ny() const { return ny_;};
    size_t size() const { return data.size();};
    const point& pos_0() const { return pos_0_;};
    double rotation() const { return rotation_;};
    complex pixel(size_t ix, size_t iy) const { 
    size_t index(ix + iy * nx()); 
    return index < size() ? data[index] : complex(0.);};
    void set_pixel(size_t ix, size_t iy, complex v) { 
    size_t index(ix + iy * nx()); 
    if (index < size()) data[index] = v;
    }
    void multiply_by_number(complex v){
      for(std::vector<complex>::iterator value=data.begin();value!=data.end();value++) *value *= v;
    }

    typedef std::vector<complex>::const_iterator const_iterator;

    const_iterator begin() const { return data.begin();};
    const_iterator end() const { return data.end();};

    std::unique_ptr<Bild> identical_image_from_vector(Vector& d) 
    const;

    std::unique_ptr< std::vector<complex> > identical_vector_from_image(void) const;

    static
    std::unique_ptr<Bild> image_from_vector(Vector& data,
                        double d,
                        int nx,
                        int ny);
private:
    friend class image_Factory;
    friend class image_slice_coloring;

    std::vector<complex> data;
    
    Bild(){};
    Bild(const Bild&); // blocked

    double d_;
    
    double width_;
    double length_;
    point pos_0_;
    double rotation_;

    size_t nx_;
    size_t ny_;

    state* s;

};


class image_Factory: public state_worker{
public:
    
    typedef STD_TR1::shared_ptr<image_Factory> ref;

    image_Factory(){}
    ~image_Factory() throw() {}

    std::unique_ptr<Bild> Image(MPI_Comm comm,
                const state s,
                const size_t drawing_layer);
    
private:

    double min_x;
    double max_x;
    double min_y;
    double max_y;

    double rotation_;

    std::unique_ptr<Bild> prepbild;

    STD_TR1::shared_ptr< std::list< STD_TR1::shared_ptr< abstract_image_parser> > >
         my_image_parsers;

    void process_wv_(MPI_Comm, const state s);

    void init_state_worker();

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

    const char* name() const {return "Image";};

    void setup_data_();
    void post_process_(MPI_Comm);

    double zoom;

};


#endif