Line data    Source code

       1             : /*
       2             :  * Vbi2MsRow.h
       3             :  *
       4             :  *  Created on: Aug 22, 2013
       5             :  *      Author: jjacobs
       6             :  */
       7             : 
       8             : #ifndef VBI2MSROW_H_
       9             : #define VBI2MSROW_H_
      10             : 
      11             : #include <casacore/casa/Arrays/Array.h>
      12             : #include <msvis/MSVis/MsRows.h>
      13             : 
      14             : // Forward Decls
      15             : 
      16             : namespace casa {
      17             : 
      18             : namespace vi {
      19             : 
      20             : class VisBufferImpl2;
      21             : 
      22             : }
      23             : 
      24             : }
      25             : 
      26             : namespace casa {
      27             : 
      28             : namespace ms {
      29             : 
      30             : class CachedArrayBase {
      31             : 
      32             : public:
      33             : 
      34           0 :     CachedArrayBase () : cached_p (false) {}
      35           0 :     virtual ~CachedArrayBase () {}
      36             : 
      37           0 :     void clearCache () { cached_p = false;}
      38             : 
      39             : protected:
      40             : 
      41           0 :     casacore::Bool isCached () const { return cached_p;}
      42           0 :     void setCached () { cached_p = true;}
      43             : 
      44             : private:
      45             : 
      46             :     casacore::Bool cached_p;
      47             : };
      48             : 
      49             : template <typename T>
      50             : class CachedPlane : public CachedArrayBase {
      51             : 
      52             : public:
      53             : 
      54             : typedef const casacore::Cube<T> & (casa::vi::VisBufferImpl2::* Accessor) () const;
      55             : 
      56           0 : CachedPlane (Accessor accessor) : accessor_p (accessor) {}
      57             : 
      58             : casacore::Matrix<T> &
      59           0 : getCachedPlane (casa::vi::VisBufferImpl2 * vb, casacore::Int row)
      60             : {
      61           0 :     if (! isCached()){
      62             : 
      63             :         //cache_p.reference ((vb ->* accessor_p)().xyPlane (row)); // replace with something more efficient
      64           0 :         referenceMatrix (cache_p, (vb ->* accessor_p)(), row);
      65           0 :         setCached ();
      66             :     }
      67             : 
      68           0 :     return cache_p;
      69             : }
      70             : 
      71             : private:
      72             : 
      73             :     static void
      74           0 :     referenceMatrix (casacore::Matrix<T> & cache, const casacore::Cube<T> & src, casacore::Int row)
      75             :     {
      76           0 :         casacore::IPosition shape = src.shape ();
      77           0 :         shape.resize (2);
      78             : 
      79             :         // This is a bit sleazy but it seems to be helpful to performance.
      80             :         // Assumes contiguously stored cube.
      81             : 
      82           0 :         T * storage = const_cast <T *> (& src (casacore::IPosition (3, 0, 0, row)));
      83             : 
      84           0 :         cache.takeStorage (shape, storage, casacore::SHARE);
      85           0 :     }
      86             : 
      87             :     Accessor accessor_p;
      88             :     casacore::Matrix<T> cache_p;
      89             : };
      90             : 
      91             : template <typename T>
      92             : class CachedColumn : public CachedArrayBase {
      93             : 
      94             : public:
      95             : 
      96             : typedef const casacore::Matrix<T> & (casa::vi::VisBufferImpl2::* Accessor) () const;
      97             : 
      98           0 : CachedColumn (Accessor accessor) : accessor_p (accessor) {}
      99             : 
     100             : casacore::Vector<T> &
     101           0 : getCachedColumn (casa::vi::VisBufferImpl2 * vb, casacore::Int row)
     102             : {
     103           0 :     if (! isCached()){
     104             : 
     105           0 :         referenceVector (cache_p, (vb ->* accessor_p)(), row);
     106           0 :         setCached ();
     107             :     }
     108             : 
     109           0 :     return cache_p;
     110             : }
     111             : 
     112             : private:
     113             : 
     114             :     static void
     115           0 :     referenceVector (casacore::Vector<T> & cache, const casacore::Matrix<T> & src, casacore::Int row)
     116             :     {
     117           0 :         casacore::IPosition shape = src.shape ();
     118           0 :         shape.resize (1);
     119             : 
     120             :         // This is a bit sleazy but it seems to be helpful to performance.
     121             :         // Assumes contiguously stored cube.
     122             : 
     123           0 :         T * storage = const_cast <T *> (& src (casacore::IPosition (2, 0, row)));
     124             : 
     125           0 :         cache.takeStorage (shape, storage, casacore::SHARE);
     126           0 :     }
     127             : 
     128             :     Accessor accessor_p;
     129             :     casacore::Vector<T> cache_p;
     130             : };
     131             : 
     132             : 
     133             : class Vbi2MsRow : public MsRow {
     134             : 
     135             : public:
     136             : 
     137             :     // Constructors
     138             : 
     139             :     // Constructor for read-only access.
     140             :     // Attempt to write will throw exception.
     141             : 
     142             :     Vbi2MsRow (casacore::rownr_t row, const vi::VisBufferImpl2 * vb);
     143             : 
     144             :     // Constructor for read/write access
     145             : 
     146             :     Vbi2MsRow (casacore::rownr_t row, vi::VisBufferImpl2 * vb);
     147             : 
     148           0 :     virtual ~Vbi2MsRow () {}
     149             : 
     150             :     void changeRow (casacore::rownr_t row);
     151             :     void copy (Vbi2MsRow * other,
     152             :                const VisBufferComponents2 & componentsToCopy);
     153             : 
     154             :     casacore::Int antenna1 () const;
     155             :     casacore::Int antenna2 () const;
     156             :     casacore::Int arrayId () const;
     157             :     casacore::Int correlationType () const;
     158             :     casacore::Int dataDescriptionId () const;
     159             :     casacore::Int feed1 () const;
     160             :     casacore::Int feed2 () const;
     161             :     casacore::Int fieldId () const;
     162             :     casacore::Int observationId () const;
     163             :     casacore::Int rowId () const;
     164             :     casacore::Int processorId () const;
     165             :     casacore::Int scanNumber () const;
     166             :     casacore::Int stateId () const;
     167             :     casacore::Double exposure () const;
     168             :     casacore::Double interval () const;
     169             :     casacore::Int spectralWindow () const;
     170             :     casacore::Double time () const;
     171             :     casacore::Double timeCentroid () const;
     172             : 
     173             :     void setAntenna1 (casacore::Int);
     174             :     void setAntenna2 (casacore::Int);
     175             :     void setArrayId (casacore::Int);
     176             :     void setCorrelationType (casacore::Int);
     177             :     void setDataDescriptionId (casacore::Int);
     178             :     void setFeed1 (casacore::Int);
     179             :     void setFeed2 (casacore::Int);
     180             :     void setFieldId (casacore::Int);
     181             :     void setObservationId (casacore::Int);
     182             :     void setProcessorId (casacore::Int);
     183             :     void setRowId (casacore::Int);
     184             :     void setScanNumber (casacore::Int);
     185             :     void setStateId (casacore::Int);
     186             :     void setExposure (casacore::Double);
     187             :     void setInterval (casacore::Double);
     188             :     void setSpectralWindow (casacore::Int);
     189             :     void setTime (casacore::Double);
     190             :     void setTimeCentroid (casacore::Double);
     191             : 
     192             :     const casacore::Vector<casacore::Double> uvw () const;
     193             :     const casacore::Double & uvw (casacore::Int i) const;
     194             :     void setUvw (const casacore::Vector<casacore::Double> &);
     195             :     void setUvw (casacore::Int i, const casacore::Vector<casacore::Double> &);
     196             : 
     197             :     const casacore::Complex & corrected (casacore::Int correlation, casacore::Int channel) const;
     198             :     const casacore::Matrix<casacore::Complex> & corrected () const;
     199             :     casacore::Matrix<casacore::Complex> & correctedMutable ();
     200             :     void setCorrected (casacore::Int correlation, casacore::Int channel, const casacore::Complex & value);
     201             :     void setCorrected (const casacore::Matrix<casacore::Complex> & value);
     202             : 
     203             :     const casacore::Complex & model (casacore::Int correlation, casacore::Int channel) const;
     204             :     const casacore::Matrix<casacore::Complex> & model () const;
     205             :     casacore::Matrix<casacore::Complex> & modelMutable ();
     206             :     void setModel(casacore::Int correlation, casacore::Int channel, const casacore::Complex & value);
     207             :     void setModel (const casacore::Matrix<casacore::Complex> & value);
     208             : 
     209             :     const casacore::Complex & observed (casacore::Int correlation, casacore::Int channel) const;
     210             :     const casacore::Matrix<casacore::Complex> & observed () const;
     211             :     casacore::Matrix<casacore::Complex> & observedMutable ();
     212             :     void setObserved (casacore::Int correlation, casacore::Int channel, const casacore::Complex & value);
     213             :     void setObserved (const casacore::Matrix<casacore::Complex> & value);
     214             : 
     215             :     const casacore::Float & singleDishData (casacore::Int correlation, casacore::Int channel) const;
     216             :     const casacore::Matrix<casacore::Float> singleDishData () const;
     217             :     casacore::Matrix<casacore::Float> singleDishDataMutable ();
     218             :     void setSingleDishData (casacore::Int correlation, casacore::Int channel, const casacore::Float & value);
     219             :     void setSingleDishData (const casacore::Matrix<casacore::Float> & value);
     220             : 
     221             :     casacore::Float sigma (casacore::Int correlation) const;
     222             :     const casacore::Vector<casacore::Float> & sigma () const;
     223             :     casacore::Vector<casacore::Float> & sigmaMutable () const;
     224             :     void setSigma (casacore::Int correlation, casacore::Float value);
     225             :     void setSigma (const casacore::Vector<casacore::Float> & value);
     226             :     casacore::Float weight (casacore::Int correlation) const;
     227             :     const casacore::Vector<casacore::Float> & weight () const;
     228             :     casacore::Vector<casacore::Float> & weightMutable () const;
     229             :     void setWeight (casacore::Int correlation, casacore::Float value);
     230             :     void setWeight (const casacore::Vector<casacore::Float> & value);
     231             :     casacore::Float weightSpectrum (casacore::Int correlation, casacore::Int channel) const;
     232             :     void setWeightSpectrum (casacore::Int correlation, casacore::Int channel, casacore::Float value);
     233             :     void setWeightSpectrum (const casacore::Matrix<casacore::Float> & value);
     234             :     const casacore::Matrix<casacore::Float> & weightSpectrum () const;
     235             :     casacore::Matrix<casacore::Float> & weightSpectrumMutable () const;
     236             :     casacore::Float sigmaSpectrum (casacore::Int correlation, casacore::Int channel) const;
     237             :     const casacore::Matrix<casacore::Float> & sigmaSpectrum () const;
     238             :     casacore::Matrix<casacore::Float> & sigmaSpectrumMutable () const;
     239             :     void setSigmaSpectrum (casacore::Int correlation, casacore::Int channel, casacore::Float value);
     240             :     void setSigmaSpectrum (const casacore::Matrix<casacore::Float> & value);
     241             : 
     242             :     casacore::Bool isRowFlagged () const;
     243             :     const casacore::Matrix<casacore::Bool> & flags () const;
     244             :     void setFlags (const casacore::Matrix<casacore::Bool> & flags);
     245             :     casacore::Bool isFlagged (casacore::Int correlation, casacore::Int channel) const;
     246             : 
     247             :     void setRowFlag (casacore::Bool isFlagged);
     248             :     void setFlags (casacore::Bool isFlagged, casacore::Int correlation, casacore::Int channel);
     249             : 
     250             : protected:
     251             : 
     252             :     template <typename T>
     253           0 :     void addToCachedArrays (T & cachedArray)
     254             :     {
     255           0 :         arrayCaches_p.push_back (& cachedArray);
     256           0 :     }
     257             : 
     258             :     void clearArrayCaches();
     259             :     casacore::Matrix<casacore::Bool> & flagsMutable ();
     260             :     vi::VisBufferImpl2 * getVbi () const;
     261             : 
     262             : private:
     263             : 
     264             :     void configureArrayCaches(); // called in ctor so do not override
     265             : 
     266             :     mutable CachedPlane<casacore::Complex> correctedCache_p;
     267             :     mutable CachedPlane<casacore::Bool> flagCache_p;
     268             :     mutable CachedPlane<casacore::Complex> modelCache_p;
     269             :     mutable CachedPlane<casacore::Complex> observedCache_p;
     270             :     mutable CachedColumn<casacore::Float> sigmaCache_p;
     271             :     mutable CachedPlane<casacore::Float> sigmaSpectrumCache_p;
     272             :     mutable CachedColumn<casacore::Float> weightCache_p;
     273             :     mutable CachedPlane<casacore::Float> weightSpectrumCache_p;
     274             : 
     275             :     std::vector<CachedArrayBase *> arrayCaches_p;
     276             : 
     277             : template <typename T, typename U>
     278             : void
     279             : copyIf (casacore::Bool copyThis, Vbi2MsRow * other,
     280             :                    void (Vbi2MsRow::* setter) (T),
     281             :                    U (Vbi2MsRow::* getter) () const);
     282             : 
     283             :     vi::VisBufferImpl2 * vbi2_p;
     284             : 
     285             : };
     286             : 
     287             : }
     288             : 
     289             : } // end namespace casa
     290             : 
     291             : 
     292             : #endif /* VBI2MSROW_H_ */