Classes
class	FEDDAQHeader

class	FEDDAQTrailer

class	Phase2TrackerCommissioningDigiProducer

class	Phase2TrackerDigiProducer

class	Phase2TrackerFEDBuffer

class	Phase2TrackerFEDChannel

class	Phase2TrackerFEDHeader

class	Phase2TrackerFEDRawChannelUnpacker

class	Phase2TrackerFEDZSChannelUnpacker

Enumerations
enum	FEDDAQEventType { DAQ_EVENT_TYPE_PHYSICS = 0x1, DAQ_EVENT_TYPE_CALIBRATION = 0x2, DAQ_EVENT_TYPE_TEST = 0x3, DAQ_EVENT_TYPE_TECHNICAL = 0x4, DAQ_EVENT_TYPE_SIMULATED = 0x5, DAQ_EVENT_TYPE_TRACED = 0x6, DAQ_EVENT_TYPE_ERROR = 0xF, DAQ_EVENT_TYPE_INVALID = INVALID }

enum	FEDReadoutMode { READOUT_MODE_INVALID = INVALID, READOUT_MODE_SCOPE = 0x1, READOUT_MODE_VIRGIN_RAW = 0x2, READOUT_MODE_PROC_RAW = 0x6, READOUT_MODE_ZERO_SUPPRESSED = 0xA, READOUT_MODE_ZERO_SUPPRESSED_LITE = 0xC, READOUT_MODE_SPY = 0xE }

enum	FEDTTSBits { TTS_DISCONNECTED0 = 0x0, TTS_WARN_OVERFLOW = 0x1, TTS_OUT_OF_SYNC = 0x2, TTS_BUSY = 0x4, TTS_READY = 0x8, TTS_ERROR = 0x12, TTS_DISCONNECTED1 = 0xF, TTS_INVALID = INVALID }

enum	READ_MODE { READ_MODE_INVALID = INVALID, SUMMARY = 0, FULL_DEBUG = 1, CBC_ERROR = 2 }

enum	trackerHeader_m { VERSION_M = 0xF000000000000000, HEADER_FORMAT_M = 0x0C00000000000000, EVENT_TYPE_M = 0x03C0000000000000, GLIB_STATUS_M = 0x003FFFFFFFFF0000, FRONTEND_STAT_M = 0x000000000000FFFF, CBC_NUMBER_M = 0xFFFF000000000000 }

enum	trackerHeader_s { VERSION_S = 60, HEADER_FORMAT_S = 58, EVENT_TYPE_S = 54, GLIB_STATUS_S = 16, FRONTEND_STAT_S = 0, CBC_NUMBER_S = 48 }

Functions
uint64_t	extract64 (trackerHeader_m mask, trackerHeader_s shift, uint64_t data)

std::ostream &	operator<< (std::ostream &os, const FEDDAQEventType &value)

std::ostream &	operator<< (std::ostream &os, const FEDTTSBits &value)

std::ostream &	operator<< (std::ostream &os, const FEDReadoutMode &value)

std::ostream &	operator<< (std::ostream &os, const READ_MODE &value)

void	printHex (const void *pointer, const size_t lengthInBytes, std::ostream &os)

void	printHexValue (const uint8_t value, std::ostream &os)

void	printHexWord (const uint8_t *pointer, const size_t lengthInBytes, std::ostream &os)

void	printNibbleValue (uint8_t value, std::ostream &os)

uint64_t	read64 (int offset, const uint8_t *buffer)

Variables
static const uint16_t	CMS_FED_ID_MAX = static_cast<uint16_t>(FEDNumbering::MAXFEDID)

static const uint16_t	FED_ID_MAX = static_cast<uint16_t>(FEDNumbering::MAXSiStripFEDID)

static const uint16_t	FED_ID_MIN = static_cast<uint16_t>(FEDNumbering::MINSiStripFEDID)

static const uint8_t	INVALID = 0xFF

static const int	MAX_CBC_PER_FE = 16

static const int	MAX_FE_PER_FED = 16

static const uint16_t	NUMBER_OF_FEDS = static_cast<uint16_t>(FED_ID_MAX - FED_ID_MIN + 1)

static const int	STRIPS_PADDING = 2

static const int	STRIPS_PER_CBC = 254

static const int	TRIGGER_SIZE = 0

Enumeration Type Documentation

◆ FEDDAQEventType

enum Phase2Tracker::FEDDAQEventType

Enumerator
DAQ_EVENT_TYPE_PHYSICS
DAQ_EVENT_TYPE_CALIBRATION
DAQ_EVENT_TYPE_TEST
DAQ_EVENT_TYPE_TECHNICAL
DAQ_EVENT_TYPE_SIMULATED
DAQ_EVENT_TYPE_TRACED
DAQ_EVENT_TYPE_ERROR
DAQ_EVENT_TYPE_INVALID

Definition at line 15 of file Phase2TrackerFEDDAQHeader.h.

                        {
     DAQ_EVENT_TYPE_PHYSICS = 0x1,
     DAQ_EVENT_TYPE_CALIBRATION = 0x2,
     DAQ_EVENT_TYPE_TEST = 0x3,
     DAQ_EVENT_TYPE_TECHNICAL = 0x4,
     DAQ_EVENT_TYPE_SIMULATED = 0x5,
     DAQ_EVENT_TYPE_TRACED = 0x6,
     DAQ_EVENT_TYPE_ERROR = 0xF,
     DAQ_EVENT_TYPE_INVALID = INVALID
   };

◆ FEDReadoutMode

enum Phase2Tracker::FEDReadoutMode

Enumerator
READOUT_MODE_INVALID
READOUT_MODE_SCOPE
READOUT_MODE_VIRGIN_RAW
READOUT_MODE_PROC_RAW
READOUT_MODE_ZERO_SUPPRESSED
READOUT_MODE_ZERO_SUPPRESSED_LITE
READOUT_MODE_SPY

Definition at line 95 of file utils.h.

                       {
     READOUT_MODE_INVALID = INVALID,
     READOUT_MODE_SCOPE = 0x1,
     READOUT_MODE_VIRGIN_RAW = 0x2,
     READOUT_MODE_PROC_RAW = 0x6,
     READOUT_MODE_ZERO_SUPPRESSED = 0xA,
     READOUT_MODE_ZERO_SUPPRESSED_LITE = 0xC,
     READOUT_MODE_SPY = 0xE
   };

◆ FEDTTSBits

enum Phase2Tracker::FEDTTSBits

Enumerator
TTS_DISCONNECTED0
TTS_WARN_OVERFLOW
TTS_OUT_OF_SYNC
TTS_BUSY
TTS_READY
TTS_ERROR
TTS_DISCONNECTED1
TTS_INVALID

Definition at line 15 of file Phase2TrackerFEDDAQTrailer.h.

                   {
     TTS_DISCONNECTED0 = 0x0,
     TTS_WARN_OVERFLOW = 0x1,
     TTS_OUT_OF_SYNC = 0x2,
     TTS_BUSY = 0x4,
     TTS_READY = 0x8,
     TTS_ERROR = 0x12,
     TTS_DISCONNECTED1 = 0xF,
     TTS_INVALID = INVALID
   };

◆ READ_MODE

enum Phase2Tracker::READ_MODE

Enumerator
READ_MODE_INVALID
SUMMARY
FULL_DEBUG
CBC_ERROR

Definition at line 141 of file utils.h.

141 { READ_MODE_INVALID = INVALID, SUMMARY = 0, FULL_DEBUG = 1, CBC_ERROR = 2 };

Phase2Tracker::INVALID

static const uint8_t INVALID

Definition: utils.h:32

Phase2Tracker::READ_MODE_INVALID

Definition: utils.h:141

Phase2Tracker::FULL_DEBUG

Definition: utils.h:141

Phase2Tracker::CBC_ERROR

Definition: utils.h:141

Phase2Tracker::SUMMARY

Definition: utils.h:141

◆ trackerHeader_m

enum Phase2Tracker::trackerHeader_m

Enumerator
VERSION_M
HEADER_FORMAT_M
EVENT_TYPE_M
GLIB_STATUS_M
FRONTEND_STAT_M
CBC_NUMBER_M

Definition at line 167 of file utils.h.

                        {
     VERSION_M = 0xF000000000000000,
     HEADER_FORMAT_M = 0x0C00000000000000,
     EVENT_TYPE_M = 0x03C0000000000000,
     GLIB_STATUS_M = 0x003FFFFFFFFF0000,
     FRONTEND_STAT_M = 0x000000000000FFFF,
     CBC_NUMBER_M = 0xFFFF000000000000
   };

◆ trackerHeader_s

enum Phase2Tracker::trackerHeader_s

Enumerator
VERSION_S
HEADER_FORMAT_S
EVENT_TYPE_S
GLIB_STATUS_S
FRONTEND_STAT_S
CBC_NUMBER_S

Definition at line 176 of file utils.h.

                        {
     VERSION_S = 60,
     HEADER_FORMAT_S = 58,
     EVENT_TYPE_S = 54,
     GLIB_STATUS_S = 16,
     FRONTEND_STAT_S = 0,
     CBC_NUMBER_S = 48
   };

Function Documentation

◆ extract64()

uint64_t Phase2Tracker::extract64	(	trackerHeader_m	mask,
		trackerHeader_s	shift,
		uint64_t	data
	)

inline

Definition at line 191 of file utils.h.

References data, and edm::shift.

Referenced by Phase2Tracker::Phase2TrackerFEDHeader::dataFormatVersion(), Phase2Tracker::Phase2TrackerFEDHeader::debugMode(), Phase2Tracker::Phase2TrackerFEDHeader::eventType(), Phase2Tracker::Phase2TrackerFEDHeader::frontendStatus(), Phase2Tracker::Phase2TrackerFEDHeader::glibStatusCode(), and Phase2Tracker::Phase2TrackerFEDHeader::numberOfCBC().

                                                                                         {
     // cout <<"IN  "<< hex<< " " <<setfill('0') << setw(16) << data  << "\n" ;
     data = (data & mask) >> shift;
     return data;
   }

◆ operator<<() [1/4]

std::ostream & Phase2Tracker::operator<<	(	std::ostream &	os,
		const FEDDAQEventType &	value
	)

inline

Definition at line 7 of file Phase2TrackerFEDDAQHeader.cc.

References DAQ_EVENT_TYPE_CALIBRATION, DAQ_EVENT_TYPE_ERROR, DAQ_EVENT_TYPE_INVALID, DAQ_EVENT_TYPE_PHYSICS, DAQ_EVENT_TYPE_SIMULATED, DAQ_EVENT_TYPE_TECHNICAL, DAQ_EVENT_TYPE_TEST, DAQ_EVENT_TYPE_TRACED, and printHexValue().

                                                                        {
     switch (value) {
       case DAQ_EVENT_TYPE_PHYSICS:
         os << "Physics trigger";
         break;
       case DAQ_EVENT_TYPE_CALIBRATION:
         os << "Calibration trigger";
         break;
       case DAQ_EVENT_TYPE_TEST:
         os << "Test trigger";
         break;
       case DAQ_EVENT_TYPE_TECHNICAL:
         os << "Technical trigger";
         break;
       case DAQ_EVENT_TYPE_SIMULATED:
         os << "Simulated event";
         break;
       case DAQ_EVENT_TYPE_TRACED:
         os << "Traced event";
         break;
       case DAQ_EVENT_TYPE_ERROR:
         os << "Error";
         break;
       case DAQ_EVENT_TYPE_INVALID:
         os << "Unknown";
         break;
       default:
         os << "Unrecognized";
         os << " (";
         printHexValue(value, os);
         os << ")";
         break;
     }
     return os;
   }

◆ operator<<() [2/4]

std::ostream & Phase2Tracker::operator<<	(	std::ostream &	os,
		const FEDTTSBits &	value
	)

inline

Definition at line 7 of file Phase2TrackerFEDDAQTrailer.cc.

References printHexValue(), TTS_BUSY, TTS_DISCONNECTED0, TTS_DISCONNECTED1, TTS_ERROR, TTS_INVALID, TTS_OUT_OF_SYNC, TTS_READY, and TTS_WARN_OVERFLOW.

                                                                   {
     switch (value) {
       case TTS_DISCONNECTED0:
         os << "Disconected 0";
         break;
       case TTS_WARN_OVERFLOW:
         os << "Warning overflow";
         break;
       case TTS_OUT_OF_SYNC:
         os << "Out of sync";
         break;
       case TTS_BUSY:
         os << "Busy";
         break;
       case TTS_READY:
         os << "Ready";
         break;
       case TTS_ERROR:
         os << "Error";
         break;
       case TTS_INVALID:
         os << "Invalid";
         break;
       case TTS_DISCONNECTED1:
         os << "Disconected 1";
         break;
       default:
         os << "Unrecognized";
         os << " (";
         printHexValue(value, os);
         os << ")";
         break;
     }
     return os;
   }

◆ operator<<() [3/4]

std::ostream & Phase2Tracker::operator<<	(	std::ostream &	os,
		const FEDReadoutMode &	value
	)

inline

Definition at line 107 of file utils.h.

References printHexValue(), READOUT_MODE_INVALID, READOUT_MODE_PROC_RAW, READOUT_MODE_SCOPE, READOUT_MODE_SPY, READOUT_MODE_VIRGIN_RAW, READOUT_MODE_ZERO_SUPPRESSED, and READOUT_MODE_ZERO_SUPPRESSED_LITE.

                                                                              {
     switch (value) {
       case READOUT_MODE_SCOPE:
         os << "Scope mode";
         break;
       case READOUT_MODE_VIRGIN_RAW:
         os << "Virgin raw";
         break;
       case READOUT_MODE_PROC_RAW:
         os << "Processed raw";
         break;
       case READOUT_MODE_ZERO_SUPPRESSED:
         os << "Zero suppressed";
         break;
       case READOUT_MODE_ZERO_SUPPRESSED_LITE:
         os << "Zero suppressed lite";
         break;
       case READOUT_MODE_SPY:
         os << "Spy channel";
         break;
       case READOUT_MODE_INVALID:
         os << "Invalid";
         break;
       default:
         os << "Unrecognized";
         os << " (";
         printHexValue(value, os);
         os << ")";
         break;
     }
     return os;
   }

◆ operator<<() [4/4]

std::ostream & Phase2Tracker::operator<<	(	std::ostream &	os,
		const READ_MODE &	value
	)

inline

Definition at line 145 of file utils.h.

References CBC_ERROR, FULL_DEBUG, printHexValue(), and SUMMARY.

                                                                         {
     switch (value) {
       case SUMMARY:
         os << "Summary mode";
         break;
       case FULL_DEBUG:
         os << "Full debug mode";
         break;
       case CBC_ERROR:
         os << "CBC error mode";
         break;
       default:
         os << "Unrecognized mode";
         os << " (";
         printHexValue(value, os);
         os << ")";
         break;
     }
     return os;
   }

◆ printHex()

void Phase2Tracker::printHex	(	const void *	pointer,
		const size_t	lengthInBytes,
		std::ostream &	os
	)

inline

Definition at line 58 of file utils.h.

References AlCaHLTBitMon_ParallelJobs::p, printHexWord(), and w().

Referenced by Phase2Tracker::Phase2TrackerFEDHeader::dataFormatVersion(), Phase2Tracker::Phase2TrackerFEDHeader::debugMode(), Phase2Tracker::Phase2TrackerFEDBuffer::dump(), Phase2Tracker::FEDDAQHeader::print(), Phase2Tracker::FEDDAQTrailer::print(), and Phase2Tracker::Phase2TrackerFEDHeader::readoutMode().

                                                                                         {
     const uint8_t* bytePointer = reinterpret_cast<const uint8_t*>(pointer);
     //if there is one 64 bit word or less, print it out
     if (lengthInBytes <= 8) {
       printHexWord(bytePointer, lengthInBytes, os);
     }
     //otherwise, print word numbers etc
     else {
       //header
       os << "word\tbyte\t                       \t\tbyte" << std::endl;
       ;
       const size_t words = lengthInBytes / 8;
       const size_t extraBytes = lengthInBytes - 8 * words;
       //print full words
       for (size_t w = 0; w < words; w++) {
         const size_t startByte = w * 8;
         os << w << '\t' << startByte + 8 << '\t';
         printHexWord(bytePointer + startByte, 8, os);
         os << "\t\t" << startByte << std::endl;
       }
       //print part word, if any
       if (extraBytes) {
         const size_t startByte = words * 8;
         os << words << '\t' << startByte + 8 << '\t';
         //padding
         size_t p = 8;
         while (p-- > extraBytes) {
           os << "00 ";
         }
         printHexWord(bytePointer + startByte, extraBytes, os);
         os << "\t\t" << startByte << std::endl;
       }
       os << std::endl;
     }
   }

◆ printHexValue()

void Phase2Tracker::printHexValue	(	const uint8_t	value,
		std::ostream &	os
	)

inline

Definition at line 42 of file utils.h.

Referenced by operator<<(), and printHexWord().

                                                                  {
     const std::ios_base::fmtflags originalFormatFlags = os.flags();
     os << std::hex << std::setfill('0') << std::setw(2);
     os << uint16_t(value);
     os.flags(originalFormatFlags);
   }

◆ printHexWord()

void Phase2Tracker::printHexWord	(	const uint8_t *	pointer,
		const size_t	lengthInBytes,
		std::ostream &	os
	)

inline

Definition at line 49 of file utils.h.

References mps_fire::i, and printHexValue().

Referenced by printHex().

                                                                                                {
     size_t i = lengthInBytes - 1;
     do {
       printHexValue(pointer[i], os);
       if (i != 0)
         os << " ";
     } while (i-- != 0);
   }

◆ printNibbleValue()

void Phase2Tracker::printNibbleValue	(	uint8_t	value,
		std::ostream &	os
	)

inline

Definition at line 36 of file utils.h.

References relativeConstraints::value.

                                                               {
     const std::ios_base::fmtflags originalFormatFlags = os.flags();
     os << std::hex << std::setw(1) << value;
     os.flags(originalFormatFlags);
   }

◆ read64()

uint64_t Phase2Tracker::read64	(	int	offset,
		const uint8_t *	buffer
	)

inline

Definition at line 186 of file utils.h.

References edmScanValgrind::buffer, and hltrates_dqm_sourceclient-live_cfg::offset.

Referenced by Phase2Tracker::Phase2TrackerFEDHeader::CBCStatus(), Phase2Tracker::Phase2TrackerFEDBuffer::Phase2TrackerFEDBuffer(), and Phase2Tracker::Phase2TrackerFEDHeader::Phase2TrackerFEDHeader().

                                                             {
     return *reinterpret_cast<const uint64_t*>(buffer + offset);
   }

Variable Documentation

◆ CMS_FED_ID_MAX

const uint16_t Phase2Tracker::CMS_FED_ID_MAX = static_cast<uint16_t>(FEDNumbering::MAXFEDID)

static

Definition at line 19 of file utils.h.

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

◆ FED_ID_MAX

const uint16_t Phase2Tracker::FED_ID_MAX = static_cast<uint16_t>(FEDNumbering::MAXSiStripFEDID)

static

Definition at line 18 of file utils.h.

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

◆ FED_ID_MIN

const uint16_t Phase2Tracker::FED_ID_MIN = static_cast<uint16_t>(FEDNumbering::MINSiStripFEDID)

static

Definition at line 17 of file utils.h.

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

◆ INVALID

const uint8_t Phase2Tracker::INVALID = 0xFF

static

Definition at line 32 of file utils.h.

◆ MAX_CBC_PER_FE

const int Phase2Tracker::MAX_CBC_PER_FE = 16

static

Definition at line 25 of file utils.h.

Referenced by Phase2Tracker::Phase2TrackerFEDBuffer::findChannels(), Phase2Tracker::Phase2TrackerFEDBuffer::Phase2TrackerFEDBuffer(), and Phase2Tracker::Phase2TrackerDigiProducer::produce().

◆ MAX_FE_PER_FED

const int Phase2Tracker::MAX_FE_PER_FED = 16

static

Definition at line 24 of file utils.h.

Referenced by Phase2Tracker::Phase2TrackerFEDBuffer::Phase2TrackerFEDBuffer(), and Phase2Tracker::Phase2TrackerDigiProducer::produce().

◆ NUMBER_OF_FEDS

const uint16_t Phase2Tracker::NUMBER_OF_FEDS = static_cast<uint16_t>(FED_ID_MAX - FED_ID_MIN + 1)

static

Definition at line 20 of file utils.h.

◆ STRIPS_PADDING

const int Phase2Tracker::STRIPS_PADDING = 2

static

Definition at line 27 of file utils.h.

Referenced by Phase2Tracker::Phase2TrackerFEDBuffer::findChannels().

◆ STRIPS_PER_CBC

const int Phase2Tracker::STRIPS_PER_CBC = 254

static

Definition at line 26 of file utils.h.

Referenced by Phase2Tracker::Phase2TrackerFEDBuffer::findChannels(), and Phase2Tracker::Phase2TrackerDigiProducer::produce().

◆ TRIGGER_SIZE

const int Phase2Tracker::TRIGGER_SIZE = 0

static

Definition at line 28 of file utils.h.

Referenced by Phase2Tracker::Phase2TrackerFEDBuffer::conditionData(), and Phase2Tracker::Phase2TrackerFEDBuffer::findChannels().

Classes

Enumerations

Functions

Variables

Enumeration Type Documentation

◆ FEDDAQEventType

◆ FEDReadoutMode

◆ FEDTTSBits

◆ READ_MODE

◆ trackerHeader_m

◆ trackerHeader_s

Function Documentation

◆ extract64()

◆ operator<<() [1/4]

◆ operator<<() [2/4]

◆ operator<<() [3/4]

◆ operator<<() [4/4]

◆ printHex()

◆ printHexValue()

◆ printHexWord()

◆ printNibbleValue()

◆ read64()

Variable Documentation

◆ CMS_FED_ID_MAX

◆ FED_ID_MAX

◆ FED_ID_MIN

◆ INVALID

◆ MAX_CBC_PER_FE

◆ MAX_FE_PER_FED

◆ NUMBER_OF_FEDS

◆ STRIPS_PADDING

◆ STRIPS_PER_CBC

◆ TRIGGER_SIZE