externalpotential.hpp

Go to the documentation of this file.

#ifndef EXTPOT_HEADER
#define EXTPOT_HEADER

#include "abstract_potential.hpp"
#include "funcs_base.hpp"

class point_Positions;
typedef STD_TR1::shared_ptr<point_Positions> point_Positions_ref;



class y_dependent_Potential: public Potential{
public:
    ~y_dependent_Potential() throw(){};
   
private:  

    vector_Object::ref v; 
    function_Object::ref f;
    function_Object::ref f_imag;

    point_Positions_ref points;

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

    void init_pot_();

    void prepare_pot_(const geometry_const_Iterator& p);
    complex get_pot_(int iy) const;

};


class absorbing_lower_Boundary: public Potential{
public:
    ~absorbing_lower_Boundary() throw() {};

private:
    vector_Object::ref shape;
    complex V_up;
    complex V_low;
    int index;

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

    void init_pot_();


    void prepare_pot_(const geometry_const_Iterator& p);
    complex get_pot_(int iy) const;
};


class x_dependent_Potential: public Potential{
public:
    ~x_dependent_Potential() throw(){};
   
private:    

    vector_Object::ref v; 
    function_Object::ref f; 
    
    point_Positions_ref points;
    
    double e0;

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

    void init_pot_();

    void prepare_pot_(const geometry_const_Iterator& p);
    complex get_pot_(int iy) const;

};

/*
  Name: xy_Potential
  Parameters:
  Objects:
  - data: a vector_Object, that contains the values of the potential as function of 
          position index
  - [modulo_ny]: for layered structures, take iy % modulo_ny, so that both layers can see the same potential
  - [global_geometry]: use global coordinate systems instead of local one
  - [data_imag]: a vector_Object, that contains the imaginary part of the potential 
    (if it exists) as function of position index
  - [force_ny]: An integer, default 0, that gives the leading dimension of the data array.
          if 0, H%ny will be used.
  - [smooth_sides] An integer, default 0. if the distance to the boundary is smaller
    than smooth_sides, potential will be multiplied by (ix/smooth_sides)**2
*/

class xy_dependent_Potential: public Potential{
public:
    ~xy_dependent_Potential() throw(){};

private:

    vector_Object::ref v;
    vector_Object::ref v_imag;

    function_Object::ref f; 
    function_Object::ref f_imag; 
    
    int force_ny;
    int modulo_ny;
    int index;
    int smooth_sides;
    int only_one_smooth_side;

    bool global_geometry;
    
    double mult;

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

    void init_pot_();


    void prepare_pot_(const geometry_const_Iterator& p);
    complex get_pot_(int iy) const;

};

class xy_dependent_function2d_Potential: public Potential {
public:
    ~xy_dependent_function2d_Potential() throw(){};

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

  function_complex2d_Object::ref f;

  STD_TR1::shared_ptr<std::vector<complex> > values;

  void init_pot_();


  void prepare_pot_(const geometry_const_Iterator& p);
  complex get_pot_(int iy) const;
};




class Puddles: public Potential{
friend class periodic_puddles;
public:
    ~Puddles() throw() {};    
protected:
    STD_TR1::shared_ptr<std::vector<double> > positions_x;
    STD_TR1::shared_ptr<std::vector<double> > positions_y;
    STD_TR1::shared_ptr<std::vector<double> > depths;
    STD_TR1::shared_ptr<std::vector<double> > widths;
    
    STD_TR1::shared_ptr<std::vector<complex> > values;

    STD_TR1::shared_ptr<function_complex_Object> dependence;

    size_t n_puddle;
 
    void init_posdep();

private:

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

    void init_pot_();
    void prepare_pot_(const geometry_const_Iterator&);
    complex get_pot_(int) const;

    complex get_puddle_pot(double, double, int);
    virtual void cut_xy(double& x, double& y);
};

//Two lattice vectors and a starting point should be given; the structure will then be repeated
//over the whole rectangle. Where to get its geometry has yet to be figured out.
//possible extension: more than one radially symmetrical potential being repeated
//angle turns clockwise because the coordinates start at the top left

class periodic_puddles: public Puddles
{
public:
    ~periodic_puddles() throw() {};
  
private:
    
    double vector1_x,vector1_y,vector2_x,vector2_y;
    double cvector1_x,cvector1_y,cvector2_x,cvector2_y;
    double start_x, start_y;
    
    void init_pot_();
    
    const char* name() const { return "periodic_puddles";};      

    void cut_xy( double& x, double& y);
};



class Edge_Roughness: public Potential{
public:
    ~Edge_Roughness() throw() {};

private:
    function_complex_Object::ref f_up;
    function_complex_Object::ref f_down;
    vector_Object::ref edge_up;   
    vector_Object::ref edge_down;   

    double dist_x;
    int nx_;
    int ny_;
    int ix_;
    int iwrap;
    bool index_wrap;

    bool only_y;
    bool left_to_right;

    point_Positions_ref points;

    const char* name() const { return "Edge_Roughness";};
    
    void init_pot_();
    void prepare_pot_(const geometry_const_Iterator& );
    complex get_pot_(int) const;
};


class Edge_Roughness_smooth: public Potential{
public:
    ~Edge_Roughness_smooth() throw() {};

private:
    function_complex_Object::ref f_interior;

    function_complex_Object::ref f_up;
    function_complex_Object::ref f_down;
    function_Object::ref edge_up;   
    function_Object::ref edge_down;   

    complex get_very_good_pot(int iy) const;
    double get_up(int, function_Object::ref, function_Object::ref, int) const;

    double dist_x;
    double pos_x_;
    double dx_;
    double wrap_;
    double length_;
    double width_;
    double correct_dist_fac;
    double estimate_side_dist_fac;

    bool index_wrap;
    bool correct_dist;
    bool very_good_pot;

    bool only_y;

    point_Positions_ref points;

    const char* name() const { return "Edge_Roughness_smoth";};
    
    complex effective_dist_down( double D ) const;
    complex effective_dist_up( double D ) const;

    void init_pot_();
    void prepare_pot_(const geometry_const_Iterator& );
    complex get_pot_(int) const;
};


class Lattice_vacancies: public Potential{
public:

    ~Lattice_vacancies() throw() {};

private:
    std::vector< int > disabled;
    int pos;
    int xmin;
    int xmax;
    int ymin;
    int ymax;
    int posinunit;
    double E1;
    double E2;
    double prob;
    bool do_symmetric;

    const char* name() const { return "Lattice_vacancies";};
    
    void init_pot_();
    void prepare_pot_(const geometry_const_Iterator& );
    complex get_pot_(int) const;
};

// Point defects at fixed positions

class Point_defects: public Potential{
public:
    ~Point_defects() throw() {};

private:
    STD_TR1::shared_ptr<std::vector< int > > pos_x;
    STD_TR1::shared_ptr<std::vector< int > > pos_y;
    STD_TR1::shared_ptr<std::vector< double > > E_shift;

    size_t nsize;

    int current_ix;

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

    void init_pot_();
    void prepare_pot_(const geometry_const_Iterator& );
    complex get_pot_(int) const;
};


class Linear_Potential: public Potential{
public:

    ~Linear_Potential() throw() {};

private:
  double linpot,vleft, vright;

    const char* name() const { return "Linear";};
    
    void init_pot_();
    void prepare_pot_(const geometry_const_Iterator& );
    complex get_pot_(int) const;
};

class Sine_Potential: public Potential{
public:

    ~Sine_Potential() throw() {};

private:
  double sinpot,vleft, vright;

    const char* name() const { return "Sine";};
    
    void init_pot_();
    void prepare_pot_(const geometry_const_Iterator& );
    complex get_pot_(int) const;
};

class multiband_Potential: public Potential {
public:
  ~multiband_Potential() throw (){};

private:
  Potential::ref pot;
  int bands;
  int ny;
  int nx;
  const char* name() const { return "multiband_Potential"; };
  void init_pot_();
  void prepare_pot_(const geometry_const_Iterator& p);
  complex get_pot_(int iy) const;
};
                     

#endif