hamiltonian.hpp

Go to the documentation of this file.

#ifndef HAMILTONIAN_CPP_H
#define HAMILTONIAN_CPP_H

#include <vector>

#include "shared_ptr.hpp"
#include "exceptions.hpp"
#include "input_file.hpp"
#include "points.hpp"

class Rectangle;
class Matrix;
class geometry_const_Iterator;
class pencil;

class simple_Hamiltonian;

class Hamiltonian: public loadable_Object{
public:

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

    Hamiltonian() {};    
    ~Hamiltonian() throw() {};


    void create_H0(Matrix&,const geometry_const_Iterator&) const;
    void create_HI(Matrix&,const geometry_const_Iterator&) const;
    void create_HIt(Matrix& s, const geometry_const_Iterator& pos) const;

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

    int ny(const geometry_const_Iterator& pos) const;
    int ny_layer(const geometry_const_Iterator& pos) const;
    point_Positions::ref rxy(const geometry_const_Iterator& pos) const;

    double dx(const geometry_const_Iterator& pos) const;
    double dy(const geometry_const_Iterator& pos) const;
    double dphi(const geometry_const_Iterator& pos) const;
    double width(const geometry_const_Iterator& pos) const;

    std::unique_ptr<pencil> get_pencil() const;
    const std::string& pencil_name() const { return get_pencil_name_();};

    STD_TR1::shared_ptr<simple_Hamiltonian> get_simple_H() { return get_simple_H_();};
    STD_TR1::shared_ptr<const simple_Hamiltonian> get_simple_H() const { return get_simple_H_();};
  
private:

    mutable STD_TR1::shared_ptr<simple_Hamiltonian> mysimple;
    
    virtual std::unique_ptr<pencil> get_pencil_() const = 0;
    virtual const std::string& get_pencil_name_() const = 0;

    virtual STD_TR1::shared_ptr<const simple_Hamiltonian> get_simple_H_() const;
    virtual STD_TR1::shared_ptr<simple_Hamiltonian> get_simple_H_();

    virtual void createH0(Matrix&,const geometry_const_Iterator& pos) const = 0;
    virtual void createHI(Matrix&,const geometry_const_Iterator& pos) const = 0;
    virtual void createHIt(Matrix&,const geometry_const_Iterator& pos) const;

    virtual size_t layers_() const = 0;

    virtual int ny_(const geometry_const_Iterator& pos) const = 0;
    virtual int ny_layer_(const geometry_const_Iterator& pos) const;
    virtual point_Positions::ref rxy_(const geometry_const_Iterator& pos) const = 0;

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

class simple_Hamiltonian_visitor;

class simple_Hamiltonian: public Hamiltonian{
public:

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

    simple_Hamiltonian(): Hamiltonian(){};
    ~simple_Hamiltonian() throw (){};

    size_t ny() const { return my_ny;};
    size_t ny_layer(size_t layer) const { return ny_layer_sh_(layer);};
        // ny_modes(?) includes the possibility that number of ny_

    point_Positions::ref rxy() const{ return rxy_sh_();};

    using Hamiltonian::create_H0;
    using Hamiltonian::create_HI;
    using Hamiltonian::create_HIt;
    
    void create_H0(Matrix& m) const { createperiodicH0(m);};
    void create_HI(Matrix& m) const { createperiodicHI(m);};       
    void create_HIt(Matrix& m) const;       

    void visit( simple_Hamiltonian_visitor& ) const;
    
    void set_new_ny(int ny);

    double dx() const { return dx_sh_();};
    double dy() const { return dy_sh_();};
    double width() const { return width_sh_();};

    bool do_generalized() const { return do_generalized_();};
    virtual size_t slice_num() const {return 1;};
    
    virtual int lead_system_handler() const { return 0;};// 0 is default
    
    virtual int get_basistrans_size() const {return 1;};
    virtual void fill_basistrans_mat(Matrix& m) const;
    virtual size_t get_geometry_slice_num() const {return 1;};
    
protected:
    int my_ny;
    
private:

    virtual bool do_generalized_() const { return false;};

    virtual void init_H_params() = 0;
    virtual void init_ny_dependent_H_params() = 0;
    void init();

    virtual STD_TR1::shared_ptr<const simple_Hamiltonian> get_simple_H_() const;
    virtual STD_TR1::shared_ptr<simple_Hamiltonian> get_simple_H_();

    double dx_(const geometry_const_Iterator& pos) const { return dx_sh_();};
    double dy_(const geometry_const_Iterator& pos) const { return dy_sh_();};
    double width_(const geometry_const_Iterator& pos) const { return width_sh_();};    

    virtual double dx_sh_() const = 0;
    virtual double dy_sh_() const = 0;
    virtual double width_sh_() const = 0;
    
    virtual void visit_(simple_Hamiltonian_visitor&) const;

    point_Positions::ref rxy_(const geometry_const_Iterator& pos) const { 
    return rxy_sh_();};
    virtual point_Positions::ref rxy_sh_() const = 0;

    void createH0(Matrix& m,const geometry_const_Iterator&)
    const { createperiodicH0(m);};
    void createHI(Matrix& m,const geometry_const_Iterator&)
    const { createperiodicHI(m);};
    void createHIt(Matrix& m,const geometry_const_Iterator&)
    const { createperiodicHIt(m);};

    virtual void createperiodicH0(Matrix&) const = 0;
    virtual void createperiodicHI(Matrix&) const = 0;       
    virtual void createperiodicHIt(Matrix&) const;       
    
    size_t layers_() const; 
    virtual size_t layers_sh_() const; 

    int ny_(const geometry_const_Iterator&) const { return ny();};    
    int ny_layer_(const geometry_const_Iterator& p) const;
    virtual int ny_layer_sh_(size_t) const;
};

#endif