VisBufferImpl2.h

Go to the documentation of this file.
00001 //# VisBuffer.h: buffer for iterating through MS in large blocks
00002 //# Copyright (C) 1996,1997,1998,1999,2000,2002,2003
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 
00027 #ifndef MSVIS_VISBUFFERIMPL2_H
00028 #define MSVIS_VISBUFFERIMPL2_H
00029 
00030 #include <casa/aips.h>
00031 
00032 //#warning "Remove next line later"
00033 //#    include <msvis/MSVis/VisBuffer.h>
00034 
00035 #include <casa/Arrays/Cube.h>
00036 #include <casa/Arrays/Vector.h>
00037 #include <casa/Arrays/Matrix.h>
00038 #include <casa/BasicSL/Complex.h>
00039 #include <msvis/MSVis/VisBufferComponents2.h>
00040 #include <msvis/MSVis/VisBuffer2.h>
00041 
00042 using casa::vi::VisBufferComponent2;
00043 using casa::vi::VisBufferComponents2;
00044 
00045 namespace casa { //# NAMESPACE CASA - BEGIN
00046 
00047 class VisModelDataI;
00048 
00049 namespace asyncio {
00050     class VLAT;
00051 } // end namespace asyncio
00052 
00053 namespace ms {
00054     class Vbi2MsRow;
00055 }
00056 
00057 namespace vi {
00058 
00059 //#forward
00060 
00061 class VbCacheItemBase;
00062 class VisBufferCache;
00063 class VisBufferState;
00064 class VisBufferImpl2;
00065 class ViImplementation2;
00066 
00067 namespace avg {
00068 
00069     class VbAvg;
00070 }
00071 
00072 namespace tavg {
00073 
00074     class VbAvg;
00075 }
00076 
00077 
00078 
00079 //<summary>VisBufferImpls encapsulate one chunk of visibility data for processing.</summary>
00080 //
00081 // <use visibility=export>
00082 //
00083 // <reviewed reviewer="" date="" tests="" demos="">
00084 
00085 // <prerequisite>
00086 //   <li> <linkto class="VisSet">VisSet</linkto>
00087 //   <li> <linkto class="ViImplementation2">ViImplementation2</linkto>
00088 //   <li> <linkto class="VisBufferImplAutoPtr">VisBufferImplAutoPtr</linkto>
00089 //   <li> <linkto class="VbDirtyComponents">VbDirtyComponents</linkto>
00090 // </prerequisite>
00091 //
00092 // <etymology>
00093 // VisBufferImpl is a buffer for visibility data
00094 // </etymology>
00095 //
00096 //<synopsis>
00097 // This class contains 'one iteration' of the
00098 // <linkto class="ViImplementation2">ViImplementation2</linkto>
00099 // It is a modifiable
00100 // buffer of values to which calibration and averaging can be applied.
00101 // This allows processing of the data in larger blocks, avoiding some
00102 // overheads for processing per visibility point or spectrum.
00103 //
00104 // See <linkto module="MeasurementEquations">MeasurementEquations</linkto>
00105 // for more details on how the VisBufferImpl is to be used.
00106 //
00107 // When the user intends to allow asynchronous I/O they will need to use
00108 // the VisBufferImplAsync and VisBufferImplAsyncWrapper classes; these are
00109 // publicly derived from VisBufferImpl.  Normally, the user should not
00110 // explicitly use these classes but should use the helper class
00111 // VisBufferImplAutoPtr which will ensure that the appropriate class is
00112 // used.
00113 //
00114 //</synopsis>
00115 
00116 //<todo>
00117 //</todo>
00118 
00119 class VisBufferImpl2 : public VisBuffer2 {
00120 
00121     friend class VLAT; // for async i/o
00122     friend class casa::vi::avg::VbAvg;
00123     friend class casa::vi::tavg::VbAvg;
00124     friend class AveragingTvi2;
00125     friend class VbCacheItemBase;
00126     friend class VisBufferCache;
00127     friend class VisBufferState;
00128     friend class casa::vi::VisBuffer2;
00129     friend class VisBufferImpl2Async; // for async i/o
00130     friend class VisBufferImpl2AsyncWrapper; // for async i/o
00131     friend class ViReadImpl;
00132     friend class ViReadImplAsync; // for async I/O
00133     friend class casa::ms::Vbi2MsRow;
00134 
00135 public:
00136 
00137 
00138     // Destructor (detaches from VisIter)
00139 
00140     virtual ~VisBufferImpl2();
00141 
00142     void appendRow (ms::Vbi2MsRow * rowSrc, Int initialCapacity,
00143                     const VisBufferComponents2 & optionalComponentsToCopy,
00144                     bool doCopy = True);
00145     void appendRowsComplete ();
00146     Int appendSize () const;
00147 
00148     // Copies all of the components (or just the one in the cache) from
00149     // the specified VisBuffer into this one.
00150 
00151     virtual void copy (const VisBuffer2 & other, Bool fetchIfNeeded = True);
00152 
00153     // Copies the specified components (or just the one in the cache) from
00154     // the specified VisBuffer into this one.
00155 
00156     virtual void copyComponents (const VisBuffer2 & other,
00157                                                  const VisBufferComponents2 & components,
00158                                  Bool allowShapeChange = False,
00159                                                  Bool fetchIfNeeded = True);
00160 
00161     virtual void copyCoordinateInfo (const VisBuffer2 * vb, Bool dirDependent,
00162                                      Bool allowShapeChange = False, Bool fetchIfNeeded = True);
00163 
00164     virtual Vector<Stokes::StokesTypes> getCorrelationTypesDefined () const;
00165     virtual Vector<Stokes::StokesTypes> getCorrelationTypesSelected () const;
00166 
00167     virtual Vector<Int> getCorrelationTypes () const;
00168     virtual String getFillErrorMessage () const;
00169     virtual Double getFrequency (Int rowInBuffer, Int frequencyIndex, Int frame = FrameNotSpecified) const;
00170     virtual const Vector<Double> & getFrequencies (Int rowInBuffer,
00171                                                    Int frame = FrameNotSpecified) const;
00172     virtual Int getChannelNumber (Int rowInBuffer, Int frequencyIndex) const;
00173     virtual const Vector<Int> & getChannelNumbers (Int rowInBuffer) const;
00174     virtual Vector<Int> getChannelNumbersSelected (Int outputChannelIndex) const;
00175 
00176     ms::MsRow * getRow (Int row) const;
00177     ms::MsRow * getRowMutable (Int row);
00178 
00179     virtual void invalidate();
00180 
00181     virtual Bool isAttached () const;
00182     virtual Bool isFillable () const;
00183     virtual void setShape (Int nCorrelations, Int nChannels, Int nRows, Bool clearTheCache = True);
00184     virtual void validateShapes () const;
00185 
00186     virtual void writeChangesBack ();
00187     virtual void initWeightSpectrum (const Cube<Float>& wtspec);
00188     virtual void initSigmaSpectrum (const Cube<Float>& sigspec);
00189 
00190     //--> This needs to be removed: virtual Bool fetch(const asyncio::PrefetchColumns *pfc);
00191 
00192     // feed1_pa() and feed2_pa() return an array of parallactic angles
00193     // (each corresponds to the first receptor of the feed) one for each
00194     // row in the current buffer. In contrast, feed_pa() calculates
00195     // the angles for each antenna. These methods are implemented for
00196     // VisBufferImpl2 only to benefit from caching of the feed and antenna IDs.
00197 
00198     // Note that feed_pa is a function instead of a cached value
00199     virtual const Vector<Float> & feedPa (Double time) const;
00200 
00201     // NOMINAL parallactic angle (feed p.a. offset NOT included)
00202     virtual Float parang0(Double time) const;
00203     virtual const Vector<Float> & parang(Double time) const;
00204 
00205     virtual MDirection azel0(Double time) const; // function rather than cached value
00206     virtual const Vector<MDirection> & azel(Double time) const;
00207 
00208     // Hour angle for specified time
00209     virtual Double hourang(Double time) const;
00210 
00211     // Sort/unsort the correlations, if necessary
00212     //  (Rudimentary handling of non-canonically sorted correlations--use with care!)
00213     virtual void sortCorr ();
00214     virtual void unSortCorr();
00215 
00216     // Normalize the visCube by the modelVisCube
00217     //   (and optionally also divide visCube_p by its normalized amp)
00218 
00219     virtual void normalize ();
00220 
00221     // Rotate visibility phase for given vector (dim = nrow of vb) of phases (metres)
00222     virtual void phaseCenterShift(const Vector<Double>& phase);
00223     // Rotate visibility phase for phase center offsets (arcsecs)
00224     virtual void phaseCenterShift(Double dx, Double dy);
00225 
00226     // Fill weightMat according to sigma column
00227     virtual void resetWeightsUsingSigma ();//virtual void resetWeightMat();
00228 
00229     // Rotate visibility phase for given vector (dim = nrow of vb) of phases (metres)
00230 
00231     // Update coordinate info - useful for copied VisBufferImpl2s that need
00232     // to retain some state for later reference.
00233     // Presently this fills antenna, array, field and spectralWindow ids, time,
00234     // frequency and number of rows.
00235     // if dirDependent is set to False the expensive direction dependent calculation of parallactic or direction of
00236     // antenna from pointing table is avoided
00237     //Add more as needed.
00238 
00239     virtual Bool isNewArrayId () const;
00240     virtual Bool isNewFieldId () const;
00241     virtual Bool isNewMs() const;
00242     virtual Bool isNewSpectralWindow () const;
00243     virtual Bool isRekeyable () const;
00244     virtual Bool isWritable () const;
00245     virtual IPosition getShape () const;
00246     virtual Int msId() const;
00247     virtual String msName (Bool stripPath = False) const;
00248     virtual Subchunk getSubchunk () const;
00249 
00250     virtual Bool areCorrelationsSorted() const;
00251     virtual IPosition getValidShape (Int) const;
00252     virtual VisModelDataI * getVisModelData() const;
00253 
00254 
00256     //
00257     //  Data accessors and setters (where appropriate)
00258     //
00259     //  There are the methods that allows access to the items cached in the
00260     //  VisBuffer.  The straight accessors provide read-only access to the
00261     //  item.  Where the item is allowed to be modified, one or more set
00262     //  methods are provided.  N.B.: the VB usually caches the information
00263     //  in the representation requested so that using a setter to modify
00264     //  a value (e.g., weight vs. weightMat) will not modify the cached value
00265     //  in a different representation.
00266 
00267     virtual const Vector<Int> & antenna1 () const;
00268     virtual void setAntenna1 (const Vector<Int> & value);
00269     virtual const Vector<Int> & antenna2 () const;
00270     virtual void setAntenna2 (const Vector<Int> & value);
00271     virtual const Vector<Int> & arrayId () const;
00272     virtual void setArrayId (const Vector<Int> &);
00273     virtual const Vector<SquareMatrix<Complex, 2> > & cjones () const;
00274     virtual const Vector<Int> & correlationTypes () const;
00275 //    virtual Int dataDescriptionId () const;
00276 //    virtual void setDataDescriptionId (Int value);
00277     virtual const Vector<Int> & dataDescriptionIds () const;
00278     virtual void setDataDescriptionIds (const Vector<Int> & ); // [nR]
00279     virtual const Vector<MDirection> & direction1 () const;
00280     virtual const Vector<MDirection> & direction2 () const;
00281     virtual const Vector<Double> & exposure () const;
00282     virtual void setExposure (const Vector<Double> & value);
00283     virtual const Vector<Int> & feed1 () const;
00284     virtual void setFeed1 (const Vector<Int> & value);
00285     virtual const Vector<Float> & feedPa1 () const;
00286     virtual const Vector<Int> & feed2 () const;
00287     virtual void setFeed2 (const Vector<Int> & value);
00288     virtual const Vector<Float> & feedPa2 () const;
00289     virtual const Vector<Int> & fieldId () const;
00290     virtual void setFieldId (const Vector<Int> &);
00291 //    virtual const Matrix<Bool> & flag () const;
00292 //    virtual void setFlag (const Matrix<Bool>&);
00293     virtual const Array<Bool> & flagCategory () const;
00294     virtual void setFlagCategory (const Array<Bool>&);
00295     virtual const Cube<Bool> & flagCube () const;
00296     virtual void setFlagCube (const Cube<Bool>&);
00297     virtual const Vector<Bool> & flagRow () const;
00298     virtual void setFlagRow (const Vector<Bool>&);
00299     virtual const Matrix<Float> & imagingWeight () const;
00300     void setImagingWeight (const Matrix<Float> & newImagingWeights);
00301     virtual Int nAntennas () const;
00302     virtual Int nChannels () const;
00303     virtual Int nCorrelations () const;
00304     virtual Int nRows () const;
00305     virtual const Vector<Int> & observationId () const;
00306     virtual void setObservationId (const Vector<Int> & value);
00307     virtual const MDirection& phaseCenter () const;
00308     virtual Int polarizationFrame () const;
00309     virtual Int polarizationId () const;
00310     virtual const Vector<Int> & processorId () const;
00311     virtual void setProcessorId (const Vector<Int> & value);
00312     virtual const Vector<uInt> & rowIds () const;
00313     virtual const Vector<Int> & scan () const;
00314     virtual void setScan (const Vector<Int> & value);
00315     virtual const Matrix<Float> & sigma () const;
00316     virtual void setSigma (const Matrix<Float> &);
00317     //virtual const Matrix<Float> & sigmaMat () const;
00318     //virtual Int spectralWindow () const;
00319     virtual const Vector<Int> & spectralWindows () const;
00320     virtual void setSpectralWindows (const Vector<Int> & spectralWindows);
00321     virtual const Vector<Int> & stateId () const;
00322     virtual void setStateId (const Vector<Int> & value);
00323     virtual const Vector<Double> & time () const;
00324     virtual void setTime (const Vector<Double> & value);
00325     virtual const Vector<Double> & timeCentroid () const;
00326     virtual void setTimeCentroid (const Vector<Double> & value);
00327     virtual const Vector<Double> & timeInterval () const;
00328     virtual void setTimeInterval (const Vector<Double> & value);
00329     virtual const Matrix<Double> & uvw () const;
00330     virtual void setUvw (const Matrix<Double> & value);
00331     virtual const Cube<Complex> & visCubeCorrected () const;
00332     virtual void setVisCubeCorrected (const Cube<Complex> &);
00333 //    virtual const Matrix<CStokesVector> & visCorrected () const;
00334 //    virtual void setVisCorrected (const Matrix<CStokesVector> &);
00335     virtual const Cube<Float> & visCubeFloat () const;
00336     virtual void setVisCubeFloat (const Cube<Float> &);
00337     virtual const Cube<Complex> & visCubeModel () const;
00338     virtual void setVisCubeModel (const Complex & c);
00339     virtual void setVisCubeModel (const Cube<Complex>& vis);
00340     virtual void setVisCubeModel(const Vector<Float>& stokes);  // by supplied Stokes vector
00341 //    virtual const Matrix<CStokesVector> & visModel () const;
00342 //    virtual void setVisModel (Matrix<CStokesVector> &);
00343     virtual const Cube<Complex> & visCube () const;
00344     virtual void setVisCube(const Complex & c);
00345     virtual void setVisCube (const Cube<Complex> &);
00346 //    virtual const Matrix<CStokesVector> & vis () const;
00347 //    virtual void setVis (Matrix<CStokesVector> &);
00348     virtual const Matrix<Float> & weight () const;
00349     virtual void setWeight (const Matrix<Float>&);
00350     virtual const Cube<Float> & weightSpectrum () const;
00351     virtual void setWeightSpectrum (const Cube<Float>&);
00352     virtual const Cube<Float> & sigmaSpectrum () const;
00353     virtual void setSigmaSpectrum (const Cube<Float>& value);
00354 
00355 protected:
00356 
00357     // Create empty VisBufferImpl2 you can assign to or attach.
00358     VisBufferImpl2 (VisBufferOptions options = VbNoOptions);
00359     // Construct VisBufferImpl2 for a particular ViImplementation2
00360     // The buffer will remain synchronized with the iterator.
00361 
00362     VisBufferImpl2(ViImplementation2 * iter, VisBufferOptions options);
00363 
00364     // Attach to a VisIter. Detaches itself first if already attached
00365     // to a VisIter. Will remain synchronized with iterator.
00366 
00367     //virtual void cacheCopy (const VisBufferImpl2 & other, Bool markAsCached);
00368 
00369     void adjustWeightFactorsAndFlags (Matrix <Float> & rowWeightFactors,
00370                                       Bool useWeightSpectrum,
00371                                       Int nRows,
00372                                       Int nCorrelations,
00373                                       Int nChannelsOut);
00374     void adjustWeightAndSigmaMatrices (Int nChannelsAveraged, Int nChannelsOut, Int nRows,
00375                                        Int nCorrelations, Int nChannelsSelected,
00376                                        const Matrix <Float> & rowWeightFactors);
00377 
00378     Int averageChannelFrequencies (Int nChannelsOut,
00379                                    const Vector<Int> & channels,
00380                                    const Matrix<Int> & averagingBounds);
00381 
00382     void averageFlagInfoChannels (const Matrix<Int> & averagingBounds,
00383                                   Int nChannelsOut, Bool useWeightSpectrum);
00384 
00385     template<typename T>
00386     void averageVisCubeChannels (T & dataCache,
00387                                  Int nChanOut,
00388                                  const Matrix<Int>& averagingbounds);
00389 
00390     virtual void cacheClear (Bool markAsCached = False);
00391     virtual void cacheResizeAndZero (const VisBufferComponents2 & exclusions = VisBufferComponents2());
00392 
00393     virtual void checkVisIter (const char * func, const char * file, int line, const char * extra = "") const;
00394     void computeRowWeightFactors (Matrix <Float> & rowWeightFactors, Bool useWeightSpectrum);
00395     virtual void configureNewSubchunk (Int msId, const String & msName, Bool isNewMs,
00396                                        Bool isNewArrayId, Bool isNewFieldId,
00397                                        Bool isNewSpectralWindow, const Subchunk & subchunk,
00398                                        Int nRows, Int nChannels, Int nCorrelations,
00399                                        const Vector<Int> & correlations,
00400                                        const Vector<Stokes::StokesTypes> & correlationsDefined,
00401                                        const Vector<Stokes::StokesTypes> & correlationsSelected,
00402                                        CountedPtr<WeightScaling> weightScaling);
00403 
00404     virtual void copyRow (Int sourceRow, Int destinationRow);
00405     virtual void deleteRows (const Vector<Int> & rowsToDelete);
00406     virtual void dirtyComponentsAdd (const VisBufferComponents2 & additionalDirtyComponents);
00407     virtual void dirtyComponentsAdd (VisBufferComponent2 component);
00408     virtual void dirtyComponentsClear ();
00409     virtual VisBufferComponents2 dirtyComponentsGet () const;
00410     virtual void dirtyComponentsSet (const VisBufferComponents2 & dirtyComponents);
00411     virtual void dirtyComponentsSet (VisBufferComponent2 component);
00412     virtual Bool hasShape () const;
00413     void normalizeRow (Int row, Int nCorrelations, const Cube<Bool> & flagged,
00414                        Cube<Complex> & visCube, Cube<Complex> & modelCube,
00415                         Matrix<Float> & weightMat);
00416 
00417     virtual void sortCorrelationsAux (Bool makeSorted);
00418     virtual ViImplementation2 * getViiP () const; // protected, non-const access to VI
00419     void registerCacheItem (VbCacheItemBase *);
00420     virtual void resizeRows (Int newNRows);
00421     virtual void stateCopy (const VisBufferImpl2 & other); // copy relevant noncached members
00422     virtual void setFillable (Bool isFillable);
00423     virtual void setRekeyable (Bool isRekeyable);
00424     virtual bool setWritability (Bool newWritability) override;
00425     virtual void setupValidShapes ();
00426     template <typename Coord>
00427     void updateCoord (Coord & item, const Coord & otherItem);
00428 
00429     virtual Vector<Bool> & flagRowRef ();  // [nR]
00430     virtual Cube<Bool> & flagCubeRef ();  // [nC,nF,nR]
00431     virtual Cube<Complex> & visCubeRef (); // [nC,nF,nR]
00432     virtual Cube<Complex> & visCubeCorrectedRef (); // [nC,nF,nR]
00433     virtual Cube<Complex> & visCubeModelRef (); // [nC,nF,nR]
00434     virtual Cube<Float> & weightSpectrumRef (); // [nC,nF,nR]
00435     virtual Cube<Float> & sigmaSpectrumRef (); // [nC,nF,nR]
00436 
00437     Float getWeightScaled (Int row) const;
00438     Float getWeightScaled (Int correlation, Int row) const;
00439     Float getWeightScaled (Int correlation, Int channel, Int row) const;
00440     Float getSigmaScaled (Int row) const;
00441     Float getSigmaScaled (Int correlation, Int row) const;
00442     Float getSigmaScaled (Int correlation, Int channel, Int row) const;
00443     virtual CountedPtr<WeightScaling> getWeightScaling () const;
00444     void setIterationInfo (Int msId, const String & msName, Bool isNewMs,
00445                            Bool isNewArrayId, Bool isNewFieldId, Bool isNewSpectralWindow,
00446                            const Subchunk & subchunk, const Vector<Int> & correlations,
00447                            const Vector<Stokes::StokesTypes> & correlationsDefined,
00448                            const Vector<Stokes::StokesTypes> & correlationsSelected,
00449                            CountedPtr <WeightScaling> weightScaling);
00450     Bool weightSpectrumPresent () const;
00451     Bool sigmaSpectrumPresent () const;
00452 
00453 private:
00454 
00455     virtual Bool areCorrelationsInCanonicalOrder () const;
00456     void checkVisIterBase (const char * func, const char * file, int line, const char * extra = "") const;
00457     void construct(ViImplementation2 * vi, VisBufferOptions options);
00458     void constructCache();
00459     virtual void validate();
00460 
00462     //
00463     //  Fillers
00464     //
00465     // These methods fill the needed value into the cache.  This
00466     // usually means getting it from the attached ViImplementation2
00467     // but the needed value can be generated as well.
00468     //
00469     // The name of the filler should match up with the accessor method
00470     // (see above) as well as the member name in the cache (see
00471     // VisBufferCache class in VisBuffer.cc).
00472 
00473 
00474     virtual void fillAntenna1 (Vector<Int>& value) const;
00475     virtual void fillAntenna2 (Vector<Int>& value) const;
00476     virtual void fillArrayId (Vector<Int>& value) const;
00477     virtual void fillCorrType (Vector<Int>& value) const;
00478     virtual void fillCubeCorrected (Cube <Complex> & value) const;
00479     virtual void fillCubeModel (Cube <Complex> & value) const;
00480     virtual void fillCubeObserved (Cube <Complex> & value) const;
00481     virtual void fillDataDescriptionId  (Int& value) const;
00482     virtual void fillDataDescriptionIds  (Vector<Int>& value) const;
00483     virtual void fillDirection1 (Vector<MDirection>& value) const;
00484     virtual void fillDirection2 (Vector<MDirection>& value) const;
00485     virtual void fillDirectionAux (Vector<MDirection>& value,
00486                            const Vector<Int> & antenna,
00487                            const Vector<Int> &feed,
00488                            const Vector<Float> & feedPa) const;
00489     virtual void fillExposure (Vector<Double>& value) const;
00490     virtual void fillFeed1 (Vector<Int>& value) const;
00491     virtual void fillFeed2 (Vector<Int>& value) const;
00492     virtual void fillFeedPa1 (Vector <Float> & feedPa) const;
00493     virtual void fillFeedPa2 (Vector <Float> & feedPa) const;
00494     virtual void fillFeedPaAux (Vector <Float> & feedPa,
00495                         const Vector <Int> & antenna,
00496                         const Vector <Int> & feed) const;
00497     virtual void fillFieldId (Vector<Int>& value) const;
00498     virtual void fillFlag (Matrix<Bool>& value) const;
00499     virtual void fillFlagCategory (Array<Bool>& value) const;
00500     virtual void fillFlagCube (Cube<Bool>& value) const;
00501     virtual void fillFlagRow (Vector<Bool>& value) const;
00502     virtual void fillFloatData (Cube<Float>& value) const;
00503     virtual void fillImagingWeight (Matrix<Float> & value) const;
00504     virtual void fillJonesC (Vector<SquareMatrix<Complex, 2> >& value) const;
00505     virtual void fillNAntennas (Int& value) const;
00506     virtual void fillNChannel (Int& value) const;
00507     virtual void fillNCorr (Int& value) const;
00508     virtual void fillNRow (Int& value) const;
00509     virtual void fillObservationId (Vector<Int>& value) const;
00510     virtual void fillPhaseCenter (MDirection& value) const;
00511     virtual void fillPolFrame (Int& value) const;
00512     virtual void fillPolarizationId (Int& value) const;
00513     virtual void fillProcessorId (Vector<Int>& value) const;
00514     virtual void fillRowIds (Vector<uInt>& value) const;
00515     virtual void fillScan (Vector<Int>& value) const;
00516     virtual void fillSigma (Matrix<Float>& value) const;
00517     //virtual void fillSigmaMat (Matrix<Float>& value) const;
00518     //virtual void fillSpectralWindow (Int& value) const;
00519     virtual void fillSpectralWindows  (Vector<Int>& value) const;
00520     virtual void fillStateId (Vector<Int>& value) const;
00521     virtual void fillTime (Vector<Double>& value) const;
00522     virtual void fillTimeCentroid (Vector<Double>& value) const;
00523     virtual void fillTimeInterval (Vector<Double>& value) const;
00524     virtual void fillUvw (Matrix<Double>& value) const;
00525 //    virtual void fillVisibilityCorrected (Matrix<CStokesVector>& value) const;
00526 //    virtual void fillVisibilityModel (Matrix<CStokesVector>& value) const;
00527 //    virtual void fillVisibilityObserved (Matrix<CStokesVector>& value) const;
00528     virtual void fillWeight (Matrix<Float>& value) const;
00529     //virtual void fillWeightMat (Matrix<Float>& value) const;
00530     virtual void fillWeightSpectrum (Cube<Float>& value) const;
00531     virtual void fillSigmaSpectrum (Cube<Float>& value) const;
00532 
00533     VisBufferCache * cache_p;
00534     casa::ms::Vbi2MsRow * msRow_p;
00535     VisBufferState * state_p;
00536 };
00537 
00538 } // end namespace vi
00539 
00540 } // end namespace casa
00541 
00542 
00543 #endif
00544