Line data    Source code

       1             : #include <msvis/MSVis/TransformingVi2.h>
       2             : 
       3             : #include <casacore/measures/Measures/MDirection.h>
       4             : #include <casacore/measures/Measures/MEpoch.h>
       5             : #include <casacore/measures/Measures/MPosition.h>
       6             : #include <stdcasa/UtilJ.h>
       7             : #include <msvis/MSVis/VisibilityIterator2.h>
       8             : #include <msvis/MSVis/VisBuffer2.h>
       9             : 
      10             : //#include <casa/Arrays/Cube.h>
      11             : //#include <casa/Arrays/Matrix.h>
      12             : //#include <casa/Arrays/Slicer.h>
      13             : //#include <casa/BasicSL/String.h>
      14             : //#include <casa/Containers/Stack.h>
      15             : //#include <casa/Quanta/MVDoppler.h>
      16             : //#include <casa/aips.h>
      17             : //#include <measures/Measures/MCDoppler.h>
      18             : //#include <measures/Measures/MDoppler.h>
      19             : //#include <measures/Measures/MeasConvert.h>
      20             : //#include <measures/Measures/Stokes.h>
      21             : //#include <ms/MSOper/MSDerivedValues.h>
      22             : //#include <ms/MeasurementSets/MSIter.h>
      23             : //#include <ms/MeasurementSets/MSColumns.h>
      24             : //#include <ms/MeasurementSets/MeasurementSet.h>
      25             : //#include <scimath/Mathematics/RigidVector.h>
      26             : //#include <scimath/Mathematics/SquareMatrix.h>
      27             : //#include <msvis/MSVis/StokesVector.h>
      28             : //#include <msvis/MSVis/VisBufferComponents2.h>
      29             : //#include <msvis/MSVis/VisImagingWeight.h>
      30             : //#include <msvis/MSVis/VisibilityIterator2.h>
      31             : //#include <tables/Tables/ArrayColumn.h>
      32             : //#include <tables/Tables/ScalarColumn.h>
      33             : 
      34             : #define Tvi2NotImplemented() {Throw ("Not implemented.");}
      35             : 
      36             : using namespace casacore;
      37             : using namespace casa::utilj;
      38             : 
      39             : using namespace casacore;
      40             : namespace casa {
      41             : 
      42             : namespace vi {
      43             : 
      44         879 : TransformingVi2::TransformingVi2 (ViImplementation2 * inputVi)
      45         879 : : inputVii_p (inputVi),
      46         879 :   vb_p (0)
      47         879 : {}
      48             : 
      49         879 : TransformingVi2::~TransformingVi2 ()
      50             : {
      51         879 :     delete inputVii_p;
      52         879 :     delete vb_p;
      53         879 : }
      54             : 
      55             : void
      56        3803 : TransformingVi2::next ()
      57             : {
      58        3803 :      getVii()->next ();
      59        3803 : }
      60             : 
      61             : Bool
      62           0 : TransformingVi2::allBeamOffsetsZero ()  const
      63             : {
      64           0 :     return getVii()->allBeamOffsetsZero ();
      65             : }
      66             : 
      67             : void
      68      481878 : TransformingVi2::antenna1 (Vector<Int> & ant1)  const
      69             : {
      70      481878 :      getVii()->antenna1 (ant1);
      71      481878 : }
      72             : 
      73             : void
      74      481874 : TransformingVi2::antenna2 (Vector<Int> & ant2)  const
      75             : {
      76      481874 :      getVii()->antenna2 (ant2);
      77      481874 : }
      78             : 
      79             : const Vector<String> &
      80           0 : TransformingVi2::antennaMounts ()  const
      81             : {
      82           0 :     return getVii()->antennaMounts ();
      83             : }
      84             : 
      85             : void
      86       74191 : TransformingVi2::arrayIds (Vector<Int>& ids)  const
      87             : {
      88       74191 :     return getVii()->arrayIds (ids);
      89             : }
      90             : 
      91             : const Vector<MDirection> &
      92           0 : TransformingVi2::azel (Double time)  const
      93             : {
      94           0 :     return getVii()->azel (time);
      95             : }
      96             : 
      97             : MDirection
      98           0 : TransformingVi2::azel0 (Double time)  const
      99             : {
     100           0 :     return getVii()->azel0 (time);
     101             : }
     102             : 
     103             : void
     104      522716 : TransformingVi2::configureNewSubchunk (){
     105             : 
     106      522716 :     configureNewSubchunk (msId(), // always the first MS
     107      522716 :                           msName(),
     108      522716 :                           isNewMs(),
     109      522716 :                           isNewArrayId (),
     110      522716 :                           isNewFieldId (),
     111      522716 :                           isNewSpectralWindow (),
     112      522716 :                           getSubchunkId (),
     113      522716 :                           nRowsPerShape(),
     114      522716 :                           nChannelsPerShape(),
     115      522716 :                           nCorrelationsPerShape(),
     116     1045432 :                           getCorrelations(),
     117     1045432 :                           getCorrelationTypesDefined(),
     118     1045432 :                           getCorrelationTypesSelected(),
     119     1045432 :                           getWeightScaling());
     120      522716 : }
     121             : 
     122             : void
     123      522716 : TransformingVi2::configureNewSubchunk (Int msId, const String & msName, Bool isNewMs,
     124             :                                        Bool isNewArrayId, Bool isNewFieldId,
     125             :                                        Bool isNewSpectralWindow, const Subchunk & subchunk,
     126             :                                        const casacore::Vector<casacore::rownr_t>& nRowsPerShape,
     127             :                                        const casacore::Vector<casacore::Int>& nChannelsPerShape,
     128             :                                        const casacore::Vector<casacore::Int>& nCorrelationsPerShape,
     129             :                                        const Vector<Int> & correlations,
     130             :                                        const Vector<Stokes::StokesTypes> & correlationsDefined,
     131             :                                        const Vector<Stokes::StokesTypes> & correlationsSelected,
     132             :                                        CountedPtr<WeightScaling> weightScaling)
     133             : {
     134      522716 :     getVisBuffer()->configureNewSubchunk (msId, // always the first MS
     135             :                                           msName,
     136             :                                           isNewMs,
     137             :                                           isNewArrayId,
     138             :                                           isNewFieldId,
     139             :                                           isNewSpectralWindow,
     140             :                                           subchunk,
     141             :                                           nRowsPerShape,
     142             :                                           nChannelsPerShape,
     143             :                                           nCorrelationsPerShape,
     144             :                                           correlations,
     145             :                                           correlationsDefined,
     146             :                                           correlationsSelected,
     147             :                                           weightScaling);
     148      522716 : }
     149             : 
     150             : 
     151             : 
     152             : void
     153       56257 : TransformingVi2::corrType (Vector<Int> & corrTypes)  const
     154             : {
     155       56257 :      getVii()->corrType (corrTypes);
     156       56257 : }
     157             : 
     158             : Int
     159       95666 : TransformingVi2::dataDescriptionId ()  const
     160             : {
     161       95666 :     return getVii()->dataDescriptionId ();
     162             : }
     163             : 
     164             : void
     165       73963 : TransformingVi2::dataDescriptionIds(Vector<int>& ddIds) const
     166             : {
     167       73963 :     getVii()->dataDescriptionIds (ddIds);
     168       73963 : }
     169             : 
     170             : Bool
     171        1672 : TransformingVi2::existsColumn (VisBufferComponent2 id)  const
     172             : {
     173        1672 :     return getVii()->existsColumn (id);
     174             : }
     175             : 
     176             : void
     177      420725 : TransformingVi2::exposure (Vector<Double> & expo)  const
     178             : {
     179      420725 :      getVii()->exposure (expo);
     180      420725 : }
     181             : 
     182             : void
     183       12864 : TransformingVi2::feed1 (Vector<Int> & fd1)  const
     184             : {
     185       12864 :      getVii()->feed1 (fd1);
     186       12864 : }
     187             : 
     188             : void
     189       12860 : TransformingVi2::feed2 (Vector<Int> & fd2)  const
     190             : {
     191       12860 :      getVii()->feed2 (fd2);
     192       12860 : }
     193             : 
     194             : const Vector<Float> &
     195       74684 : TransformingVi2::feed_pa (Double time)  const
     196             : {
     197       74684 :     return getVii()->feed_pa (time);
     198             : }
     199             : 
     200             : void
     201       74191 : TransformingVi2::fieldIds (Vector<Int>& ids)  const
     202             : {
     203       74191 :     return getVii()->fieldIds (ids);
     204             : }
     205             : 
     206             : String
     207           0 : TransformingVi2::fieldName ()  const
     208             : {
     209           0 :     return getVii()->fieldName ();
     210             : }
     211             : 
     212             : void
     213        5111 : TransformingVi2::flag (Cube<Bool> & flags)  const
     214             : {
     215        5111 :      getVii()->flag (flags);
     216        5111 : }
     217             : 
     218             : void
     219           0 : TransformingVi2::flag (Vector<Cube<Bool>> & flags)  const
     220             : {
     221           0 :      getVii()->flag (flags);
     222           0 : }
     223             : 
     224             : void
     225           0 : TransformingVi2::flag (Matrix<Bool> & flags)  const
     226             : {
     227           0 :      getVii()->flag (flags);
     228           0 : }
     229             : 
     230             : void
     231           0 : TransformingVi2::flagCategory (Array<Bool> & flagCategories)  const
     232             : {
     233           0 :      getVii()->flagCategory (flagCategories);
     234           0 : }
     235             : 
     236             : Bool
     237           0 : TransformingVi2::flagCategoryExists ()  const
     238             : {
     239           0 :     return getVii()->flagCategoryExists ();
     240             : }
     241             : 
     242             : void
     243       24860 : TransformingVi2::flagRow (Vector<Bool> & rowflags)  const
     244             : {
     245       24860 :      getVii()->flagRow (rowflags);
     246       24860 : }
     247             : 
     248             : void
     249           0 : TransformingVi2::floatData (Cube<Float> & fcube)  const
     250             : {
     251           0 :      getVii()->floatData (fcube);
     252           0 : }
     253             : 
     254             : void
     255           0 : TransformingVi2::floatData (Vector<Cube<Float>> & fcube)  const
     256             : {
     257           0 :      getVii()->floatData (fcube);
     258           0 : }
     259             : 
     260             : const Cube<RigidVector<Double, 2> > &
     261           0 : TransformingVi2::getBeamOffsets ()  const
     262             : {
     263           0 :     return getVii()->getBeamOffsets ();
     264             : }
     265             : 
     266             : Vector<Int>
     267        1138 : TransformingVi2::getChannels (Double time, Int frameOfReference,
     268             :                               Int spectralWindowId, Int msId)  const
     269             : {
     270        1138 :     return getVii()->getChannels (time, frameOfReference,
     271        1138 :                                   spectralWindowId, msId);
     272             : }
     273             : 
     274             : Vector<Int>
     275      744900 : TransformingVi2::getCorrelations () const
     276             : {
     277      744900 :     return getVii()->getCorrelations();
     278             : }
     279             : 
     280             : Vector<Stokes::StokesTypes>
     281      744900 : TransformingVi2::getCorrelationTypesDefined () const
     282             : {
     283      744900 :     return getVii()->getCorrelationTypesDefined();
     284             : }
     285             : 
     286             : Vector<Stokes::StokesTypes>
     287      744900 : TransformingVi2::getCorrelationTypesSelected () const
     288             : {
     289      744900 :     return getVii()->getCorrelationTypesSelected();
     290             : }
     291             : 
     292             : MEpoch
     293           0 : TransformingVi2::getEpoch ()  const
     294             : {
     295           0 :     return getVii()->getEpoch ();
     296             : }
     297             : 
     298             : Vector<Double>
     299       58598 : TransformingVi2::getFrequencies (Double time, Int frameOfReference,
     300             :                                  Int spectralWindowId, Int msId)  const
     301             : {
     302       58598 :     return getVii()->getFrequencies (time, frameOfReference,
     303       58598 :                                      spectralWindowId, msId);
     304             : }
     305             : 
     306             : Vector<Double>
     307         859 : TransformingVi2::getChanWidths (Double time, Int frameOfReference,
     308             :                                    Int spectralWindowId, Int msId)  const
     309             : {
     310         859 :     return getVii()->getChanWidths (time, frameOfReference,
     311         859 :                                        spectralWindowId, msId);
     312             : }
     313             : 
     314             : const VisImagingWeight &
     315           0 : TransformingVi2::getImagingWeightGenerator ()  const
     316             : {
     317           0 :     return getVii()->getImagingWeightGenerator ();
     318             : }
     319             : 
     320             : Double
     321           0 : TransformingVi2::getInterval ()  const
     322             : {
     323           0 :     return getVii()->getInterval ();
     324             : }
     325             : 
     326             : Int
     327          94 : TransformingVi2::getNMs () const
     328             : {
     329          94 :     return getVii()->getNMs ();
     330             : }
     331             : 
     332             : MFrequency::Types
     333           0 : TransformingVi2::getObservatoryFrequencyType ()  const
     334             : {
     335           0 :     return getVii()->getObservatoryFrequencyType ();
     336             : }
     337             : 
     338             : MPosition
     339           0 : TransformingVi2::getObservatoryPosition ()  const
     340             : {
     341           0 :     return getVii()->getObservatoryPosition ();
     342             : }
     343             : 
     344             : std::pair<bool, casacore::MDirection> 
     345           0 : TransformingVi2::getPointingAngle (int antenna, double time) const
     346             : {
     347           0 :     return getVii()->getPointingAngle (antenna, time);
     348             : }
     349             : 
     350             : Vector<Float>
     351           0 : TransformingVi2::getReceptor0Angle ()
     352             : {
     353           0 :     return getVii()->getReceptor0Angle ();
     354             : }
     355             : 
     356             : Int
     357       75908 : TransformingVi2::getReportingFrameOfReference ()  const
     358             : {
     359       75908 :     return getVii()->getReportingFrameOfReference ();
     360             : }
     361             : 
     362             : void
     363        3559 : TransformingVi2::getRowIds (Vector<rownr_t> & rowids)  const
     364             : {
     365        3559 :      getVii()->getRowIds (rowids);
     366        3559 : }
     367             : 
     368             : const SortColumns &
     369           0 : TransformingVi2::getSortColumns ()  const
     370             : {
     371           0 :     return getVii()->getSortColumns ();
     372             : }
     373             : 
     374             : const SpectralWindowChannels &
     375           0 : TransformingVi2::getSpectralWindowChannels (Int msId, Int spectralWindowId)  const
     376             : {
     377           0 :     return getVii()->getSpectralWindowChannels (msId, spectralWindowId);
     378             : }
     379             : 
     380             : Subchunk
     381      752563 : TransformingVi2::getSubchunkId ()  const
     382             : {
     383      752563 :     return getVii()->getSubchunkId ();
     384             : }
     385             : 
     386             : ViImplementation2 *
     387    24827812 : TransformingVi2::getVii () const
     388             : {
     389    24827812 :     Assert (inputVii_p != 0);
     390             : 
     391    24827812 :     return inputVii_p;
     392             : }
     393             : 
     394             : Double
     395           0 : TransformingVi2::hourang (Double time)  const
     396             : {
     397           0 :     return getVii()->hourang (time);
     398             : }
     399             : 
     400             : Bool
     401      752308 : TransformingVi2::isNewArrayId ()  const
     402             : {
     403      752308 :     return getVii()->isNewArrayId ();
     404             : }
     405             : 
     406             : Bool
     407      752308 : TransformingVi2::isNewFieldId ()  const
     408             : {
     409      752308 :     return getVii()->isNewFieldId ();
     410             : }
     411             : 
     412             : Bool
     413      763059 : TransformingVi2::isNewMs ()  const
     414             : {
     415      763059 :     return getVii()->isNewMs ();
     416             : }
     417             : 
     418             : Bool
     419      752308 : TransformingVi2::isNewSpectralWindow ()  const
     420             : {
     421      752308 :     return getVii()->isNewSpectralWindow ();
     422             : }
     423             : 
     424             : Bool
     425           0 : TransformingVi2::isWritable ()  const
     426             : {
     427           0 :     return getVii()->isWritable ();
     428             : }
     429             : 
     430             : void
     431           0 : TransformingVi2::jonesC (Vector<SquareMatrix<Complex, 2> > & cjones)  const
     432             : {
     433           0 :      getVii()->jonesC (cjones);
     434           0 : }
     435             : 
     436             : Bool
     437      565303 : TransformingVi2::more ()  const
     438             : {
     439      565303 :     return getVii()->more ();
     440             : }
     441             : 
     442             : Bool
     443      118585 : TransformingVi2::moreChunks ()  const
     444             : {
     445      118585 :     return getVii()->moreChunks ();
     446             : }
     447             : 
     448             : void
     449         282 : TransformingVi2::result(casacore::Record &res) const
     450             : {
     451         282 :     return getVii()->result(res);
     452             : }
     453             : 
     454             : const MeasurementSet &
     455         909 : TransformingVi2::ms ()  const
     456             : {
     457         909 :     return getVii()->ms ();
     458             : }
     459             : 
     460             : Int
     461     1203581 : TransformingVi2::msId ()  const
     462             : {
     463     1203581 :     return getVii()->msId ();
     464             : }
     465             : 
     466      752344 : String TransformingVi2::msName () const
     467             : {
     468      752344 :     return getVii()->msName ();
     469             : }
     470             : 
     471             : Int
     472      201784 : TransformingVi2::nAntennas ()  const
     473             : {
     474      201784 :     return getVii()->nAntennas ();
     475             : }
     476             : 
     477             : Int
     478           0 : TransformingVi2::nDataDescriptionIds ()  const
     479             : {
     480           0 :     return getVii()->nDataDescriptionIds ();
     481             : }
     482             : 
     483             : Int
     484         393 : TransformingVi2::nPolarizationIds ()  const
     485             : {
     486         393 :     return getVii()->nPolarizationIds ();
     487             : }
     488             : 
     489             : rownr_t
     490        6998 : TransformingVi2::nRows ()  const
     491             : {
     492        6998 :     return getVii()->nRows ();
     493             : }
     494             : 
     495             : rownr_t
     496           0 : TransformingVi2::nShapes ()  const
     497             : {
     498           0 :     return getVii()->nShapes ();
     499             : }
     500             : 
     501             : const casacore::Vector<casacore::rownr_t>&
     502      752308 : TransformingVi2::nRowsPerShape () const
     503             : {
     504      752308 :     return getVii()->nRowsPerShape ();
     505             : }
     506             : 
     507             : const casacore::Vector<casacore::Int>&
     508      301035 : TransformingVi2::nChannelsPerShape () const
     509             : {
     510      301035 :     return getVii()->nChannelsPerShape ();
     511             : }
     512             : 
     513             : const casacore::Vector<casacore::Int>&
     514      744900 : TransformingVi2::nCorrelationsPerShape () const
     515             : {
     516      744900 :     return getVii()->nCorrelationsPerShape ();
     517             : }
     518             : 
     519             : rownr_t
     520         258 : TransformingVi2::nRowsInChunk ()  const
     521             : {
     522         258 :     return getVii()->nRowsInChunk ();
     523             : }
     524             : 
     525             : rownr_t
     526           0 : TransformingVi2::nRowsViWillSweep ()  const
     527             : {
     528           0 :     return getVii()->nRowsViWillSweep ();
     529             : }
     530             : 
     531             : Int
     532       21304 : TransformingVi2::nSpectralWindows ()  const
     533             : {
     534       21304 :     return getVii()->nSpectralWindows ();
     535             : }
     536             : 
     537           0 : Int TransformingVi2::nTimes() const {
     538           0 :     return getVii()->nTimes();
     539             : }
     540             : 
     541             : void
     542       78952 : TransformingVi2::nextChunk ()
     543             : {
     544       78952 :      getVii()->nextChunk ();
     545       78952 : }
     546             : 
     547             : void
     548       74191 : TransformingVi2::observationId (Vector<Int> & obsids)  const
     549             : {
     550       74191 :      getVii()->observationId (obsids);
     551       74191 : }
     552             : 
     553             : void
     554         101 : TransformingVi2::origin ()
     555             : {
     556         101 :      getVii()->origin ();
     557         101 : }
     558             : 
     559             : void
     560         195 : TransformingVi2::originChunks (Bool forceRewind)
     561             : {
     562         195 :      getVii()->originChunks (forceRewind);
     563         195 : }
     564             : 
     565             : const Vector<Float> &
     566           0 : TransformingVi2::parang (Double time)  const
     567             : {
     568           0 :     return getVii()->parang (time);
     569             : }
     570             : 
     571             : const Float &
     572           0 : TransformingVi2::parang0 (Double time)  const
     573             : {
     574           0 :     return getVii()->parang0 (time);
     575             : }
     576             : 
     577             : const MDirection &
     578         576 : TransformingVi2::phaseCenter ()  const
     579             : {
     580         576 :     return getVii()->phaseCenter ();
     581             : }
     582             : 
     583             : Int
     584         576 : TransformingVi2::polFrame ()  const
     585             : {
     586         576 :     return getVii()->polFrame ();
     587             : }
     588             : 
     589             : Int
     590         577 : TransformingVi2::polarizationId ()  const
     591             : {
     592         577 :     return getVii()->polarizationId ();
     593             : }
     594             : 
     595             : void
     596       12860 : TransformingVi2::processorId (Vector<Int> & procids)  const
     597             : {
     598       12860 :      getVii()->processorId (procids);
     599       12860 : }
     600             : 
     601             : const Cube<Double> &
     602           0 : TransformingVi2::receptorAngles ()  const
     603             : {
     604           0 :     return getVii()->receptorAngles ();
     605             : }
     606             : 
     607             : void
     608       74195 : TransformingVi2::scan (Vector<Int> & scans)  const
     609             : {
     610       74195 :      getVii()->scan (scans);
     611       74195 : }
     612             : 
     613             : void
     614          94 : TransformingVi2::setFrequencySelections (const FrequencySelections & selection)
     615             : {
     616          94 :      getVii()->setFrequencySelections (selection);
     617          94 : }
     618             : 
     619             : void
     620           0 : TransformingVi2::setInterval (Double timeInterval)
     621             : {
     622           0 :      getVii()->setInterval (timeInterval);
     623           0 : }
     624             : 
     625             : void
     626           0 : TransformingVi2::setReportingFrameOfReference (Int frame)
     627             : {
     628           0 :      getVii()->setReportingFrameOfReference (frame);
     629           0 : }
     630             : 
     631             : void
     632          62 : TransformingVi2::setRowBlocking (rownr_t nRows)
     633             : {
     634          62 :      getVii()->setRowBlocking (nRows);
     635          62 : }
     636             : 
     637             : rownr_t
     638       13743 : TransformingVi2::getRowBlocking () const
     639             : {
     640       13743 :      return getVii()->getRowBlocking ();
     641             : }
     642             : 
     643             : void
     644         878 : TransformingVi2::setVisBuffer (VisBuffer2 * vb)
     645             : {
     646         878 :     ThrowIf (vb_p != 0, "A VisBuffer is already associated with this VI");
     647             : 
     648         878 :     vb_p = vb;
     649         878 : }
     650             : 
     651             : void
     652      218668 : TransformingVi2::sigma (Matrix<Float> & sig)  const
     653             : {
     654      218668 :      getVii()->sigma (sig);
     655      218668 : }
     656             : 
     657             : void
     658           0 : TransformingVi2::sigma (Vector<Matrix<Float>> & sig)  const
     659             : {
     660           0 :      getVii()->sigma (sig);
     661           0 : }
     662             : 
     663             : void
     664          38 : TransformingVi2::slurp ()  const
     665             : {
     666          38 :      getVii()->slurp ();
     667          38 : }
     668             : 
     669             : String
     670           0 : TransformingVi2::sourceName ()  const
     671             : {
     672           0 :     return getVii()->sourceName ();
     673             : }
     674             : 
     675             : void
     676     1131966 : TransformingVi2::spectralWindows (Vector<Int> & spws) const
     677             : {
     678     1131966 :     getVii()->spectralWindows (spws);
     679     1131966 : }
     680             : 
     681             : void
     682           0 : TransformingVi2::polarizationIds (Vector<Int> & spws) const
     683             : {
     684           0 :     getVii()->polarizationIds (spws);
     685           0 : }
     686             : 
     687             : void
     688       13036 : TransformingVi2::stateId (Vector<Int> & stateids)  const
     689             : {
     690       13036 :      getVii()->stateId (stateids);
     691       13036 : }
     692             : 
     693             : const vi::SubtableColumns &
     694           0 : TransformingVi2::subtableColumns ()  const
     695             : {
     696           0 :     return getVii()->subtableColumns ();
     697             : }
     698             : 
     699             : void
     700      478516 : TransformingVi2::time (Vector<Double> & t)  const
     701             : {
     702      478516 :      getVii()->time (t);
     703      478516 : }
     704             : 
     705             : void
     706      478269 : TransformingVi2::timeCentroid (Vector<Double> & t)  const
     707             : {
     708      478269 :      getVii()->timeCentroid (t);
     709      478269 : }
     710             : 
     711             : void
     712      417166 : TransformingVi2::timeInterval (Vector<Double> & ti)  const
     713             : {
     714      417166 :      getVii()->timeInterval (ti);
     715      417166 : }
     716             : 
     717             : void
     718           0 : TransformingVi2::useImagingWeight (const VisImagingWeight & imWgt)
     719             : {
     720           0 :      getVii()->useImagingWeight (imWgt);
     721           0 : }
     722             : 
     723             : void
     724      415071 : TransformingVi2::uvw (Matrix<Double> & uvwmat)  const
     725             : {
     726      415071 :     getVii()->uvw (uvwmat);
     727      415071 : }
     728             : 
     729             : void
     730           0 : TransformingVi2::visibilityCorrected (Cube<Complex> & vis)  const
     731             : {
     732           0 :     getVii()->visibilityCorrected (vis);
     733           0 : }
     734             : 
     735             : void
     736           0 : TransformingVi2::visibilityCorrected (Vector<Cube<Complex>> & vis) const
     737             : {
     738           0 :     getVii()->visibilityCorrected (vis);
     739           0 : }
     740             : 
     741             : void
     742           0 : TransformingVi2::visibilityModel (Cube<Complex> & vis)  const
     743             : {
     744           0 :     getVii()->visibilityModel (vis);
     745           0 : }
     746             : 
     747             : void
     748           0 : TransformingVi2::visibilityModel (casacore::Vector<casacore::Cube<casacore::Complex>> & vis) const
     749             : {
     750           0 :     getVii()->visibilityModel (vis);
     751           0 : }
     752             : 
     753             : void
     754         120 : TransformingVi2::visibilityObserved (Cube<Complex> & vis)  const
     755             : {
     756         120 :     getVii()->visibilityObserved (vis);
     757         120 : }
     758             : 
     759             : void
     760           0 : TransformingVi2::visibilityObserved (casacore::Vector<casacore::Cube<casacore::Complex>> & vis) const
     761             : {
     762           0 :     getVii()->visibilityObserved (vis);
     763           0 : }
     764             : 
     765             : IPosition
     766     1009459 : TransformingVi2::visibilityShape ()  const
     767             : {
     768     1009459 :     return getVii()->visibilityShape ();
     769             : }
     770             : 
     771             : void
     772         134 : TransformingVi2::weight (Matrix<Float> & wt)  const
     773             : {
     774         134 :      getVii()->weight (wt);
     775         134 : }
     776             : 
     777             : void
     778           0 : TransformingVi2::weight (Vector<Matrix<Float>> & wt)  const
     779             : {
     780           0 :      getVii()->weight (wt);
     781           0 : }
     782             : 
     783             : void
     784         682 : TransformingVi2::weightSpectrum (Cube<Float> & wtsp)  const
     785             : {
     786         682 :      getVii()->weightSpectrum (wtsp);
     787         682 : }
     788             : 
     789             : void
     790           0 : TransformingVi2::weightSpectrum (Vector<Cube<Float>> & wtsp)  const
     791             : {
     792           0 :      getVii()->weightSpectrum (wtsp);
     793           0 : }
     794             : 
     795             : void
     796        3335 : TransformingVi2::sigmaSpectrum (Cube<Float> & sigsp)  const
     797             : {
     798        3335 :      getVii()->sigmaSpectrum (sigsp);
     799        3335 : }
     800             : 
     801             : void
     802           0 : TransformingVi2::sigmaSpectrum (Vector<Cube<Float>> & sigsp)  const
     803             : {
     804           0 :      getVii()->sigmaSpectrum (sigsp);
     805           0 : }
     806             : 
     807             : Bool
     808       15934 : TransformingVi2::weightSpectrumExists ()  const
     809             : {
     810       15934 :     return getVii()->weightSpectrumExists ();
     811             : }
     812             : 
     813             : Bool
     814      195484 : TransformingVi2::sigmaSpectrumExists ()  const
     815             : {
     816      195484 :     return getVii()->sigmaSpectrumExists ();
     817             : }
     818             : 
     819             : void
     820           0 : TransformingVi2::writeBackChanges (VisBuffer2 * /*vb*/)
     821             : {
     822           0 :     Tvi2NotImplemented ();
     823             : }
     824             : 
     825             : void
     826           0 : TransformingVi2::writeFlag (const Matrix<Bool> & /*flag*/)
     827             : {
     828           0 :     Tvi2NotImplemented ();
     829             : }
     830             : 
     831             : void
     832           0 : TransformingVi2::writeFlag (const Cube<Bool> & /*flag*/)
     833             : {
     834           0 :     Tvi2NotImplemented ();
     835             : }
     836             : 
     837             : void
     838           0 : TransformingVi2::writeFlagCategory (const Array<Bool>& /*fc*/)
     839             : {
     840           0 :     Tvi2NotImplemented ();
     841             : }
     842             : 
     843             : void
     844           0 : TransformingVi2::writeFlagRow (const Vector<Bool> & /*rowflags*/)
     845             : {
     846           0 :     Tvi2NotImplemented ();
     847             : }
     848             : 
     849             : void
     850           0 : TransformingVi2::writeModel (const RecordInterface& /*rec*/, Bool /*iscomponentlist*/,
     851             :                             Bool /*incremental*/)
     852             : {
     853           0 :     Tvi2NotImplemented ();
     854             : }
     855             : 
     856             : void
     857           0 : TransformingVi2::writeSigma (const Matrix<Float> & /*sig*/)
     858             : {
     859           0 :     Tvi2NotImplemented ();
     860             : }
     861             : 
     862             : //void
     863             : //TransformingVi2::writeSigmaMat (const Matrix<Float> & /*sigmat*/)
     864             : //{
     865             : //    Tvi2NotImplemented ();
     866             : //}
     867             : 
     868             : //void
     869             : //TransformingVi2::writeVisCorrected (const Matrix<CStokesVector> & /*visibilityStokes*/)
     870             : //{
     871             : //    Tvi2NotImplemented ();
     872             : //}
     873             : 
     874             : void
     875           0 : TransformingVi2::writeVisCorrected (const Cube<Complex> & /*vis*/)
     876             : {
     877           0 :     Tvi2NotImplemented ();
     878             : }
     879             : 
     880             : //void
     881             : //TransformingVi2::writeVisModel (const Matrix<CStokesVector> & /*visibilityStokes*/)
     882             : //{
     883             : //    Tvi2NotImplemented ();
     884             : //}
     885             : 
     886             : void
     887           0 : TransformingVi2::writeVisModel (const Cube<Complex> & /*vis*/)
     888             : {
     889           0 :     Tvi2NotImplemented ();
     890             : }
     891             : 
     892             : //void
     893             : //TransformingVi2::writeVisObserved (const Matrix<CStokesVector> & /*visibilityStokes*/)
     894             : //{
     895             : //    Tvi2NotImplemented ();
     896             : //}
     897             : 
     898             : void
     899           0 : TransformingVi2::writeVisObserved (const Cube<Complex> & /*vis*/)
     900             : {
     901           0 :     Tvi2NotImplemented ();
     902             : }
     903             : 
     904             : void
     905           0 : TransformingVi2::writeWeight (const Matrix<Float> & /*wt*/)
     906             : {
     907           0 :     Tvi2NotImplemented ();
     908             : }
     909             : 
     910             : //void
     911             : //TransformingVi2::writeWeightMat (const Matrix<Float> & /*wtmat*/)
     912             : //{
     913             : //    Tvi2NotImplemented ();
     914             : //}
     915             : 
     916             : void
     917           0 : TransformingVi2::writeWeightSpectrum (const Cube<Float> & /*wtsp*/)
     918             : {
     919           0 :     Tvi2NotImplemented ();
     920             : }
     921             : 
     922             : void
     923           0 : TransformingVi2::writeSigmaSpectrum (const Cube<Float> & /*wtsp*/)
     924             : {
     925           0 :     Tvi2NotImplemented ();
     926             : }
     927             : 
     928             : void
     929         202 : TransformingVi2::setWeightScaling (CountedPtr <WeightScaling> weightScaling)
     930             : {
     931         202 :     getVii()->setWeightScaling(weightScaling);
     932         202 : }
     933             : 
     934             : Bool
     935           0 : TransformingVi2::hasWeightScaling () const
     936             : {
     937           0 :     return getVii()->hasWeightScaling();
     938             : }
     939             : 
     940             : CountedPtr<WeightScaling>
     941      752308 : TransformingVi2::getWeightScaling () const
     942             : {
     943      752308 :     return getVii()->getWeightScaling();
     944             : }
     945             : 
     946             : // -----------------------------------------------------------------------
     947             : // Utility method to calculate FLAG_ROW from flag cube with the applicable convention
     948             : // -----------------------------------------------------------------------
     949         208 : void TransformingVi2::calculateFlagRowFromFlagCube (const Cube<Bool> &flagCube, Vector<Bool> &flagRow)
     950             : {
     951             :         // Get original shape
     952         208 :         IPosition shape = flagCube.shape();
     953         208 :         size_t nCorr = shape(0);
     954         208 :         size_t nChan = shape(1);
     955         208 :         size_t nRows = shape(2);
     956             : 
     957             :         // Reshape flag cube to match the input shape
     958         208 :         flagRow.resize(nRows,false);
     959         208 :         flagRow = false;
     960             : 
     961         208 :         Bool rowFlagValue = false;
     962        8412 :         for (size_t row_i =0;row_i<nRows;row_i++)
     963             :         {
     964        8204 :                 rowFlagValue = true;
     965       57332 :                 for (size_t chan_i =0;chan_i<nChan;chan_i++)
     966             :                 {
     967       57088 :                         if (rowFlagValue)
     968             :                         {
     969      213800 :                                 for (size_t corr_i =0;corr_i<nCorr;corr_i++)
     970             :                                 {
     971      172632 :                                         if (not flagCube(corr_i,chan_i,row_i))
     972             :                                         {
     973        7960 :                                                 rowFlagValue = false;
     974        7960 :                                                 break;
     975             :                                         }
     976             :                                 }
     977             :                         }
     978             :                         else
     979             :                         {
     980        7960 :                                 break;
     981             :                         }
     982             :                 }
     983        8204 :                 flagRow(row_i) = rowFlagValue;
     984             :         }
     985             : 
     986         416 :         return;
     987         208 : }
     988             : 
     989             : //**********************************************************************
     990             : // Methods to access the subtables.
     991             : //**********************************************************************
     992             : 
     993           0 : const casacore::MSAntennaColumns& TransformingVi2::antennaSubtablecols() const
     994             : {
     995           0 :     return getVii()->antennaSubtablecols();
     996             : }
     997             : 
     998         128 : const casacore::MSDataDescColumns& TransformingVi2::dataDescriptionSubtablecols() const
     999             : {
    1000         128 :     return getVii()->dataDescriptionSubtablecols();
    1001             : }
    1002             : 
    1003           0 : const casacore::MSFeedColumns& TransformingVi2::feedSubtablecols() const
    1004             : {
    1005           0 :     return getVii()->feedSubtablecols();
    1006             : }
    1007             : 
    1008           0 : const casacore::MSFieldColumns& TransformingVi2::fieldSubtablecols() const
    1009             : {
    1010           0 :     return getVii()->fieldSubtablecols();
    1011             : }
    1012             : 
    1013           0 : const casacore::MSFlagCmdColumns& TransformingVi2::flagCmdSubtablecols() const
    1014             : {
    1015           0 :     return getVii()->flagCmdSubtablecols();
    1016             : }
    1017             : 
    1018           0 : const casacore::MSHistoryColumns& TransformingVi2::historySubtablecols() const
    1019             : {
    1020           0 :     return getVii()->historySubtablecols();
    1021             : }
    1022             : 
    1023           0 : const casacore::MSObservationColumns& TransformingVi2::observationSubtablecols() const
    1024             : {
    1025           0 :     return getVii()->observationSubtablecols();
    1026             : }
    1027             : 
    1028           0 : const casacore::MSPointingColumns& TransformingVi2::pointingSubtablecols() const
    1029             : {
    1030           0 :     return getVii()->pointingSubtablecols();
    1031             : }
    1032             : 
    1033          49 : const casacore::MSPolarizationColumns& TransformingVi2::polarizationSubtablecols() const
    1034             : {
    1035          49 :     return getVii()->polarizationSubtablecols();
    1036             : }
    1037             : 
    1038           0 : const casacore::MSProcessorColumns& TransformingVi2::processorSubtablecols() const
    1039             : {
    1040           0 :     return getVii()->processorSubtablecols();
    1041             : }
    1042             : 
    1043         550 : const casacore::MSSpWindowColumns& TransformingVi2::spectralWindowSubtablecols() const
    1044             : {
    1045         550 :     return getVii()->spectralWindowSubtablecols();
    1046             : }
    1047             : 
    1048       40134 : const casacore::MSStateColumns& TransformingVi2::stateSubtablecols() const
    1049             : {
    1050       40134 :     return getVii()->stateSubtablecols();
    1051             : }
    1052             : 
    1053           0 : const casacore::MSDopplerColumns& TransformingVi2::dopplerSubtablecols() const
    1054             : {
    1055           0 :     return getVii()->dopplerSubtablecols();
    1056             : }
    1057             : 
    1058           0 : const casacore::MSFreqOffsetColumns& TransformingVi2::freqOffsetSubtablecols() const
    1059             : {
    1060           0 :     return getVii()->freqOffsetSubtablecols();
    1061             : }
    1062             : 
    1063           0 : const casacore::MSSourceColumns& TransformingVi2::sourceSubtablecols() const
    1064             : {
    1065           0 :     return getVii()->sourceSubtablecols();
    1066             : }
    1067             : 
    1068           0 : const casacore::MSSysCalColumns& TransformingVi2::sysCalSubtablecols() const
    1069             : {
    1070           0 :     return getVii()->sysCalSubtablecols();
    1071             : }
    1072             : 
    1073           0 : const casacore::MSWeatherColumns& TransformingVi2::weatherSubtablecols() const
    1074             : {
    1075           0 :     return getVii()->weatherSubtablecols();
    1076             : }
    1077             : 
    1078             : 
    1079             : } // end namespace vi
    1080             : 
    1081             : using namespace casacore;
    1082             : } // end namespace casa