#include <L1GtFdlWord.h>

Public Member Functions
const cms_uint16_t	boardId () const
	get/set board ID
const int	bxInEvent () const
	get/set bunch cross in the GT event record
const cms_uint16_t	bxNr () const
	get/set BxNr - bunch cross number of the actual bx
const cms_uint32_t	eventNr () const
	get/set event number since last L1 reset generated in FDL
const cms_uint16_t	finalOR () const
	get/set "Final OR" bits
const unsigned int	getSize () const
	get the size of the FDL block in GT DAQ record (in multiple of 8 bits)
const bool	globalDecision () const
const DecisionWord &	gtDecisionWord () const
	get/set/print algorithms bits (decision word)
const DecisionWordExtended &	gtDecisionWordExtended () const
	get/set extended algorithms bits (extended decision word)
const cms_uint16_t	gtPrescaleFactorIndexAlgo () const
const cms_uint16_t	gtPrescaleFactorIndexTech () const
	get/set index of the set of prescale factors
const TechnicalTriggerWord &	gtTechnicalTriggerWord () const
	get/set technical trigger bits
	L1GtFdlWord (cms_uint16_t boardIdValue, int bxInEventValue, cms_uint16_t bxNrValue, cms_uint32_t eventNrValue, TechnicalTriggerWord gtTechnicalTriggerWordValue, DecisionWord gtDecisionWordValue, DecisionWordExtended gtDecisionWordExtendedValue, cms_uint16_t gtPrescaleFactorIndexTechValue, cms_uint16_t gtPrescaleFactorIndexAlgoValue, cms_uint16_t noAlgoValue, cms_uint16_t finalORValue, cms_uint32_t orbitNrValue, cms_uint16_t lumiSegmentNrValue, cms_uint16_t localBxNrValue)
	L1GtFdlWord ()
	constructors
const cms_uint16_t	localBxNr () const
	get/set local bunch cross number of the actual bx
const cms_uint16_t	lumiSegmentNr () const
	get/set luminosity segment number of the actual bx
const cms_uint16_t	noAlgo () const
	get/set NoAlgo
bool	operator!= (const L1GtFdlWord &) const
	unequal operator
bool	operator== (const L1GtFdlWord &) const
	equal operator
const cms_uint32_t	orbitNr () const
	get/set orbit number
const cms_uint16_t	physicsDeclared () const
	get/set "physics declared" bit
void	print (std::ostream &myCout) const
	pretty print the content of a L1GtFdlWord
void	printGtDecisionWord (std::ostream &myCout) const
void	printGtDecisionWordExtended (std::ostream &myCout) const
void	printGtTechnicalTriggerWord (std::ostream &myCout) const
void	reset ()
	reset the content of a L1GtFdlWord
void	setBoardId (const cms_uint64_t &word64)
	set the BoardId value from a 64-bits word
void	setBoardId (const cms_uint16_t &boardIdValue)
	set BoardId from a BoardId value
void	setBoardIdWord64 (cms_uint64_t &word64, const int iWord)
void	setBxInEvent (const int bxInEventValue)
void	setBxInEvent (const cms_uint64_t &word64)
	set the BxInEvent value from a 64-bits word
void	setBxInEventWord64 (cms_uint64_t &word64, const int iWord)
void	setBxNr (const cms_uint64_t &word64)
	set the BxNr value from a 64-bits word
void	setBxNr (const cms_uint16_t &bxNrValue)
void	setBxNrWord64 (cms_uint64_t &word64, const int iWord)
void	setEventNr (const cms_uint32_t &eventNrValue)
void	setEventNr (const cms_uint64_t &word64)
	set the EventNr value from a 64-bits word
void	setEventNrWord64 (cms_uint64_t &word64, const int iWord)
void	setFinalOR (const cms_uint16_t &finalORValue)
void	setFinalOR (const cms_uint64_t &word64)
	set the "Final OR" bits from a 64-bits word
void	setFinalORWord64 (cms_uint64_t &word64, const int iWord)
void	setGtDecisionWord (const DecisionWord &gtDecisionWordValue)
void	setGtDecisionWordA (const cms_uint64_t &word64)
void	setGtDecisionWordAWord64 (cms_uint64_t &word64, const int iWord)
void	setGtDecisionWordB (const cms_uint64_t &word64)
void	setGtDecisionWordBWord64 (cms_uint64_t &word64, const int iWord)
void	setGtDecisionWordExtended (const DecisionWordExtended &gtDecisionWordExtendedValue)
void	setGtDecisionWordExtended (const cms_uint64_t &word64)
	set the extended algorithms bits from a 64-bits word
void	setGtDecisionWordExtendedWord64 (cms_uint64_t &word64, const int iWord)
void	setGtPrescaleFactorIndexAlgo (const cms_uint16_t &gtPrescaleFactorIndexAlgoValue)
void	setGtPrescaleFactorIndexAlgo (const cms_uint64_t &word64)
	set the GtPrescaleFactorIndexAlgo from a 64-bits word
void	setGtPrescaleFactorIndexAlgoWord64 (cms_uint64_t &word64, const int iWord)
void	setGtPrescaleFactorIndexTech (const cms_uint16_t &gtPrescaleFactorIndexTechValue)
void	setGtPrescaleFactorIndexTech (const cms_uint64_t &word64)
	set the GtPrescaleFactorIndexTech from a 64-bits word
void	setGtPrescaleFactorIndexTechWord64 (cms_uint64_t &word64, const int iWord)
void	setGtTechnicalTriggerWord (const TechnicalTriggerWord &gtTechnicalTriggerWordValue)
void	setGtTechnicalTriggerWord (const cms_uint64_t &word64)
	set the technical trigger bits from a 64-bits word
void	setGtTechnicalTriggerWordWord64 (cms_uint64_t &word64, const int iWord)
void	setLocalBxNr (const cms_uint64_t &word64)
	set the local bunch cross number bits from a 64-bits word
void	setLocalBxNr (const cms_uint16_t &localBxNrValue)
void	setLocalBxNrWord64 (cms_uint64_t &word64, const int iWord)
void	setLumiSegmentNr (const cms_uint16_t &lumiSegmentNrValue)
void	setLumiSegmentNr (const cms_uint64_t &word64)
	set the luminosity segment number bits from a 64-bits word
void	setLumiSegmentNrWord64 (cms_uint64_t &word64, const int iWord)
void	setNoAlgo (const cms_uint64_t &word64)
	set the NoAlgo from a 64-bits word
void	setNoAlgo (const cms_uint16_t &noAlgoValue)
void	setNoAlgoWord64 (cms_uint64_t &word64, const int iWord)
void	setOrbitNr (const cms_uint64_t &word64)
	set the orbit number bits from a 64-bits word
void	setOrbitNr (const cms_uint32_t &orbitNrValue)
void	setOrbitNrWord64 (cms_uint64_t &word64, const int iWord)
void	setPhysicsDeclared (const cms_uint16_t &physicsDeclaredValue)
void	setPhysicsDeclared (const cms_uint64_t &word64)
	set the "physics declared" bit from a 64-bits word
void	setPhysicsDeclaredWord64 (cms_uint64_t &word64, const int iWord)
void	unpack (const unsigned char *fdlPtr)
virtual	~L1GtFdlWord ()
	destructor
Private Attributes
cms_uint16_t	m_boardId
	board identifier
int	m_bxInEvent
	bunch cross in the GT event record
cms_uint16_t	m_bxNr
	bunch cross number of the actual bx
cms_uint32_t	m_eventNr
	event number since last L1 reset generated in FDL
cms_uint16_t	m_finalOR
DecisionWord	m_gtDecisionWord
	algorithm bits
DecisionWordExtended	m_gtDecisionWordExtended
	extended algorithm bits, in addition to 128
cms_uint16_t	m_gtPrescaleFactorIndexAlgo
cms_uint16_t	m_gtPrescaleFactorIndexTech
TechnicalTriggerWord	m_gtTechnicalTriggerWord
	technical trigger bits
cms_uint16_t	m_localBxNr
cms_uint16_t	m_lumiSegmentNr
	luminosity segment number
cms_uint16_t	m_noAlgo
	true if no algorithm (from a defined group - default all) triggered
cms_uint32_t	m_orbitNr
	orbit number
cms_uint16_t	m_physicsDeclared
	set to true when physics declared
Static Private Attributes
static const int	BlockSize = 7
static const cms_uint64_t	BoardIdMask = 0xFFFF000000000000ULL
static const int	BoardIdShift = 48
static const int	BoardIdWord = 0
static const cms_uint64_t	BxInEventMask = 0x0000F00000000000ULL
static const int	BxInEventShift = 44
static const int	BxInEventWord = 0
static const cms_uint64_t	BxNrMask = 0x00000FFF00000000ULL
static const int	BxNrShift = 32
static const int	BxNrWord = 0
static const cms_uint64_t	EventNrMask = 0x0000000000FFFFFFULL
static const int	EventNrShift = 0
static const int	EventNrWord = 0
static const cms_uint64_t	FinalORMask = 0x00000000000000FFULL
static const int	FinalORShift = 0
static const int	FinalORWord = 5
static const cms_uint64_t	GtDecisionWordAMask = 0xFFFFFFFFFFFFFFFFULL
static const int	GtDecisionWordAShift = 0
static const int	GtDecisionWordAWord = 2
static const cms_uint64_t	GtDecisionWordBMask = 0xFFFFFFFFFFFFFFFFULL
static const int	GtDecisionWordBShift = 0
static const int	GtDecisionWordBWord = 3
static const cms_uint64_t	GtDecisionWordExtendedMask = 0xFFFFFFFFFFFFFFFFULL
static const int	GtDecisionWordExtendedShift = 0
static const int	GtDecisionWordExtendedWord = 4
static const cms_uint64_t	GtPrescaleFactorIndexAlgoMask = 0x000000FF00000000ULL
static const int	GtPrescaleFactorIndexAlgoShift = 32
static const int	GtPrescaleFactorIndexAlgoWord = 5
static const cms_uint64_t	GtPrescaleFactorIndexTechMask = 0x00FF000000000000ULL
static const int	GtPrescaleFactorIndexTechShift = 48
static const int	GtPrescaleFactorIndexTechWord = 5
static const cms_uint64_t	GtTechnicalTriggerWordMask = 0xFFFFFFFFFFFFFFFFULL
static const int	GtTechnicalTriggerWordShift = 0
static const int	GtTechnicalTriggerWordWord = 1
static const cms_uint64_t	LocalBxNrMask = 0x0000000000000FFFULL
static const int	LocalBxNrShift = 0
static const int	LocalBxNrWord = 6
static const cms_uint64_t	LumiSegmentNrMask = 0x00000000FFFF0000ULL
static const int	LumiSegmentNrShift = 16
static const int	LumiSegmentNrWord = 6
static const cms_uint64_t	NoAlgoMask = 0x0000000000000100ULL
static const int	NoAlgoShift = 8
static const int	NoAlgoWord = 5
static const cms_uint64_t	OrbitNrMask = 0xFFFFFFFF00000000ULL
static const int	OrbitNrShift = 32
static const int	OrbitNrWord = 6
static const cms_uint64_t	PhysicsDeclaredMask = 0x8000000000000000ULL
static const int	PhysicsDeclaredShift = 63
static const int	PhysicsDeclaredWord = 5

Detailed Description

Description: L1 Global Trigger - FDL block in the readout record.

Implementation: <TODO: enter implementation details>

Author:: : Vasile Mihai Ghete - HEPHY Vienna

$Date$ $Revision$

Description: see header file.

Implementation: <TODO: enter implementation details>

Author:: : Vasile Mihai Ghete - HEPHY Vienna

$Date$ $Revision$

Definition at line 31 of file L1GtFdlWord.h.

Constructor & Destructor Documentation

L1GtFdlWord::L1GtFdlWord ( )

constructors

Definition at line 34 of file L1GtFdlWord.cc.

References m_boardId, m_bxInEvent, m_bxNr, m_eventNr, m_finalOR, m_gtDecisionWord, m_gtDecisionWordExtended, m_gtPrescaleFactorIndexAlgo, m_gtPrescaleFactorIndexTech, m_gtTechnicalTriggerWord, m_localBxNr, m_lumiSegmentNr, m_noAlgo, m_orbitNr, m_physicsDeclared, L1GlobalTriggerReadoutSetup::NumberPhysTriggers, L1GlobalTriggerReadoutSetup::NumberPhysTriggersExtended, and L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers.

{

    m_boardId = 0;
    m_bxInEvent = 0;
    m_bxNr = 0;
    m_eventNr = 0;

    // technical triggers std::vector<bool>
    m_gtTechnicalTriggerWord.reserve(
        L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers);
    m_gtTechnicalTriggerWord.assign(
        L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers, false);

    // decision word  std::vector<bool>
    m_gtDecisionWord.reserve(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggers);
    m_gtDecisionWord.assign(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggers, false);

    // extended decision word  std::vector<bool>
    m_gtDecisionWordExtended.reserve(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggersExtended);
    m_gtDecisionWordExtended.assign(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggersExtended, false);

    m_physicsDeclared = 0;
    m_gtPrescaleFactorIndexTech = 0;
    m_gtPrescaleFactorIndexAlgo = 0;

    m_noAlgo = 0;

    m_finalOR = 0;


    m_orbitNr = 0;
    m_lumiSegmentNr = 0;
    m_localBxNr = 0;

}

L1GtFdlWord::L1GtFdlWord	(	cms_uint16_t	boardIdValue,
		int	bxInEventValue,
		cms_uint16_t	bxNrValue,
		cms_uint32_t	eventNrValue,
		TechnicalTriggerWord	gtTechnicalTriggerWordValue,
		DecisionWord	gtDecisionWordValue,
		DecisionWordExtended	gtDecisionWordExtendedValue,
		cms_uint16_t	gtPrescaleFactorIndexTechValue,
		cms_uint16_t	gtPrescaleFactorIndexAlgoValue,
		cms_uint16_t	noAlgoValue,
		cms_uint16_t	finalORValue,
		cms_uint32_t	orbitNrValue,
		cms_uint16_t	lumiSegmentNrValue,
		cms_uint16_t	localBxNrValue
	)

Definition at line 76 of file L1GtFdlWord.cc.

References m_physicsDeclared.

                                     :
    m_boardId(boardIdValue), m_bxInEvent(bxInEventValue), m_bxNr(bxNrValue),
            m_eventNr(eventNrValue),
            m_gtTechnicalTriggerWord(gtTechnicalTriggerWordValue),
            m_gtDecisionWord(gtDecisionWordValue),
            m_gtDecisionWordExtended(gtDecisionWordExtendedValue),
            m_gtPrescaleFactorIndexTech(gtPrescaleFactorIndexTechValue),
            m_gtPrescaleFactorIndexAlgo(gtPrescaleFactorIndexAlgoValue),
            m_noAlgo(noAlgoValue), m_finalOR(finalORValue),
            m_orbitNr(orbitNrValue), m_lumiSegmentNr(lumiSegmentNrValue),
            m_localBxNr(localBxNrValue)

{
    m_physicsDeclared = 0;

    // the rest done in initialization list
}

L1GtFdlWord::~L1GtFdlWord ( ) [virtual]

destructor

Definition at line 104 of file L1GtFdlWord.cc.

{

    // empty now
}

Member Function Documentation

const cms_uint16_t L1GtFdlWord::boardId ( ) const [inline]

get/set board ID

get BoardId value

Definition at line 71 of file L1GtFdlWord.h.

References m_boardId.

Referenced by L1GtDataEmulAnalyzer::compareFDL(), and L1GtHwValidation::compareFDL().

    {
        return m_boardId;
    }

const int L1GtFdlWord::bxInEvent ( ) const [inline]

get/set bunch cross in the GT event record

Definition at line 92 of file L1GtFdlWord.h.

References m_bxInEvent.

Referenced by L1GtDataEmulAnalyzer::compareFDL(), and L1GtHwValidation::compareFDL().

    {
        return m_bxInEvent;
    }

const cms_uint16_t L1GtFdlWord::bxNr ( ) const [inline]

get/set BxNr - bunch cross number of the actual bx

Definition at line 112 of file L1GtFdlWord.h.

References m_bxNr.

Referenced by L1TGT::analyze(), L1GtDataEmulAnalyzer::compareFDL(), and L1GtHwValidation::compareFDL().

    {
        return m_bxNr;
    }

const cms_uint32_t L1GtFdlWord::eventNr ( ) const [inline]

get/set event number since last L1 reset generated in FDL

Definition at line 132 of file L1GtFdlWord.h.

References m_eventNr.

Referenced by L1GtDataEmulAnalyzer::compareFDL(), and L1GtHwValidation::compareFDL().

    {
        return m_eventNr;
    }

const cms_uint16_t L1GtFdlWord::finalOR ( ) const [inline]

get/set "Final OR" bits

Definition at line 308 of file L1GtFdlWord.h.

References m_finalOR.

Referenced by L1GtDataEmulAnalyzer::compareFDL(), and L1GtHwValidation::compareFDL().

    {
        return m_finalOR;
    }

const unsigned int L1GtFdlWord::getSize ( ) const [inline]

get the size of the FDL block in GT DAQ record (in multiple of 8 bits)

Definition at line 394 of file L1GtFdlWord.h.

References BlockSize, and L1GlobalTriggerReadoutSetup::UnitLength.

Referenced by L1GTEvmDigiToRaw::packFDL(), L1GTDigiToRaw::packFDL(), L1GTEvmDigiToRaw::produce(), L1GlobalTriggerEvmRawToDigi::produce(), L1GTDigiToRaw::produce(), and L1GlobalTriggerRawToDigi::produce().

    {
        int unitLengthBits = L1GlobalTriggerReadoutSetup::UnitLength;

        return BlockSize*unitLengthBits;
    }

const bool L1GtFdlWord::globalDecision ( ) const [inline]

Definition at line 327 of file L1GtFdlWord.h.

References m_finalOR.

    {
        return static_cast<bool> (m_finalOR);
    }

const DecisionWord& L1GtFdlWord::gtDecisionWord ( ) const [inline]

get/set/print algorithms bits (decision word)

Definition at line 173 of file L1GtFdlWord.h.

References m_gtDecisionWord.

Referenced by TrackerDpgAnalysis::analyze(), L1GtDataEmulAnalyzer::compareFDL(), L1GtHwValidation::compareFDL(), and HSCPTreeBuilder::filter().

    {
        return m_gtDecisionWord;
    }

const DecisionWordExtended& L1GtFdlWord::gtDecisionWordExtended ( ) const [inline]

get/set extended algorithms bits (extended decision word)

Definition at line 205 of file L1GtFdlWord.h.

References m_gtDecisionWordExtended.

Referenced by L1GtDataEmulAnalyzer::compareFDL(), L1GtHwValidation::compareFDL(), and HSCPTreeBuilder::filter().

    {
        return m_gtDecisionWordExtended;
    }

const cms_uint16_t L1GtFdlWord::gtPrescaleFactorIndexAlgo ( ) const [inline]

Definition at line 269 of file L1GtFdlWord.h.

References m_gtPrescaleFactorIndexAlgo.

Referenced by L1TGT::analyze(), and L1GtHwValidation::compareFDL().

    {
        return m_gtPrescaleFactorIndexAlgo;
    }

const cms_uint16_t L1GtFdlWord::gtPrescaleFactorIndexTech ( ) const [inline]

get/set index of the set of prescale factors

Definition at line 250 of file L1GtFdlWord.h.

References m_gtPrescaleFactorIndexTech.

    {
        return m_gtPrescaleFactorIndexTech;
    }

const TechnicalTriggerWord& L1GtFdlWord::gtTechnicalTriggerWord ( ) const [inline]

get/set technical trigger bits

Definition at line 151 of file L1GtFdlWord.h.

References m_gtTechnicalTriggerWord.

Referenced by L1GtDataEmulAnalyzer::compareFDL(), L1GtHwValidation::compareFDL(), and HSCPTreeBuilder::filter().

    {
        return m_gtTechnicalTriggerWord;
    }

const cms_uint16_t L1GtFdlWord::localBxNr ( ) const [inline]

get/set local bunch cross number of the actual bx

Definition at line 374 of file L1GtFdlWord.h.

References m_localBxNr.

Referenced by L1TGT::analyze(), L1GtDataEmulAnalyzer::compareFDL(), and L1GtHwValidation::compareFDL().

    {
        return m_localBxNr;
    }

const cms_uint16_t L1GtFdlWord::lumiSegmentNr ( ) const [inline]

get/set luminosity segment number of the actual bx

Definition at line 354 of file L1GtFdlWord.h.

References m_lumiSegmentNr.

Referenced by L1TGT::analyze(), L1GlobalTriggerEvmRawToDigi::produce(), and L1GlobalTriggerRawToDigi::produce().

    {
        return m_lumiSegmentNr;
    }

const cms_uint16_t L1GtFdlWord::noAlgo ( ) const [inline]

get/set NoAlgo

Definition at line 288 of file L1GtFdlWord.h.

References m_noAlgo.

Referenced by L1GtDataEmulAnalyzer::compareFDL(), and L1GtHwValidation::compareFDL().

    {
        return m_noAlgo;
    }

bool L1GtFdlWord::operator!= ( const L1GtFdlWord & result ) const

unequal operator

Definition at line 179 of file L1GtFdlWord.cc.

{

    return !( result == *this);

}

bool L1GtFdlWord::operator== ( const L1GtFdlWord & result ) const

equal operator

Definition at line 111 of file L1GtFdlWord.cc.

References m_boardId, m_bxInEvent, m_bxNr, m_eventNr, m_finalOR, m_gtDecisionWord, m_gtDecisionWordExtended, m_gtPrescaleFactorIndexAlgo, m_gtPrescaleFactorIndexTech, m_gtTechnicalTriggerWord, m_localBxNr, m_lumiSegmentNr, m_noAlgo, m_orbitNr, and m_physicsDeclared.

{

    if (m_boardId   != result.m_boardId) {
        return false;
    }

    if (m_bxInEvent != result.m_bxInEvent) {
        return false;
    }

    if (m_bxNr      != result.m_bxNr) {
        return false;
    }
    if (m_eventNr   != result.m_eventNr) {
        return false;
    }

    if (m_gtTechnicalTriggerWord != result.m_gtTechnicalTriggerWord) {
        return false;
    }

    if (m_gtDecisionWord         != result.m_gtDecisionWord) {
        return false;
    }

    if (m_gtDecisionWordExtended != result.m_gtDecisionWordExtended) {
        return false;
    }

    if (m_physicsDeclared != result.m_physicsDeclared) {
        return false;
    }

    if (m_gtPrescaleFactorIndexTech != result.m_gtPrescaleFactorIndexTech) {
        return false;
    }

    if (m_gtPrescaleFactorIndexAlgo != result.m_gtPrescaleFactorIndexAlgo) {
        return false;
    }

    if (m_noAlgo                != result.m_noAlgo) {
        return false;
    }

    if (m_finalOR               != result.m_finalOR) {
        return false;
    }

    if (m_orbitNr != result.m_orbitNr) {
        return false;
    }

    if (m_lumiSegmentNr != result.m_lumiSegmentNr) {
        return false;
    }

    if (m_localBxNr != result.m_localBxNr) {
        return false;
    }

    // all members identical
    return true;

}

const cms_uint32_t L1GtFdlWord::orbitNr ( ) const [inline]

get/set orbit number

Definition at line 334 of file L1GtFdlWord.h.

References m_orbitNr.

Referenced by L1TGT::analyze().

    {
        return m_orbitNr;
    }

const cms_uint16_t L1GtFdlWord::physicsDeclared ( ) const [inline]

get/set "physics declared" bit

Definition at line 229 of file L1GtFdlWord.h.

References m_physicsDeclared.

Referenced by PhysDecl::filter(), HLTPhysicsDeclared::filter(), DQMProvInfo::makeGtInfo(), DQMDcsInfo::makeGtInfo(), and pat::PATTriggerEventProducer::produce().

    {
        return m_physicsDeclared;
    }

void L1GtFdlWord::print ( std::ostream & myCout ) const

pretty print the content of a L1GtFdlWord

Definition at line 768 of file L1GtFdlWord.cc.

References m_boardId, m_bxInEvent, m_bxNr, m_eventNr, m_finalOR, m_gtPrescaleFactorIndexAlgo, m_gtPrescaleFactorIndexTech, m_localBxNr, m_lumiSegmentNr, m_noAlgo, m_orbitNr, m_physicsDeclared, printGtDecisionWord(), printGtDecisionWordExtended(), and printGtTechnicalTriggerWord().

Referenced by L1GtPackUnpackAnalyzer::analyzeGT(), L1GtDataEmulAnalyzer::compareFDL(), L1GtHwValidation::compareFDL(), L1GTEvmDigiToRaw::produce(), L1GlobalTriggerEvmRawToDigi::produce(), L1GTDigiToRaw::produce(), and L1GlobalTriggerRawToDigi::produce().

{

    myCout << "\n L1GtFdlWord::print \n" << std::endl;

    int iWord = 0;

    myCout << "\n Word " << iWord << std::endl;

    myCout << "  Board Id:         "
    << std::hex << " hex: " << "    " << std::setw(4) << std::setfill('0') << m_boardId
    << std::setfill(' ')
    << std::dec << " dec: " << m_boardId
    << std::endl;
    //

    int baseValue = 16; // using hexadecimal values;
    int hexBxInEvent = (m_bxInEvent + baseValue)%baseValue;

    myCout << "  BxInEvent:        "
    << std::hex << " hex: " << "       " << std::setw(1) << hexBxInEvent
    << std::dec << " dec: " << m_bxInEvent
    << std::endl;

    myCout << "  BxNr:             "
    << std::hex << " hex: "  << "     " << std::setw(3) << std::setfill('0') << m_bxNr
    << std::setfill(' ')
    << std::dec << " dec: " << m_bxNr
    << std::endl;


    myCout << "  EventNr:          "
    << std::hex << " hex: " << "  " << std::setw(6) << std::setfill('0') << m_eventNr
    << std::setfill(' ')
    << std::dec << " dec: " << m_eventNr
    << std::endl;

    // technical triggers

    iWord++;
    myCout << "\n Word " << iWord << std::endl;

    printGtTechnicalTriggerWord(myCout);
    myCout << std::endl;

    // physics triggers (2 words!)

    iWord++;
    myCout << "\n Word " << iWord;
    iWord++;
    myCout << " and word " << iWord;

    printGtDecisionWord(myCout);
    myCout << std::endl;

    // decision word extended (64 bits)

    iWord++;
    myCout << "\n Word " << iWord << std::endl;

    printGtDecisionWordExtended(myCout);
    myCout << std::endl;

    //
    iWord++;
    myCout << "\n Word " << iWord << std::endl;

    myCout << "  PhysicsDeclared:           "
    << std::hex << " hex: "  << "    " << std::setw(4) << std::setfill('0')
    << m_physicsDeclared
    << std::setfill(' ')
    << std::dec << " dec: " << m_physicsDeclared
    << std::endl;

    myCout << "  GtPrescaleFactorIndexTech: "
    << std::hex << " hex: "  << "    " << std::setw(4) << std::setfill('0')
    << m_gtPrescaleFactorIndexTech
    << std::setfill(' ')
    << std::dec << " dec: " << m_gtPrescaleFactorIndexTech
    << std::endl;

    myCout << "  GtPrescaleFactorIndexAlgo: "
    << std::hex << " hex: "  << "    " << std::setw(4) << std::setfill('0')
    << m_gtPrescaleFactorIndexAlgo
    << std::setfill(' ')
    << std::dec << " dec: " << m_gtPrescaleFactorIndexAlgo
    << std::endl;

    myCout << "  NoAlgo:                    "
    << std::hex << " hex: "  << "       " << std::setw(1) << std::setfill('0') << m_noAlgo
    << std::setfill(' ')
    << std::dec << " dec: " << m_noAlgo
    << std::endl;

    myCout << "  FinalOR:                   "
    << std::hex << " hex: "  << "      " << std::setw(2) << std::setfill('0') << m_finalOR
    << std::setfill(' ')
    << std::dec << " dec: " << m_finalOR
    << std::endl;

    iWord++;
    myCout << "\n Word " << iWord << std::endl;

    myCout << "  OrbitNr:          "
    << std::hex << " hex: "  << "" << std::setw(8) << std::setfill('0') << m_orbitNr
    << std::setfill(' ')
    << std::dec << " dec: " << m_orbitNr
    << std::endl;

    myCout << "  LumiSegmentNr:    "
    << std::hex << " hex: "  << "    " << std::setw(4) << std::setfill('0') << m_lumiSegmentNr
    << std::setfill(' ')
    << std::dec << " dec: " << m_lumiSegmentNr
    << std::endl;

    myCout << "  LocalBxNr:        "
    << std::hex << " hex: "  << "     " << std::setw(3) << std::setfill('0') << m_localBxNr
    << std::setfill(' ')
    << std::dec << " dec: " << m_localBxNr
    << std::endl;

}

void L1GtFdlWord::printGtDecisionWord ( std::ostream & myCout ) const

Definition at line 347 of file L1GtFdlWord.cc.

References m_gtDecisionWord.

Referenced by L1GtDataEmulAnalyzer::compareFDL(), L1GtHwValidation::compareFDL(), and print().

{

    // decision word (in 64bits words)
    int sizeW64 = 64; // 64 bits words

    int iBit = 0;
    int jBit = m_gtDecisionWord.size();
    int nrDecWord = m_gtDecisionWord.size()/sizeW64;

    std::ostringstream stream64;

    std::vector<std::string> decWord;
    decWord.reserve(nrDecWord);

    for (std::vector<bool>::const_reverse_iterator ritBit = m_gtDecisionWord.rbegin();
            ritBit != m_gtDecisionWord.rend(); ++ritBit) {

        stream64 << (*ritBit ? '1' : '0');

        if ( (((iBit + 1)%16) == (sizeW64%16)) ) {
            stream64  << " ";
        }

        if ( ((iBit + 1)%sizeW64) == 0) {
            std::string iW = stream64.str();
            stream64.str("");

            decWord.push_back(iW);
        }


        iBit++;
        jBit--;
    }

    int iWord = 0;

    for (std::vector<std::string>::reverse_iterator ritWord = decWord.rbegin();
            ritWord != decWord.rend(); ++ritWord) {

        myCout << std::endl;
        myCout << "  DecisionWord (bitset style): bits "
        << iWord*sizeW64 + sizeW64 - 1 << " : " << iWord*sizeW64 << "\n  ";
        myCout << *ritWord;

        iWord++;

    }
}

void L1GtFdlWord::printGtDecisionWordExtended ( std::ostream & myCout ) const

Definition at line 505 of file L1GtFdlWord.cc.

References m_gtDecisionWordExtended.

Referenced by L1GtDataEmulAnalyzer::compareFDL(), L1GtHwValidation::compareFDL(), and print().

{

    myCout << "  DecisionWordExtended (bitset style):    \n  " ;

    int sizeW64 = 64; // 64 bits words
    int iBit = 0;

    for (std::vector<bool>::const_reverse_iterator ritBit = m_gtDecisionWordExtended.rbegin();
            ritBit != m_gtDecisionWordExtended.rend(); ++ritBit) {

        myCout << (*ritBit ? '1' : '0');

        if ( (((iBit + 1)%16) == (sizeW64%16)) && (iBit != 63) ) {
            myCout << " ";
        }

        iBit++;

    }

}

void L1GtFdlWord::printGtTechnicalTriggerWord ( std::ostream & myCout ) const

Definition at line 273 of file L1GtFdlWord.cc.

References m_gtTechnicalTriggerWord.

Referenced by L1GtDataEmulAnalyzer::compareFDL(), L1GtHwValidation::compareFDL(), and print().

{

    myCout << "  Technical triggers (bitset style):    \n  " ;

    int sizeW64 = 64; // 64 bits words
    int iBit = 0;

    for (std::vector<bool>::const_reverse_iterator ritBit = m_gtTechnicalTriggerWord.rbegin();
            ritBit != m_gtTechnicalTriggerWord.rend(); ++ritBit) {

        myCout << (*ritBit ? '1' : '0');

        if ( (((iBit + 1)%16) == (sizeW64%16)) && (iBit != 63) ) {
            myCout << " ";
        }

        iBit++;
    }


}

void L1GtFdlWord::reset ( void )

reset the content of a L1GtFdlWord

Definition at line 734 of file L1GtFdlWord.cc.

References m_boardId, m_bxInEvent, m_bxNr, m_eventNr, m_finalOR, m_gtDecisionWord, m_gtDecisionWordExtended, m_gtPrescaleFactorIndexAlgo, m_gtPrescaleFactorIndexTech, m_gtTechnicalTriggerWord, m_localBxNr, m_lumiSegmentNr, m_noAlgo, m_orbitNr, m_physicsDeclared, L1GlobalTriggerReadoutSetup::NumberPhysTriggers, L1GlobalTriggerReadoutSetup::NumberPhysTriggersExtended, and L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers.

Referenced by L1GlobalTriggerEvmRawToDigi::produce(), L1GlobalTriggerRawToDigi::produce(), and L1GlobalTriggerFDL::reset().

{

    m_boardId = 0;
    m_bxInEvent = 0;
    m_bxNr = 0;
    m_eventNr = 0;

    // technical triggers std::vector<bool>
    m_gtTechnicalTriggerWord.assign(
        L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers, false);

    // decision word  std::vector<bool>
    m_gtDecisionWord.assign(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggers, false);

    // extended decision word  std::vector<bool>
    m_gtDecisionWordExtended.assign(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggersExtended, false);

    m_physicsDeclared = 0;
    m_gtPrescaleFactorIndexTech = 0;
    m_gtPrescaleFactorIndexAlgo = 0;

    m_noAlgo = 0;
    m_finalOR = 0;

    m_orbitNr = 0;
    m_lumiSegmentNr = 0;
    m_localBxNr = 0;

}

void L1GtFdlWord::setBoardId ( const cms_uint16_t & boardIdValue ) [inline]

set BoardId from a BoardId value

Definition at line 77 of file L1GtFdlWord.h.

References m_boardId.

Referenced by L1GlobalTriggerFDL::run(), and unpack().

    {
        m_boardId = boardIdValue;
    }

void L1GtFdlWord::setBoardId ( const cms_uint64_t & word64 )

set the BoardId value from a 64-bits word

Definition at line 190 of file L1GtFdlWord.cc.

References BoardIdMask, BoardIdShift, and m_boardId.

{
    m_boardId = (word64 & BoardIdMask) >> BoardIdShift;

}

void L1GtFdlWord::setBoardIdWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the BoardId value in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 198 of file L1GtFdlWord.cc.

References BoardIdShift, BoardIdWord, and m_boardId.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == BoardIdWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_boardId) << BoardIdShift);
    }

}

void L1GtFdlWord::setBxInEvent ( const int bxInEventValue ) [inline]

Definition at line 97 of file L1GtFdlWord.h.

References m_bxInEvent.

Referenced by L1GlobalTriggerFDL::run(), and unpack().

    {
        m_bxInEvent = bxInEventValue;
    }

void L1GtFdlWord::setBxInEvent ( const cms_uint64_t & word64 )

set the BxInEvent value from a 64-bits word

Definition at line 209 of file L1GtFdlWord.cc.

References BxInEventMask, BxInEventShift, and m_bxInEvent.

{
    int baseValue = 16; // using hexadecimal values;
    int hexBxInEvent = (word64 & BxInEventMask) >> BxInEventShift;
    m_bxInEvent = (hexBxInEvent + baseValue/2)%baseValue - baseValue/2;

}

void L1GtFdlWord::setBxInEventWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the BxInEvent value in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 219 of file L1GtFdlWord.cc.

References BxInEventShift, BxInEventWord, and m_bxInEvent.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == BxInEventWord) {
        int baseValue = 16; // using hexadecimal values;
        int hexBxInEvent = (m_bxInEvent + baseValue)%baseValue;
        word64 = word64 | (static_cast<cms_uint64_t> (hexBxInEvent)
                           << BxInEventShift);
    }

}

void L1GtFdlWord::setBxNr ( const cms_uint16_t & bxNrValue ) [inline]

Definition at line 117 of file L1GtFdlWord.h.

References m_bxNr.

Referenced by L1GlobalTriggerFDL::run(), and unpack().

    {
        m_bxNr = bxNrValue;
    }

void L1GtFdlWord::setBxNr ( const cms_uint64_t & word64 )

set the BxNr value from a 64-bits word

Definition at line 233 of file L1GtFdlWord.cc.

References BxNrMask, BxNrShift, and m_bxNr.

{
    m_bxNr = (word64 & BxNrMask) >> BxNrShift;

}

void L1GtFdlWord::setBxNrWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the BxNr value in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 241 of file L1GtFdlWord.cc.

References BxNrShift, BxNrWord, and m_bxNr.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == BxNrWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_bxNr) << BxNrShift);
    }

}

void L1GtFdlWord::setEventNr ( const cms_uint32_t & eventNrValue ) [inline]

Definition at line 137 of file L1GtFdlWord.h.

References m_eventNr.

Referenced by L1GlobalTriggerFDL::run(), and unpack().

    {
        m_eventNr = eventNrValue;
    }

void L1GtFdlWord::setEventNr ( const cms_uint64_t & word64 )

set the EventNr value from a 64-bits word

Definition at line 252 of file L1GtFdlWord.cc.

References EventNrMask, EventNrShift, and m_eventNr.

{
    m_eventNr = (word64 & EventNrMask) >> EventNrShift;

}

void L1GtFdlWord::setEventNrWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the EventNr value in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 260 of file L1GtFdlWord.cc.

References EventNrShift, EventNrWord, and m_eventNr.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == EventNrWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_eventNr) << EventNrShift);
    }

}

void L1GtFdlWord::setFinalOR ( const cms_uint16_t & finalORValue ) [inline]

Definition at line 313 of file L1GtFdlWord.h.

References m_finalOR.

Referenced by L1GlobalTriggerFDL::run(), and unpack().

    {
        m_finalOR = finalORValue;
    }

void L1GtFdlWord::setFinalOR ( const cms_uint64_t & word64 )

set the "Final OR" bits from a 64-bits word

Definition at line 658 of file L1GtFdlWord.cc.

References FinalORMask, FinalORShift, and m_finalOR.

{
    m_finalOR = (word64 & FinalORMask) >> FinalORShift;

}

void L1GtFdlWord::setFinalORWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the "Final OR" bits in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 666 of file L1GtFdlWord.cc.

References FinalORShift, FinalORWord, and m_finalOR.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == FinalORWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_finalOR)
                           << FinalORShift);
    }

}

void L1GtFdlWord::setGtDecisionWord ( const DecisionWord & gtDecisionWordValue ) [inline]

Definition at line 178 of file L1GtFdlWord.h.

References m_gtDecisionWord.

Referenced by L1GlobalTriggerFDL::run().

    {
        m_gtDecisionWord = gtDecisionWordValue;
    }

void L1GtFdlWord::setGtDecisionWordA ( const cms_uint64_t & word64 )

set the algorithms bits from two 64-bits words WordA: bits 0-63

Definition at line 400 of file L1GtFdlWord.cc.

References GtDecisionWordAMask, GtDecisionWordAShift, and m_gtDecisionWord.

Referenced by unpack().

{

    int word64Size = sizeof(word64)*8; // well, it should be 64, if not...  :-)
    cms_uint64_t wordA = (word64 & GtDecisionWordAMask) >> GtDecisionWordAShift;

    cms_uint64_t one64 = 1ULL;

    for (int iBit = 0; iBit < word64Size; ++iBit) {
        m_gtDecisionWord.at(iBit) = wordA & (one64 << iBit);
    }

}

void L1GtFdlWord::setGtDecisionWordAWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the algorithms bits in two 64-bits word, having the first index iWord in the GTFE raw record WordA: bits 0-63

Definition at line 437 of file L1GtFdlWord.cc.

References GtDecisionWordAShift, GtDecisionWordAWord, and m_gtDecisionWord.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == GtDecisionWordAWord) {

        int word64Size = sizeof(word64)*8;
        cms_uint64_t wordA = 0x0000000000000000ULL;

        int iBit = 0;
        cms_uint64_t iDecision = 0ULL;

        for (std::vector<bool>::const_iterator itBit = m_gtDecisionWord.begin();
                itBit != m_gtDecisionWord.end(); ++itBit) {

            iDecision = static_cast<cms_uint64_t> (*itBit);//(*itBit ? 1 : 0);
            wordA = wordA | (iDecision << iBit);

            iBit++;
            if (iBit >= word64Size) {
                break;
            }

        }

        word64 = word64 | (wordA << GtDecisionWordAShift);

    }

}

void L1GtFdlWord::setGtDecisionWordB ( const cms_uint64_t & word64 )

set the algorithms bits from two 64-bits words WordB: bits 64-128

Definition at line 416 of file L1GtFdlWord.cc.

References GtDecisionWordBMask, GtDecisionWordBShift, and m_gtDecisionWord.

Referenced by unpack().

{

    int word64Size = sizeof(word64)*8;
    cms_uint64_t wordB = (word64 & GtDecisionWordBMask) >> GtDecisionWordBShift;

    cms_uint64_t one64 = 1ULL;

    for (int iBit = 0; iBit < word64Size; ++iBit) {
        m_gtDecisionWord.at(iBit + word64Size) = wordB & (one64 << iBit);

    }

}

void L1GtFdlWord::setGtDecisionWordBWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the algorithms bits in two 64-bits word, having the first index iWord in the GTFE raw record WordB: bits 64-128

Definition at line 473 of file L1GtFdlWord.cc.

References GtDecisionWordBShift, GtDecisionWordBWord, and m_gtDecisionWord.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == GtDecisionWordBWord) {

        int word64Size = sizeof(word64)*8;
        cms_uint64_t wordB = 0x0000000000000000ULL;

        int iBit = 0;
        cms_uint64_t iDecision = 0ULL;

        for (std::vector<bool>::const_iterator itBit = m_gtDecisionWord.begin();
                itBit != m_gtDecisionWord.end(); ++itBit) {

            if (iBit >= word64Size) {
                // skip first word64Size bits, they go in wordA
                iDecision = static_cast<cms_uint64_t> (*itBit);//(*itBit ? 1 : 0);
                wordB = wordB | ( iDecision << (iBit - word64Size) );
            }

            iBit++;

        }

        word64 = word64 | (wordB << GtDecisionWordBShift);
    }

}

void L1GtFdlWord::setGtDecisionWordExtended ( const cms_uint64_t & word64 )

set the extended algorithms bits from a 64-bits word

Definition at line 529 of file L1GtFdlWord.cc.

References GtDecisionWordExtendedMask, GtDecisionWordExtendedShift, and m_gtDecisionWordExtended.

{

    int word64Size = sizeof(word64)*8;
    cms_uint64_t wordE = (word64 & GtDecisionWordExtendedMask)
                            >> GtDecisionWordExtendedShift;

    cms_uint64_t one64 = 1ULL;

    for (int iBit = 0; iBit < word64Size; ++iBit) {
        m_gtDecisionWordExtended.at(iBit) = wordE & (one64 << iBit);
    }


}

void L1GtFdlWord::setGtDecisionWordExtended ( const DecisionWordExtended & gtDecisionWordExtendedValue ) [inline]

Definition at line 210 of file L1GtFdlWord.h.

References m_gtDecisionWordExtended.

Referenced by unpack().

    {
        m_gtDecisionWordExtended = gtDecisionWordExtendedValue;
    }

void L1GtFdlWord::setGtDecisionWordExtendedWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the extended algorithms bits in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 547 of file L1GtFdlWord.cc.

References GtDecisionWordExtendedShift, GtDecisionWordExtendedWord, and m_gtDecisionWordExtended.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == GtDecisionWordExtendedWord) {

        int word64Size = sizeof(word64)*8;
        cms_uint64_t wordE = 0x0000000000000000ULL;

        int iBit = 0;
        cms_uint64_t iDecision = 0ULL;

        for (std::vector<bool>::const_iterator itBit = m_gtDecisionWordExtended.begin();
                itBit != m_gtDecisionWordExtended.end(); ++itBit) {

            iDecision = static_cast<cms_uint64_t> (*itBit);//(*itBit ? 1 : 0);
            wordE = wordE | (iDecision << iBit);

            iBit++;
            if (iBit >= word64Size) {
                break;
            }

        }

        word64 = word64 | (wordE << GtDecisionWordExtendedShift);

    }

}

void L1GtFdlWord::setGtPrescaleFactorIndexAlgo ( const cms_uint16_t & gtPrescaleFactorIndexAlgoValue ) [inline]

Definition at line 274 of file L1GtFdlWord.h.

References m_gtPrescaleFactorIndexAlgo.

Referenced by L1GlobalTriggerFDL::run(), and unpack().

    {
        m_gtPrescaleFactorIndexAlgo = gtPrescaleFactorIndexAlgoValue;
    }

void L1GtFdlWord::setGtPrescaleFactorIndexAlgo ( const cms_uint64_t & word64 )

set the GtPrescaleFactorIndexAlgo from a 64-bits word

Definition at line 618 of file L1GtFdlWord.cc.

References GtPrescaleFactorIndexAlgoMask, GtPrescaleFactorIndexAlgoShift, and m_gtPrescaleFactorIndexAlgo.

                                                                         {
    m_gtPrescaleFactorIndexAlgo = (word64 & GtPrescaleFactorIndexAlgoMask)
            >> GtPrescaleFactorIndexAlgoShift;
}

void L1GtFdlWord::setGtPrescaleFactorIndexAlgoWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the GtPrescaleFactorIndexAlgo bits in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 625 of file L1GtFdlWord.cc.

References GtPrescaleFactorIndexAlgoShift, GtPrescaleFactorIndexAlgoWord, and m_gtPrescaleFactorIndexAlgo.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

                         {

    if (iWord == GtPrescaleFactorIndexAlgoWord) {
        word64 = word64
                | (static_cast<cms_uint64_t> (m_gtPrescaleFactorIndexAlgo)
                        << GtPrescaleFactorIndexAlgoShift);
    }

}

void L1GtFdlWord::setGtPrescaleFactorIndexTech ( const cms_uint16_t & gtPrescaleFactorIndexTechValue ) [inline]

Definition at line 255 of file L1GtFdlWord.h.

References m_gtPrescaleFactorIndexTech.

Referenced by L1GlobalTriggerFDL::run(), and unpack().

    {
        m_gtPrescaleFactorIndexTech = gtPrescaleFactorIndexTechValue;
    }

void L1GtFdlWord::setGtPrescaleFactorIndexTech ( const cms_uint64_t & word64 )

set the GtPrescaleFactorIndexTech from a 64-bits word

Definition at line 598 of file L1GtFdlWord.cc.

References GtPrescaleFactorIndexTechMask, GtPrescaleFactorIndexTechShift, and m_gtPrescaleFactorIndexTech.

                                                                         {
    m_gtPrescaleFactorIndexTech = (word64 & GtPrescaleFactorIndexTechMask)
            >> GtPrescaleFactorIndexTechShift;
}

void L1GtFdlWord::setGtPrescaleFactorIndexTechWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the GtPrescaleFactorIndexTech bits in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 605 of file L1GtFdlWord.cc.

References GtPrescaleFactorIndexTechShift, GtPrescaleFactorIndexTechWord, and m_gtPrescaleFactorIndexTech.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

                         {

    if (iWord == GtPrescaleFactorIndexTechWord) {
        word64 = word64
                | (static_cast<cms_uint64_t> (m_gtPrescaleFactorIndexTech)
                        << GtPrescaleFactorIndexTechShift);
    }

}

void L1GtFdlWord::setGtTechnicalTriggerWord ( const cms_uint64_t & word64 )

set the technical trigger bits from a 64-bits word

Definition at line 297 of file L1GtFdlWord.cc.

References GtTechnicalTriggerWordMask, GtTechnicalTriggerWordShift, and m_gtTechnicalTriggerWord.

{

    int word64Size = sizeof(word64)*8;
    cms_uint64_t wordTT = (word64 & GtTechnicalTriggerWordMask)
                             >> GtTechnicalTriggerWordShift;

    cms_uint64_t one64 = 1ULL;
    for (int iBit = 0; iBit < word64Size; ++iBit) {
        m_gtTechnicalTriggerWord.at(iBit) = wordTT & (one64 << iBit);
    }

}

void L1GtFdlWord::setGtTechnicalTriggerWord ( const TechnicalTriggerWord & gtTechnicalTriggerWordValue ) [inline]

Definition at line 156 of file L1GtFdlWord.h.

References m_gtTechnicalTriggerWord.

Referenced by L1GlobalTriggerFDL::run(), and unpack().

    {
        m_gtTechnicalTriggerWord = gtTechnicalTriggerWordValue;
    }

void L1GtFdlWord::setGtTechnicalTriggerWordWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the technical trigger bits in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 313 of file L1GtFdlWord.cc.

References GtTechnicalTriggerWordShift, GtTechnicalTriggerWordWord, and m_gtTechnicalTriggerWord.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == GtTechnicalTriggerWordWord) {

        int word64Size = sizeof(word64)*8;
        cms_uint64_t wordTT = 0x0000000000000000ULL;

        int iBit = 0;
        cms_uint64_t iDecision = 0ULL;

        for (std::vector<bool>::const_iterator itBit = m_gtTechnicalTriggerWord.begin();
                itBit != m_gtTechnicalTriggerWord.end(); ++itBit) {

            iDecision = static_cast<cms_uint64_t> (*itBit);//(*itBit ? 1 : 0);
            wordTT = wordTT | (iDecision << iBit);

            iBit++;
            if (iBit >= word64Size) {
                break;
            }

        }

        word64 = word64 | (wordTT << GtTechnicalTriggerWordShift);

    }

}

void L1GtFdlWord::setLocalBxNr ( const cms_uint64_t & word64 )

set the local bunch cross number bits from a 64-bits word

Definition at line 714 of file L1GtFdlWord.cc.

References LocalBxNrMask, LocalBxNrShift, and m_localBxNr.

{
    m_localBxNr = (word64 & LocalBxNrMask) >> LocalBxNrShift;
}

void L1GtFdlWord::setLocalBxNr ( const cms_uint16_t & localBxNrValue ) [inline]

Definition at line 379 of file L1GtFdlWord.h.

References m_localBxNr.

Referenced by L1GlobalTriggerFDL::run(), and unpack().

    {
        m_localBxNr = localBxNrValue;
    }

void L1GtFdlWord::setLocalBxNrWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the local bunch cross number bits in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 721 of file L1GtFdlWord.cc.

References LocalBxNrShift, LocalBxNrWord, and m_localBxNr.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == LocalBxNrWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_localBxNr)
                           << LocalBxNrShift);
    }

}

void L1GtFdlWord::setLumiSegmentNr ( const cms_uint64_t & word64 )

set the luminosity segment number bits from a 64-bits word

Definition at line 696 of file L1GtFdlWord.cc.

References LumiSegmentNrMask, LumiSegmentNrShift, and m_lumiSegmentNr.

                                                             {
    m_lumiSegmentNr = (word64 & LumiSegmentNrMask) >> LumiSegmentNrShift;
}

void L1GtFdlWord::setLumiSegmentNr ( const cms_uint16_t & lumiSegmentNrValue ) [inline]

Definition at line 359 of file L1GtFdlWord.h.

References m_lumiSegmentNr.

Referenced by L1GlobalTriggerEvmRawToDigi::produce(), L1GlobalTriggerRawToDigi::produce(), L1GlobalTriggerFDL::run(), and unpack().

    {
        m_lumiSegmentNr = lumiSegmentNrValue;
    }

void L1GtFdlWord::setLumiSegmentNrWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the luminosity segment number bits in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 702 of file L1GtFdlWord.cc.

References LumiSegmentNrShift, LumiSegmentNrWord, and m_lumiSegmentNr.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

                         {

    if (iWord == LumiSegmentNrWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_lumiSegmentNr)
                << LumiSegmentNrShift);
    }

}

void L1GtFdlWord::setNoAlgo ( const cms_uint64_t & word64 )

set the NoAlgo from a 64-bits word

Definition at line 637 of file L1GtFdlWord.cc.

References m_noAlgo, NoAlgoMask, and NoAlgoShift.

{
    m_noAlgo = (word64 & NoAlgoMask) >> NoAlgoShift;
}

void L1GtFdlWord::setNoAlgo ( const cms_uint16_t & noAlgoValue ) [inline]

Definition at line 293 of file L1GtFdlWord.h.

References m_noAlgo.

Referenced by unpack().

    {
        m_noAlgo = noAlgoValue;
    }

void L1GtFdlWord::setNoAlgoWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the NoAlgo bits in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 644 of file L1GtFdlWord.cc.

References m_noAlgo, NoAlgoShift, and NoAlgoWord.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == NoAlgoWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_noAlgo)
                           << NoAlgoShift);
    }

}

void L1GtFdlWord::setOrbitNr ( const cms_uint64_t & word64 )

set the orbit number bits from a 64-bits word

Definition at line 678 of file L1GtFdlWord.cc.

References m_orbitNr, OrbitNrMask, and OrbitNrShift.

                                                       {
    m_orbitNr = (word64 & OrbitNrMask) >> OrbitNrShift;
}

void L1GtFdlWord::setOrbitNr ( const cms_uint32_t & orbitNrValue ) [inline]

Definition at line 339 of file L1GtFdlWord.h.

References m_orbitNr.

Referenced by L1GlobalTriggerFDL::run(), and unpack().

    {
        m_orbitNr = orbitNrValue;
    }

void L1GtFdlWord::setOrbitNrWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the orbit number bits in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 684 of file L1GtFdlWord.cc.

References m_orbitNr, OrbitNrShift, and OrbitNrWord.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

                                                                        {

    if (iWord == OrbitNrWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_orbitNr)
                << OrbitNrShift);
    }

}

void L1GtFdlWord::setPhysicsDeclared ( const cms_uint16_t & physicsDeclaredValue ) [inline]

Definition at line 234 of file L1GtFdlWord.h.

References m_physicsDeclared.

Referenced by unpack().

    {
        m_physicsDeclared = physicsDeclaredValue;
    }

void L1GtFdlWord::setPhysicsDeclared ( const cms_uint64_t & word64 )

set the "physics declared" bit from a 64-bits word

Definition at line 579 of file L1GtFdlWord.cc.

References m_physicsDeclared, PhysicsDeclaredMask, and PhysicsDeclaredShift.

{
    m_physicsDeclared = (word64 & PhysicsDeclaredMask) >> PhysicsDeclaredShift;
}

void L1GtFdlWord::setPhysicsDeclaredWord64	(	cms_uint64_t &	word64,
		const int	iWord
	)

set the "physics declared" bit bits in a 64-bits word, having the index iWord in the GTFE raw record

Definition at line 586 of file L1GtFdlWord.cc.

References m_physicsDeclared, PhysicsDeclaredShift, and PhysicsDeclaredWord.

Referenced by L1GTEvmDigiToRaw::packFDL(), and L1GTDigiToRaw::packFDL().

{

    if (iWord == PhysicsDeclaredWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_physicsDeclared)
                           << PhysicsDeclaredShift);
    }

}

void L1GtFdlWord::unpack ( const unsigned char * fdlPtr )

unpack FDL fdlPtr pointer to the beginning of the FDL block in the raw data

Definition at line 893 of file L1GtFdlWord.cc.

References BlockSize, BoardIdWord, BxInEventWord, BxNrWord, EventNrWord, FinalORWord, GtDecisionWordAWord, GtDecisionWordBWord, GtDecisionWordExtendedWord, GtPrescaleFactorIndexAlgoWord, GtPrescaleFactorIndexTechWord, GtTechnicalTriggerWordWord, edm::isDebugEnabled(), LocalBxNrWord, LogDebug, LogTrace, LumiSegmentNrWord, NoAlgoWord, OrbitNrWord, PhysicsDeclaredWord, setBoardId(), setBxInEvent(), setBxNr(), setEventNr(), setFinalOR(), setGtDecisionWordA(), setGtDecisionWordB(), setGtDecisionWordExtended(), setGtPrescaleFactorIndexAlgo(), setGtPrescaleFactorIndexTech(), setGtTechnicalTriggerWord(), setLocalBxNr(), setLumiSegmentNr(), setNoAlgo(), setOrbitNr(), and setPhysicsDeclared().

Referenced by L1GlobalTriggerEvmRawToDigi::produce(), and L1GlobalTriggerRawToDigi::produce().

{
    LogDebug("L1GtFdlWord")
    << "\nUnpacking FDL block.\n"
    << std::endl;

    const cms_uint64_t* payload =
        reinterpret_cast<cms_uint64_t*>(const_cast<unsigned char*>(fdlPtr));

    setBoardId(payload[BoardIdWord]);
    setBxInEvent(payload[BxInEventWord]);
    setBxNr(payload[BxNrWord]);
    setEventNr(payload[EventNrWord]);

    setGtTechnicalTriggerWord(payload[GtTechnicalTriggerWordWord]);

    setGtDecisionWordA(payload[GtDecisionWordAWord]);

    setGtDecisionWordB(payload[GtDecisionWordBWord]);

    setGtDecisionWordExtended(payload[GtDecisionWordExtendedWord]);

    setPhysicsDeclared(payload[PhysicsDeclaredWord]);
    setGtPrescaleFactorIndexTech(payload[GtPrescaleFactorIndexTechWord]);
    setGtPrescaleFactorIndexAlgo(payload[GtPrescaleFactorIndexAlgoWord]);
    setNoAlgo(payload[NoAlgoWord]);
    setFinalOR(payload[FinalORWord]);

    setOrbitNr(payload[OrbitNrWord]);
    setLumiSegmentNr(payload[LumiSegmentNrWord]);
    setLocalBxNr(payload[LocalBxNrWord]);

    if ( edm::isDebugEnabled() ) {

        for (int iWord = 0; iWord < BlockSize; ++iWord) {
            LogTrace("L1GtFdlWord")
            << std::setw(4) << iWord << "  "
            << std::hex << std::setfill('0')
            << std::setw(16) << payload[iWord]
            << std::dec << std::setfill(' ')
            << std::endl;
        }

    }

}