Fw2dFFT Class Reference

#include <Fw2dFFT.h>

Public Types
using	DataFloat = float
using	DftFloat = double
using	Data = Real2dData< DataFloat >
using	DFT = FftwReal2dDftData< DftFloat >
using	Index = DFT::Index
using	IndexArray = DFT::IndexArray
using	Complex = DFT::Complex
using	Plan = fftw_plan
using	PlanMap = std::map< IndexArray, Plan >
typedef double	FftwComplex[2]

Public Member Functions
	Fw2dFFT (Index ndatMax, Index opt)
	~Fw2dFFT ()
Index	checkDataSize (const IndexArray &nsams) const
bool	haveForwardPlan (const IndexArray &nsams) const
bool	haveBackwardPlan (const IndexArray &nsams) const
Plan &	forwardPlan (const IndexArray &nsams)
Plan &	backwardPlan (const IndexArray &nsams)
int	fftForward (const Data &dat, DFT &dft, Index logLevel=0)
int	fftBackward (const DFT &dft, Data &dat, Index logLevel=0)
FftwComplex *	fftwOutData ()
DftFloat *	floatOutData ()

Private Attributes
Index	m_ndatMax
Index	m_flag
DftFloat *	m_inData
Complex *	m_outData
PlanMap	m_forwardPlans
PlanMap	m_backwardPlans

Detailed Description

Definition at line 30 of file Fw2dFFT.h.

Member Typedef Documentation

using Fw2dFFT::Complex = DFT::Complex

Definition at line 40 of file Fw2dFFT.h.

using Fw2dFFT::Data = Real2dData<DataFloat>

Definition at line 36 of file Fw2dFFT.h.

using Fw2dFFT::DataFloat = float

Definition at line 34 of file Fw2dFFT.h.

using Fw2dFFT::DFT = FftwReal2dDftData<DftFloat>

Definition at line 37 of file Fw2dFFT.h.

using Fw2dFFT::DftFloat = double

Definition at line 35 of file Fw2dFFT.h.

typedef double Fw2dFFT::FftwComplex[2]

Definition at line 43 of file Fw2dFFT.h.

using Fw2dFFT::Index = DFT::Index

Definition at line 38 of file Fw2dFFT.h.

using Fw2dFFT::IndexArray = DFT::IndexArray

Definition at line 39 of file Fw2dFFT.h.

using Fw2dFFT::Plan = fftw_plan

Definition at line 41 of file Fw2dFFT.h.

using Fw2dFFT::PlanMap = std::map<IndexArray, Plan>

Definition at line 42 of file Fw2dFFT.h.

Constructor & Destructor Documentation

Fw2dFFT::Fw2dFFT	(	Index	ndatMax,
		Index	opt
	)

Definition at line 22 of file Fw2dFFT.cxx.

: m_ndatMax(ndatMax),
  m_flag(opt==2 ? FFTW_PATIENT : opt==1 ? FFTW_MEASURE : FFTW_ESTIMATE),
  m_inData(reinterpret_cast<DftFloat*>(fftw_malloc(m_ndatMax*sizeof(DftFloat)))),
  m_outData(reinterpret_cast<Complex*>(fftw_malloc(m_ndatMax*sizeof(DftFloat)))) { }

Fw2dFFT::~Fw2dFFT

(

)

Definition at line 30 of file Fw2dFFT.cxx.

                  {
  for ( auto& iplan : m_forwardPlans ) fftw_destroy_plan(iplan.second);
  for ( auto& iplan : m_backwardPlans ) fftw_destroy_plan(iplan.second);
  fftw_free(m_inData);
  fftw_free(m_outData);
}

Member Function Documentation

Fw2dFFT::Plan & Fw2dFFT::backwardPlan

(

const IndexArray &

nsams

)

Definition at line 77 of file Fw2dFFT.cxx.

                                                          {
  const string myname = "Fw2dFFT::backwardPlan: ";
  static Plan badplan;
  if ( checkDataSize(nsams) ) {
    cout << myname << "Data cannot be accomodated. Maximum data size is " << m_ndatMax << endl;
    return badplan;
  }
  if ( m_backwardPlans.count(nsams) == 0 ) {
    m_backwardPlans[nsams] = fftw_plan_dft_c2r_2d(nsams[0], nsams[1], fftwOutData(), m_inData, m_flag);
  }
  return m_backwardPlans[nsams];
}

Fw2dFFT::Index Fw2dFFT::checkDataSize

(

const IndexArray &

nsams

)

const

Definition at line 39 of file Fw2dFFT.cxx.

                                                                 {
  Index ndatIn = Real2dDftData<DataFloat>::dataSize(nsams);
  Index ndatOut = FftwReal2dDftData<DftFloat>::dftFloatDataSize(nsams);
  if ( ndatIn > m_ndatMax ) return 1;
  if ( ndatOut > m_ndatMax ) return 2;
  if ( ndatIn == 0 ) return 3;
  return 0;
}

int Fw2dFFT::fftBackward	(	const DFT &	dft,
		Data &	dat,
		Index	logLevel = 0
	)

Definition at line 123 of file Fw2dFFT.cxx.

                                                       {
  const string myname = "Fw2dFFT::fftBackward: ";
  if ( ! dft.isValid() ) return 1;
  auto nsams = dft.nSamples();
  if ( checkDataSize(nsams) ) {
    cout << myname << "Sample counts are too large. Maximum data size is " << m_ndatMax << endl;
    return 2;
  }
  Index ndatIn = Real2dDftData<DataFloat>::dataSize(nsams);
  Index ndatOut = FftwReal2dDftData<DftFloat>::dftFloatDataSize(nsams);
  if ( dft.normalization().isPower() ) {
    cout << myname << "ERROR: Power normalization is not (yet) supported." << endl;
    return 3;
  }
  dat.reset(nsams);
  if ( ! dat.isValid() ) {
    cout << myname << "ERROR: Unable to initialize output data container." << endl;
    return 4;
  }
  float fndat = ndatIn;
  float nfac = dft.normalization().isStandard()   ? 1.0/fndat       :
               dft.normalization().isConsistent() ? 1.0/sqrt(fndat) :
               dft.normalization().isBin()        ? 1.0             : 0.0;
  Plan& plan = backwardPlan(nsams);
  for ( Index idat=0; idat<ndatOut; ++idat ) floatOutData()[idat] = nfac*dft.floatData()[idat];
  fftw_execute(plan);
  dat.copyDataIn(m_inData);
  return 0;
}

int Fw2dFFT::fftForward	(	const Data &	dat,
		DFT &	dft,
		Index	logLevel = 0
	)

Definition at line 93 of file Fw2dFFT.cxx.

                                                      {
  const string myname = "Fw2dFFT::fftForward: ";
  if ( ! dat.isValid() ) return 1;
  auto nsams = dat.nSamples();
  dft.reset(nsams);
  if ( ! dft.isValid() ) return 2;
  if ( dft.normalization().isPower() ) {
    cout << myname << "ERROR: Power normalization is not (yet) supported." << endl;
    return 3;
  }
  Index ndatIn = dat.size();
  Index ndatOut = DFT::dftFloatDataSize(nsams);
  Plan& plan = forwardPlan(nsams);
  float fndat = ndatIn;
  float nfac = dft.normalization().isStandard()   ? 1.0             :
               dft.normalization().isConsistent() ? 1.0/sqrt(fndat) :
               dft.normalization().isBin()        ? 1.0/fndat       : 0.0;
  if ( dat.copyDataOut(m_inData) ) {
    cout << myname << "ERROR: Copy of input data failed." << endl;
    return 4;
  }
  fftw_execute(plan);
  dft.reset(nsams);
  for ( Index idat=0; idat<ndatOut; ++idat ) dft.floatData()[idat] = nfac*floatOutData()[idat];
  return 0;
}

FftwComplex* Fw2dFFT::fftwOutData ( )

inline

Definition at line 83 of file Fw2dFFT.h.

{ return reinterpret_cast<FftwComplex*>(m_outData); }

DftFloat* Fw2dFFT::floatOutData ( )

inline

Definition at line 86 of file Fw2dFFT.h.

{ return reinterpret_cast<DftFloat*>(m_outData); }

Fw2dFFT::Plan & Fw2dFFT::forwardPlan

(

const IndexArray &

nsams

)

Definition at line 62 of file Fw2dFFT.cxx.

                                                         {
  const string myname = "Fw2dFFT::forwardPlan: ";
  static Plan badplan;
  if ( checkDataSize(nsams) ) {
    cout << myname << "Data cannot be accomodated. Maximum data size is " << m_ndatMax << endl;
    return badplan;
  }
  if ( m_forwardPlans.count(nsams) == 0 ) {
    m_forwardPlans[nsams] = fftw_plan_dft_r2c_2d(nsams[0], nsams[1], m_inData, fftwOutData(), m_flag);
  }
  return m_forwardPlans[nsams];
}

bool Fw2dFFT::haveBackwardPlan

(

const IndexArray &

nsams

)

const

Definition at line 56 of file Fw2dFFT.cxx.

                                                            {
  return m_backwardPlans.count(nsams);
}

bool Fw2dFFT::haveForwardPlan

(

const IndexArray &

nsams

)

const

Definition at line 50 of file Fw2dFFT.cxx.

                                                           {
  return m_forwardPlans.count(nsams);
}

Member Data Documentation

PlanMap Fw2dFFT::m_backwardPlans

private

Definition at line 95 of file Fw2dFFT.h.

Index Fw2dFFT::m_flag

private

Definition at line 91 of file Fw2dFFT.h.

PlanMap Fw2dFFT::m_forwardPlans

private

Definition at line 94 of file Fw2dFFT.h.

DftFloat* Fw2dFFT::m_inData

private

Definition at line 92 of file Fw2dFFT.h.

Index Fw2dFFT::m_ndatMax

private

Definition at line 90 of file Fw2dFFT.h.

Complex* Fw2dFFT::m_outData

private

Definition at line 93 of file Fw2dFFT.h.

---

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

• dunecore/dunecore/DuneCommon/Utility/Fw2dFFT.h
• dunecore/dunecore/DuneCommon/Utility/Fw2dFFT.cxx