SDMDataObjectWriter.h

Go to the documentation of this file.

#ifndef SDMDataObjectWriter_CLASS
#define SDMDataObjectWriter_CLASS

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

#include <iostream>
#include <fstream>
#include <sstream>

#include <alma/ASDMBinaries/SDMDataObject.h>

#include <alma/Enumerations/CAtmPhaseCorrection.h>
#include <alma/Enumerations/CCorrelationMode.h>
#include <alma/Enumerations/CCorrelatorType.h>
#include <alma/Enumerations/CNetSideband.h>
#include <alma/Enumerations/CProcessorType.h>

namespace asdmbinaries {
  class SDMDataObjectWriterException {
    
  public:
    SDMDataObjectWriterException();

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

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

  inline SDMDataObjectWriterException::SDMDataObjectWriterException() : message ("SDMDataObjectWritererException") {}
  inline SDMDataObjectWriterException::SDMDataObjectWriterException(const std::string& m) : message(m) {}
  inline SDMDataObjectWriterException::~SDMDataObjectWriterException() {}
  inline std::string SDMDataObjectWriterException::getMessage() const {
    return "SDMDataObjectWriterException : " + message;
  }

  class SDMDataObjectWriter {
  public:
    
    SDMDataObjectWriter(const std::string& uid="uid://X0/X0/X0", const std::string& title="ALMA Binary Data");


    SDMDataObjectWriter(std::ofstream* ofs, const std::string& uid="uid://X0/X0/X0", const std::string& title="ALMA Binary Data");

    SDMDataObjectWriter(std::ostringstream* oss, const std::string& uid="uid://X0/X0/X0", const std::string& title="ALMA Binary Data");


    virtual ~SDMDataObjectWriter();
    

    void done();
    

    /* /\** */
    /*  * Writes a data subset of Total Power binary data. */
    /*  * @param time time of the subscan. */
    /*  * @param interval duration of the subscan. */
    /*  * @param flags the values of flags (see note). */
    /*  * @param actualTimes the values of actualTimes (see note). */
    /*  * @param actualDurations the values of actualDurations (see note). */
    /*  * @param autoData the values of autoData. */
    /*  * */
    /*  * @throws SDMDataObjectWriterException  */
    /*  * */
    /*  * @note */
    /*  * This method must called only once after a call to tpDataHeader. */
    /*  **\/ */
    /* void addTPSubscan(uint64_t time, */
    /*                uint64_t interval, */
    /*                const vector<FLAGSTYPE>& flags, */
    /*                const vector<ACTUALTIMESTYPE>& actualTimes, */
    /*                const vector<ACTUALDURATIONSTYPE>& actualDurations, */
    /*                const vector<AUTODATATYPE>& autoData); */

    void tpData(uint64_t startTime,
                const std::string& execBlockUID,
                uint32_t execBlockNum,
                uint32_t scanNum,
                uint32_t subscanNum,
                uint32_t numOfIntegrations,
                uint32_t numAntenna,
                const std::vector<SDMDataObject::Baseband>& basebands,
                uint64_t time,
                uint64_t interval,
                const std::vector<AxisNameMod::AxisName>& flagsAxes,
                const std::vector<FLAGSTYPE>& flags,
                const std::vector<AxisNameMod::AxisName>& actualTimesAxes,
                const std::vector<ACTUALTIMESTYPE>& actualTimes,
                const std::vector<AxisNameMod::AxisName>& actualDurationsAxes,
                const std::vector<ACTUALDURATIONSTYPE>& actualDurations,
                const std::vector<AxisNameMod::AxisName>& autoDataAxes,
                const std::vector<AUTODATATYPE>& autoData);

    void tpData(uint64_t startTime,
                const std::string& execBlockUID,
                uint32_t execBlockNum,
                uint32_t scanNum,
                uint32_t subscanNum,
                uint32_t numOfIntegrations,
                uint32_t numAntenna,
                const std::vector<SDMDataObject::Baseband>& basebands,
                uint64_t time,
                uint64_t interval,
                const std::vector<AxisNameMod::AxisName>& autoDataAxes,
                const std::vector<AUTODATATYPE>& autoData);

    void tpDataHeader(uint64_t startTime,
                      const std::string& execBlockUID,
                      uint32_t execBlockNum,
                      uint32_t scanNum,
                      uint32_t subscanNum,
                      uint32_t numAntenna,
              SDMDataObject::DataStruct& dataStruct);

    void tpAddIntegration(uint32_t integrationNum,
                          uint64_t time,
                          uint64_t interval,
                          const std::vector<FLAGSTYPE>& flags,
                          const std::vector<ACTUALTIMESTYPE>& actualTimes,
                          const std::vector<ACTUALDURATIONSTYPE>& actualDurations,
                          const std::vector<AUTODATATYPE>& autoData);

    void wvrData (const std::string & execBlockUID,
                  uint32_t execBlockNum,
                  uint32_t scanNum,
                  uint32_t subscanNum,
                  uint32_t numTimes,
                  uint32_t numAntennas,
                  uint32_t numChannels,
                  NetSidebandMod::NetSideband  netSideband,
                  uint64_t time,
                  uint64_t interval,
                  const std::vector<AUTODATATYPE>& wvrData,
                  const std::vector<FLAGSTYPE>& flags);
  
  
    void corrDataHeader(uint64_t startime,
                        const std::string& execBlockUID,
                        uint32_t execBlockNum,
                        uint32_t scanNum,
                        uint32_t subscanNum,
                        uint32_t numAntenna,
                        CorrelationModeMod::CorrelationMode correlationMode,
                        const OptionalSpectralResolutionType& spectralResolutionType,
                        SDMDataObject::DataStruct& dataStruct);


    void addIntegration(uint32_t integrationNum,
                        uint64_t time,
                        uint64_t interval,
                        const std::vector<FLAGSTYPE>& flags,
                        const std::vector<ACTUALTIMESTYPE>& actualTimes,
                        const std::vector<ACTUALDURATIONSTYPE>& actualDurations,
                        const std::vector<ZEROLAGSTYPE>& zeroLags,
                        const std::vector<INTCROSSDATATYPE>& crossData,
                        const std::vector<AUTODATATYPE>& autoData);
    

    void addIntegration(uint32_t integrationNum,
                        uint64_t time,
                        uint64_t interval,
                        const std::vector<FLAGSTYPE>& flags,
                        const std::vector<ACTUALTIMESTYPE>& actualTimes,
                        const std::vector<ACTUALDURATIONSTYPE>& actualDurations,
                        const std::vector<ZEROLAGSTYPE>& zeroLags,
                        const std::vector<SHORTCROSSDATATYPE>& crossData,
                        const std::vector<AUTODATATYPE>& autoData);

    void addIntegration(uint32_t integrationNum,
                        uint64_t time,
                        uint64_t interval,
                        const std::vector<FLAGSTYPE>& flags,
                        const std::vector<ACTUALTIMESTYPE>& actualTimes,
                        const std::vector<ACTUALDURATIONSTYPE>& actualDurations,
                        const std::vector<ZEROLAGSTYPE>& zeroLags,
                        const std::vector<FLOATCROSSDATATYPE>& crossData,
                        const std::vector<AUTODATATYPE>& autoData);


    void addSubintegration(uint32_t integrationNum,
                           uint32_t subintegrationNum,
                           uint64_t time,
                           uint64_t interval,
                           const std::vector<FLAGSTYPE>& flags,
                           const std::vector<ACTUALTIMESTYPE>& actualTimes,
                           const std::vector<ACTUALDURATIONSTYPE>& actualDurations,
                           const std::vector<ZEROLAGSTYPE>& zeroLags,
                           const std::vector<INTCROSSDATATYPE>& crossData,
                           const std::vector<AUTODATATYPE>& autoData);
    

    void addSubintegration(uint32_t integrationNum,
                           uint32_t subintegrationNum,
                           uint64_t time,
                           uint64_t interval,
                           const std::vector<FLAGSTYPE>& flags,
                           const std::vector<ACTUALTIMESTYPE>& actualTimes,
                           const std::vector<ACTUALDURATIONSTYPE>& actualDurations,
                           const std::vector<ZEROLAGSTYPE>& zeroLags,
                           const std::vector<SHORTCROSSDATATYPE>& crossData,
                           const std::vector<AUTODATATYPE>& autoData);

    void addSubintegration(uint32_t integrationNum,
                           uint32_t subintegrationNum,
                           uint64_t time,
                           uint64_t interval,
                           const std::vector<FLAGSTYPE>& flags,
                           const std::vector<ACTUALTIMESTYPE>& actualTimes,
                           const std::vector<ACTUALDURATIONSTYPE>& actualDurations,
                           const std::vector<ZEROLAGSTYPE>& zeroLags,
                           const std::vector<FLOATCROSSDATATYPE>& crossData,
                           const std::vector<AUTODATATYPE>& autoData);

    uint64_t numBytes(); 
      
    
    void output   (const std::string& s);    
    void outputln (const std::string& s);
    void output   (const float* data, uint32_t numData);
    void outputln (const float* data, uint32_t numData);
    void outputln (const long long* data, uint32_t numData);

    template <class T> void output(const std::vector<T>& data) {
      numBytes_ += data.size()*sizeof(T);
      switch (otype_) {

      case STDOUT:
        std::cout.write((const char*)&data.at(0), data.size()*sizeof(T));
        break;
        
      case MEMORY:
        oss_->write((const char*)&data.at(0), data.size()*sizeof(T));
        break;
        
      case FILE:
        ofs_->write((const char*)&data.at(0), data.size()*sizeof(T));
        break;
      }       
    }

    template <class T> void outputln (const std::vector<T>& data) {
      output<T>(data);
      outputln();
    }
    
    void outputln ();

    void outputlnLocation(const std::string& name, const SDMDataSubset& sdmDataSubset);
    
  private:
    enum OUTDEST {STDOUT, MEMORY, FILE};
    OUTDEST otype_;
    std::ofstream*       ofs_;
    std::ostringstream*  oss_;

    // The ALMA uid of the MIME message.
    std::string uid_;

    // The title of the binary data.
    std::string title_;

    // The subscan path.
    std::string subscanPath_;

    // An SDMDataObject
    SDMDataObject sdmDataObject_;

    // The number of the SDMDataSubset being written
    uint32_t sdmDataSubsetNum_;

    // Two strings used as MIME boundaries
    static const std::string MIMEBOUNDARY_1;
    static const std::string MIMEBOUNDARY_2;


    // Class initialization stuff
    static const bool initClass_;
    static bool initClass();

    // The axes names definitions for WVR data and their related flags.
    static std::vector<AxisNameMod::AxisName> WVRDATAAXES, WVRDATAFLAGSAXES;

    // A utility to fill a vector of <Enum> from a an array of c-strings.
    template <class Enum, class EnumHelper> static std::vector<Enum> enumvec(const std::string& strliterals) {
      std::vector<Enum> result;
      
      std::string strliteral;
      std::stringstream ss(strliterals);
      
      std::vector<std::string> tokens;   
      while (ss >> strliteral)
        result.push_back(EnumHelper::literal(strliteral));
      
      return result;     
    }

    // Writes the very first part of the MIME message.
    void preamble();

    // Write the very end of the MIME message.
    void postamble();


    void addData(uint32_t integrationNum,
                 uint32_t subintegrationNum,
                 uint64_t time,
                 uint64_t interval,
                 const std::vector<FLAGSTYPE>& flags,
                 const std::vector<ACTUALTIMESTYPE>& actualTimes,
                 const std::vector<ACTUALDURATIONSTYPE>& actualDurations,
                 const std::vector<ZEROLAGSTYPE>& zeroLags,
                 const std::vector<INTCROSSDATATYPE>& intCrossData,
                 const std::vector<SHORTCROSSDATATYPE>& shortCrossData,
                 const std::vector<FLOATCROSSDATATYPE>& floatCrossData,
                 const std::vector<AUTODATATYPE>& autoData);

    // Are we done with this ?
    bool done_;

    // The number of bytes written so far.
    uint64_t numBytes_;


    // A small finite state automaton to control the usage of SDMDataObjectWriter.
    enum States {START, S_TPDATA, S_TPDATAHEADER, S_ADDTPSUBSCAN, S_ADDTPINTEGRATION, S_WVRDATA, S_CORRDATAHEADER, S_ADDINTEGRATION, S_ADDSUBINTEGRATION, END};
    enum Transitions {T_TPDATA, T_TPDATAHEADER, T_ADDTPSUBSCAN, T_ADDTPINTEGRATION, T_WVRDATA, T_CORRDATAHEADER, T_ADDINTEGRATION, T_ADDSUBINTEGRATION, T_DONE};
    States currentState_;

    void checkState(Transitions t, const std::string& methodName);

  };
} // namespace asdmbinaries
#endif // SDMDataObjectWriter_CLASS