GridFT.h

Classes

GridFT -- An FTMachine for Gridded Fourier transforms (full description)

class GridFT : public FTMachine

Interface

Public Members
GridFT(Long cachesize, Int tilesize, String convType="SF", Float padding=1.0, Bool usezero=True)
GridFT(Long cachesize, Int tilesize, String convType, MPosition mLocation, Float padding=1.0, Bool usezero=True)
GridFT(Long cachesize, Int tilesize, String convType, MDirection mTangent, Float padding=1.0, Bool usezero=True)
GridFT(Long cachesize, Int tilesize, String convType, MPosition mLocation, MDirection mTangent, Float passing=1.0, Bool usezero=True)
GridFT(const RecordInterface& stateRec)
GridFT(const GridFT &other)
GridFT &operator=(const GridFT &other)
~GridFT()
void initializeToVis(ImageInterface<Complex>& image, const Complex& vb)
void initializeToVis(ImageInterface<Complex>& image, const Complex& vb, VisBuffer<Complex>& griddedVis, Array<Double>& uvscale, Vector* &uvwMachine)
void finalizeToVis()
void initializeToSky(ImageInterface<Complex>& image, Complex<Float>& weight, const Matrix& vb)
void initializeToSky(ImageInterface<Complex>& image, Complex<Float>& weight, const Matrix& vb, VisBuffer<Double>& uvscale, Vector* & uvwmachine)
void finalizeToSky()
void finalizeToSky(ImageInterface<Complex>& iimage)
void get(VisBuffer& vb, Int row=-1)
virtual void get(VisBuffer& vb, Cube<Complex>& degrid, Array<Complex>& griddedVis, Array<Double>& scale, Vector *uvwMachine, Int row=-1)
void put(const VisBuffer& vb, Int row=-1, Bool dopsf=False, FTMachine::Type type=FTMachine::OBSERVED)
void put(const VisBuffer& vb, TempImage<Complex>& iimage, Vector<Double>& scale, Int row=-1, Vector *uvwMachine=0, Bool dopsf=False)
void makeImage(FTMachine::Type type, VisSet& vs, ImageInterface<Complex>& image, Complex<Float>& weight)
ImageInterface<Complex>& getImage(Complex<Float>&, Bool normalize=True)
void getWeightImage(ImageInterface<Float>&, Matrix<Float>&)
virtual Bool toRecord(String& error, RecordInterface& outRec, Bool withImage=False)
virtual Bool fromRecord(String& error, const RecordInterface& inRec)
virtual Bool isFourier()
virtual void setNoPadding(Bool nopad)
virtual String name()
Protected Members
Array<Complex>* getDataPointer(const IPosition&, Bool)
void ok()
void init()
Bool recordOnGrid(const VisBuffer& vb, Int rownr) const

Description

Prerequisite

Etymology

FTMachine is a Machine for Fourier Transforms. GridFT does Grid-based Fourier transforms.

Synopsis

The SkyEquation needs to be able to perform Fourier transforms on visibility data. GridFT allows efficient Fourier Transform processing using a VisBuffer which encapsulates a chunk of visibility (typically all baselines for one time) together with all the information needed for processing (e.g. UVW coordinates).

Gridding and degridding in GridFT are performed using a novel sort-less algorithm. In this approach, the gridded plane is divided into small patches, a cache of which is maintained in memory using a general-purpose LatticeCache class. As the (time-sorted) visibility data move around slowly in the Fourier plane, patches are swapped in and out as necessary. Thus, optimally, one would keep at least one patch per baseline.

A grid cache is defined on construction. If the gridded uv plane is smaller than this, it is kept entirely in memory and all gridding and degridding is done entirely in memory. Otherwise a cache of tiles is kept an paged in and out as necessary. Optimally the cache should be big enough to hold all polarizations and frequencies for all baselines. The paging rate will then be small. As the cache size is reduced below this critical value, paging increases. The algorithm will work for only one patch but it will be very slow!

This scheme works well for arrays having a moderate number of antennas since the saving in space goes as the ratio of baselines to image size. For the ATCA, VLBA and WSRT, this ratio is quite favorable. For the VLA, one requires images of greater than about 200 pixels on a side to make it worthwhile.

The FFT step is done plane by plane for images having less than 1024 * 1024 pixels on each plane, and line by line otherwise.

The gridding and degridding steps are implemented in Fortran for speed. In gridding, the visibilities are added onto the grid points in the neighborhood using a weighting function. In degridding, the value is derived by a weight summ of the same points, using the same weighting function.

Example

See the example for SkyModel.

Motivation

Define an interface to allow efficient processing of chunks of visibility data

To Do