u3d_prgrid3d.hpp

/* u3d_prgrid3d.hpp */
/* $Id: u3d_prgrid3d.hpp,v 1.4 2008/10/28 08:12:31 hasher Exp $ */
#ifndef __u3d_prgrid3d_hpp
#define __u3d_prgrid3d_hpp

#include <mth/u3d_point4d.hpp>
#include "u3d_prgrid2d.hpp"

class U3dPRGrid3d 
{
public:
  
  U3dPRGrid3d(const U3dPoints4dAr &points, double g_step);
  
  U3dPRGrid3d(const U3dPRGrid3d &obj);
  
  virtual ~U3dPRGrid3d();
  

  void construct(const U3dPoints4dAr &points, double g_step);
  

  int getGridPoint(int i, int j, int k, U3dPoint4d &p) const;
  
  int getGridX1Size() const {
    return grd_x1.size();
  }
  
  int getGridX2Size() const {
    return grd_x2.size();
  }
  
  int getGridX3Size() const {
    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:
  
  class U3dIntEq4dLeftPart : public UEqAbstractFunction
  {
  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;
  };
  
  struct Area4d
  {
    double x1mn, x1mx;
    double x2mn, x2mx;
    double x3mn, x3mx;
    double x4mn, x4mx;
  } area4d;
  
  std::vector<U3dPRGrid2d::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;
    
  UEqDiv2Solve m_grd_eq_solver;
        
  void push_ip(U3dPoint4d *point);
  
  void add_grid_cell(int ix1, int jx2, int kx3, U3dPRGrid2d::GridCell &cell);
  
  double calc_nip_x4(double x1, double x2, double x3);

  void clear();
};


#endif /* u3d_prgrid3d.hpp */