In This Package:

LtbReadout.cc

Go to the documentation of this file.

/*
 *  LtbReadout.cc
 *  LtbReadoutFormat
 *
 *  Created by Simon Patton on 7/22/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */

#include "LtbReadoutFormat/LtbReadout.h"

#include "DaqReadoutFormat/ByteBuffer.h"
#include "LtbReadoutFormat/LtbFrame.h"
#include "LtbReadoutFormat/LtbFoot.h"
#include "LtbReadoutFormat/LtbHead.h"
#include "LtbReadoutFormat/LtbTraits.h"

using DybDaq::ByteBuffer;
using DybDaq::DaqBuffer;
using DybDaq::DaqContainer;
using DybDaq::DaqTraits;
using DybDaq::LtbBuffer;
using DybDaq::LtbFoot;
using DybDaq::LtbFrame;
using DybDaq::LtbHead;
using DybDaq::LtbReadout;
using DybDaq::LtbTraits;

LtbReadout::LtbReadout(const unsigned int localTriggerNumber,
                       const unsigned int rawTriggerTotal,
                       const unsigned int ltbStatus,
                       const bool clockError,
                       const LtbTraits& traits) :
DaqContainer(),
m_head(new LtbHead(localTriggerNumber,
                   rawTriggerTotal,
                   ltbStatus,
                   clockError,
                   traits)),
m_frames(0),
m_foot(0) {
}

LtbReadout::LtbReadout(const ByteBuffer& byteBuffer,
                       const unsigned int bufferSize) :
DaqContainer(byteBuffer,
             bufferSize),
m_head(0),
m_frames(0),
m_foot(0) {
    byteBuffer.position(byteBuffer.position() + (bufferSize * kBytesInInt));
}

LtbReadout::~LtbReadout() {
    if (0 != m_foot) {
        delete m_foot;
    }
        if (0 != m_frames) {
                LtbFramePtrList::iterator iterator;
                for (iterator = m_frames->begin();
                         iterator != m_frames->end();
                         ++iterator) {
                        delete const_cast<LtbFrame*>(*iterator);
                }
                delete m_frames;
        }
    if (0 != m_head) {
        delete m_head;
    }
}

const DaqTraits& LtbReadout::daqTraits() const {
    return head().ltbTraits();
}

const LtbHead& LtbReadout::head() const {
    if (0 == m_head && hasByteBuffer()) {
        const ByteBuffer& buffer = byteBuffer();
        const unsigned int originalPosition = buffer.position();
        buffer.position(begin());
        m_head = new LtbHead(buffer);
        buffer.position(originalPosition);
    }
    return *m_head;
}

const LtbReadout::LtbFramePtrList& LtbReadout::ltbFrames() const {
    if (0 == m_frames) {
        m_frames = new LtbFramePtrList();
        if (hasByteBuffer()) {
            const LtbTraits& traits = head().ltbTraits();
            const ByteBuffer& buffer = byteBuffer();
            
            const unsigned int originalPosition = buffer.position();
            buffer.position(begin() + (traits.headSize() * kBytesInInt));
            const unsigned int finished = (containerSize() - (traits.headSize() + traits.footSize())) / traits.frameSize();
            for (unsigned int count = 0;
                 count != finished;
                 ++count) {
                const LtbFrame* frame = new LtbFrame(buffer,
                                                     traits);    
                m_frames->push_back(frame);
            }
            buffer.position(originalPosition);
        }
    }
    return *m_frames;
}

const LtbFoot& LtbReadout::foot() const {
    if (0 == m_foot && hasByteBuffer()) {
        const LtbTraits& traits = head().ltbTraits();
        const ByteBuffer& buffer = byteBuffer();
        
        const unsigned int originalPosition = buffer.position();
        buffer.position(begin() + ((containerSize() - traits.footSize()) * kBytesInInt));
        m_foot = new LtbFoot(buffer,
                             head().ltbTraits());
        buffer.position(originalPosition);
        
    }
    return *m_foot;
}

unsigned int LtbReadout::gatherRom(DaqBuffer::OutputBufferList& outputBuffers) const {
    return gather(outputBuffers);
}

unsigned int LtbReadout::inspectRom(DaqBuffer::Bytes& inspectors) const {
    return inspect(inspectors);
}

unsigned int LtbReadout::romSize() const {
    return bufferSize();
}

unsigned int LtbReadout::gatherComponents(OutputBufferList& outputBuffers) const {
    unsigned int result = head().gather(outputBuffers);
    const LtbFramePtrList& frames = ltbFrames();
    LtbFramePtrList::const_iterator frame;
    for (frame = frames.begin();
         frame != frames.end();
         ++frame) {
        result += (*frame)->gather(outputBuffers);
    }
    
    result += foot().gather(outputBuffers);
    return result;
}

unsigned int LtbReadout::inspectComponents(DaqBuffer::Bytes& inspectors) const {
    unsigned int result = head().inspect(inspectors);
    const LtbFramePtrList& frames = ltbFrames();
    LtbFramePtrList::const_iterator frame;
    for (frame = frames.begin();
         frame != frames.end();
         ++frame) {
        result += (*frame)->inspect(inspectors);
    }
    
    result += foot().inspect(inspectors);
    return result;
}
    
unsigned int LtbReadout::bufferSize() const {
    unsigned int result = head().bufferSize();
    const LtbFramePtrList& frames = ltbFrames();
    LtbFramePtrList::const_iterator frame;
    for (frame = frames.begin();
         frame != frames.end();
         ++frame) {
        result += (*frame)->bufferSize();
    }
    result += foot().bufferSize();
    return result;
}

void LtbReadout::expanded(const unsigned int size) {
    LtbFoot& footToUse = foot();
    footToUse.setDataLength(footToUse.dataLength() + (size * kBytesInInt));
    notifyExpandable(size);
}

bool LtbReadout::setRomExpandable(DaqExpandable& expandable) {
    return setExpandable(expandable);
}

const LtbFrame& LtbReadout::addFrame(const unsigned int readoutType,
                                     const unsigned int triggerMask,
                                     const LtbTraits::LtbDateTime& dateTime,
                                     const unsigned int halfNanoseconds,
                                     const int accumulation,
                                     const unsigned int hitSum,
                                     const bool totalEsum,
                                     const bool highEsum,
                                     const bool lowEsum,
                                     const unsigned int energySum,
                                     const unsigned int crossTriggerSource,
                                     const bool accumulationStatus,
                                     const bool validGps,
                                     const bool usingUtc,
                                     const bool validClockSystem,
                                     const bool feeBufferFull,
                                     const bool ltbBufferFull,
                                     const unsigned int blockedTriggerCount) {
    LtbFrame* result = new LtbFrame(readoutType,
                                    triggerMask,
                                    dateTime,
                                    halfNanoseconds,
                                    accumulation,
                                    hitSum,
                                    totalEsum,
                                    highEsum,
                                    lowEsum,
                                    energySum,
                                    crossTriggerSource,
                                    accumulationStatus,
                                    validGps,
                                    usingUtc,
                                    validClockSystem,
                                    feeBufferFull,
                                    ltbBufferFull,
                                    blockedTriggerCount,
                                    head().ltbTraits());
    return addFrame(result);
}

const LtbFrame& LtbReadout::addFrame(const LtbFrame* frame) {
    if (0 == m_frames) {
        m_frames = new LtbFramePtrList();
    }
    (const_cast<LtbFrame*>(frame))->setFrameNumber(m_frames->size());
    m_frames->push_back(frame);
    m_head->setRawTriggersSaved(m_frames->size());
    expanded(frame->bufferSize());
    return *frame;
}

LtbFoot& LtbReadout::foot() {
    if (0 == m_foot) {
        m_foot = new LtbFoot(head());
    }
    return *m_foot;
}

---