Line data    Source code

       1             : /*
       2             :  * VisibilityIterator2.cc
       3             :  *
       4             :  *  Created on: Jun 4, 2012
       5             :  *      Author: jjacobs
       6             :  */
       7             : 
       8             : #include <msvis/MSVis/VisibilityIterator2.h>
       9             : 
      10             : #include <casacore/casa/Arrays/Cube.h>
      11             : #include <casacore/casa/Arrays/Matrix.h>
      12             : #include <casacore/casa/Arrays/Slicer.h>
      13             : #include <casacore/casa/BasicSL/String.h>
      14             : #include <casacore/casa/Quanta/MVDoppler.h>
      15             : #include <casacore/casa/aips.h>
      16             : #include <casacore/casa/System/AipsrcValue.h>
      17             : #include <casacore/measures/Measures/MCDoppler.h>
      18             : #include <casacore/measures/Measures/MDoppler.h>
      19             : #include <casacore/measures/Measures/MeasConvert.h>
      20             : #include <casacore/measures/Measures/Stokes.h>
      21             : #include <casacore/ms/MSOper/MSDerivedValues.h>
      22             : #include <casacore/ms/MeasurementSets/MSIter.h>
      23             : #include <casacore/ms/MeasurementSets/MeasurementSet.h>
      24             : #include <casacore/scimath/Mathematics/RigidVector.h>
      25             : #include <casacore/scimath/Mathematics/SquareMatrix.h>
      26             : #include <stdcasa/UtilJ.h>
      27             : #include <msvis/MSVis/AveragingTvi2.h>
      28             : #include <msvis/MSVis/ViFrequencySelection.h>
      29             : #include <msvis/MSVis/StokesVector.h>
      30             : #include <msvis/MSVis/VisBuffer2.h>
      31             : #include <msvis/MSVis/VisBufferComponents2.h>
      32             : #include <msvis/MSVis/VisImagingWeight.h>
      33             : #include <msvis/MSVis/VisibilityIteratorImpl2.h>
      34             : #include <msvis/MSVis/VisibilityIteratorImplAsync2.h>
      35             : #include <casacore/tables/Tables/ArrayColumn.h>
      36             : #include <casacore/tables/Tables/ScalarColumn.h>
      37             : 
      38             : #include <cstdarg>
      39             : #include <map>
      40             : #include <set>
      41             : #include <utility>
      42             : #include <vector>
      43             : 
      44             : using namespace std;
      45             : 
      46             : #define CheckImplementationPointer() Assert (impl_p != NULL);
      47             : 
      48             : using namespace casacore;
      49             : namespace casa {
      50             : 
      51             : namespace vi {
      52             : 
      53       10525 : SortColumns::SortColumns (const Block<Int> & columnIds, Bool addDefaultColumns)
      54             : : addDefaultColumns_p (addDefaultColumns),
      55             :   columnIds_p (columnIds),
      56       10525 :   usingDefaultSortingFunctions_p (true)
      57             : {
      58       29614 :     for (auto colId : columnIds)
      59       19089 :         sortingDefinition_p.push_back(
      60       38178 :             std::make_pair(MS::columnName(casacore::MS::PredefinedColumns(colId)), nullptr));
      61       10525 : }
      62             : 
      63        5434 : SortColumns::SortColumns (Bool usingDefaultSortingFunctions)
      64        5434 : : usingDefaultSortingFunctions_p (usingDefaultSortingFunctions)
      65             : {
      66        5434 : }
      67             : 
      68           0 : SortColumns::SortColumns (const std::vector<std::pair<casacore::MS::PredefinedColumns, std::shared_ptr<casacore::BaseCompare>>> sortingDefinition)
      69             : : addDefaultColumns_p (false),
      70           0 :   usingDefaultSortingFunctions_p (false)
      71             : {
      72           0 :     for (auto pair : sortingDefinition)
      73           0 :         sortingDefinition_p.push_back(
      74           0 :             std::make_pair(MS::columnName(pair.first), pair.second));
      75           0 : }
      76             : 
      77           0 : SortColumns::SortColumns (const std::vector<std::pair<casacore::String, std::shared_ptr<casacore::BaseCompare>>> sortingDefinition)
      78             : : addDefaultColumns_p (false),
      79             :   sortingDefinition_p(sortingDefinition),
      80           0 :   usingDefaultSortingFunctions_p (false)
      81             : {
      82           0 : }
      83             : 
      84        5434 : void SortColumns::addSortingColumn(casacore::MS::PredefinedColumns colId,
      85             :     std::shared_ptr<casacore::BaseCompare> sortingFunction)
      86             : {
      87        5434 :     if (usingDefaultSortingFunctions_p)
      88             :         throw AipsError("SortColumns invalid construction. "
      89           0 :                         "Cannot add generic sorting functions.");
      90        5434 :     sortingDefinition_p.push_back(
      91       10868 :         std::make_pair(MS::columnName(colId), sortingFunction));
      92        5434 :     usingDefaultSortingFunctions_p = false;
      93        5434 : }
      94             : 
      95           0 : void SortColumns::addSortingColumn(casacore::String colName,
      96             :     std::shared_ptr<casacore::BaseCompare> sortingFunction)
      97             : {
      98           0 :     if (usingDefaultSortingFunctions_p)
      99             :         throw AipsError("SortColumns invalid construction. "
     100           0 :                         "Cannot add generic sorting functions.");
     101           0 :     sortingDefinition_p.push_back(
     102           0 :         std::make_pair(colName, sortingFunction));
     103           0 :     usingDefaultSortingFunctions_p = false;
     104           0 : }
     105             : 
     106             : Bool
     107       10868 : SortColumns::shouldAddDefaultColumns () const
     108             : {
     109       10868 :     return addDefaultColumns_p;
     110             : }
     111             : 
     112             : bool
     113        5434 : SortColumns::usingDefaultSortingFunctions () const
     114             : {
     115        5434 :     return usingDefaultSortingFunctions_p;
     116             : }
     117             : 
     118             : const Block<Int> &
     119        7744 : SortColumns::getColumnIds () const
     120             : {
     121        7744 :     return columnIds_p;
     122             : }
     123             : 
     124             : const std::vector<std::pair<casacore::String, std::shared_ptr<casacore::BaseCompare>>> &
     125      287959 : SortColumns::sortingDefinition() const
     126             : {
     127      287959 :     return sortingDefinition_p;
     128             : }
     129             : 
     130             : CountedPtr <WeightScaling>
     131         202 : WeightScaling::generateUnityWeightScaling ()
     132             : {
     133         202 :     return generateWeightScaling (WeightScaling::unity);
     134             : }
     135             : 
     136             : CountedPtr <WeightScaling>
     137           0 : WeightScaling::generateIdentityWeightScaling ()
     138             : {
     139           0 :     return  generateWeightScaling (WeightScaling::identity);
     140             : }
     141             : 
     142             : CountedPtr <WeightScaling>
     143           0 : WeightScaling::generateSquareWeightScaling ()
     144             : {
     145           0 :     return  generateWeightScaling (WeightScaling::square);
     146             : }
     147             : 
     148           0 : Float WeightScaling::unity (Float) { return 1.0;}
     149           0 : Float WeightScaling::identity (Float x) { return x;}
     150           0 : Float WeightScaling::square (Float x) { return x * x;}
     151             : 
     152           0 : VisibilityIterator2::VisibilityIterator2()
     153           0 : : impl_p (0)
     154             : {
     155           0 : }
     156             : 
     157        2054 : VisibilityIterator2::VisibilityIterator2(const MeasurementSet& ms,
     158             :                                          const SortColumns & sortColumns,
     159             :                                          Bool isWritable,
     160             :                                          const VisBufferComponents2 * prefetchColumns,
     161        2054 :                                          Double timeInterval)
     162             : {
     163        4108 :     Block<const MeasurementSet *> mss (1, & ms);
     164        2054 :     construct (prefetchColumns, mss, sortColumns,
     165             :                timeInterval, isWritable);
     166        2054 : }
     167             : 
     168        1724 : VisibilityIterator2::VisibilityIterator2 (const Block<const MeasurementSet *>& mss,
     169             :                                           const SortColumns & sortColumns,
     170             :                                           Bool isWritable,
     171             :                                           const VisBufferComponents2 * prefetchColumns,
     172        1724 :                                           Double timeInterval)
     173             : {
     174        1724 :     construct (prefetchColumns, mss, sortColumns, timeInterval, isWritable);
     175        1724 : }
     176             : 
     177         258 : VisibilityIterator2::VisibilityIterator2 (const ViFactory & factory)
     178         258 : : impl_p (0)
     179             : {
     180         258 :     ViImplementation2 * newImpl = factory.createVi ();
     181             : 
     182         258 :     impl_p = newImpl;
     183         258 : }
     184             : 
     185        1398 : VisibilityIterator2::VisibilityIterator2 (const Vector<ViiLayerFactory*> & factories)
     186        1398 : : impl_p (0)
     187             : {
     188             : 
     189        1398 :     Int nfactory=factories.nelements();
     190             : 
     191        1398 :     if(factories(nfactory-1) == nullptr)
     192           0 :         throw(AipsError("ViiLayerFactory in factories is null"));
     193             : 
     194        1409 :     ViImplementation2 * newImpl = factories(nfactory-1)->createViImpl2(factories(Slice(0,nfactory-1,1)));
     195             : 
     196        1387 :     impl_p = newImpl;
     197        1387 : }
     198             : 
     199             : 
     200             : void
     201        3778 : VisibilityIterator2::construct (const VisBufferComponents2 * prefetchColumns,
     202             :                                 const Block<const MeasurementSet *>& mss,
     203             :                                 const SortColumns & sortColumns,
     204             :                                 Double timeInterval,
     205             :                                 Bool writable)
     206             : {
     207             : 
     208             :     // Factory didn't create the read implementation so decide whether to create a
     209             :     // synchronous or asynchronous read implementation.
     210             : 
     211        3778 :     Bool createAsAsynchronous = prefetchColumns != NULL && isAsynchronousIoEnabled ();
     212             : 
     213        3778 :     if (createAsAsynchronous){
     214             :         //            impl_p = new ViImplAsync2 (mss, * prefetchColumns, sortColumns,
     215             :         //                                               addDefaultSortCols, timeInterval, writable);
     216             :     }
     217             :     else{
     218        3778 :         impl_p = new VisibilityIteratorImpl2 (mss, sortColumns, timeInterval, writable);
     219             :     }
     220        3778 : }
     221             : 
     222       16078 : VisibilityIterator2::~VisibilityIterator2 ()
     223             : {
     224        5423 :         delete impl_p;
     225       10655 : }
     226             : 
     227             : String
     228          44 : VisibilityIterator2::ViiType() const
     229             : {
     230          44 :   return impl_p->ViiType ();
     231             : }
     232             : 
     233             : 
     234             : void
     235     2350077 : VisibilityIterator2::next()
     236             : {
     237     2350077 :     CheckImplementationPointer ();
     238     2350077 :     impl_p->next ();
     239     2350077 : }
     240             : 
     241             : 
     242             : const MeasurementSet&
     243       28972 : VisibilityIterator2::ms () const
     244             : {
     245       28972 :     CheckImplementationPointer ();
     246       28972 :     return impl_p->ms ();
     247             : }
     248             : 
     249             : Bool
     250         402 : VisibilityIterator2::existsColumn (VisBufferComponent2 id) const
     251             : {
     252         402 :     CheckImplementationPointer ();
     253             : 
     254         402 :     return impl_p->existsColumn (id);
     255             : }
     256             : 
     257             : Bool
     258          98 : VisibilityIterator2::weightSpectrumExists () const
     259             : {
     260          98 :     CheckImplementationPointer ();
     261          98 :     return impl_p->weightSpectrumExists();
     262             : }
     263             : 
     264             : ViImplementation2 *
     265       34405 : VisibilityIterator2::getImpl () const
     266             : {
     267       34405 :     return impl_p;
     268             : }
     269             : 
     270             : Int
     271           0 : VisibilityIterator2::getReportingFrameOfReference () const
     272             : {
     273           0 :     return impl_p->getReportingFrameOfReference ();
     274             : }
     275             : 
     276             : void
     277           0 : VisibilityIterator2::setReportingFrameOfReference (Int frame)
     278             : {
     279           0 :     impl_p->setReportingFrameOfReference (frame);
     280           0 : }
     281             : 
     282             : 
     283             : Subchunk
     284           0 : VisibilityIterator2::getSubchunkId () const
     285             : {
     286           0 :     CheckImplementationPointer ();
     287           0 :     return impl_p->getSubchunkId ();
     288             : }
     289             : 
     290             : VisBuffer2 *
     291     1725308 : VisibilityIterator2::getVisBuffer ()
     292             : {
     293     1725308 :     CheckImplementationPointer ();
     294     1725308 :     return impl_p->getVisBuffer(this);
     295             : }
     296             : 
     297             : Bool
     298          34 : VisibilityIterator2::isAsynchronous () const
     299             : {
     300             : //    Bool isAsync = impl_p != NULL && dynamic_cast<const ViImplAsync2 *> (impl_p) != NULL;
     301             : //
     302             : //    return isAsync;
     303             : 
     304          34 :     return false; // for now
     305             : }
     306             : 
     307             : 
     308             : Bool
     309         195 : VisibilityIterator2::isAsynchronousIoEnabled()
     310             : {
     311             :     // Determines whether asynchronous I/O is enabled by looking for the
     312             :     // expected AipsRc value.  If not found then async i/o is disabled.
     313             : 
     314             :     Bool isEnabled;
     315         195 :     AipsrcValue<Bool>::find (isEnabled, getAipsRcBase () + "async.enabled", false);
     316             : 
     317         195 :     return isEnabled;
     318             : }
     319             : 
     320             : Bool
     321     2767868 : VisibilityIterator2::more () const
     322             : {
     323     2767868 :     CheckImplementationPointer ();
     324     2767868 :     return impl_p->more ();
     325             : }
     326             : 
     327             : Bool
     328      143969 : VisibilityIterator2::moreChunks () const
     329             : {
     330      143969 :     CheckImplementationPointer ();
     331      143969 :     return impl_p->moreChunks ();
     332             : }
     333             : 
     334             : 
     335             : void
     336       93397 : VisibilityIterator2::nextChunk ()
     337             : {
     338       93397 :     CheckImplementationPointer ();
     339       93397 :     impl_p->nextChunk ();
     340       93397 : }
     341             : 
     342             : void
     343        1106 : VisibilityIterator2::result(casacore::Record& res) const
     344             : {
     345        1106 :     impl_p->result(res);
     346        1106 : }
     347             : 
     348             : // Report Name of slowest column that changes at end of current iteration
     349       20259 : String VisibilityIterator2::keyChange() const
     350             : {
     351       20259 :   return impl_p->keyChange();
     352             : }
     353             : 
     354             : 
     355             : 
     356             : 
     357             : 
     358             : Int
     359           0 : VisibilityIterator2::nDataDescriptionIds () const
     360             : {
     361           0 :     CheckImplementationPointer ();
     362           0 :     return impl_p->nDataDescriptionIds ();
     363             : }
     364             : //
     365             : Int
     366         164 : VisibilityIterator2::nPolarizationIds () const
     367             : {
     368         164 :     CheckImplementationPointer ();
     369         164 :     return impl_p->nPolarizationIds ();
     370             : }
     371             : //
     372             : Int
     373          82 : VisibilityIterator2::nSpectralWindows () const
     374             : {
     375          82 :     CheckImplementationPointer ();
     376          82 :     return impl_p->nSpectralWindows ();
     377             : }
     378             : 
     379             : void
     380       94607 : VisibilityIterator2::origin ()
     381             : {
     382       94607 :     CheckImplementationPointer ();
     383       94607 :     impl_p->origin ();
     384       94607 : }
     385             : 
     386             : void
     387       17062 : VisibilityIterator2::originChunks ()
     388             : {
     389       17062 :     CheckImplementationPointer ();
     390       17062 :     originChunks (false);
     391       17061 : }
     392             : 
     393             : void
     394       17062 : VisibilityIterator2::originChunks (Bool forceRewind)
     395             : {
     396       17062 :     CheckImplementationPointer ();
     397       17062 :     impl_p->originChunks (forceRewind);
     398       17061 : }
     399             : 
     400             : void
     401         824 : VisibilityIterator2::setRowBlocking (rownr_t nRows) // for use by Async I/O *ONLY
     402             : {
     403         824 :     CheckImplementationPointer ();
     404         824 :     impl_p->setRowBlocking (nRows);
     405         824 : }
     406             : 
     407             : void
     408        1039 : VisibilityIterator2::slurp () const
     409             : {
     410        1039 :     CheckImplementationPointer ();
     411        1039 :     impl_p->slurp ();
     412        1039 : }
     413             : 
     414             : rownr_t
     415       22392 : VisibilityIterator2::nRowsInChunk () const
     416             : {
     417       22392 :     CheckImplementationPointer ();
     418       22392 :     return impl_p->nRowsInChunk ();
     419             : }
     420             : 
     421             : void
     422        1528 : VisibilityIterator2::setFrequencySelection (const FrequencySelection & selection)
     423             : {
     424        3056 :     FrequencySelections selections;
     425        1528 :     selections.add (selection);
     426        1528 :     setFrequencySelection (selections);
     427        1528 : }
     428             : 
     429             : void
     430        3334 : VisibilityIterator2::setFrequencySelection (const FrequencySelections & selections)
     431             : {
     432        3334 :     ThrowIf (selections.size () != impl_p->getNMs (),
     433             :              String::format ("Frequency selection size, %d, does not VisibilityIterator # of MSs, %d.",
     434             :                      impl_p->getNMs (), selections.size()));
     435             : 
     436        3334 :     CheckImplementationPointer ();
     437        3334 :     impl_p->setFrequencySelections (selections);
     438        3334 : }
     439             : 
     440             : 
     441             : 
     442             : const vi::SubtableColumns &
     443           0 : VisibilityIterator2::subtableColumns () const
     444             : {
     445           0 :     CheckImplementationPointer ();
     446           0 :     return impl_p->subtableColumns ();
     447             : }
     448             : 
     449             : void
     450        3252 : VisibilityIterator2::useImagingWeight (const VisImagingWeight & viw)
     451             : {
     452        3252 :     CheckImplementationPointer ();
     453        3252 :     impl_p->useImagingWeight(viw);
     454        3252 : }
     455             : 
     456             : const VisImagingWeight &
     457          27 : VisibilityIterator2::getImagingWeightGenerator () const
     458             : {
     459          27 :     CheckImplementationPointer ();
     460          27 :     return impl_p->getImagingWeightGenerator ();
     461             : }
     462             : 
     463             : void
     464      402995 : VisibilityIterator2::writeFlag (const Cube<Bool>& flag)
     465             : {
     466      402995 :     CheckImplementationPointer ();
     467      402995 :     impl_p->writeFlag (flag);
     468      402995 : }
     469             : 
     470             : void
     471      379121 : VisibilityIterator2::writeFlagRow (const Vector<Bool>& rowflags)
     472             : {
     473      379121 :     CheckImplementationPointer ();
     474      379121 :     impl_p->writeFlagRow (rowflags);
     475      379121 : }
     476             : 
     477             : void
     478           0 : VisibilityIterator2::writeWeightSpectrum (const Cube<Float>& wtsp)
     479             : {
     480           0 :     CheckImplementationPointer ();
     481           0 :     impl_p->writeWeightSpectrum (wtsp);
     482           0 : }
     483             : 
     484             : void
     485       14320 : VisibilityIterator2::writeVisModel (const Cube<Complex>& modelCube)
     486             : {
     487       14320 :     CheckImplementationPointer ();
     488       14320 :     impl_p->writeVisModel (modelCube);
     489       14320 : }
     490             : 
     491             : void
     492           0 : VisibilityIterator2::writeVisCorrected (const Cube<Complex>& CorrectedCube)
     493             : {
     494           0 :     CheckImplementationPointer ();
     495           0 :     impl_p->writeVisCorrected (CorrectedCube);
     496           0 : }
     497             : 
     498             : void
     499          17 : VisibilityIterator2::writeModel(const RecordInterface& record,
     500             :                                 bool isComponentList,
     501             :                                 bool addToExistingModel)
     502             : {
     503          17 :     CheckImplementationPointer ();
     504          17 :     impl_p->writeModel (record, isComponentList, addToExistingModel);
     505          17 : }
     506             : 
     507             : void
     508           0 : VisibilityIterator2::writeVisObserved (const Cube<Complex>& ObservedCube)
     509             : {
     510           0 :     CheckImplementationPointer ();
     511           0 :     impl_p->writeVisObserved (ObservedCube);
     512           0 : }
     513             : 
     514             : //
     515             : void
     516           0 : VisibilityIterator2::initWeightSpectrum (const Cube<Float>& wtsp)
     517             : {
     518           0 :     CheckImplementationPointer ();
     519           0 :     impl_p->initWeightSpectrum (wtsp);
     520           0 : }
     521             : 
     522             : void
     523         202 : VisibilityIterator2::setWeightScaling (CountedPtr<WeightScaling> weightScaling)
     524             : {
     525         202 :   CheckImplementationPointer ();
     526             : 
     527         202 :   impl_p->setWeightScaling (weightScaling);
     528         202 : }
     529             : 
     530             : Bool
     531           0 : VisibilityIterator2::hasWeightScaling () const
     532             : {
     533           0 :   CheckImplementationPointer ();
     534             : 
     535           0 :   return impl_p->hasWeightScaling ();
     536             : }
     537             : 
     538           0 : const casacore::MSAntennaColumns& VisibilityIterator2::antennaSubtablecols() const
     539             : {
     540           0 :   CheckImplementationPointer ();
     541             : 
     542           0 :   return impl_p->antennaSubtablecols ();
     543             : }
     544             : 
     545           0 : const casacore::MSDataDescColumns& VisibilityIterator2::dataDescriptionSubtablecols() const
     546             : {
     547           0 :   CheckImplementationPointer ();
     548             : 
     549           0 :   return impl_p->dataDescriptionSubtablecols ();
     550             : }
     551             : 
     552           0 : const casacore::MSFeedColumns& VisibilityIterator2::feedSubtablecols() const
     553             : {
     554           0 :   CheckImplementationPointer ();
     555             : 
     556           0 :   return impl_p->feedSubtablecols ();
     557             : }
     558             : 
     559           0 : const casacore::MSFieldColumns& VisibilityIterator2::fieldSubtablecols() const
     560             : {
     561           0 :   CheckImplementationPointer ();
     562             : 
     563           0 :   return impl_p->fieldSubtablecols ();
     564             : }
     565             : 
     566           0 : const casacore::MSFlagCmdColumns& VisibilityIterator2::flagCmdSubtablecols() const
     567             : {
     568           0 :   CheckImplementationPointer ();
     569             : 
     570           0 :   return impl_p->flagCmdSubtablecols ();
     571             : }
     572             : 
     573           0 : const casacore::MSHistoryColumns& VisibilityIterator2::historySubtablecols() const
     574             : {
     575           0 :   CheckImplementationPointer ();
     576             : 
     577           0 :   return impl_p->historySubtablecols ();
     578             : }
     579             : 
     580           0 : const casacore::MSObservationColumns& VisibilityIterator2::observationSubtablecols() const
     581             : {
     582           0 :   CheckImplementationPointer ();
     583             : 
     584           0 :   return impl_p->observationSubtablecols ();
     585             : }
     586             : 
     587           0 : const casacore::MSPointingColumns& VisibilityIterator2::pointingSubtablecols() const
     588             : {
     589           0 :   CheckImplementationPointer ();
     590             : 
     591           0 :   return impl_p->pointingSubtablecols ();
     592             : }
     593             : 
     594           0 : const casacore::MSPolarizationColumns& VisibilityIterator2::polarizationSubtablecols() const
     595             : {
     596           0 :   CheckImplementationPointer ();
     597             : 
     598           0 :   return impl_p->polarizationSubtablecols ();
     599             : }
     600             : 
     601           0 : const casacore::MSProcessorColumns& VisibilityIterator2::processorSubtablecols() const
     602             : {
     603           0 :   CheckImplementationPointer ();
     604             : 
     605           0 :   return impl_p->processorSubtablecols ();
     606             : }
     607             : 
     608         167 : const casacore::MSSpWindowColumns& VisibilityIterator2::spectralWindowSubtablecols() const
     609             : {
     610         167 :   CheckImplementationPointer ();
     611             : 
     612         167 :   return impl_p->spectralWindowSubtablecols ();
     613             : }
     614             : 
     615           0 : const casacore::MSStateColumns& VisibilityIterator2::stateSubtablecols() const
     616             : {
     617           0 :   CheckImplementationPointer ();
     618             : 
     619           0 :   return impl_p->stateSubtablecols ();
     620             : }
     621             : 
     622           0 : const casacore::MSDopplerColumns& VisibilityIterator2::dopplerSubtablecols() const
     623             : {
     624           0 :   CheckImplementationPointer ();
     625             : 
     626           0 :   return impl_p->dopplerSubtablecols ();
     627             : }
     628             : 
     629           0 : const casacore::MSFreqOffsetColumns& VisibilityIterator2::freqOffsetSubtablecols() const
     630             : {
     631           0 :   CheckImplementationPointer ();
     632             : 
     633           0 :   return impl_p->freqOffsetSubtablecols ();
     634             : }
     635             : 
     636           0 : const casacore::MSSourceColumns& VisibilityIterator2::sourceSubtablecols() const
     637             : {
     638           0 :   CheckImplementationPointer ();
     639             : 
     640           0 :   return impl_p->sourceSubtablecols ();
     641             : }
     642             : 
     643           0 : const casacore::MSSysCalColumns& VisibilityIterator2::sysCalSubtablecols() const
     644             : {
     645           0 :   CheckImplementationPointer ();
     646             : 
     647           0 :   return impl_p->sysCalSubtablecols ();
     648             : }
     649             : 
     650           0 : const casacore::MSWeatherColumns& VisibilityIterator2::weatherSubtablecols() const
     651             : {
     652           0 :   CheckImplementationPointer ();
     653             : 
     654           0 :   return impl_p->weatherSubtablecols ();
     655             : }
     656             : 
     657        5434 : SubtableColumns::SubtableColumns (CountedPtr <MSIter> msIter)
     658        5434 : : msIter_p (msIter)
     659        5434 : {}
     660             : 
     661             : const MSAntennaColumns&
     662      205802 : SubtableColumns::antenna() const
     663             : {
     664      205802 :     return msIter_p->msColumns().antenna();
     665             : }
     666             : 
     667             : const MSDataDescColumns&
     668   755184549 : SubtableColumns::dataDescription() const
     669             : {
     670   755184549 :     return msIter_p->msColumns().dataDescription();
     671             : }
     672             : 
     673             : const MSFeedColumns&
     674           0 : SubtableColumns::feed() const
     675             : {
     676           0 :     return msIter_p->msColumns().feed();
     677             : }
     678             : 
     679             : const MSFieldColumns&
     680     1552998 : SubtableColumns::field() const
     681             : {
     682     1552998 :     return msIter_p->msColumns().field();
     683             : }
     684             : 
     685             : const MSFlagCmdColumns&
     686           0 : SubtableColumns::flagCmd() const
     687             : {
     688           0 :     return msIter_p->msColumns().flagCmd();
     689             : }
     690             : 
     691             : const MSHistoryColumns&
     692           0 : SubtableColumns::history() const
     693             : {
     694           0 :     return msIter_p->msColumns().history();
     695             : }
     696             : 
     697             : const MSObservationColumns&
     698      779955 : SubtableColumns::observation() const
     699             : {
     700      779955 :     return msIter_p->msColumns().observation();
     701             : }
     702             : 
     703             : const MSPointingColumns&
     704      176781 : SubtableColumns::pointing() const
     705             : {
     706      176781 :     return msIter_p->msColumns().pointing();
     707             : }
     708             : 
     709             : const MSPolarizationColumns&
     710     8678226 : SubtableColumns::polarization() const
     711             : {
     712             : 
     713     8678226 :     return msIter_p->msColumns().polarization();
     714             : }
     715             : 
     716             : const MSProcessorColumns&
     717           0 : SubtableColumns::processor() const
     718             : {
     719           0 :     return msIter_p->msColumns().processor();
     720             : }
     721             : 
     722             : const MSSpWindowColumns&
     723     4351200 : SubtableColumns::spectralWindow() const
     724             : {
     725             : 
     726     4351200 :     return msIter_p->msColumns().spectralWindow();
     727             : }
     728             : 
     729             : const MSStateColumns&
     730           0 : SubtableColumns::state() const
     731             : {
     732           0 :     return msIter_p->msColumns().state();
     733             : }
     734             : 
     735             : const MSDopplerColumns&
     736           0 : SubtableColumns::doppler() const
     737             : {
     738           0 :     return msIter_p->msColumns().doppler();
     739             : }
     740             : 
     741             : const MSFreqOffsetColumns&
     742           0 : SubtableColumns::freqOffset() const
     743             : {
     744           0 :     return msIter_p->msColumns().freqOffset();
     745             : }
     746             : 
     747             : const MSSourceColumns&
     748           0 : SubtableColumns::source() const
     749             : {
     750           0 :     return msIter_p->msColumns().source();
     751             : }
     752             : 
     753             : const MSSysCalColumns&
     754           0 : SubtableColumns::sysCal() const
     755             : {
     756           0 :     return msIter_p->msColumns().sysCal();
     757             : }
     758             : 
     759             : const MSWeatherColumns&
     760           0 : SubtableColumns::weather() const
     761             : {
     762           0 :     return msIter_p->msColumns().weather();
     763             : }
     764             : 
     765             : 
     766             : } // end namespace vi
     767             : 
     768             : 
     769             : using namespace casacore;
     770             : } // end namespace casa