Line data    Source code

       1             : /*
       2             :  * Vbi2MsRow.cc
       3             :  *
       4             :  *  Created on: Aug 22, 2013
       5             :  *      Author: jjacobs
       6             :  */
       7             : 
       8             : #include <casacore/casa/Exceptions.h>
       9             : #include <casacore/measures/Measures/MDirection.h>
      10             : #include <msvis/MSVis/Vbi2MsRow.h>
      11             : #include <msvis/MSVis/VisibilityIterator2.h>
      12             : #include <msvis/MSVis/VisModelDataI.h>
      13             : #include <msvis/MSVis/VisBufferImpl2.h>
      14             : #include <msvis/MSVis/VisBufferImpl2Internal.h>
      15             : 
      16             : #define AssertWritable() ThrowIf (! isWritable (), "Cannot write to this MsRow object")
      17             : 
      18             : using casa::vi::VisBufferImpl2;
      19             : 
      20             : using namespace casacore;
      21             : namespace casa {
      22             : 
      23             : namespace ms {
      24             : 
      25             : 
      26      592578 : Vbi2MsRow::Vbi2MsRow (rownr_t row, const VisBufferImpl2 * vb)
      27             : : MsRow (row, vb),
      28      592578 :   correctedCache_p (& VisBufferImpl2::visCubeCorrected),
      29      592578 :   flagCache_p (& VisBufferImpl2::flagCube),
      30      592578 :   modelCache_p(& VisBufferImpl2::visCubeModel),
      31      592578 :   observedCache_p(&VisBufferImpl2::visCube),
      32      592578 :   sigmaCache_p (&VisBufferImpl2::sigma),
      33      592578 :   sigmaSpectrumCache_p(& VisBufferImpl2::sigmaSpectrum),
      34      592578 :   weightCache_p (&VisBufferImpl2::weight),
      35      592578 :   weightSpectrumCache_p(& VisBufferImpl2::weightSpectrum),
      36     1185156 :   vbi2_p (const_cast<VisBufferImpl2 *> (vb))
      37             : {
      38      592578 :     configureArrayCaches ();
      39      592578 : }
      40             : 
      41             : 
      42      607630 : Vbi2MsRow::Vbi2MsRow (rownr_t row, VisBufferImpl2 * vb)
      43             : : MsRow (row, vb),
      44      607630 :   correctedCache_p (& VisBufferImpl2::visCubeCorrected),
      45      607630 :   flagCache_p (& VisBufferImpl2::flagCube),
      46      607630 :   modelCache_p(& VisBufferImpl2::visCubeModel),
      47      607630 :   observedCache_p(&VisBufferImpl2::visCube),
      48      607630 :   sigmaCache_p (&VisBufferImpl2::sigma),
      49      607630 :   sigmaSpectrumCache_p(& VisBufferImpl2::sigmaSpectrum),
      50      607630 :   weightCache_p (&VisBufferImpl2::weight),
      51      607630 :   weightSpectrumCache_p(& VisBufferImpl2::weightSpectrum),
      52     1215260 :   vbi2_p (vb)
      53             : {
      54      607630 :     configureArrayCaches ();
      55      607630 : }
      56             : 
      57             : void
      58     1200208 : Vbi2MsRow::configureArrayCaches ()
      59             : {
      60     1200208 :     arrayCaches_p.push_back (& correctedCache_p);
      61     1200208 :     arrayCaches_p.push_back (& flagCache_p);
      62     1200208 :     arrayCaches_p.push_back (& modelCache_p);
      63     1200208 :     arrayCaches_p.push_back (& observedCache_p);
      64     1200208 :     arrayCaches_p.push_back (& sigmaCache_p);
      65     1200208 :     arrayCaches_p.push_back (& sigmaSpectrumCache_p);
      66     1200208 :     arrayCaches_p.push_back (& weightCache_p);
      67     1200208 :     arrayCaches_p.push_back (& weightSpectrumCache_p);
      68     1200208 : }
      69             : 
      70             : void
      71    22761773 : Vbi2MsRow::clearArrayCaches ()
      72             : {
      73    22761773 :     for (std::vector<CachedArrayBase *>::iterator i = arrayCaches_p.begin();
      74   216169985 :          i != arrayCaches_p.end();
      75   193408212 :          i ++){
      76   193408212 :         (* i)->clearCache();
      77             :     }
      78    22761773 : }
      79             : 
      80             : void
      81    22761773 : Vbi2MsRow::changeRow (rownr_t row)
      82             : {
      83    22761773 :     MsRow::changeRow (row);
      84    22761773 :     clearArrayCaches ();
      85    22761773 : }
      86             : 
      87             : ////////////////////////////////////////////////////////////
      88             : //
      89             : // Scalar getters
      90             : //
      91             : 
      92             : Int
      93    11937964 : Vbi2MsRow::antenna1 () const
      94             : {
      95    11937964 :     return vbi2_p->antenna1 () (row ());
      96             : }
      97             : 
      98             : Int
      99    11937964 : Vbi2MsRow::antenna2 () const
     100             : {
     101    11937964 :     return vbi2_p->antenna2 () (row ());
     102             : }
     103             : 
     104             : Int
     105      980438 : Vbi2MsRow::arrayId () const
     106             : {
     107      980438 :     return vbi2_p->arrayId () (row ());
     108             : }
     109             : 
     110             : Int
     111           0 : Vbi2MsRow::correlationType () const
     112             : {
     113           0 :     return vbi2_p->correlationTypes () (row ());
     114             : }
     115             : 
     116             : 
     117             : template <typename T, typename U>
     118             : void
     119     2941314 : Vbi2MsRow::copyIf (Bool copyThis, Vbi2MsRow * other,
     120             :                    void (Vbi2MsRow::* setter) (T),
     121             :                    U (Vbi2MsRow::* getter) () const)
     122             : {
     123     2941314 :     if (copyThis){
     124     1718985 :         (this ->* setter) ((other ->* getter) ());
     125             :     }
     126     2941314 : }
     127             : 
     128             : void
     129      490219 : Vbi2MsRow::copy (Vbi2MsRow * other,
     130             :                  const VisBufferComponents2 & componentsToCopy)
     131             : {
     132             :     // Copy the data contents of the other row into this one
     133             : 
     134      490219 :     setAntenna1 (other->antenna1 ());
     135      490219 :     setAntenna2 (other->antenna2 ());
     136      490219 :     setArrayId (other->arrayId ());
     137      490219 :     setDataDescriptionId (other->dataDescriptionId ());
     138      490219 :     setExposure (other->exposure ());
     139      490219 :     setFeed1 (other->feed1 ());
     140      490219 :     setFeed2 (other->feed2 ());
     141      490219 :     setFieldId (other->fieldId ());
     142      490219 :     setFlags (other->flags ());
     143      490219 :     setInterval (other->interval ());
     144      490219 :     setObservationId (other->observationId ());
     145      490219 :     setProcessorId (other->processorId ());
     146      490219 :     setRowFlag (other->isRowFlagged());
     147      490219 :     setRowId (other->rowId());
     148      490219 :     setScanNumber (other->scanNumber ());
     149      490219 :     setSigma (other->sigma ());
     150      490219 :     setSpectralWindow (other->spectralWindow());
     151      490219 :     setStateId (other->stateId ());
     152      490219 :     setTime (other->time ());
     153      490219 :     setTimeCentroid (other->timeCentroid ());
     154      490219 :     setUvw (other->uvw ());
     155      490219 :     setWeight (other->weight ());
     156             : 
     157             :     // Optionally copied fields
     158             : 
     159      490219 :     copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeCorrected), other,
     160             :             & Vbi2MsRow::setCorrected, & Vbi2MsRow::corrected );
     161      490219 :     copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeModel), other,
     162             :             & Vbi2MsRow::setModel, & Vbi2MsRow::model );
     163      490219 :     copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeObserved), other,
     164             :             & Vbi2MsRow::setObserved, & Vbi2MsRow::observed );
     165      490219 :     copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeFloat), other,
     166             :             & Vbi2MsRow::setSingleDishData, & Vbi2MsRow::singleDishData );
     167      490219 :     copyIf (componentsToCopy.contains (VisBufferComponent2::WeightSpectrum), other,
     168             :             & Vbi2MsRow::setWeightSpectrum, & Vbi2MsRow::weightSpectrum );
     169      490219 :     copyIf (componentsToCopy.contains (VisBufferComponent2::SigmaSpectrum), other,
     170             :             & Vbi2MsRow::setSigmaSpectrum, & Vbi2MsRow::sigmaSpectrum );
     171      490219 : }
     172             : 
     173             : 
     174             : Int
     175      980438 : Vbi2MsRow::dataDescriptionId () const
     176             : {
     177      980438 :     return vbi2_p->dataDescriptionIds () (row ());
     178             : }
     179             : 
     180             : Int
     181      980438 : Vbi2MsRow::feed1 () const
     182             : {
     183      980438 :     return vbi2_p->feed1 () (row ());
     184             : }
     185             : 
     186             : Int
     187      980438 : Vbi2MsRow::feed2 () const
     188             : {
     189      980438 :     return vbi2_p->feed2 () (row ());
     190             : }
     191             : 
     192             : Int
     193      980438 : Vbi2MsRow::fieldId () const
     194             : {
     195      980438 :     return vbi2_p->fieldId () (row ());
     196             : }
     197             : 
     198             : VisBufferImpl2 *
     199    11476550 : Vbi2MsRow::getVbi () const
     200             : {
     201    11476550 :     return vbi2_p;
     202             : }
     203             : 
     204             : 
     205             : Bool
     206    11447745 : Vbi2MsRow::isRowFlagged () const
     207             : {
     208    11447745 :     return vbi2_p->flagRow () (row ());
     209             : }
     210             : 
     211             : const Matrix<Bool> &
     212    23413789 : Vbi2MsRow::flags () const
     213             : {
     214    23413789 :     return flagCache_p.getCachedPlane (vbi2_p, row());
     215             : }
     216             : 
     217             : Matrix<Bool> &
     218    21915052 : Vbi2MsRow::flagsMutable ()
     219             : {
     220    21915052 :     return flagCache_p.getCachedPlane (vbi2_p, row());
     221             : }
     222             : 
     223             : Bool
     224           0 : Vbi2MsRow::isFlagged (Int correlation, Int channel) const
     225             : {
     226           0 :     return vbi2_p->flagCube () (correlation,channel, row ());
     227             : }
     228             : 
     229             : 
     230             : Int
     231      980438 : Vbi2MsRow::observationId () const
     232             : {
     233      980438 :     return vbi2_p->observationId () (row ());
     234             : }
     235             : 
     236             : Int
     237      980438 : Vbi2MsRow::processorId () const
     238             : {
     239      980438 :     return vbi2_p->processorId () (row ());
     240             : }
     241             : 
     242             : Int
     243      980438 : Vbi2MsRow::scanNumber () const
     244             : {
     245      980438 :     return vbi2_p->scan () (row ());
     246             : }
     247             : 
     248             : Int
     249      980438 : Vbi2MsRow::stateId () const
     250             : {
     251      980438 :     return vbi2_p->stateId () (row ());
     252             : }
     253             : 
     254             : Double
     255    22405271 : Vbi2MsRow::exposure () const
     256             : {
     257    22405271 :     return vbi2_p->exposure () (row ());
     258             : }
     259             : 
     260             : Double
     261    12378674 : Vbi2MsRow::interval () const
     262             : {
     263    12378674 :     return vbi2_p->timeInterval () (row ());
     264             : }
     265             : 
     266             : Int
     267      490219 : Vbi2MsRow::rowId () const
     268             : {
     269      490219 :     return vbi2_p->rowIds() (row());
     270             : }
     271             : 
     272             : Float
     273     2979222 : Vbi2MsRow::sigma (Int correlation) const
     274             : {
     275     2979222 :     return vbi2_p->sigma () (correlation, row ());
     276             : }
     277             : 
     278             : Int
     279    11937964 : Vbi2MsRow::spectralWindow () const
     280             : {
     281    11937964 :     return vbi2_p->spectralWindows() (row());
     282             : }
     283             : 
     284             : 
     285             : Double
     286    23107059 : Vbi2MsRow::time () const
     287             : {
     288    23107059 :     return vbi2_p->time () (row ());
     289             : }
     290             : Double
     291    22895490 : Vbi2MsRow::timeCentroid () const
     292             : {
     293    22895490 :     return vbi2_p->timeCentroid () (row ());
     294             : }
     295             : 
     296             : Float
     297    38417354 : Vbi2MsRow::weight (Int correlation) const
     298             : {
     299    38417354 :     return vbi2_p->weight () (correlation, row ());
     300             : }
     301             : 
     302             : 
     303             : ////////////////////////////////////////////////////////////
     304             : //
     305             : // Scalar setters
     306             : //
     307             : 
     308             : void
     309      980438 : Vbi2MsRow::setAntenna1 (Int value)
     310             : {
     311      980438 :     AssertWritable();
     312             : 
     313      980438 :     vbi2_p->cache_p->antenna1_p.getRef (false) (row ()) = value;
     314      980438 : }
     315             : 
     316             : void
     317      980438 : Vbi2MsRow::setAntenna2 (Int value)
     318             : {
     319      980438 :     AssertWritable();
     320             : 
     321      980438 :     vbi2_p->cache_p->antenna2_p.getRef (false)(row ()) = value;
     322      980438 : }
     323             : 
     324             : void
     325      980438 : Vbi2MsRow::setArrayId (Int value)
     326             : {
     327      980438 :     AssertWritable();
     328             : 
     329      980438 :     vbi2_p->cache_p->arrayId_p.getRef (false)(row ()) = value;
     330      980438 : }
     331             : 
     332             : void
     333           0 : Vbi2MsRow::setCorrelationType (Int value)
     334             : {
     335           0 :     AssertWritable();
     336             : 
     337           0 :     vbi2_p->cache_p->corrType_p.getRef (false)(row ()) = value;
     338           0 : }
     339             : 
     340             : 
     341             : 
     342             : void
     343      980438 : Vbi2MsRow::setDataDescriptionId (Int value)
     344             : {
     345      980438 :     AssertWritable();
     346             : 
     347      980438 :     vbi2_p->cache_p->dataDescriptionIds_p.getRef (false)(row ()) = value;
     348      980438 : }
     349             : 
     350             : void
     351      980438 : Vbi2MsRow::setFeed1 (Int value)
     352             : {
     353      980438 :     AssertWritable();
     354             : 
     355      980438 :     vbi2_p->cache_p->feed1_p.getRef (false)(row ()) = value;
     356      980438 : }
     357             : 
     358             : void
     359      980438 : Vbi2MsRow::setFeed2 (Int value)
     360             : {
     361      980438 :     AssertWritable();
     362             : 
     363      980438 :     vbi2_p->cache_p->feed2_p.getRef (false)(row ()) = value;
     364      980438 : }
     365             : 
     366             : void
     367      980438 : Vbi2MsRow::setFieldId (Int value)
     368             : {
     369      980438 :     AssertWritable();
     370             : 
     371      980438 :     vbi2_p->cache_p->fieldId_p.getRef (false)(row ()) = value;
     372      980438 : }
     373             : 
     374             : void
     375      980438 : Vbi2MsRow::setRowId (Int value)
     376             : {
     377      980438 :     AssertWritable();
     378             : 
     379      980438 :     vbi2_p->cache_p->rowIds_p.getRef (false) (row ()) = value;
     380      980438 : }
     381             : 
     382             : void
     383    12428183 : Vbi2MsRow::setRowFlag (Bool isFlagged)
     384             : {
     385    12428183 :     AssertWritable ();
     386             : 
     387    12428183 :     vbi2_p->cache_p->flagRow_p.getRef (false)(row ()) = isFlagged;
     388    12428183 : }
     389             : 
     390             : void
     391           0 : Vbi2MsRow::setFlags (Bool isFlagged, Int correlation, Int channel)
     392             : {
     393           0 :     AssertWritable ();
     394             : 
     395           0 :     vbi2_p->cache_p->flagCube_p.getRef (false)(correlation,channel, row ()) = isFlagged;
     396           0 : }
     397             : 
     398             : void
     399      980438 : Vbi2MsRow::setFlags (const Matrix<Bool> & value)
     400             : {
     401      980438 :     AssertWritable ();
     402             : 
     403      980438 :     Matrix<Bool> & flags = flagCache_p.getCachedPlane (vbi2_p, row());
     404      980438 :     flags = value;
     405      980438 : }
     406             : 
     407             : void
     408      980438 : Vbi2MsRow::setObservationId (Int value)
     409             : {
     410      980438 :     AssertWritable();
     411             : 
     412      980438 :     vbi2_p->cache_p->observationId_p.getRef (false)(row ()) = value;
     413      980438 : }
     414             : 
     415             : void
     416      980438 : Vbi2MsRow::setProcessorId (Int value)
     417             : {
     418      980438 :     AssertWritable();
     419             : 
     420      980438 :     vbi2_p->cache_p->processorId_p.getRef (false)(row ()) = value;
     421      980438 : }
     422             : 
     423             : void
     424      980438 : Vbi2MsRow::setScanNumber (Int value)
     425             : {
     426      980438 :     AssertWritable();
     427             : 
     428      980438 :     vbi2_p->cache_p->scan_p.getRef (false)(row ()) = value;
     429      980438 : }
     430             : 
     431             : void
     432      980438 : Vbi2MsRow::setSpectralWindow (Int value)
     433             : {
     434      980438 :     vbi2_p->cache_p->spectralWindows_p.getRef (false)(row ()) = value;
     435      980438 : }
     436             : 
     437             : void
     438      980438 : Vbi2MsRow::setStateId (Int value)
     439             : {
     440      980438 :     AssertWritable();
     441             : 
     442      980438 :     vbi2_p->cache_p->stateId_p.getRef (false)(row ()) = value;
     443      980438 : }
     444             : 
     445             : void
     446    11447745 : Vbi2MsRow::setExposure (Double value)
     447             : {
     448    11447745 :     AssertWritable();
     449             : 
     450    11447745 :     vbi2_p->cache_p->exposure_p.getRef (false)(row ()) = value;
     451    11447745 : }
     452             : 
     453             : void
     454     1421148 : Vbi2MsRow::setInterval (Double value)
     455             : {
     456     1421148 :     AssertWritable();
     457             : 
     458     1421148 :     vbi2_p->cache_p->timeInterval_p.getRef (false)(row ()) = value;
     459     1421148 : }
     460             : 
     461             : void
     462           0 : Vbi2MsRow::setSigma (Int correlation, Float value)
     463             : {
     464           0 :     AssertWritable();
     465             : 
     466           0 :     vbi2_p->cache_p->sigma_p.getRef (false)(correlation, row ()) = value;
     467           0 : }
     468             : 
     469             : void
     470      980438 : Vbi2MsRow::setTime (Double value)
     471             : {
     472      980438 :     AssertWritable();
     473             : 
     474      980438 :     vbi2_p->cache_p->time_p.getRef (false)(row ()) = value;
     475      980438 : }
     476             : 
     477             : void
     478    12428183 : Vbi2MsRow::setTimeCentroid (Double value)
     479             : {
     480    12428183 :     AssertWritable();
     481             : 
     482    12428183 :     vbi2_p->cache_p->timeCentroid_p.getRef (false)(row ()) = value;
     483    12428183 : }
     484             : 
     485             : void
     486           0 : Vbi2MsRow::setWeight (Int correlation, Float value)
     487             : {
     488           0 :     AssertWritable();
     489             : 
     490           0 :     vbi2_p->cache_p->weight_p.getRef (false)(correlation, row ()) = value;
     491           0 : }
     492             : 
     493             : ////////////////////////////////////////////////////////////
     494             : //
     495             : // Nonscalar getters
     496             : //
     497             : 
     498             : const Complex &
     499           0 : Vbi2MsRow::corrected (Int correlation, Int channel) const
     500             : {
     501           0 :     return vbi2_p->visCubeCorrected () (correlation, channel, row ());
     502             : }
     503             : 
     504             : 
     505             : Float
     506           0 : Vbi2MsRow::weightSpectrum (Int correlation, Int channel) const
     507             : {
     508           0 :     return vbi2_p->weightSpectrum () (correlation, channel, row ());
     509             : }
     510             : 
     511             : 
     512             : Float
     513           0 : Vbi2MsRow::sigmaSpectrum (Int correlation, Int channel) const
     514             : {
     515           0 :     return vbi2_p->sigmaSpectrum () (correlation, channel, row ());
     516             : }
     517             : 
     518             : 
     519             : const Complex &
     520           0 : Vbi2MsRow::model (Int correlation, Int channel) const
     521             : {
     522           0 :     return vbi2_p->visCubeModel () (correlation, channel, row ());
     523             : }
     524             : 
     525             : 
     526             : const Complex &
     527           0 : Vbi2MsRow::observed (Int correlation, Int channel) const
     528             : {
     529           0 :     return vbi2_p->visCube () (correlation, channel, row ());
     530             : }
     531             : 
     532           0 : const Float & Vbi2MsRow::singleDishData (Int correlation, Int channel) const
     533             : {
     534           0 :     return vbi2_p->visCubeFloat () (correlation, channel, row ());
     535             : }
     536             : 
     537             : const Vector<Double>
     538    23402701 : Vbi2MsRow::uvw () const
     539             : {
     540    23402701 :     return vbi2_p->uvw ().column (row());
     541             : }
     542             : 
     543             : void
     544    11937964 : Vbi2MsRow::setUvw (const Vector<Double> & value)
     545             : {
     546    11937964 :     vbi2_p->cache_p->uvw_p.getRef(false).column (row()) = value;
     547    11937964 : }
     548             : 
     549             : const Matrix<Complex> &
     550     9957626 : Vbi2MsRow::corrected () const
     551             : {
     552     9957626 :     return correctedCache_p.getCachedPlane (vbi2_p, row());
     553             : }
     554             : 
     555             : Matrix<Complex> &
     556     9957626 : Vbi2MsRow::correctedMutable ()
     557             : {
     558     9957626 :     return correctedCache_p.getCachedPlane (vbi2_p, row());
     559             : }
     560             : 
     561             : void
     562      251047 : Vbi2MsRow::setCorrected (const Matrix<Complex> & value)
     563             : {
     564      251047 :     AssertWritable();
     565             : 
     566      251047 :     Matrix<Complex> & corrected = correctedCache_p.getCachedPlane (vbi2_p, row());
     567      251047 :     corrected = value;
     568      251047 : }
     569             : 
     570             : const Matrix<Complex> &
     571     9936195 : Vbi2MsRow::model () const
     572             : {
     573     9936195 :     return modelCache_p.getCachedPlane (vbi2_p, row());
     574             : }
     575             : 
     576             : Matrix<Complex> &
     577     9936195 : Vbi2MsRow::modelMutable ()
     578             : {
     579     9936195 :     return modelCache_p.getCachedPlane (vbi2_p, row());
     580             : }
     581             : 
     582             : void
     583      249053 : Vbi2MsRow::setModel (const Matrix<Complex> & value)
     584             : {
     585      249053 :     AssertWritable();
     586             : 
     587      249053 :     Matrix<Complex> & model = modelCache_p.getCachedPlane (vbi2_p, row());
     588      249053 :     model = value;
     589      249053 : }
     590             : 
     591             : const Matrix<Complex> &
     592     1364231 : Vbi2MsRow::observed () const
     593             : {
     594     1364231 :     return observedCache_p.getCachedPlane (vbi2_p, row());
     595             : }
     596             : 
     597             : Matrix<Complex> &
     598     1364231 : Vbi2MsRow::observedMutable ()
     599             : {
     600     1364231 :     return observedCache_p.getCachedPlane (vbi2_p, row());
     601             : }
     602             : 
     603             : void
     604      237766 : Vbi2MsRow::setObserved (const Matrix<Complex> & value)
     605             : {
     606      237766 :     AssertWritable();
     607             : 
     608      237766 :     Matrix<Complex> & observed = observedCache_p.getCachedPlane (vbi2_p, row());
     609      237766 :     observed = value;
     610      237766 : }
     611             : 
     612             : const Vector<Float> &
     613    11909884 : Vbi2MsRow::sigma () const
     614             : {
     615    11909884 :     return sigmaCache_p.getCachedColumn (vbi2_p, row());
     616             : }
     617             : 
     618             : Vector<Float> &
     619    10957526 : Vbi2MsRow::sigmaMutable () const
     620             : {
     621    10957526 :     return sigmaCache_p.getCachedColumn (vbi2_p, row());
     622             : }
     623             : 
     624             : void
     625      518299 : Vbi2MsRow::setSigma (const Vector<Float> & value)
     626             : {
     627      518299 :     AssertWritable();
     628             : 
     629      518299 :     Vector<Float> & sigma = sigmaCache_p.getCachedColumn (vbi2_p, row());
     630      518299 :     sigma = value;
     631      518299 : }
     632             : 
     633       93972 : const Matrix<Float> Vbi2MsRow::singleDishData () const
     634             : {
     635       93972 :     return vbi2_p->visCubeFloat ().xyPlane (row());
     636             : }
     637             : 
     638             : Matrix<Float>
     639       93972 : Vbi2MsRow::singleDishDataMutable ()
     640             : {
     641       93972 :     return vbi2_p->visCubeFloat ().xyPlane (row());
     642             : }
     643             : 
     644             : void
     645         681 : Vbi2MsRow::setSingleDishData (const Matrix<Float> & value)
     646             : {
     647         681 :     vbi2_p->cache_p->floatDataCube_p.getRef(false).xyPlane (row()) = value;
     648         681 : }
     649             : 
     650             : 
     651             : 
     652             : const Vector<Float> &
     653    11909884 : Vbi2MsRow::weight () const
     654             : {
     655    11909884 :     return weightCache_p.getCachedColumn (vbi2_p, row());
     656             : }
     657             : 
     658             : Vector<Float> &
     659    10957526 : Vbi2MsRow::weightMutable () const
     660             : {
     661    10957526 :     return weightCache_p.getCachedColumn (vbi2_p, row());
     662             : }
     663             : 
     664             : void
     665     1470657 : Vbi2MsRow::setWeight (const Vector<Float> & value)
     666             : {
     667     1470657 :     AssertWritable();
     668             : 
     669     1470657 :     Vector<Float> & weight = weightCache_p.getCachedColumn (vbi2_p, row());
     670     1470657 :     weight = value;
     671     1470657 : }
     672             : 
     673             : void
     674      980438 : Vbi2MsRow::setWeightSpectrum (const Matrix<Float> & value)
     675             : {
     676      980438 :     AssertWritable();
     677             : 
     678      980438 :     Matrix<Float> & weightSpectrum = weightSpectrumCache_p.getCachedPlane (vbi2_p, row());
     679      980438 :     weightSpectrum = value;
     680      980438 : }
     681             : 
     682             : const Matrix<Float> &
     683    11830818 : Vbi2MsRow::weightSpectrum () const
     684             : {
     685    11830818 :     return weightSpectrumCache_p.getCachedPlane (vbi2_p, row());
     686             : }
     687             : 
     688             : Matrix<Float> &
     689    10957526 : Vbi2MsRow::weightSpectrumMutable () const
     690             : {
     691    10957526 :     return weightSpectrumCache_p.getCachedPlane (vbi2_p, row());
     692             : }
     693             : 
     694             : const Matrix<Float> &
     695     2256354 : Vbi2MsRow::sigmaSpectrum () const
     696             : {
     697     2256354 :     return sigmaSpectrumCache_p.getCachedPlane (vbi2_p, row());
     698             : }
     699             : 
     700             : Matrix<Float> &
     701    10957526 : Vbi2MsRow::sigmaSpectrumMutable () const
     702             : {
     703    10957526 :     return sigmaSpectrumCache_p.getCachedPlane (vbi2_p, row());
     704             : }
     705             : 
     706             : void
     707      980438 : Vbi2MsRow::setSigmaSpectrum (const Matrix<Float> & value)
     708             : {
     709      980438 :     AssertWritable();
     710             : 
     711      980438 :     Matrix<Float> & sigmaSpectrum = sigmaSpectrumCache_p.getCachedPlane (vbi2_p, row());
     712      980438 :     sigmaSpectrum = value;
     713      980438 : }
     714             : 
     715             : ////////////////////////////////////////////////////////////
     716             : //
     717             : // Nonscalar setters
     718             : //
     719             : 
     720             : void
     721           0 : Vbi2MsRow::setCorrected (Int correlation, Int channel, const Complex & value)
     722             : {
     723           0 :     AssertWritable();
     724             : 
     725           0 :     vbi2_p->cache_p->correctedVisCube_p.getRef (false)(correlation, channel, row ()) = value;
     726           0 : }
     727             : 
     728             : void
     729           0 : Vbi2MsRow::setWeightSpectrum (Int correlation, Int channel, Float value)
     730             : {
     731           0 :     AssertWritable();
     732             : 
     733           0 :     vbi2_p->cache_p->weightSpectrum_p.getRef (false)(correlation, channel, row ()) = value;
     734           0 : }
     735             : 
     736             : 
     737             : void
     738           0 : Vbi2MsRow::setSigmaSpectrum (Int correlation, Int channel, Float value)
     739             : {
     740           0 :     AssertWritable();
     741             : 
     742           0 :     vbi2_p->cache_p->sigmaSpectrum_p.getRef (false)(correlation, channel, row ()) = value;
     743           0 : }
     744             : 
     745             : 
     746             : void
     747           0 : Vbi2MsRow::setModel (Int correlation, Int channel, const Complex & value)
     748             : {
     749           0 :     AssertWritable();
     750             : 
     751           0 :     vbi2_p->cache_p->modelVisCube_p.getRef (false)(correlation, channel, row ()) = value;
     752           0 : }
     753             : 
     754             : void
     755           0 : Vbi2MsRow::setObserved (Int correlation, Int channel, const Complex & value)
     756             : {
     757           0 :     AssertWritable();
     758             : 
     759           0 :     vbi2_p->cache_p->visCube_p.getRef (false)(correlation, channel, row ()) = value;
     760           0 : }
     761             : 
     762             : void
     763           0 : Vbi2MsRow::setSingleDishData (Int correlation, Int channel, const Float & value)
     764             : {
     765           0 :     AssertWritable();
     766             : 
     767           0 :     vbi2_p->cache_p->floatDataCube_p.getRef (false)(correlation, channel, row ()) = value;
     768           0 : }
     769             : 
     770             : 
     771             : 
     772             : }
     773             : }
     774             : 
     775             :