optimize1d.hpp

/* optimize1d.hpp */
/* $Id: optimize1d.hpp,v 1.9 2008/12/11 08:59:33 ibadm Exp $ */
#ifndef __optimize1d_hpp
#define __optimize1d_hpp

#include "ikp1ddata.hpp"
#include "ikp1dmod.hpp"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

#ifndef Fortran
#define Fortran(x)   x##_
#endif
  
  void Fortran(tmell)(double*, double*, double*, int*, int*, int*,
              double*, double*, double*, int*, double*, int*,
              double*, double*, int*, int*, double*);
  
  void Fortran(gradtu)(double*, double*, double*, int*, int*, int*,
               double*, double*, double*, int*, 
               double*, double*, double*, double*);
   
  void Fortran(ldikp)(double*, double*, double*, double*, double*,
              int*, int*, double*, double*, double*, double*, double*, double*,
              double*, double*, double*,double*, double*, double*,double*, double*,
              int*);

#ifdef __cplusplus
};
#endif /* __cplusplus */

class Optimize1d
{
public:
    
  struct OptType {
    static const int VP  = 1; // 001 - Velocity optimization
    static const int KP  = 2; // 010 - Anizotropy koefficients optimization
    static const int DIP = 4; // 100 - Dip optimization
  };
  
  Optimize1d(IKP1dModel *mod, IKP1dData *data);
  
  virtual ~Optimize1d();
  
  void inverseProblem(int IterNum);
  
  void directProblem();
  
  void setAnizLim(double lim);
  
  void setOptimType(int type);
  
  void setDipArea(double min, double max);
  
  void initData();
  
  IKP1dData* getHodsData() {
    return m_data;
  }
  
  IKP1dModel* getCurrentModel() {
    return m_mod;
  }
  
  double getCurDerVal()
  {return calc_derivatives();}
  
  int getCurIterVal()
  {return cur_iter_val;}
  
  void stopOptim()
  {m_optim_continue = false;}
  
  static void calcPolylineHodVels(IKP1dHod *hod, IKP1dModel *mod, 
                  IKP1dWaveType wt, double maxVelocity);

  void set_dip_az(double dip, double az);
  
protected:
  
  struct IntData
  {
    IntData();
    
    virtual ~IntData() {
      clean();
    }
    
    void clean();
    
    double *q0p, *q0s, *q1p, *q1s; 
    double *q0pcur, *q1pcur;       
    double *q0scur, *q1scur;       
    std::vector<int*> Lr, Ls;      
    std::vector<double*> L0;       
    std::vector<double**> dtdqp0;   
    std::vector<double**> dtdqp1;   
    std::vector<double**> dtdqs0;   
    std::vector<double**> dtdqs1;   
    std::vector<double**> dtdDip;   
    double *ztop;                  
    double *hr;                    
    int *Ln;                       
    double *dFdqp0,  *dFdqp1;      
    double *dFdqs0,  *dFdqs1;      
    double *dFdDip;                
    double dFdDipFull;             
    int N;                         
    IKP1dData *data;               
  } iData;
  
  IKP1dModel *m_mod;
  
  IKP1dData *m_data;
  
  typedef double CMatrix[3][3]; 
  
  double m_aniz_lim;
  
  int m_opt_type;
  
  float m_min_sin;
  
  bool m_optim_continue;
  
  double cur_der_val;
  
  int cur_iter_val;
  
  double m_min_sin_fi;
  
  bool m_compute_dip;
  
  double m_min_dip_val, m_max_dip_val;
  
  virtual void setProgressValue(int val){};

  void init_data();
  
  void remove_idata();
      
  double calc_f();
  
  double calc_derivatives();
  
  void trans_os(IKP1dDataLayer *lay, CMatrix &m);
  
  void make_trans_matrix(double dip, double az, CMatrix &m1, CMatrix &m2); 
  
  void set_lr_ls(int n);
  
  void q_step(int n, double *q0p, double *q1p, double alf, double k_lim);
  
  void fix_slownes_vel_ranges(int n, double &q0);
  
  void v2q();
  
  void q2v();

private:
  
  Optimize1d() {;}
};

#endif /* optimize1d.hpp */