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

Generated on 31 Aug 2016 for casa by  doxygen 1.6.1