In This Package:

FecData.cc

Go to the documentation of this file.

#include "FecReadoutFormat/FecData.h"
#include "FecReadoutFormat/FecTraits.h"

#include "DaqReadoutFormat/ByteBuffer.h"

using DybDaq::FecData;

FecData::FecData(const unsigned int rpcCFId,
                 const unsigned int rpcFecId,
                 const bool transErr1,
                 const bool transErr2,
                 const unsigned int trigType,
                 const bool fullFlag,
                 const bool validGPS,
                 const bool validCLK,
                 const bool usingUTC,
                 const unsigned int second,
                 const unsigned int nanoSecond,
                 const unsigned int hitMap,
                 const FecTraits& traits)
: FecBuffer(new char[ traits.fecSize() * kBytesInInt ], traits)
{
   traits.initializeFec( buffer() );
   setRpcCFId(rpcCFId);
   setRpcFecId(rpcFecId);
   setTransErr1(transErr1);
   setTransErr2(transErr2);
   setTrigType(trigType);
   setFullFlag(fullFlag);
   setValidGPS(validGPS);
   setValidCLK(validCLK);
   setUsingUTC(usingUTC);
   setSecond(second);
   setNanoSecond(nanoSecond);
   setHitMap(hitMap);
}

FecData::FecData(const ByteBuffer& byteBuffer, const FecTraits& traits)
   : FecBuffer(byteBuffer, traits)
{
   byteBuffer.position( byteBuffer.position() + fecTraits().fecSize() * kBytesInInt );
}

FecData::~FecData()
{
}

unsigned int FecData::formatComponent() const {
    return FecTraits::kData;
}

unsigned int FecData::rpcCFId() const {
   return readUnsignedInt(FecTraits::kRpcCFId);
}

unsigned int FecData::rpcFecId() const {
   return readUnsignedInt(FecTraits::kRpcFecId);
}

bool FecData::transErr1() const {
   return readBool(FecTraits::kTransErr1);
}

bool FecData::transErr2() const {
   return readBool(FecTraits::kTransErr2);
}

unsigned int FecData::trigType() const {
   return readUnsignedInt(FecTraits::kTrigType);
}

bool FecData::fullFlag() const {
   return readBool(FecTraits::kFullFlag);
}

bool FecData::validGPS() const {
   return readBool(FecTraits::kValidGPS);
}

bool FecData::validCLK() const {
   return readBool(FecTraits::kValidCLK);
}

bool FecData::usingUTC() const {
   return readBool(FecTraits::kUsingUTC);
}

unsigned int FecData::second() const {
   return readUnsignedInt(FecTraits::kSecond);
}

unsigned int FecData::nanoSecond() const {
   return readUnsignedInt(FecTraits::kNanoSecond);
}

unsigned int FecData::hitMap() const {
   return readUnsignedInt(FecTraits::kFecHitMap);
}

unsigned int FecData::bufferSize() const {
   return fecTraits().fecSize();
}

void FecData::setRpcCFId(const unsigned int rpcCFId) {
   writeField( rpcCFId, FecTraits::kRpcCFId );
}

void FecData::setRpcFecId(const unsigned int rpcFecId) {
   writeField( rpcFecId, FecTraits::kRpcFecId );
}

void FecData::setTransErr1(const bool transErr1) {
   writeField( transErr1, FecTraits::kTransErr1);
}

void FecData::setTransErr2(const bool transErr2) {
   writeField( transErr2, FecTraits::kTransErr2);
}

void FecData::setTrigType(const unsigned int trigType) {
   writeField( trigType, FecTraits::kTrigType);
}

void FecData::setFullFlag(const bool fullFlag) {
   writeField( fullFlag, FecTraits::kFullFlag);
}

void FecData::setValidGPS(const bool validGPS) {
   writeField( validGPS, FecTraits::kValidGPS);
}

void FecData::setValidCLK(const bool validCLK) {
   writeField( validCLK, FecTraits::kValidCLK);
}

void FecData::setUsingUTC(const bool usingUTC) {
   writeField( usingUTC, FecTraits::kUsingUTC);
}

void FecData::setSecond(const unsigned int second) {
   writeField( second, FecTraits::kSecond);
}

void FecData::setNanoSecond(const unsigned int nanoSecond) {
   writeField( nanoSecond, FecTraits::kNanoSecond);
}

void FecData::setHitMap(const unsigned int hitMap) {
   writeField( hitMap, FecTraits::kFecHitMap);
}

---