funcs.hpp

#ifndef FUNC_CPP_HEADER_INPU
#define FUNC_CPP_HEADER_INPU

#include "funcs_base.hpp"
#include <list>

class expression;
class ncexpression;
class cexpression;

class real2complex_wrapper : public function_complex_Object
{
public:
    ~real2complex_wrapper() throw() {};
    real2complex_wrapper(function_Object::ref given_real_func) : real_func(given_real_func) {
    real_func->initialize(real_func);
    };

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

    void init_func();

    complex value(const double) const;

    function_Object::ref real_func;
};

class real2complex_2d_wrapper : public function_complex2d_Object
{
public:
    ~real2complex_2d_wrapper() throw() {};
    real2complex_2d_wrapper(function2d_Object::ref given_real_func) : real_func(given_real_func) {};

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

    void init_func();

    complex value(const double,const double) const;

    function2d_Object::ref real_func;
};

class parsed_complex_func: public function_complex_Object{
public:
    virtual ~parsed_complex_func() throw() {};
private:
    STD_TR1::shared_ptr<cexpression> expr;
    STD_TR1::shared_ptr<cexpression> expr_2;

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

    void init_func();

    complex value(const double) const;
};

class translated2d_func: public function2d_Object{
public:
    virtual ~translated2d_func() throw() {};
private:
    STD_TR1::shared_ptr< 
    std::list< function2d_Object::ref > > funcs;


    function2d_Object::ref fxy;
    function2d_Object::ref yp;
    function2d_Object::ref xp;

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

    void init_func();

    double value(const double,const double) const;
};


class parsed_complex2d_func: public function_complex2d_Object{
public:
    virtual ~parsed_complex2d_func() throw() {};
private:
    STD_TR1::shared_ptr<ncexpression> expr;
    STD_TR1::shared_ptr<ncexpression> expr_2;

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

    void init_func();

    complex value(const double,const double) const;
};

/*
2d Gaussian distribution with standard deviation stddeviation. volume represents the "height", standing for the integral value over R2 (default value 1)

TODO: stddeviation is presumably wrong
*/
class gaussian2d_func: public function2d_Object{
public:
    virtual ~gaussian2d_func() throw() {};

private:
    double stddeviation;
    double volume;

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

    void init_func();

    double value(const double,const double) const;
};

/*
Potential of a pointload -q_potential at a distance -d_load appart from the 2d layer 

*/
class pointload2d_func: public function2d_Object{
public:
    virtual ~pointload2d_func() throw() {};

private:
    double q_potential;
    double d_load;

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

    void init_func();

    double value(const double,const double) const;
};


/*
a radial function expanded into 2d 
*/
class radial2d_func: public function2d_Object{
public:
    STD_TR1::shared_ptr<expression> expr;
    
    virtual ~radial2d_func() throw() {};

private:

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

    void init_func();

    double value(const double,const double) const;
};


class sine2d_func: public function2d_Object{
public:
    virtual ~sine2d_func() throw() {};

private:
    double amplitude;
    double lambdax;
    double lambday;

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

    void init_func();

    double value(const double,const double) const;
};

class periodic2d_func: public function2d_Object {
public:
    virtual ~periodic2d_func() throw() {};
private:

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

    function2d_Object::ref f;

    double vector1_x,vector1_y;
    double vector2_x,vector2_y;
    double angle;

    void init_func();

    double value(const double,const double) const;

};


class modify_vector: public vector_Object{
public:
    ~modify_vector() throw() {};
private:
    const char* name() const {return "modify_vector";};

    size_t determine_size();
    void init_vector();
    void lazy_init() const;
};


class combine_vectors: public vector_Object{
public:
    ~combine_vectors() throw() {};
private:
    const char* name() const {return "combine_vectors";};

    size_t determine_size();
    void init_vector();
};



class random_vector: public vector_Object{
public:
    virtual ~random_vector() throw() {};

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

    void init_vector();
};


class random_smooth_vector: public vector_Object{
public:
    virtual ~random_smooth_vector() throw() {};

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

    void init_vector();
};


class expand_2d_vector: public vector_Object{
public:
    virtual ~expand_2d_vector() throw() {};

private:
    size_t nx, ny, data_ny;

    vector_Object::ref data;

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

    size_t determine_size();
    void init_vector();
    void lazy_init() const;
};


class random_smooth2d_vector: public vector_Object{
public:
    virtual ~random_smooth2d_vector() throw() {};

private:
    double dx, dy, correlation, amp, dis;
    int nx, ny, periodic_y,periodic_x;
    int shift_to_zero;
    function_Object::ref rand_dist_func;

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

    size_t determine_size();
    void init_vector();
    void lazy_init() const;
};


class input_file_vector: public vector_Object{
public:
    virtual ~input_file_vector() throw() {};

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

    void init_vector();
};


class parsed_vector_Object: public vector_Object{
public:
    ~parsed_vector_Object() throw() {};
private:
    const char* name() const {return "parsed_vector";};

    void init_vector();
};


class vector_step_function: public function_Object{
public:
    ~vector_step_function() throw() {};

private:
    vector_Object::ref data;
    double ddy, Wy;
    int ny;
    bool discrete;// true: interpret f(x) as f(int(x)), false: interpolate: f(x) = f(int(y *f/ Wy))
    
    const char* name() const { return "vector_step_function"; };

    void init_func();

    double value(const double) const;
};


class vector_step_function2d: public function2d_Object{
public:
    ~vector_step_function2d() throw() {};

private:
    vector_Object::ref data;
    double ddx, ddy, Wx, Wy;
    int ny, nx;
    bool flip_nxy;

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

    void init_func();

    double value(const double, const double) const;
};


class complex_vector_step_function2d: public function_complex2d_Object{
public:
    ~complex_vector_step_function2d() throw() {};

private:
    vector_Object::ref data;
    vector_Object::ref data_imag;
    double ddx, ddy, Wx, Wy;
    int ny;

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

    void init_func();

    complex value(const double, const double) const;
};


class totally_random_vector : public vector_Object {
    /* creating vector with random numbers from [distance-amplitude/2,distance+amplitude/2 */

public:
    virtual ~totally_random_vector() throw() {};

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

    void init_vector();
};

class double_QPC_on_cyl_vector : public vector_Object {
public:
  virtual ~double_QPC_on_cyl_vector() throw() {};
private:
  int nx,ny,gap1,gap2,wall,y_leftlead;
  const char* name() const { return "Double_QPC";};

  size_t determine_size();
  void init_vector();
  void lazy_init() const;
};

class single_QPC_on_cyl_vector : public vector_Object {
public:
  virtual ~single_QPC_on_cyl_vector() throw() {};
private:
  int nx,ny,gap1,wall,y_leftlead;
  const char* name() const { return "Single_QPC";};

  size_t determine_size();
  void init_vector();
  void lazy_init() const;
};

class single_QPC_on_long_cyl_vector : public vector_Object {
public:
  virtual ~single_QPC_on_long_cyl_vector() throw() {};
private:
  int nx,ny,gap1,wall,y_leftlead;
  const char* name() const { return "Single_QPC_long";};

  size_t determine_size();
  void init_vector();
  void lazy_init() const;
};

class single_QPC_on_straight : public vector_Object {
public:
  virtual ~single_QPC_on_straight() throw() {};
private:
  int nx,ny,gap1,wall,y_leftlead;
  const char* name() const { return "Single_horizontal_QPC";};

  size_t determine_size();
  void init_vector();
  void lazy_init() const;
};

class cut_simple_obstacles : public vector_Object {

public:
  virtual ~cut_simple_obstacles() throw() {};
private:
  int nx,ny, do_rect, phi;
  std::vector< double > xpositions;
  std::vector< double > ypositions;
  std::vector< double > radii;
  std::vector< double > width;
  std::vector< double > height;
  std::vector< double > potentials;
  //std::vector< double > pot_real;
  //std::vector< double > pot_imag;
  const char* name() const {return "simple_obst";};

  size_t determine_size();
  void init_vector();
  void lazy_init() const;
};

class cut_random_obstacles : public vector_Object {

public:
  virtual ~cut_random_obstacles() throw() {};
private:
  int nx,ny;
  int randomize_radii;
  int breakconf;
  double dx,dy;
  double r_max;
  double d_min;
  double circle_pot,background_pot;
  double filling_factor;
  int number_of_circles;

  const char* name() const {return "random_obstacles";};
  size_t determine_size();
  void init_vector();
  void lazy_init() const;

};



class const_vector : public vector_Object {

public:
  virtual ~const_vector() throw() {};
private:
  int nx,ny;
  double bulk_pot;
  double border_pot;
  int border_width;

  const char* name() const {return "const_vector";};
  size_t determine_size();
  void init_vector();
  void lazy_init() const;

};

class interpolate_vector: public vector_Object{
public:
    virtual ~interpolate_vector() throw() {};

private:
    int nx0,ny0;
    int zoom;
    vector_Object::ref data;
    int nx,ny;
    std::string filename;
    const char* name() const {return "interpolate_vector";};
    size_t determine_size();
    void init_vector();
    void lazy_init() const;
};
    
class sine_boundary: public vector_Object{

public:
    virtual ~sine_boundary() throw() {};
private:
    int nx;
    double dx,dy,epsilon,delta,k;

    const char * name() const { return "sine_boundary";}
    size_t determine_size();
    void init_vector();
    void lazy_init() const;

};


#endif