#include <Phase2TrackerFEDBuffer.h>

Public Member Functions
size_t	bufferSize () const

const Phase2TrackerFEDChannel &	channel (const uint8_t internalPhase2TrackerFEDChannelNum) const

bool	checkNoFEOverflows () const

std::map< uint32_t, uint32_t >	conditionData () const

uint16_t	daqBXID () const

uint16_t	daqCRC () const

uint32_t	daqEventLengthIn64bitWords () const

uint32_t	daqEventLengthInBytes () const

FEDDAQEventType	daqEventType () const

FEDDAQHeader	daqHeader () const

uint32_t	daqLvl1ID () const

uint16_t	daqSourceID () const

FEDDAQTrailer	daqTrailer () const

FEDTTSBits	daqTTSState () const

bool	doChecks () const

bool	doCorruptBufferChecks () const

void	dump (std::ostream &os) const

const uint8_t *	getPointerToCondData () const

const uint8_t *	getPointerToPayload () const

const uint8_t *	getPointerToTriggerData () const

	Phase2TrackerFEDBuffer (const uint8_t *fedBuffer, const size_t fedBufferSize)

FEDReadoutMode	readoutMode () const

Phase2TrackerFEDHeader	trackerHeader () const

	~Phase2TrackerFEDBuffer ()

Private Member Functions
void	findChannels ()

Private Attributes
const uint8_t *	buffer_

const size_t	bufferSize_

std::vector< Phase2TrackerFEDChannel >	channels_

const uint8_t *	condDataPointer_

FEDDAQHeader	daqHeader_

FEDDAQTrailer	daqTrailer_

const uint8_t *	payloadPointer_

Phase2TrackerFEDHeader	trackerHeader_

const uint8_t *	triggerPointer_

Detailed Description

Definition at line 14 of file Phase2TrackerFEDBuffer.h.

Constructor & Destructor Documentation

◆ Phase2TrackerFEDBuffer()

Phase2Tracker::Phase2TrackerFEDBuffer::Phase2TrackerFEDBuffer	(	const uint8_t *	fedBuffer,
		const size_t	fedBufferSize
	)

Definition at line 9 of file Phase2TrackerFEDBuffer.cc.

       : buffer_(fedBuffer), bufferSize_(fedBufferSize) {
     LogTrace("Phase2TrackerFEDBuffer") << "content of buffer with size: " << int(fedBufferSize) << std::endl;
     for (size_t i = 0; i < fedBufferSize; i += 8) {
       uint64_t word = read64(i, buffer_);
       LogTrace("Phase2TrackerFEDBuffer") << " word " << std::setfill(' ') << std::setw(2) << i / 8 << " | " << std::hex
                                          << std::setw(16) << std::setfill('0') << word << std::dec << std::endl;
     }
     LogTrace("Phase2TrackerFEDBuffer") << std::endl;
  
     // reserve all channels (should be 16x16 in our case)
     channels_.reserve(MAX_FE_PER_FED * MAX_CBC_PER_FE);
     // first 64 bits word is for DAQ header
     daqHeader_ = FEDDAQHeader(buffer_);
     // last 64 bit word is daq trailer
     daqTrailer_ = FEDDAQTrailer(buffer_ + bufferSize_ - 8);
     // tracker header follows daq header
     trackerHeader_ = Phase2TrackerFEDHeader(buffer_ + 8);
     // get pointer to payload
     payloadPointer_ = getPointerToPayload();
     // fill list of Phase2TrackerFEDChannels and get pointers to trigger and comissioning data
     findChannels();
   }

References buffer_, bufferSize_, channels_, daqHeader_, daqTrailer_, TauDecayModes::dec, findChannels(), getPointerToPayload(), mps_fire::i, createfilelist::int, LogTrace, Phase2Tracker::MAX_CBC_PER_FE, Phase2Tracker::MAX_FE_PER_FED, payloadPointer_, Phase2Tracker::read64(), and trackerHeader_.

◆ ~Phase2TrackerFEDBuffer()

Phase2Tracker::Phase2TrackerFEDBuffer::~Phase2TrackerFEDBuffer ( )

Definition at line 33 of file Phase2TrackerFEDBuffer.cc.

33 {}

Member Function Documentation

◆ bufferSize()

size_t Phase2Tracker::Phase2TrackerFEDBuffer::bufferSize ( ) const

inline

Definition at line 26 of file Phase2TrackerFEDBuffer.h.

26 { return bufferSize_; }

References bufferSize_.

◆ channel()

const Phase2TrackerFEDChannel& Phase2Tracker::Phase2TrackerFEDBuffer::channel ( const uint8_t internalPhase2TrackerFEDChannelNum ) const

inline

Definition at line 28 of file Phase2TrackerFEDBuffer.h.

                                                                                                    {
       return channels_[internalPhase2TrackerFEDChannelNum];
     }

References channels_.

◆ checkNoFEOverflows()

bool Phase2Tracker::Phase2TrackerFEDBuffer::checkNoFEOverflows ( ) const

inline

Definition at line 67 of file Phase2TrackerFEDBuffer.h.

67 { return true; } // FEDBufferBase

◆ conditionData()

std::map< uint32_t, uint32_t > Phase2Tracker::Phase2TrackerFEDBuffer::conditionData ( ) const

Definition at line 140 of file Phase2TrackerFEDBuffer.cc.

                                                                          {
     std::map<uint32_t, uint32_t> cdata;
     // check if there is condition data
     if (condDataPointer_) {
       const uint8_t* pointer = condDataPointer_;
       const uint8_t* stop = buffer_ + bufferSize_ - 8;
       // first read the size
       uint32_t size = 0;
       // somehow the size is not inverted
       //for (int i=0;i<4;++i) size += *(pointer-4+(i^7)) << (i*8);
       size = *reinterpret_cast<const uint32_t*>(pointer);
       LogTrace("Phase2TrackerFEDBuffer") << "Condition Data size = " << size << std::endl;
       pointer += 8;
       // now the conditions
       while (pointer < stop) {
         // somehow the data is not inverted
         uint32_t data = 0;
         //for (int i = 0, j=3 ; i<4; i++,j--)
         //{ data += (*(pointer+i) << j*8); }
         data = *reinterpret_cast<const uint32_t*>(pointer);
         pointer += 4;
  
         uint32_t key = 0;
         for (int i = 0, j = 3; i < 4; i++, j--) {
           key += (*(pointer + i) << j * 8);
         }
         pointer += 4;
  
         cdata[key] = data;
       }
       // final check: cdata size == size
       if (cdata.size() != size) {
         std::ostringstream ss;
         ss << "[Phase2Tracker::Phase2TrackerFEDBuffer::" << __func__ << "] "
            << "\n";
         ss << "Number of condition data does not match the announced value!"
            << "\n";
         ss << "Expected condition data Size " << size << " entries"
            << "\n";
         ss << "Computed condition data Size " << cdata.size() << " entries"
            << "\n";
         throw cms::Exception("Phase2TrackerFEDBuffer") << ss.str();
       }
     }
     // REMOVE THIS : inject fake cond data for tests
     /*
       cdata[0x0011] = 0x0001;
       cdata[0x0012] = 0x0002;
       */
     // add trigger data
     cdata[0x0B0000FF] = (TRIGGER_SIZE > 0) ? (*triggerPointer_) : 0x00000000;
     return cdata;
   }

References buffer_, bufferSize_, condDataPointer_, data, Exception, mps_fire::i, dqmiolumiharvest::j, crabWrapper::key, LogTrace, findQualityFiles::size, contentValuesCheck::ss, Phase2Tracker::TRIGGER_SIZE, and triggerPointer_.

◆ daqBXID()

uint16_t Phase2Tracker::Phase2TrackerFEDBuffer::daqBXID ( ) const

inline

Definition at line 36 of file Phase2TrackerFEDBuffer.h.

36 { return daqHeader_.bxID(); }

References Phase2Tracker::FEDDAQHeader::bxID(), and daqHeader_.

◆ daqCRC()

uint16_t Phase2Tracker::Phase2TrackerFEDBuffer::daqCRC ( ) const

inline

Definition at line 42 of file Phase2TrackerFEDBuffer.h.

42 { return daqTrailer_.crc(); }

References Phase2Tracker::FEDDAQTrailer::crc(), and daqTrailer_.

◆ daqEventLengthIn64bitWords()

uint32_t Phase2Tracker::Phase2TrackerFEDBuffer::daqEventLengthIn64bitWords ( ) const

inline

Definition at line 40 of file Phase2TrackerFEDBuffer.h.

40 { return daqTrailer_.eventLengthIn64BitWords(); }

References daqTrailer_, and Phase2Tracker::FEDDAQTrailer::eventLengthIn64BitWords().

◆ daqEventLengthInBytes()

uint32_t Phase2Tracker::Phase2TrackerFEDBuffer::daqEventLengthInBytes ( ) const

inline

Definition at line 41 of file Phase2TrackerFEDBuffer.h.

41 { return daqTrailer_.eventLengthInBytes(); }

References daqTrailer_, and Phase2Tracker::FEDDAQTrailer::eventLengthInBytes().

◆ daqEventType()

FEDDAQEventType Phase2Tracker::Phase2TrackerFEDBuffer::daqEventType ( ) const

inline

Definition at line 34 of file Phase2TrackerFEDBuffer.h.

34 { return daqHeader_.eventType(); }

References daqHeader_, and Phase2Tracker::FEDDAQHeader::eventType().

◆ daqHeader()

FEDDAQHeader Phase2Tracker::Phase2TrackerFEDBuffer::daqHeader ( ) const

inline

Definition at line 24 of file Phase2TrackerFEDBuffer.h.

24 { return daqHeader_; }

References daqHeader_.

◆ daqLvl1ID()

uint32_t Phase2Tracker::Phase2TrackerFEDBuffer::daqLvl1ID ( ) const

inline

Definition at line 35 of file Phase2TrackerFEDBuffer.h.

35 { return daqHeader_.l1ID(); }

References daqHeader_, and Phase2Tracker::FEDDAQHeader::l1ID().

◆ daqSourceID()

uint16_t Phase2Tracker::Phase2TrackerFEDBuffer::daqSourceID ( ) const

inline

Definition at line 37 of file Phase2TrackerFEDBuffer.h.

37 { return daqHeader_.sourceID(); }

References daqHeader_, and Phase2Tracker::FEDDAQHeader::sourceID().

◆ daqTrailer()

FEDDAQTrailer Phase2Tracker::Phase2TrackerFEDBuffer::daqTrailer ( ) const

inline

Definition at line 25 of file Phase2TrackerFEDBuffer.h.

25 { return daqTrailer_; }

References daqTrailer_.

◆ daqTTSState()

FEDTTSBits Phase2Tracker::Phase2TrackerFEDBuffer::daqTTSState ( ) const

inline

Definition at line 43 of file Phase2TrackerFEDBuffer.h.

43 { return daqTrailer_.ttsBits(); }

References daqTrailer_, and Phase2Tracker::FEDDAQTrailer::ttsBits().

◆ doChecks()

bool Phase2Tracker::Phase2TrackerFEDBuffer::doChecks ( ) const

inline

Definition at line 66 of file Phase2TrackerFEDBuffer.h.

66 { return true; } // FEDBuffer

◆ doCorruptBufferChecks()

bool Phase2Tracker::Phase2TrackerFEDBuffer::doCorruptBufferChecks ( ) const

inline

Definition at line 68 of file Phase2TrackerFEDBuffer.h.

68 { return true; } // FEDBuffer

◆ dump()

void Phase2Tracker::Phase2TrackerFEDBuffer::dump ( std::ostream & os ) const

inline

Definition at line 21 of file Phase2TrackerFEDBuffer.h.

21 { printHex(buffer_, bufferSize_, os); }

References buffer_, bufferSize_, and Phase2Tracker::printHex().

◆ findChannels()

void Phase2Tracker::Phase2TrackerFEDBuffer::findChannels ( )

private

Definition at line 35 of file Phase2TrackerFEDBuffer.cc.

                                             {
     // each FED can be connectd to up to 16 frontends (read from header)
     // each fronted can be connected to up to 16 CBC
     // in raw mode, a header of 16bits tells which CBC are activated on this FE
     // in ZS mode, one byte is used to tell how many clusters are present in the current CBC
     // one channel corresponds to one CBC chip, undependently of the mode
  
     // offset of beginning of current channel
     size_t offsetBeginningOfChannel = 0;
  
     // iterate over all FEs to see if they are active
     std::vector<bool>::iterator FE_it;
     std::vector<bool> status = trackerHeader_.frontendStatus();
  
     if (readoutMode() == READOUT_MODE_PROC_RAW) {
       for (FE_it = status.begin(); FE_it < status.end(); FE_it++) {
         // if the current fronted is on, fill channels and advance pointer to end of channel
         if (*FE_it) {
           // read first FEDCH_PER_FEUNIT bits to know which CBC are on
           uint16_t cbc_status = static_cast<uint16_t>(*(payloadPointer_ + (offsetBeginningOfChannel ^ 7)) << 8);
           cbc_status += static_cast<uint16_t>(*(payloadPointer_ + ((offsetBeginningOfChannel + 1) ^ 7)));
  
           // advance pointer by FEDCH_PER_FEUNIT bits
           offsetBeginningOfChannel += MAX_CBC_PER_FE / 8;
           for (int i = 0; i < MAX_CBC_PER_FE; i++) {
             // if CBC is ON, fill channel and advance pointer. else, push back empty channel
             if ((cbc_status >> i) & 0x1) {
               // Warning: STRIPS_PADDING+STRIPS_PER_CBC should always be an entire number of bytes
               channels_.push_back(Phase2TrackerFEDChannel(
                   payloadPointer_, offsetBeginningOfChannel, (STRIPS_PADDING + STRIPS_PER_CBC) / 8));
               offsetBeginningOfChannel += (STRIPS_PADDING + STRIPS_PER_CBC) / 8;
             } else {
               channels_.push_back(Phase2TrackerFEDChannel(nullptr, 0, 0));
             }
           }
         } else {
           // else fill with FEDCH_PER_FEUNIT null channels, don't advance the channel pointer
           channels_.insert(channels_.end(), size_t(MAX_CBC_PER_FE), Phase2TrackerFEDChannel(payloadPointer_, 0, 0));
         }
       }
     } else if (readoutMode() == READOUT_MODE_ZERO_SUPPRESSED) {
       for (FE_it = status.begin(); FE_it < status.end(); FE_it++) {
         if (*FE_it) {
           for (int i = 0; i < MAX_CBC_PER_FE; i++) {
             // read first byte to get number of clusters and skip it
             uint8_t n_clusters = static_cast<uint8_t>(*(payloadPointer_ + offsetBeginningOfChannel));
             offsetBeginningOfChannel += 1;
             // each channel contains 2 bytes per cluster
             channels_.push_back(Phase2TrackerFEDChannel(payloadPointer_, offsetBeginningOfChannel, 2 * n_clusters));
             // skip clusters
             offsetBeginningOfChannel += 2 * n_clusters;
           }
         } else {
           // else fill with FEDCH_PER_FEUNIT null channels, don't advance the channel pointer
           channels_.insert(channels_.end(), size_t(MAX_CBC_PER_FE), Phase2TrackerFEDChannel(payloadPointer_, 0, 0));
         }
       }
     } else {
       // TODO: throw exception for unrecognised readout mode
       // check done at Phase2TrackerFEDHeader::readoutMode()
     }
     // round the offset to the next 64 bits word
     int words64 = (offsetBeginningOfChannel + 8 - 1) / 8;  // size in 64 bit
     int payloadSize = words64 * 8;                         // size in bytes
     triggerPointer_ = payloadPointer_ + payloadSize;
  
     // get diff size in bytes:
     // fedBufferSize - (DAQHeader+TrackHeader+PayloadSize+TriggerSize+DAQTrailer)
     int bufferDiff = bufferSize_ - 8 - trackerHeader_.getTrackerHeaderSize() - payloadSize - TRIGGER_SIZE - 8;
  
     // check if condition data is supposed to be there:
     if (trackerHeader_.getConditionData()) {
       condDataPointer_ = triggerPointer_ + TRIGGER_SIZE;
       // diff must be equal to condition data size
       if (bufferDiff <= 0) {
         std::ostringstream ss;
         ss << "[Phase2Tracker::Phase2TrackerFEDBuffer::" << __func__ << "] "
            << "\n";
         ss << "FED Buffer Size does not match data => missing condition data? : "
            << "\n";
         ss << "Expected Buffer Size " << bufferSize_ << " bytes"
            << "\n";
         ss << "Computed Buffer Size " << bufferSize_ + bufferDiff << " bytes"
            << "\n";
         throw cms::Exception("Phase2TrackerFEDBuffer") << ss.str();
       }
     } else {
       // put a null pointer to indicate lack of condition data
       condDataPointer_ = nullptr;
       // check buffer size :
       if (bufferDiff != 0) {
         std::ostringstream ss;
         ss << "[Phase2Tracker::Phase2TrackerFEDBuffer::" << __func__ << "] "
            << "\n";
         ss << "FED Buffer Size does not match data => corrupted buffer? : "
            << "\n";
         ss << "Expected Buffer Size " << bufferSize_ << " bytes"
            << "\n";
         ss << "Computed Buffer Size " << bufferSize_ + bufferDiff << " bytes"
            << "\n";
         throw cms::Exception("Phase2TrackerFEDBuffer") << ss.str();
       }
     }
   }