RpcEventBuilder.cc

Go to the documentation of this file.

#include "RawRecordPool/RpcEventBuilder.h"
#include "RawRecordPool/RecordBuffer.h"
#include "RawRecordPool/RecordParser.h"
#include "RawRecordPool/DaqRawEvent.h"
#include "RawRecordPool/PackedRpcEvent.h"
#include "RawRecordPool/RawRecordPoolUtil.h"
#include <iostream>
#include <cstdlib>
#include <cstring>

using DybDaq::EventBuilder;
using DybDaq::RpcEventBuilder;
using DybDaq::RecordBuffer;
using DybDaq::RecordParser;
using DybDaq::DaqRawEvent;
using DybDaq::DaqRomData;
using DybDaq::PackedRpcEvent;
using DybDaq::RawRecordPoolUtil::RTM_DATA_SIZE;
using DybDaq::RawRecordPoolUtil::FEC_DATA_SIZE;

/*
 * EventBuilder
 */
EventBuilder::EventBuilder()
    : m_size(0)
{
}

EventBuilder::~EventBuilder()
{
}

int EventBuilder::size()
{
    return m_size;
}

bool EventBuilder::empty()
{
    return (m_size == 0);
}

int EventBuilder::add(RecordBuffer* record)
{
    if ( record != 0 ) {
        m_records.push_back(record);
        ++m_size;
    }
    return m_size;
}

RecordBuffer* EventBuilder::front()
{
    RecordBuffer* result = 0;
    if ( m_size > 0 ) {
        result = m_records.front();
    }
    return result;
}

RecordBuffer* EventBuilder::pop_front()
{
    RecordBuffer* result = 0;
    if ( m_size > 0 ) {
        result = m_records.front();
        m_records.pop_front();
        --m_size;
    }
    return result;
}

/*
 * RpcEventBuilder::ElementList
 */
RpcEventBuilder::ElementList::ElementList(int elementSize)
    : m_elementsSize(elementSize)
{
    for ( int i = 0; i < 16; ++i ) {
        m_elements.push_back(new uint32_t[elementSize]);
    }
    m_begin = m_elements.begin();
    m_end   = m_elements.begin();
}

RpcEventBuilder::ElementList::~ElementList()
{
    element_iterator it = m_elements.begin();
    while ( it != m_elements.end() ) {
        delete [] (*it);
        ++it;
    }
}

bool RpcEventBuilder::ElementList::empty()
{
    return (m_begin == m_end);
}

uint32_t* RpcEventBuilder::ElementList::front()
{
    if ( m_begin != m_end ) {
        return *m_begin;
    }
    return 0;
}

uint32_t* RpcEventBuilder::ElementList::pre_front()
{
    if ( m_begin != m_elements.begin() ) {
        --m_begin;
        uint32_t* result = *m_begin;
        ++m_begin;
        return result;
    }
    return m_elements.back();
}

void RpcEventBuilder::ElementList::pop_front()
{
    if ( (m_begin != m_end) ) {
        ++m_begin;
        if ( m_begin == m_elements.end() ) {
            m_begin = m_elements.begin();
        }
    }
}

void RpcEventBuilder::ElementList::push_back(const uint32_t* element)
{
    element_iterator bak = m_end++;
    if ( m_end == m_elements.end() ) {
        m_end = m_elements.begin();
    }
    if ( m_end == m_begin ) {
        m_end = bak;
        bak = m_elements.insert(bak, new uint32_t[m_elementsSize]);
    }
    memcpy(*bak, element, m_elementsSize*sizeof(uint32_t));
}

/*
 * RpcEventBuilder
 */
RpcEventBuilder::RpcEventBuilder(RecordParser* parser)
    : m_totRtm(0),
      m_totFec(0),
      m_fresh(true),
      m_parser(parser)
{
    int nRtmCF = parser->farSite() ? 3 : 2;
    int nFecCF = 2*nRtmCF;

    m_rtm = new ElementList*[nRtmCF];
    for ( int i = 0; i < nRtmCF; ++i ) {
        m_rtm[i] = new ElementList(RTM_DATA_SIZE);
    }

    m_fec = new ElementList**[nFecCF];
    for ( int i = 0; i < nFecCF; ++i ) {
        int nFec = 15;  //for the telescope ((i%2) == 0 ) ? 15 : 12;
        m_fec[i] = new ElementList*[nFec];
        for ( int j = 0; j < nFec; ++j ) {
            m_fec[i][j] = new ElementList(FEC_DATA_SIZE);
        }
    }

    m_target = new PackedRpcEvent(m_parser->farSite());
}

RpcEventBuilder::~RpcEventBuilder()
{
    int nRtmCF = m_parser->farSite() ? 3 : 2;
    int nFecCF = 2*nRtmCF;

    for ( int i = 0; i < nRtmCF; ++i ) {
        delete m_rtm[i];
    }
    delete [] m_rtm;

    for ( int i = 0; i < nFecCF; ++i ) {
        int nFec = 15;  //for the telescope ((i%2) == 0 ) ? 15 : 12;
        for ( int j = 0; j < nFec; ++j ) {
            delete m_fec[i][j];
        }
        delete [] m_fec[i];
    }
    delete [] m_fec;

    if ( m_target != 0 ) delete m_target;
}

int RpcEventBuilder::size()
{
    return m_size;
}

bool RpcEventBuilder::empty()
{
    return (m_size == 0);
}

int RpcEventBuilder::add(RecordBuffer* record)
{
    const uint32_t* pevt = (const uint32_t*)(record->data()+16);

    m_target->initHeader(pevt);

    DaqRawEvent event(pevt);
    DaqRomData* rom = event.next_rom();
    while ( rom != 0 ) {
        if ( rom->is_fec() ) {  //FEC data
            const uint32_t* fec = rom->next_fec();
            while ( fec != 0 ) {
                int _CfId  = (fec[0]>>12)&0xF;
                int _FecId = (fec[0]>>8)&0xF;
                m_fec[_CfId][_FecId]->push_back(fec);
                ++m_totFec;
                fec = rom->next_fec();
            }
        }
        else if ( rom->is_rtm() ) {  //RTM data
            const uint32_t* rtm = rom->next_rtm();
            while ( rtm != 0 ) {
                int _CfId  = (rtm[0]>>12)&0xF;
                m_rtm[_CfId]->push_back(rtm);
                ++m_totRtm;
                m_target->updateAccumulation(rtm);
                rtm = rom->next_rtm();
            }
        }
        else {
            std::cerr << "RpcEventBuilder: bad RPC block!" << std::endl;
        }
        delete rom;
        rom = event.next_rom();
    }

    m_fresh = true;
    delete [] record->data();
    delete record;

    //std::cout << "zdebug: Rtm " << m_totRtm << "   Fec " << m_totFec << std::endl;

    bool forced = ( m_totFec < 10000 ) ? false : true;
    tryPack(forced);

    return m_size;
}

RecordBuffer* RpcEventBuilder::front()
{
    RecordBuffer* result = 0;
    if ( m_size > 0 ) {
        result = m_records.front();
    }
    return result;
}

RecordBuffer* RpcEventBuilder::pop_front()
{
    RecordBuffer* result = 0;
    if ( m_size > 0 ) {
        result = m_records.front();
        m_records.pop_front();
        --m_size;
    }
    return result;
}

void RpcEventBuilder::tryPack(bool forced)
{
    while ( m_fresh && m_totRtm > 0 ) {

        // packing a event
        int _RtmCfId = m_target->rtmNeeded();
        while ( _RtmCfId >= 0 ) {
            if ( ! m_rtm[_RtmCfId]->empty() ) {
                if ( m_target->addRtmData(m_rtm[_RtmCfId]->front()) <= 0 ) {
                    m_rtm[_RtmCfId]->pop_front();
                    --m_totRtm;
                }
            }
            else if ( !forced ) {
                m_fresh = false;
                return;
            }
            else {
                m_target->setNextRtm();
            }
            _RtmCfId = m_target->rtmNeeded();
            if ( _RtmCfId < 0 ) m_target->makeFecList();
        }

        int _FecId = m_target->fecNeeded();
        while ( _FecId >= 0 ) {
            int _iRtm = (_FecId >> 8);
            int _FecCfId = (_FecId >> 4) & 0xF;
            _FecId &= 0xF;
            if ( ! m_fec[_FecCfId][_FecId]->empty() ) {
                int status = m_target->addFecData(m_fec[_FecCfId][_FecId]->front(), _iRtm, forced);
                if ( m_target->accumulationValid() || forced ) {
                    if ( status <= 0 ) {
                        m_fec[_FecCfId][_FecId]->pop_front();
                        --m_totFec;
                    }
                    else {  //try to share FecData with the previous event
                        m_target->tryPreFecData(m_fec[_FecCfId][_FecId]->pre_front(), _iRtm);
                    }
                }
                else {
                    m_fresh = false;
                    return;
                }
            }
            else if ( !forced ) {
                m_fresh = false;
                return;
            }
            else {
                m_target->setNextFec();
                m_target->tryPreFecData(m_fec[_FecCfId][_FecId]->pre_front(), _iRtm);
            }
            _FecId = m_target->fecNeeded();
        }

        m_target->pack();
        int   recordSize = m_target->recordSize();
        char* recordData = new char[recordSize];
        memcpy(recordData, m_target->recordData(), recordSize);
        m_records.push_back(new RecordBuffer(recordData, recordSize));
        ++m_size;
        m_target->reset();
    }
}

void RpcEventBuilder::purge()
{
    m_fresh = true;
    tryPack(true);
    m_fresh = false;
}