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 "EventReadoutFormat/RomHeader.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;
using DybDaq::RomHeader;

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 bool rpcSortDisabled,
                           const bool dataSortTimeout,
                           const EventTraits& traits) :
DaqContainer(),
m_header(new EventHeader(site,
                         detector,
                         run,
                         event,
                         dataType,
                         false,
                         rawCblt,
                         triggerMismatch,
                         invalidData,
                         rpcSortDisabled,
                         dataSortTimeout,
                         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 bool rpcSortDisabled,
                           const bool dataSortTimeout,
                           const CbltTraits& cbltTraits,
                           const EventTraits& traits) :
DaqContainer(),
m_header(new EventHeader(site,
                         detector,
                         run,
                         event,
                         dataType,
                         true,
                         rawCblt,
                         triggerMismatch,
                         invalidData,
                         rpcSortDisabled,
                         dataSortTimeout,
                         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;
}

bool EventReadout::containsPmtFragments() const {
    const EventTraits& traits = header().eventTraits();
    const unsigned int kLtbModuleType = traits.moduleType(EventTraits::kLtbModule);
    const unsigned int kFeeModuleType = traits.moduleType(EventTraits::kFeeModule);
    const unsigned int kFadcModuleType = traits.moduleType(EventTraits::kFadcModule);
    const RomFragmentPtrList& fragments = romFragments();
    for (RomFragmentPtrList::const_iterator fragment = fragments.begin();
         fragment != fragments.end();
         ++fragment) {
        unsigned int romType = (*fragment)->header().moduleType();
        if (kLtbModuleType == romType || kFeeModuleType == romType || kFadcModuleType == romType) {
            return true;
        }
    }
    return false;
}
        
bool EventReadout::containsRpcFragments() const {
    const EventTraits& traits = header().eventTraits();
    const unsigned int kRpcRomModuleType = traits.moduleType(EventTraits::kRpcRomModule);
    const unsigned int kRpcRtmModuleType = traits.moduleType(EventTraits::kRpcRtmModule);
    const RomFragmentPtrList& fragments = romFragments();
    for (RomFragmentPtrList::const_iterator fragment = fragments.begin();
         fragment != fragments.end();
         ++fragment) {
        unsigned int romType = (*fragment)->header().moduleType();
        if (kRpcRomModuleType == romType || kRpcRtmModuleType == romType) {
            return true;
        }
    }
    return false;
}

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;
}