u3d_svrg_math_abstract_surface.hpp

// u3d_svrg_math_abstract_surface.hpp
// $Id: u3d_svrg_math_abstract_surface.hpp,v 1.13 2007/06/27 15:48:32 guser1 Exp $
#ifndef U3D_SVRG_MATH_ABSTRACT_SURFACE_HPP_
#define U3D_SVRG_MATH_ABSTRACT_SURFACE_HPP_

#include <u3d_point.hpp>
#include <u3d_defines.hpp>
#include "u3d_abstract_surface.hpp"
#include "u3d_nl_eqsolve.hpp"
//#include "u3d_svrg_math_abstract_surf4d.hpp"

#include <vector>

#define S3D_MIN_DELTA_FOR_DIV 1e-10

class U3dIntEqLeftPart;

class U3dSVRGMathAbstractSurface : public U3dMathAbstractSurface  
{
  
  friend class U3dSVRGMathAbstractSurf4d;
  
public:
  
  U3dSVRGMathAbstractSurface(U3dPointsAr &points, double g_step);
  
  U3dSVRGMathAbstractSurface(U3dSVRGMathAbstractSurface *ps);
  
  virtual ~U3dSVRGMathAbstractSurface();
  
  

  virtual void addPoint(U3dPoint *point);
  
  virtual bool removePoint(int ind);
  
  virtual void movePoint(int ind, double x, double y, double z);
  
 
 
  int getGridPoint(int i, int j, U3dPoint &p);
  
  int getGridXSize() {
    return grd_x.size();
  }
  
  int getGridYSize() {
    return grd_y.size();
  }
  
  
  
  void setMinGridStep(double eps) {
    minGridEps = (eps < 0.)?(0.):(eps);
  }
  
  double getMinGridStep() {
    return minGridEps;
  }  
      
protected:
  
  double minGridEps;
  
  std::vector<double> grd_x, grd_y;
  
  struct GridCell
  {
    GridCell(int i_ind,  double i_z) {
      ip_ind = i_ind;
      z = i_z;
    }
    
    int ip_ind;    
    double z;      
  };
  
  typedef std::vector<GridCell> GridLine;
  
  typedef std::vector<GridLine> GridMatrix;
  
  GridMatrix grid;
  
  void construct_grid(U3dPointsAr &points);
  
  void push_ip(U3dPoint *point);
  
  static int get_ip_id(double x, std::vector<double> &grd_x, 
               double dx, double &xmn, double &xmx);
  
  static void correct_id(int &id, int size) {
    if (id < 0)
      id = 0;
    else if (id >= size)
      id = size - 1; 
  }
  
private:
  
  U3dEqDiv2Solve *m_grd_eq_solver;
  
  U3dIntEqLeftPart *m_grd_eq_lp;
  
  int m_grd_ip_num;
  
  U3dPointsAr m_grd_ips;
  
  double m_prev_zmn, m_prev_zmx;
  
  double tmpd;
  
  int tmpi;
  
  static bool add_grid_cell(int ix, int jy, GridCell &cell, GridMatrix &rgrid, 
                double &zmn, double &zmx, double &pzmn, double &pzmx,
                std::vector<double> &xgd, std::vector<double> &ygd,
                double x, double y, bool is_increase_xy = true);
  
  double calc_nip_z(double x, double y);
};


class U3dIntEqLeftPart : public U3dEqAbstractFunction
{
public:
  U3dIntEqLeftPart()
  {is_init = false;}
  
  virtual ~U3dIntEqLeftPart(){}
  
  double calc(double z);
  
  void init(U3dPointsAr &pips)
  {ips = pips; is_init = true;}
  
  void setPCoords(double px, double py)
  {x = px; y = py;}
  
  double get_2d_ip_dist(int i, double x, double y) {
    return ((ips[i]->getX() - x)*(ips[i]->getX() - x) +
        (ips[i]->getY() - y)*(ips[i]->getY() - y));
  }
  
  double get_3d_ip_dist(int i, double x, double y, double z) {
    return ((ips[i]->getX() - x)*(ips[i]->getX() - x) +
        (ips[i]->getY() - y)*(ips[i]->getY() - y) +
        (ips[i]->getZ() - z)*(ips[i]->getZ() - z));
  }
  
  
protected:

  U3dPointsAr ips;
  
  double x, y;
  
  bool is_init;
};

#endif  /*U3D_SVRG_MATH_ABSTRACT_SURFACE_HPP_*/