In This Package:

RomFragment.cc

Go to the documentation of this file.

/*
 *  RomFragment.cc
 *  RawFileReading
 *
 *  Created by Simon Patton on 7/20/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include "EventReadoutFormat/RomFragment.h"

#include "CbltReadoutFormat/CbltBody.h"
#include "CbltReadoutFormat/CbltReadout.h"
#include "DaqReadoutFormat/ByteBuffer.h"
#include "DaqReadoutFormat/RomData.h"
#include "FadcReadoutFormat/FadcReadout.h"
#include "FeeReadoutFormat/FeeReadout.h"
#include "LtbReadoutFormat/LtbReadout.h"
#include "FecReadoutFormat/FecReadout.h"
#include "RtmReadoutFormat/RtmReadout.h"
#include "EventReadoutFormat/EventTraits.h"
#include "EventReadoutFormat/RomHeader.h"

using DybDaq::ByteBuffer;
using DybDaq::CbltBody;
using DybDaq::CbltReadout;
using DybDaq::DaqBuffer;
using DybDaq::EventTraits;
using DybDaq::FadcReadout;
using DybDaq::FeeReadout;
using DybDaq::LtbReadout;
using DybDaq::RomData;
using DybDaq::RomFragment;
using DybDaq::RomHeader;

RomFragment::RomFragment(const unsigned int site,
                         const unsigned int detector,
                         const unsigned int moduleType,
                         const unsigned int slot,
                         const RomData* data,
                         const EventTraits& traits,
                         const bool cbltWrapping,
                         DaqExpandable& expandable) :
DaqContainer(expandable),
m_header(new RomHeader(site,
                       detector,
                       moduleType,
                       slot,
                       traits)),
m_data(data),
m_cbltWrapping(cbltWrapping) {
    expandedByRomData(data);
    m_header->setTotalSize(m_header->headerSize() + data->romSize());
}


RomFragment::RomFragment(const ByteBuffer& byteBuffer,
                         const EventTraits& traits,
                         const bool cbltWrapping) :
DaqContainer(byteBuffer,
             traits,
             0),
m_header(0),
m_data(0),
m_cbltWrapping(cbltWrapping) {
    byteBuffer.position(byteBuffer.position() + (header().totalSize() * kBytesInInt));
}

RomFragment::~RomFragment() {
    if (0 != m_data) {
        delete m_data;
    }
    if (0 != m_header) {
        delete m_header;
    }
}

const RomHeader& RomFragment::header() const {
    if (0 == m_header && hasByteBuffer()) {
        const ByteBuffer& buffer = byteBuffer();
        const unsigned int originalPosition = buffer.position();
        buffer.position(begin());
        m_header = new RomHeader(buffer,
                                 dynamic_cast<const EventTraits&>(daqTraits()));
        buffer.position(originalPosition);
    }
    return *m_header;
}

const RomData& RomFragment::data() const {
    if (0 == m_data && hasByteBuffer()) {
        const ByteBuffer& buffer = byteBuffer();
        const unsigned int originalPosition = buffer.position();
        const RomHeader& romHeader = header();
        const unsigned int headerSize = romHeader.headerSize();
        buffer.position(begin() + (headerSize * kBytesInInt));
        unsigned dataSize = romHeader.totalSize() - headerSize;
        // Check whether data contains CBLT wrappings
        static const unsigned int cbltMask = 0xf0000000U;
        static const unsigned int cbltValue = 0x20000000U;
        const unsigned int peek = *((unsigned int*)(buffer.cursor()));
        //
        if (m_cbltWrapping || (cbltValue == (peek & cbltMask))) {
            m_data = new CbltReadout(buffer,
                                     dataSize);
            
        } else {
            const EventTraits& traits = romHeader.eventTraits();
            const unsigned int moduleType = romHeader.moduleType();
            if (moduleType == traits.moduleType(EventTraits::kFadcModule)) {
                m_data = new FadcReadout(buffer,
                                         dataSize);
            } else if (moduleType == traits.moduleType(EventTraits::kFeeModule)) {
                m_data = new FeeReadout(buffer,
                                        dataSize);
            } else if (moduleType == traits.moduleType(EventTraits::kLtbModule)) {
                m_data = new LtbReadout(buffer,
                                        dataSize);
            }
            else if (moduleType == traits.moduleType(EventTraits::kRpcRomModule)) {
               m_data = new FecReadout(buffer, dataSize);
            }
            else if (moduleType == traits.moduleType(EventTraits::kRpcRtmModule)) {
               m_data = new RtmReadout(buffer, dataSize);
            }
        }
        buffer.position(originalPosition);
    }
    return *m_data;
}

const RomData& RomFragment::unwrappedData() const {
    // Make sure m_data is filled
    data();
    const CbltReadout* cbltReadout = dynamic_cast<const CbltReadout*> (m_data);
    if (0 == cbltReadout) {
        return *m_data;
    }
    return cbltReadout->body().data();
}


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

unsigned int RomFragment::gatherComponents(DaqBuffer::OutputBufferList& outputBuffers) const {
    unsigned int result = header().gather(outputBuffers);
    
    result += data().gatherRom(outputBuffers);
    return result;
}

unsigned int RomFragment::inspectComponents(DaqBuffer::Bytes& inspectors) const {
    unsigned int result = header().inspect(inspectors);
    
    result += data().inspectRom(inspectors);
    return result;
}

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

---