u3d_migr.hpp

/* u3d_migr.hpp */
/* $Id: u3d_migr.hpp,v 1.1 2008/05/13 12:19:18 sad Exp $ */
//---------------------------------------------------------------------
#ifndef __u3d_migrhpp
#define __u3d_migrhpp

#include "u3d_migr_shooter.hpp"
#include <rbm/u3d_seis.hpp>
//#include "u3d_migr_defines.hpp"

//==============================================================================
class U3dMigr : public U3dMigrRayShooter
{
public:
  
  U3dMigr(U3dModel *model, U3dAbstractSeis *seis, 
      float stpX, float stpY, float stpZ, 
      double dfe, double mAngle, U3D_MIGR_TYPE mt, bool slave=true);
         
  ~U3dMigr();
  
  void initMigrCube(ushort imx, ushort jmx, ushort kmx);



  // ***************************************************************************
  // Stage 1 procedures ********************************************************

  bool       getMigrCubeSP(int sp_num, MigrCell *&cube, int &size);
  
  bool       getMigrCubeRec(int recNum, MigrCell *&cube, int &size);

  bool       getMigrCube(U3dPoint p, U3D_WAVE_TYPE wType);  
  bool       getMigrCubeDummy(U3dPoint p, U3D_WAVE_TYPE wType); 



  // ***************************************************************************
  // Stage 2 procedures ********************************************************

  void       compMigrGrid(MigrCell *grid1, int size1, MigrCell *grid2, int size2, 
              int recId,
              IPCell *&ip_info, int &ip_cell_num, 
              int i_beg = -1, int i_end = -1);

  void       addIPInfo(MigrDataCube ip_data, IPCell* ip_info, int ip_cell_num); 

  void       recalculateIPGrid(MigrDataCube ip_data);


  

  // ***************************************************************************
  // Stage 3 procedures ********************************************************
  
  
  /***/
  bool       loadSPTraces(int spId);
  
  double     getIPValue(const IPCell& ip_cell);




  // ***************************************************************************
  // Service procedures ********************************************************
  
  void       calculateImageBox();
  
  ushort     getIMax();
  
  ushort     getJMax();
  
  ushort     getKMax();
  
  void       getSteps(float &step_x, float &step_y, float &step_z);

  U3dAbstractSeis* getSeis();
  
  bool       getReady();

  bool   formMigrGrid(MigrCell *&grid, int &size);
  
  
  
  
  void       cleanMigrCube();
  
  void       freeMigrCube();
  
  void       freeNormCube();
    

  
  
  
  /* ------------ DEBUG ---------------- */
  
  /* Returns migration 3d-grid, contained in the object */
  MigrDataCube accessMigrCube() { return m_migr_cube; }
  /* Delete all children of each migration cell */
  void       cleanMigrChildren();
  
  U3dRay*   testRayShoot(U3dPoint startP, double f, double az, U3dCodeAr rCode, bool waySave) 
  { return rayShoot(startP, f, az, rCode, waySave); }
  


  
  time_t startTimer() { return time(NULL); }
  void stopTimer(time_t beg, const char* message) 
  { 
    time_t end = time(NULL);
    double t = difftime(end, beg);
    UMessage::info("%s : complete... WORKING TIME = %g s", message, t);
  }
  
  /* ------------ DEBUG ---------------- */


  
  
  void       prepareSecondStage();
  
  void       prepareThirdStage();
  
  
  
private:


  // ****************************************************************************
  // Stage 1 procedures (private) ***********************************************
  

  bool       coverCubeFace(U3dPoint p, U3D_WAVE_TYPE wt, int faceId, 
               double f, double az);
  

  // ****************************************************************************
  // Stage 2 procedures (private) ***********************************************
  
  bool       migrCellComp(MigrCell cell1, MigrCell cell2, ushort i, ushort j, ushort k);

  bool       getNormalDirection(ushort i, ushort j, ushort k, double &normF, double &normAz);
  

  // ****************************************************************************    
  // Stage 3 procedures (private) ***********************************************

  double      getAmpl(int spId, std::vector<int> &recIds, std::vector<double> &recT, 
              std::vector<double> &recF, std::vector<double> &recAz);
  

  // ****************************************************************************
  // Service procedures (private) ***********************************************
  
  
  inline bool getCellPoint(const ushort& i, const ushort& j, const ushort& k, U3dPoint& p);
  
  
  


  /* Forms migration-cell structures array on the basis of 3d migration grid; 
      is used in procedure getMigrGrid  */ 
  //bool       formMigrGrid(MigrCell *&grid, int &size);



  
  

  // ****************************************************************************
  // **************************************************************************** 
  // ****************************************************************************  
  /*============ debug ==================*/
  /* Remember start parameters of current shooted ray ??????? */
  bool       rayError(U3dRay *ray, const char* message, double f, double az, U3dPoint sp);
  void       Log(const char* str);
    
  /* Saving incident points grid (debug) */
  void       saveIPGrid(MigrDataCube migr_cube, int i_max, int j_max, int k_max, 
            int prog_id,int sp_num);
  
  /*============ debug ==================*/
  // **************************************************************************** 
  // ****************************************************************************
  // **************************************************************************** 






  // ****************************************************************************
  // **************************************************************************** 
  
  NormDataCube     m_norm_cube;         
  double           m_dfEps;             
  double           m_migrAngle;         /* ray angle sector half-width for well 
                       shooting (see procedure GetIPValue) (UNUSED) */
  
  U3dAbstractSeis *m_seis;              
  U3D_MIGR_TYPE    m_mType;             
  bool             m_ready;             
};




//==============================================================================
//------------------------------------------------------------------------------
inline bool U3dMigr::getCellPoint(const ushort& i, const ushort& j, const ushort& k, U3dPoint& p)
{
  if (i>m_i_max || j>m_j_max || k>m_k_max)
    return false;
  double stepx = m_stepX, stepy = m_stepY, stepz = m_stepZ;
  if (i==m_i_max) stepx = m_model->getModelBox().getXMax() - i*m_stepX;
  if (j==m_j_max) stepy = m_model->getModelBox().getYMax() - j*m_stepY;
  if (k==m_k_max) stepz = m_model->getModelBox().getZMax() - k*m_stepZ;
  p.setXYZ(stepx/2 + i*m_stepX, 
       stepy/2 + j*m_stepY, 
       stepz/2 + k*m_stepZ);
  return true;
}

//---------------------------------------------------------------------
#endif /* u3d_migr.hpp */