velocitycalc.h

Go to the documentation of this file.

#ifndef velocitycalc_h
#define velocitycalc_h

/*+
________________________________________________________________________

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

-*/


#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 char*         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<double>& times,
                                   double* depths);
    static bool mDeprecated 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, double t0, float v0,
                        const double* t, int nrlayers, float* Vint);

mGlobal(Algo) bool mDeprecated 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, double t0, float v0,
                        const double* t, int nrlayers, float* Vint)
                { return computeDix( Vrms, t0, v0, t, nrlayers, Vint ); }

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



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

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

mGlobal(Algo) bool mDeprecated 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,double t0,const double* t,
                               int nrlayers, float* Vrms);

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


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

mGlobal(Algo) bool mDeprecated 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,const double* t,int nrvels,
                               float* Vavg);

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


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

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


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

mGlobal(Algo) bool mDeprecated 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 double* t_in,int nr_in,
                        const SamplingData<double>& sd_out,float* Vout,
                        int nr_out);

mGlobal(Algo) bool mDeprecated 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 double* zarr,const double* tord_in,int nr_in,
                        const SamplingData<double>& sd_out,int nr_out,
                        double* zsampled);

mGlobal(Algo) void mDeprecated 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 double* t_in,int nr_in,const SamplingData<double>& sd_out,
        int nr_out,float* voutarr);

mGlobal(Algo) void mDeprecated 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 double* t_in,
                                int nr_in,const SamplingData<double>& sd_out,
                                int nr_out,float* outarr);

mGlobal(Algo) void mDeprecated 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 double* in,const double* t_in,
                                int nr_in,const SamplingData<double>& sd_out,
                                int nr_out,double* outarr);

mGlobal(Algo) void mDeprecated 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);

mGlobal(Algo) SamplingData<double> getDoubleSamplingData(
                                                    const SamplingData<float>&);

#endif