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

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

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 98 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
                       };

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

enum Phase2Tracker::READ_MODE

Enumerator
READ_MODE_INVALID
SUMMARY
FULL_DEBUG
CBC_ERROR

Definition at line 144 of file utils.h.

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

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 179 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 
                        };

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 187 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

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

inline

Definition at line 203 of file utils.h.

References data.

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

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

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

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

inline

Definition at line 109 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;
   }

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

inline

Definition at line 154 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;
   }

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

inline

Definition at line 60 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;
     }
   }

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

inline

Definition at line 43 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);
   }

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

inline

Definition at line 51 of file utils.h.

References i, and printHexValue().

Referenced by printHex().

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

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

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

inline

Definition at line 197 of file utils.h.

References evf::evtn::offset().

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

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

Variable Documentation

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().

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().

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().

const uint8_t Phase2Tracker::INVALID =0xFF

static

Definition at line 32 of file utils.h.

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().

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().

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.

const int Phase2Tracker::STRIPS_PADDING = 2

static

Definition at line 27 of file utils.h.

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

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().

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

Function Documentation

Variable Documentation