rt_migr.hpp

// rt_migr.hpp
// $Id: rt_migr.hpp,v 1.12 2008/07/30 14:29:22 guser1 Exp $
//---------------------------------------------------------------------
#ifndef __rt_migrhpp
#define __rt_migrhpp

#include <math.h>
#include <vector>

#include "ray_tracing.hpp"
//#include <mix/misc.h>         // for timer
//#include <ldb/dbtools.h>

#include "seis.hpp"
//#define RAY_SHOOT_DEBUG

using namespace std;
typedef vector<int> iVect;
typedef vector<double> dVect;


enum BOUND {TOP, BOT, RIGHT, LEFT, BAD}; 


enum ACTIVE_ZONE {AZ_OK, AZ_NO, AZ_SPECIAL}; 


enum MIGR_TYPE {PPUP, PPDOWN, PSUP, PSDOWN, SPUP, SPDOWN, SSUP, SSDOWN}; 


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

struct MigrInnerCell 
{
  double    f;
  
  double    t;
  
  MigrInnerCell *next;  
};



struct MigrCell 
{
  double    f;
  
  double    t;
  
  unsigned short int      next;
};



struct IPCell 
{
  int       i; 
  
  int       j;
  
  double    f;
  
  double    t;
};


typedef MigrInnerCell** MigrInnerGrid;

//==============================================================================
class RTMigr : private RayTracing
{
public:
  
  //#ifndef GE_BUILD_RAYTR
  //RTMigr(Vel2dModelLDB *VelMod2d, AbstractSeis *seis, double stepX, double stepZ, double dfEps, double migrAngle, MIGR_TYPE mt);  
  //#else
  //RTMigr(Vel2dModelGEVSP *VelMod2d, AbstractSeis *seis, double stepX, double stepZ, double dfEps, double migrAngle, MIGR_TYPE mt);  
  //#endif
  RTMigr(Vel2dModel *VelMod2d, AbstractSeis *seis, double stepX, double stepZ, double dfEps, double migrAngle, MIGR_TYPE mt);  
  
  ~RTMigr();
  
  bool       GetMigrGridSP(int sp_num, MigrCell *&grid, int &size);
  
  bool       GetMigrGridRec(int recNum, MigrCell *&grid, int &size);
  
  
  bool       GetMigrGrid(double x, double z, WAVE_TYPE wType, MigrCell *&grid, int &size);
  
  bool       GetMigrGrid(double x, double z, WAVE_TYPE wType, MigrInnerGrid &grid);
  
  
  
  
  void       CompMigrGrid(MigrCell *grid1, int size1, MigrCell *grid2, int size2, IPCell *&ip_info, int &ip_cell_num,
              int i_beg = -1, int i_end = -1);
  
  void       AddIPInfo(MigrInnerGrid ip_grid, IPCell* ip_info, int ip_cell_num); 
  
  void       RecalculateIPGrid(MigrInnerGrid ip_grid);
  
  double     GetIPValue(int spN, int i, int j, MigrInnerCell cell);
  
  int        GetIMax();
  
  int        GetJMax();
  
  AbstractSeis* GetSeis();
  
  MigrGridArea GetMGArea();
    
  //RayInfo*   RayShoot(double f, double startX, double startZ, WAVE_TYPE wp, MigrInnerGrid grid);
  

  Vel2dModel* GetMod2d() const { return Mod2d; };


  bool       GetReady();
  
private:
  
  RayInfo*   RayShoot(double f, double startX, double startZ, WAVE_TYPE wp, MigrInnerGrid grid);
    
  void       AddRayPoint(double rx0, double rz0, double rx1, double rz1, WAVE_TYPE wType, 
             double f, double t, double dt, MigrInnerGrid grid);  
  
  void       GetCellIJ(double x, double z, int &i, int&j);
  
  void       GetCellXZ(int i, int j, double &x, double &z, BOUND bound=BAD);
  
  void       MarkCell(MigrInnerGrid grid, int i, int j, double f, double t);
  
  BOUND      GetNextCell(int i1, int j1, int &i_next, int &j_next);
  
  BOUND      GetNextPoint(double x, double z, double &x_next, double &z_next);
  
  bool       GetShadowZoneBorder(WAVE_TYPE wType, double spX, double spZ, double init_f, double &last_f, double &f_shad_tmp, double f);
  
  void       GetShadowZoneEnd(WAVE_TYPE wType, double spX, double spZ, double init_f_shad, double f_step, 
                  double &x1, double &z1, int &i1, int &j1, double &f, MigrInnerGrid inner_grid);
  
  bool       CheckBoundPoint(double x, double z);
  
  void       MovePointFromBound(double &x, double &z);
  
  bool       FormMigrGrid(MigrInnerGrid inner_grid, MigrCell *&grid, int &size);
  
  bool       MigrCellComp(MigrCell cell1, MigrCell cell2, int i, int j);
  
  //---------------------------------------------------------------------
  
  ACTIVE_ZONE GetActiveZoneStart(WAVE_TYPE wType, double spX, double spZ, double &init_f, double &init_x, double &init_z, 
                 double f, int &rec_count, bool print=TRUE);
  
  ACTIVE_ZONE AZDetermination(WAVE_TYPE wType, double spX, double spZ, double &init_f, 
                  double &init_x, double &init_z, double f, int &rec_count, 
                  ACTIVE_ZONE AZ, double well_f, double no_well_f, bool print);
  
  int         GetWellDir(double spX, double spZ, double z1, double z2);
  
  bool        GetNearestRecNum(double spX, double spZ, double last_x, double last_z, int &first_rec, int rec_count, bool print=TRUE);
  
  int         GetLastRecNum(WAVE_TYPE wType, double spX, double spZ, double f, int first_rec, int rec_count, 
                double &end_f, double &end_x, double &end_z);
  
  bool        OneRecShoot(WAVE_TYPE wType , double spX, double spZ, int rec_num, double x0, double z0, double x1, double z1, 
              double base_angle, double sec_base_angle, double &result_x, double &result_z, double &result_angle, 
              double &result_w_angle, double &time, double eps); 
  
  double      GetAmpl(int spN, iVect &recNum, dVect &recT, dVect &recF);
  
  bool        AboveWell(double spZ);
  
  bool        RayError(RayInfo *ray, const char* message, double f, double sp_x, double sp_z);
  
  //---------------------------------------------------------------------
  // TEMPORARY
  
  void        Log(const char* str);
    
  //---------------------------------------------------------------------
  // INPUT DATA STORAGE
  
  double     stepX;             
  double     stepZ;             
  double     dfEps;             
  double     migrAngle;         
  int i_max;                    
  int j_max;                    
  AbstractSeis *ASeis;          
  MIGR_TYPE  mType;             
  //---------------------------------------------------------------------
  // AUXILIARY VALUES
  
  bool       ready;             
  double     DIAGONAL;          
  double     T_EPS;             
  double     F_EPS;             
  double     MIN_RAY_STEP;      
  double     ROUGH_F_STEP;      
  double     MIN_F_STEP;        
  int        MAX_CHILD_NUM;     
  double     AZ_F_STEP;         
  double     MOD_LIM_EPS;       
  double     MOD_BOUND_STEP_X;  
  double     MOD_BOUND_STEP_Z;  
  double     MOD_BOUND_EPS_X;   
  double     MOD_BOUND_EPS_Z;   
  int        MAX_ITER_NUM;      
  double     MOVE_POINT_STEP;   
  double     CHECK_BOUND_EPS;   
};


#endif