AWProjectFT.h

Go to the documentation of this file.
00001 //# AWProjectFT.h: Definition for AWProjectFT
00002 //# Copyright (C) 1996,1997,1998,1999,2000,2002
00003 //# Associated Universities, Inc. Washington DC, USA.
00004 //#
00005 //# This library is free software; you can redistribute it and/or modify it
00006 //# under the terms of the GNU Library General Public License as published by
00007 //# the Free Software Foundation; either version 2 of the License, or (at your
00008 //# option) any later version.
00009 //#
00010 //# This library is distributed in the hope that it will be useful, but WITHOUT
00011 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00012 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
00013 //# License for more details.
00014 //#
00015 //# You should have received a copy of the GNU Library General Public License
00016 //# along with this library; if not, write to the Free Software Foundation,
00017 //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
00018 //#
00019 //# Correspondence concerning AIPS++ should be adressed as follows:
00020 //#        Internet email: aips2-request@nrao.edu.
00021 //#        Postal address: AIPS++ Project Office
00022 //#                        National Radio Astronomy Observatory
00023 //#                        520 Edgemont Road
00024 //#                        Charlottesville, VA 22903-2475 USA
00025 //#
00026 //#
00027 //# $Id$
00028 
00029 #ifndef SYNTHESIS_TRANSFORM2_AWPROJECTFT_H
00030 #define SYNTHESIS_TRANSFORM2_AWPROJECTFT_H
00031 
00032 #include <synthesis/TransformMachines2/VLACalcIlluminationConvFunc.h>
00033 #include <synthesis/TransformMachines2/VLAIlluminationConvFunc.h>
00034 #include <synthesis/TransformMachines2/AWVisResampler.h>
00035 //#include <synthesis/MeasurementComponents/ConvolutionFunction.h>
00036 #include <synthesis/TransformMachines2/EVLAConvFunc.h>
00037 #include <synthesis/MeasurementComponents/SolvableVisCal.h>
00038 #include <synthesis/TransformMachines2/VPSkyJones.h>
00039 #include <synthesis/TransformMachines2/FTMachine.h>
00040 #include <synthesis/TransformMachines2/PolOuterProduct.h>
00041 //#include <synthesis/MeasurementComponents/CFCache.h>
00042 #include <synthesis/TransformMachines2/Utils.h>
00043 
00044 #include <scimath/Mathematics/FFTServer.h>
00045 //#include <msvis/MSVis/VisBuffer.h>
00046 
00047 #include <casa/Containers/Block.h>
00048 #include <casa/Arrays/Array.h>
00049 #include <casa/Arrays/Vector.h>
00050 #include <casa/Arrays/Matrix.h>
00051 
00052 #include <scimath/Mathematics/ConvolveGridder.h>
00053 #include <lattices/Lattices/LatticeCache.h>
00054 #include <lattices/Lattices/ArrayLattice.h>
00055 #include <ms/MeasurementSets/MSColumns.h>
00056 #include <measures/Measures/Measure.h>
00057 #include <measures/Measures/MDirection.h>
00058 #include <measures/Measures/MPosition.h>
00059 #include <images/Images/ImageInterface.h>
00060 #include <coordinates/Coordinates/DirectionCoordinate.h>
00061 
00062 #include <synthesis/TransformMachines2/AWConvFunc.h>
00063 #include <synthesis/TransformMachines2/AWConvFuncEPJones.h>
00064 #include <synthesis/TransformMachines2/ATerm.h>
00065 
00066 #include <casa/OS/Timer.h>
00067 
00068 namespace casa { //# NAMESPACE CASA - BEGIN
00069   
00070   // namespace vi
00071   // { 
00072   //   class VisBuffer2;
00073   //   class VisibilityIterator2;
00074   // }
00075   // <summary>  An FTMachine for Gridded Fourier transforms including effects of primary beam and pointing offsets and the w-term</summary>
00076   
00077   // <use visibility=export>
00078   
00079   // <reviewed reviewer="" date="" tests="" demos="">
00080   
00081   // <prerequisite>
00082   //   <li> <linkto class=FTMachine>FTMachine</linkto> module
00083   //   <li> <linkto class=SkyEquation>SkyEquation</linkto> module
00084   //   <li> <linkto class=VisBuffer>VisBuffer</linkto> module
00085   //   <li> <linto class=EPJones>EPJones</linkto> module
00086   // </prerequisite>
00087   //
00088   // <etymology> 
00089   // FTMachine is a Machine for Fourier Transforms. Like
00090   // WProjectFT, AWProjectFT does Grid-based Fourier transforms but
00091   // also includes the effects of primary beam and antenna pointing
00092   // offsets. 
00093   // </etymology>
00094   //
00095   // <synopsis> 
00096   //
00097   // The <linkto class=SkyEquation>SkyEquation</linkto> needs to be
00098   // able to perform Fourier transforms on visibility
00099   // data. AWProjectFT allows efficient handling of direction
00100   // dependent effects due to the primary beam and antenna pointing
00101   // offsets using a <linkto class=VisBuffer>VisBuffer</linkto> which
00102   // encapsulates a chunk of visibility (typically all baselines for
00103   // one time) together with all the information needed for processing
00104   // (e.g. UVW coordinates).
00105   //
00106   // Using this FTMachine, errors due antenna pointing offsets can be
00107   // corrected during deconvolution.  One form of antenna pointing
00108   // error which is known a-priori is the VLA polarization squint
00109   // (about 6% of the Primary beam width at any frequency).  For
00110   // Stokes imaging, using this FTMachine, the VLA polarization squint
00111   // and beam polarization can also be corrected.  Also since the
00112   // effects of antenna pointing errors is strongest in the range of
00113   // 1-2GHz band (where the sky is not quite empty while the beams are
00114   // not too large either), this FTMachine can also be setup to
00115   // correct for the w-term.
00116   //
00117   // Switches are provided in the get() method to compute the
00118   // derivatives with respect to the parameters of the primary beam
00119   // (only pointing offsets for now).  This is used in the pointing
00120   // offset solver.
00121   //
00122   // See the documentation of other FTMachines for details about the
00123   // design of the FTMachines in general.
00124   //
00125   // </synopsis> 
00126   //
00127   // <example>
00128   // See the example for <linkto class=SkyModel>SkyModel</linkto>.
00129   // </example>
00130   //
00131   // <motivation>
00132   //
00133   // Encapsulate the correction of direction dependent effects via
00134   // visibility plane convolutions with a potentially different
00135   // convolution function for each baseline.
00136   //
00137   // </motivation>
00138   //
00139   // <todo asof="2005/07/21">
00140   //
00141   // <ul> Include the antenna based complex gain term as well since
00142   // that can interfere with the effects of pointing offsets.  
00143   //
00144   // <ul> Factor out the actual convolution functions as a separate
00145   // class making FTMachines for various direction dependent effects
00146   // generic.
00147   //
00148   // </todo>
00149   
00150   //  class EPJones;
00151   class SolvableVisJones;
00152   namespace refim{
00153   class AWProjectFT : public FTMachine {
00154   public:
00155     static ATerm* createTelescopeATerm(const String& telescopeName, 
00156                                        const Bool& isATermOn);
00157     static CountedPtr<ConvolutionFunction> makeCFObject(const String& telescopeName,
00158                                                         const Bool aTermOn,
00159                                                         const Bool psTermOn,
00160                                                         const Bool wTermOn,
00161                                                         const Bool mTermOn,
00162                                                         const Bool wBAWP,
00163                                                         const Int cfBufferSize=-1,
00164                                                         const Int cfOverSampling=-1);
00165     AWProjectFT();
00166     
00167     // Constructor: cachesize is the size of the cache in words
00168     // (e.g. a few million is a good number), tilesize is the
00169     // size of the tile used in gridding (cannot be less than
00170     // 12, 16 works in most cases). 
00171     // <group>
00172     AWProjectFT(Int nFacets, Long cachesize, 
00173                 CountedPtr<CFCache>& cfcache,
00174                 CountedPtr<ConvolutionFunction>& cf,
00175                 CountedPtr<VisibilityResamplerBase>& visResampler,
00176                 Bool applyPointingOffset=True,
00177                 Bool doPBCorr=True,
00178                 Int tilesize=16, 
00179                 Float pbLimit=5e-4,
00180                 Bool usezero=False,
00181                 Bool conjBeams_p=True,
00182                 Bool doublePrecGrid=False,
00183                 PolOuterProduct::MuellerType muellerType=PolOuterProduct::FULL);
00184     // </group>
00185     
00186     // Construct from a Record containing the AWProjectFT state
00187     AWProjectFT(const RecordInterface& stateRec);
00188     
00189     // Copy constructor
00190     AWProjectFT(const AWProjectFT &other);
00191     
00192     // Assignment operator
00193     AWProjectFT &operator=(const AWProjectFT &other);
00194     
00195     ~AWProjectFT();
00196     
00197     //   void setEPJones(EPJones* ep_j) {epJ = ep_j;}
00198     void setEPJones(SolvableVisJones* ep_j) {epJ_p = ep_j;}
00199     
00200     virtual void setDOPBCorrection(Bool doit=True) {doPBCorrection=doit;};
00201     virtual Bool getDOPBCorrection() {return doPBCorrection;};
00202     virtual void setConjBeams(Bool useit=True) {conjBeams_p=useit;};
00203     virtual Bool getConjBeams() {return conjBeams_p;};
00204 
00205     virtual Float getPBLimit() {return pbLimit_p;};
00206     // Initialize transform to Visibility plane using the image
00207     // as a template. The image is loaded and Fourier transformed.
00208     
00209     void setObservatoryLocation(const MPosition& mLocation) {mLocation_p=mLocation;};
00210     
00211     // Vectorized version of initializeToVis.  Required since
00212     // MultiTermFTM needs vectorized version. And this is implemented
00213     // in FTMachine (the baseclass).  And one relies on static_cast in
00214     // Imager::createFTMachine() (or is it in CSE?) to cast the
00215     // pointer to specific types such that this methods gets called
00216     // when the FTMachine pointer is of type AWProjectFT.
00217     virtual void initializeToVis(Block<CountedPtr<ImageInterface<Complex> > > & compImageVec,
00218                                  PtrBlock<SubImage<Float> *> & modelImageVec, 
00219                                  PtrBlock<SubImage<Float> *>& weightImageVec, 
00220                                  PtrBlock<SubImage<Float> *>& fluxScaleVec, 
00221                                  Block<Matrix<Float> >& weightsVec,
00222                                  const vi::VisBuffer2& vb);
00223 
00224     virtual void initializeToVis(ImageInterface<Complex>& image,
00225                                  const vi::VisBuffer2& vb);
00226     // This version returns the gridded vis...should be used in conjunction 
00227     // with the version of 'get' that needs the gridded visdata 
00228     virtual void initializeToVis(ImageInterface<Complex>& image,
00229                                  const vi::VisBuffer2& vb, Array<Complex>& griddedVis,
00230                                  Vector<Double>& uvscale);
00231     
00232     // Finalize transform to Visibility plane: flushes the image
00233     // cache and shows statistics if it is being used.
00234     virtual void finalizeToVis();
00235     
00236     // Initialize transform to Sky plane: initializes the image
00237     virtual void initializeToSky(ImageInterface<Complex>& image,  Matrix<Float>& weight,
00238                                  const vi::VisBuffer2& vb);
00239     
00240     // Finalize transform to Sky plane: flushes the image
00241     // cache and shows statistics if it is being used. DOES NOT
00242     // DO THE FINAL TRANSFORM!
00243     virtual void finalizeToSky();
00244     
00245     virtual void initVisBuffer(vi::VisBuffer2& vb, Type whichVBColumn);
00246     void initVisBuffer(vi::VisBuffer2& vb, Type whichVBColumn, Int row);
00247 
00248     // Get actual coherence from grid by degridding
00249     void get(vi::VisBuffer2& vb, Int row=-1);
00250     
00251     // Get the coherence from grid return it in the degrid 
00252     // is used especially when scratch columns are not 
00253     // present in ms.
00254     void get(vi::VisBuffer2& vb, Cube<Complex>& degrid, 
00255              Array<Complex>& griddedVis, Vector<Double>& scale, 
00256              Int row=-1);
00257     
00258     void get(vi::VisBuffer2& vb, Cube<Float>& pointingOffsets, Int row=-1,
00259              FTMachine::Type whichVBColumn=FTMachine::MODEL,Int Conj=0)
00260     {
00261       get(vb,vb,vb,pointingOffsets,row,whichVBColumn,whichVBColumn,Conj,0);
00262     }
00263     
00264     void get(vi::VisBuffer2& vb, vi::VisBuffer2& gradAzVB,vi::VisBuffer2& gradElVB,
00265              Cube<Float>& pointingOffsets,Int row=-1,
00266              Type whichVBColumn=FTMachine::MODEL,
00267              Type whichGradVBColumn=FTMachine::MODEL,
00268              Int Conj=0, Int doGrad=1) ;
00269     void nget(vi::VisBuffer2& vb,
00270             // These offsets should be appropriate for the VB
00271             Array<Float>& l_off, Array<Float>& m_off,
00272             Cube<Complex>& Mout,
00273             Cube<Complex>& dMout1,
00274             Cube<Complex>& dMout2,
00275             Int Conj=0, Int doGrad=1);
00276     // Get the coherence from grid return it in the degrid 
00277     // is used especially when scratch columns are not 
00278     // present in ms.
00279     void get(vi::VisBuffer2& vb, Cube<Complex>& degrid, 
00280              Array<Complex>& griddedVis, Vector<Double>& scale, 
00281              Cube<Float>& pointingOffsets,Int row=-1);
00282     
00283     
00284     // Put coherence to grid by gridding.
00285     void put(const vi::VisBuffer2&,
00286              TempImage<Complex>&, Vector<Double>&, int,
00287              UVWMachine*, Bool) 
00288     {
00289       //    throw(AipsError("AWProjectFT::put is not implemented"));
00290     }
00291     void put(const vi::VisBuffer2& vb, Int row=-1, Bool dopsf=False,
00292              FTMachine::Type type=FTMachine::OBSERVED);
00293     
00294     // Make the entire image using a ROVisIter
00295     // virtual void makeImage(FTMachine::Type,
00296     //                     ROVisibilityIterator&,
00297     //                     ImageInterface<Complex>&,
00298     //                     Matrix<Float>&) {};
00299 
00300     // Make the entire image
00301     // void makeImage(FTMachine::Type type,
00302     //             VisSet& vs,
00303     //             ImageInterface<Complex>& image,
00304     //             Matrix<Float>& weight);
00305     
00306     // Get the final image: do the Fourier transform and
00307     // grid-correct, then optionally normalize by the summed weights
00308     virtual ImageInterface<Complex>& getImage(Matrix<Float>&, Bool normalize=True);
00309 
00310     // Get the final weights image
00311     void getWeightImage(ImageInterface<Float>&, Matrix<Float>&);
00312     
00313     // Save and restore the AWProjectFT to and from a record
00314     Bool toRecord(RecordInterface& outRec,  Bool withImage=False);
00315     Bool fromRecord(const RecordInterface& inRec);
00316     
00317     // Can this FTMachine be represented by Fourier convolutions?
00318     Bool isFourier() {return True;}
00319     
00320     //  Bool changed(const VisBuffer& vb) {return vpSJ->changed(vb,1);};
00321     //    Bool changed(const VisBuffer& vb) {return False;}
00322     
00323     virtual Int findPointingOffsets(const vi::VisBuffer2&, Array<Float>&, Array<Float>&,
00324                                     Bool Evaluate=True);
00325     virtual Int findPointingOffsets(const vi::VisBuffer2&, Cube<Float>&,
00326                                     Array<Float>&, Array<Float>&,
00327                                     Bool Evaluate=True);
00328     virtual Double getVBPA(const vi::VisBuffer2& vb) 
00329     {
00330       // if (!rotateApertureOTP_p) return currentCFPA;
00331       // else return getPA(vb);
00332       return getPA(vb);
00333     };
00334     MDirection::Convert makeCoordinateMachine(const vi::VisBuffer2&,
00335                                               const MDirection::Types&,
00336                                               const MDirection::Types&,
00337                                               MEpoch& last);
00338     //
00339     // Make a sensitivity image (sensitivityImage), given the gridded
00340     // weights (wtImage).  These are related to each other by a
00341     // Fourier transform and normalization by the sum-of-weights
00342     // (sumWt) and normalization by the product of the 2D FFT size
00343     // along each axis.  If doFFTNorm=False, normalization by the FFT
00344     // size is not done.  If sumWt is not provided, normalization by
00345     // the sum of weights is also not done.
00346     //
00347     virtual void makeSensitivityImage(Lattice<Complex>&,// wtImage,
00348                                       ImageInterface<Float>&,// sensitivityImage,
00349                                       const Matrix<Float>&,// sumWt=Matrix<Float>(),
00350                                       const Bool& ) {};
00351     virtual void makeSensitivityImage(const vi::VisBuffer2& vb, 
00352                                       const ImageInterface<Complex>& imageTemplate,
00353                                       ImageInterface<Float>& sensitivityImage);
00354 
00355     //
00356     // Given the sky image (Fourier transform of the visibilities),
00357     // sum of weights and the sensitivity image, this method replaces
00358     // the skyImage with the normalized image of the sky.
00359     //
00360     // These are now implement in the FTMachine base class.  
00361     //
00362     // These can't be left here since now the design depends on
00363     // getting the correct version called due to static type casting
00364     // of FTM pointer and not on inheretance and and specialization
00365     // via overloading.
00366 
00367     // virtual void normalizeImage(Lattice<Complex>& skyImage,
00368     //                          const Matrix<Double>& sumOfWts,
00369     //                          Lattice<Float>& sensitivityImage,
00370     //                          Bool fftNorm=True);
00371     // virtual void normalizeImage(Lattice<Complex>& skyImage,
00372     //                          const Matrix<Double>& sumOfWts,
00373     //                          Lattice<Float>& sensitivityImage,
00374     //                          Lattice<Complex>& sensitivitySqImage,
00375     //                          Bool fftNorm=True);
00376     
00377     virtual ImageInterface<Float>& getSensitivityImage() {return *avgPB_p;}
00378     virtual Matrix<Double>& getSumOfWeights() {return sumWeight;};
00379     virtual Matrix<Double>& getSumOfCFWeights() {return sumCFWeight;};
00380 
00381     void makeConjPolMap(const vi::VisBuffer2& vb, const Vector<Int> cfPolMap, 
00382                         Vector<Int>& conjPolMap);
00383     //    Vector<Int> makeConjPolMap(const VisBuffer& vb);
00384     void makeCFPolMap(const vi::VisBuffer2& vb, const Vector<Int>& cfstokes, 
00385                       Vector<Int>& polM);
00386     //    void reset() {vpSJ->reset();}
00387     void reset() {paChangeDetector.reset();}
00388 
00389     void setPAIncrement(const Quantity &computePAIncr, const Quantity &rotateOTFPAIncr);
00390 
00391     Vector<Int>& getPolMap() {return polMap;};
00392     virtual String name() const { return "AWProjectFT";};
00393     virtual Bool verifyAvgPB(ImageInterface<Float>& pb, ImageInterface<Float>& sky)
00394     {return verifyShapes(pb.shape(),sky.shape());}
00395 
00396     virtual Bool verifyAvgPB(ImageInterface<Float>& pb, ImageInterface<Complex>& sky)
00397     {return verifyShapes(pb.shape(),sky.shape());}
00398 
00399     virtual Bool verifyShapes(IPosition shape0, IPosition shape1);
00400 
00401     inline virtual Float pbFunc(const Float& a, const Float& limit) 
00402     {Float tt=sqrt(a);return  (abs(tt) >= limit)?tt:1.0;};
00403     // {if (abs(a) >= limit) return (a);else return 1.0;};
00404 
00405     inline virtual Complex pbFunc(const Complex& a, const Float& limit) 
00406     {if (abs(a)>=limit) return (a); else return Complex(1.0,0.0);};
00407 
00408     virtual void setMiscInfo(const Int qualifier)
00409     {
00410       sensitivityPatternQualifier_p=qualifier;
00411       sensitivityPatternQualifierStr_p = ".tt"+String::toString(sensitivityPatternQualifier_p);
00412     }
00413     virtual void ComputeResiduals(vi::VisBuffer2&vb, Bool useCorrected);
00414     void makeWBCFWt(CFStore2& cfs,const Double imRefFreq);
00415 
00416     CFBStruct cfbst_pub;
00417     // Image Scaling and offset
00418     Vector<Double> uvScale, uvOffset;
00419   protected:
00420     
00421     Int nint(Double val) {return Int(floor(val+0.5));};
00422     // Locate convolution functions on the disk
00423     //    Int locateConvFunction(const Int Nw, const Float pa);
00424     //    void cacheConvFunction(Int which, Array<Complex>& cf, CoordinateSystem& coord);
00425     // Find the convolution function
00426     void findConvFunction(const ImageInterface<Complex>& image,
00427                           const vi::VisBuffer2& vb);
00428     
00429     // Get the appropriate data pointer
00430     Array<Complex>* getDataPointer(const IPosition&, Bool);
00431     
00432     void ok();
00433     
00434     void init();
00435     //    virtual void initPolInfo(const vi::VisBuffer2& vb);
00436     // Is this record on Grid? check both ends. This assumes that the
00437     // ends bracket the middle
00438     Bool recordOnGrid(const vi::VisBuffer2& vb, Int rownr) const;
00439     
00440     // Padding in FFT
00441     Float padding_p;
00442     
00443     Int nWPlanes_p;
00444     // Image cache
00445     LatticeCache<Complex> * imageCache;
00446     
00447     // Sizes
00448     Long cachesize;
00449     Int tilesize;
00450     
00451     // Gridder
00452     ConvolveGridder<Double, Complex>* gridder;
00453     
00454     // Is this tiled?
00455     Bool isTiled;
00456     
00457     // Array lattice
00458     CountedPtr<Lattice<Complex> > arrayLattice;
00459     
00460     // Lattice. For non-tiled gridding, this will point to arrayLattice,
00461     //  whereas for tiled gridding, this points to the image
00462     CountedPtr<Lattice<Complex> > lattice;
00463     
00464     Float maxAbsData;
00465     
00466     // Useful IPositions
00467     IPosition centerLoc, offsetLoc;
00468     
00469     // // Image Scaling and offset
00470     // Vector<Double> uvScale, uvOffset;
00471     
00472    
00473     //    DirectionCoordinate directionCoord;
00474     MDirection::Convert* pointingToImage;
00475     
00476     // Grid/degrid zero spacing points?
00477     Bool usezero_p;
00478     
00479     //    CountedPtr<ConvolutionFunction> telescopeConvFunc_p;
00480     //    CFStore cfs_p, cfwts_p;
00481     // Array<Complex> convFunc_p, convWeights_p;
00482     //
00483     // Vector to hold the support size info. for the convolution
00484     // functions pointed to by the elements of convFunctions_p.  The
00485     // co-ordinates of this array are (W-term, Poln, PA).
00486     //
00487     Int // convSize,
00488       convSampling, wConvSize, lastIndex_p;
00489     
00490     //
00491     // The average PB for sky image normalization
00492     //
00493     CountedPtr<ImageInterface<Float> > avgPB_p;
00494     CountedPtr<ImageInterface<Complex> > avgPBSq_p;
00495     //
00496     // No. of vis. polarization planes used in making the user defined
00497     // Stokes images
00498     //
00499     Int maxConvSupport;
00500     //
00501     // Percentage of the peak of the PB after which the image is set
00502     // to zero.
00503     //
00504     CountedPtr<SolvableVisJones> epJ_p;
00505     Double sigma;
00506     Int Nant_p, doPointing;
00507     Bool doPBCorrection, makingPSF, conjBeams_p;
00508     
00509     //    CountedPtr<CFCache> cfCache_p;
00510     ParAngleChangeDetector paChangeDetector;
00511     Double rotateOTFPAIncr_p, computePAIncr_p;
00512 
00513     Unit Second, Radian, Day;
00514     Array<Float> l_offsets,m_offsets;
00515     Vector<Float> pbPeaks, paList;
00516 
00517     Double currentCFPA, cfRefFreq_p, imRefFreq_p;
00518     Float lastPAUsedForWtImg;
00519     Bool pbNormalized_p;
00520     Vector<Bool> paNdxProcessed_p;
00521     //
00522     //----------------------------------------------------------------------
00523     //
00524     virtual void normalizeAvgPB();
00525     virtual void normalizeAvgPB(ImageInterface<Complex>& inImage,
00526                                 ImageInterface<Float>& outImage);
00527     virtual void resampleDataToGrid(Array<Complex>& griddedData, VBStore& vbs, 
00528                                     const vi::VisBuffer2& vb, Bool& dopsf);
00529     virtual void resampleDataToGrid(Array<DComplex>& griddedData, VBStore& vbs, 
00530                                     const vi::VisBuffer2& vb, Bool& dopsf);
00531     virtual void resampleGridToData(VBStore& vbs, Array<Complex>& griddedData,
00532                                     const vi::VisBuffer2& vb);
00533 
00534     virtual void makeThGridCoords(VBStore& vbs, const Vector<Int>& gridShape);
00535     virtual void setupVBStore(VBStore& vbs,
00536                               const vi::VisBuffer2& vb,
00537                               const Matrix<Float>& imagingweight,
00538                               const Cube<Complex>& visData,
00539                               const Matrix<Double>& uvw,
00540                               const Cube<Int>& flagCube,
00541                               const Vector<Double>& dphase,
00542                               const Bool& doPSF,
00543                               const Vector<Int> &gridShape);
00544 
00545     //    AWVisResampler visResampler_p;
00546     CountedPtr<VisibilityResamplerBase> visResampler_p;
00547     Int sensitivityPatternQualifier_p;
00548     String sensitivityPatternQualifierStr_p;
00549     CFStore rotatedConvFunc_p;
00550     //CountedPtr<CFStore2> cfs2_p, cfwts2_p;
00551     Vector<Int> ConjCFMap_p, CFMap_p;
00552 
00553     Timer timer_p;
00554     Double runTime1_p;
00555 
00556     PolOuterProduct::MuellerType muellerType_p;
00557 
00558 #include "AWProjectFT.FORTRANSTUFF.INC"
00559   };
00560 } //# NAMESPACE CASA - END
00561 };
00562 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 31 Aug 2016 for casa by  doxygen 1.6.1