s2_reflsim.hpp

/* s2_reflsim.hpp */
/* $Id: s2_reflsim.hpp 21022 2011-07-11 11:45:03Z urij $ */
#ifndef __s2_reflsim_hpp
#define __s2_reflsim_hpp

#include <s2proc/s2_poly_wave_approx.hpp>

class S2ReflSim
{
public:
  
  enum KinType
    {
      HYP = 0,  
      AVEL      
    };
  
  struct Parameters
  {
    Trace::AmplT kpmn, kpmx;            
    size_t tr_slide_base;               
    Trace::AmplT tlen;                  
    size_t poly_deg;                    
    size_t poly_bases_num;              
    Trace::AmplT poly_time_base;        
    Trace::AmplT poly_time_win;         
    S2ReflSim::KinType kin_type;        
  };
  
  struct AprItem
  {
    AprItem() {t = pmn = pmx = 0.;}
    
    AprItem(Trace::AmplT i_t, Trace::AmplT i_pmn, Trace::AmplT i_pmx)
    {
      t = i_t;
      pmn = i_pmn;
      pmx = i_pmx;
    }
    
    Trace::AmplT t, pmn, pmx;
  };
  
  typedef std::vector<S2ReflSim::AprItem> AprVector;
  
  struct KinParams
  {
    double t;         
    double p;         
    double k1;        
    double k2;        
    double corr;      
    int nmgl;         
    int point_type;   
    static bool t_asc_corr_desc_comp (const KinParams &p1, const KinParams &p2); 
    
    static bool t_asc_nmgl_asc_comp (const KinParams &p1, const KinParams &p2); 
    
    static bool nmgl_asc_t_asc_comp (const KinParams &p1, const KinParams &p2); 
        
    static bool t_asc_comp (const KinParams &p1, const KinParams &p2); 

    static bool t_eq_predicator (const KinParams &p1, const KinParams &p2);
    
    void info() const 
    {printf ("KinParams->info: (nmgl,t,p,k1,k2,corr)=(%d, %2.3f, %2.3f, %2.3f, %2.3f, %2.3f)\n",
         nmgl, t, p, k1, k2, corr);}
  };
  
  typedef std::vector<S2ReflSim::KinParams> KPSVector;
  
  struct CFElem
  {
    CFElem(){ c = 0.; cmx = 0.; mxbn = 0;}
    
    double c;    
    double cmx;  
    int mxbn;    
  };
  
  typedef std::vector<CFElem> CFVector;
  typedef std::vector<CFVector> CFMatrix;
  
  S2ReflSim();
  
  S2ReflSim(const Parameters &params);
  
  virtual ~S2ReflSim();
    
  
  Parameters getParameters() {return m_params;}
  void setParameters(const Parameters &params);
  Parameters& parameters() {return m_params;}
  
  void setApriorityKin(std::vector<S2ReflSim::AprItem> &apriority)
  {m_apriority_kin = apriority;}
  
  bool calcCorrField(WaveField &field, std::vector<CFVector> &corr);
  
  bool calcCorrField(const std::vector<WaveField>::iterator &field_begin_it,
             const std::vector<WaveField>::iterator &field_end_it,
             CFMatrix &corr);
  
  bool calcSim(WaveField &field, CFVector &sim_vec);
  
  bool calcKinParams(const CFMatrix &corr, 
             std::vector<KinParams> &kps);
  
  bool calcPolyCoeffs(const std::vector<WaveField>::iterator &field_begin_it,
              const std::vector<WaveField>::iterator &field_end_it,
              std::vector<KinParams> &kps);
  
  bool smoothKin(std::vector<KinParams> &kinparams, double smooth_coeff);
  
  bool smoothPolyCoeffs(std::vector<KinParams> &kinparams, double smooth_coeff);
  
  bool mfKin(std::vector<KinParams> &kinparams, double rejection);
  
  bool apriorityKin(std::vector<KinParams> &kinparams, 
            std::vector<S2ReflSim::AprItem> &apriority,
            size_t poly_deg);
  
  
  static void applyKin(WaveField &field, 
               const std::vector<KinParams> &kin_params,
               bool dir = true,
               double mul = 1.);

protected:
  
  bool m_ready;
  
  Parameters m_params;

  std::vector<S2ReflSim::AprItem> m_apriority_kin;
  
  bool construct_hyp(const CFMatrix &cf,
             double t0, double dt,
             double p0, double dp,
             std::vector<KinParams> &kps);
  
  void calc_kin_ranges(double t, double &pmn, double &pmx);
  
private:
  
};

#endif /* s2_reflsim.hpp */