LtbFrame.cc

Go to the documentation of this file.

/*
 *  LtbFrame.cc
 *  LtbReadoutFormat
 *
 *  Created by Simon Patton on 7/21/10.
 *  Copyright 2010 DayaBay Collaboration. All rights reserved.
 *
 */
#include <cstring>
#include "LtbReadoutFormat/LtbFrame.h"

#include "DaqReadoutFormat/ByteBuffer.h"
#include "LtbReadoutFormat/LtbTime.h"
#include "LtbReadoutFormat/LtbTraits.h"

using DybDaq::ByteBuffer;
using DybDaq::LtbBuffer;
using DybDaq::LtbFrame;
using DybDaq::LtbTime;
using DybDaq::LtbTraits;

LtbFrame::LtbFrame(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,
                   const LtbTraits& traits) :
LtbBuffer(new char[traits.frameSize() * kBytesInInt],
          traits),
m_time(0) {
    traits.initializeFrame(buffer());
    setFrameNumber(0);
    setReadoutType(readoutType);
    setTriggerMask(triggerMask);
    m_time = new LtbTime(dateTime,
                         halfNanoseconds,
                         accumulation,
                         traits);
    setHitSum(hitSum);
    setTotalEsum(totalEsum);
    setHighEsum(highEsum);
    setLowEsum(lowEsum);
    setEnergySum(energySum);
    setCrossTriggerSource(crossTriggerSource);
    setAccumulationStatus(accumulationStatus);
    setValidGps(validGps);
    setUsingUtc(usingUtc);
    setValidClockSystem(validClockSystem);
    setFeeBufferFull(feeBufferFull);
    setLtbBufferFull(ltbBufferFull);
    setBlockedTriggerCount(blockedTriggerCount);
}


LtbFrame::LtbFrame(const ByteBuffer& byteBuffer,
                   const LtbTraits& traits) :
LtbBuffer(byteBuffer,
          traits),
m_time(0) {
    const unsigned int position = byteBuffer.position();
        byteBuffer.position(position + (ltbTraits().timeOffset() * kBytesInInt));
    m_time = new LtbTime(byteBuffer,
                         traits);
        byteBuffer.position(position + (ltbTraits().frameSize() * kBytesInInt));
}

LtbFrame::~LtbFrame() {
    if (0 != m_time) {
        delete m_time;
    }
}

unsigned int LtbFrame::frameNumber() const {
        return readUnsignedInt(LtbTraits::kFrameNumber);
}

unsigned int LtbFrame::readoutType() const {
        return readUnsignedInt(LtbTraits::kReadoutType);
}

unsigned int LtbFrame::triggerMask() const {
        return readUnsignedInt(LtbTraits::kTriggerMask);
}

bool LtbFrame::isTriggerLineSet(const unsigned int line) const {
    return 0 != (triggerMask() & ltbTraits().triggerLineBit(line));
}

const LtbTraits::LtbDateTime& LtbFrame::dateTime() const {
    return *m_time;
}

unsigned int LtbFrame::ticks() const {
    return m_time->ticks();
}

unsigned int LtbFrame::halfNanoseconds() const {
    return m_time->halfNanoseconds();
}

int LtbFrame::accumulation() const {
    return m_time->accumulation();
}

unsigned int LtbFrame::hitSum() const {
        return readUnsignedInt(LtbTraits::kHitSum);
}

bool LtbFrame::totalEsum() const {
        return readBool(LtbTraits::kTotalEsum);
}

bool LtbFrame::highEsum() const {
        return readBool(LtbTraits::kHighEsum);
}

bool LtbFrame::lowEsum() const {
        return readBool(LtbTraits::kLowEsum);
}

unsigned int LtbFrame::energySum() const {
        return readUnsignedInt(LtbTraits::kEnergySum);
}

unsigned int LtbFrame::crossTriggerSource() const {
    if (4 > ltbTraits().majorVersion() || (4 == ltbTraits().majorVersion() && 6 > ltbTraits().minorVersion())) {
        return readUnsignedInt(LtbTraits::kCrossTriggerSource);
    }
    const unsigned int highCrossTrigger = readUnsignedInt(LtbTraits::kHighCrossTrigger);
    const unsigned int lowCrossTrigger = readUnsignedInt(LtbTraits::kLowCrossTrigger);
    return (highCrossTrigger << 16U) | lowCrossTrigger;
}

bool LtbFrame::accumulationStatus() const {
        return readBool(LtbTraits::kAccumulationStatus);
}

bool LtbFrame::validGps() const {
        return readBool(LtbTraits::kValidGps);
}

bool LtbFrame::usingUtc() const {
        return readBool(LtbTraits::kUsingUtc);
}

bool LtbFrame::validClockSystem() const {
        return readBool(LtbTraits::kValidClockSystem);
}

bool LtbFrame::feeBufferFull() const {
        return readBool(LtbTraits::kFeeBufferFull);
}

bool LtbFrame::ltbBufferFull() const {
        return readBool(LtbTraits::kLtbBufferFull);
}

unsigned int LtbFrame::blockedTriggerCount() const {
        return readUnsignedInt(LtbTraits::kBlockedTriggerCount);
}

unsigned int LtbFrame::gather(OutputBufferList& outputBuffers) const {
    if (!hasByteBuffer()) {
        const LtbTraits& traits = ltbTraits();
        memcpy(const_cast<char*>(buffer()) + (traits.timeOffset() * kBytesInInt),
               m_time->buffer(),
               traits.timeSize() * kBytesInInt);
    }
    return LtbBuffer::gather(outputBuffers);
}


unsigned int LtbFrame::inspect(DaqBuffer::Bytes& inspectors) const {
    unsigned int cursor = fillInspectors(inspectors,
                                         LtbTraits::kFrameFront,
                                         0);
    cursor += m_time->inspect(inspectors);
    cursor = fillInspectors(inspectors,
                          LtbTraits::kFrameBack,
                          cursor + 1);
    return cursor + 1;
}


unsigned int LtbFrame::bufferSize() const {
    return ltbTraits().frameSize();
}

void LtbFrame::setFrameNumber(const unsigned int frameNumber) {
    writeField(frameNumber,
               LtbTraits::kFrameNumber);
}

void LtbFrame::setReadoutType(const unsigned int readoutType) {
    writeField(readoutType,
               LtbTraits::kReadoutType);
}

void LtbFrame::setTriggerMask(const unsigned int triggerMask) {
    writeField(triggerMask,
               LtbTraits::kTriggerMask);
}

void LtbFrame::setTriggerLine(const unsigned int line) {
    writeField((triggerMask() | ltbTraits().triggerLineBit(line)),
               LtbTraits::kTriggerMask);
}

void LtbFrame::setDateTime(const LtbTraits::LtbDateTime& dateTime) {
    m_time->setDateTime(dateTime);
}

void LtbFrame::setHalfNanoseconds(const unsigned int halfNanoseconds) {
    m_time->setHalfNanoseconds(halfNanoseconds);
}

void LtbFrame::setAccumulation(const int accumulation) {
    m_time->setAccumulation(accumulation);
}

void LtbFrame::setHitSum(const unsigned int hitSum) {
    writeField(hitSum,
               LtbTraits::kHitSum);
}

void LtbFrame::setTotalEsum(const bool totalEsum) {
    writeField(totalEsum,
               LtbTraits::kTotalEsum);
}

void LtbFrame::setHighEsum(const bool highEsum) {
    writeField(highEsum,
               LtbTraits::kHighEsum);
}

void LtbFrame::setLowEsum(const bool lowEsum) {
    writeField(lowEsum,
               LtbTraits::kLowEsum);
}

void LtbFrame::setEnergySum(const unsigned int energySum) {
    writeField(energySum,
               LtbTraits::kEnergySum);
}

void LtbFrame::setCrossTriggerSource(const unsigned int crossTriggerSource) {
    if (4 > ltbTraits().majorVersion() || (4 == ltbTraits().majorVersion() && 6 > ltbTraits().minorVersion())) {
        writeField(crossTriggerSource,
                   LtbTraits::kCrossTriggerSource);
    }
    writeField((crossTriggerSource >> 16U) & 0x0000ffffU,
               LtbTraits::kHighCrossTrigger);
    writeField(crossTriggerSource & 0x0000ffffU,
               LtbTraits::kLowCrossTrigger);
}

void LtbFrame::setAccumulationStatus(const bool accumulationStatus) {
    writeField(accumulationStatus,
               LtbTraits::kAccumulationStatus);
}

void LtbFrame::setValidGps(const bool validGps) {
    writeField(validGps,
               LtbTraits::kValidGps);
}

void LtbFrame::setUsingUtc(const bool usingUtc) {
    writeField(usingUtc,
               LtbTraits::kUsingUtc);
}

void LtbFrame::setValidClockSystem(const bool validClockSystem) {
    writeField(validClockSystem,
               LtbTraits::kValidClockSystem);
}

void LtbFrame::setFeeBufferFull(const bool feeBufferFull) {
    writeField(feeBufferFull,
               LtbTraits::kFeeBufferFull);
}

void LtbFrame::setLtbBufferFull(const bool ltbBufferFull) {
    writeField(ltbBufferFull,
               LtbTraits::kLtbBufferFull);
}

void LtbFrame::setBlockedTriggerCount(const unsigned int blockedTriggerCount) {
    writeField(blockedTriggerCount,
               LtbTraits::kBlockedTriggerCount);
}