SDMBinData.h

Go to the documentation of this file.

#if     !defined(_SDMBINDATA_H)

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

#include <ASDMEntities.h>  
#include <Tag.h>
#include <ArrayTime.h>
#include <ArrayTimeInterval.h>

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

#include <CorrelatorType.h>

// Views:
#include "SDMDataViews.h"

#include "BaselinesSet.h"
#include "Integration.h"


#include "SDMDataObjectReader.h"
#include "SDMDataObjectStreamReader.h"

using namespace asdmbinaries;

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


using namespace std;
using namespace asdm;

namespace sdmbin{

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

  ~SDMBinData();

  void select( EnumSet<ScanIntent> es_si);

  void select( EnumSet<ProcessorType> es_pt);

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

  void select( EnumSet<TimeSampling> es_ts);


  void select( EnumSet<CorrelationMode>        es_cm,
               EnumSet<SpectralResolutionType> es_srt, 
               EnumSet<TimeSampling>           es_ts);  


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

  void setPriorityDataDescription();

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

  bool dataDescriptionFirst()const;

  void applySysCal();

  bool sysCalApplied() const;

  bool acceptMainRow( MainRow* const mainRowPtr);

  bool openMainRow(MainRow* const mainRowPtr);

  string reasonToReject(MainRow* const mainRowPtr);


  bool isComplexData();

  vector<SDMData*> getData();

  vector<MSData*>  getData( Enum<CorrelationMode> e_qcm, EnumSet<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,
                                      pair<bool,vector<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, 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, vector<unsigned int> v_napc,
                                      float scleFactor,
                                      pair<bool,vector<vector<float> > > p_tsys);

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

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

  const VMSData* getDataCols();

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

  const VMSData* getNextMSMainCols(unsigned int n);

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

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

  void getNextDataDumps(unsigned int n);

  static bool baselineReverse();

  static bool autoTrailing();

  static pair<bool,bool> dataOrder();

 protected:

  int  attachDataObject(string dataOID);

  int  attachStreamDataObject(const string& dataOID);

  int openStreamDataObject(const string& dataOID);

  void detachDataObject();

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

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

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

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

  MainRow*                         mainRowPtr_;
  string                              dataOID_;
  SDMDataObjectReader                  blob_r_;  // current read-only BLOB
  SDMDataObjectStreamReader           sdmdosr ;  // current SDMDataObjectStreamReader
  bool                         bdfMemoryMapped;  // will the BDF mapped in memory (true) or read sequentially (false) ?
  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
  const  unsigned int*               flagsPtr_;  // mutable attribute; flags data in a single dump
  const  int64_t*            actualTimesPtr_;  // mutable attribute; actualTimes in a single dump 
  const  int64_t*        actualDurationsPtr_;  // mutable attribute; actualDurations in a single dump
  const  float*                   zeroLagsPtr_;  // mutable attribute; zeroLags in 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 vector<MSData*>          v_msDataPtr_;  // mutable attribute
  static VMSData*                  vmsDataPtr_;
  static vector<SDMData*>        v_sdmDataPtr_;
  map<Tag,BaselinesSet*>  m_cdId_baselinesSet_;
  set<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_;

  vector<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