SDMDataObject.h

Go to the documentation of this file.

#ifndef SDMDataObject_CLASS
#define SDMDataObject_CLASS

#include <string>
#include <set>
#include <vector>
#include <map>
#include <sstream>

#ifdef WITHOUT_ACS
#else
#include "almaEnumerations_IFC.h"
#endif

#include <alma/ASDMBinaries/SDMDataObjectPartTypes.h>

#include <alma/Enumerations/CAtmPhaseCorrection.h>
#include <alma/Enumerations/CAxisName.h>
#include <alma/Enumerations/CBasebandName.h>
#include <alma/Enumerations/CCorrelationMode.h>
#include <alma/Enumerations/CPrimitiveDataType.h>
#include <alma/Enumerations/CSpectralResolutionType.h>
#include <alma/Enumerations/CProcessorType.h>
#include <alma/Enumerations/CCorrelatorType.h>
#include <alma/Enumerations/CStokesParameter.h>
#include <alma/Enumerations/CNetSideband.h>

#ifndef WITHOUT_BOOST
#include <boost/regex.hpp> 
#else
#include <regex>
#endif

#ifdef REG_BASIC
#undef REG_BASIC
#endif

#ifdef REG_EXTENDED 
#undef REG_EXTENDED
#endif 

#ifdef REG_ICASE
#undef REG_ICASE
#endif

#ifdef REG_NOSUB
#undef REG_NOSUB
#endif

#ifdef REG_NEWLINE
#undef REG_NEWLINE
#endif

#ifdef REG_NOTBOL
#undef REG_NOTBOL
#endif

#ifdef REG_NOTEOL
#undef REG_NOTEOL
#endif

#ifdef REG_STARTEND
#undef REG_STARTEND
#endif

#ifdef REG_NOERROR
#undef REG_NOERROR
#endif

#ifdef REG_NOMATCH
#undef REG_NOMATCH
#endif

#ifdef REG_BADPAT
#undef REG_BADPAT
#endif

#ifdef REG_ECOLLATE
#undef REG_ECOLLATE
#endif

#if defined(__APPLE__)
#include <machine/endian.h>
#else 
#include <endian.h>
#endif

namespace asdmbinaries {

  const int SCHEMAVERSION=2;


  class SDMDataObjectException {
    
  public:
    SDMDataObjectException();

    SDMDataObjectException(const std::string& m);
    
    virtual ~SDMDataObjectException();

    std::string getMessage() const;
    
  protected:
    std::string message;
    
  };

  inline SDMDataObjectException::SDMDataObjectException() : message ("SDMDataObjectReaderException") {}
  inline SDMDataObjectException::SDMDataObjectException(const std::string& m) : message(m) {}
  inline SDMDataObjectException::~SDMDataObjectException() {}
  inline std::string SDMDataObjectException::getMessage() const {
    return "SDMDataObjectException : " + message;
  }
  
  template<class Enum, class EnumHelper> 
    class Optional {
    private:
    bool present_;
    Enum literal_;
    
    public:
    Optional() {
      present_=false;
    }
    
    Optional(Enum literal) {
      literal_ = literal;
      present_ = true;
    }
    
    bool present() const { return present_; }

    Enum literal() const { return literal_; }
  };

  typedef Optional<SpectralResolutionTypeMod::SpectralResolutionType, CSpectralResolutionType> OptionalSpectralResolutionType;


  class ByteOrder {
  public:
    static const ByteOrder* Little_Endian; /*< A unique object to represent a little endian byte order. */
    static const ByteOrder* Big_Endian;    /*< A unique object to represent a big endian byte order. */
    static const ByteOrder* Machine_Endianity; /*< A unique object storing the endianity of the machine. */

    std::string toString() const ;

  private:
    std::string name_;

    ByteOrder(const std::string & name);
    virtual ~ByteOrder();
    static const ByteOrder* machineEndianity(); 
  };

  // forward declarations.
  class SDMDataSubset;
  class SDMDataObject;


  
  class SDMDataObjectReader;

  // SDMDataObject:: declarations
  //

  class SDMDataObject {
    friend class SDMDataObjectStreamReader;
    friend class SDMDataObjectReader;
    friend class SDMDataObjectWriter;
    friend class HeaderParser;
    friend class SDMDataSubset;
    friend class CorrSubsetHeaderParser;

  public:

    // SDMDataObject::SpectralWindow:: declarations
    //
    class SpectralWindow {
      friend class SDMDataObject;
      friend class DataStruct;
      friend class Baseband;
      friend class HeaderParser;

    private:
      std::vector<StokesParameterMod::StokesParameter> crossPolProducts_;
      std::vector<StokesParameterMod::StokesParameter> sdPolProducts_;
      float scaleFactor_;
      unsigned int numSpectralPoint_;
      unsigned int numBin_;
      NetSidebandMod::NetSideband sideband_;
      std::string strSw_;
      std::string strImage_;
      void strSw(const std::string& s);
      const std::string & strSw() const;
      void strImage(const std::string& s);
      const std::string & strImage() const;

      const SDMDataObject* owner_;

      void owner(const SDMDataObject* o);

    public:
      SpectralWindow();


      virtual ~SpectralWindow();

      SpectralWindow(const std::vector<StokesParameterMod::StokesParameter>& crossPolProducts,
                     float scaleFactor,
                     unsigned int numSpectralPoint,
                     unsigned int numBin,
                     NetSidebandMod::NetSideband sideband);

      SpectralWindow(const std::vector<StokesParameterMod::StokesParameter>& sdPolProducts,
                     unsigned int numSpectralPoint,
                     unsigned numBin,
                     NetSidebandMod::NetSideband sideband);

      SpectralWindow(const std::vector<StokesParameterMod::StokesParameter>& crossPolProducts,
                     const std::vector<StokesParameterMod::StokesParameter>& sdPolProduct,
                     float scaleFactor,
                     unsigned int numSpectralPoint,
                     unsigned int numBin,
                     NetSidebandMod::NetSideband sideband);

      const std::vector<StokesParameterMod::StokesParameter>& crossPolProducts() const;
      //void crossPolProducts(const vector<StokesParameter>& value);

      const std::vector<StokesParameterMod::StokesParameter>& sdPolProducts() const;
      //void sdPolProducts(const vector<StokesParameter>& value);

      float scaleFactor() const;
      //void scaleFactor(float value);

      unsigned int numSpectralPoint() const;
      //void numSpectralPoint(unsigned int value);

      unsigned int numBin() const;
      //void numBin(unsigned int value);

      NetSidebandMod::NetSideband sideband() const;

    }; // SpectralWindow::


    // SDMDataObject::Baseband:: declarations
    //
    class Baseband {
      friend class SDMDataObject;
      friend class DataStruct;
      friend class HeaderParser;

    private:
      BasebandNameMod::BasebandName name_;
      std::vector<SpectralWindow> spectralWindows_;

      const SDMDataObject* owner_;

      void owner(const SDMDataObject* o);

    public:
      Baseband();

      ~Baseband();

      Baseband(BasebandNameMod::BasebandName name, const std::vector<SpectralWindow>& spectralWindows);

      BasebandNameMod::BasebandName name() const;
      //void ref(BasebandName value);

      const std::vector<SpectralWindow>& spectralWindows() const;
      void spectralWindows(const std::vector<SpectralWindow>& value);
    }; // Baseband::


    // SDMDataObject::BinaryPart:: declarations
    //
    class BinaryPart {
      friend class DataStruct;
      friend class SDMDataObject;
      friend class HeaderParser;
      friend class SDMDataObjectWriter;

    protected:
      unsigned int size_;
      std::vector<AxisNameMod::AxisName> axes_;

      const SDMDataObject* owner_;
    
      void owner(const SDMDataObject* o);
    public:

      BinaryPart();

      virtual ~BinaryPart();

      BinaryPart( unsigned int size,
                  const std::vector<AxisNameMod::AxisName>& axes);
      
      virtual unsigned int size() const; 
      //      virtual void size (unsigned int value); 
      
      virtual const std::vector<AxisNameMod::AxisName>& axes() const ; 
      //      virtual void axes (const vector<AxisName>& axes); 
    }; // BinaryPart::

    class AutoDataBinaryPart : public BinaryPart {
      friend class DataStruct;
      friend class SDMDataObject;
      friend class HeaderParser;
      friend class SDMDataObjectWriter;
      
    protected:
      bool normalized_;

    public:
      AutoDataBinaryPart();
      
      ~AutoDataBinaryPart();
      
      AutoDataBinaryPart(unsigned int size,
                         const std::vector<AxisNameMod::AxisName>& axes,
                         bool normalized);
      
      virtual bool normalized() const;
      
    }; // AutoDataBinaryPart
    
    class ZeroLagsBinaryPart : public BinaryPart {
      friend class DataStruct;
      friend class SDMDataObject;
      friend class HeaderParser;
      friend class SDMDataObjectWriter;

    protected:
      CorrelatorTypeMod::CorrelatorType correlatorType_;
      
    public:
      
      ZeroLagsBinaryPart() ;

      ~ZeroLagsBinaryPart();

      ZeroLagsBinaryPart(unsigned int size,
                         const std::vector<AxisNameMod::AxisName>& axes,
                         CorrelatorTypeMod::CorrelatorType correlatorType);

      virtual CorrelatorTypeMod::CorrelatorType correlatorType() const;
    };

    // SDMDataObject::DataStruct:: declarations
    //
    class DataStruct {
      friend class SDMDataObject;
      friend class HeaderParser;
      friend class SDMDataObjectWriter;

    public:
      DataStruct();

      virtual ~DataStruct();

      DataStruct(const std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection>& apc,
                 const std::vector<Baseband>& basebands,
                 const BinaryPart& flags,
                 const BinaryPart& actualTimes,
                 const BinaryPart& actualDurations,
                 const ZeroLagsBinaryPart& zeroLags,
                 const BinaryPart& crossData,
                 const AutoDataBinaryPart& autoData);
      
      
      const std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection>& apc() const;
      //      void apc(const vector<AtmPhaseCorrectionMod::AtmPhaseCorrection>& value);

      const std::vector<Baseband>& basebands() const;
      //      void basebands(const vector<Baseband>& value);
      
      const BinaryPart& flags() const;
      //      void flags(const BinaryPart& value);

      const BinaryPart& actualTimes() const;
      //      void actualTimes(const BinaryPart& value);
 

      const BinaryPart& actualDurations() const;
      //      void actualDurations(const BinaryPart& value);


      const ZeroLagsBinaryPart& zeroLags() const;
      //      void zeroLags(const BinaryPart& value);


      const BinaryPart& crossData() const;
      //      void crossData(const BinaryPart& value);


      const AutoDataBinaryPart& autoData() const;
      //      void autoData(const BinaryPart& value);

      void imageSPW(unsigned int ibb,
                    unsigned int ispw1,
                    unsigned int ispw2);

      const SpectralWindow* imageSPW(unsigned int ibb,
                                     unsigned int ispw) const;

      void imageOfSPW(unsigned int ibb,
                      unsigned int ispw1,
                      unsigned int ispw2);
      

      const SpectralWindow* imageOfSPW(unsigned int ibb,
                                       unsigned int ispw) const;
      

    private:
      std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection> apc_;
      std::vector<Baseband> basebands_;
      BinaryPart flags_;
      BinaryPart actualTimes_;
      BinaryPart actualDurations_;
      ZeroLagsBinaryPart zeroLags_;
      BinaryPart crossData_;
      AutoDataBinaryPart autoData_;

      const SDMDataObject* owner_;
      void owner(const SDMDataObject* o);

      std::map<std::string, std::string> imageSPW_;
      std::map<std::string, std::string> imageOfSPW_;

      void checkCoordinate(unsigned int ibb, unsigned int ispw) const;
      bool associatedSPW(unsigned int ibb,
                         unsigned int ispw1,
                         unsigned int ispw2);

      void divorceSPW(unsigned int ibb, unsigned int ispw)   ;

    }; //DataStruct::

    SDMDataObject();
    SDMDataObject(unsigned long long startTime,
                  const std::string& dataOID,
                  unsigned int dimensionality,
                  const std::string& execBlockUID,
                  unsigned int execBlockNum,
                  unsigned int scanNum,
                  unsigned int subscanNum,
                  unsigned int numAntenna,
                  CorrelationModeMod::CorrelationMode correlatorMode,
                  const SDMDataObject::DataStruct& dataStruct);

    SDMDataObject(unsigned long long startTime,
                  const std::string& dataOID,
                  unsigned int dimensionality,
                  unsigned int numTime,
                  const std::string& execBlockUID,
                  unsigned int execBlockNum,
                  unsigned int scanNum,
                  unsigned int subscanNum,
                  unsigned int numAntenna,
                  const SDMDataObject::DataStruct& dataStruct);

    std::string title() const;
    void title(const std::string& value) ;

    const ByteOrder* byteOrder() const;

    unsigned long long startTime() const;
    void startTime(unsigned long long value);    

    unsigned int numTime() const;
    void numTime(unsigned int value);

    std::string dataOID() const;
    void dataOID(const std::string& value);


    std::string execBlockUID() const;
    void execBlockUID(const std::string& value);

    unsigned int execBlockNum() const;
    void execBlockNum (unsigned int value );

    unsigned int scanNum() const;
    void scanNum( unsigned int value);

    unsigned int subscanNum() const;
    void subscanNum(int value);

    std::string projectPath() const;

    std::vector<std::string> projectPaths() const;

    unsigned int numAntenna() const;
    void numAntenna (unsigned int value);

    CorrelationModeMod::CorrelationMode correlationMode() const;


    OptionalSpectralResolutionType spectralResolutionType() const;

    ProcessorTypeMod::ProcessorType processorType() const;
    

    CorrelatorTypeMod::CorrelatorType correlatorType() const;

    bool isTP() const ;

    bool isWVR() const ;

    bool isCorrelation() const;

    bool hasPackedData() const;
       
    const DataStruct& dataStruct() const;
    void dataStruct(const DataStruct& dataStruct);


    const std::vector<SDMDataSubset>& sdmDataSubsets() const;

    const std::vector<SDMDataSubset>& corrDataSubsets() const;
    void corrDataSubsets(const std::vector<SDMDataSubset>& value);

    const SDMDataSubset& sdmDataSubset(const std::string& projectPath) const;


    bool aborted() const ;

    unsigned long long abortTime() const ;



    std::string abortReason() const ;


    const SDMDataSubset& tpDataSubset() const;
    void tpDataSubset(const SDMDataSubset& value);

    std::string toString() const;

    void done();

    unsigned int dimensionality() const;

  private:

    static std::vector<std::string> correlationModeRefs;
    static std::vector<std::string> axes;
    static std::vector<std::string> types;
    static std::vector<std::string> apcs;

    const static bool _init;
    static bool init();

    // Is the SDMDataObject actually properly filled with valid data.
    bool valid_; 

    // Global header variables.
    std::string title_;

    const ByteOrder* byteOrder_;

    int schemaVersion_;
    
    long long startTime_;

    std::string dataOID_;

    unsigned int dimensionality_;

    unsigned int numTime_;

    std::string execBlockUID_;

    unsigned int execBlockNum_;

    unsigned int scanNum_;

    unsigned int subscanNum_;

    unsigned int numAntenna_;

    CorrelationModeMod::CorrelationMode correlationMode_;

    OptionalSpectralResolutionType spectralResolutionType_;

    ProcessorTypeMod::ProcessorType processorType_;

    DataStruct dataStruct_;

    std::map<std::string, unsigned int> str2index_;
    
    std::vector<SDMDataSubset> dataSubsets_;

    bool aborted_;

    unsigned long long int abortTime_;
    std::string   abortReason_;

    void append(const SDMDataSubset& value);


    void dimensionality( unsigned int value );

    bool inTitle(const std::string& what) const;

    void owns();

 
    std::string toXML() ;
    void toXML(const BinaryPart& binaryPart, const std::string& elementName,  std::ostringstream& oss) const;
    void toXML(const AutoDataBinaryPart& autoDataBinaryPart, const std::string& elementName,  std::ostringstream& oss) const;
    void toXML(const ZeroLagsBinaryPart& zeroLagsBinaryPart, const std::string& elementName,  std::ostringstream& oss) const;
    void spectralWindowsToXML(const std::vector<Baseband>& basebands, unsigned int ibb,  std::ostringstream& oss) const;
    void basebandsToXML(std::ostringstream& oss) const; 
    void dataStructToXML(std::ostringstream& oss) ;

    void updateIdImageSPW();

#ifndef WITHOUT_BOOST
    const static boost::regex  SPWID;
#else
    const static std::regex  SPWID;
#endif

  };
  // SDMDataObject::

  // SDMDataSubset:: declarations
  //
  class SDMDataSubset {
    friend class SDMDataObject;
    friend class SDMDataObjectReader;
    friend class SDMDataObjectStreamReader;
    friend class SDMDataObjectWriter;
    friend class CorrSubsetHeaderParser;
    friend class TPSubsetHeaderParser;

  public:
  
    /*
     * An empty constructor.
     */
    SDMDataSubset(SDMDataObject* owner= 0);

    SDMDataSubset(SDMDataObject* owner,
                  unsigned long long time,
                  unsigned long long interval,
                  const std::vector<float>& autoData);

    /*
     * A copy constructor.
     */
    SDMDataSubset(const SDMDataSubset & sdmDataSubset);

    /*
     * Overloading = 
     */
    SDMDataSubset& operator= (const SDMDataSubset& sdmDataSubset);

    /*
     * The destructor.
     */
    virtual ~SDMDataSubset();

    const SDMDataObject* owner() const;

    unsigned int integrationNum() const;
    
    unsigned int subintegrationNum() const;    

    std::string projectPath() const;
  
    unsigned long long time() const;
  
    unsigned long long interval() const;


    std::string toString(unsigned int N = 10 )const ;

    void binAttachToXML(const std::string& name, std::ostringstream& oss);
    void tpBinAttachToXML(std::ostringstream& oss);
    void corrBinAttachToXML(std::ostringstream& oss);

    void toXML(std::ostringstream& oss) const;

    std::string toXML();


    unsigned long int actualDurations(const ACTUALDURATIONSTYPE* & ptr) const;

    uint64_t actualDurationsPosition() const;

    unsigned long int actualTimes(const ACTUALTIMESTYPE* & ptr) const;

    uint64_t actualTimesPosition() const;

    unsigned long int autoData(const AUTODATATYPE* & ptr) const ;

    uint64_t autoDataPosition() const;

    unsigned long int crossData(const SHORTCROSSDATATYPE* & ptr) const;


    unsigned long int crossData(const INTCROSSDATATYPE* & ptr) const;

    unsigned long int crossData(const FLOATCROSSDATATYPE* & ptr) const;

    uint64_t crossDataPosition() const;

    PrimitiveDataTypeMod::PrimitiveDataType crossDataType() const;

    void crossDataType(PrimitiveDataTypeMod::PrimitiveDataType value);

    unsigned long int flags(const FLAGSTYPE* &ptr) const;

    uint64_t flagsPosition() const;

    unsigned long int zeroLags(const ZEROLAGSTYPE* & ptr) const;

    uint64_t zeroLagsPosition() const;

    bool aborted() const ; 

    unsigned long long abortTime() const; 

    std::string abortReason() const;



  private:
    SDMDataObject* owner_;
    unsigned int integrationNum_;
    unsigned int subintegrationNum_;
    CorrelationModeMod::CorrelationMode ref_;
    unsigned long long time_;
    unsigned long long interval_;
    std::string dataStruct_;
    std::string flagsREF_;
    std::string actualTimesREF_;
    std::string actualDurationsREF_;
    std::string zeroLagsREF_;
    std::string crossDataREF_;
    PrimitiveDataTypeMod::PrimitiveDataType crossDataType_;
    std::string autoDataREF_;

    const ACTUALTIMESTYPE * actualTimes_;
    unsigned long int nActualTimes_;
    uint64_t actualTimesPosition_;
    const ACTUALDURATIONSTYPE * actualDurations_;
    unsigned long int nActualDurations_;
    uint64_t actualDurationsPosition_;
    const ZEROLAGSTYPE* zeroLags_;
    unsigned long int nZeroLags_;
    uint64_t zeroLagsPosition_;
    const FLAGSTYPE* flags_;    
    unsigned long int nFlags_;
    uint64_t flagsPosition_;
    const INTCROSSDATATYPE* longCrossData_;
    const SHORTCROSSDATATYPE* shortCrossData_;
    const FLOATCROSSDATATYPE* floatCrossData_;
    unsigned long int nCrossData_;
    uint64_t crossDataPosition_;
    const AUTODATATYPE* autoData_;
    unsigned long int nAutoData_;
    uint64_t autoDataPosition_;

    std::string xsiType() const;

    bool aborted_;
    unsigned long long int abortTime_;
    std::string   abortReason_;

  };
  // SDMDataSubset:: declarations


  // Utils:: declarations
  //
  class Utils {
  public:
    static void invalidCall(const std::string & methodName, const SDMDataObject* sdmDataObject);
    static std::string quote(const std::string& s);
    static std::string quote(bool b);
    static std::string quote(int i);
    static std::string quote(unsigned int i);
    static std::string quote(long long l);
    static std::string quote(float f);
    static std::string quote(const std::set<std::string>& s);
    static std::string quote(const std::vector<std::string>& s);
    template<class Enum, class EnumHelper> static std::string quote(Enum l) {
      std::ostringstream oss;
      oss << "\"";
      oss << EnumHelper::name(l);
      oss << "\"";
      return oss.str();
    }

    template<class Enum, class EnumHelper> static std::string quote(const std::vector<Enum>& v_l) {
      std::ostringstream oss;
      oss << "\"";

      if (v_l.size() > 0)
        oss << EnumHelper::name(v_l.at(0));

      for (unsigned int i = 1; i < v_l.size(); i++)
        oss << " " << EnumHelper::name(v_l.at(i));
      oss << "\"";
      return oss.str();
    }

    template<class Enum, class EnumHelper> static std::string toString(Enum l) {
      std::ostringstream oss;
      oss << EnumHelper::name(l);
      return oss.str();
    }

    template<class Enum, class EnumHelper> static std::string toString(const std::vector<Enum>& v_l) {
      std::ostringstream oss;

      if (v_l.size() > 0)
        oss << EnumHelper::name(v_l.at(0));

      for (unsigned int i = 1; i < v_l.size(); i++)
        oss << " " << EnumHelper::name(v_l.at(i));
      return oss.str();
    }

    template<class Enum, class EnumHelper> static std::vector<Enum> enumvec(const std::string& strliterals) {
      std::vector<Enum> result;
      
      std::string strliteral;
      std::istringstream iss(strliterals);
      
      while (iss >> strliteral)
        result.push_back(EnumHelper::literal(strliteral));
      
      return result;
    }


    static void toXML(const std::string& elementName, int value, std::ostringstream& oss);
    static void toXML(const std::string& elementName, unsigned int value, std::ostringstream& oss);
    static void toXML(const std::string& elementName, long long value, std::ostringstream& oss);
    static void toXML(const std::string& elementName, unsigned long long value, std::ostringstream& oss);
    static void oXML(const std::string& elementName, std::ostringstream& oss);
    static void cXML(const std::string& elementName, std::ostringstream& oss);
    
    template<class Enum, class EnumHelper> static void toXML(const std::string& elementName, Enum value, std::ostringstream& oss) {
      oss << "<" << elementName << ">" << EnumHelper::name(value) << "</" << elementName << ">" << std::endl;      
    }

#define QUOTE    Utils::quote
#define TOSTRING Utils::toString
#define TOXML    Utils::toXML
#define OXML     Utils::oXML
#define CXML     Utils::cXML
  };
}
#endif // SDMDataObject_CLASS