RawTriggerV0.cpp

Go to the documentation of this file.

#include "DAQDataFormats/RawTriggerV0.h"
#include "DAQDataFormats/RawTriggerHeader.h"
#include "DAQDataFormats/RawTriggerTimingMarker.h"
#include "DAQDataFormats/RawTriggerRange.h"
#include "DAQDataFormats/RawTriggerTime.h"
#include "DAQDataFormats/RawTriggerMask.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                RawTrigger
#define  CURRENT_CLASS_VERSION        0
#define  CURRENT_FIELDS_SUB_NAMESPACE rawtrigger
#include "DAQDataFormats/DataFormatLast.inc"

namespace daqdataformats{
namespace VERSION_NAMESPACE{

//------------------------Constructors------------------------------------------
RawTrigger::RawTrigger(const version_t version):
    RawDAQData(version, true)
     ,ZEROOUT_SET(TriggerHeader)
     ,ZEROOUT_SET(TriggerTimingMarker)
     ,ZEROOUT_SET(TriggerRange)
     ,ZEROOUT_SET(TriggerTime)
     ,ZEROOUT_SET(TriggerMask)
     ,ZEROOUT_GET_AND_SET(TriggerStart)
    ,_function_readDataFromFileDescriptor(&RawTrigger::readDataUnknownVersion)
    ,_Header (NULL)
    ,_Marker (NULL)
    ,_Range  (NULL)
    ,_Time   (NULL)
    ,_Mask   (NULL)
    ,_size   (1)     /// Need at least size 1 to be able to set the Header pointer
    ,_version_TriggerTimingMarker(daqdataformats::rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
    ,_version_TriggerRange       (daqdataformats::rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
    ,_version_TriggerTime        (daqdataformats::rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
    ,_version_TriggerMask        (daqdataformats::rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
{}
//------------------------------------------------------------------------------
RawTrigger::RawTrigger(const RawTrigger& copyin):
     RawDAQData(copyin)
     ,DEEPCOPY_SET(TriggerHeader)
     ,DEEPCOPY_SET(TriggerTimingMarker)
     ,DEEPCOPY_SET(TriggerRange)
     ,DEEPCOPY_SET(TriggerTime)
     ,DEEPCOPY_SET(TriggerMask)
     ,DEEPCOPY_GET_AND_SET(TriggerStart)
     ,_function_readDataFromFileDescriptor(copyin._function_readDataFromFileDescriptor)
    ,_Header (NULL)
    ,_Marker (NULL)
    ,_Range  (NULL)
    ,_Time   (NULL)
    ,_Mask   (NULL)
    ,_size   (copyin._size)     /// Need at least size 1 to be able to set the Header pointer
    ,_version_TriggerTimingMarker(copyin._version_TriggerTimingMarker)
    ,_version_TriggerRange       (copyin._version_TriggerRange)
    ,_version_TriggerTime        (copyin._version_TriggerTime)
    ,_version_TriggerMask        (copyin._version_TriggerMask)
{ }




//------------------------Destructor--------------------------------------------
RawTrigger::~RawTrigger() {
    if(_Header){
        delete _Header;
        delete _Marker;
        delete _Range;
        delete _Time;
        delete _Mask;
    }
}

//------------------------------------------------------------------------------
// Default Initialization of Data members
void RawTrigger::init(){

  PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" Initializing Header");
    _Header->init();
    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" Initializing _Time");
    _Time->init();
    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" Initializing _Marker");
    _Marker->init();
    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" Initializing _Range");
    _Range->init();
    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" Initializing _Mask");
    _Mask->init();
    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" End of method");
}

//------------------------------------------------------------------------------
uint64_t  RawTrigger::getTriggerStart() const                    { return _Marker->getTriggerStart_baseClock();}
bool      RawTrigger::setTriggerStart(const uint64_t start_time) { return _Marker->setTriggerStart_baseClock(start_time);}


//------------------------------------------------------------------------------
void RawTrigger::print(std::ostream& os) const{

    os<<boost::format("---RawTrigger version %d... Size=%d\n")% _version% EXECUTE_FUNCTION(sizeofdata)();

    _Header->print(os);

    _Time->print(os);

    _Marker->print(os);

    _Range->print(os);

    _Mask->print(os);

    PRINT_ON_DEBUG("Buffer is set to "<<_Buffer);

    os<<boost::format("---END OF RawTrigger version %d... Size=%d\n")% _version% EXECUTE_FUNCTION(sizeofdata)();

}

//------------------------------------------------------------------------------
bool RawTrigger::setTriggerHeader      (const daqdataformats::RawTriggerHeader&       header) { _Header->readData(header.getBuffer()); return true;}
bool RawTrigger::setTriggerTimingMarker(const daqdataformats::RawTriggerTimingMarker& marker) { _Marker->readData(marker.getBuffer()); return true;}
bool RawTrigger::setTriggerRange       (const daqdataformats::RawTriggerRange&        range ) { _Range->readData(range.getBuffer())  ; return true;}
bool RawTrigger::setTriggerTime        (const daqdataformats::RawTriggerTime&         time  ) { _Time->readData(time.getBuffer())    ; return true;}
bool RawTrigger::setTriggerMask        (const daqdataformats::RawTriggerMask&         mask  ) { _Mask->readData(mask.getBuffer())    ; return true;}

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


   _Buffer = (void*)pointer;

   /// If Header is already defined, then set its buffer source
   /// Otherwise, need to construct it
   if(_Header){
       void* pointer_new = setBufferSourceGeneral(*_Header, _Buffer);
       pointer_new       = setBufferSourceGeneral(*_Time  , pointer_new);
       pointer_new       = setBufferSourceGeneral(*_Marker, pointer_new);
       pointer_new       = setBufferSourceGeneral(*_Range , pointer_new);
       return _Mask->setBufferSource(pointer_new);
   }

   PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" initializing");
   /// So, Header, etc. are not constructed


   /// Construct header
   _Header  = new daqdataformats::RawTriggerHeader(_Buffer, _version);     ///< version of the TriggerHeader equals the version of the TriggerHeader
        _size = _Header->sizeofdata();                     ///< Trigger size so far
        PRINT_ON_DEBUG("size = "<<_size);
        /// Adjust internal buffer. One more word is needed to consttruct the next object
        _shouldBufferBeInternal = isInternalBuffer();
        if(_shouldBufferBeInternal) resizeInternalBuffer(_size + 1);

        PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" After initializing Header size = "<<_size);

        PRINT_ON_DEBUG("Version_trigger = "<<_version<<"   "<<_version_TriggerTime);;

   /// Construct Time
   _Time = new daqdataformats::RawTriggerTime(&RAWBUFF32[_size],   _version_TriggerTime);
        _size += _Time->sizeofdata();                      ///< Trigger size so far
        PRINT_ON_DEBUG("size = "<<_size<<" Added "<<_Time->sizeofdata());
        /// Adjust internal buffer. One more word is needed to consttruct the next object
        if(_shouldBufferBeInternal) resizeInternalBuffer(_size + 1);


        PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" After initializing _Time size = "<<_size);

   /// Construct TriggerTimingMarker
   _Marker = new daqdataformats::RawTriggerTimingMarker(&RAWBUFF32[_size], _version_TriggerTimingMarker);
        _size += _Marker->sizeofdata();                      ///< Trigger size so far
        PRINT_ON_DEBUG("size = "<<_size);

        /// Adjust internal buffer. One more word is needed to consttruct the next object
        if(_shouldBufferBeInternal) resizeInternalBuffer(_size + 1);
        PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" After initializing _Marker size = "<<_size);

   /// Construct Range
   _Range = new daqdataformats::RawTriggerRange      (&RAWBUFF32[_size], _version_TriggerRange);
        _size += _Range->sizeofdata();                     ///< Trigger size so far
        PRINT_ON_DEBUG("size = "<<_size);
        /// Adjust internal buffer. One more word is needed to consttruct the next object
        if(_shouldBufferBeInternal) resizeInternalBuffer(_size + 1);
        PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" After initializing _Range size = "<<_size);
   
   /// Construct Mask
   _Mask = new daqdataformats::RawTriggerMask        (&RAWBUFF32[_size], _version_TriggerMask);
        _size += _Mask->sizeofdata();                      ///< Final Trigger size
        PRINT_ON_DEBUG("size = "<<_size);
        /// Final adjustment of internal buffer
        if(_shouldBufferBeInternal) resizeInternalBuffer(_size);
        PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" After initializing _Mask size = "<<_size);
        
   return true;
}


//------------------------------------------------------------------------------
bool RawTrigger::setVersions(){
    _version_TriggerTimingMarker = CURRENT_FIELDS_SUB_NAMESPACE::VERSION_TriggerTimingMarker;
    _version_TriggerRange        = CURRENT_FIELDS_SUB_NAMESPACE::VERSION_TriggerRange;
    _version_TriggerTime         = CURRENT_FIELDS_SUB_NAMESPACE::VERSION_TriggerTime;
    _version_TriggerMask         = CURRENT_FIELDS_SUB_NAMESPACE::VERSION_TriggerMask;
    return true;
}


//------------------------------------------------------------------------------
// Read an entire DataBlock from datablock_buffer into _Buffer
void* RawTrigger::readData(const void* datablock_buffer){

    const uint32_t header_size = _Header->sizeofdata();

    //Read the header and unpack it
    void* datablock_buffer_new = readDataGeneral(datablock_buffer, header_size, 0);

    /// Check pointers after each read or resize buffer
    checkBufferInternalness();

    // read the rest of 
    datablock_buffer_new = readDataGeneral(datablock_buffer_new, EXECUTE_FUNCTION(sizeofdata)() - header_size, header_size);

    /// Check pointers after each read or resize buffer
    checkBufferInternalness();

    return datablock_buffer_new;
}

//------------------------------------------------------------------------------
// Method to read data from a PIPE (not socket).
// Only one read can be made. After that the pipe is closed.
// According to Ron Rechenmacher, the maximum size of a PIPE is 512 bytes.
readDataStatus RawTrigger::readDataFromFileDescriptor(const int fd)
{
        if (fd < 0) return rds_error;
        
        /// since the version is known, the internal buffer is set accordingly
        /// The maximum size of a pipe
        const size_t bytes_to_read = 512;

        const size_t bytes_read    = read(fd, (char*)_Buffer, bytes_to_read );
        
        if ((int)bytes_read==-1 || bytes_read == 0)
                return rds_error;

        /// Cant be greater
        if (bytes_read > bytes_to_read){
                return rds_error;
        }

        /// check for reasonableness
        if (_Header->getDelimiter() != daqdataformats::triggerheader::TriggerHeaderDelimiter)
                return rds_error;
            
        const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();

        // at this point, the header should have been read in and the
        // size from within can be examined.
        if (size_of_data > 512/sizeof (uint32_t) ) 
                return rds_error;

        /// check if something is wrong
        if (((size_t)size_of_data*sizeof (uint32_t)) != bytes_read)
                return rds_error;
        
        return rds_complete;
}

//------------------------------------------------------------------------------
// Method to read data from a PIPE (not socket).
// Only one read can be made. After that the pipe is closed.
// According to Ron Rechenmacher, the maximum size of a PIPE is 512 bytes.
readDataStatus RawTrigger::readDataUnknownVersion(const int fd)
{
    
        if (fd < 0) return rds_error;
        
        /// since the version is known, the internal buffer is set accordingly
        /// The maximum size of a pipe
        const size_t bytes_to_read = 512;
        
        /// If the buffer is internal, need to resize it
        if (isInternalBuffer()){
                _InternalBuffer.resize(bytes_to_read / sizeof(uint32_t));
                _Buffer = (void*)(&_InternalBuffer[0]);
        }// end of checking if the buffer is internal


        const size_t bytes_read    = read(fd, (char*)_Buffer, bytes_to_read );

        
        if ((int)bytes_read==-1 || bytes_read==0)
                return rds_error;

        /// Cant be greater
        if (bytes_read > bytes_to_read){
                return rds_error;
        }

        /// Now we can figure out the version of the Trigger
        _version = figureOutTheVersion(_Buffer);


        /// Now that we know the version, initialize function pointers
        setFunctionPointers();

        /// Need to construct all Headers and stuff
        setBufferSource(_Buffer);
        
        /// check for reasonableness
        if (_Header->getDelimiter() != daqdataformats::triggerheader::TriggerHeaderDelimiter)
                return rds_error;

        const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();

        // at this point, the header should have been read in and the
        // size from within can be examined.
        if (size_of_data > 512/sizeof (uint32_t) ) 
                return rds_error;

        /// check if something is wrong
        if (((size_t)size_of_data*sizeof (uint32_t)) != bytes_read)
                return rds_error;
        
        return rds_complete;
}


}}// end of namespaces