velocityfunction.h

Go to the documentation of this file.

#ifndef velocityfunction_h
#define velocityfunction_h

/*+
________________________________________________________________________

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


-*/

#include "velocitymod.h"
#include "enums.h"
#include "factory.h"
#include "multiid.h"
#include "position.h"
#include "ranges.h"
#include "refcount.h"
#include "samplingdata.h"
#include "threadlock.h"
#include "veldesc.h"

namespace Attrib { class DataHolder; };

class BinIDValueSet;


namespace Vel
{

class FunctionSource;

mExpClass(Velocity) Function
{
public:
    void                        ref() const;
    void                        unRef() const;
    void                        unRefNoDelete() const;

                                Function(FunctionSource&);
    const FunctionSource&       getSource() const       { return source_; }

    virtual const VelocityDesc& getDesc() const;

    float                       getVelocity(float z) const;
    const BinID&                getBinID() const;
    virtual bool                moveTo(const BinID&);

    virtual void                removeCache();

    virtual StepInterval<float> getAvailableZ() const                   = 0;
    void                        setDesiredZRange(const StepInterval<float>&);
    const StepInterval<float>&  getDesiredZ() const;

protected:
    virtual                     ~Function();

    virtual bool                computeVelocity(float z0, float dz, int nr,
                                                float* res ) const      = 0;

    FunctionSource&             source_;
    BinID                       bid_;
    StepInterval<float>         desiredrg_;

private:
    friend                      class FunctionSource;

    mutable Threads::Lock       cachelock_;
    mutable TypeSet<float>*     cache_;
    mutable SamplingData<double> cachesd_;
};


mExpClass(Velocity) FunctionSource : public CallBacker
{ mRefCountImplNoDestructor(FunctionSource)
public:
                                mDefineFactory1ParamInClass(
                                        FunctionSource,const MultiID&,factory)

    virtual BufferString        userName() const;
    virtual const VelocityDesc& getDesc() const                         = 0;
    virtual void                getSurroundingPositions(const BinID&,
                                    BinIDValueSet&) const;
    virtual void                getAvailablePositions(BinIDValueSet&) const {}

    ConstRefMan<Function>       getFunction(const BinID&);
    virtual Function*           createFunction(const BinID&)            = 0;

    const MultiID&              multiID() const         { return mid_; }

    virtual NotifierAccess*     changeNotifier()        { return 0; }
    virtual BinID               changeBinID() const     { return BinID(-1,-1); }

    virtual void                fillPar(IOPar&) const   {}
    virtual bool                usePar(const IOPar&)    { return true; }

    const char*                 errMsg() const;

protected:

    friend                      class Function;
    void                        refFunction(const Function* v);
    bool                        unRefFunction(const Function* v);

    int                         findFunction(const BinID&) const;


    MultiID                             mid_;
    BufferString                        errmsg_;

    ObjectSet<Function>                 functions_;
    TypeSet<int>                        refcounts_;
    Threads::Lock                       lock_;
};

} // namespace Vel

#endif