VisBuffer.h

Go to the documentation of this file.
00001 //# VisBuffer.h: buffer for iterating through MS in large blocks
00002 //# Copyright (C) 1996-2014
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 addressed 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 //# $Id: VisBuffer.h,v 19.14 2006/02/28 04:48:58 mvoronko Exp $
00027 
00028 #ifndef MSVIS_VISBUFFER_H
00029 #define MSVIS_VISBUFFER_H
00030 
00031 #include <casa/aips.h>
00032 #include <casa/Arrays/Cube.h>
00033 #include <casa/Arrays/Vector.h>
00034 #include <casa/Arrays/Matrix.h>
00035 #include <casa/BasicSL/Complex.h>
00036 #include <measures/Measures/MDirection.h>
00037 #include <measures/Measures/MEpoch.h>
00038 #include <msvis/MSVis/VisModelDataI.h>
00039 #include <msvis/MSVis/StokesVector.h>
00040 #include <msvis/MSVis/VisibilityIterator.h>
00041 #include <msvis/MSVis/VisBufferComponents.h>
00042 #include <msvis/MSVis/MSCalEnums.h>
00043 #include <set>
00044 
00045 namespace casa { //# NAMESPACE CASA - BEGIN
00046 
00047 
00048 //#forward
00049   class SIMapperCollection;
00050 
00051 // <summary>
00052 // VbDirtyComponents allows marking portions of a VisBuffer as
00053 // modified (aka dirty).  This feature is needed for the Visibility
00054 // Processing Framework (VPF) which allows a sequence of data processing
00055 // nodes to work as a bucket brigade operating sequentially on a
00056 // VisBuffer.  A downstream output node needs to know what data,
00057 // if any, needs to be written out.
00058 //
00059 // <prerequisite>
00060 //   #<li><linkto class="VisBuffer">VisBuffer</linkto>
00061 // </prerequisite>
00062 //
00063 // </summary>
00064 //
00065 // <synopsis>
00066 //
00067 // </synopsis>
00068 // <example>
00069 //
00070 // <code>
00071 //
00072 // </code>
00073 // </example>
00074 //
00075 class VbDirtyComponents {
00076 
00077 public:
00078 
00079     typedef std::set<VisBufferComponents::EnumType> Set;
00080     typedef Set::const_iterator const_iterator;
00081 
00082     VbDirtyComponents operator+ (const VbDirtyComponents & other) const;
00083 
00084     const_iterator begin () const;
00085     Bool contains (VisBufferComponents::EnumType component) const;
00086     const_iterator end () const;
00087 
00088     static VbDirtyComponents all ();
00089     static VbDirtyComponents exceptThese (VisBufferComponents::EnumType component, ...);
00090     static VbDirtyComponents none ();
00091     static VbDirtyComponents singleton (VisBufferComponents::EnumType component);
00092     static VbDirtyComponents these (VisBufferComponents::EnumType component, ...);
00093 
00094 protected:
00095 
00096 private:
00097 
00098     Set set_p;
00099 
00100     static const VbDirtyComponents all_p;
00101 
00102     static VbDirtyComponents initializeAll ();
00103 
00104 };
00105 
00106 namespace asyncio {
00107     class VLAT;
00108 } // end namespace asyncio
00109 
00110 //<summary>VisBuffers encapsulate one chunk of visibility data for processing.</summary>
00111 //
00112 // <use visibility=export>
00113 //
00114 // <reviewed reviewer="" date="" tests="" demos="">
00115 
00116 // <prerequisite>
00117 //   <li> <linkto class="VisSet">VisSet</linkto>
00118 //   <li> <linkto class="VisibilityIterator">VisibilityIterator</linkto>
00119 //   <li> <linkto class="VisBufferAutoPtr">VisBufferAutoPtr</linkto>
00120 //   <li> <linkto class="VbDirtyComponents">VbDirtyComponents</linkto>
00121 // </prerequisite>
00122 //
00123 // <etymology>
00124 // VisBuffer is a buffer for visibility data
00125 // </etymology>
00126 //
00127 //<synopsis>
00128 // This class contains 'one iteration' of the
00129 // <linkto class="VisibilityIterator">VisibilityIterator</linkto>
00130 // It is a modifiable
00131 // buffer of values to which calibration and averaging can be applied.
00132 // This allows processing of the data in larger blocks, avoiding some
00133 // overheads for processing per visibility point or spectrum.
00134 //
00135 // See <linkto module="MeasurementEquations">MeasurementEquations</linkto>
00136 // for more details on how the VisBuffer is to be used.
00137 //
00138 // When the user intends to allow asynchronous I/O they will need to use
00139 // the VisBufferAsync and VisBufferAsyncWrapper classes; these are
00140 // publicly derived from VisBuffer.  Normally, the user should not
00141 // explicitly use these classes but should use the helper class
00142 // VisBufferAutoPtr which will ensure that the appropriate class is
00143 // used.
00144 //</synopsis>
00145 
00146 //<todo>
00147 // <li> reconcile vis/visCube usage: visCube, flagCube and weightMatrix
00148 // are currently only correct when this VisBuffer got them from a
00149 // VisIter, operations like -=, freqAverage() are only done for
00150 // visibility() and flag().
00151 //</todo>
00152 
00153 class VisBuffer {
00154 
00155     friend class asyncio::VLAT; // for async i/o
00156     friend class VisBufferAsync; // for async i/o
00157     friend class VisBufferAsyncWrapper; // for async i/o
00158     friend class ViReadImplAsync; // for async I/O
00159     friend class SIMapperCollection; //for SIimager as we need access to MS object
00160 
00161 public:
00162     // Create empty VisBuffer you can assign to or attach.
00163     VisBuffer();
00164     // Construct VisBuffer for a particular VisibilityIterator
00165     // The buffer will remain synchronized with the iterator.
00166     VisBuffer(ROVisibilityIterator & iter);
00167 
00168     // Copy construct, looses synchronization with iterator: only use buffer for
00169     // current iteration (or reattach).
00170     VisBuffer(const VisBuffer & vb);
00171 
00172     // Destructor (detaches from VisIter)
00173     virtual ~VisBuffer();
00174 
00175     // Assignment, loses synchronization with iterator: only use buffer for
00176     // current iteration (or reattach)
00177 
00178     virtual VisBuffer & operator=(const VisBuffer & vb);
00179 
00180     // Assignment, optionally without copying the data across; with copy=True
00181     // this is identical to normal assignment operator
00182 
00183     virtual VisBuffer & assign(const VisBuffer & vb, Bool copy = True);
00184 
00185     virtual VisBuffer * clone () const;
00186 
00187     // subtraction: return the difference of the visibilities, flags of
00188     // this and other are or-ed. An exception is thrown if the number of
00189     // rows or channels differs, but no further checks are done.
00190     VisBuffer & operator-=(const VisBuffer & vb);
00191 
00192     // Attach to a VisIter. Detaches itself first if already attached
00193     // to a VisIter. Will remain synchronized with iterator.
00194     virtual void attachToVisIter(ROVisibilityIterator & iter);
00195     virtual void detachFromVisIter ();
00196 
00197     // Invalidate the cache
00198     virtual void invalidate();
00199 
00200     // <group>
00201     // Access functions
00202     //
00203     virtual Int & nCorr() {
00204         return nCorrOK_p ? nCorr_p : fillnCorr();
00205     }
00206     virtual Int nCorr() const {
00207         return This->nCorr();
00208     }
00209 
00210     virtual Int & nChannel() {
00211         return nChannelOK_p ? nChannel_p : fillnChannel();
00212     }
00213     virtual Int nChannel() const {
00214         return This->nChannel();
00215     }
00216 
00217     virtual Vector<Int>& channel() {
00218         return channelOK_p ? channel_p : fillChannel();
00219     }
00220     virtual const Vector<Int>& channel() const {
00221         return This->channel();
00222     }
00223 
00224     // virtual Int & nCat() {
00225     //     return nCatOK_p ? nCat_p : fillnCat();
00226     // }
00227     // virtual Int nCat() const {
00228     //     return This->nCat();
00229     // }
00230 
00235     // Decide what is the right value (depending on where the vb is coming from) 
00236     // for you for the size of the buffer. i.e (nCorr(), nChannel(), nRow()) or vb.visCube().shape()
00237     // The latter comes from the VisIter state ...the former be careful...
00239     //without updating fillnrow 
00244     virtual Int & nRow() {
00245         return nRowOK_p ? nRow_p : fillnRow();
00246     }
00247     virtual Int nRow() const {
00248         return This->nRow();
00249     }
00250 
00251     virtual Int nRowChunk() const;
00252 
00253     virtual Vector<Int>& antenna1() {
00254         return antenna1OK_p ? antenna1_p : fillAnt1();
00255     }
00256     virtual const Vector<Int>& antenna1() const {
00257         return This->antenna1();
00258     }
00259 
00260     virtual Vector<Int>& antenna2() {
00261         return antenna2OK_p ? antenna2_p : fillAnt2();
00262     }
00263     virtual const Vector<Int>& antenna2() const {
00264         return This->antenna2();
00265     }
00266 
00267     virtual Vector<Int>& feed1() {
00268         return feed1OK_p ? feed1_p : fillFeed1();
00269     }
00270     virtual const Vector<Int>& feed1() const {
00271         return This->feed1();
00272     }
00273 
00274     virtual Vector<Int>& feed2() {
00275         return feed2OK_p ? feed2_p : fillFeed2();
00276     }
00277     virtual const Vector<Int>& feed2() const {
00278         return This->feed2();
00279     }
00280 
00281     virtual void dirtyComponentsAdd (const VbDirtyComponents & additionalDirtyComponents);
00282     virtual void dirtyComponentsAdd (VisBufferComponents::EnumType component);
00283     virtual void dirtyComponentsClear ();
00284     virtual VbDirtyComponents dirtyComponentsGet () const;
00285     virtual void dirtyComponentsSet (const VbDirtyComponents & dirtyComponents);
00286     virtual void dirtyComponentsSet (VisBufferComponents::EnumType component);
00287 
00288     virtual Bool fetch(const asyncio::PrefetchColumns *pfc);
00289 
00290     // feed1_pa() and feed2_pa() return an array of parallactic angles
00291     // (each corresponds to the first receptor of the feed) one for each
00292     // row in the current buffer. In contrast, feed_pa() calculates
00293     // the angles for each antenna. These methods are implemented for
00294     // VisBuffer only to benefit from caching of the feed and antenna IDs.
00295     virtual Vector<Float>& feed1_pa() {
00296         return feed1_paOK_p ? feed1_pa_p : fillFeed1_pa();
00297     }
00298     virtual const Vector<Float>& feed1_pa() const {
00299         return This->feed1_pa();
00300     }
00301 
00302     virtual Vector<Float>& feed2_pa() {
00303         return feed2_paOK_p ? feed2_pa_p : fillFeed2_pa();
00304     }
00305     virtual const Vector<Float>& feed2_pa() const {
00306         return This->feed2_pa();
00307     }
00308 
00309     virtual Vector<SquareMatrix<Complex, 2> >& CJones() {
00310         return cjonesOK_p ? cjones_p : fillCjones();
00311     }
00312     virtual const Vector<SquareMatrix<Complex, 2> >& CJones() const {
00313         return This->CJones();
00314     }
00315 
00316     // Note that feed_pa is a function instead of a cached value
00317     virtual Vector<Float> feed_pa(Double time) const;
00318 
00319     // direction1() and direction2() return arrays of directions where
00320     // the first and the second antenna/feed are pointed to. One value for
00321     // each row in the current buffer.
00322     virtual Vector<MDirection>& direction1() {
00323         return direction1OK_p ? direction1_p
00324                : fillDirection1();
00325     }
00326     virtual const Vector<MDirection>& direction1()  const {
00327         return This->direction1();
00328     }
00329 
00330     virtual Vector<MDirection>& direction2() {
00331         return direction2OK_p ? direction2_p :
00332                fillDirection2();
00333     }
00334     virtual const Vector<MDirection>& direction2()  const {
00335         return This->direction2();
00336     }
00337     virtual MDirection& firstDirection1() {
00338         return firstDirection1OK_p ? firstDirection1_p
00339                : fillFirstDirection1();
00340     }
00341     virtual const MDirection& firstDirection1()  const {
00342         return This->firstDirection1();
00343     }
00344     // NOMINAL parallactic angle (feed p.a. offset NOT included)
00345     virtual Float parang0(Double time) const;
00346     virtual Vector<Float> parang(Double time) const;
00347 
00348     // Note that azel is a function instead of a cached value
00349     virtual MDirection azel0(Double time) const;
00350     virtual Vector<Double>& azel0Vec(Double time, Vector<Double>& azelVec) const;
00351     virtual Vector<MDirection> azel(Double time) const;
00352     virtual Matrix<Double>& azelMat(Double time, Matrix<Double>& azelMat) const;
00353 
00354     // Hour angle for specified time
00355     virtual Double hourang(Double time) const;
00356 
00357     virtual Int fieldId() const {
00358         return fieldIdOK_p ? fieldId_p : This->fillFieldId();
00359     }
00360 
00361     virtual Int& fieldIdRef() {
00362         return fieldIdOK_p ? fieldId_p : This->fillFieldId();
00363     }
00364 
00365     virtual Int& arrayIdRef() {
00366         return arrayIdOK_p ? arrayId_p : This->fillArrayId();
00367     }
00368 
00369     virtual Int arrayId() const {
00370         return arrayIdOK_p ? arrayId_p : This->fillArrayId();
00371     }
00372 
00373     // Return flag for each channel & row
00374     virtual Matrix<Bool>& flag() {
00375         return flagOK_p ? flag_p : fillFlag();
00376     }
00377     virtual const Matrix<Bool>& flag() const {
00378         return This->flag();
00379     }
00380 
00381     // Return flag for each polarization, channel and row
00382     virtual Cube<Bool>& flagCube() {
00383         return flagCubeOK_p ? flagCube_p : fillFlagCube();
00384     }
00385     virtual const Cube<Bool>& flagCube() const {
00386         return This->flagCube();
00387     }
00388 
00389     virtual Vector<Bool>& flagRow() {
00390         return flagRowOK_p ? flagRow_p : fillFlagRow();
00391     }
00392     virtual const Vector<Bool>& flagRow() const {
00393         return This->flagRow();
00394     }
00395 
00396     // Return flags for each polarization, channel, category, and row.
00397     virtual Array<Bool>& flagCategory() {
00398         return flagCategoryOK_p ? flagCategory_p : fillFlagCategory();
00399     }
00400     virtual const Array<Bool>& flagCategory() const {
00401         return This->flagCategory();
00402     }
00403 
00404     virtual Vector<Int>& scan() {
00405         return scanOK_p ? scan_p : fillScan();
00406     }
00407     virtual const Vector<Int>& scan() const {
00408         return This->scan();
00409     }
00410 
00411     // scalar version for convenience, when scan known constant for
00412     // entire iteration/buffer.
00413     virtual Int scan0() {
00414         return scan()(0);
00415     }
00416 
00417     virtual Vector<Int>& processorId() {
00418         return processorIdOK_p ? processorId_p : fillProcessorId();
00419     }
00420     virtual const Vector<Int>& processorId() const {
00421         return This->processorId();
00422     }
00423 
00424     virtual Vector<Int>& observationId() {
00425         return observationIdOK_p ? observationId_p : fillObservationId();
00426     }
00427     virtual const Vector<Int>& observationId() const {
00428         return This->observationId();
00429     }
00430 
00431     virtual Vector<Int>& stateId() {
00432         return stateIdOK_p ? stateId_p : fillStateId();
00433     }
00434     virtual const Vector<Int>& stateId() const {
00435         return This->stateId();
00436     }
00437 
00438     // Gets SPECTRAL_WINDOW/CHAN_FREQ (in Hz, acc. to the MS def'n v.2).
00439     virtual Vector<Double>& frequency() {
00440         return frequencyOK_p ? frequency_p : fillFreq();
00441     }
00442     virtual const Vector<Double>& frequency() const {
00443         return This->frequency();
00444     }
00445 
00446 //    virtual Vector<Double>& lsrFrequency() {
00447 //        return lsrFrequencyOK_p ? lsrFrequency_p : fillLSRFreq();
00448 //    }
00449 //    virtual const Vector<Double>& lsrFrequency() const {
00450 //        return This->lsrFrequency();
00451 //    }
00452 
00453 
00454     //the following method is to convert the observed frequencies
00455     // This conversion may not be accurate for some frame
00456     // conversion like topo to lsr except if the spw is in the actual buffer
00457 
00458     //if ignoreconv=True..frequency is served as is in the data frame
00459     virtual void lsrFrequency(const Int & spw, Vector<Double>& freq, Bool & convert, const Bool ignoreconv=False) const;
00460 
00461     virtual Int numberCoh () const;
00462 
00463     virtual MDirection & phaseCenter() {
00464         return phaseCenterOK_p ? phaseCenter_p : fillPhaseCenter();
00465     }
00466     virtual MDirection phaseCenter() const {
00467         return This->phaseCenter();
00468     }
00469 
00470     virtual Int polFrame() const {
00471         return polFrameOK_p ? polFrame_p : This->fillPolFrame();
00472     }
00473 
00474     virtual Vector<Int>& corrType() {
00475         return corrTypeOK_p ? corrType_p : fillCorrType();
00476     }
00477     virtual const Vector<Int>& corrType() const {
00478         return This->corrType();
00479     }
00480 
00481     virtual Vector<Float>& sigma() {
00482         return sigmaOK_p ? sigma_p : fillSigma();
00483     }
00484     virtual const Vector<Float>& sigma() const {
00485         return This->sigma();
00486     }
00487 
00488     virtual Matrix<Float>& sigmaMat() {
00489         return sigmaMatOK_p ? sigmaMat_p : fillSigmaMat();
00490     }
00491     virtual const Matrix<Float>& sigmaMat() const {
00492         return This->sigmaMat();
00493     }
00494 
00495     virtual Int & spectralWindow() {
00496         return spectralWindowOK_p ? spectralWindow_p : This->fillSpW();
00497     }
00498     virtual Int spectralWindow() const {
00499         return spectralWindowOK_p ? spectralWindow_p : This->fillSpW();
00500     }
00501     virtual Int polarizationId() const {
00502       return visIter_p->polarizationId();
00503     } 
00504     virtual Int& dataDescriptionIdRef() {
00505       return dataDescriptionIdOK_p ? dataDescriptionId_p : This->fillDataDescriptionId ();
00506     }
00507     virtual Int dataDescriptionId() const {
00508       return dataDescriptionIdOK_p ? dataDescriptionId_p : This->fillDataDescriptionId ();
00509     }
00510     virtual Vector<Double>& time() {
00511         return timeOK_p ? time_p : fillTime();
00512     }
00513     virtual const Vector<Double>& time() const {
00514         return This->time();
00515     }
00516 
00517     virtual Vector<Double>& timeCentroid() {
00518         return timeCentroidOK_p ? timeCentroid_p : fillTimeCentroid();
00519     }
00520     virtual const Vector<Double>& timeCentroid() const {
00521         return This->timeCentroid();
00522     }
00523 
00524     virtual Vector<Double>& timeInterval() {
00525         return timeIntervalOK_p ? timeInterval_p : fillTimeInterval();
00526     }
00527     virtual const Vector<Double>& timeInterval() const {
00528         return This->timeInterval();
00529     }
00530 
00531     virtual Vector<Double>& exposure() {
00532         return exposureOK_p ? exposure_p : fillExposure();
00533     }
00534     virtual const Vector<Double>& exposure() const {
00535         return This->exposure();
00536     }
00537 
00538     virtual Vector<RigidVector<Double, 3> >& uvw() {
00539         return uvwOK_p ? uvw_p : filluvw();
00540     }
00541     virtual const Vector<RigidVector<Double, 3> >& uvw() const {
00542         return This->uvw();
00543     }
00544 
00545     virtual Matrix<Double>& uvwMat() {
00546         return uvwMatOK_p ? uvwMat_p : filluvwMat();
00547     }
00548     virtual const Matrix<Double>& uvwMat() const {
00549         return This->uvwMat();
00550     }
00551 
00552     virtual Matrix<CStokesVector>& visibility() {
00553         return visibilityOK_p ? visibility_p : fillVis(VisibilityIterator::Observed);
00554     }
00555     virtual const Matrix<CStokesVector>& visibility() const {
00556         return This->visibility();
00557     }
00558 
00559     virtual Matrix<CStokesVector>& modelVisibility() {
00560         return modelVisibilityOK_p ? modelVisibility_p :
00561                fillVis(VisibilityIterator::Model);
00562     }
00563     virtual const Matrix<CStokesVector>& modelVisibility() const {
00564         return This->modelVisibility();
00565     }
00566 
00567     virtual Matrix<CStokesVector>& correctedVisibility() {
00568         return correctedVisibilityOK_p ? correctedVisibility_p :
00569                fillVis(VisibilityIterator::Corrected);
00570     }
00571     virtual const Matrix<CStokesVector>& correctedVisibility() const {
00572         return This->correctedVisibility();
00573     }
00574 
00575     virtual Cube<Complex>& visCube() {
00576         return visCubeOK_p ? visCube_p : fillVisCube(VisibilityIterator::Observed);
00577     }
00578     virtual const Cube<Complex>& visCube() const {
00579         return This->visCube();
00580     }
00581 
00582     virtual Cube<Complex>& modelVisCube() {
00583         return modelVisCubeOK_p ? modelVisCube_p :
00584                fillVisCube(VisibilityIterator::Model);
00585     }
00586 
00587     virtual Cube<Complex>& modelVisCube(const Bool & matchVisCubeShape) {
00588         // Avoids call to fillVisCube(VisIter::Model)
00589         modelVisCubeOK_p = True;
00590         if (matchVisCubeShape) {
00591             // shape it in memory like data
00592             modelVisCube_p.resize(visCube().shape());
00593             modelVisCube_p = Complex(0.0);
00594         }
00595         // ... and return it in the usual way
00596         return modelVisCube();
00597     }
00598 
00599     virtual const Cube<Complex>& modelVisCube() const {
00600         return This->modelVisCube();
00601     }
00602 
00603     virtual Cube<Complex>& correctedVisCube() {
00604         return correctedVisCubeOK_p ? correctedVisCube_p :
00605                fillVisCube(VisibilityIterator::Corrected);
00606     }
00607     virtual const Cube<Complex>& correctedVisCube() const {
00608         return This->correctedVisCube();
00609     }
00610 
00611     // Return visCube(), modelVisCube(), or correctedVisCube(),
00612     // according to whichcol.  They throw an exception if whichcol is
00613     // unsupported, but note the encouraged default.
00614     // TODO: Optionally return DATA if whichcol is unavailable.
00615     Cube<Complex>& dataCube(const MS::PredefinedColumns whichcol=MS::DATA);
00616     const Cube<Complex>& dataCube(const MS::PredefinedColumns
00617                                   whichcol=MS::DATA) const;
00618 
00619     virtual Cube<Float>& floatDataCube() {
00620         return floatDataCubeOK_p ? floatDataCube_p : fillFloatDataCube();
00621     }
00622     virtual const Cube<Float>& floatDataCube() const {
00623         return This->floatDataCube();
00624     }
00625 
00626     // Returns the weights for each row averaged over the parallel hand correlations.
00627     virtual Vector<Float>& weight() {
00628         return weightOK_p ? weight_p : fillWeight();
00629     }
00630     virtual const Vector<Float>& weight() const {
00631         return This->weight();
00632     }
00633 
00634     // Returns the nPol_p x curNumRow_p weight matrix.
00635     virtual Matrix<Float>& weightMat() {
00636         return weightMatOK_p ? weightMat_p : fillWeightMat();
00637     }
00638     virtual const Matrix<Float>& weightMat() const {
00639         return This->weightMat();
00640     }
00641 
00642     // Is a valid WEIGHT_SPECTRUM available?
00643     virtual Bool existsWeightSpectrum() const {
00644       return visIter_p ? visIter_p->existsWeightSpectrum() : false;
00645     }
00646 
00647     virtual Cube<Float>& weightSpectrum() {
00648         return weightSpectrumOK_p ? weightSpectrum_p : fillWeightSpectrum();
00649     }
00650     virtual const Cube<Float>& weightSpectrum() const {
00651         return This->weightSpectrum();
00652     }
00653 
00654     virtual Matrix<Float>& imagingWeight();
00655     virtual const Matrix<Float>& imagingWeight() const;
00656 
00657 
00658 //    virtual Matrix<Float>& imagingWeight() {
00659 //        return imagingWeightOK_p ? imagingWeight_p : fillImagingWeight();
00660 //    }
00661 //    virtual const Matrix<Float>& imagingWeight() const {
00662 //        return This->imagingWeight();
00663 //    }
00664 
00665     virtual Cube<Float>& weightCube() {
00666         return weightCube_p;
00667     }
00668     //</group>
00669 
00670     //<group>
00671     // Utility functions to provide coordinate or column ranges of the
00672     // data in the VisBuffer. Flagging is applied before computing the ranges.
00673     //
00674     // Generic accessor to column ranges of integer type, as specified by
00675     // enumerations defined in class MSCalEnums. Throws an exception
00676     // if the enum is not for a recognized integer column.
00677     virtual Vector<Int> vecIntRange(const MSCalEnums::colDef & calEnum) const;
00678 
00679     // Antenna id. range (includes both ANTENNA1 and ANTENNA2 columns)
00680     virtual Vector<Int> antIdRange() const;
00681 
00682     // Time range
00683     virtual Bool timeRange(MEpoch & rTime, MVEpoch & rTimeEP, MVEpoch & rInterval) const;
00684 
00685     // Return the row Ids from the original ms. If the ms used is a subset of
00686     // another ms then rowIds() return the row ids of the original ms.
00687     virtual Vector<uInt>& rowIds();
00688 
00689     virtual const Vector<uInt>& rowIds() const {
00690         return This->rowIds();
00691     };
00692 
00693     //</group>
00694 
00695     // Frequency average the buffer (visibility() column only)
00696     virtual void freqAverage();
00697 
00698     // Frequency average the buffer (visCube and [if present] modelVisCube)
00699     void freqAveCubes();
00700 
00701     // Average channel axis according to chanavebounds, for whichever of DATA,
00702     // MODEL_DATA, CORRECTED_DATA, FLOAT_DATA, FLAG, and WEIGHT_SPECTRUM are
00703     // present.  It will only treat the first 5 as present if they have already
00704     // been loaded into the buffer!
00705     void channelAve(const Matrix<Int>& chanavebounds,Bool calmode=True);
00706 
00707     // Average channel axis by factor.
00708     template<class T> void chanAveVisCube(Cube<T>& data, Int nChanOut);
00709 
00710     // Accumulate channel axis by factor, without applying WEIGHT_SPECTRUM even
00711     // if it is present.
00712     // It is primarily intended for averaging WEIGHT_SPECTRUM itself.
00713     template<class T> void chanAccCube(Cube<T>& data, Int nChanOut);
00714 
00715     // This defaults to no conceptual side effects, but usually it is more
00716     // efficient to let it leave weightSpectrum() in a channel averaged state.
00717     // restoreWeightSpectrum has no effect if !existsWeightSpectrum().
00718     virtual void chanAveFlagCube(Cube<Bool>& flagcube, const Int nChanOut,
00719                          const Bool restoreWeightSpectrum = True);
00720 
00721     // Doesn't do anything if flagcat is degenerate.
00722     void chanAveFlagCategory(Array<Bool>& flagcat, const Int nChanOut);
00723 
00724     // Form Stokes parameters from correlations
00725     //  (these are preliminary versions)
00726     virtual void formStokes();
00727     virtual void formStokesWeightandFlag();
00728     virtual void formStokes(Cube<Complex>& vis);
00729     virtual void formStokes(Cube<Float>& fcube);    // Will throw up if asked to do all 4.
00730 
00731     // Sort/unsort the correlations, if necessary
00732     //  (Rudimentary handling of non-canonically sorted correlations--use with care!)
00733     virtual void sortCorr();
00734     virtual void unSortCorr();
00735 
00736     // Normalize the visCube by the modelVisCube
00737     //   (and optionally also divide visCube_p by its normalized amp)
00738     virtual void normalize(const Bool & phaseOnly = False);
00739 
00740     // Fill weightMat according to sigma column
00741     virtual void resetWeightMat();
00742 
00743     // Rotate visibility phase for given vector (dim = nrow of vb) of phases (metres)
00744     virtual void phaseCenterShift(const Vector<Double>& phase);
00745     // Rotate visibility phase for phase center offsets (arcsecs)
00746     virtual void phaseCenterShift(Double dx, Double dy);
00747 
00748     // Update coordinate info - useful for copied VisBuffers that need
00749     // to retain some state for later reference.
00750     // Presently this fills antenna, array, field and spectralWindow ids, time,
00751     // frequency and number of rows. 
00752     // if dirDependent is set to False the expensive direction dependent calculation of parallactic or direction of
00753     // antenna from pointing table is avoided
00754     //Add more as needed.
00755     virtual void updateCoordInfo(const VisBuffer * vb = NULL, const Bool dirDependent=True);
00756     void copyCoordInfo(const VisBuffer& other, Bool force=False);
00757 
00758     // Set the visibility to a constant, note that this only changes the buffer,
00759     // no values are written back to tables from here.
00760     virtual void setVisCube(Complex c);
00761     virtual void setModelVisCube(Complex c);
00762     virtual void setCorrectedVisCube(Complex c);
00763 
00764     // Set the visibility, note that this only changes the buffer,
00765     // no values are written back to tables from here.
00766     virtual void setVisCube(const Cube<Complex>& vis);
00767     virtual void setModelVisCube(const Cube<Complex>& vis);
00768     virtual void setCorrectedVisCube(const Cube<Complex>& vis);
00769 
00770     // Like the above, but for FLOAT_DATA, keeping it as real floats.
00771     virtual void setFloatDataCube(const Cube<Float>& fcube);
00772 
00773     // Set model according to a Stokes vector
00774     virtual void setModelVisCube(const Vector<Float>& stokes);
00775 
00776     // Reference external model visibilities
00777     virtual void refModelVis(const Matrix<CStokesVector>& mvis);
00778 
00779     // Remove scratch cols data from vb
00780     virtual void removeScratchCols();
00781 
00782     // Access the current ROMSColumns object via VisIter
00783     virtual const ROMSColumns & msColumns() const {
00784         return visIter_p->msColumns();
00785     }
00786 
00787     virtual  Int numberAnt () const;
00788 
00789 
00790 
00791     // Get all selected spectral windows not just the one in the actual buffer
00792     virtual void allSelectedSpectralWindows(Vector<Int>& spws, Vector<Int>& nvischan) {
00793         visIter_p->allSelectedSpectralWindows(spws, nvischan);
00794     }
00795 
00796   virtual void getChannelSelection(Block< Vector<Int> >& blockNGroup,
00797                                    Block< Vector<Int> >& blockStart,
00798                                    Block< Vector<Int> >& blockWidth,
00799                                    Block< Vector<Int> >& blockIncr,
00800                                    Block< Vector<Int> >& blockSpw) const {
00801     visIter_p->getChannelSelection(blockNGroup, blockStart, blockWidth, blockIncr, blockSpw);
00802   };
00803     void allSelectedSpectralWindows(Vector<Int>& spws, Vector<Int>& nvischan) const {
00804         This->allSelectedSpectralWindows(spws, nvischan);
00805     }
00806 
00807     // Return the actual msid, useful if using multiple ms to monitor which
00808     // ms in the  list is being dealt with
00809     virtual Int msId() const {
00810         This->checkMSId();
00811         return oldMSId_p;
00812     }
00813 
00814     //checked if the ms has changed since the last chunk processed
00815     virtual Bool newMS() const {
00816         This->checkMSId();
00817         return newMS_p;
00818     }
00819     //get the name of the ms the buffer is at empty string if no visiter is attached
00820     virtual String msName(Bool stripPath=False) const;
00821 
00822     virtual Bool newArrayId () const;
00823     virtual Bool newFieldId () const;
00824     virtual Bool newSpectralWindow () const;
00825 
00826     //
00827 
00828 protected:
00829 
00830     virtual Bool checkMSId();
00831     virtual void checkVisIter (const char * func, const char * file, int line, const char * extra = "") const;
00832     virtual void copyCache (const VisBuffer & other, Bool force);
00833     virtual void copyMsInfo (Int & msID, Bool & MsOk_p, Bool & newMs) const;
00834     virtual const Matrix<Float>& imagingWeight(const VisImagingWeight & weightGenerator) const;
00835     virtual Int getOldMsId () const;
00836     virtual ROVisibilityIterator * getVisibilityIterator () const;
00837 
00838     template <typename Coord>
00839     void updateCoord (const VisBuffer * other,
00840                       Bool otherOk,
00841                       const Coord & (VisBuffer::* getCoord) () const,
00842                       Coord & coord,
00843                       Bool & coordOk)
00844     {
00845         if (otherOk){
00846             coord.assign ((other ->* getCoord) ());
00847             coordOk = True;
00848         }
00849         else {
00850             ((this ->* getCoord) ());
00851         }
00852     }
00853 
00854     template <typename Scalar>
00855     void updateCoordS (const VisBuffer * other,
00856                        Bool otherOk,
00857                        Scalar (VisBuffer::* getCoord) () const,
00858                        Scalar & coord,
00859                        Bool & coordOk)
00860     {
00861         if (otherOk){
00862             coord = (other ->* getCoord) ();
00863             coordOk = True;
00864         }
00865         else {
00866             ((this ->* getCoord) ());
00867         }
00868     }
00869 
00870 
00871 private:
00872 
00873 
00874     // validate the cache
00875     virtual void validate();
00876 
00877     void checkVisIterBase (const char * func, const char * file, int line, const char * extra = "") const;
00878 
00879     template<typename T>
00880     static void cacheCopyArray (Bool & newStatus,
00881                                 Bool oldStatus,
00882                                 T & newCache,
00883                                 const VisBuffer & other,
00884                                 const T &  (VisBuffer::* oldCache) () const,
00885                                 Bool force) {
00886 
00887         // Leave things unchanged if the old status is false.  This will often
00888         // leave the value with an empty data structure and an OK status which
00889         // is needed in many cases.
00890         //
00891         // For copying Array<T> derived objects since the assign operator
00892         // doesn't work for these.
00893 
00894         newStatus = force || oldStatus;
00895 
00896         if (newStatus) {
00897             newCache.assign (((& other) ->* oldCache) ());
00898         }
00899     }
00900 
00901     template<typename T>
00902     static void cacheCopyNormal (Bool & newStatus,
00903                                  Bool oldStatus,
00904                                  T & newCache,
00905                                  const VisBuffer & other,
00906                                  T (VisBuffer::* oldCache) () const,
00907                                  Bool force) {
00908 
00909         // Leave things unchanged if the old status is false.  This will often
00910         // leave the value with an empty data structure and an OK status which
00911         // is needed in many cases.
00912         //
00913         // For copying "normal" cache status and values.  Normal means
00914         // the assign operator works (which it doesn't for classes based on Array<T>)
00915 
00916         newStatus = force || oldStatus;
00917 
00918         if (newStatus) {
00919 
00920             newCache = ((& other) ->* oldCache) ();
00921         }
00922     }
00923 
00924     virtual void setAllCacheStatuses (bool status);
00925 
00926     virtual Bool nonCanonCorr(); // Are correlations in non-canonical order?
00927 
00928     // Filter index arrays for unique elements
00929     virtual Vector<Int> unique(const Vector<Int>& indices) const;
00930 
00931     Bool corrSorted_p; // Have correlations been sorted by sortCorr?
00932     VbDirtyComponents dirtyComponents_p;
00933     Int lastPointTableRow_p;
00934     Int oldMSId_p;
00935     VisBuffer * This;
00936     Bool twoWayConnection_p;
00937     ROVisibilityIterator * visIter_p;
00938     CountedPtr <VisModelDataI> visModelData_p;
00939 
00940     // +-------------------------------------------------+
00941     // | Cache Declarations (fillers, statuses and data) |
00942     // +-------------------------------------------------+
00943     //
00944     // Preferred naming convention:
00945     //
00946     // T thing () --- returns the value of thing (public method)
00947     // T fillThing () --- fills thing cache variable and sets thingOK_p to true (private)
00948     // Bool thingOK_p --- true if the value of thing is currently cached  (private)
00949     // T thing_p --- holds cached value of thing (if thingOK_p is true)  (private)
00950     //
00951     // Example: Vector<Int>& feed1(); Vector<Int>& fillFeed1();
00952     //          Bool feed1OK_P; Vector<Int> feed1_p;
00953 
00954     // Cache filling routines in alphabetical order
00955     //
00956     // The first line in a fill routine should be the macro CheckVisIter.  This
00957     // will cause an AipsError to be throw when there is no visibilty iterator
00958     // associated with the VisBuffer.  This is especially important because the
00959     // fillers may be called on a VisBufferAsync in two contexts: filling
00960     // where there will be a VI attached and in normal use where there is no VI
00961     // attached.  The filler must also set the cache status variable to True during
00962     // its execution.
00963 
00964     virtual Vector<Int>& fillAnt1();
00965     virtual Vector<Int>& fillAnt2();
00966     virtual Int & fillArrayId();
00967     //virtual Matrix<Int>& fillChanAveBounds();
00968     virtual Vector<Int>& fillChannel();
00969     virtual Vector<SquareMatrix<Complex, 2> >& fillCjones();
00970     virtual Vector<Int>& fillCorrType();
00971     virtual Int & fillDataDescriptionId ();
00972     virtual Vector<MDirection>& fillDirection1();
00973     virtual MDirection& fillFirstDirection1();
00974     virtual Vector<MDirection>& fillDirection2();
00975     virtual Vector<Double>& fillExposure();
00976     virtual Vector<Int>& fillFeed1();
00977     virtual Vector<Float>& fillFeed1_pa();
00978     virtual Vector<Int>& fillFeed2();
00979     virtual Vector<Float>& fillFeed2_pa();
00980     virtual Int & fillFieldId();
00981     virtual Matrix<Bool>& fillFlag();
00982     virtual Array<Bool>& fillFlagCategory();
00983     virtual Cube<Bool>& fillFlagCube();
00984     virtual Vector<Bool> & fillFlagRow();
00985     virtual Cube<Float>& fillFloatDataCube();
00986     virtual Vector<Double>& fillFreq();         // Puts SPECTRAL_WINDOW/CHAN_FREQ in frequency_p.
00987     //virtual Matrix<Float>& fillImagingWeight();
00988     //virtual Vector<Double>& fillLSRFreq();
00989     virtual Int & fillnChannel();
00990     virtual Int & fillnCorr();
00991   //    virtual Int & fillnCat();
00992     virtual Int & fillnRow();
00993     virtual Vector<Int> & fillObservationId();
00994     virtual MDirection & fillPhaseCenter();
00995     virtual Int & fillPolFrame();
00996     virtual Vector<Int> & fillProcessorId();
00997     virtual Vector<Int> & fillScan();
00998     virtual Vector<Float>& fillSigma();
00999     virtual Matrix<Float>& fillSigmaMat();
01000     virtual Int & fillSpW();
01001     virtual Vector<Int> & fillStateId();
01002     virtual Vector<Double>& fillTime();
01003     virtual Vector<Double>& fillTimeCentroid();
01004     virtual Vector<Double>& fillTimeInterval();
01005     virtual Vector<RigidVector<Double, 3> >& filluvw();
01006     virtual Matrix<Double>& filluvwMat();
01007     virtual Matrix<CStokesVector>& fillVis(VisibilityIterator::DataColumn whichOne);
01008     virtual Cube<Complex>& fillVisCube(VisibilityIterator::DataColumn whichOne);
01009     virtual Vector<Float>& fillWeight();
01010     virtual Matrix<Float>& fillWeightMat();
01011     virtual Cube<Float>& fillWeightSpectrum();
01012 
01013     Bool newMS_p;
01014 
01015     // Variables to track validity of cache (alphabetical order)
01016 
01017 #define CacheStatus(item) \
01018 virtual Bool item ## OK () const\
01019 {\
01020     return item ## OK_p;\
01021 }\
01022 Bool item ## OK_p;
01023 
01024     // Define the cache statuses
01025     //
01026     // For example, CacheStatus (antenna1) defines:
01027     //
01028     // virtual Bool antenna1OK () const { return antenna1OK_p;}
01029     //
01030     // and
01031     //
01032     // Bool antenna1OK_p;
01033 
01034     CacheStatus (antenna1);
01035     CacheStatus (antenna2);
01036     CacheStatus (arrayId);
01037     CacheStatus (channel);
01038     CacheStatus (cjones);
01039     CacheStatus (correctedVisCube);
01040     CacheStatus (correctedVisibility);
01041     CacheStatus (corrType);
01042     CacheStatus (dataDescriptionId);
01043     CacheStatus (direction1);
01044     CacheStatus (direction2);
01045     CacheStatus (firstDirection1);
01046     CacheStatus (exposure);
01047     CacheStatus (feed1_pa);
01048     CacheStatus (feed1);
01049     CacheStatus (feed2_pa);
01050     CacheStatus (feed2);
01051     CacheStatus (fieldId);
01052     CacheStatus (flagCategory);
01053     CacheStatus (flagCube);
01054     CacheStatus (flag);
01055     CacheStatus (flagRow);
01056     CacheStatus (floatDataCube);
01057     CacheStatus (frequency);
01058     CacheStatus (imagingWeight);
01059     CacheStatus (modelVisCube);
01060     CacheStatus (modelVisibility);
01061     CacheStatus (ms);
01062     CacheStatus (nChannel);
01063     CacheStatus (nCorr);
01064     CacheStatus (nRow);
01065     CacheStatus (observationId);
01066     CacheStatus (phaseCenter);
01067     CacheStatus (polFrame);
01068     CacheStatus (processorId);
01069     CacheStatus (rowIds);
01070     CacheStatus (scan);
01071     CacheStatus (sigmaMat);
01072     CacheStatus (sigma);
01073     CacheStatus (spectralWindow);
01074     CacheStatus (stateId);
01075     CacheStatus (timeCentroid);
01076     CacheStatus (timeInterval);
01077     CacheStatus (time);
01078     CacheStatus (uvwMat);
01079     CacheStatus (uvw);
01080     CacheStatus (visCube);
01081     CacheStatus (visibility);
01082     CacheStatus (weightMat);
01083     CacheStatus (weight);
01084     CacheStatus (weightSpectrum);
01085 
01086     // Cached values (alphabetical order)
01087 
01088     Vector<Int> antenna1_p;
01089     Vector<Int> antenna2_p;
01090     Int arrayId_p;
01091     Matrix<Int> chanAveBounds_p;
01092     Vector<Int> channel_p;
01093     Vector<SquareMatrix<Complex, 2> > cjones_p;
01094     Cube<Complex> correctedVisCube_p;
01095     Matrix<CStokesVector> correctedVisibility_p;
01096     Vector<Int> corrType_p;
01097     Int dataDescriptionId_p;
01098     Vector<MDirection> direction1_p; //where the first antenna/feed is pointed to
01099     Vector<MDirection> direction2_p; //where the second antenna/feed is pointed to
01100     MDirection firstDirection1_p;
01101     Vector<Double> exposure_p;
01102     Vector<Int> feed1_p;
01103     Vector<Float> feed1_pa_p;
01104     Vector<Int> feed2_p;
01105     Vector<Float> feed2_pa_p;
01106     Int fieldId_p;
01107     Matrix<Bool> flag_p;
01108     Array<Bool> flagCategory_p;
01109     Cube<Bool> flagCube_p;
01110     Vector<Bool> flagRow_p;
01111     Cube<Float> floatDataCube_p;
01112     Vector<Double> frequency_p;
01113     mutable Matrix<Float> imagingWeight_p;
01114     //Vector<Double> lsrFrequency_p;
01115     Cube<Complex> modelVisCube_p;
01116     Matrix<CStokesVector> modelVisibility_p;
01117     Int nChannel_p;
01118     Int nCorr_p;
01119   //    Int nCat_p;
01120     Int nRow_p;
01121     Vector<Int> observationId_p;
01122     MDirection phaseCenter_p;
01123     Int polFrame_p;
01124     Vector<Int> processorId_p;
01125     Vector<uInt> rowIds_p;
01126     Vector<Int> scan_p;
01127     Vector<Float> sigma_p;
01128     Matrix<Float> sigmaMat_p;
01129     Int spectralWindow_p;
01130     Vector<Int> stateId_p;
01131     Vector<Double> time_p;
01132     Vector<Double> timeCentroid_p;
01133     Vector<Double> timeInterval_p;
01134     Vector<RigidVector<Double, 3> > uvw_p;
01135     Matrix<Double> uvwMat_p;
01136     Cube<Complex> visCube_p;
01137     Matrix<CStokesVector> visibility_p;
01138     Vector<Float> weight_p;
01139     Cube<Float> weightCube_p;
01140     Matrix<Float> weightMat_p;
01141     Cube<Float> weightSpectrum_p;
01142 
01143 };
01144 
01145 // <summary>
01146 // A convenience class to assist in migrating code to potentially use
01147 // asynchronous I/O.
01148 //
01149 // <prerequisite>
01150 //   <li> <linkto class="VisBuffer">VisBuffer</linkto>
01151 //   <li> <linkto class="VisBufferAsync">VisBufferAsync</linkto>
01152 //   <li> <linkto class="ROVisibilityIterator">ROVisibilityIterator</linkto>
01153 // </prerequisite>
01154 //
01155 // </summary>
01156 //
01157 // <synopsis>
01158 //
01159 // When existing code is modified to potentially use asynchronous I/O the current
01160 // VisBuffer usage is probably using automatic (stack) storage which will have to
01161 // be replaced to allow VisBufferAsync objects (which derive from VisBuffer) to be
01162 // used with asynchronous I/O.  The goal of this class is to make that transition
01163 // easier.  The user will replace their existing declaration of a VisBuffer object
01164 // with a declaration of a VisBufferAutoPtr object.  Depending on the attributes
01165 // of the VisBuffer reference/pointer or the ROVisibilityIterator provided in the
01166 // VisBufferAutoPtr constructor, the appropriate type of VisBuffer will be created
01167 // dynamically.  The VisBufferAutoPtr will also function somewhat like an auto_ptr
01168 // and delete the underlying object when the VisBufferAutoPtr object is destroyed.
01169 //
01170 // Once the straight VisBuffer declaration is replaced, then the code in its scope
01171 // will need to be modified to dereference the VisBufferAutoPtr or to delete use
01172 // of the address-of operator, "&", applied to the previous VisBuffer variable.
01173 // See the example below.
01174 //
01175 // </synopsis>
01176 // <example>
01177 //
01178 // <code>
01179 // // Before adding asynchronous I/O support
01180 //
01181 // VisBuffer vb (vi);
01182 //
01183 // doSomething (vb);        // void doSomething (VisBuffer &);
01184 // doSomethingElse (& vb);  // void doSomethingElse (VisBuffer *);
01185 //
01186 // // After adding asynchronous I/O support
01187 //
01188 // VisBufferAutoPtr vb (vi);
01189 //
01190 // doSomething (* vb);
01191 // doSomethingElse (vb.get());
01192 //
01193 // </code>
01194 // </example>
01195 //
01196 class VisBufferAutoPtr {
01197 
01198 public:
01199 
01200     VisBufferAutoPtr ();
01201     VisBufferAutoPtr (VisBufferAutoPtr & other);
01202     explicit VisBufferAutoPtr (VisBuffer &);
01203     explicit VisBufferAutoPtr (VisBuffer *);
01204     explicit VisBufferAutoPtr (ROVisibilityIterator * rovi);
01205     explicit VisBufferAutoPtr (ROVisibilityIterator & rovi);
01206     ~VisBufferAutoPtr ();
01207 
01208     VisBufferAutoPtr & operator= (VisBufferAutoPtr & other);
01209     VisBuffer & operator* () const;
01210     VisBuffer * operator-> () const;
01211 
01212     VisBuffer * get () const;
01213     VisBuffer * release ();
01214     void set (VisBuffer &);
01215     void set (VisBuffer *);
01216     void set (ROVisibilityIterator * rovi, Bool attachIt = False);
01217     void set (ROVisibilityIterator & rovi, Bool attachIt = False);
01218 
01219 protected:
01220 
01221     void construct (ROVisibilityIterator * rovi, Bool attachVi);
01222     void constructVb (VisBuffer * rovi);
01223 
01224 private:
01225 
01226     VisBuffer * visBuffer_p;
01227 
01228 };
01229 
01230 } //# NAMESPACE CASA - END
01231 
01232 #ifndef AIPS_NO_TEMPLATE_SRC
01233 #include <msvis/MSVis/VisBuffer.tcc>
01234 #endif //# AIPS_NO_TEMPLATE_SRC
01235 
01236 #endif
01237 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 31 Aug 2016 for casa by  doxygen 1.6.1