RawSummaryDCMDataV0.cpp

Go to the documentation of this file.

#include "DAQDataFormats/RawSummaryDCMDataV0.h"
#include "DAQDataFormats/RawSummaryDCMDataPoint.h"
#include "DAQDataFormats/RawMilliSliceHeader.h"
#include <boost/format.hpp>
#include <iomanip>

/// It is requred to
///   1. include DAQDataFormats/DataFormatFirst.inc
///   2. define CURRENT_CLASS
///   3.    define CURRENT_CLASS_VERSION for version of the class
///      OR define LAST_CLASS_VERSION    for the main structure of the class
///   4. (optional) define CURRENT_FIELDS_SUB_NAMESPACE
///   5. include DAQDataFormats/DataFormatLast.inc
/// before the declaration of the DataFormat version class in the header.
#include "DAQDataFormats/DataFormatFirst.inc"
#define  CURRENT_CLASS                RawSummaryDCMData
#define  CURRENT_CLASS_VERSION        0
#define  CURRENT_FIELDS_SUB_NAMESPACE summarydcmdata
#include "DAQDataFormats/DataFormatLast.inc"

//#define PRINT_ON_DEBUG(x) std::cout<<x<<"\n";

namespace daqdataformats{
namespace VERSION_NAMESPACE{

//------------------------------------------------------------------------------
// Default constructor
RawSummaryDCMData::RawSummaryDCMData(const version_t version):
     RawDAQData(version, true, (sizeofdata_t) &RawSummaryDCMData::getPredefinedSize)
    ,_Header (NULL)
{ }

//------------------------------------------------------------------------------
RawSummaryDCMData::RawSummaryDCMData(const RawSummaryDCMData& copyin):
     RawDAQData(copyin)
    ,_Header (NULL)
{ }

//------------------------------------------------------------------------------
// Destructor
RawSummaryDCMData::~RawSummaryDCMData() {
    if(_Header) delete _Header;
}

 bool  RawSummaryDCMData::addDataPoints(const std::list<std::pair<uint64_t, uint16_t> >& list, const uint8_t type)
  {
    const uint32_t new_sizeofdata = EXECUTE_FUNCTION(sizeofdata)() +  list.size() * summarydcmdatapoint::RAWSUMMARYDCMDATAPOINT_SIZE;
    PRINT_ON_DEBUG(__PRETTY_FUNCTION__ << ": list.size()=" << list.size() << ", new_sizeofdata=" << new_sizeofdata << " 000000000000");
    /// If buffer is internal, we need to adjust its size
    if(_shouldBufferBeInternal) {
      /// Dcmdata size is the size of the header and the microslice

      /// Add the dcmdata size
      resizeInternalBuffer(new_sizeofdata);

      /// Check pointers after each read or resize buffer
      checkBufferInternalness();
    }// end of adjusting the internal buffer size

    PRINT_ON_DEBUG(__PRETTY_FUNCTION__ << ": list.size()=" << list.size() << ", new_sizeofdata=" << new_sizeofdata << " 1111111111111");
    std::list<std::pair<uint64_t, uint16_t> >::const_iterator ii = list.begin(), ee=list.end();
    for(; ii != ee; ++ii) {
      //std::cout << "RawSummaryDCMDataV0::addDataPoints: first:0x" << std::hex << (unsigned long long)(*ii).first <<", second:" << (unsigned)(*ii).second << ", type: " << (unsigned)type << std::endl;
      daqdataformats::RawSummaryDCMDataPoint newPoint(daqdataformats::summarydcmdatapoint::RAWSUMMARYDCMDATAPOINT_LATEST_VERSION);
      newPoint.setTimeStamp((*ii).first);
      newPoint.setDCMID((*ii).second);
      newPoint.setDataType(type);
      readDataGeneral(newPoint.getBuffer(), newPoint.sizeofdata(), EXECUTE_FUNCTION(sizeofdata)());
      checkBufferInternalness();
      _Header->advanceNumEntries();
      PRINT_ON_DEBUG(__PRETTY_FUNCTION__ << ": list.size()=" << list.size() << ", new_sizeofdata=" << new_sizeofdata << " 2222222222222");
    }
    return true;
    
  }
// //------------------------------------------------------------------------------
 bool RawSummaryDCMData::setBufferSource(const void* pointer){

   PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" initial size of internal buffer"<<_InternalBuffer.size());

        _Buffer = (void*)pointer;

        _shouldBufferBeInternal = isInternalBuffer();

        /// If Header is already defined, then set its buffer source
        /// Otherwise, need to construct it
        if(_Header) {
            return _Header->setBufferSource(pointer);
        }
        PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" step0 size of internal buffer "<<_InternalBuffer.size()<<"  000000000000000000000000000000000000000000000000000\n");

        /// Construct header
        _Header = new daqdataformats::RawSummaryDCMDataHeader(_Buffer, _version); ///< version of the MicroBlockHeader equals the version of the MicroBlock

        /// If buffer is internal, resize it to header size plus one,
        /// so that we can assige the start of the MicroSlice buffer
        if(_shouldBufferBeInternal){
            resizeInternalBuffer(_Header->sizeofdata() + 0);
            /// Check pointers after each read or resize buffer
            checkBufferInternalness();
        }

        PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" step1 size of internal buffer "<<_InternalBuffer.size()<<"  1111111111111111111111111111111111111111111111111111\n");

        EXECUTE_ON_DEBUG(
                         if(_function_sizeofdata)std::cout<<"sizeofdata before binding "<<sizeofdata()<<"\n";
                         else                    std::cout<<"sizeofdata is not bound\n"
        );

        _function_sizeofdata = (sizeofdata_t) &version0::RawSummaryDCMData::sizeofdata;

        PRINT_ON_DEBUG("sizeofdata after binding "<<sizeofdata());
        return true;
    }

  void RawSummaryDCMData::init() {

    /// This is needed for the formats with variable size
    /// If buffer is internal, need to resize it
    if(_shouldBufferBeInternal){
        resizeInternalBuffer(_Header->sizeofdata());
        /// Check pointers after each read or resize buffer
        checkBufferInternalness();
    }

    _Header->init();
  }

      uint32_t            RawSummaryDCMData::getVersion()                 const { return _Header->getVersion();}

//------------------------------------------------------------------------------
// Printing the MicroBlock structure
void RawSummaryDCMData::print(std::ostream& os) const {

    const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();

    os<<boost::format("\n---SummaryDCMData---------------------------------------------(size=%u, version=%u)\n")
            % size_of_data % _version;

    printBuffer(os);

    for(uint32_t i = 0; i < size_of_data; ++i){
            os<<" ";
            printWord(i, false, os);
            os<<"\n";
    }

    _Header->print(os);
    printBinary(_Buffer, _Header->sizeofdata(), os);
}

//------------------------------------------------------------------------------
// Size of the MicroBlock _Buffer in words
uint32_t RawSummaryDCMData::sizeofdata() const {
  if(!_Header) return 0;
  return _Header->sizeofdata() + _Header->getNumEntries() * summarydcmdatapoint::RAWSUMMARYDCMDATAPOINT_SIZE;
}

  daqdataformats::RawSummaryDCMDataPoint* RawSummaryDCMData::getDataPoint(const uint32_t idx) const
  {
    if(_Header->getNumEntries() - 1 < idx) return NULL;
    void* pointer = (void*)&RAWBUFF32[_Header->sizeofdata() + 3*idx];
    return new daqdataformats::RawSummaryDCMDataPoint(pointer, 0);
  }

}}// end of namespaces