Real2dData< F > Class Template Reference

#include <Real2dData.h>

Public Types
using	Float = F
using	DataVector = std::vector< F >
using	Index = unsigned int
using	IndexArray = std::array< Index, 2 >
using	Norm = RealDftNormalization
using	Complex = std::complex< Float >

Public Member Functions
	Real2dData ()
	Real2dData (const IndexArray &nsams)
	Real2dData (const IndexArray &nsams, const DataVector &data)
virtual	~Real2dData ()=default
void	clear ()
void	reset (const IndexArray &nsams)
Index	rank () const
const IndexArray &	nSamples () const
Index	nSamples (Index idim) const
Index	size (Index idim) const
Index	size () const
bool	inRange (Index idim, Index idat) const
bool	isZero (Index idat) const
bool	isValid () const
Float	badValue () const
const std::vector< F > &	data () const
int	copyDataIn (const DataVector &data)
template<typename T >
int	copyDataIn (const T *pdat)
template<typename T >
int	copyDataOut (T *pdat) const
Index	globalIndex (const IndexArray &isams, Index *pchk=nullptr) const
Float	value (const IndexArray &isams, Index *pchk=nullptr) const
Index	setValue (const IndexArray &isams, Float val, Index *pchk=nullptr)
F	power () const

Static Public Member Functions
template<std::size_t N>
static Index	dataSize (const std::array< Index, N > &nsams)

Private Attributes
IndexArray	m_nsams
DataVector	m_data

Detailed Description

template<typename F>
class Real2dData< F >

Definition at line 20 of file Real2dData.h.

Member Typedef Documentation

template<typename F>

using Real2dData< F >::Complex = std::complex<Float>

Definition at line 36 of file Real2dData.h.

template<typename F>

using Real2dData< F >::DataVector = std::vector<F>

Definition at line 32 of file Real2dData.h.

template<typename F>

using Real2dData< F >::Float = F

Definition at line 31 of file Real2dData.h.

template<typename F>

using Real2dData< F >::Index = unsigned int

Definition at line 33 of file Real2dData.h.

template<typename F>

using Real2dData< F >::IndexArray = std::array<Index,2>

Definition at line 34 of file Real2dData.h.

template<typename F>

using Real2dData< F >::Norm = RealDftNormalization

Definition at line 35 of file Real2dData.h.

Constructor & Destructor Documentation

template<typename F>

Real2dData< F >::Real2dData ( )

inline

Definition at line 52 of file Real2dData.h.

: m_nsams({0,0}) { }

template<typename F>

Real2dData< F >::Real2dData ( const IndexArray &  nsams )

inline

Definition at line 56 of file Real2dData.h.

: m_nsams(nsams), m_data(dataSize(nsams), 0.0) { }

template<typename F>

Real2dData< F >::Real2dData ( const IndexArray &  nsams, const DataVector &  data  )

inline

Definition at line 59 of file Real2dData.h.

  : Real2dData(nsams) {
    copyDataIn(data);
  }

template<typename F>

virtual Real2dData< F >::~Real2dData ( )

virtualdefault

Member Function Documentation

template<typename F>

Float Real2dData< F >::badValue ( ) const

inline

Definition at line 111 of file Real2dData.h.

                         {
    double bad = std::numeric_limits<Float>::quiet_NaN();
    return bad;
  }

template<typename F>

void Real2dData< F >::clear ( )

inline

Definition at line 68 of file Real2dData.h.

               {
    for ( Index& nsam : m_nsams ) nsam = 0;
    m_data.clear();
  }

template<typename F>

int Real2dData< F >::copyDataIn ( const DataVector &  data )

inline

Definition at line 121 of file Real2dData.h.

                                         {
    if ( ! isValid() ) return 1;
    if ( data.size() != m_data.size() ) return 2;
    m_data = data;
    return 0;
  }

template<typename F>

template<typename T >

int Real2dData< F >::copyDataIn ( const T *  pdat )

inline

Definition at line 131 of file Real2dData.h.

                                {
    if ( ! isValid() ) return 1;
    Index ndat = size();
    for ( Index idat=0; idat<ndat; ++idat ) {
      m_data[idat] = pdat[idat];
    }
    return 0;
  }

template<typename F>

template<typename T >

int Real2dData< F >::copyDataOut ( T *  pdat ) const

inline

Definition at line 143 of file Real2dData.h.

                                 {
    if ( ! isValid() ) return 1;
    Index ndat = dataSize(nSamples());
    for ( Index idat=0; idat<ndat; ++idat ) {
      pdat[idat] = m_data[idat];
    }
    return 0;
  }

template<typename F>

const std::vector<F>& Real2dData< F >::data ( ) const

inline

Definition at line 117 of file Real2dData.h.

{ return m_data; }

template<typename F>

template<std::size_t N>

static Index Real2dData< F >::dataSize ( const std::array< Index, N > &  nsams )

inlinestatic

Definition at line 41 of file Real2dData.h.

                                                         {
    Index ndat = 1;
    Index ndim = nsams.size();
    for ( Index idim=0; idim<ndim; ++idim ) {
      Index nsam = nsams[idim];
      ndat *= nsam;
    }
    return ndat;
  }

template<typename F>

Index Real2dData< F >::globalIndex ( const IndexArray &  isams, Index *  pchk = nullptr  ) const

inline

Definition at line 154 of file Real2dData.h.

                                                                         {
    if ( ! isValid() ) {
      if ( pchk != nullptr ) *pchk = 1;
      return size();
    }
    if ( isams.size() != rank() ) {
      if ( pchk != nullptr ) *pchk = 2;
      return size();
    }
    if ( pchk != nullptr ) {
      for ( Index idim=0; idim<rank(); ++idim ) {
        if  ( ! inRange(idim, isams[idim]) ) {
          *pchk = 10 + idim;
          return size();
        }
      }
      *pchk = 0;
    }
    Index idat = isams[0];
    for ( Index idim=1; idim<rank(); ++idim ) {
      idat *= m_nsams[idim];
      idat += isams[idim];
    }
    return idat;
  }

template<typename F>

bool Real2dData< F >::inRange ( Index  idim, Index  idat  ) const

inline

Definition at line 97 of file Real2dData.h.

{ return idim < rank() && idat < size(idim); }

template<typename F>

bool Real2dData< F >::isValid ( ) const

inline

Definition at line 102 of file Real2dData.h.

                       {
    if ( rank() != 2 ) return false;
    if ( m_nsams.size() != rank() ) return false;
    if ( size() == 0 ) return false;
    return true;
  }

template<typename F>

bool Real2dData< F >::isZero ( Index  idat ) const

inline

Definition at line 98 of file Real2dData.h.

{ return idat == 0; }

template<typename F>

const IndexArray& Real2dData< F >::nSamples ( ) const

inline

Definition at line 86 of file Real2dData.h.

{ return m_nsams; }

template<typename F>

Index Real2dData< F >::nSamples ( Index  idim ) const

inline

Definition at line 87 of file Real2dData.h.

                                   {
    if ( idim > rank() ) return 0;
    return nSamples()[idim];
  }

template<typename F>

F Real2dData< F >::power ( ) const

inline

Definition at line 206 of file Real2dData.h.

                  {
    F pwr = 0.0;
    IndexArray idats;
    for ( idats[0]=0; idats[0]<size(0); ++idats[0] ) {
      for ( idats[1]=0; idats[1]<size(1); ++idats[1] ) {
        F val = value(idats);
        pwr += val*val;
      }
    }
    return pwr;
  }

template<typename F>

Index Real2dData< F >::rank ( ) const

inline

Definition at line 82 of file Real2dData.h.

{ return 2; }

template<typename F>

void Real2dData< F >::reset ( const IndexArray &  nsams )

inline

Definition at line 74 of file Real2dData.h.

                                       {
    m_nsams = nsams;
    m_data.clear();
    Index ndat = dataSize(m_nsams);
    m_data.resize(ndat, 0.0);
  }

template<typename F>

Index Real2dData< F >::setValue ( const IndexArray &  isams, Float  val, Index *  pchk = nullptr  )

inline

Definition at line 197 of file Real2dData.h.

                                                                           {
    Index idat = globalIndex(isams, pchk);
    if ( pchk != nullptr && *pchk > 0 ) return size();
    if ( idat >= size() ) return size();
    m_data[idat] = val;
    return idat;
  }

template<typename F>

Index Real2dData< F >::size ( Index  idim ) const

inline

Definition at line 91 of file Real2dData.h.

{ return nSamples(idim); }

template<typename F>

Index Real2dData< F >::size ( ) const

inline

Definition at line 94 of file Real2dData.h.

{ return m_data.size(); }

template<typename F>

Float Real2dData< F >::value ( const IndexArray &  isams, Index *  pchk = nullptr  ) const

inline

Definition at line 184 of file Real2dData.h.

                                                                   {
    Index idat = globalIndex(isams, pchk);
    if ( idat >= size() ) return this->badValue();
    return m_data[idat];
  }

Member Data Documentation

template<typename F>

DataVector Real2dData< F >::m_data

private

Definition at line 221 of file Real2dData.h.

template<typename F>

IndexArray Real2dData< F >::m_nsams

private

Definition at line 220 of file Real2dData.h.

---

The documentation for this class was generated from the following file:

• dunecore/dunecore/DuneInterface/Data/Real2dData.h