#include <GlobalObjectMap.h>

Public Member Functions
int	algoBitNumber () const
	get / set bit number for algorithm in the object map More...

bool	algoGtlResult () const

const std::string &	algoName () const
	destructor More...

const std::vector< CombinationsInCond > &	combinationVector () const

const CombinationsInCond *	getCombinationsInCond (const std::string &condNameVal) const
	return all the combinations passing the requirements imposed in condition condNameVal More...

const CombinationsInCond *	getCombinationsInCond (const int condNumberVal) const
	return all the combinations passing the requirements imposed in condition condNumberVal More...

const bool	getConditionResult (const std::string &condNameVal) const
	return the result for the condition condNameVal More...

	GlobalObjectMap ()
	constructor(s) More...

const std::vector< L1TObjectTypeInCond > &	objectTypeVector () const

const std::vector< GlobalLogicParser::OperandToken > &	operandTokenVector () const

void	print (std::ostream &myCout) const
	print the full object map More...

void	reset ()
	reset the object map More...

void	setAlgoBitNumber (int algoBitNumberValue)

void	setAlgoGtlResult (bool algoGtlResultValue)

void	setAlgoName (const std::string &algoNameValue)

void	setCombinationVector (const std::vector< CombinationsInCond > &combinationVectorValue)

void	setObjectTypeVector (const std::vector< L1TObjectTypeInCond > &objectTypeVectorValue)

void	setOperandTokenVector (const std::vector< GlobalLogicParser::OperandToken > &operandTokenVectorValue)

void	swapCombinationVector (std::vector< CombinationsInCond > &combinationVectorValue)

void	swapObjectTypeVector (std::vector< L1TObjectTypeInCond > &objectTypeVectorValue)

void	swapOperandTokenVector (std::vector< GlobalLogicParser::OperandToken > &operandTokenVectorValue)

Private Attributes
int	m_algoBitNumber

bool	m_algoGtlResult

std::string	m_algoName

std::vector< CombinationsInCond >	m_combinationVector

std::vector< L1TObjectTypeInCond >	m_objectTypeVector

std::vector< GlobalLogicParser::OperandToken >	m_operandTokenVector

Detailed Description

Description: map trigger objects to an algorithm and the conditions therein.

Implementation: <TODO: enter implementation details>

Author: : Vasile Mihai Ghete - HEPHY Vienna

Description: group typedefs used by GlobalObjectMap.

Implementation: <TODO: enter implementation details>

Author: : Vasile Mihai Ghete - HEPHY Vienna

Description: see header file.

Implementation: <TODO: enter implementation details>

Author: : Vasile Mihai Ghete - HEPHY Vienna

Definition at line 32 of file GlobalObjectMap.h.

Constructor & Destructor Documentation

GlobalObjectMap::GlobalObjectMap ( )

inline

constructor(s)

Definition at line 37 of file GlobalObjectMap.h.

37 {}

Member Function Documentation

int GlobalObjectMap::algoBitNumber ( ) const

inline

get / set bit number for algorithm in the object map

Definition at line 55 of file GlobalObjectMap.h.

References m_algoBitNumber.

Referenced by l1t::GtRecordDump::analyze(), and HLTL1TSeed::seedsL1TriggerObjectMaps().

     {
         return m_algoBitNumber;
     }

bool GlobalObjectMap::algoGtlResult ( ) const

inline

get / set the GTL result for algorithm NOTE: FDL can mask an algorithm!

Definition at line 67 of file GlobalObjectMap.h.

References m_algoGtlResult.

Referenced by l1t::GtRecordDump::analyze(), and HLTL1TSeed::seedsL1TriggerObjectMaps().

                                       {
         return m_algoGtlResult;
     }

const std::string& GlobalObjectMap::algoName ( ) const

inline

destructor

get / set name for algorithm in the object map

Definition at line 45 of file GlobalObjectMap.h.

References m_algoName.

Referenced by l1t::GtRecordDump::analyze(), and HLTL1TSeed::seedsL1TriggerObjectMaps().

     {
         return m_algoName;
     }

const std::vector<CombinationsInCond>& GlobalObjectMap::combinationVector ( ) const

inline

get / set the vector of combinations for the algorithm return a constant reference to the vector of combinations for the algorithm

Definition at line 77 of file GlobalObjectMap.h.

References m_combinationVector.

Referenced by HLTL1TSeed::seedsL1TriggerObjectMaps().

     {
         return m_combinationVector;
     }

const CombinationsInCond * GlobalObjectMap::getCombinationsInCond ( const std::string & condNameVal ) const

return all the combinations passing the requirements imposed in condition condNameVal

Definition at line 37 of file GlobalObjectMap.cc.

References mps_fire::i, m_combinationVector, and m_operandTokenVector.

Referenced by l1t::GtRecordDump::analyze(), HLTL1TSeed::seedsL1TriggerObjectMaps(), and swapObjectTypeVector().

                                         {
 
     for (size_t i = 0; i < m_operandTokenVector.size(); ++i) {
 
         if ((m_operandTokenVector[i]).tokenName == condNameVal) {
             return &(m_combinationVector.at((m_operandTokenVector[i]).tokenNumber));
         }
 
     }
 
     // return a null address - should not arrive here
     edm::LogError("GlobalObjectMap")
         << "\n\n  ERROR: The requested condition with tokenName = " << condNameVal
         << "\n  does not exists in the operand token vector."
         << "\n  Returning zero pointer for getCombinationsInCond\n\n" << std::endl;
 
     return nullptr;
 
 }

const CombinationsInCond * GlobalObjectMap::getCombinationsInCond ( const int condNumberVal ) const

return all the combinations passing the requirements imposed in condition condNumberVal

Definition at line 59 of file GlobalObjectMap.cc.

References mps_fire::i, m_combinationVector, and m_operandTokenVector.

                                                                                               {
 
     for (size_t i = 0; i < m_operandTokenVector.size(); ++i) {
 
         if ((m_operandTokenVector[i]).tokenNumber == condNumberVal) {
             return &(m_combinationVector.at((m_operandTokenVector[i]).tokenNumber));
         }
 
     }
 
     // return a null address - should not arrive here
     edm::LogError("GlobalObjectMap")
         << "\n\n  ERROR: The requested condition with tokenNumber = " << condNumberVal
         << "\n  does not exists in the operand token vector."
         << "\n  Returning zero pointer for getCombinationsInCond\n\n" << std::endl;
 
     return nullptr;
 
 }

const bool GlobalObjectMap::getConditionResult ( const std::string & condNameVal ) const

return the result for the condition condNameVal

Definition at line 79 of file GlobalObjectMap.cc.

References mps_fire::i, and m_operandTokenVector.

Referenced by swapObjectTypeVector().

                                                                                  {
 
     for (size_t i = 0; i < m_operandTokenVector.size(); ++i) {
 
         if ((m_operandTokenVector[i]).tokenName == condNameVal) {
             return (m_operandTokenVector[i]).tokenResult;
         }
     }
 
     // return false - should not arrive here
     edm::LogError("GlobalObjectMap")
         << "\n\n  ERROR: The requested condition with name = " << condNameVal
         << "\n  does not exists in the operand token vector."
         << "\n  Returning false for getConditionResult\n\n" << std::endl;
     return false;
 
 }

const std::vector<L1TObjectTypeInCond>& GlobalObjectMap::objectTypeVector ( ) const

inline

get / set the vector of object types return a constant reference to the vector of operand tokens

Definition at line 105 of file GlobalObjectMap.h.

References m_objectTypeVector.

Referenced by l1t::GtRecordDump::analyze(), and HLTL1TSeed::seedsL1TriggerObjectMaps().

                                                                           {
         return m_objectTypeVector;
     }

const std::vector<GlobalLogicParser::OperandToken>& GlobalObjectMap::operandTokenVector ( ) const

inline

get / set the vector of operand tokens return a constant reference to the vector of operand tokens

Definition at line 91 of file GlobalObjectMap.h.

References m_operandTokenVector.

Referenced by l1t::GtRecordDump::analyze(), and HLTL1TSeed::seedsL1TriggerObjectMaps().

                                                                                       {
         return m_operandTokenVector;
     }

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

print the full object map

Definition at line 118 of file GlobalObjectMap.cc.

References popcon2dropbox::copy(), mps_fire::i, m_algoBitNumber, m_algoGtlResult, m_algoName, m_combinationVector, m_operandTokenVector, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by l1t::GlobalBoard::runGTL(), and swapObjectTypeVector().

 {
 
     myCout << "GlobalObjectMap: print " << std::endl;
 
     myCout << "  Algorithm name: " << m_algoName << std::endl;
     myCout << "    Bit number: " << m_algoBitNumber << std::endl;
     myCout << "    GTL result: " << m_algoGtlResult << std::endl;
 
     int operandTokenVectorSize = m_operandTokenVector.size();
 
     myCout << "    Operand token vector size: " << operandTokenVectorSize;
 
     if (operandTokenVectorSize == 0) {
         myCout << "   - not properly initialized! " << std::endl;
     }
     else {
         myCout << std::endl;
 
         for (int i = 0; i < operandTokenVectorSize; ++i) {
 
             myCout << "      " << std::setw(5) << (m_operandTokenVector[i]).tokenNumber << "\t"
             << std::setw(25) << (m_operandTokenVector[i]).tokenName << "\t" 
             << (m_operandTokenVector[i]).tokenResult 
             << std::endl;
         }
 
     }
 
     myCout << "    CombinationVector size: " << m_combinationVector.size() << std::endl;
 
     myCout << "  conditions: "  << std::endl;
 
     std::vector<CombinationsInCond>::const_iterator itVVV;
     int iCond = 0;
     for(itVVV  = m_combinationVector.begin();
             itVVV != m_combinationVector.end(); itVVV++) {
 
         std::string condName = (m_operandTokenVector[iCond]).tokenName;
         bool condResult = (m_operandTokenVector[iCond]).tokenResult;
 
         myCout << "    Condition " << condName << " evaluated to " << condResult
         << std::endl;
 
         myCout << "    List of combinations passing all requirements for this condition:"
         << std::endl;
 
         myCout << "    ";
 
         if ((*itVVV).empty()) {
             myCout << "(none)";
         } else {
 
             CombinationsInCond::const_iterator itVV;
             for(itVV  = (*itVVV).begin(); itVV != (*itVVV).end(); itVV++) {
 
                 myCout << "( ";
 
                 std::copy((*itVV).begin(), (*itVV).end(),
                           std::ostream_iterator<int> (myCout, " "));
 
                 myCout << "); ";
 
             }
 
         }
         iCond++;
         myCout << "\n\n";
     }
 }

void GlobalObjectMap::reset ( void )

reset the object map

Definition at line 98 of file GlobalObjectMap.cc.

References m_algoBitNumber, m_algoGtlResult, m_algoName, m_combinationVector, and m_operandTokenVector.

Referenced by swapObjectTypeVector().

 {
 
     // name of the algorithm
     m_algoName.clear();
 
     // bit number for algorithm
     m_algoBitNumber = -1;
 
     // GTL result of the algorithm
     m_algoGtlResult = false;
 
     // vector of operand tokens for an algorithm 
     m_operandTokenVector.clear();
     
     // vector of combinations for all conditions in an algorithm
     m_combinationVector.clear();
 
 }

void GlobalObjectMap::setAlgoBitNumber ( int algoBitNumberValue )

inline

Definition at line 60 of file GlobalObjectMap.h.

References m_algoBitNumber.

Referenced by l1t::GlobalBoard::runGTL().

     {
         m_algoBitNumber = algoBitNumberValue;
     }

void GlobalObjectMap::setAlgoGtlResult ( bool algoGtlResultValue )

inline

Definition at line 71 of file GlobalObjectMap.h.

References m_algoGtlResult.

Referenced by l1t::GlobalBoard::runGTL().

                                                    {
         m_algoGtlResult = algoGtlResultValue;
     }

void GlobalObjectMap::setAlgoName ( const std::string & algoNameValue )

inline

Definition at line 50 of file GlobalObjectMap.h.

References m_algoName.

Referenced by l1t::GlobalBoard::runGTL().

                                                      {
         m_algoName = algoNameValue;
     }

void GlobalObjectMap::setCombinationVector ( const std::vector< CombinationsInCond > & combinationVectorValue )

inline

Definition at line 82 of file GlobalObjectMap.h.

References m_combinationVector.

                                                                                            {
         m_combinationVector = combinationVectorValue;
     }

void GlobalObjectMap::setObjectTypeVector ( const std::vector< L1TObjectTypeInCond > & objectTypeVectorValue )

inline

Definition at line 108 of file GlobalObjectMap.h.

References m_objectTypeVector.

                                                                                           {
         m_objectTypeVector = objectTypeVectorValue;
     }

void GlobalObjectMap::setOperandTokenVector ( const std::vector< GlobalLogicParser::OperandToken > & operandTokenVectorValue )

inline

Definition at line 95 of file GlobalObjectMap.h.

References m_operandTokenVector.

                                                                                                         {
         m_operandTokenVector = operandTokenVectorValue;
     }

void GlobalObjectMap::swapCombinationVector ( std::vector< CombinationsInCond > & combinationVectorValue )

inline

Definition at line 85 of file GlobalObjectMap.h.

References m_combinationVector.

Referenced by l1t::GlobalBoard::runGTL().

                                                                                       {
       m_combinationVector.swap(combinationVectorValue);
     }

void GlobalObjectMap::swapObjectTypeVector ( std::vector< L1TObjectTypeInCond > & objectTypeVectorValue )

inline

Definition at line 111 of file GlobalObjectMap.h.

References getCombinationsInCond(), getConditionResult(), m_objectTypeVector, print(), reset(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by l1t::GlobalBoard::runGTL().

                                                                                      {
       m_objectTypeVector.swap(objectTypeVectorValue);
     }

void GlobalObjectMap::swapOperandTokenVector ( std::vector< GlobalLogicParser::OperandToken > & operandTokenVectorValue )

inline

Definition at line 98 of file GlobalObjectMap.h.

References m_operandTokenVector.

Referenced by l1t::GlobalBoard::runGTL().

                                                                                                    {
       m_operandTokenVector.swap(operandTokenVectorValue);
     }