#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

$Date$ $Revision$

Definition at line 42 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 50 of file L1GtTriggerMenuLite.h.

typedef L1TriggerMap::iterator L1GtTriggerMenuLite::ItL1Trig

Definition at line 51 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 47 of file L1GtTriggerMenuLite.h.

Constructor & Destructor Documentation

L1GtTriggerMenuLite::L1GtTriggerMenuLite ( )

constructor

Definition at line 39 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 47 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 77 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 103 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 385 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap.

                                                             {
 
     const std::string* gtAlgorithmAlias = 0;
 
     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 120 of file L1GtTriggerMenuLite.h.

References m_algorithmAliasMap.

Referenced by L1GtUtils::retrieveL1GtTriggerMenuLite().

                                                            {
         return m_algorithmAliasMap;
     }

const L1TriggerMap& L1GtTriggerMenuLite::gtAlgorithmMap ( ) const

inline

get / set the algorithm map (by name)

Definition at line 113 of file L1GtTriggerMenuLite.h.

References m_algorithmMap.

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 409 of file L1GtTriggerMenuLite.cc.

References m_algorithmMap.

                                                             {
 
     const std::string* gtAlgorithmName = 0;
 
     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 455 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap, m_algorithmMap, and m_technicalTriggerMap.

                                                          {
 
     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 153 of file L1GtTriggerMenuLite.h.

References m_prescaleFactorsAlgoTrig.

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

     {
         return m_prescaleFactorsAlgoTrig;
     }

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

inline

Definition at line 160 of file L1GtTriggerMenuLite.h.

References m_prescaleFactorsTechTrig.

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

     {
         return m_prescaleFactorsTechTrig;
     }

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

inline

menu associated scale key

Definition at line 106 of file L1GtTriggerMenuLite.h.

References m_scaleDbKey.

                                                  {
         return m_scaleDbKey;
     }

const L1TriggerMap& L1GtTriggerMenuLite::gtTechnicalTriggerMap ( ) const

inline

get / set the technical trigger map

Definition at line 127 of file L1GtTriggerMenuLite.h.

References m_technicalTriggerMap.

Referenced by L1GtUtils::retrieveL1GtTriggerMenuLite().

                                                              {
         return m_technicalTriggerMap;
     }

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

Definition at line 431 of file L1GtTriggerMenuLite.cc.

References m_technicalTriggerMap.

                                                             {
 
     const std::string* gtTechTrigName = 0;
 
     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 134 of file L1GtTriggerMenuLite.h.

References m_triggerMaskAlgoTrig.

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 144 of file L1GtTriggerMenuLite.h.

References m_triggerMaskTechTrig.

Referenced by L1GtUtils::retrieveL1GtTriggerMenuLite().

     {
         return m_triggerMaskTechTrig;
     }

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

inline

Definition at line 99 of file L1GtTriggerMenuLite.h.

References m_triggerMenuImplementation.

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 85 of file L1GtTriggerMenuLite.h.

References m_triggerMenuInterface.

                                                            {
         return m_triggerMenuInterface;
     }

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

inline

Definition at line 92 of file L1GtTriggerMenuLite.h.

References m_triggerMenuName.

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 504 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap, m_algorithmMap, and m_technicalTriggerMap.

Referenced by FWL1TriggerTableView::fillTable().

                                                               {
 
     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 200 of file L1GtTriggerMenuLite.cc.

                                                                                   {
 
     return (otherObj == *this);
 }

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

unequal operator

Definition at line 193 of file L1GtTriggerMenuLite.cc.

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

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

assignment operator

Definition at line 113 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 141 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 274 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.

Referenced by 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 232 of file L1GtTriggerMenuLite.cc.

References m_algorithmAliasMap.

                                                                             {
     m_algorithmAliasMap = algoMap;
 }

void L1GtTriggerMenuLite::setGtAlgorithmMap ( const L1TriggerMap & algoMap )

Definition at line 227 of file L1GtTriggerMenuLite.cc.

References m_algorithmMap.

                                                                        {
     m_algorithmMap = algoMap;
 }

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

Definition at line 259 of file L1GtTriggerMenuLite.cc.

References m_prescaleFactorsAlgoTrig.

                                                        {
 
     m_prescaleFactorsAlgoTrig = factorValue;
 
 }

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

Definition at line 266 of file L1GtTriggerMenuLite.cc.

References m_prescaleFactorsTechTrig.

                                                        {
 
     m_prescaleFactorsTechTrig = factorValue;
 
 }

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

Definition at line 222 of file L1GtTriggerMenuLite.cc.

References m_scaleDbKey.

                                                                    {
     m_scaleDbKey = scaleKey;
 }

void L1GtTriggerMenuLite::setGtTechnicalTriggerMap ( const L1TriggerMap & ttMap )

Definition at line 237 of file L1GtTriggerMenuLite.cc.

References m_technicalTriggerMap.

                                                                             {
     m_technicalTriggerMap = ttMap;
 }

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

set the trigger mask for physics algorithms

Definition at line 242 of file L1GtTriggerMenuLite.cc.

References m_triggerMaskAlgoTrig.

                                                   {
 
     m_triggerMaskAlgoTrig = maskValue;
 
 }

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

set the trigger mask for technical triggers

Definition at line 250 of file L1GtTriggerMenuLite.cc.

References m_triggerMaskTechTrig.

 {
 
     m_triggerMaskTechTrig = maskValue;
 
 }

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

Definition at line 216 of file L1GtTriggerMenuLite.cc.

References m_triggerMenuImplementation.

                                              {
     m_triggerMenuImplementation = menuImplementation;
 }

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

Definition at line 207 of file L1GtTriggerMenuLite.cc.

References m_triggerMenuInterface.

                                         {
     m_triggerMenuInterface = menuInterface;
 }

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

Definition at line 212 of file L1GtTriggerMenuLite.cc.

References m_triggerMenuName.

                                                                         {
     m_triggerMenuName = menuName;
 }

Friends And Related Function Documentation

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

friend

output stream operator

Definition at line 375 of file L1GtTriggerMenuLite.cc.

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