L1GlobalTriggerObjectMaps Class Reference

#include <L1GlobalTriggerObjectMaps.h>

Classes
class	AlgorithmResult
class	CombinationsInCondition
class	ConditionResult
class	ConditionsInAlgorithm

Public Member Functions
bool	algorithmExists (int algorithmBitNumber) const
	Returns true if there is an entry for this algorithm bit number. More...
bool	algorithmResult (int algorithmBitNumber) const
	Returns whether an algorithm trigger passed or failed. More...
void	consistencyCheck () const
void	getAlgorithmBitNumbers (std::vector< int > &algorithmBitNumbers) const
	Fills the vector with all the algorithm bit numbers. More...
CombinationsInCondition	getCombinationsInCondition (int algorithmBitNumber, unsigned conditionNumber) const
ConditionsInAlgorithm	getConditionsInAlgorithm (int algorithmBitNumber) const
unsigned	getNumberOfConditions (int algorithmBitNumber) const
	Number of conditions associated with an algorithm. More...
	L1GlobalTriggerObjectMaps ()
edm::ParameterSetID const &	namesParameterSetID () const
void	pushBackAlgorithm (unsigned startIndexOfConditions, int algorithmBitNumber, bool algorithmResult)
void	pushBackCondition (unsigned startIndexOfCombinations, unsigned short nObjectsPerCombination, bool conditionResult)
void	pushBackObjectIndex (unsigned char objectIndex)
void	reserveForAlgorithms (unsigned n)
void	reserveForConditions (unsigned n)
void	reserveForObjectIndexes (unsigned n)
void	setNamesParameterSetID (edm::ParameterSetID const &psetID)
void	swap (L1GlobalTriggerObjectMaps &rh)
void	updateOperandTokenVector (int algorithmBitNumber, std::vector< L1GtLogicParser::OperandToken > &operandTokenVector) const
	Update the condition result in the operandTokenVector. More...
	~L1GlobalTriggerObjectMaps ()

Private Member Functions
void	getStartEndIndex (int algorithmBitNumber, unsigned &startIndex, unsigned &endIndex) const

Private Attributes
std::vector< AlgorithmResult >	m_algorithmResults
std::vector< unsigned char >	m_combinations
std::vector< ConditionResult >	m_conditionResults
edm::ParameterSetID	m_namesParameterSetID

Detailed Description

Description: map trigger objects to algorithms and conditions.

Implementation: <TODO: enter implementation details>

Author

: Vasile Mihai Ghete - HEPHY Vienna

: W. David Dagenhart

Definition at line 24 of file L1GlobalTriggerObjectMaps.h.

Constructor & Destructor Documentation

L1GlobalTriggerObjectMaps()

L1GlobalTriggerObjectMaps::L1GlobalTriggerObjectMaps ( )

inline

Definition at line 26 of file L1GlobalTriggerObjectMaps.h.

{}

~L1GlobalTriggerObjectMaps()

L1GlobalTriggerObjectMaps::~L1GlobalTriggerObjectMaps ( )

inline

Definition at line 28 of file L1GlobalTriggerObjectMaps.h.

{}

Member Function Documentation

algorithmExists()

bool L1GlobalTriggerObjectMaps::algorithmExists

(

int

algorithmBitNumber

)

const

Returns true if there is an entry for this algorithm bit number.

Definition at line 30 of file L1GlobalTriggerObjectMaps.cc.

                                                                            {
  std::vector<AlgorithmResult>::const_iterator i = std::lower_bound(
      m_algorithmResults.begin(), m_algorithmResults.end(), AlgorithmResult(0, algorithmBitNumber, false));
  if (i == m_algorithmResults.end() || i->algorithmBitNumber() != algorithmBitNumber) {
    return false;
  }
  return true;
}

References mps_fire::i, cuda_std::lower_bound(), and m_algorithmResults.

Referenced by pat::PATTriggerProducer::produce().

algorithmResult()

bool L1GlobalTriggerObjectMaps::algorithmResult

(

int

algorithmBitNumber

)

const

Returns whether an algorithm trigger passed or failed.

Definition at line 39 of file L1GlobalTriggerObjectMaps.cc.

                                                                            {
  std::vector<AlgorithmResult>::const_iterator i = std::lower_bound(
      m_algorithmResults.begin(), m_algorithmResults.end(), AlgorithmResult(0, algorithmBitNumber, false));
  if (i == m_algorithmResults.end() || i->algorithmBitNumber() != algorithmBitNumber) {
    cms::Exception ex("L1GlobalTrigger");
    ex << "algorithmBitNumber not found";
    ex.addContext("Calling L1GlobalTriggerObjectMaps::algorithmResult");
    throw ex;
  }
  return i->algorithmResult();
}

References cms::Exception::addContext(), mps_fire::i, cuda_std::lower_bound(), and m_algorithmResults.

Referenced by CompareToObjectMapRecord::analyze(), pat::PATTriggerProducer::produce(), and pushBackAlgorithm().

consistencyCheck()

void L1GlobalTriggerObjectMaps::consistencyCheck

(

)

const

Definition at line 138 of file L1GlobalTriggerObjectMaps.cc.

                                                       {
  // None of these checks should ever fail unless there
  // is a bug in the code filling this object
  for (std::vector<AlgorithmResult>::const_iterator i = m_algorithmResults.begin(), iEnd = m_algorithmResults.end();
       i != iEnd;
       ++i) {
    std::vector<AlgorithmResult>::const_iterator j = i;
    ++j;
    if (j != iEnd && !(*i < *j)) {
      cms::Exception ex("L1GlobalTrigger");
      ex << "AlgorithmResults should be sorted in increasing order of bit number with no duplicates. It is not.";
      ex.addContext("Calling L1GlobalTriggerObjectMaps::consistencyCheck");
      throw ex;
    }
    unsigned endIndex = (j != iEnd) ? j->startIndexOfConditions() : m_conditionResults.size();
 
    if (endIndex < i->startIndexOfConditions()) {
      cms::Exception ex("L1GlobalTrigger");
      ex << "startIndexOfConditions decreases or exceeds the size of m_conditionResults";
      ex.addContext("Calling L1GlobalTriggerObjectMaps::consistencyCheck");
      throw ex;
    }
  }
  for (std::vector<ConditionResult>::const_iterator i = m_conditionResults.begin(), iEnd = m_conditionResults.end();
       i != iEnd;
       ++i) {
    std::vector<ConditionResult>::const_iterator j = i;
    ++j;
    unsigned endIndex = (j != iEnd) ? j->startIndexOfCombinations() : m_combinations.size();
 
    if (endIndex < i->startIndexOfCombinations()) {
      cms::Exception ex("L1GlobalTrigger");
      ex << "startIndexOfCombinations decreases or exceeds the size of m_conditionResults";
      ex.addContext("Calling L1GlobalTriggerObjectMaps::consistencyCheck");
      throw ex;
    }
    unsigned length = endIndex - i->startIndexOfCombinations();
    if (length == 0U) {
      if (i->nObjectsPerCombination() != 0U) {
        cms::Exception ex("L1GlobalTrigger");
        ex << "Length is zero and nObjectsInCombination is not zero";
        ex.addContext("Calling L1GlobalTriggerObjectMaps::consistencyCheck");
        throw ex;
      }
    } else {
      if (i->nObjectsPerCombination() == 0 || length % i->nObjectsPerCombination() != 0) {
        cms::Exception ex("L1GlobalTrigger");
        ex << "Size indicated by startIndexOfCombinations is not a multiple of nObjectsInCombination";
        ex.addContext("Calling L1GlobalTriggerObjectMaps::consistencyCheck");
        throw ex;
      }
    }
  }
}

References cms::Exception::addContext(), mps_fire::i, dqmiolumiharvest::j, m_algorithmResults, m_combinations, m_conditionResults, and mitigatedMETSequence_cff::U.

Referenced by pat::PATTriggerProducer::produce().

getAlgorithmBitNumbers()

void L1GlobalTriggerObjectMaps::getAlgorithmBitNumbers

(

std::vector< int > &

algorithmBitNumbers

)

const

Fills the vector with all the algorithm bit numbers.

Definition at line 70 of file L1GlobalTriggerObjectMaps.cc.

                                                                                                {
  algorithmBitNumbers.clear();
  for (std::vector<AlgorithmResult>::const_iterator i = m_algorithmResults.begin(), iEnd = m_algorithmResults.end();
       i != iEnd;
       ++i) {
    algorithmBitNumbers.push_back(i->algorithmBitNumber());
  }
}

References mps_fire::i, and m_algorithmResults.

Referenced by CompareToObjectMapRecord::analyze().

getCombinationsInCondition()

L1GlobalTriggerObjectMaps::CombinationsInCondition L1GlobalTriggerObjectMaps::getCombinationsInCondition	(	int	algorithmBitNumber,
		unsigned	conditionNumber
	)		const

Each condition can be satisfied by multiple combinations of L1 objects. The number, order, and type of objects associated with each condition is defined in the L1 Trigger Menu. The following function returns an object which has a function that returns the index into the L1 Object Collections of each object in each combination.

Definition at line 94 of file L1GlobalTriggerObjectMaps.cc.

                                                            {
  unsigned startIndex = 0;
  unsigned endIndex = 0;
  getStartEndIndex(algorithmBitNumber, startIndex, endIndex);
 
  if (endIndex <= startIndex + conditionNumber) {
    cms::Exception ex("L1GlobalTrigger");
    ex << "Condition number is out of range";
    ex.addContext("Calling L1GlobalTriggerObjectMaps::getCombinationsInCondition");
    throw ex;
  }
 
  unsigned endObjectIndex = m_combinations.size();
  unsigned nextConditionIndex = startIndex + conditionNumber + 1U;
  if (nextConditionIndex < m_conditionResults.size()) {
    endObjectIndex = m_conditionResults[nextConditionIndex].startIndexOfCombinations();
  }
  unsigned beginObjectIndex = m_conditionResults[startIndex + conditionNumber].startIndexOfCombinations();
  unsigned short nObjectsPerCombination = m_conditionResults[startIndex + conditionNumber].nObjectsPerCombination();
 
  if (endObjectIndex == beginObjectIndex) {
    return CombinationsInCondition(nullptr, 0, 0);
  }
  if (endObjectIndex < beginObjectIndex || m_combinations.size() < endObjectIndex || nObjectsPerCombination == 0 ||
      (endObjectIndex - beginObjectIndex) % nObjectsPerCombination != 0) {
    cms::Exception ex("L1GlobalTrigger");
    ex << "Indexes to combinations are invalid";
    ex.addContext("Calling L1GlobalTriggerObjectMaps::getCombinationsInCondition");
    throw ex;
  }
  return CombinationsInCondition(&m_combinations[beginObjectIndex],
                                 (endObjectIndex - beginObjectIndex) / nObjectsPerCombination,
                                 nObjectsPerCombination);
}

References cms::Exception::addContext(), getStartEndIndex(), m_combinations, m_conditionResults, and mitigatedMETSequence_cff::U.

Referenced by CompareToObjectMapRecord::analyze(), and pat::PATTriggerProducer::produce().

getConditionsInAlgorithm()

L1GlobalTriggerObjectMaps::ConditionsInAlgorithm L1GlobalTriggerObjectMaps::getConditionsInAlgorithm

(

int

algorithmBitNumber

)

const

Return an object which has a function that returns the results of the conditions associated with an algorithm.

Definition at line 86 of file L1GlobalTriggerObjectMaps.cc.

                                  {
  unsigned startIndex = 0;
  unsigned endIndex = 0;
  getStartEndIndex(algorithmBitNumber, startIndex, endIndex);
  return ConditionsInAlgorithm(&m_conditionResults[startIndex], endIndex - startIndex);
}

References getStartEndIndex(), and m_conditionResults.

Referenced by CompareToObjectMapRecord::analyze(), and pat::PATTriggerProducer::produce().

getNumberOfConditions()

unsigned L1GlobalTriggerObjectMaps::getNumberOfConditions

(

int

algorithmBitNumber

)

const

Number of conditions associated with an algorithm.

Definition at line 79 of file L1GlobalTriggerObjectMaps.cc.

                                                                                      {
  unsigned startIndex = 0;
  unsigned endIndex = 0;
  getStartEndIndex(algorithmBitNumber, startIndex, endIndex);
  return endIndex - startIndex;
}

References getStartEndIndex().

Referenced by CompareToObjectMapRecord::analyze().

getStartEndIndex()

void L1GlobalTriggerObjectMaps::getStartEndIndex ( int  algorithmBitNumber, unsigned &  startIndex, unsigned &  endIndex  ) const

private

Definition at line 279 of file L1GlobalTriggerObjectMaps.cc.

                                                                           {
  std::vector<AlgorithmResult>::const_iterator iAlgo = std::lower_bound(
      m_algorithmResults.begin(), m_algorithmResults.end(), AlgorithmResult(0, algorithmBitNumber, false));
 
  if (iAlgo == m_algorithmResults.end() || iAlgo->algorithmBitNumber() != algorithmBitNumber) {
    cms::Exception ex("L1GlobalTrigger");
    ex << "algorithmBitNumber not found";
    ex.addContext("Calling L1GlobalTriggerObjectMaps::getStartEndIndex");
    throw ex;
  }
 
  startIndex = iAlgo->startIndexOfConditions();
  ++iAlgo;
  endIndex = (iAlgo != m_algorithmResults.end()) ? iAlgo->startIndexOfConditions() : m_conditionResults.size();
 
  if (endIndex < startIndex || m_conditionResults.size() < endIndex) {
    cms::Exception ex("L1GlobalTrigger");
    ex << "index out of order or out of range";
    ex.addContext("Calling L1GlobalTriggerObjectMaps::getStartEndIndex");
    throw ex;
  }
}

References cms::Exception::addContext(), cuda_std::lower_bound(), m_algorithmResults, and m_conditionResults.

Referenced by getCombinationsInCondition(), getConditionsInAlgorithm(), getNumberOfConditions(), and updateOperandTokenVector().

namesParameterSetID()

edm::ParameterSetID const& L1GlobalTriggerObjectMaps::namesParameterSetID ( ) const

inline

Returns the ID of the ParameterSet containing the algorithm names and condition names.

Definition at line 64 of file L1GlobalTriggerObjectMaps.h.

{ return m_namesParameterSetID; }

References m_namesParameterSetID.

Referenced by CompareToObjectMapRecord::analyze(), and pat::PATTriggerProducer::produce().

pushBackAlgorithm()

void L1GlobalTriggerObjectMaps::pushBackAlgorithm	(	unsigned	startIndexOfConditions,
		int	algorithmBitNumber,
		bool	algorithmResult
	)

Definition at line 132 of file L1GlobalTriggerObjectMaps.cc.

                                                                        {
  m_algorithmResults.push_back(AlgorithmResult(startIndexOfConditions, algorithmBitNumber, algorithmResult));
}

References algorithmResult(), and m_algorithmResults.

pushBackCondition()

void L1GlobalTriggerObjectMaps::pushBackCondition	(	unsigned	startIndexOfCombinations,
		unsigned short	nObjectsPerCombination,
		bool	conditionResult
	)

Definition at line 195 of file L1GlobalTriggerObjectMaps.cc.

                                                                        {
  m_conditionResults.push_back(ConditionResult(startIndexOfCombinations, nObjectsPerCombination, conditionResult));
}

References m_conditionResults.

pushBackObjectIndex()

void L1GlobalTriggerObjectMaps::pushBackObjectIndex

(

unsigned char

objectIndex

)

Definition at line 203 of file L1GlobalTriggerObjectMaps.cc.

                                                                             {
  m_combinations.push_back(objectIndex);
}

References m_combinations.

reserveForAlgorithms()

void L1GlobalTriggerObjectMaps::reserveForAlgorithms

(

unsigned

n

)

Definition at line 130 of file L1GlobalTriggerObjectMaps.cc.

{ m_algorithmResults.reserve(n); }

References m_algorithmResults, and dqmiodumpmetadata::n.

reserveForConditions()

void L1GlobalTriggerObjectMaps::reserveForConditions

(

unsigned

n

)

Definition at line 193 of file L1GlobalTriggerObjectMaps.cc.

{ m_conditionResults.reserve(n); }

References m_conditionResults, and dqmiodumpmetadata::n.

reserveForObjectIndexes()

void L1GlobalTriggerObjectMaps::reserveForObjectIndexes

(

unsigned

n

)

Definition at line 201 of file L1GlobalTriggerObjectMaps.cc.

{ m_combinations.reserve(n); }

References m_combinations, and dqmiodumpmetadata::n.

setNamesParameterSetID()

void L1GlobalTriggerObjectMaps::setNamesParameterSetID

(

edm::ParameterSetID const &

psetID

)

Definition at line 207 of file L1GlobalTriggerObjectMaps.cc.

                                                                                      {
  m_namesParameterSetID = psetID;
}

References m_namesParameterSetID.

swap()

void L1GlobalTriggerObjectMaps::swap

(

L1GlobalTriggerObjectMaps &

rh

)

Definition at line 23 of file L1GlobalTriggerObjectMaps.cc.

                                                                  {
  m_algorithmResults.swap(rh.m_algorithmResults);
  m_conditionResults.swap(rh.m_conditionResults);
  m_combinations.swap(rh.m_combinations);
  m_namesParameterSetID.swap(rh.m_namesParameterSetID);
}

References m_algorithmResults, m_combinations, m_conditionResults, m_namesParameterSetID, and edm::Hash< I >::swap().

updateOperandTokenVector()

void L1GlobalTriggerObjectMaps::updateOperandTokenVector	(	int	algorithmBitNumber,
		std::vector< L1GtLogicParser::OperandToken > &	operandTokenVector
	)		const

Update the condition result in the operandTokenVector.

Definition at line 51 of file L1GlobalTriggerObjectMaps.cc.

                                                                                              {
  unsigned startIndex = 0;
  unsigned endIndex = 0;
  getStartEndIndex(algorithmBitNumber, startIndex, endIndex);
 
  unsigned length = endIndex - startIndex;
  if (length != operandTokenVector.size()) {
    cms::Exception ex("L1GlobalTrigger");
    ex << "operand token vector size does not match number of conditions";
    ex.addContext("Calling L1GlobalTriggerObjectMaps::updateOperandTokenVector");
    throw ex;
  }
 
  for (unsigned i = 0; i < length; ++i) {
    operandTokenVector[i].tokenResult = m_conditionResults[startIndex + i].conditionResult();
  }
}

References cms::Exception::addContext(), getStartEndIndex(), mps_fire::i, and m_conditionResults.

Member Data Documentation

m_algorithmResults

std::vector<AlgorithmResult> L1GlobalTriggerObjectMaps::m_algorithmResults

private

Definition at line 157 of file L1GlobalTriggerObjectMaps.h.

Referenced by algorithmExists(), algorithmResult(), consistencyCheck(), getAlgorithmBitNumbers(), getStartEndIndex(), pushBackAlgorithm(), reserveForAlgorithms(), and swap().

m_combinations

std::vector<unsigned char> L1GlobalTriggerObjectMaps::m_combinations

private

Definition at line 159 of file L1GlobalTriggerObjectMaps.h.

Referenced by consistencyCheck(), getCombinationsInCondition(), pushBackObjectIndex(), reserveForObjectIndexes(), and swap().

m_conditionResults

std::vector<ConditionResult> L1GlobalTriggerObjectMaps::m_conditionResults

private

Definition at line 158 of file L1GlobalTriggerObjectMaps.h.

Referenced by consistencyCheck(), getCombinationsInCondition(), L1GlobalTriggerObjectMaps::ConditionsInAlgorithm::getConditionResult(), getConditionsInAlgorithm(), getStartEndIndex(), pushBackCondition(), reserveForConditions(), swap(), and updateOperandTokenVector().

m_namesParameterSetID

edm::ParameterSetID L1GlobalTriggerObjectMaps::m_namesParameterSetID

private

Definition at line 160 of file L1GlobalTriggerObjectMaps.h.

Referenced by namesParameterSetID(), setNamesParameterSetID(), and swap().