polycor_math_old.hpp

/* polycor_math.hpp */
/* $Id: polycor_math.hpp 21283 2011-11-29 07:50:53Z urij $ */
#ifndef __polycor_math_old_hpp
#define __polycor_math_old_hpp

#include <s2proc/udb_seis.hpp>
#include <s2proc/wave_field.hpp>
#include <s2proc/PolyMatrix_old.hpp>

#include <math.h>

namespace polycor_old
{


namespace Polycor
{
  
  struct CCF_sample
  {
    std::pair<int, int> m_TRS1;  // id of the first trace
    std::pair<int, int> m_TRS2;  // id of the second trace
    
    int m_CCF_RANGE;         // Correlation function range  0-> ACF 
                             //                             1-> neighbour shot points
                             //                             2-> cross 1 shot point    
    char m_COMP;             // component of traces
    
    int m_summed_count;
    Trace m_CCF_TRACE;       // body of CCF1
    
  };

  struct CCF2_shift
  {
    std::pair<int, int> NSP_PAIR1;  // id of the first trace in first CCF1 
    std::pair<int, int> NSP_PAIR2;  // id of the second trace in first CCF1
      
    float SHIFT;         // shift betwen pair of CCF1 in ms 
    float MAX_VAL;       // Value of CCF2 in SHIFT point
    Trace m_CCF2;        // body of CCF2
  };
 
  typedef std::vector<Polycor::CCF_sample> CCF_Ar;
  typedef std::vector<Polycor::CCF2_shift> SHIFT_Ar;

  typedef std::vector<std::vector<double> > Coeff_Matrix;

  struct AmplBadness 
  {
    AmplBadness(const std::vector<double> &shifts) :
      m_d(0.0),
      m_mean(0.0)
    {
      if (shifts.size() < 1) 
    {
      m_d = 0.0;
      m_mean = 0.0;
      return;
    }     
      
      // mean value 
      m_mean = 0.;
      for (size_t i=0; i<shifts.size(); i++)
    {
      m_mean += shifts[i]* shifts[i]; 
    }
      m_mean /= shifts.size();
      
      //summ of quadratic derivations
      m_d = 0;
      for (size_t i=0; i<shifts.size(); ++i)
    {
      m_d += (shifts[i]*shifts[i] - m_mean) * (shifts[i]*shifts[i] - m_mean);
    }
      m_d /= shifts.size();
    }
    
    double operator()() const {return m_d;}
    
    double operator()(const double& t) const 
    { 
      return fabs(t*t - m_mean);
    }
    
    double m_d;
    
    double m_mean;
  };
  
    
  typedef std::vector<std::pair<std::pair<int, int >, double> > StaticRow;

  bool WfCorrelator(WaveField &wf1, WaveField &wf2,  WaveField &ccf_wf, float start_time, float time_width, float ccf_length, bool norma);

  bool TransformCCF(const WaveField &wf, TrHeader *headers, Polycor::CCF_Ar &CcfAr);

  bool summ_CCF1_rows(CCF_Ar &Base_row, CCF_Ar &add_row, CCF2_shift &CCF2, const float &intersect_ratio, const float *l_range, const float &max_shift);

  bool get_CCF_max(const Trace &trs, float &time, float &max_value);

  
  bool get_CCF2_wave(const SHIFT_Ar &TMP_CCF2_ROW, Trace &ccf2_trs);


  bool compose_summ_row(CCF_Ar &first_row, const CCF_Ar &second_row, float &time_shift, CCF_Ar &summ_row);
  

  bool form_Matrix(SHIFT_Ar &cur_shift_ar,
           std::vector<std::pair<int ,int> > &X_i, 
           Coeff_Matrix &coef_mat, 
           std::vector<double> &result);

  bool gauss_Prepare(Coeff_Matrix &coef_mat, std::vector<double> &result);


};

bool Comparator(const Polycor::CCF2_shift &ccf_sh1, const Polycor::CCF2_shift &ccf_sh2);

//===================================================================================================
//=========================* Class for RP based matrix construction *================================
//===================================================================================================

class PolyMatrixRP : public PolyMatrix
{
public:
  
  PolyMatrixRP(std::vector<Polycor::CCF_Ar> &CCF1_base);
  virtual ~PolyMatrixRP();

  bool SetMatrixElement(size_t i, size_t j, double& val);
  bool SetVectorElement(size_t i, double& val);

  bool IsReady();
  size_t GetPointsCount(std::vector<int> &ID_num);

protected:
  
  bool set_ID_Row();
  std::set<int> m_RP_set;
  std::vector<Polycor::CCF_Ar>* m_CCF1_base;

private:
  bool m_ready;

};



//===================================================================================================
//=========================* Class for SP based matrix construction *================================
//===================================================================================================

class PolyMatrixSP : public PolyMatrix
{
public:
  
  PolyMatrixSP(std::vector<Polycor::SHIFT_Ar> &CCF2_base);
  virtual ~PolyMatrixSP();

  bool SetMatrixElement(size_t i, size_t j, double& val);
  bool SetVectorElement(size_t i, double& val);

  bool IsReady();
  size_t GetPointsCount(std::vector<int> &ID_num);

protected:
  
  bool set_ID_Row();
  std::set<int> m_SP_set;
  std::vector<Polycor::SHIFT_Ar>* m_CCF2_base;

private:
  bool m_ready;

};

};

#endif /* polycor_math_old.hpp */