library: libFFTW
#include "TFFTRealComplex.h"

TFFTRealComplex


class description - header file - source file
viewCVS header - viewCVS source

class TFFTRealComplex: public TVirtualFFT

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
public:
TFFTRealComplex()
TFFTRealComplex(const TFFTRealComplex&)
TFFTRealComplex(Int_t n, Bool_t inPlace)
TFFTRealComplex(Int_t ndim, Int_t* n, Bool_t inPlace)
virtual~TFFTRealComplex()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
virtual voidTObject::Delete(Option_t* option = "")
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() const
virtual TObject*TObject::DrawClone(Option_t* option = "") const
virtual voidTObject::Dump() const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
static TVirtualFFT*TVirtualFFT::FFT(Int_t ndim, Int_t* n, Option_t* option)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
static TVirtualFFT*TVirtualFFT::GetCurrentTransform()
static const char*TVirtualFFT::GetDefaultFFT()
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TObject::GetIconName() const
virtual Int_t*GetN() const
virtual const char*TObject::GetName() const
virtual Int_tGetNdim() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
virtual voidGetPointComplex(Int_t ipoint, Double_t& re, Double_t& im, Bool_t fromInput = kFALSE) const
virtual voidGetPointComplex(const Int_t* ipoint, Double_t& re, Double_t& im, Bool_t fromInput = kFALSE) const
virtual Double_tGetPointReal(Int_t ipoint, Bool_t fromInput = kFALSE) const
virtual Double_tGetPointReal(const Int_t* ipoint, Bool_t fromInput = kFALSE) const
virtual voidGetPoints(Double_t* data, Bool_t fromInput = kFALSE) const
virtual voidGetPointsComplex(Double_t* data, Bool_t fromInput = kFALSE) const
virtual voidGetPointsComplex(Double_t* re, Double_t* im, Bool_t fromInput = kFALSE) const
virtual Double_t*GetPointsReal(Bool_t fromInput = kFALSE) const
virtual Int_tGetSign() const
virtual Int_tGetSize() const
virtual const char*TObject::GetTitle() const
virtual Option_t*GetTransformFlag() const
virtual Option_t*GetType() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidInit(Option_t* flags, Int_t, const Int_t*)
virtual voidTObject::Inspect() const
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
virtual Bool_tIsInplace() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
TFFTRealComplex&operator=(const TFFTRealComplex&)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTObject::Print(Option_t* option = "") const
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") const
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
static voidTVirtualFFT::SetDefaultFFT(const char* name = "")
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidSetPoint(Int_t ipoint, Double_t re, Double_t im = 0)
virtual voidSetPoint(const Int_t* ipoint, Double_t re, Double_t im = 0)
virtual voidSetPointComplex(Int_t ipoint, TComplex& c)
virtual voidSetPoints(const Double_t* data)
virtual voidSetPointsComplex(const Double_t* re, const Double_t* im)
static voidTVirtualFFT::SetTransform(TVirtualFFT* fft)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
static TVirtualFFT*TVirtualFFT::SineCosine(Int_t ndim, Int_t* n, Int_t* r2rkind, Option_t* option)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTransform()
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0) const
protected:
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()
UInt_tMapFlag(Option_t* flag)

Data Members

public:
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
void*fIninput array
void*fOutoutput array
void*fPlanfftw plan (the plan how to compute the transform)
Int_tfNdimnumber of dimensions
Int_tfTotalSizetotal size of the transform
Int_t*fNtransform sizes in each dimension
Option_t*fFlagstransform flags
static TVirtualFFT*TVirtualFFT::fgFFTcurrent transformer
static TStringTVirtualFFT::fgDefaultdefault transformer

Class Description

                                                                      
 TFFTRealComplex                                                       
                                                                      
 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 a real input/complex output discrete Fourier transform in 1 or more
 dimensions. However, only out-of-place transforms are now supported for transforms
 in more than 1 dimension. For detailed information about the computed transforms,
 please refer to the FFTW manual

 How to use it:
 1) Create an instance of TFFTRealComplex - 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 (see function
    comments for possible kind parameters)
 3) Set the data (via SetPoints()or SetPoint() functions)
 4) Run the Transform() function
 5) Get the output (via GetPoints() or GetPoint() 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
 


TFFTRealComplex()
default
TFFTRealComplex(Int_t n, Bool_t inPlace)
For 1d transforms
Allocates memory for the input array, and, if inPlace = kFALSE, for the output array
TFFTRealComplex(Int_t ndim, Int_t *n, Bool_t inPlace)
For ndim-dimensional transforms
Second argurment contains sizes of the transform in each dimension
~TFFTRealComplex()
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 /*sign*/, const Int_t* /*kind*/)
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 Transform()
Computes the transform, specified in Init() function
void GetPoints(Double_t *data, Bool_t fromInput)
Fills the array data with the computed transform.
Only (roughly) a half of the transform is copied (exactly the output of FFTW),
the rest being Hermitian symmetric with the first half
Double_t GetPointReal(Int_t ipoint, Bool_t fromInput)
Returns the real part of the point #ipoint from the output or the point #ipoint
from the input
Double_t GetPointReal(const Int_t *ipoint, Bool_t fromInput)
Returns the real part of the point #ipoint from the output or the point #ipoint
from the input
void GetPointComplex(Int_t ipoint, Double_t &re, Double_t &im, Bool_t fromInput)
Returns the point #ipoint.
For 1d, if ipoint > fN/2+1 (the point is in the Hermitian symmetric part), it is still
returned. For >1d, only the first (roughly)half of points can be returned
For 2d, see function GetPointComplex(Int_t *ipoint,...)
void GetPointComplex(const Int_t *ipoint, Double_t &re, Double_t &im, Bool_t fromInput)
For multidimensional transforms. Returns the point #ipoint.
In case of transforms of more than 2 dimensions,
only points from the first (roughly)half are returned, the rest being Hermitian symmetric
Double_t* GetPointsReal(Bool_t fromInput)
Returns the input array// 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.
void GetPointsComplex(Double_t *re, Double_t *im, Bool_t fromInput)
Fills the argument arrays with the real and imaginary parts of the computed transform.
Only (roughly) a half of the transform is copied, the rest being Hermitian
symmetric with the first half
void GetPointsComplex(Double_t *data, Bool_t fromInput)
Fills the argument arrays with the real and imaginary parts of the computed transform.
Only (roughly) a half of the transform is copied, the rest being Hermitian
symmetric with the first half
void SetPoint(Int_t ipoint, Double_t re, Double_t /*im*/)
Set the point #ipoint
void SetPoint(const Int_t *ipoint, Double_t re, Double_t /*im*/)
For multidimensional transforms. Set the point #ipoint
void SetPoints(const Double_t *data)
Set all input points
void SetPointComplex(Int_t ipoint, TComplex &c)
Sets the point #ipoint (only the real part of the argument is taken)
void SetPointsComplex(const Double_t *re, const Double_t* /*im*/)
Set all points. Only the real array is used
UInt_t MapFlag(Option_t *flag)
allowed options:
"ES"
"M"
"P"
"EX"
TFFTRealComplex()
Int_t GetSize()
{return fTotalSize;}
Int_t * GetN()
{return fN;}
Int_t GetNdim()
{return fNdim;}
Option_t * GetType()
{return "R2C";}
Int_t GetSign()
{return 1;}
Option_t * GetTransformFlag()
{return fFlags;}
Bool_t IsInplace()
{if (fOut) return kTRUE; else return kFALSE;}

Author: Anna Kreshuk 07/4/2006
Last update: root/fft:$Name: $:$Id: TFFTRealComplex.cxx,v 1.4 2006/10/27 16:21:11 brun Exp $
Copyright (C) 1995-2006, Rene Brun and Fons Rademakers. *


ROOT page - Class index - Class Hierarchy - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.