In This Package:

FadcReadout.cc

Go to the documentation of this file.

/*
 *  FadcReadout.cc
 *  FadcReadoutFormat
 *
 *  Created by Simon Patton on 9/2/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "FadcReadoutFormat/FadcReadout.h"

#include "DaqReadoutFormat/ByteBuffer.h"
#include "FadcReadoutFormat/FadcFoot.h"
#include "FadcReadoutFormat/FadcHead.h"
#include "FadcReadoutFormat/FadcData.h"
#include "FadcReadoutFormat/FadcTraits.h"

using DybDaq::DaqBuffer;
using DybDaq::DaqContainer;
using DybDaq::DaqTraits;
using DybDaq::FadcFoot;
using DybDaq::FadcHead;
using DybDaq::FadcData;
using DybDaq::FadcReadout;

FadcReadout::FadcReadout(const unsigned int triggerNumber,
                         const unsigned int triggerType,
                         const bool noData,
                         const FadcTraits& traits) :
    DaqContainer(),
    m_head(new FadcHead(triggerNumber,
                        triggerType,
                        noData,
                        traits)),
    m_data(0),
    m_foot(0) {
}

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

FadcReadout::~FadcReadout() {
    if (0 != m_foot) {
        delete m_foot;
    }
    if (0 != m_data) {
        FadcDataPtrList::const_iterator data;
        for (data = m_data->begin();
             data != m_data->end();
             ++data) {
            delete const_cast<FadcData*>(*data);
        }
        delete m_data;
    }
    if (0 != m_head) {
        delete m_head;
    }
}

const DaqTraits& FadcReadout::daqTraits() const {
    return head().fadcTraits();
}

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

const FadcReadout::FadcDataPtrList& FadcReadout::fadcData() const {
    if (0 == m_data) {
        m_data = new FadcDataPtrList();
        if (hasByteBuffer()) {
            const FadcTraits& traits = head().fadcTraits();
            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.dataSize();
            for (unsigned int count = 0;
                 count != finished;
                 ++count) {
                FadcData* data = new FadcData(buffer,
                                              traits);
                m_data->push_back(data);
            }
            buffer.position(originalPosition);
        }
    }
    return *m_data;
}

const FadcFoot& FadcReadout::foot() const {
    if (0 == m_foot) {
        if (hasByteBuffer()) {
            const FadcTraits& traits = head().fadcTraits();
            const ByteBuffer& buffer = byteBuffer();
            
            const unsigned int originalPosition = buffer.position();
            buffer.position(begin() + ((containerSize() - traits.footSize()) * kBytesInInt));
            m_foot = new FadcFoot(buffer,
                                  head().fadcTraits());
            buffer.position(originalPosition);
        } else {
            m_foot = new FadcFoot(head());
        }
    }
    return *m_foot;
}

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

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

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

unsigned int FadcReadout::gatherComponents(OutputBufferList& outputBuffers) const {
    unsigned int result = head().gather(outputBuffers);
    const FadcDataPtrList& data = fadcData();
    FadcDataPtrList::const_iterator entry;
    for (entry = data.begin();
         entry != data.end();
         ++entry) {
        result += (*entry)->gather(outputBuffers);
    }
    
    result += foot().gather(outputBuffers);
    return result;
}

unsigned int FadcReadout::inspectComponents(DaqBuffer::Bytes& inspectors) const {
    unsigned int result = head().inspect(inspectors);
    const FadcDataPtrList& data = fadcData();
    FadcDataPtrList::const_iterator entry;
    for (entry = data.begin();
         entry != data.end();
         ++entry) {
        result += (*entry)->inspect(inspectors);
    }
    
    result += foot().inspect(inspectors);
    return result;
}

unsigned int FadcReadout::bufferSize() const {
    unsigned int result = head().bufferSize();
    const FadcDataPtrList& data = fadcData();
    FadcDataPtrList::const_iterator entry;
    for (entry = data.begin();
         entry != data.end();
         ++entry) {
        result += (*entry)->bufferSize();
    }
    result += foot().bufferSize();
    return result;
}

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

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

const FadcData& FadcReadout::addData(const unsigned int channel,
                                     const unsigned int highDataByte,
                                     const unsigned int middleDataByte,
                                     const unsigned int lowDataByte) {
    const FadcTraits& traits = head().fadcTraits();
    FadcData* result = new FadcData(channel,
                                    highDataByte,
                                    middleDataByte,
                                    lowDataByte,
                                    traits);
    return add(result);
}

const FadcData& FadcReadout::add(const FadcData* data) {
    if (0 == m_data) {
        m_data = new FadcDataPtrList();
    }
    m_data->push_back(data);
    expanded(data->bufferSize());
    return *data;
}

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

---