In This Package:

RtmData.cc

Go to the documentation of this file.

#include "RtmReadoutFormat/RtmData.h"
#include "RtmReadoutFormat/RtmTraits.h"

#include "DaqReadoutFormat/ByteBuffer.h"

using DybDaq::RtmData;

RtmData::RtmData(const unsigned int rpcCFId,
                 const bool transErr,
                 const bool romAlmostFull,
                 const bool rtmAlmostFull,
                 const bool fullFlag,
                 const bool validGPS,
                 const bool validCLK,
                 const bool usingUTC,
                 const unsigned int second,
                 const unsigned int nanoSecond,
                 const unsigned int accumulation,
                 const unsigned int triggerRot,
                 const unsigned int triggerMap,
                 const RtmTraits& traits)
: RtmBuffer(new char[ traits.rtmSize() * kBytesInInt ], traits)
{
   traits.initializeRtm( buffer() );
   setRpcCFId(rpcCFId);
   setTransErr(transErr);
   setRomAlmostFull(romAlmostFull);
   setRtmAlmostFull(rtmAlmostFull);
   setFullFlag(fullFlag);
   setValidGPS(validGPS);
   setValidCLK(validCLK);
   setUsingUTC(usingUTC);
   setSecond(second);
   setNanoSecond(nanoSecond);
   setAccumulation(accumulation);
   setTriggerRot(triggerRot);
   setTriggerMap(triggerMap);
}

RtmData::RtmData(const ByteBuffer& byteBuffer, const RtmTraits& traits)
   : RtmBuffer(byteBuffer, traits)
{
   byteBuffer.position( byteBuffer.position() + rtmTraits().rtmSize() * kBytesInInt );
}

RtmData::~RtmData()
{
}

unsigned int RtmData::formatComponent() const {
    return RtmTraits::kData;
}

unsigned int RtmData::rpcCFId() const {
   return readUnsignedInt(RtmTraits::kRpcCFId);
}

bool RtmData::transErr() const {
   return readBool(RtmTraits::kTransErr);
}

bool RtmData::romAlmostFull() const {
   return readBool(RtmTraits::kRomAlmostFull);
}

bool RtmData::rtmAlmostFull() const {
   return readBool(RtmTraits::kRtmAlmostFull);
}

bool RtmData::fullFlag() const {
   return readBool(RtmTraits::kFullFlag);
}

bool RtmData::validGPS() const {
   return readBool(RtmTraits::kValidGPS);
}

bool RtmData::validCLK() const {
   return readBool(RtmTraits::kValidCLK);
}

bool RtmData::usingUTC() const {
   return readBool(RtmTraits::kUsingUTC);
}

unsigned int RtmData::second() const {
   return readUnsignedInt(RtmTraits::kSecond);
}

unsigned int RtmData::nanoSecond() const {
   return readUnsignedInt(RtmTraits::kNanoSecond);
}

unsigned int RtmData::accumulation() const {
   return readUnsignedInt(RtmTraits::kAccumulation);
}

unsigned int RtmData::triggerRot() const {
   return readUnsignedInt(RtmTraits::kTriggerRot);
}

unsigned int RtmData::triggerMap() const {
   return readUnsignedInt(RtmTraits::kTriggerMap);
}


unsigned int RtmData::bufferSize() const {
   return rtmTraits().rtmSize();
}


void RtmData::setRpcCFId(const unsigned int rpcCFId) {
   writeField( rpcCFId, RtmTraits::kRpcCFId );
}

void RtmData::setTransErr(const bool transErr) {
   writeField( transErr, RtmTraits::kTransErr);
}

void RtmData::setRomAlmostFull(const bool romAlmostFull) {
   writeField( romAlmostFull, RtmTraits::kRomAlmostFull);
}

void RtmData::setRtmAlmostFull(const bool rtmAlmostFull) {
   writeField( rtmAlmostFull, RtmTraits::kRtmAlmostFull);
}

void RtmData::setFullFlag(const bool fullFlag) {
   writeField( fullFlag, RtmTraits::kFullFlag);
}

void RtmData::setValidGPS(const bool validGPS) {
   writeField( validGPS, RtmTraits::kValidGPS);
}

void RtmData::setValidCLK(const bool validCLK) {
   writeField( validCLK, RtmTraits::kValidCLK);
}

void RtmData::setUsingUTC(const bool usingUTC) {
   writeField( usingUTC, RtmTraits::kUsingUTC);
}

void RtmData::setSecond(const unsigned int second) {
   writeField( second, RtmTraits::kSecond);
}

void RtmData::setNanoSecond(const unsigned int nanoSecond) {
   writeField( nanoSecond, RtmTraits::kNanoSecond);
}

void RtmData::setAccumulation(const unsigned int accumulation) {
   writeField( accumulation, RtmTraits::kAccumulation);
}

void RtmData::setTriggerRot(const unsigned int triggerRot) {
   writeField( triggerRot, RtmTraits::kTriggerRot);
}

void RtmData::setTriggerMap(const unsigned int triggerMap) {
   writeField( triggerMap, RtmTraits::kTriggerMap);
}

---