class RooFFTConvPdf: public RooAbsCachedPdf

 This class implement a generic one-dimensional numeric convolution of two p.d.f.
 and can convolve any two RooAbsPdfs. The class exploits the convolution theorem

       f(x) (*) g(x) --F--> f(k_i) * g(k_i)

 and calculate the convolution by calculate a Real->Complex FFT of both input p.d.fs
 multiplying the complex coefficients and performing the reverse Complex->Real FFT
 to get the result in the input space. This class using the ROOT FFT Interface to
 the (free) FFTW3 package (www.fftw.org) and requires that your ROOT installation is
 compiled with the --enable-fftw3 option (instructions for Linux follow)

 Note that the performance in terms of speed and stability of RooFFTConvPdf is
 vastly superior to that of RooNumConvPdf

 An important feature of FFT convolutions is that the observable is treated in a
 cyclical way. This is correct & desirable behavior for cyclical observables such as angles,
 but it may not be for other observables. The effect that is observed is that if
 p.d.f is zero at xMin and non-zero at xMax some spillover occurs and
 a rising tail may appear at xMin. This effect can be reduced or eliminated by
 introducing a buffer zone in the FFT calculation. If this feature is activated
 input the sampling array for the FFT calculation is extended in both directions
 and filled with repetitions of the lowest bin value and highest bin value
 respectively. The buffer bins are stripped again when the FFT output values
 are transferred to the p.d.f cache. The default buffer size is 10% of the
 observable domain size and can be changed with setBufferFraction() member function.

 This class is a caching p.d.f inheriting from RooAbsCachedPdf. If this p.d.f
 is evaluated for a particular value of x, the FFT calculate the values for the
 p.d.f at all points in observables space for the given choice of parameters,
 which are stored in the cache. Subsequent evaluations of RooFFTConvPdf with
 identical parameters will retrieve results from the cache. If one or more
 of the parameters change, the cache will be updated.

 The sampling density of the cache is controlled by the binning of the
 the convolution observable, which can be changed from RooRealVar::setBins(N)
 For good results N should be large (>1000). Additional interpolation of
 cache values may improve the result if courser binning are chosen. These can be
 set in the constructor or through the setInterpolationOrder() member function.
 For N>1000 interpolation will not substantially improve the performance.

 Additionial information on caching activities can be displayed by monitoring
 the message stream with topic "Caching" at the INFO level, i.e.
 do RooMsgService::instance().addStream(RooMsgService::INFO,Topic("Caching"))
 to see these message on stdout

 Multi-dimensional convolutions are not supported yet, but will be in the future
 as FFTW can calculate them



 Installing a copy of FFTW on Linux and compiling ROOT to use it

 1) Go to www.fftw.org and download the latest stable version (a .tar.gz file)

 If you have root access to your machine and want to make a system installation of FFTW

   2) Untar fftw-XXX.tar.gz in /tmp, cd into the untarred directory
       and type './configure' followed by 'make install'.
       This will install fftw in /usr/local/bin,lib etc...

   3) Start from a source installation of ROOT. If you now have a binary distribution,
      first download a source tar ball from root.cern.ch for your ROOT version and untar it.
      Run 'configure', following the instruction from 'configure --help' but be sure run 'configure'
      with additional flags '--enable-fftw3' and '--enable-roofit', then run 'make'


 If you do not have root access and want to make a private installation of FFTW

   2) Make a private install area for FFTW, e.g. /home/myself/fftw

   3) Untar fftw-XXX.tar.gz in /tmp, cd into the untarred directory
       and type './configure --prefix=/home/myself/fftw' followed by 'make install'.
       Substitute /home/myself/fftw with a directory of your choice. This
       procedure will install FFTW in the location designated by you

   4) Start from a source installation of ROOT. If you now have a binary distribution,
      first download a source tar ball from root.cern.ch for your ROOT version and untar it.
      Run 'configure', following the instruction from 'configure --help' but be sure run 'configure'
      with additional flags
       '--enable-fftw3',
       '--with-fftw3-incdir=/home/myself/fftw/include',
       '--width-fftw3-libdir=/home/myself/fftw/lib' and
       '--enable-roofit'
      Then run 'make'