welllog.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert Bril
 Date:          Aug 2003
 RCS:           $Id$
________________________________________________________________________
 
 
-*/
 
#include "wellmod.h"
#include "welldahobj.h"
#include "ranges.h"
#include "iopar.h"
#include "unitofmeasure.h"
#include "propertyref.h"
 
namespace Well
{
 
mExpClass(Well) Log : public DahObj
{
public:
 
                        Log( const char* nm=0 )
                        : DahObj(nm)
                        , range_(mUdf(float),-mUdf(float))
                        , iscode_(false)                {}
                        Log( const Log& t )
                        : DahObj("")                    { *this = t; }
    Log&                operator =(const Log&);
 
    bool                isLoaded() const;
 
    float               value( int idx ) const          { return vals_[idx]; }
    void                setValue(int idx,float val);
 
    float               getValue(float md,bool noudfs=false) const;
    void                addValue(float md,float val);
    void                updateAfterValueChanges();
    void                ensureAscZ();
                        // Do this after adding values when Z may be reversed
    bool                insertAtDah(float md,float val);
    void                removeTopBottomUdfs();
 
    Interval<float>&    valueRange()                    { return range_; }
    const Interval<float>& valueRange() const           { return range_; }
 
    const char*         mnemLabel() const;
    const Mnemonic*     mnemonic() const;
    void                setMnemLabel( const char* );
 
    const char*         unitMeasLabel() const           { return unitmeaslbl_;}
    const UnitOfMeasure* unitOfMeasure() const;
    void                setUnitMeasLabel( const char* s ) { unitmeaslbl_ = s; }
    void                convertTo(const UnitOfMeasure*);
    PropertyRef::StdType propType() const;
    bool                isCode() const                  { return iscode_; }
    Log*                cleanUdfs() const;
    Log*                upScaleLog(const StepInterval<float>&) const;
    Log*                sampleLog(const StepInterval<float>&) const;
    static Log*         createSampledLog(const StepInterval<float>&,
                                         const float val = mUdf(float));
    
    static const char*  sKeyMnemLbl();
    static const char*  sKeyUnitLbl();
    static const char*  sKeyHdrInfo();
    static const char*  sKeyStorage();
    static const char*  sKeyDahRange();
    static const char*  sKeyLogRange();
 
    float*              valArr()                        { return vals_.arr(); }
    const float*        valArr() const                  { return vals_.arr(); }
 
    IOPar&              pars()                          { return pars_; }
    const IOPar&        pars() const                    { return pars_; }
 
protected:
 
    TypeSet<float>      vals_;
    Interval<float>     range_;
    BufferString        unitmeaslbl_;
    BufferString        mnemlbl_;
    bool                iscode_;
    IOPar               pars_;
 
    void                removeAux( int idx )    { vals_.removeSingle(idx); }
    void                eraseAux()              { vals_.erase(); }
    float               gtVal(float,int&) const;
 
};
 
 
} // namespace Well