rectangle.hpp

Go to the documentation of this file.

#ifndef ABSTRACT_RECTANGLE_HPP
#define ABSTRACT_RECTANGLE_HPP

#include "parallel.hpp"
#include "iterators.hpp"

class Hamiltonian;
class Rectangle_Visitor;
class Interface;
class index_connector;

typedef STD_TR1::shared_ptr<const Interface> Interface_const_ref;

class Rectangle: public loadable_Object{
public:

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

    Rectangle() {};
    virtual ~Rectangle() throw() {};

    geometry_Iterator begin(){ 
    return geometry_Iterator(get_dynamic_ref<Rectangle>());};
    geometry_Iterator end(){ 
    return geometry_Iterator(get_dynamic_ref<Rectangle>(), size());};
    geometry_Iterator rbegin(){ 
    return geometry_Iterator(get_dynamic_ref<Rectangle>(), size()-1, true);};

    geometry_const_Iterator begin()  const { 
    return geometry_const_Iterator(get_dynamic_ref<const Rectangle>());};
    geometry_const_Iterator end()    const { 
    return geometry_const_Iterator(get_dynamic_ref<const Rectangle>(), size());}; 
    geometry_const_Iterator rbegin() const { 
    return geometry_const_Iterator(get_dynamic_ref<const Rectangle>(), size()-1, true);};

    void create_H(Matrix& m) const;
    void create_H(Matrix& m, const geometry_const_Iterator& pos, size_t nx) const;

    void visit( Rectangle_Visitor&) const;

    size_t layers() const {return layers_();};
    size_t drawing_layers() const {return drawing_layers_();};

    size_t grid_points() const{ return grid_points_();};
    size_t blocks() const{ if (leaf()) return 1; return size();};
    const_ref block(size_t block_number) const;
    Interface_const_ref interface(size_t block_number) const;

    STD_TR1::shared_ptr<index_connector> left(size_t index) const;
    STD_TR1::shared_ptr<index_connector> right(size_t index) const;

// total number of slices
    size_t nx() const{ return nx(size());};
// total number of slices up to a given block index
    size_t nx(size_t block_max) const{ 
    if (block_max == geometry_Iterator::npos) return 0; 
        return nx_(block_max);};

    double dy(const geometry_const_Iterator& ci) const {return dy_(ci);};
    double dx(const geometry_const_Iterator& ci) const {return dx_(ci);};
    double dphi(const geometry_const_Iterator& ci) const {return dphi_(ci);};

    double rotation() const { return rotation_();};

    virtual bool leaf() const = 0;
    virtual size_t size() const = 0;

    Rectangle::const_ref get_R(size_t pos) const;
    Hamiltonian::const_ref get_H(size_t pos) const;

    Rectangle::ref get_R(size_t pos);
    Hamiltonian::ref get_H(size_t pos);

private:
    const char* name() const { return "Abstract_Rectangle";}

    friend class geometry_Iterator;
    friend class geometry_const_Iterator;

    virtual Interface_const_ref get_I(size_t pos) const {throw (E_Is_Leaf());};

    virtual Rectangle::const_ref am_no_leaf_get_R(size_t pos) const { throw (E_Is_Leaf());};
    virtual Hamiltonian::const_ref am_leaf_get_H(size_t pos) const { throw (E_Is_No_Leaf());};

    virtual Rectangle::ref am_no_leaf_get_R(size_t pos) { throw (E_Is_Leaf());};
    virtual Hamiltonian::ref am_leaf_get_H(size_t pos) { throw (E_Is_No_Leaf());};

    bool valid(size_t p) const {return p <= size();};

    virtual double dy_(const geometry_const_Iterator&) const = 0;
    virtual double dx_(const geometry_const_Iterator&) const = 0;
    virtual double dphi_(const geometry_const_Iterator&) const { return 0.;};    
    
    virtual double rotation_() const { return 0.;};

    virtual void createH(Matrix& m) const;
    virtual void createH(Matrix& m, 
             const geometry_const_Iterator& pos, size_t nx) const = 0;
    virtual void RectangleVisitor( Rectangle_Visitor&) const = 0;

    virtual size_t grid_points_() const = 0;
    virtual size_t nx_(size_t) const = 0;

    virtual size_t layers_() const = 0;
    virtual size_t drawing_layers_() const = 0;

};

struct rect_distribution_info{

    size_t Ncore;
    size_t whoami;

    std::vector<size_t> nx_sizes;
    std::vector<size_t> N_sizes;
    std::vector<size_t> N_offsets;
    std::vector<complex*> state_starts;
    std::vector<geometry_const_Iterator> positions;
    size_t N;

    explicit
    rect_distribution_info(MPI_Comm,
               Rectangle::const_ref,
               complex* state = NULL);
    explicit
    rect_distribution_info(Rectangle::const_ref, complex* state = NULL);

    void create_distributed_H_block( Matrix& m) const;
    void create_distributed_H_supermatrix( Matrix& m) const;
    void add_distributed_diagonal(std::complex<double>, Matrix& m) const;
    

private:
    rect_distribution_info();
    rect_distribution_info(const rect_distribution_info&);
};

#endif