u3d_svrg_math_abstract_surf4d.hpp

/* u3d_svrg_math_abstract_surf4d.hpp */
/* $Id: u3d_svrg_math_abstract_surf4d.hpp,v 1.6 2008/09/29 10:39:28 ibadm Exp $ */
#ifndef __u3d_svrg_math_abstract_surf4d_hpp
#define __u3d_svrg_math_abstract_surf4d_hpp

#include "u3d_svrg_math_abstract_surface.hpp"

class U3dPoint4d;

typedef std::vector<U3dPoint4d*> U3dPoints4dAr;

//------------------------------------------------------------------------------------------
class U3dIntEq4dLeftPart : public U3dEqAbstractFunction
{
public:
  U3dIntEq4dLeftPart();
  
  virtual double calc(double x4); 
  
  void setInitialPoints(U3dPoints4dAr &ips)
  {m_ips = &ips;}
  
  void setPCoords(double px1, double px2, double px3)
  {m_x1 = px1; m_x2 = px2; m_x3 = px3;}
  
protected:
  
  U3dPoints4dAr *m_ips;
  
  double m_x1, m_x2, m_x3;
};

//------------------------------------------------------------------------------------------
class U3dSVRGMathAbstractSurf4d
{
public:
  
  U3dSVRGMathAbstractSurf4d(U3dPoints4dAr &points, double g_step);
  
  U3dSVRGMathAbstractSurf4d(const U3dSVRGMathAbstractSurf4d &surf) {};
  
  virtual ~U3dSVRGMathAbstractSurf4d();
  
  virtual bool getPoint(double p, double q, double r, U3dPoint4d &pnt) = 0;
  
  int getGridPoint(int i, int j, int k, U3dPoint4d &p);
  
  int getGridX1Size() {
    return grd_x1.size();
  }
  
  int getGridX2Size() {
    return grd_x2.size();
  }
  
  int getGridX3Size() {
    return grd_x3.size();
  }
  
  void setMinGridStep(double eps) {
    minGridEps = (eps < 0.)?(0.):(eps);
  }
  
  double getMinGridStep() {
    return minGridEps;
  }  
  
  virtual void getAreaSize(U3dPoint4d &min, U3dPoint4d &max);
  
protected:
  
  struct Area4d
  {
    double x1mn, x1mx;
    double x2mn, x2mx;
    double x3mn, x3mx;
    double x4mn, x4mx;
  } area4d;
  
  std::vector<U3dSVRGMathAbstractSurface::GridMatrix> grid;
  
  std::vector<double> grd_x1, grd_x2, grd_x3;
  
  double minGridEps;
  
  int m_grd_ip_num;
  
  double m_prev_x4mn, m_prev_x4mx;
  
  U3dPoints4dAr m_ips;
  
  U3dPoints4dAr m_grd_ips;
  
  U3dIntEq4dLeftPart m_grd_eq_lp;
    
  U3dEqDiv2Solve m_grd_eq_solver;
  
  void construct_grid(U3dPoints4dAr &points);
      
  void push_ip(U3dPoint4d *point);
  
  void add_grid_cell(int ix1, int jx2, int kx3, U3dSVRGMathAbstractSurface::GridCell &cell);
  
  double calc_nip_x4(double x1, double x2, double x3);
};

//------------------------------------------------------------------------------------------

class U3dPoint4d
{
public:
  
  U3dPoint4d() {
    m_x1 = m_x2 = m_x3 = m_x4 = 0.;
  }
  
  U3dPoint4d(double x1, double x2, double x3, double x4); 
  
  U3dPoint4d(const U3dPoint4d &p);
  
  
  double getX1() { return m_x1;}
  
  double getX2() { return m_x2;}
  
  double getX3() { return m_x3;}
  
  double getX4() { return m_x4;}
  
  
  void setX1(double x1) { m_x1 = x1;}
  
  void setX2(double x2) { m_x2 = x2;}
  
  void setX3(double x3) { m_x3 = x3;}
  
  void setX4(double x4) { m_x4 = x4;}
  
  void setCoords(double x1, double x2, double x3, double x4) {
    m_x1 = x1;
    m_x2 = x2;
    m_x3 = x3;
    m_x4 = x4;
  }
  
  U3dPoint4d operator= (const U3dPoint4d& p);
  
protected:
  
  double m_x1, m_x2, m_x3, m_x4;
};

#endif /* u3d_svrg_math_abstract_surf4d.hpp */