RawConfigurationBlockV0.cpp

Go to the documentation of this file.

#include "DAQDataFormats/RawConfigurationBlockV0.h"
#include "DAQDataFormats/RawConfigurationBlock.h"
#include "DAQDataFormats/RawConfigurationTail.h"
#include "DAQDataFormats/RawConfigurationSystemID.h"
#include <boost/format.hpp>

/// 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                RawConfigurationBlock
#define  CURRENT_CLASS_VERSION        0
#define  CURRENT_FIELDS_SUB_NAMESPACE configurationblock
#include "DAQDataFormats/DataFormatLast.inc"

namespace daqdataformats{
namespace VERSION_NAMESPACE{


//------------------------------------------------------------------------------
// Default constructor
RawConfigurationBlock::RawConfigurationBlock(const version_t version):
             RawDAQData(version, true, (sizeofdata_t) &RawConfigurationBlock::getPredefinedSize)
            ,ZEROOUT_FUNCTION(close)
            ,ZEROOUT_FUNCTION(getHeader)
            ,ZEROOUT_FUNCTION(getTail)
            ,ZEROOUT_FUNCTION(getTailConst)
            ,ZEROOUT_FUNCTION(getSystemID)
            ,ZEROOUT_FUNCTION(getSystemIDConst)
            ,ZEROOUT_FUNCTION(getSystemIDWithInput)
            ,ZEROOUT_FUNCTION(getSystemIDConstWithInput)
            ,ZEROOUT_FUNCTION(setFloatingSystemIDToBufferSource)
            ,ZEROOUT_FUNCTION(setFloatingSystemID)
            ,ZEROOUT_FUNCTION(addSystemID)
            ,ZEROOUT_FUNCTION(getMarkerHi1)
            ,ZEROOUT_FUNCTION(getMarkerHi2)
            ,ZEROOUT_FUNCTION(getMarkerLo1)
            ,ZEROOUT_FUNCTION(getMarkerLo2)
            ,ZEROOUT_FUNCTION(getConfigurationVersion)
            ,ZEROOUT_FUNCTION(getConfigurationBlockSize)
            ,ZEROOUT_FUNCTION(getSystemNumber)
            ,ZEROOUT_GET_AND_SET(DetectorID)
            ,ZEROOUT_GET_AND_SET(ResourceManagerID)
            ,ZEROOUT_GET_AND_SET(RunNumber)
            ,ZEROOUT_GET_AND_SET(RunType)
            ,ZEROOUT_GET_AND_SET(Partition)
            ,ZEROOUT_GET_AND_SET(Subrun)
            ,ZEROOUT_GET_AND_SET(SystemVersionIDX)
            ,_tail                          (NULL)
            ,_header                        (NULL)
            ,_floatingSystemID              (NULL)
            ,_floatingSystemIDNumber        (-1)
            ,_version_ConfigurationSystemID (rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
            ,_version_ConfigurationTail     (rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
{ }

//------------------------------------------------------------------------------
RawConfigurationBlock::RawConfigurationBlock(const RawConfigurationBlock& copyin):
             RawDAQData(copyin)
            ,DEEPCOPY_FUNCTION(close)
            ,DEEPCOPY_FUNCTION(getHeader)
            ,DEEPCOPY_FUNCTION(getTail)
            ,DEEPCOPY_FUNCTION(getTailConst)
            ,DEEPCOPY_FUNCTION(getSystemID)
            ,DEEPCOPY_FUNCTION(getSystemIDConst)
            ,DEEPCOPY_FUNCTION(getSystemIDWithInput)
            ,DEEPCOPY_FUNCTION(getSystemIDConstWithInput)
            ,DEEPCOPY_FUNCTION(setFloatingSystemIDToBufferSource)
            ,DEEPCOPY_FUNCTION(setFloatingSystemID)
            ,DEEPCOPY_FUNCTION(addSystemID)
            ,DEEPCOPY_FUNCTION(getMarkerHi1)
            ,DEEPCOPY_FUNCTION(getMarkerHi2)
            ,DEEPCOPY_FUNCTION(getMarkerLo1)
            ,DEEPCOPY_FUNCTION(getMarkerLo2)
            ,DEEPCOPY_FUNCTION(getConfigurationVersion)
            ,DEEPCOPY_FUNCTION(getConfigurationBlockSize)
            ,DEEPCOPY_FUNCTION(getSystemNumber)
            ,DEEPCOPY_GET_AND_SET(DetectorID)
            ,DEEPCOPY_GET_AND_SET(ResourceManagerID)
            ,DEEPCOPY_GET_AND_SET(RunNumber)
            ,DEEPCOPY_GET_AND_SET(RunType)
            ,DEEPCOPY_GET_AND_SET(Partition)
            ,DEEPCOPY_GET_AND_SET(Subrun)
            ,DEEPCOPY_GET_AND_SET(SystemVersionIDX)
            ,_tail                          (NULL)
            ,_header                        (NULL)
            ,_floatingSystemID              (NULL)
            ,_floatingSystemIDNumber        (-1)
            ,_version_ConfigurationSystemID (rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
            ,_version_ConfigurationTail     (rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
{}


//------------------------------------------------------------------------------
// Destructor
RawConfigurationBlock::~RawConfigurationBlock(){
    if(_header)             delete _header;
    if(_tail)               delete _tail;
    if(_floatingSystemID)   delete _floatingSystemID;
}

//------------------------------------------------------------------------------
// General initialization
void RawConfigurationBlock::init(){

    /// This is needed for the formats with variable size
    /// If buffer is internal, need to resize it
    if(isInternalBuffer()){
        _InternalBuffer.resize(_header->sizeofdata() + 1);
        checkBufferInternalness();
    }

    _header->init();

    /// header + crc
    _header->setConfigurationBlockSize(_header->sizeofdata() + 1);


    //PRINT_ON_DEBUG("Adresses "<<getBuffer()<<" header"<<_header->getBuffer())
    /// Initialize _floatingSystemIDNumber
    _floatingSystemIDNumber = -1;
}

//------------------------------------------------------------------------------
daqdataformats::RawConfigurationHeader* RawConfigurationBlock::getHeader()  {return _header;}

daqdataformats::RawConfigurationTail*   RawConfigurationBlock::getTailConst() const {
    _tail->setBufferSource(&RAWBUFF32[EXECUTE_FUNCTION(sizeofdata)() - _tail->sizeofdata()]);
    return _tail;
}
daqdataformats::RawConfigurationTail*   RawConfigurationBlock::getTail()            {
    _tail->setBufferSource(&RAWBUFF32[EXECUTE_FUNCTION(sizeofdata)() - _tail->sizeofdata()]);
    return _tail;
}

//------------------------------------------------------------------------------
daqdataformats::RawConfigurationSystemID* RawConfigurationBlock::getSystemID()            {return _floatingSystemID;}
daqdataformats::RawConfigurationSystemID* RawConfigurationBlock::getSystemIDConst() const {return _floatingSystemID;}

//------------------------------------------------------------------------------
daqdataformats::RawConfigurationSystemID* RawConfigurationBlock::getSystemIDWithInput(const uint32_t isystem) {
    EXECUTE_FUNCTION(setFloatingSystemID)(isystem);
    return _floatingSystemID;
}
//------------------------------------------------------------------------------
daqdataformats::RawConfigurationSystemID* RawConfigurationBlock::getSystemIDConstWithInput(const uint32_t isystem) const {
    EXECUTE_FUNCTION(setFloatingSystemID)(isystem);
    return _floatingSystemID;
}

uint32_t RawConfigurationBlock::getMarkerHi1()              const { return _header->getMarkerHi1();}
uint32_t RawConfigurationBlock::getMarkerHi2()              const { return _header->getMarkerHi2();}
uint32_t RawConfigurationBlock::getMarkerLo1()              const { RETURN_FUNCTION(getTailConst)()->getMarkerLo1();}
uint32_t RawConfigurationBlock::getMarkerLo2()              const { RETURN_FUNCTION(getTailConst)()->getMarkerLo2();}
uint32_t RawConfigurationBlock::getConfigurationVersion()   const { return _header->getConfigurationHeaderVersion();}
uint32_t RawConfigurationBlock::getDetectorID()             const { return _header->getDetectorID();}
uint32_t RawConfigurationBlock::getConfigurationBlockSize() const { return _header->getConfigurationBlockSize();}
uint32_t RawConfigurationBlock::getResourceManagerID()      const { return _header->getResourceManagerID();}
uint32_t RawConfigurationBlock::getRunNumber()              const { return _header->getRunNumber();}
uint32_t RawConfigurationBlock::getRunType()                const { return _header->getRunType();}
uint32_t RawConfigurationBlock::getPartition()              const { return _header->getPartition();}
uint32_t RawConfigurationBlock::getSubrun()                 const { return _header->getSubrun();}
uint32_t RawConfigurationBlock::getSystemNumber()           const { return _header->getSystemNumber();}
uint32_t RawConfigurationBlock::getSystemVersionIDX()       const { return _header->getSystemVersionIDX();}


bool RawConfigurationBlock::setDetectorID       (const uint32_t a){return _header->setDetectorID(a);}
bool RawConfigurationBlock::setResourceManagerID(const uint32_t a){return _header->setResourceManagerID(a);}
bool RawConfigurationBlock::setRunNumber        (const uint32_t a){return _header->setRunNumber(a);}
bool RawConfigurationBlock::setRunType          (const uint32_t a){return _header->setRunType(a);}
bool RawConfigurationBlock::setPartition        (const uint32_t a){return _header->setPartition(a);}
bool RawConfigurationBlock::setSubrun           (const uint32_t a){return _header->setSubrun(a);}
bool RawConfigurationBlock::setSystemVersionIDX (const uint32_t a){return _header->setSystemVersionIDX(a);}

//------------------------------------------------------------------------------
bool RawConfigurationBlock::addSystemID(const void* system_pointer){


    const daqdataformats::RawConfigurationSystemID input_system(system_pointer);
    const uint32_t sysid_size = input_system.sizeofdata();

    /// If internal buffer, need to adjust the size
    if(_shouldBufferBeInternal){
            resizeInternalBuffer(_header->getConfigurationBlockSize() + sysid_size);
            checkBufferInternalness();
    }

    const uint32_t system_number = EXECUTE_FUNCTION(getSystemNumber)();

    EXECUTE_FUNCTION(setFloatingSystemID)(system_number);

    /// initialize it. Version and such
    _floatingSystemID->readData(system_pointer);

    /// advancing system number
    _header->setSystemNumber(system_number + 1);
    return _header->setConfigurationBlockSize(_header->getConfigurationBlockSize() + sysid_size);
}

//------------------------------------------------------------------------------
bool RawConfigurationBlock::setFloatingSystemIDToBufferSource(const void* buffer_pointer) const {
            /// If it exists, just set its buffer
            if(_floatingSystemID)
                return _floatingSystemID->setBufferSource(buffer_pointer);

            /// Otherwise, create new Floating MicroSlice pointing to the buffer
            _floatingSystemID = new daqdataformats::RawConfigurationSystemID(buffer_pointer, _version_ConfigurationSystemID);

            return true;
}

//------------------------------------------------------------------------------
bool RawConfigurationBlock::setFloatingSystemID(const uint32_t isysid) const {

        /// If it's already the same, nothing needs to be done
        if((int)isysid == _floatingSystemIDNumber)
            return true;

        /// Pointer that we are going to use
        uint32_t* pointer;

        /// If microslice number is greater than current floating Microslice number, then no need
        /// to loop over all MicroSlices, just start from the current floating MicroSlice
        if((int)isysid > _floatingSystemIDNumber && _floatingSystemIDNumber > -1){
            pointer = (uint32_t*)_floatingSystemID->getBuffer();
        }
        else{
            /// Otherwise, start from scratch
            /// First point to the first MicroSlice
            pointer = (uint32_t*)&RAWBUFF32[_header->sizeofdata()];

            /// Set floating MicroSlice to pointer
            /// If it doesn't exist, create it
            EXECUTE_FUNCTION(setFloatingSystemIDToBufferSource)(pointer);
            _floatingSystemIDNumber = 0;
        }// end of setting the first floating MicroSlice


        /// Pointer to the end of the buffer for checks
        const uint32_t* end_of_buffer_pointer = &RAWBUFF32[EXECUTE_FUNCTION(sizeofdata)()];

        /// Start loop over microslices
        for(; _floatingSystemIDNumber < (int)isysid; ++_floatingSystemIDNumber){
            pointer += _floatingSystemID->sizeofdata();

            /// Check if the pointer is not valid
            if (pointer >= end_of_buffer_pointer)
                return false;

            _floatingSystemID->setBufferSource(pointer);
        }// end of loop over microslices

        return true;
}

//------------------------------------------------------------------------------
bool RawConfigurationBlock::close(const bool produce_crc){

    /// If internal buffer, need to adjust the size
    if(_shouldBufferBeInternal){
        resizeInternalBuffer(_header->getConfigurationBlockSize() + _tail->sizeofdata());
        checkBufferInternalness();
    }

    /// Adjust the size
    _header->setConfigurationBlockSize(_header->getConfigurationBlockSize() + _tail->sizeofdata());

    /// Set Tail's address and initialize it
    EXECUTE_FUNCTION(getTail)()->init();

    /// Add CRC at the very end of _Buffer
    if(produce_crc){
        _tail->setCRC(calculateCheckSum(1));
    }

    return true;
}

//------------------------------------------------------------------------------
bool RawConfigurationBlock::setBufferSource(const void* pointer){

        const uint32_t* old_buffer = (uint32_t*)_Buffer;
        _Buffer                    = (void*)pointer;
        _shouldBufferBeInternal    = isInternalBuffer();

        /// If Header is already defined, then set its buffer source
        /// Otherwise, need to construct it
        if(_header){
            _header->setBufferSource(_Buffer);

            /// It's possible that Floating Microblock was already constructed.
            /// If so, need to reassign its pointer
            if(_floatingSystemIDNumber > -1){

                /// See how many Microblocks in the new buffer.
                /// If it's greater, then make the floating MicroBlock non-valid.
                if(_floatingSystemIDNumber > (int)_header->getSystemNumber()){
                    _floatingSystemIDNumber = -1;
                    return true;
                }// end of checking number of microblocks

                /// New Floating MicroBlock pointer
                const uint32_t* floating_sysid_pointer =((uint32_t*)_Buffer) + ((uint32_t*)_floatingSystemID->getBuffer() - old_buffer);
                RETURN_FUNCTION(setFloatingSystemIDToBufferSource)(floating_sysid_pointer);
            }// end of setting new floating MicroBlock pointer

            return true;

        }

        _header = new daqdataformats::RawConfigurationHeader(_Buffer, _version); ///< version of the DataBlockSliceHeader equals the version of the DataBlockSlice

        PRINT_ON_DEBUG("Constructed _header with version"<<_version);

        _function_sizeofdata = (sizeofdata_t) &RawConfigurationBlock::sizeofdata;
        return true;
}

//------------------------------------------------------------------------------
// This is a general method to read the microslice from millislice_buffer to _Buffer
void* RawConfigurationBlock::readData(const void* buffer)
{
    const uint32_t header_size = _header->sizeofdata();

    /// If internal buffer, need to adjust the size
    if(_shouldBufferBeInternal){
        resizeInternalBuffer(header_size);
        checkBufferInternalness();
    }

    /// Read the header
    void* buffer_new = _header->readData(buffer);

    /// If internal buffer, need to adjust the size
    if(_shouldBufferBeInternal){
        resizeInternalBuffer(EXECUTE_FUNCTION(sizeofdata)());
        checkBufferInternalness();
    }

    /// Now, read the rest of the configuration block
    buffer_new = readDataGeneral(buffer_new, EXECUTE_FUNCTION(sizeofdata)() - header_size, header_size);

    checkBufferInternalness();

    return buffer_new;
 }// end of readData(void*)

//------------------------------------------------------------------------------
// Print the DataBlock structure
void RawConfigurationBlock::print(std::ostream& os) const {

    os<<"----------ConfigurationBlock----------------------------------------size="<<EXECUTE_FUNCTION(sizeofdata)();
    _header->print(os);

    const uint32_t nsystems = EXECUTE_FUNCTION(getSystemNumber)();

    os<<"\nNumber of systems = "<<nsystems<<"\n";


    daqdataformats::RawConfigurationBlock confblock_copy(_Buffer, _version);

    if(nsystems){
        for(uint32_t isystem = 0; isystem < nsystems; ++isystem){
            confblock_copy.getSystemID(isystem)->print(os);
        }
    }

    daqdataformats::RawConfigurationTail* tail = confblock_copy.getTail();

    /// see if the tail is valid
    if(tail->getMarkerLo1() == daqdataformats::rawconftail::Marker_value[0] && tail->getMarkerLo2() == daqdataformats::rawconftail::Marker_value[1]){
        tail->print(os);
    }
    else
        os<<"Configuration Block is not closed\n";


}

}}// end of namespaces