class TFFTComplexReal: public TVirtualFFT
TFFTComplexReal One of the interface classes to the FFTW package, can be used directly or via the TVirtualFFT class. Only the basic interface of FFTW is implemented. Computes the inverse of the real-to-complex transforms (class TFFTRealComplex) taking complex input (storing the non-redundant half of a logically Hermitian array) to real output (see FFTW manual for more details) How to use it: 1) Create an instance of TFFTComplexReal - this will allocate input and output arrays (unless an in-place transform is specified) 2) Run the Init() function with the desired flags and settings 3) Set the data (via SetPoints(), SetPoint() or SetPointComplex() functions) 4) Run the Transform() function 5) Get the output (via GetPoints(), GetPoint() or GetPointReal() functions) 6) Repeat steps 3)-5) as needed For a transform of the same size, but with different flags, rerun the Init() function and continue with steps 3)-5) NOTE: 1) running Init() function will overwrite the input array! Don't set any data before running the Init() function 2) FFTW computes unnormalized transform, so doing a transform followed by its inverse will lead to the original array scaled by the transform size
Function Members (Methods)
public:
protected:
| virtual void | TObject::DoError(int level, const char* location, const char* fmt, va_list va) const |
| void | TObject::MakeZombie() |
| UInt_t | MapFlag(Option_t* flag) |
Data Members
private:
| enum TObject::EStatusBits { | kCanDelete | |
| kMustCleanup | ||
| kObjInCanvas | ||
| kIsReferenced | ||
| kHasUUID | ||
| kCannotPick | ||
| kNoContextMenu | ||
| kInvalidObject | ||
| }; | ||
| enum TObject::[unnamed] { | kIsOnHeap | |
| kNotDeleted | ||
| kZombie | ||
| kBitMask | ||
| kSingleKey | ||
| kOverwrite | ||
| kWriteDelete | ||
| }; |
protected:
| Option_t* | fFlags | transform flags |
| void* | fIn | input array |
| Int_t* | fN | transform sizes in each dimension |
| Int_t | fNdim | number of dimensions |
| void* | fOut | output array |
| void* | fPlan | fftw plan (the plan how to compute the transform) |
| Int_t | fTotalSize | total size of the transform |
| static TString | TVirtualFFT::fgDefault | default transformer |
| static TVirtualFFT* | TVirtualFFT::fgFFT | current transformer |
Class Charts
Function documentation
TFFTComplexReal(Int_t n, Bool_t inPlace)
For 1d transforms Allocates memory for the input array, and, if inPlace = kFALSE, for the output array
TFFTComplexReal(Int_t ndim, Int_t* n, Bool_t inPlace)
For ndim-dimensional transforms Second argurment contains sizes of the transform in each dimension
~TFFTComplexReal()
Destroys the data arrays and the plan. However, some plan information stays around until the root session is over, and is reused if other plans of the same size are created
void Init(Option_t* flags, Int_t , const Int_t* )
Creates the fftw-plan
NOTE: input and output arrays are overwritten during initialisation,
so don't set any points, before running this function!!!!!
Arguments sign and kind are dummy and not need to be specified
Possible flag_options:
"ES" (from "estimate") - no time in preparing the transform, but probably sub-optimal
performanc
"M" (from "measure") - some time spend in finding the optimal way to do the transform
"P" (from "patient") - more time spend in finding the optimal way to do the transform
"EX" (from "exhaustive") - the most optimal way is found
This option should be chosen depending on how many transforms of the same size and
type are going to be done. Planning is only done once, for the first transform of this
size and type.
void GetPoints(Double_t* data, Bool_t fromInput = kFALSE) const
Fills the argument array with the computed transform
Double_t GetPointReal(const Int_t *ipoint, Bool_t fromInput)
For multidimensional transforms. Returns the point #ipoint
void GetPointComplex(Int_t ipoint, Double_t &re, Double_t &im, Bool_t fromInput)
void GetPointComplex(const Int_t *ipoint, Double_t &re, Double_t &im, Bool_t fromInput)
For multidimensional transforms. Returns the point #ipoint
void GetPointsComplex(Double_t* re, Double_t* im, Bool_t fromInput = kFALSE) const
Fills the argument array with the computed transform
void GetPointsComplex(Double_t* data, Bool_t fromInput = kFALSE) const
void SetPoint(Int_t ipoint, Double_t re, Double_t im)
since the input must be complex-Hermitian, if the ipoint > n/2, the according point before n/2 is set to (re, -im)
void SetPoint(const Int_t *ipoint, Double_t re, Double_t im)
Set the point #ipoint. Since the input is Hermitian, only the first (roughly)half of the points have to be set.
void SetPointComplex(Int_t ipoint, TComplex& c)
since the input must be complex-Hermitian, if the ipoint > n/2, the according point before n/2 is set to (re, -im)
void SetPoints(const Double_t* data)
set all points. the values are copied. points should be ordered as follows: [re_0, im_0, re_1, im_1, ..., re_n, im_n)
void SetPointsComplex(const Double_t* re, const Double_t* im)
Set all points. The values are copied.
UInt_t MapFlag(Option_t* flag)
allowed options: "ES" - FFTW_ESTIMATE "M" - FFTW_MEASURE "P" - FFTW_PATIENT "EX" - FFTW_EXHAUSTIVE