accumulator.hpp

/* accumulator.hpp */
/* $Id$ */
#ifndef __accumulator_hpp
#define __accumulator_hpp

#ifdef GE_BUILD
#include <s2_abstract_db_access.hpp>
#include <polycor.hpp>
#include <s2_traces_quality.hpp>
#include <s2_row_gen.hpp>
#else 
#include <s2proc/s2_abstract_db_access.hpp>
#include <s2proc/polycor.hpp>
#include <s2proc/s2_traces_quality.hpp>
#include <s2proc/s2_row_gen.hpp>
#endif

typedef std::set<std::pair<int, int> > ROW_IDS;

typedef std::map<int, ROW_IDS> STRIDE_ID_MAP;

typedef std::map<int, STRIDE_ID_MAP> ID_MAP;

class Accumulator
{
public:
  
  Accumulator(S2AbstractDBAccess &dba, 
          S2TracesQuality &TQ,
          const PSC::PSC_Params &params);
  
  ~Accumulator();
  
  bool operator()(std::map<int, PSC::ROW> &recv_rows,
          std::map<int, PSC::ROW> &shot_rows) const;
  
  
  
protected:
  
  //prepare map of index pairs for rows calculation and formation
  bool form_index_map(PSC::StMode mode, 
              ID_MAP &shots_pair_ids, 
              ID_MAP &recvs_pair_ids) const;

  //fill maps of indexes for CSP or CRP seismograms
  bool append_indexes(PSC::StMode mode, 
              const std::set<int> &outer_ids,
              const std::set<int> &inner_ids,
              bool is_outer_nsp,
              ID_MAP &result_pair_ids) const;


  //compose and stack rows for statics determination
  bool stack_rows(PSC::StMode mode,
          PSC::Direction row_dir,
          const ID_MAP &pair_map,
          std::map<int, PSC::ROW> &shot_rows, 
          std::map<int, PSC::ROW> &recv_rows) const;


  // prepare queue of rows to be calculated and stacked for result sum rows formation
  // rows_queue contains pairs [stride, row's id]
  bool prepare_rows_queue(const ID_MAP &pair_map,
              int stride,
              const std::map<int, Trace::AmplT>& rows_weights,
              std::vector<std::pair<int, int> >& rows_queue) const;


  // construct result rows by formed rows queue
  bool construct_result_rows(PSC::StMode mode,
                 PSC::Direction row_dir,
                 const ID_MAP &pair_map,
                 const std::vector<std::pair<int, int> >& rows_queue, 
                 const std::map<int, Trace::AmplT>& rows_weights,
                 const std::map<int, Trace::AmplT>& offset_weights,
                 const std::map<int, Trace::AmplT>& cmps_weights,
                 PSC::ROW &sum_ccf1_row,
                 PSC::ROW &sum_ccf2_row) const;


  //calculate row for current stride, in corresponded mode and direction
  bool calculate_row(PSC::StMode mode,
             PSC::Direction row_dir,
             int stride,
             int row_id,
             const ROW_IDS& row_traces,
             PSC::ROW &row) const;

  
  // stack pair of rows
  bool stack_row_pair(PSC::ROW &base_row,
              PSC::ROW &add_row, 
              Trace &ccf2,
              bool use_inversion,
              bool stack) const;

  
  //get intersection of rows pair
  bool get_id_intersection(const ROW_IDS &add_id_pair, const ROW_IDS &base_id_pair, float &intersection) const;

  

  // for each stride method accumulate sum rows, calculated by each Statics calculation mode (PSC::StMode), 
  // into integral sum row for result ststics determination
  bool integrate_rows(const PSC::ROWS_MAP &calculated_rows, std::map<int, PSC::ROW> &result_rows) const;

   // get base shift for summ row
  bool get_base_shift(PSC::Direction row_dir, int row_id, int stride, int& shift) const;
  
  S2AbstractDBAccess *mp_adba;
  
  S2TracesQuality *mp_tq;
  
  PSC::PSC_Params m_params;
};

#endif /* accumulator.hpp */