SDMBinData.h

Go to the documentation of this file.

#if     !defined(_SDMBINDATA_H)

#include <iostream>
#include <sstream>
#include <string>

#include <alma/ASDM/ASDMEntities.h>  
#include <alma/ASDM/Tag.h>
#include <alma/ASDM/ArrayTime.h>
#include <alma/ASDM/ArrayTimeInterval.h>

// Enumerations used to select data:
#include <alma/Enumtcl/AtmPhaseCorrection.h>
#include <alma/Enumtcl/CorrelationMode.h>
#include <alma/Enumtcl/ProcessorType.h>
#include <alma/Enumtcl/ScanIntent.h>
#include <alma/Enumtcl/SpectralResolutionType.h>
#include <alma/Enumtcl/TimeSampling.h>

#include <alma/Enumtcl/CorrelatorType.h>

// Views:
#include <alma/ASDMBinaries/SDMDataViews.h>

#include <alma/ASDMBinaries/BaselinesSet.h>
#include <alma/ASDMBinaries/Integration.h>


#include <alma/ASDMBinaries/SDMDataObjectReader.h>
#include <alma/ASDMBinaries/SDMDataObjectStreamReader.h>

// shared_ptr not needed by CASA, do not compile this for the WITHOUT_BOOST option
// It may be needed by ALMA code, so do not elimiate it yet.
#ifndef WITHOUT_BOOST
#include <boost/shared_ptr.hpp>
#endif

// #include "Singleton.hpp"
// #include "ExecBlockDir.hpp"

namespace sdmbin{

class SDMBinData{
 public:
  /*   SDMBinData(); */
  SDMBinData( asdm::ASDM* const datasetPtr, std::string execBlockDir);

  ~SDMBinData();

  void select( EnumSet<ScanIntentMod::ScanIntent> es_si);

  void select( EnumSet<ProcessorTypeMod::ProcessorType> es_pt);

  void select( EnumSet<CorrelationModeMod::CorrelationMode> es_cm);
  
  void select( EnumSet<SpectralResolutionTypeMod::SpectralResolutionType> es_srt);

  void select( EnumSet<TimeSamplingMod::TimeSampling> es_ts);


  void select( EnumSet<CorrelationModeMod::CorrelationMode>        es_cm,
               EnumSet<SpectralResolutionTypeMod::SpectralResolutionType> es_srt, 
               EnumSet<TimeSamplingMod::TimeSampling>           es_ts);  


  void selectDataSubset( Enum<CorrelationModeMod::CorrelationMode>       e_qcm,
                         EnumSet<AtmPhaseCorrectionMod::AtmPhaseCorrection> es_qapc );

  void setPriorityDataDescription();

  std::vector<std::pair<unsigned int,double> > timeSequence()const;

  bool dataDescriptionFirst()const;

  void applySysCal();

  bool sysCalApplied() const;

  ProcessorTypeMod::ProcessorType processorType(asdm::MainRow* const mainRowPtr) const; 

  bool acceptMainRow( asdm::MainRow* const mainRowPtr);

  bool openMainRow(asdm::MainRow* const mainRowPtr);

  std::string reasonToReject(asdm::MainRow* const mainRowPtr);


  bool isComplexData();

  std::vector<SDMData*> getData();

  std::vector<MSData*>  getData( Enum<CorrelationModeMod::CorrelationMode> e_qcm, EnumSet<AtmPhaseCorrectionMod::AtmPhaseCorrection> es_qapc); 

  MSData*          getData( unsigned int na, unsigned int nfe, unsigned int ndd, unsigned int nbin) throw (Error); 

  MSData*          getCalibratedData( unsigned int na, unsigned int nfe, unsigned int ndd, unsigned int nbin,
                                      std::pair<bool,std::vector<std::vector<float> > > p_tsys) throw (Error); 

  MSData*          getData( unsigned int na1, unsigned int nfe1, unsigned int na2, unsigned int nfe2, 
                            unsigned int ndd, unsigned int nbin, std::vector<unsigned int> v_napc,
                            float scleFactor);

  MSData*          getCalibratedData( unsigned int na1, unsigned int nfe1, unsigned int na2, unsigned int nfe2, 
                                      unsigned int ndd, unsigned int nbin, std::vector<unsigned int> v_napc,
                                      float scleFactor,
                                      std::pair<bool,std::vector<std::vector<float> > > p_tsys);

  MSData*          getData( asdm::Tag antId, int feedId,
                            asdm::Tag dataDescId, 
                            AtmPhaseCorrectionMod::AtmPhaseCorrection apc, 
                            unsigned int  binNum); 

  MSData*          getData( asdm::Tag antId1, int feedId1,
                            asdm::Tag antId2, int feedId2,
                            asdm::Tag dataDescId, 
                            std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection> v_apc, 
                            unsigned int  binNum); 

  const VMSData* getDataCols();

  const VMSData* getDataCols( Enum<CorrelationModeMod::CorrelationMode> e_qcm, EnumSet<AtmPhaseCorrectionMod::AtmPhaseCorrection> es_qapc );

  const VMSData* getNextMSMainCols(unsigned int n);
  const VMSData* getNextMSMainCols(Enum<CorrelationModeMod::CorrelationMode> e_qcm, EnumSet<AtmPhaseCorrectionMod::AtmPhaseCorrection> es_qapc, unsigned int n);

  // shared_ptr not needed by CASA, do not compile this for the WITHOUT_BOOST option
  // It may be needed by ALMA code, so do not elimiate it yet.
#ifndef WITHOUT_BOOST
  void getNextMSMainCols(unsigned int n, boost::shared_ptr<VMSDataWithSharedPtr>& vmsData_p_sp);
  void getNextMSMainCols(Enum<CorrelationModeMod::CorrelationMode> e_qcm, EnumSet<AtmPhaseCorrectionMod::AtmPhaseCorrection> es_qapc, unsigned int n, boost::shared_ptr<VMSDataWithSharedPtr>& vmsData_p_sp);
#endif

  std::vector<MSData*> getMSDataFromBDFData(Enum<CorrelationModeMod::CorrelationMode> e_qcm, EnumSet<AtmPhaseCorrectionMod::AtmPhaseCorrection> es_qapc, unsigned int n);

  void getNextDataDumps(unsigned int n);

  static bool baselineReverse();

  static bool autoTrailing();

  static std::pair<bool,bool> dataOrder();

 protected:

  int  attachDataObject(std::string dataOID);

  int  attachStreamDataObject(const std::string& dataOID);

  int openStreamDataObject(const std::string& dataOID);

  void detachDataObject();

  MSState          getMSState( unsigned int subscanNum,
                               std::vector<asdm::Tag>  v_stateId, 
                               std::vector<asdm::Tag>  v_antennaId, std::vector<int> v_feedId, std::vector<asdm::Tag> v_ddId,
                               unsigned int na, unsigned int nfe, unsigned int nspw, asdm::ArrayTime timeOfDump);

 private:
  static asdm::ASDM*                     datasetPtr_;
  static std::string                  execBlockDir_;
  static bool                       canSelect_;
  static bool                    forceComplex_;  // true ==> autoData will be transformed into complex data
  EnumSet<ScanIntentMod::ScanIntent>                   es_si_;  // set of scan intents selected
  EnumSet<ProcessorTypeMod::ProcessorType>                es_pt_;  // set of processor type selected
  EnumSet<CorrelationModeMod::CorrelationMode>              es_cm_;  // set of correlation mode selected
  EnumSet<SpectralResolutionTypeMod::SpectralResolutionType>      es_srt_;  // set of spectral resolution types selected
  EnumSet<TimeSamplingMod::TimeSampling>                 es_ts_;  // set of time sampling selected

  Enum<CorrelationModeMod::CorrelationMode>                 e_qcm_;  // query to select a subset of data in a BLOB
  EnumSet<AtmPhaseCorrectionMod::AtmPhaseCorrection>         es_qapc_;  // query to select a subset of data in a BLOB

  bool                                ddfirst_;  // true ==> output sequences of time for every dataDescription

  asdm::MainRow*                         mainRowPtr_;
  std::string                              dataOID_;
  asdmbinaries::SDMDataObjectReader                  blob_r_;  // current read-only BLOB
  asdmbinaries::SDMDataObjectStreamReader           sdmdosr ;  // current SDMDataObjectStreamReader
  bool                         bdfMemoryMapped;  // will the BDF mapped in memory (true) or read sequentially (false) ?
  std::vector<DataDump*>                v_dataDump_;

  const  float*                  floatDataPtr_;  // mutable attribute; autocorrelation data of a single dump
  const  short*                  shortDataPtr_;  // mutable attribute; visiblity data of a single dump
  const  int*                     longDataPtr_;  // mutable attribute; visiblity data of a single dump
  static MSData*                    msDataPtr_;  // mutable attribute; one MS-MAIN row given
  static SDMData*                  sdmDataPtr_;  // mutable attribute; one SDM-Main (v2) row 
  static BaselinesSet*           baselinesSet_;  // mutable attribute
  static std::vector<MSData*>          v_msDataPtr_;  // mutable attribute
  static VMSData*                  vmsDataPtr_;
  static std::vector<SDMData*>        v_sdmDataPtr_;
  std::map<asdm::Tag,BaselinesSet*>  m_cdId_baselinesSet_;
  std::set<asdm::Tag>                             s_cdId_; // the keys present in  m_cdId_baselinesSet_ (used for optimization)
  bool                            complexData_;
  static bool                  coutDeleteInfo_; // utility for debugging
  static bool                 baselineReverse_; // order in which the data are in the returning VMSData structure.
  static bool                    autoTrailing_; // position of the auto data relative cross data in the returning VMSData structure.
  static bool                          syscal_; // true ==> apply system temperature calibration.

  const float*               floatDataDumpPtr_;

  std::vector<std::pair<unsigned int,double> >    v_tci_; // Indexed time centroid sequence

  void   deleteMsData(MSData* msDataPtr);

  bool verbose_ ;  // A variable to turn on/off the verbosity of the code, traditionnally based on the existence of env var "ASDM_DEBUG"
};

}

#define _SDMBINDATA_H
#endif