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 <boost/regex.hpp> 

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

#include "SDMDataObject.h"

#include "CAtmPhaseCorrection.h"
#include "CCorrelationMode.h"
#include "CCorrelatorType.h"
#include "CNetSideband.h"
#include "CProcessorType.h"


using namespace std;

using namespace AtmPhaseCorrectionMod;
using namespace CorrelationModeMod;
using namespace CorrelatorTypeMod;
using namespace NetSidebandMod;
using namespace ProcessorTypeMod;

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

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

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

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

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


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

    SDMDataObjectWriter(ostringstream* oss, const string& uid="uid://X0/X0/X0", const 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 string& execBlockUID,
                uint32_t execBlockNum,
                uint32_t scanNum,
                uint32_t subscanNum,
                uint32_t numOfIntegrations,
                uint32_t numAntenna,
                const vector<SDMDataObject::Baseband>& basebands,
                uint64_t time,
                uint64_t interval,
                const vector<AxisName>& flagsAxes,
                const vector<FLAGSTYPE>& flags,
                const vector<AxisName>& actualTimesAxes,
                const vector<ACTUALTIMESTYPE>& actualTimes,
                const vector<AxisName>& actualDurationsAxes,
                const vector<ACTUALDURATIONSTYPE>& actualDurations,
                const vector<AxisName>& autoDataAxes,
                const vector<AUTODATATYPE>& autoData);

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

    void tpDataHeader(uint64_t startTime,
                      const 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 vector<FLAGSTYPE>& flags,
                          const vector<ACTUALTIMESTYPE>& actualTimes,
                          const vector<ACTUALDURATIONSTYPE>& actualDurations,
                          const vector<AUTODATATYPE>& autoData);

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


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

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

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


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

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

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

    uint64_t numBytes(); 
      
    
    void output   (const string& s);    
    void outputln (const 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 vector<T>& data) {
      numBytes_ += data.size()*sizeof(T);
      switch (otype_) {

      case STDOUT:
        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 vector<T>& data) {
      output<T>(data);
      outputln();
    }
    
    void outputln ();

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

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

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

    // The subscan path.
    string subscanPath_;

    // An SDMDataObject
    SDMDataObject sdmDataObject_;

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

    // Two strings used as MIME boundaries
    static const string MIMEBOUNDARY_1;
    static const 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 vector<AxisName> WVRDATAAXES, WVRDATAFLAGSAXES;

    // A utility to fill a vector of <Enum> from a an array of c-strings.
    template <class Enum, class EnumHelper> static vector<Enum> enumvec(const string& strliterals) {
      vector<Enum> result;
      
      string strliteral;
      stringstream ss(strliterals);
      
      vector<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 vector<FLAGSTYPE>& flags,
                 const vector<ACTUALTIMESTYPE>& actualTimes,
                 const vector<ACTUALDURATIONSTYPE>& actualDurations,
                 const vector<ZEROLAGSTYPE>& zeroLags,
                 const vector<INTCROSSDATATYPE>& intCrossData,
                 const vector<SHORTCROSSDATATYPE>& shortCrossData,
                 const vector<FLOATCROSSDATATYPE>& floatCrossData,
                 const 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 string& methodName);

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