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 "SDMDataObjectPartTypes.h"

#include "CAtmPhaseCorrection.h"
#include "CAxisName.h"
#include "CBasebandName.h"
#include "CCorrelationMode.h"
#include "CPrimitiveDataType.h"
#include "CSpectralResolutionType.h"
#include "CProcessorType.h"
#include "CCorrelatorType.h"
#include "CStokesParameter.h"
#include "CNetSideband.h"

using namespace AtmPhaseCorrectionMod;
using namespace AxisNameMod;
using namespace BasebandNameMod;
using namespace CorrelationModeMod;
using namespace PrimitiveDataTypeMod;
using namespace SpectralResolutionTypeMod;
using namespace ProcessorTypeMod;
using namespace CorrelatorTypeMod;
using namespace StokesParameterMod;
using namespace NetSidebandMod;

using namespace std;



#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

#include <boost/regex.hpp> 
using namespace boost;

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

/*
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/posix_time/posix_time_duration.hpp>

#include <boost/date_time/gregorian/gregorian.hpp>

using namespace boost::posix_time;
using namespace boost::gregorian;
*/

namespace asdmbinaries {

  const int SCHEMAVERSION=2;


  class SDMDataObjectException {
    
  public:
    SDMDataObjectException();

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

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

  inline SDMDataObjectException::SDMDataObjectException() : message ("SDMDataObjectReaderException") {}
  inline SDMDataObjectException::SDMDataObjectException(const string& m) : message(m) {}
  inline SDMDataObjectException::~SDMDataObjectException() {}
  inline 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<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. */

    string toString() const ;

  private:
    string name_;
    int endianity_;

    ByteOrder(const string & name, int endianity);
    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:
      vector<StokesParameter> crossPolProducts_;
      vector<StokesParameter> sdPolProducts_;
      float scaleFactor_;
      unsigned int numSpectralPoint_;
      unsigned int numBin_;
      NetSideband sideband_;
      string strSw_;
      string strImage_;
      void strSw(const string& s);
      const string & strSw() const;
      void strImage(const string& s);
      const string & strImage() const;

      const SDMDataObject* owner_;

      void owner(const SDMDataObject* o);

    public:
      SpectralWindow();


      virtual ~SpectralWindow();

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

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

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

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

      const vector<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:
      BasebandName name_;
      vector<SpectralWindow> spectralWindows_;

      const SDMDataObject* owner_;

      void owner(const SDMDataObject* o);

    public:
      Baseband();

      ~Baseband();

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

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

      const vector<SpectralWindow>& spectralWindows() const;
      void spectralWindows(const 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_;
      vector<AxisName> axes_;

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

      BinaryPart();

      virtual ~BinaryPart();

      BinaryPart( unsigned int size,
                  const vector<AxisName>& axes);
      
      virtual unsigned int size() const; 
      //      virtual void size (unsigned int value); 
      
      virtual const vector<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 vector<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:
      CorrelatorType correlatorType_;
      
    public:
      
      ZeroLagsBinaryPart() ;

      ~ZeroLagsBinaryPart();

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

      virtual CorrelatorType correlatorType() const;
    };

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

    public:
      DataStruct();

      virtual ~DataStruct();

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

      const 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:
      vector<AtmPhaseCorrection> apc_;
      vector<Baseband> basebands_;
      BinaryPart flags_;
      BinaryPart actualTimes_;
      BinaryPart actualDurations_;
      ZeroLagsBinaryPart zeroLags_;
      BinaryPart crossData_;
      AutoDataBinaryPart autoData_;

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

      map<string, string> imageSPW_;
      map<string, 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 string& dataOID,
                  unsigned int dimensionality,
                  const string& execBlockUID,
                  unsigned int execBlockNum,
                  unsigned int scanNum,
                  unsigned int subscanNum,
                  unsigned int numAntenna,
                  CorrelationMode correlatorMode,
                  const SDMDataObject::DataStruct& dataStruct);

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

    string title() const;
    void title(const 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);

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


    string execBlockUID() const;
    void execBlockUID(const 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);

    string projectPath() const;

    vector<string> projectPaths() const;

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

    CorrelationMode correlationMode() const;


    OptionalSpectralResolutionType spectralResolutionType() const;

    ProcessorType processorType() const;


    CorrelatorType correlatorType() const;

    bool isTP() const ;


    bool isCorrelation() const;



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


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

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


    bool aborted() const ;

    unsigned long long abortTime() const ;



    string abortReason() const ;


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

    string toString() const;

    void done();

  private:

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

    const static bool _init;
    static bool init();

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

    // Global header variables.
    string title_;

    const ByteOrder* byteOrder_;

    int schemaVersion_;
    
    long long startTime_;

    string dataOID_;

    unsigned int dimensionality_;

    unsigned int numTime_;

    string execBlockUID_;

    unsigned int execBlockNum_;

    unsigned int scanNum_;

    unsigned int subscanNum_;

    unsigned int numAntenna_;

    CorrelationMode correlationMode_;

    OptionalSpectralResolutionType spectralResolutionType_;

    ProcessorType processorType_;

    DataStruct dataStruct_;

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

    bool aborted_;

    unsigned long long int abortTime_;
    string   abortReason_;

    void append(const SDMDataSubset& value);


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


    void owns();

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

    void updateIdImageSPW();

    const static regex  SPWID;

  };
  // 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 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;    

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


    string toString(unsigned int N = 10 )const ;

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

    void toXML(ostringstream& oss) const;

    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;

    PrimitiveDataType crossDataType() const;

    void crossDataType(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; 

    string abortReason() const;



  private:
    SDMDataObject* owner_;
    unsigned int integrationNum_;
    unsigned int subintegrationNum_;
    CorrelationMode ref_;
    unsigned long long time_;
    unsigned long long interval_;
    string dataStruct_;
    string flagsREF_;
    string actualTimesREF_;
    string actualDurationsREF_;
    string zeroLagsREF_;
    string crossDataREF_;
    PrimitiveDataType crossDataType_;
    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_;

    string xsiType() const;

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

  };
  // SDMDataSubset:: declarations


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

    template<class Enum, class EnumHelper> static string quote(const vector<Enum>& v_l) {
      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 string toString(Enum l) {
      ostringstream oss;
      oss << EnumHelper::name(l);
      return oss.str();
    }

    template<class Enum, class EnumHelper> static string toString(const vector<Enum>& v_l) {
      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 vector<Enum> enumvec(const string& strliterals) {
      vector<Enum> result;
      
      string strliteral;
      istringstream iss(strliterals);
      
      while (iss >> strliteral)
        result.push_back(EnumHelper::literal(strliteral));
      
      return result;
    }


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

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