PlotMSCacheBase.h

Go to the documentation of this file.

//# PlotMSCacheBase.h: Generic Data cache for plotms.
//# Copyright (C) 2009
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: aips2-request@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
//#
//# $Id: $
#ifndef PLOTMSCACHEBASE_H_
#define PLOTMSCACHEBASE_H_

#include <plotms/PlotMS/PlotMSAveraging.h>
#include <plotms/PlotMS/PlotMSConstants.h>
#include <plotms/PlotMS/PlotMSFlagging.h>
#include <plotms/PlotMS/PlotMSTransformations.h>
#include <plotms/PlotMS/PlotMSCalibration.h>

#include <casa/aips.h>
#include <casa/Arrays.h>
#include <casa/Containers/Block.h>
#include <measures/Measures/MFrequency.h>

#include <QVector>

namespace casa {

//# Forward declarations.
class PlotMSApp;
class PlotMSIndexer;
class ThreadCommunication;

class PlotMSCacheBase {
  
  // Friend class declarations.
  friend class PlotMSIndexer;

  //TBD:    friend class PlotMSData;

public:    

  // Varieties of cache
  // TBD: move to PlotMSConstants?
  enum Type {MS, CAL};
  
  static const unsigned int THREAD_SEGMENT;
  static const PMS::Axis METADATA[];
  static const unsigned int N_METADATA;
    
  static bool axisIsMetaData(PMS::Axis axis);

  
  // Constructor which takes parent PlotMS.
  PlotMSCacheBase(PlotMSApp* parent);
  
  // Destructor
  virtual ~PlotMSCacheBase();

  // Identify myself
  //  pure virtual
  virtual PlotMSCacheBase::Type cacheType() const = 0;

  // Access to pol names
  virtual String polname(Int ipol)=0;

  // keep MS/CT filename (set cal type for CT)
  virtual void setFilename(String filename) = 0;
  String calType() const { return calType_; };
  bool polnRatio() const { return polnRatio_; };

  // Meta axes info
  int nmetadata() const {return N_METADATA;};
  PMS::Axis metadata(int i) {return METADATA[i];};
  
  // Reference an indexer; returns -1 if there is no indexer
  // for the given dataIndex.
  Int nIter( int dataIndex ) const;

  PlotMSIndexer& indexer( int dataIndex, uInt i) {
          return (*indexer_[dataIndex][i]);
  };
  PlotMSIndexer& indexer0() {
          return *indexer0_;
  };
  void resizeIndexer( int size );
  int getDataCount() const {
          return currentX_.size();
  }

  PMS::Axis getIterAxis() const;

  // Report the number of chunks
  Int nChunk() const { return nChunk_; };

  // Returns whether cache is filled
  bool cacheReady() const { return dataLoaded_; }

  // Returns whether user canceled during loading chunks
  bool wasCanceled() const { return userCanceled_; }

  // Report the data shapes
  inline Matrix<Int>& chunkShapes() {return chshapes_;};

  // A chunk is good (T) if it contains data
  //  (when averaging, some chunks may have nrows=0)
  inline Bool goodChunk(Int ichunk) {return goodChunk_(ichunk); };

  // Is there a reference value for the specified axis?
  // TBD: actually make this axis-dep?
  inline bool hasReferenceValue(PMS::Axis axis) { return (axis==PMS::TIME && cacheReady()); };
  inline double referenceValue(PMS::Axis axis) { return (hasReferenceValue(axis) ? refTime() : 0.0); };
  
  // Report the reference time for this cache (in seconds)
  inline Double refTime() const { return refTime_p; };

  // Frequency frame in original MS or requested by user
  inline MFrequency::Types getFreqFrame() const { return freqFrame_; };

  // Returns which axes have been loaded into the cache, including metadata.
  // Also includes the size (number of points) for each axis (which will
  // eventually be used for a cache manager to let the user know the
  // relative memory use of each axis).
  std::vector<pair<PMS::Axis, unsigned int> > loadedAxes() const;

  // Access to averaging state in the cache:
  PlotMSAveraging& averaging() { return averaging_; }

  // Access to transformations state in the cache
  PlotMSTransformations& transformations() { return transformations_; }

  // Loads the cache for the given axes and data
  // columns.  IMPORTANT: this method assumes that any currently loaded data is
  // valid for the given VisIter; i.e., if the meta-information or either of
  // the axes are already loaded, then they don't need to be reloaded.  If this
  // is not the case, then clear() should be called BEFORE append().  If a
  // PlotMSCacheThreadHelper object is given, it will be used to report
  // progress information.
  virtual void load(const std::vector<PMS::Axis>& axes,
                    const std::vector<PMS::DataColumn>& data,
                    const String& filename,
                    const PlotMSSelection& selection,
                    const PlotMSAveraging& averaging,
                    const PlotMSTransformations& transformations,
                    const PlotMSCalibration& calibration,
                    /*PlotMSCacheThread**/ThreadCommunication* thread = NULL);
  
  // Clears the cache of all stored values.  This should be called when the
  // underlying MS or MS selection is changed, thus invalidating stored data.
  void clear();
  void clearRanges();
  
  // Releases the given axes from the cache.
  void release(const std::vector<PMS::Axis>& axes);
  
  // Set up indexing for the plot
  bool isIndexerInitialized( PMS::Axis iteraxis, Bool globalXRange,
                Bool globalYRange, int dataIndex ) const;
  void setUpIndexer(PMS::Axis iteraxis=PMS::SCAN,
                    Bool globalXRange=False, Bool globalYRange=False, int dataIndex = 0);

  // Access to flags per chunk
  inline Array<Bool>& flag(Int chunk) { return *flag_[chunk]; };
  inline Vector<Bool>& flagrow(Int chunk) { return *flagrow_[chunk]; };

  // Axis-specific generic gets
  inline Double getScan(Int chnk,Int irel)     { return scan_(chnk);   (void)irel; };
  inline Double getField(Int chnk,Int irel)    { return field_(chnk);  (void)irel; };
  inline Double getTime(Int chnk,Int irel)     { return time_(chnk);  (void)irel; };
  inline Double getTimeIntr(Int chnk,Int irel) { return timeIntr_(chnk);  (void)irel; };
  inline Double getSpw(Int chnk,Int irel)      { return spw_(chnk);  (void)irel; };
  inline Double getFreq(Int chnk,Int irel) { return *(freq_[chnk]->data()+irel); };
  inline Double getVel(Int chnk,Int irel)  { return *(vel_[chnk]->data()+irel); };
  inline Double getChan(Int chnk,Int irel) { return *(chan_[chnk]->data()+irel); };
  inline Double getCorr(Int chnk,Int irel) { return *(corr_[chnk]->data()+irel); };
  inline Double getAnt1(Int chnk,Int irel) { return *(antenna1_[chnk]->data()+irel); };
  inline Double getAnt2(Int chnk,Int irel) { return *(antenna2_[chnk]->data()+irel); };
  inline Double getBsln(Int chnk,Int irel) { return *(baseline_[chnk]->data()+irel); };
  inline Double getRow(Int chnk,Int irel) { return *(row_[chnk]->data()+irel); };
  inline Double getObsid(Int chnk,Int irel) { return *(obsid_[chnk]->data()+irel); };
  inline Double getIntent(Int chnk,Int irel) { return *(intent_[chnk]->data()+irel); };
  inline Double getFeed1(Int chnk,Int irel) { return *(feed1_[chnk]->data()+irel); };
  inline Double getFeed2(Int chnk,Int irel) { return *(feed2_[chnk]->data()+irel); };

  inline Double getAmp(Int chnk,Int irel)  { return *(amp_[chnk]->data()+irel); };
  inline Double getPha(Int chnk,Int irel)  { return *(pha_[chnk]->data()+irel); };
  inline Double getReal(Int chnk,Int irel) { return *(real_[chnk]->data()+irel); };
  inline Double getImag(Int chnk,Int irel) { return *(imag_[chnk]->data()+irel); };
  inline Double getFlag(Int chnk,Int irel) { return *(flag_[chnk]->data()+irel); };
  inline Double getFlagRow(Int chnk,Int irel) { return *(flagrow_[chnk]->data()+irel); };

  inline Double getWt(Int chnk,Int irel) { return *(wt_[chnk]->data()+irel); };
  inline Double getWtxAmp(Int chnk, Int irel) { return *(wtxamp_[chnk]->data()+irel); }
  inline Double getWtSp(Int chnk,Int irel) { return *(wtsp_[chnk]->data()+irel); };
  inline Double getSigma(Int chnk,Int irel) { return *(sigma_[chnk]->data()+irel); };
  inline Double getSigmaSp(Int chnk,Int irel) { return *(sigmasp_[chnk]->data()+irel); };

  inline Double getUVDist(Int chnk,Int irel) { return *(uvdist_[chnk]->data()+irel); };
  inline Double getUVDistL(Int chnk,Int irel) { return *(uvdistL_[chnk]->data()+irel); };
  inline Double getU(Int chnk,Int irel) { return *(u_[chnk]->data()+irel); };
  inline Double getV(Int chnk,Int irel) { return *(v_[chnk]->data()+irel); };
  inline Double getW(Int chnk,Int irel) { return *(w_[chnk]->data()+irel); };
  inline Double getUwave(Int chnk,Int irel) { return *(uwave_[chnk]->data()+irel); };
  inline Double getVwave(Int chnk,Int irel) { return *(vwave_[chnk]->data()+irel); };
  inline Double getWwave(Int chnk,Int irel) { return *(wwave_[chnk]->data()+irel); };

  // These are array-global (one value per chunk)
  inline Double getAz0(Int chnk,Int irel) { return az0_(chnk);  (void)irel; };
  inline Double getEl0(Int chnk,Int irel) { return el0_(chnk);  (void)irel; };
  inline Double getRadialVelocity0(Int chnk, Int irel){ return radialVelocity_(chnk); (void)irel;};
  inline Double getRHO0(Int chnk, Int irel){return rho_(chnk); (void)irel; };
  inline Double getHA0(Int chnk,Int irel) { return ha0_(chnk);  (void)irel; };
  inline Double getPA0(Int chnk,Int irel) { return pa0_(chnk);  (void)irel; };

  // These are antenna-based
  inline Double getAntenna(Int chnk,Int irel) { return *(antenna_[chnk]->data()+irel); };
  inline Double getAz(Int chnk,Int irel)      { return *(az_[chnk]->data()+irel); };
  inline Double getEl(Int chnk,Int irel)      { return *(el_[chnk]->data()+irel); };
  inline Double getParAng(Int chnk,Int irel)  { return *(parang_[chnk]->data()+irel); };

  // These support generic non-complex calibration
  inline Double getPar(Int chnk,Int irel)  { return *(par_[chnk]->data()+irel); };
  inline Double getSnr(Int chnk,Int irel)  { return *(snr_[chnk]->data()+irel); };

  // Returns a list of channel numbers that were averaged together in that chunk
  inline Vector<Int> getChansPerBin(Int chnk,Int irel) { return (*chansPerBin_[chnk])[irel]; };

  Record locateInfo(int plotIterIndex, const Vector<PlotRegion>& regions,
                bool showUnflagged, bool showFlagged, bool selectAll );

  PlotLogMessage* locateRange( int plotIterIndex, const Vector<PlotRegion> & regions,
                bool showUnflagged, bool showFlagged);

  PlotLogMessage* flagRange( int plotIterIndex, casa::PlotMSFlagging& flagging,
                const Vector<PlotRegion>& regions, bool showFlagged);

  //Return a formatted string for time iteration plots giving the time range.
  String getTimeBounds( int iterValue );
  // Return the time as doubles 
  pair<Double,Double> getTimeBounds() const;
  // Return the axes ranges
  pair<Double,Double> getXAxisBounds() const;
  pair<Double,Double> getYAxisBounds() const;

protected:
    
  // Forbid copy for now
  PlotMSCacheBase(const PlotMSCacheBase&);

  // Increase the number of chunks
  void increaseChunks(Int nc=0);

  // Specialized method for loading the cache
  //  (pure virtual: implemented specifically in child classes)
  virtual void loadIt(std::vector<PMS::Axis>& loadAxes,
                      std::vector<PMS::DataColumn>& loadData,
                      /*PlotMSCacheThread**/ThreadCommunication* thread = NULL)=0;

  virtual void flagToDisk(const PlotMSFlagging& flagging,
                          Vector<Int>& chunks, 
                          Vector<Int>& relids,
                          Bool flag,
                          PlotMSIndexer* indexer, int dataIndex)=0;
  
  // Clean up the PtrBlocks
  void deleteCache();
  void deleteIndexer();



  virtual bool isEphemeris() {return false;};
  bool isEphemerisAxis( PMS::Axis axis ) const;
  // Set the net axes mask (defines how to collapse flags for the chosen plot axes)
  void setAxesMask(PMS::Axis axis,Vector<Bool>& axismask);

  // Return the net axes mask for the currently set plot axes
  Vector<Bool> netAxesMask(PMS::Axis xaxis,PMS::Axis yaxis);

  // Derive the plot mask by appropriately collapsing the flags
  void setPlotMask( Int dataIndex);           // all chunks
  void setPlotMask(Int dataIndex, Int chunk);  // per chunk

  // Delete the whole plot mask
  void deletePlotMask();

  // Returns the number of points loaded for the given axis or 0 if not loaded.
  unsigned int nPointsForAxis(PMS::Axis axis) const;
  
  // Convenience methods that call log() with the given method name and the
  // appropriate event type.
  // <group>
  void logInfo(const String& method, const String& message) {
      log(method, message, PlotLogger::MSG_INFO); }
  void logDebug(const String& method, const String& message) {
      log(method, message, PlotLogger::MSG_DEBUG); }
  void logWarn(const String& method, const String& message) {
      log(method, message, PlotLogger::MSG_WARN); }
  void logError(const String& method, const String& message) {
      log(method, message, PlotLogger::MSG_ERROR); }
  
  void logLoad(const String& message) {
      log(PMS::LOG_ORIGIN_LOAD_CACHE, message, PMS::LOG_EVENT_LOAD_CACHE); }
  void logFlag(const String& message) {
      log(PMS::LOG_ORIGIN_FLAG, message, PMS::LOG_EVENT_FLAG); }
  // </group>
  
  // Logs the given message from the given method name as the given event type
  // (see PlotLogger).
  void log(const String& method, const String& message, int eventType);

  //Return the color lookup index for the chunk.
  int findColorIndex( int chunk, bool initialize );



  // Private data
  
  // Parent plotms.
  //  (used only for access to logger, so far)
  PlotMSApp* plotms_;

  // An empty indexer (its an empty PlotData object used for initialization)
  PlotMSIndexer* indexer0_;

  // The indexer into the cache
  std::vector<PtrBlock<PlotMSIndexer*> > indexer_;
  
  // The number of chunks in the cache
  Int nChunk_;

  // The reference time for this cache, in seconds
  Double refTime_p;

  // The number of antennas
  Int nAnt_;

  // Set frame from VI if not specified by user
  // (for VI2::getFrequencies and axis label)
  MFrequency::Types freqFrame_;

  // Global min/max
  Double minX_,maxX_,minY_,maxY_;

  // The fundamental meta-data cache
  Matrix<Int> chshapes_;
  Vector<Bool> goodChunk_;
  Vector<Double> time_, timeIntr_;
  Vector<Int> field_, spw_, scan_;
  PtrBlock<Vector<uInt>*> row_;
  PtrBlock<Vector<Int>*> antenna1_, antenna2_, baseline_;
  PtrBlock<Vector<Double>*> uvdist_, u_, v_, w_;
  PtrBlock<Matrix<Double>*> uvdistL_, uwave_, vwave_, wwave_;
  PtrBlock<Vector<Double>*> freq_, vel_;
  PtrBlock<Vector<Int>*> chan_;
  PtrBlock<Array<Int>*> chansPerBin_;
  PtrBlock<Vector<Int>*> corr_;
  PtrBlock<Vector<Int>*> obsid_;
  PtrBlock<Vector<Int>*> intent_;
  PtrBlock<Vector<Int>*> feed1_, feed2_;

  // Optional parts of the cache
  PtrBlock<Vector<Float>*> pa_;

  // Data (the heavy part)
  PtrBlock<Array<Float>*> amp_, pha_, real_, imag_, wtxamp_;
  PtrBlock<Array<Bool>*> flag_;
  PtrBlock<Vector<Bool>*> flagrow_;
  
  PtrBlock<Array<Float>*> wt_,wtsp_;
  PtrBlock<Array<Float>*> sigma_,sigmasp_;

  PtrBlock<Vector<Float>*> parang_;
  PtrBlock<Vector<Int>*> antenna_;
  PtrBlock<Vector<Double>*> az_,el_;


  Vector<Double> radialVelocity_, rho_;
  Vector<Double> az0_,el0_,ha0_,pa0_;

  PtrBlock<Array<Float>*> par_, snr_, tsys_;

  // Current setup/state.
  bool dataLoaded_;
  bool userCanceled_;
  std::vector<PMS::Axis> currentX_;
  std::vector<PMS::Axis> currentY_;
  map<PMS::Axis, bool> loadedAxes_;
  map<PMS::Axis, PMS::DataColumn> loadedAxesData_;
  map<PMS::Axis, bool> pendingLoadAxes_;

  // Global ranges
  Double xminG_,yminG_,xflminG_,yflminG_,xmaxG_,ymaxG_,xflmaxG_,yflmaxG_;

  // A copy of the Data parameters 
  String filename_;
  PlotMSSelection selection_;
  PlotMSAveraging averaging_;
  PlotMSTransformations transformations_;
  PlotMSCalibration calibration_;

  // Axes mask
  std::vector<Vector<Bool> > netAxesMask_;

  // collapsed flag mask for plotting
  std::vector<PtrBlock<Array<Bool>* > > plmask_;

  // meta info for locate output
  Vector<String> antnames_;      
  Vector<String> stanames_;      
  Vector<String> antstanames_;   
  Vector<String> fldnames_;
  Vector<String> intentnames_;
  Array<Double> positions_;

  PMS::Axis iterAxis;
  bool ephemerisInitialized;
  ::QVector<double> uniqueTimes;

  // The calibration type (Table subType)
  String calType_;
  // polarization selection is ratio ("/")
  bool polnRatio_;

private:
  void _updateAntennaMask( Int a, Vector<Bool>& antMask, const Vector<Int> selectedAntennas );
  bool axisIsValid(PMS::Axis axis, const PlotMSAveraging& averaging);

};
typedef CountedPtr<PlotMSCacheBase> PlotMSCacheBasePtr;


}

#endif /* PLOTMSCACHEBASE_H_ */