velocitycalc.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl
 Date:          Dec 2007
________________________________________________________________________

-*/


#include "algomod.h"
#include "samplingdata.h"
#include "veldesc.h"
#include "keystrs.h"
#include "factory.h"
#include "uistring.h"

template <class T> class ValueSeries;

mExpClass(Algo) TimeDepthModel
{ mODTextTranslationClass(TimeDepthModel)
public:
                        TimeDepthModel();
                        TimeDepthModel(const TimeDepthModel&);
    virtual             ~TimeDepthModel();

    TimeDepthModel&     operator=(const TimeDepthModel&);
    virtual bool        isOK() const;
    const uiString      errMsg() const;
    int                 size() const    { return sz_; }

    bool                setModel(const float* dpths,const float* times,int sz);

    float               getDepth(float time) const;
    float               getTime(float depth) const;
    float               getVelocity(float depth) const;
    float               getFirstTime() const;
    float               getLastTime() const;

    static float        getDepth(const float* dpths,const float* times,int sz,
                                float time);
    static float        getTime(const float* dpths,const float* times,int sz,
                                float depth);
    static float        getVelocity(const float* dpths,const float* times,
                                        int sz,float depth);

                        // use only if you're sure about what you're doing
    float               getDepth(int idx) const;
    float               getTime(int idx) const;

protected:

    static float        convertTo(const float* dpths,const float* times,int sz,
                                    float z,bool targetistime);

    int                 sz_;

    float*              times_;
    float*              depths_;

    uiString            errmsg_;
};


mExpClass(Algo) TimeDepthConverter : public TimeDepthModel
{ mODTextTranslationClass(TimeDepthConverter)
public:
                        TimeDepthConverter();

    bool                isOK() const;
    static bool         isVelocityDescUseable(const VelocityDesc&,
                                              bool velintime,
                                              uiString* errmsg = 0);

    bool                setVelocityModel(const ValueSeries<float>& vels, int sz,
                                         const SamplingData<double>& sd,
                                         const VelocityDesc&,bool istime);

    bool                calcDepths(ValueSeries<float>&, int sz,
                                   const SamplingData<double>& timesamp) const;
    bool                calcTimes(ValueSeries<float>&, int sz,
                                   const SamplingData<double>& depthsamp) const;

    static bool         calcDepths(const ValueSeries<float>& vels, int velsz,
                                   const SamplingData<double>&,float* depths);
    static bool         calcDepths(const ValueSeries<float>& vels, int velsz,
                                   const ValueSeries<float>& times,
                                   float* depths); 
    static bool         calcTimes(const ValueSeries<float>& vels,int velsz,
                                  const ValueSeries<float>& depth,float* times);
    static bool         calcTimes(const ValueSeries<float>& vels, int velsz,
                                   const SamplingData<double>&, float* times);
protected:

    void                calcZ(const float*,int inpsz,
                                ValueSeries<float>&,int outpsz,
                                const SamplingData<double>&,bool istime) const; 

    float               firstvel_;
    float               lastvel_;

    bool                regularinput_;
    int                 sz_;
    SamplingData<double> sd_;
};


mExpClass(Algo) MoveoutComputer
{ mODTextTranslationClass(MoveoutComputer)
public:
    virtual             ~MoveoutComputer()              {}

    virtual int         nrVariables() const                             = 0;
    virtual const char* variableName(int) const                         = 0;

    virtual bool        computeMoveout(const float* variables,
                                             int nroffsets,
                                             const float* offsets,
                                             float* res) const          = 0;
    float               findBestVariable(float* variables, int variabletochange,
                            const Interval<float>& searchrg,int nroffsets,
                            const float* offsets, const float* moveout ) const;
};


mExpClass(Algo) RMOComputer : public MoveoutComputer
{ mODTextTranslationClass(RMOComputer)
public:
    int         nrVariables() const     { return 3; }
    const char* variableName(int idx) const
                {
                    switch ( idx ) 
                    {
                        case 0: return sKey::Depth();
                        case 1: return "RMO";
                        case 2: return "Reference offset";
                    };

                    return 0;
                }
    bool        computeMoveout(const float*,int,const float*,float*) const;
    static bool computeMoveout(float d0, float rmo, float refoffset,
                               int,const float*,float*);
};


mExpClass(Algo) NormalMoveout : public MoveoutComputer
{ mODTextTranslationClass(NormalMoveout)
public:
    int         nrVariables() const     { return 3; }
    const char* variableName( int idx ) const
                {
                    switch ( idx ) 
                    {
                        case 0: return sKey::Time();
                        case 1: return "Vrms";
                        case 2: return "Effective anisotrophy";
                    };

                    return 0;
                }
    bool        computeMoveout(const float*,int,const float*,float*) const;
    static bool computeMoveout(float t0, float Vrms, float effectiveanisotropy,
                               int,const float*,float*);
};

mGlobal(Algo) bool computeDix(const float* Vrms, float t0, float v0,
                        const float* t, int nrlayers, float* Vint);

mExpClass(Algo) Vrms2Vint
{ mODTextTranslationClass(Vrms2Vint)
public:
                        mDefineFactoryInClass( Vrms2Vint, factory );
    virtual             ~Vrms2Vint()    {}

    virtual bool        compute(const float* Vrms, float t0, float v0,
                                const float* t, int nrlayers, float* Vint) = 0;
};


mExpClass(Algo) DixConversion : public Vrms2Vint
{ mODTextTranslationClass(DixConversion)
public:
                mDefaultFactoryInstantiation( Vrms2Vint, DixConversion, 
                                              "Dix",
                                              toUiString(sFactoryKeyword()));

    bool        compute(const float* Vrms, float t0, float v0,
                        const float* t, int nrlayers, float* Vint)
                { return computeDix( Vrms, t0, v0, t, nrlayers, Vint ); }
};



mGlobal(Algo) bool computeDix(const float* Vrms,const SamplingData<double>& sd,
                        int nrvels,float* Vint);

mGlobal(Algo) bool computeDix(const float* Vrms, float t0, float v0,
                                const float* t, int nrlayers, float* Vint);


mGlobal(Algo) bool computeVrms(const float* Vint,const SamplingData<double>& sd,
                         int nrvels, float* Vrms);

mGlobal(Algo) bool computeVrms(const float* Vint,float t0, const float* t,
                         int nrlayers, float* Vrms);

mGlobal(Algo) bool sampleVrms(const float* Vin,float t0_in,float v0_in,
                        const float* t_in, int nr_in, 
                        const SamplingData<double>& sd_out,
                        float* Vout, int nr_out);


mGlobal(Algo) bool computeVavg(const float* Vint, float t0, const float* t,
                         int nrvels, float* Vavg);


mGlobal(Algo) bool computeVint(const float* Vavg, float t0, const float* t,
                         int nrvels, float* Vint);


mGlobal(Algo) bool sampleVint(const float* Vint,const float* t_in, int nr_in,
                        const SamplingData<double>& sd_out, float* Vout,
                        int nr_out);

mGlobal(Algo) bool sampleVavg(const float* Vavg, const float* t_in, int nr_in,
                        const SamplingData<double>& sd_out, float* Vout,
                        int nr_out);

mGlobal(Algo) void computeResidualMoveouts(float z0,float rmo,float refoffset,
                                      int nroffsets,bool outputdepth,
                                      const float* offsets,float* output);

mGlobal(Algo) bool fitLinearVelocity( const float* Vint, const float* z_in,
                              int nr_in, const Interval<float>& zlayer,
                              float reference_z, bool zisdepth, float& V_0,
                              float& gradient, float& error);
                
                
mGlobal(Algo) void resampleZ(const float* zarr,const float* tord_in, int nr_in,
                        const SamplingData<double>& sd_out, int nr_out,
                        float* zsampled);

mGlobal(Algo) void sampleEffectiveThomsenPars(const float* vinarr,
        const float* t_in,int nr_in,const SamplingData<double>& sd_out,
        int nr_out,float* voutarr);

mGlobal(Algo) void sampleIntvThomsenPars(const float* inarr,const float* t_in,
                                int nr_in,const SamplingData<double>& sd_out,
                                int nr_out,float* outarr);

/* Utility function for Depth and effective Thomsen parameters resampling*/
mGlobal(Algo) void resampleContinuousData(const float* inarr,const float* t_in,
                                int nr_in,const SamplingData<double>& sd_out,
                                int nr_out,float* outarr);


mGlobal(Algo) bool computeLinearT2D( double v0, double dv, double v0depth,
                                     const SamplingData<float>& timesampling,
                                     int sz, float* res );

mGlobal(Algo) bool computeLinearD2T( double v0, double dv, double v0depth,
                      const SamplingData<float>& depthsampling,
                      int sz, float* res );


mGlobal(Algo) bool convertToVintIfNeeded(const float* inpvel,
                                        const VelocityDesc& veldesc,
                                        const StepInterval<float>& zrange,
                                        float* outvel);