psc_ts_optimizer.hpp

/* psc_ts_optimizer.hpp */
/* $Id$ */
#ifndef __psc_ts_optimizer_hpp
#define __psc_ts_optimizer_hpp

#include <utility>

#ifdef GE_BUILD
#include <psc_service.hpp>
#include <psc_solver.hpp>
#include <psc_ts_dispersion_residual.hpp>
#else
#include <s2proc/psc_service.hpp>
#include <s2proc/psc_solver.hpp>
#include <s2proc/psc_ts_dispersion_residual.hpp>
#endif

namespace psc
{
  class TsOptimizer
  {
  public:
        
    struct Params
    {
      Params():
    max_time_shift(50),
    iters_num(5),
    conv_stability_coeff(1.),
    min_disp_change(0)
      {/* nothing to do */}
      
      
      Trace::TimeT max_time_shift;   
      size_t iters_num;              
      float conv_stability_coeff;    
      Trace::TimeT min_disp_change;  
    };
    
    struct Results
    {
      double dispersion[2];   
      unsigned int iters_num; 
    };

    TsOptimizer(const Params &params);
    
    virtual ~TsOptimizer();
    
    bool operator()(TsDispersionResidual &dr, 
            Solver::TimeShifts *const p_shots_statics,
            Solver::TimeShifts *const p_recvs_statics,
            Results *const p_results = NULL) const;
  protected:
    
    Params m_params;
        
    double statics_iter(TsDispersionResidual &dr,
            const Trace::Header::AttrId &attr_id,
            Solver::TimeShifts &statics) const;
    
    double calc_dispersion(TsDispersionResidual &dr,
               const Trace::Header::AttrId &attr_id) const;
    
    double dummy_minimize(const TsDispersionResidual &dr, Trace::TimeT &min_dt) const;
    
    double minimize(const TsDispersionResidual &dr, Trace::TimeT &min_dt) const;
    
    double least_squares_minimize(const TsDispersionResidual &dr, Trace::TimeT &min_dt) const;
    
    virtual void progress(const int cur, const int max) const; 
    
  private:
    
    void test_apriory_statics_apply(TsDispersionResidual &dr) const;
    
  }; // class TsOptimizer
  
}; // namespace psc

#endif /* psc_ts_optimizer.hpp */