In This Package:

EventReadout.cc

Go to the documentation of this file.

/*
 *  EventReadout.cc
 *  RawFileReading
 *
 *  Created by Simon Patton on 7/20/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */

#include "EventReadoutFormat/EventReadout.h"

#include "DaqReadoutFormat/ByteBuffer.h"
#include "CbltReadoutFormat/CbltReadout.h"
#include "CbltReadoutFormat/CbltTraits.h"
#include "EventReadoutFormat/EventHeader.h"
#include "EventReadoutFormat/EventTraits.h"
#include "EventReadoutFormat/RomFragment.h"
#include "FadcReadoutFormat/FadcReadout.h"
#include "FeeReadoutFormat/FeeReadout.h"
#include "LtbReadoutFormat/LtbReadout.h"
#include "FecReadoutFormat/FecReadout.h"
#include "RtmReadoutFormat/RtmReadout.h"

using DybDaq::ByteBuffer;
using DybDaq::CbltReadout;
using DybDaq::CbltTraits;
using DybDaq::DaqBuffer;
using DybDaq::DaqTraits;
using DybDaq::EventReadout;
using DybDaq::EventHeader;
using DybDaq::EventBuffer;
using DybDaq::FadcReadout;
using DybDaq::FeeReadout;
using DybDaq::LtbReadout;
using DybDaq::FecReadout;
using DybDaq::RtmReadout;
using DybDaq::RomFragment;

EventReadout::EventReadout(const EventReadout& readout):
DaqContainer(readout),
m_header(0),
m_fragments(0),
m_cbltTraits((CbltTraits*)0) {
    // Currently assumes a ByteBuffer based EventReadout is being copied.
}

EventReadout::EventReadout(const unsigned int site,
                           const unsigned int detector,
                           const unsigned int run,
                           const unsigned int event,
                           const unsigned int dataType,
                           const bool rawCblt,
                           const bool triggerMismatch,
                           const bool invalidData,
                           const EventTraits& traits) :
DaqContainer(),
m_header(new EventHeader(site,
                         detector,
                         run,
                         event,
                         dataType,
                         false,
                         rawCblt,
                         triggerMismatch,
                         invalidData,
                         traits)),
m_fragments(0),
m_cbltTraits((CbltTraits*)0) {
}

EventReadout::EventReadout(const unsigned int site,
                           const unsigned int detector,
                           const unsigned int run,
                           const unsigned int event,
                           const unsigned int dataType,
                           const bool rawCblt,
                           const bool triggerMismatch,
                           const bool invalidData,
                           const CbltTraits& cbltTraits,
                           const EventTraits& traits) :
DaqContainer(),
m_header(new EventHeader(site,
                         detector,
                         run,
                         event,
                         dataType,
                         true,
                         rawCblt,
                         triggerMismatch,
                         invalidData,
                         traits)),
m_fragments(0),
m_cbltTraits(&cbltTraits) {
}

EventReadout::EventReadout(const ByteBuffer& byteBuffer) :
DaqContainer(byteBuffer,
             0),
m_header(0),
m_fragments(0),
m_cbltTraits((CbltTraits*)0) {
    byteBuffer.position(byteBuffer.position() + (header().totalSize() * kBytesInInt));
}

EventReadout::~EventReadout() {
    if (0 != m_fragments) {
        RomFragmentPtrList::iterator fragment;
        for (fragment = m_fragments->begin();
             fragment != m_fragments->end();
             ++fragment) {
            delete const_cast<RomFragment*>(*fragment);
        }
        delete m_fragments;
    }
    if (0 != m_header) {
        delete m_header;
    }
}

const DaqTraits& EventReadout::daqTraits() const {
    return header().eventTraits();
}

const EventHeader& EventReadout::header() const {
    if (0 == m_header && hasByteBuffer()) {
        const ByteBuffer& buffer = byteBuffer();
        
        const unsigned int originalPosition = buffer.position();
        buffer.position(begin());
        m_header = new EventHeader(buffer);
        buffer.position(originalPosition);
    }
    return *m_header;
}

const EventReadout::RomFragmentPtrList& EventReadout::romFragments() const {
    if (0 == m_fragments) {
        m_fragments = new RomFragmentPtrList();
        if (hasByteBuffer()) {
            const ByteBuffer& buffer = byteBuffer();
            
            const unsigned int originalPosition = buffer.position();
            buffer.position(begin() + (header().headerSize() * kBytesInInt));
            const EventTraits& traits = header().eventTraits();
            const bool cbltWrapping = header().cbltWrapping();
            const unsigned int finished = begin() + (bufferSize() * kBytesInInt);
            while (buffer.position() != finished) {
                const RomFragment* romFragment = new RomFragment(buffer,
                                                                 traits,
                                                                 cbltWrapping);
                m_fragments->push_back(romFragment);
            }
            buffer.position(originalPosition);
        }
    }
        return *m_fragments;
}

unsigned int EventReadout::bufferSize() const {
    return header().totalSize();
}

unsigned int EventReadout::gatherComponents(OutputBufferList& outputBuffers) const {
    unsigned int result = header().gather(outputBuffers);
    const RomFragmentPtrList& fragments = romFragments();
    RomFragmentPtrList::const_iterator fragment;
    for (fragment = fragments.begin();
         fragment != fragments.end();
         ++fragment) {
        result += (*fragment)->gather(outputBuffers);
    }
    return result;
}

unsigned int EventReadout::inspectComponents(DaqBuffer::Bytes& inspectors) const {
    unsigned int result = header().inspect(inspectors);
    const RomFragmentPtrList& fragments = romFragments();
    RomFragmentPtrList::const_iterator fragment;
    for (fragment = fragments.begin();
         fragment != fragments.end();
         ++fragment) {
        result += (*fragment)->inspect(inspectors);
    }
    return result;
}

void EventReadout::expanded(const unsigned int size) {
    // If this is non-const, then header must already exist.
    m_header->setTotalSize(m_header->totalSize() + size);
    notifyExpandable(size);
}

void EventReadout::addReadout(const FadcReadout* readout,
                              const unsigned int slot) {
    addReadout(readout,
               slot,
               header().eventTraits().moduleType(EventTraits::kFadcModule));
}

void EventReadout::addReadout(const FeeReadout* readout,
                              const unsigned int slot) {
    addReadout(readout,
               slot,
               header().eventTraits().moduleType(EventTraits::kFeeModule));
}

void EventReadout::addReadout(const LtbReadout* readout,
                              const unsigned int slot) {
    
    addReadout(readout,
               slot,
               header().eventTraits().moduleType(EventTraits::kLtbModule));
}

void EventReadout::addReadout(const FecReadout* readout,
                              const unsigned int slot) {
    
    addReadout(readout,
               slot,
               header().eventTraits().moduleType(EventTraits::kRpcRomModule));
}

void EventReadout::addReadout(const RtmReadout* readout,
                              const unsigned int slot) {
    
    addReadout(readout,
               slot,
               header().eventTraits().moduleType(EventTraits::kRpcRtmModule));
}

void EventReadout::addReadout(const RomData* readout,
                              const unsigned int slot,
                              const unsigned int moduleType) {
    RomFragment* result;
    if (header().cbltWrapping()) {
        CbltReadout* cbltReadout = new CbltReadout(slot,
                                                   moduleType,
                                                   readout,
                                                   *m_cbltTraits);
        result = new RomFragment(header().site(),
                                 header().detector(),
                                 moduleType,
                                 slot,
                                 cbltReadout,
                                 header().eventTraits(),
                                 true,
                                 *this);
    } else {
        result = new RomFragment(header().site(),
                                 header().detector(),
                                 moduleType,
                                 slot,
                                 readout,
                                 header().eventTraits(),
                                 false,
                                 *this);
    }
    add(result);
}

const RomFragment& EventReadout::add(const RomFragment* fragment) {
    if (0 == m_fragments) {
        m_fragments = new RomFragmentPtrList();
    }
    m_fragments->push_back(fragment);
    expanded(fragment->bufferSize());
    return *fragment;
}

---