#include <L1GtTriggerMenuLite.h>

Public Types
typedef L1TriggerMap::const_iterator	CItL1Trig
	iterators through map containing the physics algorithms or the technical triggers More...

typedef L1TriggerMap::iterator	ItL1Trig

typedef std::map< unsigned int, std::string >	L1TriggerMap
	map containing the physics algorithms or the technical triggers More...

Public Member Functions
const std::string *	gtAlgorithmAlias (const unsigned int bitNumber, int &errorCode) const
	get the alias for a physics algorithm with a given bit number More...

const L1TriggerMap &	gtAlgorithmAliasMap () const
	get / set the algorithm map (by alias) More...

const L1TriggerMap &	gtAlgorithmMap () const
	get / set the algorithm map (by name) More...

const std::string *	gtAlgorithmName (const unsigned int bitNumber, int &errorCode) const

const unsigned int	gtBitNumber (const std::string &trigName, int &errorCode) const

const std::vector< std::vector< int > > &	gtPrescaleFactorsAlgoTrig () const
	get the prescale factors by reference / set the prescale factors More...

const std::vector< std::vector< int > > &	gtPrescaleFactorsTechTrig () const

const std::string &	gtScaleDbKey () const
	menu associated scale key More...

const L1TriggerMap &	gtTechnicalTriggerMap () const
	get / set the technical trigger map More...

const std::string *	gtTechTrigName (const unsigned int bitNumber, int &errorCode) const

const std::vector< unsigned int > &	gtTriggerMaskAlgoTrig () const
	get the trigger mask for physics algorithms More...

const std::vector< unsigned int > &	gtTriggerMaskTechTrig () const
	get the trigger mask for technical triggers More...

const std::string &	gtTriggerMenuImplementation () const

const std::string &	gtTriggerMenuInterface () const
	get / set the trigger menu names More...

const std::string &	gtTriggerMenuName () const

const bool	gtTriggerResult (const std::string &trigName, const std::vector< bool > &decWord, int &errorCode) const

bool	isProductEqual (const L1GtTriggerMenuLite &) const
	merge rule: test on isProductEqual More...

	L1GtTriggerMenuLite ()
	constructor More...

	L1GtTriggerMenuLite (const std::string &, const L1TriggerMap &, const L1TriggerMap &, const L1TriggerMap &, const std::vector< unsigned int > &, const std::vector< unsigned int > &, const std::vector< std::vector< int > > &, const std::vector< std::vector< int > > &)

	L1GtTriggerMenuLite (const L1GtTriggerMenuLite &)
	copy constructor More...

bool	operator!= (const L1GtTriggerMenuLite &) const
	unequal operator More...

L1GtTriggerMenuLite &	operator= (const L1GtTriggerMenuLite &)
	assignment operator More...

bool	operator== (const L1GtTriggerMenuLite &) const
	equal operator More...

void	print (std::ostream &, int &) const

void	setGtAlgorithmAliasMap (const L1TriggerMap &)

void	setGtAlgorithmMap (const L1TriggerMap &)

void	setGtPrescaleFactorsAlgoTrig (const std::vector< std::vector< int > > &)

void	setGtPrescaleFactorsTechTrig (const std::vector< std::vector< int > > &)

void	setGtScaleDbKey (const std::string &)

void	setGtTechnicalTriggerMap (const L1TriggerMap &)

void	setGtTriggerMaskAlgoTrig (const std::vector< unsigned int > &)
	set the trigger mask for physics algorithms More...

void	setGtTriggerMaskTechTrig (const std::vector< unsigned int > &)
	set the trigger mask for technical triggers More...

void	setGtTriggerMenuImplementation (const std::string &)

void	setGtTriggerMenuInterface (const std::string &)

void	setGtTriggerMenuName (const std::string &)

virtual	~L1GtTriggerMenuLite ()

Private Attributes
L1TriggerMap	m_algorithmAliasMap
	map containing the physics algorithms (by alias) More...

L1TriggerMap	m_algorithmMap
	map containing the physics algorithms (by name) More...

std::vector< std::vector< int > >	m_prescaleFactorsAlgoTrig
	prescale factors More...

std::vector< std::vector< int > >	m_prescaleFactorsTechTrig

std::string	m_scaleDbKey
	menu associated scale key More...

L1TriggerMap	m_technicalTriggerMap
	map containing the technical triggers More...

std::vector< unsigned int >	m_triggerMaskAlgoTrig
	trigger mask for physics algorithms More...

std::vector< unsigned int >	m_triggerMaskTechTrig
	trigger mask for technical triggers More...

std::string	m_triggerMenuImplementation

std::string	m_triggerMenuInterface
	menu names More...

std::string	m_triggerMenuName

Friends
std::ostream &	operator<< (std::ostream &, const L1GtTriggerMenuLite &)
	output stream operator More...

Detailed Description

Description: L1 trigger menu and masks, lite version not using event setup.

Implementation: This is the lite version of the L1 trigger menu, with trigger masks included, to be used in the environments not having access to event setup. It offers limited access to the full L1 trigger menu which is implemented as event setup (CondFormats/L1TObjects/interface/L1GtTriggerMenu.h). The masks are provided for the physics partition only.

An EDM product is created and saved in the Run Data, under the assumption that the menu remains the same in a run. The corresponding producer will read the full L1 trigger menu and the trigger masks from event setup, fill the corresponding members and save it as EDM product.

Author: : Vasile Mihai Ghete - HEPHY Vienna

Definition at line 40 of file L1GtTriggerMenuLite.h.

Member Typedef Documentation

typedef L1TriggerMap::const_iterator L1GtTriggerMenuLite::CItL1Trig

iterators through map containing the physics algorithms or the technical triggers

Definition at line 48 of file L1GtTriggerMenuLite.h.

typedef L1TriggerMap::iterator L1GtTriggerMenuLite::ItL1Trig

Definition at line 49 of file L1GtTriggerMenuLite.h.

typedef std::map<unsigned int, std::string> L1GtTriggerMenuLite::L1TriggerMap

map containing the physics algorithms or the technical triggers

Definition at line 45 of file L1GtTriggerMenuLite.h.

Constructor & Destructor Documentation

L1GtTriggerMenuLite::L1GtTriggerMenuLite ( )

constructor

Definition at line 37 of file L1GtTriggerMenuLite.cc.

                                          :
     m_triggerMenuInterface("NULL"), m_triggerMenuName("NULL"),
             m_triggerMenuImplementation("NULL"), m_scaleDbKey("NULL") {
 
     // empty
 
 }

L1GtTriggerMenuLite::L1GtTriggerMenuLite	(	const std::string &	triggerMenuNameVal,
		const L1TriggerMap &	algorithmMapVal,
		const L1TriggerMap &	algorithmAliasMapVal,
		const L1TriggerMap &	technicalTriggerMapVal,
		const std::vector< unsigned int > &	triggerMaskAlgoTrigVal,
		const std::vector< unsigned int > &	triggerMaskTechTrigVal,
		const std::vector< std::vector< int > > &	prescaleFactorsAlgoTrigVal,
		const std::vector< std::vector< int > > &	prescaleFactorsTechTrigVal
	)

Definition at line 45 of file L1GtTriggerMenuLite.cc.

         :
     m_triggerMenuInterface("NULL"),
     m_triggerMenuName(triggerMenuNameVal),
     m_triggerMenuImplementation("NULL"),
     m_scaleDbKey("NULL"),
     m_algorithmMap(algorithmMapVal),
     m_algorithmAliasMap(algorithmAliasMapVal),
     m_technicalTriggerMap(technicalTriggerMapVal),
     m_triggerMaskAlgoTrig(triggerMaskAlgoTrigVal),
     m_triggerMaskTechTrig(triggerMaskTechTrigVal),
     m_prescaleFactorsAlgoTrig(prescaleFactorsAlgoTrigVal),
     m_prescaleFactorsTechTrig(prescaleFactorsTechTrigVal)
 
 
     {
 
     // empty
 
 }

L1GtTriggerMenuLite::L1GtTriggerMenuLite ( const L1GtTriggerMenuLite & rhs )

copy constructor

Definition at line 75 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap, m_algorithmMap, m_prescaleFactorsAlgoTrig, m_prescaleFactorsTechTrig, m_scaleDbKey, m_technicalTriggerMap, m_triggerMaskAlgoTrig, m_triggerMaskTechTrig, m_triggerMenuImplementation, m_triggerMenuInterface, and m_triggerMenuName.

                                                                        {
 
     m_triggerMenuInterface = rhs.m_triggerMenuInterface;
     m_triggerMenuName = rhs.m_triggerMenuName;
     m_triggerMenuImplementation = rhs.m_triggerMenuImplementation;
     m_scaleDbKey = rhs.m_scaleDbKey;
 
     // copy algorithm map
     m_algorithmMap = rhs.m_algorithmMap;
     m_algorithmAliasMap = rhs.m_algorithmAliasMap;
 
     // copy technical triggers
     // (separate map for technical triggers and physics triggers)
     m_technicalTriggerMap = rhs.m_technicalTriggerMap;
 
     // copy masks
     m_triggerMaskAlgoTrig = rhs.m_triggerMaskAlgoTrig;
     m_triggerMaskTechTrig = rhs.m_triggerMaskTechTrig;
 
     // copy prescale factors
     m_prescaleFactorsAlgoTrig = rhs.m_prescaleFactorsAlgoTrig;
     m_prescaleFactorsTechTrig = rhs.m_prescaleFactorsTechTrig;
 
 }

L1GtTriggerMenuLite::~L1GtTriggerMenuLite ( )

virtual

Definition at line 101 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap, m_algorithmMap, and m_technicalTriggerMap.

 {
 
     m_algorithmMap.clear();
     m_algorithmAliasMap.clear();
     m_technicalTriggerMap.clear();
 
 }

Member Function Documentation

const std::string * L1GtTriggerMenuLite::gtAlgorithmAlias	(	const unsigned int	bitNumber,
		int &	errorCode
	)		const

get the alias for a physics algorithm with a given bit number

Definition at line 383 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by gtPrescaleFactorsTechTrig().

                                                             {
 
     const std::string* gtAlgorithmAlias = nullptr;
 
     for (CItL1Trig itTrig = m_algorithmAliasMap.begin(); itTrig
             != m_algorithmAliasMap.end(); itTrig++) {
 
         if (itTrig->first == bitNumber) {
 
             gtAlgorithmAlias = &(itTrig->second);
 
             errorCode = 0;
             return gtAlgorithmAlias;
         }
     }
 
     errorCode = 1;
     return gtAlgorithmAlias;
 
 }

const L1TriggerMap& L1GtTriggerMenuLite::gtAlgorithmAliasMap ( ) const

inline

get / set the algorithm map (by alias)

Definition at line 118 of file L1GtTriggerMenuLite.h.

References m_algorithmAliasMap, and setGtAlgorithmAliasMap().

Referenced by L1GtUtils::retrieveL1GtTriggerMenuLite().

                                                            {
         return m_algorithmAliasMap;
     }

const L1TriggerMap& L1GtTriggerMenuLite::gtAlgorithmMap ( ) const

inline

get / set the algorithm map (by name)

Definition at line 111 of file L1GtTriggerMenuLite.h.

References m_algorithmMap, and setGtAlgorithmMap().

Referenced by FWL1TriggerTableView::fillTable(), and L1GtUtils::retrieveL1GtTriggerMenuLite().

                                                       {
         return m_algorithmMap;
     }

const std::string * L1GtTriggerMenuLite::gtAlgorithmName	(	const unsigned int	bitNumber,
		int &	errorCode
	)		const

get the name for a physics algorithm or a technical trigger with a given bit number

Definition at line 407 of file L1GtTriggerMenuLite.cc.

References m_algorithmMap, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by gtPrescaleFactorsTechTrig().

                                                             {
 
     const std::string* gtAlgorithmName = nullptr;
 
     for (CItL1Trig itTrig = m_algorithmMap.begin(); itTrig
             != m_algorithmMap.end(); itTrig++) {
 
         if (itTrig->first == bitNumber) {
 
             gtAlgorithmName = &(itTrig->second);
 
             errorCode = 0;
             return gtAlgorithmName;
         }
     }
 
     errorCode = 1;
     return gtAlgorithmName;
 
 }

const unsigned int L1GtTriggerMenuLite::gtBitNumber	(	const std::string &	trigName,
		int &	errorCode
	)		const

get the bit number for a physics algorithm or a technical trigger with a given name or alias

Definition at line 453 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap, m_algorithmMap, and m_technicalTriggerMap.

Referenced by gtPrescaleFactorsTechTrig().

                                                          {
 
     unsigned int bitNr = 999;
 
     //
     for (CItL1Trig itTrig = m_algorithmAliasMap.begin(); itTrig
             != m_algorithmAliasMap.end(); itTrig++) {
 
         if (itTrig->second == trigName) {
 
             bitNr = itTrig->first;
 
             errorCode = 0;
             return bitNr;
         }
     }
 
     //
     for (CItL1Trig itTrig = m_algorithmMap.begin(); itTrig
             != m_algorithmMap.end(); itTrig++) {
 
         if (itTrig->second == trigName) {
 
             bitNr = itTrig->first;
             errorCode = 0;
             return bitNr;
         }
     }
 
     //
     for (CItL1Trig itTrig = m_technicalTriggerMap.begin(); itTrig
             != m_technicalTriggerMap.end(); itTrig++) {
 
         if (itTrig->second == trigName) {
 
             bitNr = itTrig->first;
             errorCode = 0;
             return bitNr;
         }
     }
 
     errorCode = 1;
     return bitNr;
 
 }

const std::vector<std::vector<int> >& L1GtTriggerMenuLite::gtPrescaleFactorsAlgoTrig ( ) const

inline

get the prescale factors by reference / set the prescale factors

Definition at line 151 of file L1GtTriggerMenuLite.h.

References m_prescaleFactorsAlgoTrig, and setGtPrescaleFactorsAlgoTrig().

Referenced by FWL1TriggerTableView::fillTable(), and L1GtUtils::retrieveL1GtTriggerMenuLite().

     {
         return m_prescaleFactorsAlgoTrig;
     }

const std::vector<std::vector<int> >& L1GtTriggerMenuLite::gtPrescaleFactorsTechTrig ( ) const

inline

Definition at line 158 of file L1GtTriggerMenuLite.h.

References gtAlgorithmAlias(), gtAlgorithmName(), gtBitNumber(), gtTechTrigName(), gtTriggerResult(), m_prescaleFactorsTechTrig, operator<<, print(), setGtPrescaleFactorsTechTrig(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by FWL1TriggerTableView::fillTable(), and L1GtUtils::retrieveL1GtTriggerMenuLite().

     {
         return m_prescaleFactorsTechTrig;
     }

const std::string& L1GtTriggerMenuLite::gtScaleDbKey ( ) const

inline

menu associated scale key

Definition at line 104 of file L1GtTriggerMenuLite.h.

References m_scaleDbKey, setGtScaleDbKey(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                  {
         return m_scaleDbKey;
     }

const L1TriggerMap& L1GtTriggerMenuLite::gtTechnicalTriggerMap ( ) const

inline

get / set the technical trigger map

Definition at line 125 of file L1GtTriggerMenuLite.h.

References m_technicalTriggerMap, and setGtTechnicalTriggerMap().

Referenced by L1GtUtils::retrieveL1GtTriggerMenuLite().

                                                              {
         return m_technicalTriggerMap;
     }

const std::string * L1GtTriggerMenuLite::gtTechTrigName	(	const unsigned int	bitNumber,
		int &	errorCode
	)		const

Definition at line 429 of file L1GtTriggerMenuLite.cc.

References m_technicalTriggerMap, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by gtPrescaleFactorsTechTrig(), and PrescaleWeightProvider::prescaleWeight().

                                                             {
 
     const std::string* gtTechTrigName = nullptr;
 
     for (CItL1Trig itTrig = m_technicalTriggerMap.begin(); itTrig
             != m_technicalTriggerMap.end(); itTrig++) {
 
         if (itTrig->first == bitNumber) {
 
             gtTechTrigName = &(itTrig->second);
 
             errorCode = 0;
             return gtTechTrigName;
         }
     }
 
     errorCode = 1;
     return gtTechTrigName;
 
 }

const std::vector<unsigned int>& L1GtTriggerMenuLite::gtTriggerMaskAlgoTrig ( ) const

inline

get the trigger mask for physics algorithms

Definition at line 132 of file L1GtTriggerMenuLite.h.

References m_triggerMaskAlgoTrig, and setGtTriggerMaskAlgoTrig().

Referenced by L1GtUtils::retrieveL1GtTriggerMenuLite().

     {
         return m_triggerMaskAlgoTrig;
     }

const std::vector<unsigned int>& L1GtTriggerMenuLite::gtTriggerMaskTechTrig ( ) const

inline

get the trigger mask for technical triggers

Definition at line 142 of file L1GtTriggerMenuLite.h.

References m_triggerMaskTechTrig, and setGtTriggerMaskTechTrig().

Referenced by L1GtUtils::retrieveL1GtTriggerMenuLite().

     {
         return m_triggerMaskTechTrig;
     }

const std::string& L1GtTriggerMenuLite::gtTriggerMenuImplementation ( ) const

inline

Definition at line 97 of file L1GtTriggerMenuLite.h.

References m_triggerMenuImplementation, setGtTriggerMenuImplementation(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by L1GtUtils::l1Results(), L1GtUtils::l1TriggerMenuImplementation(), and L1GtUtils::triggerMask().

                                                                 {
         return m_triggerMenuImplementation;
     }

const std::string& L1GtTriggerMenuLite::gtTriggerMenuInterface ( ) const

inline

get / set the trigger menu names

Definition at line 83 of file L1GtTriggerMenuLite.h.

References m_triggerMenuInterface, setGtTriggerMenuInterface(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                            {
         return m_triggerMenuInterface;
     }

const std::string& L1GtTriggerMenuLite::gtTriggerMenuName ( ) const

inline

Definition at line 90 of file L1GtTriggerMenuLite.h.

References m_triggerMenuName, setGtTriggerMenuName(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by L1GtUtils::l1TriggerMenu().

                                                       {
         return m_triggerMenuName;
     }

const bool L1GtTriggerMenuLite::gtTriggerResult	(	const std::string &	trigName,
		const std::vector< bool > &	decWord,
		int &	errorCode
	)		const

get the result for a physics algorithm or a technical trigger with name trigName use directly the format of decisionWord (no typedef)

Definition at line 502 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap, m_algorithmMap, and m_technicalTriggerMap.

Referenced by FWL1TriggerTableView::fillTable(), and gtPrescaleFactorsTechTrig().

                                                               {
 
     bool trigResult = false;
 
     // try first physics algorithm aliases
 
     for (CItL1Trig itTrig = m_algorithmAliasMap.begin(); itTrig
             != m_algorithmAliasMap.end(); itTrig++) {
 
         if (itTrig->second == trigName) {
             unsigned int bitNumber = itTrig->first;
 
             if ((bitNumber >= decWord.size())) {
                 trigResult = false;
                 errorCode = 10;
             } else {
                 trigResult = decWord[bitNumber];
                 errorCode = 0;
             }
 
             return trigResult;
         }
     }
 
     // ... then physics algorithm names
 
     for (CItL1Trig itTrig = m_algorithmMap.begin(); itTrig
             != m_algorithmMap.end(); itTrig++) {
 
         if (itTrig->second == trigName) {
             unsigned int bitNumber = itTrig->first;
 
             if ((bitNumber >= decWord.size())) {
                 trigResult = false;
                 errorCode = 10;
             } else {
                 trigResult = decWord[bitNumber];
                 errorCode = 0;
             }
 
             return trigResult;
         }
     }
 
     // ... then technical trigger names
 
     for (CItL1Trig itTrig = m_technicalTriggerMap.begin(); itTrig
             != m_technicalTriggerMap.end(); itTrig++) {
 
         if (itTrig->second == trigName) {
             unsigned int bitNumber = itTrig->first;
 
             if ((bitNumber >= decWord.size())) {
                 trigResult = false;
                 errorCode = 10;
             } else {
                 trigResult = decWord[bitNumber];
                 errorCode = 0;
             }
 
             return trigResult;
         }
     }
 
     // algorithm or technical trigger not in the menu
 
     errorCode = 1;
     return false;
 
 }

bool L1GtTriggerMenuLite::isProductEqual ( const L1GtTriggerMenuLite & otherObj ) const

merge rule: test on isProductEqual

Definition at line 198 of file L1GtTriggerMenuLite.cc.

                                                                                   {
 
     return (otherObj == *this);
 }

bool L1GtTriggerMenuLite::operator!= ( const L1GtTriggerMenuLite & otherObj ) const

unequal operator

Definition at line 191 of file L1GtTriggerMenuLite.cc.

                                                                               {
 
     return !(otherObj == *this);
 
 }

L1GtTriggerMenuLite & L1GtTriggerMenuLite::operator= ( const L1GtTriggerMenuLite & rhs )

assignment operator

Definition at line 111 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap, m_algorithmMap, m_prescaleFactorsAlgoTrig, m_prescaleFactorsTechTrig, m_scaleDbKey, m_technicalTriggerMap, m_triggerMaskAlgoTrig, m_triggerMaskTechTrig, m_triggerMenuImplementation, m_triggerMenuInterface, and m_triggerMenuName.

                                         {
 
     if (this != &rhs) {
 
         m_triggerMenuInterface = rhs.m_triggerMenuInterface;
         m_triggerMenuName = rhs.m_triggerMenuName;
         m_triggerMenuImplementation = rhs.m_triggerMenuImplementation;
         m_scaleDbKey = rhs.m_scaleDbKey;
 
         m_algorithmMap = rhs.m_algorithmMap;
         m_algorithmAliasMap = rhs.m_algorithmAliasMap;
 
         m_technicalTriggerMap = rhs.m_technicalTriggerMap;
 
         m_triggerMaskAlgoTrig = rhs.m_triggerMaskAlgoTrig;
         m_triggerMaskTechTrig = rhs.m_triggerMaskTechTrig;
 
         m_prescaleFactorsAlgoTrig = rhs.m_prescaleFactorsAlgoTrig;
         m_prescaleFactorsTechTrig = rhs.m_prescaleFactorsTechTrig;
     }
 
     // return the object
     return *this;
 
 }

bool L1GtTriggerMenuLite::operator== ( const L1GtTriggerMenuLite & rhs ) const

equal operator

Definition at line 139 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap, m_algorithmMap, m_prescaleFactorsAlgoTrig, m_prescaleFactorsTechTrig, m_scaleDbKey, m_technicalTriggerMap, m_triggerMaskAlgoTrig, m_triggerMaskTechTrig, m_triggerMenuImplementation, m_triggerMenuInterface, and m_triggerMenuName.

                                                                          {
 
     if (m_triggerMenuInterface != rhs.m_triggerMenuInterface) {
         return false;
     }
 
     if (m_triggerMenuName != rhs.m_triggerMenuName) {
         return false;
     }
 
     if (m_triggerMenuImplementation != rhs.m_triggerMenuImplementation) {
         return false;
     }
 
     if (m_scaleDbKey != rhs.m_scaleDbKey) {
         return false;
     }
 
     if (m_algorithmMap != rhs.m_algorithmMap) {
         return false;
     }
 
     if (m_algorithmAliasMap != rhs.m_algorithmAliasMap) {
         return false;
     }
 
     if (m_technicalTriggerMap != rhs.m_technicalTriggerMap) {
         return false;
     }
 
     if (m_triggerMaskAlgoTrig != rhs.m_triggerMaskAlgoTrig) {
         return false;
     }
 
     if (m_triggerMaskTechTrig != rhs.m_triggerMaskTechTrig) {
         return false;
     }
 
     if (m_prescaleFactorsAlgoTrig != rhs.m_prescaleFactorsAlgoTrig) {
         return false;
     }
 
     if (m_prescaleFactorsTechTrig != rhs.m_prescaleFactorsTechTrig) {
         return false;
     }
 
     // all members identical
     return true;
 
 }

void L1GtTriggerMenuLite::print	(	std::ostream &	myCout,
		int &	printVerbosity
	)		const

print the trigger menu allow various verbosity levels

Definition at line 272 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap, m_algorithmMap, m_prescaleFactorsAlgoTrig, m_prescaleFactorsTechTrig, m_scaleDbKey, m_technicalTriggerMap, m_triggerMaskAlgoTrig, m_triggerMaskTechTrig, m_triggerMenuImplementation, m_triggerMenuInterface, m_triggerMenuName, and AlCaHLTBitMon_QueryRunRegistry::string.

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

                                                                              {
 
     //
 
     switch (printVerbosity) {
 
         case 0: {
 
             size_t nrDefinedAlgo = m_algorithmMap.size();
             size_t nrDefinedTech = m_technicalTriggerMap.size();
 
             // header for printing algorithms
 
             myCout << "\n   ********** L1 Trigger Menu - printing   ********** \n"
             << "\nL1 Trigger Menu Interface: " << m_triggerMenuInterface
             << "\nL1 Trigger Menu Name:      " << m_triggerMenuName
             << "\nL1 Trigger Menu Implementation: " << m_triggerMenuImplementation
             << "\nAssociated Scale DB Key: " << m_scaleDbKey << "\n\n"
             << "\nL1 Physics Algorithms: " << nrDefinedAlgo << " algorithms defined." << "\n\n"
             << "Bit Number "
             << std::right << std::setw(35) << "Algorithm Name" << "  "
             << std::right << std::setw(35) << "Algorithm Alias" << "  "
             << std::right << std::setw(12) << "Trigger Mask";
             for (unsigned iSet = 0; iSet < m_prescaleFactorsAlgoTrig.size(); iSet++) {
                 myCout << std::right << std::setw(10) << "PF Set "
                        << std::right << std::setw(2)  << iSet;
             }
 
             myCout << std::endl;
 
 
             for (CItL1Trig itTrig = m_algorithmMap.begin(); itTrig
                     != m_algorithmMap.end(); itTrig++) {
 
                 const unsigned int bitNumber = itTrig->first;
                 const std::string& aName = itTrig->second;
 
                 std::string aAlias;
                 CItL1Trig itAlias = m_algorithmAliasMap.find(bitNumber);
                 if (itAlias != m_algorithmAliasMap.end()) {
                     aAlias = itAlias->second;
                 }
 
                 myCout << std::setw(6) << bitNumber << "     "
                     << std::right << std::setw(35) << aName << "  "
                     << std::right << std::setw(35) << aAlias << "  "
                     << std::right << std::setw(12) << m_triggerMaskAlgoTrig[bitNumber];
                 for (unsigned iSet = 0; iSet < m_prescaleFactorsAlgoTrig.size(); iSet++) {
                     myCout << std::right << std::setw(12) << m_prescaleFactorsAlgoTrig[iSet][bitNumber];
                 }
 
                 myCout << std::endl;
             }
 
             myCout << "\nL1 Technical Triggers: " << nrDefinedTech
                     << " technical triggers defined." << "\n\n" << std::endl;
             if (nrDefinedTech) {
                 myCout
                     << std::right << std::setw(6) << "Bit Number "
                     << std::right << std::setw(45) << " Technical trigger name " << "  "
                     << std::right << std::setw(12) << "Trigger Mask";
                 for (unsigned iSet = 0; iSet < m_prescaleFactorsTechTrig.size(); iSet++) {
                     myCout << std::right << std::setw(10) << "PF Set "
                             << std::right << std::setw(2) << iSet;
                 }
 
                 myCout << std::endl;
             }
 
             for (CItL1Trig itTrig = m_technicalTriggerMap.begin(); itTrig
                     != m_technicalTriggerMap.end(); itTrig++) {
 
                 unsigned int bitNumber = itTrig->first;
                 std::string aName = itTrig->second;
 
                 myCout << std::setw(6) << bitNumber << "       "
                 << std::right << std::setw(45) << aName
                 << std::right << std::setw(12) << m_triggerMaskTechTrig[bitNumber];
                 for (unsigned iSet = 0; iSet < m_prescaleFactorsTechTrig.size(); iSet++) {
                     myCout << std::right << std::setw(12) << m_prescaleFactorsTechTrig[iSet][bitNumber];
                 }
 
                 myCout << std::endl;
 
             }
 
 
 
         }
             break;
         default: {
             myCout << "\n   ********** L1 Trigger Menu - printing   ********** \n\n"
             << "Verbosity level: " << printVerbosity << " not implemented.\n\n"
             << std::endl;
         }
             break;
     }
 
 }

void L1GtTriggerMenuLite::setGtAlgorithmAliasMap ( const L1TriggerMap & algoMap )

Definition at line 230 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap.

Referenced by gtAlgorithmAliasMap().

                                                                             {
     m_algorithmAliasMap = algoMap;
 }

void L1GtTriggerMenuLite::setGtAlgorithmMap ( const L1TriggerMap & algoMap )

Definition at line 225 of file L1GtTriggerMenuLite.cc.

References m_algorithmMap.

Referenced by gtAlgorithmMap().

                                                                        {
     m_algorithmMap = algoMap;
 }

void L1GtTriggerMenuLite::setGtPrescaleFactorsAlgoTrig ( const std::vector< std::vector< int > > & factorValue )

Definition at line 257 of file L1GtTriggerMenuLite.cc.

References m_prescaleFactorsAlgoTrig.

Referenced by gtPrescaleFactorsAlgoTrig().

                                                        {
 
     m_prescaleFactorsAlgoTrig = factorValue;
 
 }

void L1GtTriggerMenuLite::setGtPrescaleFactorsTechTrig ( const std::vector< std::vector< int > > & factorValue )

Definition at line 264 of file L1GtTriggerMenuLite.cc.

References m_prescaleFactorsTechTrig.

Referenced by gtPrescaleFactorsTechTrig().

                                                        {
 
     m_prescaleFactorsTechTrig = factorValue;
 
 }

void L1GtTriggerMenuLite::setGtScaleDbKey ( const std::string & scaleKey )

Definition at line 220 of file L1GtTriggerMenuLite.cc.

References m_scaleDbKey.

Referenced by gtScaleDbKey().

                                                                    {
     m_scaleDbKey = scaleKey;
 }

void L1GtTriggerMenuLite::setGtTechnicalTriggerMap ( const L1TriggerMap & ttMap )

Definition at line 235 of file L1GtTriggerMenuLite.cc.

References m_technicalTriggerMap.

Referenced by gtTechnicalTriggerMap().

                                                                             {
     m_technicalTriggerMap = ttMap;
 }

void L1GtTriggerMenuLite::setGtTriggerMaskAlgoTrig ( const std::vector< unsigned int > & maskValue )

set the trigger mask for physics algorithms

Definition at line 240 of file L1GtTriggerMenuLite.cc.

References m_triggerMaskAlgoTrig.

Referenced by gtTriggerMaskAlgoTrig().

                                                   {
 
     m_triggerMaskAlgoTrig = maskValue;
 
 }

void L1GtTriggerMenuLite::setGtTriggerMaskTechTrig ( const std::vector< unsigned int > & maskValue )

set the trigger mask for technical triggers

Definition at line 248 of file L1GtTriggerMenuLite.cc.

References m_triggerMaskTechTrig.

Referenced by gtTriggerMaskTechTrig().

 {
 
     m_triggerMaskTechTrig = maskValue;
 
 }

void L1GtTriggerMenuLite::setGtTriggerMenuImplementation ( const std::string & menuImplementation )

Definition at line 214 of file L1GtTriggerMenuLite.cc.

References m_triggerMenuImplementation.

Referenced by gtTriggerMenuImplementation().

                                              {
     m_triggerMenuImplementation = menuImplementation;
 }

void L1GtTriggerMenuLite::setGtTriggerMenuInterface ( const std::string & menuInterface )

Definition at line 205 of file L1GtTriggerMenuLite.cc.

References m_triggerMenuInterface.

Referenced by gtTriggerMenuInterface().

                                         {
     m_triggerMenuInterface = menuInterface;
 }

void L1GtTriggerMenuLite::setGtTriggerMenuName ( const std::string & menuName )

Definition at line 210 of file L1GtTriggerMenuLite.cc.

References m_triggerMenuName.

Referenced by gtTriggerMenuName().

                                                                         {
     m_triggerMenuName = menuName;
 }

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	streamRec,
		const L1GtTriggerMenuLite &	result
	)

friend

output stream operator

Definition at line 373 of file L1GtTriggerMenuLite.cc.

Referenced by gtPrescaleFactorsTechTrig().

                                            {
     int verbosityLevel = 0;
 
     result.print(streamRec, verbosityLevel);
     return streamRec;
 
 }