complicated_rectangle.hpp

#ifndef COMPLICATED_RECTANGLE_HPP
#define COMPLICATED_RECTANGLE_HPP

namespace fortran{
    struct Block;
}

#include "rectangle.hpp"
#include "interface.hpp"



class rotated_matrix;
 
class rotated_rect: public Rectangle{
public:
    rotated_rect(){};
    ~rotated_rect() throw() {};
    
protected:
    
    bool leaf() const { return false;};
    size_t size() const { return 2;};

private:
    typedef STD_TR1::shared_ptr< std::vector<int> > mat_index_ref; 
    const char* name() const { return "rotated_rect";};

    void init();

    Rectangle::const_ref am_no_leaf_get_R(size_t pos) const { 
    return (pos == 0) ? left_rect : right_rect;};
    Rectangle::ref am_no_leaf_get_R(size_t pos) { 
    return (pos == 0) ? left_rect : right_rect;};

    complex bpar;
    bool upwards;
    mutable double ist_x;
    mutable double ist_y;
    int ist;

    Rectangle::ref left_rect;
    Rectangle::ref right_rect;
    Interface::ref inter;

    Interface_const_ref get_I(size_t pos) const { return inter;};    

    mutable mat_index_ref matrix_indizes;
    mutable STD_TR1::shared_ptr<Vector> Lambda;

    STD_TR1::shared_ptr<rotated_matrix> my_mat;

    void set_coordinates() const;
    void set_coordinates_upwards(std::vector<point>&) const;
    void set_coordinates_not_upwards(std::vector<point>&) const;

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

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

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

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



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

protected:

    size_t size() const {return 1;}; 
    bool leaf() const {return false;};
    
private:
    size_t myN;
    
    Rectangle::ref my_rect;

    Interface::ref my_inter;

    Interface_const_ref get_I(size_t pos) const { return my_inter;};    

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

    Rectangle::const_ref am_no_leaf_get_R(size_t pos) const { return my_rect;};
    Rectangle::ref am_no_leaf_get_R(size_t pos) { return my_rect;};

    void calculate();

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

    double dy_(const geometry_const_Iterator&) const;
    double dx_(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;

    double bloch_k;

};

class rect_Block;

class many_Rects: public Rectangle{
public:
    typedef STD_TR1::shared_ptr<many_Rects> ref;
    typedef STD_TR1::shared_ptr<const many_Rects> const_ref;

    many_Rects();
    ~many_Rects() throw() {};

protected:

    size_t size() const; 
    bool leaf() const;
    
private:

    size_t counter;
    int gen_count;
    bool randomize_rects;
    bool use_generic_Interface;

    typedef std::vector<Interface::ref> Interface_Vec;
    typedef STD_TR1::shared_ptr<Interface_Vec> Interface_Vec_p;
    Interface_Vec_p Interfaces;

    typedef std::list<Rectangle::ref> Rect_List;
    typedef STD_TR1::shared_ptr<Rect_List> Rect_List_p;
    Rect_List_p Rects;

    Rectangle::ref actual_Rect;    

    void Fibonacci(int);

    Rectangle::ref combine();
    Rectangle::ref combine(const Rect_List&);

    Interface::ref get_Interface();

    Rect_List_p generate(Rect_List_p) const;

    const char* name() const { return "Fibonacci_rectangles";};
    void init();
    void init_from_clone(loadable_Object::const_ref);

    void init_basic();

    Interface_const_ref get_I(size_t pos) const;    

    Rectangle::const_ref am_no_leaf_get_R(size_t pos) const;
    Rectangle::ref am_no_leaf_get_R(size_t pos);

    void createH(Matrix&) const;
    void createH(Matrix&,
         const geometry_const_Iterator& pos,
         size_t nx) 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;
};

#endif