VisBuffer2Adapter.h

Go to the documentation of this file.
00001 /*
00002  * VisBuffer2Adapter.h
00003  *
00004  *  Created on: Oct 9, 2012
00005  *      Author: jjacobs
00006  */
00007 
00008 #ifndef VISBUFFER2ADAPTER_H_
00009 #define VISBUFFER2ADAPTER_H_
00010 
00011 #include <msvis/MSVis/VisBuffer.h>
00012 #include <msvis/MSVis/VisBuffer2.h>
00013 #include <casa/BasicSL/String.h>
00014 #include <msvis/MSVis/UtilJ.h>
00015 #include <msvis/MSVis/VisibilityIterator2.h>
00016 #include <msvis/MSVis/VisibilityIteratorImpl2.h>
00017 
00018 using casa::utilj::toStdError;
00019 
00020 #define IllegalOperation() \
00021     Throw (String::format ("Illegal operation: %s", __func__));
00022 
00023 #define CheckWritability() \
00024     ThrowIf (vb2Rw_p == 0, String::format ("VB is not writable in %s", __func__));
00025 
00026 namespace casa {
00027 
00028 namespace vi {
00029 
00030 class VisBuffer2Adapter : public VisBuffer {
00031 
00032 public:
00033 
00034     VisBuffer2Adapter (VisBuffer2 * vb) : vb2_p (vb) , vb2Rw_p (vb)
00035     {
00036         construct();
00037     }
00038     VisBuffer2Adapter (const VisBuffer2 * vb) : msColumns_p (0), vb2_p (vb), vb2Rw_p (0)
00039     {
00040         construct();
00041     }
00042 
00043     void
00044     construct ()
00045     {
00046         const VisibilityIteratorImpl2 * vi =
00047             dynamic_cast<const VisibilityIteratorImpl2 *> (vb2_p->getVi()->getImpl());
00048 
00049         msColumns_p = vi->msColumnsKluge();
00050 
00051         vi->allSpectralWindowsSelected (spectralWindows_p, nChannels_p);
00052 
00053     }
00054 
00055     ~VisBuffer2Adapter () {}
00056 
00057     virtual VisBuffer & assign(const VisBuffer &, Bool = True) {IllegalOperation();}
00058 
00059     virtual VisBuffer * clone () const {IllegalOperation();}
00060 
00061     virtual void invalidate(){IllegalOperation();}
00062 
00063 //#if 0
00064 
00065     // <group>
00066     // Access functions
00067     //
00068     virtual Int & nCorr() { nCorr_p = vb2_p->nCorrelations(); return nCorr_p;}
00069     virtual Int nCorr() const { return vb2_p-> nCorrelations(); }
00070 
00071     virtual Int & nChannel() { nChannelsScalar_p = vb2_p-> nChannels(); return nChannelsScalar_p;}
00072     virtual Int nChannel() const { return vb2_p-> nChannels(); }
00073 
00074     virtual Vector<Int>& channel() { IllegalOperation (); }
00075     virtual const Vector<Int>& channel() const { IllegalOperation(); }
00076 
00077     virtual Int & nRow() { nRows_p = vb2_p->nRows (); return nRows_p;}
00078 
00079     virtual Vector<Int>& antenna1() { return const_cast<Vector<Int>&> (vb2_p-> antenna1());}
00080     virtual const Vector<Int>& antenna1() const { return vb2_p-> antenna1(); }
00081 
00082     virtual Vector<Int>& antenna2() { return const_cast<Vector<Int>&> (vb2_p-> antenna2());}
00083     virtual const Vector<Int>& antenna2() const { return vb2_p-> antenna2(); }
00084 
00085     virtual Vector<Int>& feed1() { return const_cast<Vector<Int>&> (vb2_p-> feed1());}
00086     virtual const Vector<Int>& feed1() const { return vb2_p-> feed1(); }
00087 
00088     virtual Vector<Int>& feed2() { return const_cast<Vector<Int>&> (vb2_p-> feed2());}
00089     virtual const Vector<Int>& feed2() const { return vb2_p-> feed2(); }
00090 
00091     // feed1_pa() and feed2_pa() return an array of parallactic angles
00092     // (each corresponds to the first receptor of the feed) one for each
00093     // row in the current buffer. In contrast, feed_pa() calculates
00094     // the angles for each antenna. These methods are implemented for
00095     // VisBuffer only to benefit from caching of the feed and antenna IDs.
00096 
00097     virtual Vector<Float>& feed1_pa() { IllegalOperation (); }
00098     virtual const Vector<Float>& feed1_pa() const { return vb2_p-> feedPa1(); }
00099 
00100     virtual Vector<Float>& feed2_pa() { IllegalOperation (); }
00101     virtual const Vector<Float>& feed2_pa() const { return vb2_p-> feedPa2(); }
00102 
00103     virtual Vector<SquareMatrix<Complex, 2> >& CJones() { IllegalOperation (); }
00104     virtual const Vector<SquareMatrix<Complex, 2> >& CJones() const { return vb2_p-> cjones(); }
00105 
00106     // Note that feed_pa is a function instead of a cached value
00107     virtual Vector<Float> feed_pa(Double time) const{ return vb2_p-> feedPa (time); }
00108 
00109     // direction1() and direction2() return arrays of directions where
00110     // the first and the second antenna/feed are pointed to. One value for
00111     // each row in the current buffer.
00112     virtual Vector<MDirection>& direction1() { IllegalOperation (); }
00113     virtual const Vector<MDirection>& direction1()  const { return vb2_p-> direction1(); }
00114 
00115     virtual Vector<MDirection>& direction2() { IllegalOperation (); }
00116     virtual const Vector<MDirection>& direction2()  const { return vb2_p-> direction2(); }
00117 
00118 
00119     // NOMINAL parallactic angle (feed p.a. offset NOT included)
00120     virtual Float parang0(Double time) const{ return vb2_p-> parang0(time); }
00121     virtual Vector<Float> parang(Double time) const{ return vb2_p-> parang(time); }
00122 
00123     // Note that azel is a function instead of a cached value
00124     virtual MDirection azel0(Double time) const{ return vb2_p-> azel0(time); }
00125     virtual Vector<Double>& azel0Vec(Double , Vector<Double>& ) const{ IllegalOperation(); }
00126     virtual Vector<MDirection> azel(Double time) const{ return vb2_p-> azel(time); }
00127     virtual Matrix<Double>& azelMat(Double , Matrix<Double>& ) const{ IllegalOperation(); }
00128 
00129     // Hour angle for specified time
00130     virtual Double hourang(Double time) const{ return vb2_p-> hourang(time); }
00131 
00132     virtual Int fieldId() const { return vb2_p-> fieldId()(0); }
00133 
00134     virtual Int& fieldIdRef() { IllegalOperation(); }
00135 
00136     virtual Int& arrayIdRef() { IllegalOperation(); }
00137 
00138     virtual Int arrayId() const { return vb2_p-> arrayId()(0); }
00139 
00140     // Return flag for each channel & row
00141     virtual Matrix<Bool>& flag() { IllegalOperation(); }
00142     virtual const Matrix<Bool>& flag() const { IllegalOperation(); }
00143 
00144     // Return flag for each polarization, channel and row
00145     virtual Cube<Bool>& flagCube() { return const_cast<Cube<Bool>&> (vb2_p-> flagCube());}
00146     virtual const Cube<Bool>& flagCube() const { return vb2_p-> flagCube(); }
00147 
00148     virtual Vector<Bool>& flagRow() { return const_cast<Vector<Bool>&> (vb2_p-> flagRow());}
00149     virtual const Vector<Bool>& flagRow() const { return vb2_p-> flagRow(); }
00150 
00151     // Return flags for each polarization, channel, category, and row.
00152     virtual Array<Bool>& flagCategory() { IllegalOperation (); }
00153     virtual const Array<Bool>& flagCategory() const { return vb2_p-> flagCategory(); }
00154 
00155     virtual Vector<Int>& scan() { return const_cast<Vector<Int>&> (vb2_p-> scan());}
00156     virtual const Vector<Int>& scan() const { return vb2_p-> scan(); }
00157 
00158     // scalar version for convenience, when scan known constant for
00159     // entire iteration/buffer.
00160     virtual Int scan0() { IllegalOperation(); }
00161 
00162     virtual Vector<Int>& processorId() { return const_cast<Vector<Int>&> (vb2_p-> processorId());}
00163     virtual const Vector<Int>& processorId() const { return vb2_p-> processorId(); }
00164 
00165     virtual Vector<Int>& observationId() { return const_cast<Vector<Int>&> (vb2_p-> observationId());}
00166     virtual const Vector<Int>& observationId() const { return vb2_p-> observationId(); }
00167 
00168     virtual Vector<Int>& stateId() { return const_cast<Vector<Int>&> (vb2_p-> stateId());}
00169     virtual const Vector<Int>& stateId() const { return vb2_p-> stateId(); }
00170 
00171     // Gets SPECTRAL_WINDOW/CHAN_FREQ (in Hz, acc. to the MS def'n v.2).
00172     virtual Vector<Double>& frequency() {
00173         return const_cast<Vector<Double>&> (vb2_p->getFrequencies(0));
00174     }
00175     virtual const Vector<Double>& frequency() const
00176     {
00177         return vb2_p->getFrequencies(0);
00178     }
00179 
00180     //if ignoreconv=True..frequency is served as is in the data frame
00181     virtual void lsrFrequency(const Int & spw, Vector<Double>& freq, Bool & convert,
00182                               const Bool ignoreConv = False) const
00183     {
00184         const VisibilityIteratorImpl2 * vi =
00185             dynamic_cast<const VisibilityIteratorImpl2 *> (vb2_p->getVi()->getImpl());
00186 
00187         Int frame = -1;
00188         if (ignoreConv){
00189             frame = vi->getObservatoryFrequencyType ();
00190         }
00191         else{
00192             frame = MFrequency::LSRK;
00193         }
00194 
00195         convert = frame != MFrequency::LSRK; // make this parameter write-only
00196 
00197         freq = vi->getFrequencies (this->time()(0), frame, spw, vi->msId());
00198     }
00199 
00200     virtual Int numberCoh () const { IllegalOperation(); }
00201 
00202     virtual MDirection & phaseCenter() { IllegalOperation (); }
00203     virtual MDirection phaseCenter() const { return vb2_p-> phaseCenter(); }
00204 
00205     virtual Int polFrame() const { return vb2_p-> polarizationFrame(); }
00206 
00207     virtual Vector<Int>& corrType() { return const_cast<Vector<Int> &> (vb2_p-> correlationTypes()); }
00208     virtual const Vector<Int>& corrType() const { return vb2_p-> correlationTypes(); }
00209 
00210     virtual Vector<Float>& sigma() { IllegalOperation (); }
00211     virtual const Vector<Float>& sigma() const { IllegalOperation(); }
00212 
00213     virtual Matrix<Float>& sigmaMat() { IllegalOperation (); }
00214     virtual const Matrix<Float>& sigmaMat() const { return vb2_p-> sigma(); }
00215 
00216     virtual Int & spectralWindow() { spectralWindow_p = vb2_p->spectralWindows()(0); return spectralWindow_p;}
00217     virtual Int spectralWindow() const { return vb2_p-> spectralWindows()(0); }
00218     virtual Int polarizationId() const { return vb2_p-> polarizationId(); }
00219     virtual Int& dataDescriptionIdRef() { IllegalOperation(); }
00220     virtual Int dataDescriptionId() const { return vb2_p-> dataDescriptionIds()(0); }
00221     virtual Vector<Double>& time() { IllegalOperation (); }
00222     virtual const Vector<Double>& time() const { return vb2_p-> time(); }
00223 
00224     virtual Vector<Double>& timeCentroid() { IllegalOperation (); }
00225     virtual const Vector<Double>& timeCentroid() const { return vb2_p-> timeCentroid(); }
00226 
00227     virtual Vector<Double>& timeInterval() { IllegalOperation (); }
00228     virtual const Vector<Double>& timeInterval() const { return vb2_p-> timeInterval(); }
00229 
00230     virtual Vector<Double>& exposure() { IllegalOperation (); }
00231     virtual const Vector<Double>& exposure() const { return vb2_p-> exposure(); }
00232 
00233     virtual Vector<RigidVector<Double, 3> >& uvw()
00234     {
00235         if (uvw_p.empty()){
00236 
00237             fillUvw ();
00238 
00239         }
00240 
00241         return uvw_p;
00242     }
00243 
00244     virtual const Vector<RigidVector<Double, 3> >& uvw() const
00245     {
00246         if (uvw_p.empty()){
00247 
00248             fillUvw ();
00249 
00250         }
00251 
00252         return uvw_p;
00253     }
00254 
00255     void
00256     fillUvw() const {
00257 
00258         const Matrix<Double> & u = vb2_p->uvw();
00259 
00260         Int nRows = u.shape()(1);
00261         uvw_p.resize (nRows);
00262 
00263         for (Int i = 0; i < nRows; i++){
00264             RigidVector<Double,3> t;
00265             for (Int j = 0; j < 3; j++){
00266                 t (j) = u (j, i);
00267             }
00268             uvw_p (i) = t;
00269         }
00270     }
00271 
00272 
00273     virtual Matrix<Double>& uvwMat() { IllegalOperation (); }
00274     virtual const Matrix<Double>& uvwMat() const { return vb2_p-> uvw(); }
00275 
00276     virtual Matrix<CStokesVector>& visibility() { IllegalOperation (); }
00277     virtual const Matrix<CStokesVector>& visibility() const { IllegalOperation (); }
00278 
00279     virtual Matrix<CStokesVector>& modelVisibility() { IllegalOperation (); }
00280     virtual const Matrix<CStokesVector>& modelVisibility() const { IllegalOperation (); }
00281 
00282     virtual Matrix<CStokesVector>& correctedVisibility() { IllegalOperation (); }
00283     virtual const Matrix<CStokesVector>& correctedVisibility() const { IllegalOperation (); }
00284 
00285     virtual Cube<Complex>& visCube() { IllegalOperation (); }
00286     virtual const Cube<Complex>& visCube() const { return vb2_p-> visCube(); }
00287 
00288     virtual Cube<Complex>& modelVisCube() { return const_cast<Cube<Complex> &> (vb2_p->visCubeModel()); }
00289 
00290     virtual Cube<Complex>& modelVisCube(const Bool & ) { IllegalOperation (); }
00291 
00292     virtual const Cube<Complex>& modelVisCube() const { return vb2_p->visCubeModel(); }
00293 
00294     virtual Cube<Complex>& correctedVisCube() { IllegalOperation(); }
00295     virtual const Cube<Complex>& correctedVisCube() const { return vb2_p-> visCubeCorrected(); }
00296 
00297     // Return visCube(), modelVisCube(), or correctedVisCube(),
00298     // according to whichcol.  They throw an exception if whichcol is
00299     // unsupported, but note the encouraged default.
00300     // TODO: Optionally return DATA if whichcol is unavailable.
00301     Cube<Complex>& dataCube(const MS::PredefinedColumns whichcol=MS::DATA);
00302     const Cube<Complex>& dataCube(const MS::PredefinedColumns
00303                                   whichcol=MS::DATA) const;
00304 
00305     virtual Cube<Float>& floatDataCube() { IllegalOperation(); }
00306     virtual const Cube<Float>& floatDataCube() const { return vb2_p-> visCubeFloat (); }
00307 
00308     // Returns the weights for each row averaged over the parallel hand correlations.
00309     virtual Vector<Float>& weight() { IllegalOperation(); }
00310     virtual const Vector<Float>& weight() const { IllegalOperation(); }
00311 
00312     // Returns the nPol_p x curNumRow_p weight matrix.
00313     virtual Matrix<Float>& weightMat() { IllegalOperation(); }
00314     virtual const Matrix<Float>& weightMat() const { return vb2_p-> weight(); }
00315 
00316     // Is a valid WEIGHT_SPECTRUM available?
00317     virtual Bool existsWeightSpectrum() const { IllegalOperation(); }
00318 
00319     virtual Cube<Float>& weightSpectrum() { IllegalOperation();; }
00320     virtual const Cube<Float>& weightSpectrum() const { return vb2_p-> weightSpectrum(); }
00321 
00322     virtual Matrix<Float>& imagingWeight(){ IllegalOperation(); }
00323     virtual const Matrix<Float>& imagingWeight() const{ return vb2_p-> imagingWeight(); }
00324 
00325     virtual Cube<Float>& weightCube() { IllegalOperation(); }
00326     //</group>
00327 
00328     //<group>
00329     // Utility functions to provide coordinate or column ranges of the
00330     // data in the VisBuffer. Flagging is applied before computing the ranges.
00331     //
00332     // Generic accessor to column ranges of integer type, as specified by
00333     // enumerations defined in class MSCalEnums. Throws an exception
00334     // if the enum is not for a recognized integer column.
00335     virtual Vector<Int> vecIntRange(const MSCalEnums::colDef & ) const{ IllegalOperation(); }
00336 
00337     // Antenna id. range (includes both ANTENNA1 and ANTENNA2 columns)
00338     virtual Vector<Int> antIdRange() const{ IllegalOperation(); }
00339 
00340     // Time range
00341     virtual Bool timeRange(MEpoch & , MVEpoch & , MVEpoch & ) const
00342     { IllegalOperation(); }
00343 
00344     // Return the row Ids from the original ms. If the ms used is a subset of
00345     // another ms then rowIds() return the row ids of the original ms.
00346     virtual Vector<uInt>& rowIds(){ IllegalOperation(); }
00347 
00348     virtual const Vector<uInt>& rowIds() const { return vb2_p-> rowIds(); };
00349 
00350     //</group>
00351 
00352     // Frequency average the buffer (visibility() column only)
00353     virtual void freqAverage(){ IllegalOperation(); }
00354 
00355     // Frequency average the buffer (visCube and [if present] modelVisCube)
00356     void freqAveCubes(){ IllegalOperation(); }
00357 
00358     // Average channel axis according to chanavebounds, for whichever of DATA,
00359     // MODEL_DATA, CORRECTED_DATA, FLOAT_DATA, FLAG, and WEIGHT_SPECTRUM are
00360     // present.  It will only treat the first 5 as present if they have already
00361     // been loaded into the buffer!
00362     void channelAve(const Matrix<Int>& ){ IllegalOperation(); }
00363 
00364     // Average channel axis by factor.
00365     template<class T> void chanAveVisCube(Cube<T>& , Int ){ IllegalOperation(); }
00366 
00367     // Accumulate channel axis by factor, without applying WEIGHT_SPECTRUM even
00368     // if it is present.
00369     // It is primarily intended for averaging WEIGHT_SPECTRUM itself.
00370     template<class T> void chanAccCube(Cube<T>& , Int ){ IllegalOperation(); }
00371 
00372     // This defaults to no conceptual side effects, but usually it is more
00373     // efficient to let it leave weightSpectrum() in a channel averaged state.
00374     // restoreWeightSpectrum has no effect if !existsWeightSpectrum().
00375     virtual void chanAveFlagCube(Cube<Bool>& , const Int ,
00376                          const Bool  = True){ IllegalOperation(); }
00377 
00378     // Doesn't do anything if flagcat is degenerate.
00379     void chanAveFlagCategory(Array<Bool>& flagcat, const Int nChanOut);
00380 
00381     // Form Stokes parameters from correlations
00382     //  (these are preliminary versions)
00383     virtual void formStokes(){ IllegalOperation(); }
00384     virtual void formStokesWeightandFlag(){ IllegalOperation(); }
00385     virtual void formStokes(Cube<Complex>& ){ IllegalOperation(); }
00386     virtual void formStokes(Cube<Float>& ){ IllegalOperation(); }    // Will throw up if asked to do all 4.
00387 
00388     // Sort/unsort the correlations, if necessary
00389     //  (Rudimentary handling of non-canonically sorted correlations--use with care!)
00390     virtual void sortCorr(){ IllegalOperation(); }
00391     virtual void unSortCorr(){ IllegalOperation(); }
00392 
00393     // Normalize the visCube by the modelVisCube
00394     //   (and optionally also divide visCube_p by its normalized amp)
00395     virtual void normalize(const Bool &  = False){ CheckWritability(); vb2Rw_p-> normalize(); }
00396 
00397     // Fill weightMat according to sigma column
00398     virtual void resetWeightMat(){ IllegalOperation(); }
00399 
00400     // Rotate visibility phase for given vector (dim = nrow of vb) of phases (metres)
00401     virtual void phaseCenterShift(const Vector<Double>& ){ IllegalOperation(); }
00402     // Rotate visibility phase for phase center offsets (arcsecs)
00403     virtual void phaseCenterShift(Double , Double ){ IllegalOperation(); }
00404 
00405     // Update coordinate info - useful for copied VisBuffers that need
00406     // to retain some state for later reference.
00407     // Presently this fills antenna, array, field and spectralWindow ids, time,
00408     // frequency and number of rows.
00409     // if dirDependent is set to False the expensive direction dependent calculation of parallactic or direction of
00410     // antenna from pointing table is avoided
00411     //Add more as needed.
00412     virtual void updateCoordInfo(const VisBuffer *  = NULL, const Bool =True){ IllegalOperation(); }
00413 
00414     // Set the visibility to a constant, note that this only changes the buffer,
00415     // no values are written back to tables from here.
00416     virtual void setVisCube(Complex c){ CheckWritability(); vb2Rw_p-> setVisCube(c); }
00417     virtual void setModelVisCube(Complex c){ CheckWritability(); vb2Rw_p-> setVisCubeModel(c); }
00418     virtual void setCorrectedVisCube(Complex ){ IllegalOperation(); }
00419 
00420     // Set the visibility, note that this only changes the buffer,
00421     // no values are written back to tables from here.
00422     virtual void setVisCube(const Cube<Complex>& vis){ CheckWritability(); vb2Rw_p-> setVisCube(vis); }
00423     virtual void setModelVisCube(const Cube<Complex>& vis){ CheckWritability(); vb2Rw_p-> setVisCubeModel(vis); }
00424     virtual void setCorrectedVisCube(const Cube<Complex>& vis){ CheckWritability(); vb2Rw_p-> setVisCubeCorrected(vis); }
00425 
00426     // Like the above, but for FLOAT_DATA, keeping it as real floats.
00427     virtual void setFloatDataCube(const Cube<Float>& fcube){ CheckWritability(); vb2Rw_p-> setVisCubeFloat(fcube); }
00428 
00429     // Set model according to a Stokes vector
00430     virtual void setModelVisCube(const Vector<Float>& /*stokes*/){ IllegalOperation (); }
00431 
00432     // Reference external model visibilities
00433     virtual void refModelVis(const Matrix<CStokesVector>& ){ IllegalOperation(); }
00434 
00435     // Remove scratch cols data from vb
00436     virtual void removeScratchCols(){ IllegalOperation(); }
00437 
00438     // Access the current ROMSColumns object via VisIter
00439     virtual const ROMSColumns & msColumns() const
00440     {
00441         Assert (msColumns_p != 0);
00442         return * msColumns_p;
00443     }
00444 
00445     virtual  Int numberAnt () const{ return vb2_p-> nAntennas (); }
00446 
00447     // Get all selected spectral windows not just the one in the actual buffer
00448     virtual void allSelectedSpectralWindows(Vector<Int>& spectralWindows, Vector<Int>& nChannels)
00449     {
00450         spectralWindows.assign (spectralWindows_p);
00451         nChannels.assign (nChannels_p);
00452     }
00453 
00454     virtual void getChannelSelection(Block< Vector<Int> >& ,
00455                                    Block< Vector<Int> >& ,
00456                                    Block< Vector<Int> >& ,
00457                                    Block< Vector<Int> >& ,
00458                                    Block< Vector<Int> >& ) const { IllegalOperation(); }
00459     void allSelectedSpectralWindows(Vector<Int>& spws, Vector<Int>& nvischan) const ;
00460 
00461     // Return the actual msid, useful if using multiple ms to monitor which
00462     // ms in the  list is being dealt with
00463     virtual Int msId() const { return vb2_p-> msId(); }
00464 
00465     //checked if the ms has changed since the last chunk processed
00466     virtual Bool newMS() const { return vb2_p-> isNewMs(); }
00467     //get the name of the ms the buffer is at empty string if no visiter is attached
00468     virtual String msName(Bool =False) const{ return vb2_p-> msName(); }
00469 
00470     virtual Bool newArrayId () const{ return vb2_p-> isNewArrayId (); }
00471     virtual Bool newFieldId () const{ return vb2_p-> isNewFieldId (); }
00472     virtual Bool newSpectralWindow () const{ return vb2_p-> isNewSpectralWindow (); }
00473 
00474     //
00475 
00476 
00477 private:
00478 
00479 
00480     const ROMSColumns * msColumns_p; // [use]
00481     Vector<Int> nChannels_p;
00482     Int nChannelsScalar_p;
00483     Int nCorr_p;
00484     Int nRows_p;
00485     Int spectralWindow_p;
00486     Vector<Int> spectralWindows_p;
00487     mutable Vector<RigidVector<Double, 3> > uvw_p;
00488     const vi::VisBuffer2 * vb2_p; // [use]
00489     vi::VisBuffer2 * vb2Rw_p; // [use]
00490 
00491 };
00492 
00493 } // end namespace vi
00494 
00495 } // end namespace casa
00496 
00497 
00498 #endif /* VISBUFFER2ADAPTER_H_ */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 31 Aug 2016 for casa by  doxygen 1.6.1