EventHeader.cc

Go to the documentation of this file.

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

#include "DaqReadoutFormat/ByteBuffer.h"
#include "EventReadoutFormat/EventTraits.h"

using DybDaq::ByteBuffer;
using DybDaq::DaqTraits;
using DybDaq::EventHeader;
using DybDaq::EventBuffer;

EventHeader::EventHeader(const unsigned int site,
                         const unsigned int detector,
                         const unsigned int run,
                         const unsigned int event,
                         const unsigned int dataType,
                         const bool cbltWrapping,
                         const bool rawCblt,
                         const bool triggerMismatch,
                         const bool invalidData,
                         const bool rpcSortDisabled,
                         const bool dataSortTimeout,
                         const EventTraits& traits) : 
EventBuffer(new char[traits.headerSize(EventTraits::kEventHeader) * kBytesInInt],
            traits) {
    m_traits = &traits;
    traits.initializeHeader(EventTraits::kEventHeader,
                            buffer());
    setMajorVersion(traits.majorVersion());
    setMinorVersion(traits.minorVersion());
    setHeaderSize(traits.headerSize(EventTraits::kEventHeader)),
    setTotalSize(headerSize());
    setSite(site);
    setDetector(detector);
    setRun(run);
    setEvent(event);
    setDataType(dataType);
    setCbltWrapping(cbltWrapping);
    setRawCblt(rawCblt);
    setTriggerMismatch(triggerMismatch);
    setInvalidData(invalidData);
    setRpcSortDisabled(rpcSortDisabled);
    setDataSortTimeout(dataSortTimeout);
}

EventHeader::EventHeader(const ByteBuffer& byteBuffer) :
EventBuffer(byteBuffer,
            *((EventTraits*)0)) {
    const char* buffer = byteBuffer.cursor();
    m_traits = EventTraits::readTraits(buffer);
        byteBuffer.position(byteBuffer.position() + (headerSize() * kBytesInInt));
}

EventHeader::~EventHeader() {
}

const DaqTraits& EventHeader::daqTraits() const {
        return *m_traits;
}

unsigned int EventHeader::formatComponent() const {
    return EventTraits::kEventHeader;
}

unsigned int EventHeader::majorVersion() const {
        return readUnsignedInt(EventTraits::kMajorVersion);
}

unsigned int EventHeader::minorVersion() const {
        return readUnsignedInt(EventTraits::kMinorVersion);
}

unsigned int EventHeader::headerSize() const {
        return readUnsignedInt(EventTraits::kEventHeaderSize);
}

unsigned int EventHeader::totalSize() const {
        return readUnsignedInt(EventTraits::kEventTotalSize);
}

unsigned int EventHeader::site() const {
        return readUnsignedInt(EventTraits::kEventSite);
}

unsigned int EventHeader::detector() const {
        return readUnsignedInt(EventTraits::kEventDetector);
}

unsigned int EventHeader::run() const {
        return readUnsignedInt(EventTraits::kEventRun);
}

unsigned int EventHeader::event() const {
        return readUnsignedInt(EventTraits::kEventNumber);
}

unsigned int EventHeader::dataType() const {
        return readUnsignedInt(EventTraits::kEventDataType);
}

bool EventHeader::rpcSortDisabled() const {
        return readBool(EventTraits::kRpcSortDisabled);
}

bool EventHeader::cbltWrapping() const {
        return readBool(EventTraits::kCbltWrapping);
}

bool EventHeader::rawCblt() const {
        return readBool(EventTraits::kRawCblt);
}

bool EventHeader::dataSortTimeout() const{
        return readBool(EventTraits::kDataSortTimeout);
}

bool EventHeader::triggerMismatch() const{
        return readBool(EventTraits::kLtbMismatch);
}

bool EventHeader::invalidData() const{
        return readBool(EventTraits::kInvalidData);
}

unsigned int EventHeader::bufferSize() const {
    return headerSize();
}

void EventHeader::setMajorVersion(const unsigned int majorVersion) {
    writeField(majorVersion,
               EventTraits::kMajorVersion);
}

void EventHeader::setMinorVersion(const unsigned int minorVersion) {
    writeField(minorVersion,
               EventTraits::kMinorVersion);
}

void EventHeader::setHeaderSize(const unsigned int headerLength) {
    writeField(headerLength,
               EventTraits::kEventHeaderSize);
}

void EventHeader::setTotalSize(const unsigned int totalLength) {
    writeField(totalLength,
               EventTraits::kEventTotalSize);
}

void EventHeader::setSite(const unsigned int site) {
    writeField(site,
               EventTraits::kEventSite);
}

void EventHeader::setDetector(const unsigned int detector) {
    writeField(detector,
               EventTraits::kEventDetector);
}

void EventHeader::setRun(const unsigned int run) {
    writeField(run,
               EventTraits::kEventRun);
}

void EventHeader::setEvent(const unsigned int event) {
    writeField(event,
               EventTraits::kEventNumber);
}

void EventHeader::setDataType(const unsigned int dataType) {
    writeField(dataType,
               EventTraits::kEventDataType);
}

void EventHeader::setRpcSortDisabled(const bool disabled) {
  writeField(disabled,
             EventTraits::kRpcSortDisabled);
}

void EventHeader::setCbltWrapping(const bool cbltWrapping) {
    writeField(cbltWrapping,
               EventTraits::kCbltWrapping);
}

void EventHeader::setRawCblt(const bool rawCblt) {
    writeField(rawCblt,
               EventTraits::kRawCblt);
}

void EventHeader::setDataSortTimeout(bool timedOut) {
    writeField(timedOut,
               EventTraits::kDataSortTimeout);
}

void EventHeader::setTriggerMismatch(const bool triggerMismatch) {
    writeField(triggerMismatch,
               EventTraits::kLtbMismatch);
}

void EventHeader::setInvalidData(const bool invalidData) {
    writeField(invalidData,
               EventTraits::kInvalidData);
}