Phase2Tracker::Phase2TrackerFEDBuffer Class Reference

#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

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

Definition at line 10 of file Phase2TrackerFEDBuffer.cc.

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_.

    : 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();
  }

Phase2Tracker::Phase2TrackerFEDBuffer::~Phase2TrackerFEDBuffer

(

)

Definition at line 38 of file Phase2TrackerFEDBuffer.cc.

  {
  }

Member Function Documentation

size_t Phase2Tracker::Phase2TrackerFEDBuffer::bufferSize ( ) const

inline

Definition at line 27 of file Phase2TrackerFEDBuffer.h.

References bufferSize_.

Referenced by Phase2Tracker::Phase2TrackerDigiProducer::produce().

{ return bufferSize_; }

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

inline

Definition at line 29 of file Phase2TrackerFEDBuffer.h.

References channels_, and conditionData().

Referenced by Phase2Tracker::Phase2TrackerDigiProducer::produce().

{ return channels_[internalPhase2TrackerFEDChannelNum]; }

bool Phase2Tracker::Phase2TrackerFEDBuffer::checkNoFEOverflows ( ) const

inline

Definition at line 66 of file Phase2TrackerFEDBuffer.h.

{ return true; } // FEDBufferBase

std::map< uint32_t, uint32_t > Phase2Tracker::Phase2TrackerFEDBuffer::conditionData

(

)

const

Definition at line 164 of file Phase2TrackerFEDBuffer.cc.

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

Referenced by channel(), and Phase2Tracker::Phase2TrackerCommissioningDigiProducer::produce().

  {
      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;

  }

uint16_t Phase2Tracker::Phase2TrackerFEDBuffer::daqBXID ( ) const

inline

Definition at line 35 of file Phase2TrackerFEDBuffer.h.

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

{ return daqHeader_.bxID(); }

uint16_t Phase2Tracker::Phase2TrackerFEDBuffer::daqCRC ( ) const

inline

Definition at line 41 of file Phase2TrackerFEDBuffer.h.

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

{ return daqTrailer_.crc(); }

uint32_t Phase2Tracker::Phase2TrackerFEDBuffer::daqEventLengthIn64bitWords ( ) const

inline

Definition at line 39 of file Phase2TrackerFEDBuffer.h.

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

{ return daqTrailer_.eventLengthIn64BitWords(); }

uint32_t Phase2Tracker::Phase2TrackerFEDBuffer::daqEventLengthInBytes ( ) const

inline

Definition at line 40 of file Phase2TrackerFEDBuffer.h.

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

{ return daqTrailer_.eventLengthInBytes(); }

FEDDAQEventType Phase2Tracker::Phase2TrackerFEDBuffer::daqEventType ( ) const

inline

Definition at line 33 of file Phase2TrackerFEDBuffer.h.

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

{ return daqHeader_.eventType(); }

FEDDAQHeader Phase2Tracker::Phase2TrackerFEDBuffer::daqHeader ( ) const

inline

Definition at line 25 of file Phase2TrackerFEDBuffer.h.

References daqHeader_.

{ return daqHeader_; }

uint32_t Phase2Tracker::Phase2TrackerFEDBuffer::daqLvl1ID ( ) const

inline

Definition at line 34 of file Phase2TrackerFEDBuffer.h.

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

{ return daqHeader_.l1ID(); }

uint16_t Phase2Tracker::Phase2TrackerFEDBuffer::daqSourceID ( ) const

inline

Definition at line 36 of file Phase2TrackerFEDBuffer.h.

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

{ return daqHeader_.sourceID(); }

FEDDAQTrailer Phase2Tracker::Phase2TrackerFEDBuffer::daqTrailer ( ) const

inline

Definition at line 26 of file Phase2TrackerFEDBuffer.h.

References daqTrailer_.

{ return daqTrailer_; }

FEDTTSBits Phase2Tracker::Phase2TrackerFEDBuffer::daqTTSState ( ) const

inline

Definition at line 42 of file Phase2TrackerFEDBuffer.h.

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

{ return daqTrailer_.ttsBits(); }

bool Phase2Tracker::Phase2TrackerFEDBuffer::doChecks ( ) const

inline

Definition at line 65 of file Phase2TrackerFEDBuffer.h.

{ return true; }  // FEDBuffer

bool Phase2Tracker::Phase2TrackerFEDBuffer::doCorruptBufferChecks ( ) const

inline

Definition at line 67 of file Phase2TrackerFEDBuffer.h.

{ return true; } // FEDBuffer

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

inline

Definition at line 22 of file Phase2TrackerFEDBuffer.h.

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

{ printHex(buffer_,bufferSize_,os); }

void Phase2Tracker::Phase2TrackerFEDBuffer::findChannels ( )

private

Definition at line 42 of file Phase2TrackerFEDBuffer.cc.

References bufferSize_, channels_, condDataPointer_, Exception, Phase2Tracker::Phase2TrackerFEDHeader::frontendStatus(), Phase2Tracker::Phase2TrackerFEDHeader::getConditionData(), Phase2Tracker::Phase2TrackerFEDHeader::getTrackerHeaderSize(), mps_fire::i, Phase2Tracker::MAX_CBC_PER_FE, payloadPointer_, Phase2Tracker::READOUT_MODE_PROC_RAW, Phase2Tracker::READOUT_MODE_ZERO_SUPPRESSED, readoutMode(), mps_update::status, Phase2Tracker::STRIPS_PADDING, Phase2Tracker::STRIPS_PER_CBC, trackerHeader_, Phase2Tracker::TRIGGER_SIZE, and triggerPointer_.

Referenced by Phase2TrackerFEDBuffer().

  {
    // 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();
      }
    } 

  }

const uint8_t* Phase2Tracker::Phase2TrackerFEDBuffer::getPointerToCondData ( ) const

inline

Definition at line 47 of file Phase2TrackerFEDBuffer.h.

References condDataPointer_.

{ return condDataPointer_; }

const uint8_t* Phase2Tracker::Phase2TrackerFEDBuffer::getPointerToPayload ( ) const

inline

Definition at line 46 of file Phase2TrackerFEDBuffer.h.

References Phase2Tracker::Phase2TrackerFEDHeader::getPointerToData(), and trackerHeader_.

Referenced by Phase2TrackerFEDBuffer().

{ return trackerHeader_.getPointerToData(); }

const uint8_t* Phase2Tracker::Phase2TrackerFEDBuffer::getPointerToTriggerData ( ) const

inline

Definition at line 48 of file Phase2TrackerFEDBuffer.h.

References triggerPointer_.

{ return triggerPointer_; }

FEDReadoutMode Phase2Tracker::Phase2TrackerFEDBuffer::readoutMode

(

)

const

Definition at line 217 of file Phase2TrackerFEDBuffer.cc.

References Phase2Tracker::Phase2TrackerFEDHeader::getReadoutMode(), and trackerHeader_.

Referenced by daqTTSState(), and findChannels().

  {
    return trackerHeader_.getReadoutMode();
  }

Phase2TrackerFEDHeader Phase2Tracker::Phase2TrackerFEDBuffer::trackerHeader ( ) const

inline

Definition at line 28 of file Phase2TrackerFEDBuffer.h.

References trackerHeader_.

Referenced by Phase2Tracker::Phase2TrackerDigiProducer::produce().

{ return trackerHeader_; }

Member Data Documentation

const uint8_t* Phase2Tracker::Phase2TrackerFEDBuffer::buffer_

private

Definition at line 51 of file Phase2TrackerFEDBuffer.h.

Referenced by conditionData(), dump(), and Phase2TrackerFEDBuffer().

const size_t Phase2Tracker::Phase2TrackerFEDBuffer::bufferSize_

private

Definition at line 52 of file Phase2TrackerFEDBuffer.h.

Referenced by bufferSize(), conditionData(), dump(), findChannels(), and Phase2TrackerFEDBuffer().

std::vector<Phase2TrackerFEDChannel> Phase2Tracker::Phase2TrackerFEDBuffer::channels_

private

Definition at line 53 of file Phase2TrackerFEDBuffer.h.

Referenced by channel(), findChannels(), and Phase2TrackerFEDBuffer().

const uint8_t* Phase2Tracker::Phase2TrackerFEDBuffer::condDataPointer_

private

Definition at line 58 of file Phase2TrackerFEDBuffer.h.

Referenced by conditionData(), findChannels(), and getPointerToCondData().

FEDDAQHeader Phase2Tracker::Phase2TrackerFEDBuffer::daqHeader_

private

Definition at line 54 of file Phase2TrackerFEDBuffer.h.

Referenced by daqBXID(), daqEventType(), daqHeader(), daqLvl1ID(), daqSourceID(), and Phase2TrackerFEDBuffer().

FEDDAQTrailer Phase2Tracker::Phase2TrackerFEDBuffer::daqTrailer_

private

Definition at line 55 of file Phase2TrackerFEDBuffer.h.

Referenced by daqCRC(), daqEventLengthIn64bitWords(), daqEventLengthInBytes(), daqTrailer(), daqTTSState(), and Phase2TrackerFEDBuffer().

const uint8_t* Phase2Tracker::Phase2TrackerFEDBuffer::payloadPointer_

private

Definition at line 57 of file Phase2TrackerFEDBuffer.h.

Referenced by findChannels(), and Phase2TrackerFEDBuffer().

Phase2TrackerFEDHeader Phase2Tracker::Phase2TrackerFEDBuffer::trackerHeader_

private

Definition at line 56 of file Phase2TrackerFEDBuffer.h.

Referenced by findChannels(), getPointerToPayload(), Phase2TrackerFEDBuffer(), readoutMode(), and trackerHeader().

const uint8_t* Phase2Tracker::Phase2TrackerFEDBuffer::triggerPointer_

private

Definition at line 59 of file Phase2TrackerFEDBuffer.h.

Referenced by conditionData(), findChannels(), and getPointerToTriggerData().