psc_ts_dispersion_residual.hpp

/* psc_ts_dispersion_residual.hpp */
/* $Id$ */
#ifndef __psc_ts_dispersion_residual_hpp
#define __psc_ts_dispersion_residual_hpp

#include <stdio.h>
#include <stdint.h>
#include <utility>

#ifdef GE_BUILD
#include <residual.hpp>
#include <psc_service.hpp>
#include <psc_ts_container.hpp>
#else
#include <mth/residual.hpp>
#include <s2proc/psc_service.hpp>
#include <s2proc/psc_ts_container.hpp>
#endif

namespace psc
{
  class TsDispersionResidual : public AbstractResidual
  {
  public:
    
    struct Params
    {
      Params():
    hdr_attr(Trace::Header::TA_NSP),
    id(0),
    max_trs_in_base(10),
    min_available_weight(0)
      {/* nothing to do */}
      
      Trace::Header::AttrId hdr_attr;          
      int id;                                  
      int max_trs_in_base;                     
      float min_available_weight;              
    };
    
    TsDispersionResidual(TsContainer &ts_container,
             const Params &params = Params());
    
    virtual ~TsDispersionResidual();
        
    
    Params& params() {return m_params;}
    
    const Params& params() const {return m_params;}
    
    
    TsContainer& tsContainer() {return *mp_ts_container;}
    
    const TsContainer& tsContainer() const {return *mp_ts_container;}
    
  protected:
    
    struct TsCurveParams
    {
      int row_id;
      std::pair<int,int> ids_range;
      Trace::TimeT time_shift;
      unsigned int corr_dir;
      int stride;
    };
    
    struct TsCurveResult
    {
      TsCurveResult(const size_t size) :
    dt_vec(std::vector<double>(size, 0)),
    w_vec(std::vector<double>(size, 0)),
    points_num_vec(std::vector<int>(size, 0))
      {/* nothing to do */}
      
      size_t size() const {return dt_vec.size();}
      
      std::vector<double> dt_vec;
      std::vector<double> w_vec;
      std::vector<int> points_num_vec;
    };
    
    Params m_params;
    
    TsContainer *mp_ts_container;
    
    virtual double calc(const std::vector<double> &dt_vec) const;
    
    bool get_ts_curve(const TsCurveParams &cp, TsCurveResult &cr) const;
    
    bool get_ids_range(const int id,
               const int base_size,
               const std::pair<int,int> &full_ids_range,
               std::pair<int,int> &ids_range) const;
        
    virtual void progress(const int cur, const int max) const; 
    
  }; // class TsDispersionResidual
  
}; // namespace psc

#endif /* psc_ts_dispersion_residual.hpp */