velocityfunction.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:          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