simple_rectangles.hpp

#ifndef CONCRETE_RECTANGLE_HPP
#define CONCRETE_RECTANGLE_HPP

#include "rectangle.hpp"

namespace fortran{
    struct Block;
}

/*****************************
 *
 *  class single_Rectangle
 *
 *      Hold one slice of one Hamiltonian, solve by direct inversion
 *
 */

class single_Rectangle: public Rectangle{
public:

    single_Rectangle(): my_H(){};
    virtual ~single_Rectangle() throw() {};

protected:

    bool leaf() const {return true;};
    size_t size() const {return 1;};

private:
    Hamiltonian::ref my_H;

    Hamiltonian::const_ref am_leaf_get_H(size_t pos) const {return my_H;};
    Hamiltonian::ref am_leaf_get_H(size_t pos) {return my_H;};

    void init();

    double dy_(const geometry_const_Iterator& pos) const { return my_H->dy(pos);};
    double dx_(const geometry_const_Iterator& pos) const { return my_H->dy(pos);};

    void RectangleVisitor( Rectangle_Visitor& v) const;

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

    size_t layers_() const { return my_H->layers();};
    size_t drawing_layers_() const;

    void createH(Matrix&, const geometry_const_Iterator&, size_t) const;

    size_t grid_points_() const {return begin().ny();};
    size_t nx_(size_t) const { return 1;};
};


/*****************************
 *
 *  class periodic_Rectangle
 *
 *      Hold nx slices of one periodic (i.e. not x-dependent)
 *      Hamiltonian, solve by Sanvito
 *
 */

class periodic_Rectangle: public Rectangle{
public:

    periodic_Rectangle(){};
    ~periodic_Rectangle() throw() {};

protected:

    bool leaf() const {return true;};
    size_t size() const { return nx;}; 

private:
    simple_Hamiltonian::ref my_H;
    int nx;

    Hamiltonian::const_ref am_leaf_get_H(size_t pos) const {return my_H;};
    Hamiltonian::ref am_leaf_get_H(size_t pos) {return my_H;};

    double dy_(const geometry_const_Iterator&) const {return my_H->dy();};
    double dx_(const geometry_const_Iterator&) const { return my_H->dx();};

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

    void createH(Matrix&, const geometry_const_Iterator&, size_t) const;

    void RectangleVisitor( Rectangle_Visitor& v) const;

    size_t layers_() const { return my_H->layers();};
    size_t drawing_layers_() const;

    void init();

    size_t grid_points_() const;
    size_t nx_(size_t) const { return nx;};
};

/*****************************
 *
 *  class normal_Rectangle
 *
 *      Hold nx slices of not necessarily periodic
 *      Hamiltonian, solve by Inversion
 *
 */

class normal_Rectangle: public Rectangle{
public:

    normal_Rectangle(){};
    ~normal_Rectangle() throw() {};

protected:

    bool leaf() const {return true;};
    size_t size() const { return nx;}; 

    void init_nx_H();

private:
    Hamiltonian::ref my_H;
    int nx;

    Hamiltonian::const_ref am_leaf_get_H(size_t pos) const {return my_H;};
    Hamiltonian::ref am_leaf_get_H(size_t pos) {return my_H;};

    double dy_(const geometry_const_Iterator& pos) const {return my_H->dy(pos);};
    double dx_(const geometry_const_Iterator& pos) const { return my_H->dx(pos);};

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

    void createH(Matrix&, const geometry_const_Iterator&, size_t) const;
    void RectangleVisitor( Rectangle_Visitor& v) const;

    size_t layers_() const { return my_H->layers();};
    size_t drawing_layers_() const;

    void init();

    size_t grid_points_() const;
    size_t nx_(size_t) const { return nx;};
};

class Interface;

typedef STD_TR1::shared_ptr<Interface> Interface_ref;
typedef STD_TR1::shared_ptr<const Interface> Interface_const_ref;

class Potential;

class rect_Block: public Rectangle{
public:
    rect_Block(){};
    ~rect_Block() throw() {};

protected:

    size_t size() const {return Rects->size();}; 
    bool leaf() const {return false;};
    
private:
    
    typedef std::vector<Rectangle::ref> Rect_List;
    STD_TR1::shared_ptr<Rect_List> Rects;

    typedef std::vector<Rectangle::ref>::iterator rect_iter;
    typedef std::vector<Rectangle::ref>::const_iterator c_rect_iter;

    typedef std::vector<Interface_ref> Inter_List;
    Inter_List Interfaces;

    typedef std::vector<Interface_ref>::iterator int_iter;
    typedef std::vector<Interface_ref>::const_iterator c_int_iter;

    const char* name() const { return "Block";};
    void init();

    Interface_const_ref get_I(size_t pos) const { return Interfaces[pos];};    

    Rectangle::const_ref am_no_leaf_get_R(size_t pos) const { return (*Rects)[pos];};
    Rectangle::ref am_no_leaf_get_R(size_t pos) { return (*Rects)[pos];};

    void calculate();

    void createH(Matrix&) const;
    void createH(Matrix&, const geometry_const_Iterator&, size_t) const;

    void RectangleVisitor( Rectangle_Visitor& v) const;

    double dy_(const geometry_const_Iterator&) const;
    double dx_(const geometry_const_Iterator&) const;
    double dphi_(const geometry_const_Iterator&) const;

    size_t layers_() const;
    size_t drawing_layers_() const;

    size_t grid_points_() const;
    size_t nx_(size_t) const;

    bool act_as_one_rect;
};



#endif