L1GlobalTriggerObjectMaps.cc

Go to the documentation of this file.

#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMaps.h"

#include <algorithm>
#include <limits>

#include "FWCore/Utilities/interface/Exception.h"

void L1GlobalTriggerObjectMaps::swap(L1GlobalTriggerObjectMaps& rh) {
  m_algorithmResults.swap(rh.m_algorithmResults);
  m_conditionResults.swap(rh.m_conditionResults);
  m_combinations.swap(rh.m_combinations);
  m_namesParameterSetID.swap(rh.m_namesParameterSetID);
}

bool L1GlobalTriggerObjectMaps::algorithmExists(int algorithmBitNumber) const {
  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;
}

bool L1GlobalTriggerObjectMaps::algorithmResult(int algorithmBitNumber) const {
  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();
}

void L1GlobalTriggerObjectMaps::
updateOperandTokenVector(int algorithmBitNumber,
                         std::vector<L1GtLogicParser::OperandToken>& operandTokenVector) const {
  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();
  }
}

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

unsigned L1GlobalTriggerObjectMaps::
getNumberOfConditions(int algorithmBitNumber) const {

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

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

L1GlobalTriggerObjectMaps::CombinationsInCondition L1GlobalTriggerObjectMaps::
getCombinationsInCondition(int algorithmBitNumber,
                           unsigned conditionNumber) const {
  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);
}

void L1GlobalTriggerObjectMaps::
reserveForAlgorithms(unsigned n) {
  m_algorithmResults.reserve(n);
}

void L1GlobalTriggerObjectMaps::
pushBackAlgorithm(unsigned startIndexOfConditions,
                  int algorithmBitNumber,
                  bool algorithmResult) {
  m_algorithmResults.push_back(AlgorithmResult(startIndexOfConditions,
                                               algorithmBitNumber,
                                               algorithmResult));
}

void L1GlobalTriggerObjectMaps::consistencyCheck() const {
  // 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;
      }
    }
  }
}

void L1GlobalTriggerObjectMaps::
reserveForConditions(unsigned n) {
  m_conditionResults.reserve(n);
}

void L1GlobalTriggerObjectMaps::
pushBackCondition(unsigned startIndexOfCombinations,
                  unsigned short nObjectsPerCombination,
                  bool conditionResult) {
  m_conditionResults.push_back(ConditionResult(startIndexOfCombinations,
                                               nObjectsPerCombination,
                                               conditionResult));
}

void L1GlobalTriggerObjectMaps::
reserveForObjectIndexes(unsigned n) {
  m_combinations.reserve(n);
}

void L1GlobalTriggerObjectMaps::
pushBackObjectIndex(unsigned char objectIndex) {
  m_combinations.push_back(objectIndex);
}

void L1GlobalTriggerObjectMaps::
setNamesParameterSetID(edm::ParameterSetID const& psetID) {
  m_namesParameterSetID = psetID;
}

L1GlobalTriggerObjectMaps::AlgorithmResult::
AlgorithmResult() :
  m_startIndexOfConditions(0),
  m_algorithmBitNumber(0),
  m_algorithmResult(false) {
}

L1GlobalTriggerObjectMaps::AlgorithmResult::
AlgorithmResult(unsigned startIndexOfConditions,
                int algorithmBitNumber,
                bool algorithmResult) :
  m_startIndexOfConditions(startIndexOfConditions),
  m_algorithmResult(algorithmResult) {

  // We made the decision to try to save space in the data format
  // and fit this object into 8 bytes by making the persistent
  // algorithmBitNumber a short. This creates something very
  // ugly below.  In practice the range should never be exceeded.
  // In fact it is currently always supposed to be less than 128.
  // I hope this never comes back to haunt us for some unexpected reason.
  // I cringe when I look at it, but cannot think of any practical
  // harm ... It is probably a real bug if anyone ever
  // tries to shove a big int into here.
  if (algorithmBitNumber < std::numeric_limits<short>::min() ||
      algorithmBitNumber > std::numeric_limits<short>::max()) {
    cms::Exception ex("L1GlobalTrigger");
    ex << "algorithmBitNumber out of range of a short int";
    ex.addContext("Calling L1GlobalTriggerObjectMaps::AlgorithmResult::AlgorithmResult");
    throw ex;    
  }
  m_algorithmBitNumber = static_cast<short>(algorithmBitNumber);
}

L1GlobalTriggerObjectMaps::ConditionResult::
ConditionResult() :
  m_startIndexOfCombinations(0),
  m_nObjectsPerCombination(0),
  m_conditionResult(false) {
}

L1GlobalTriggerObjectMaps::ConditionResult::
ConditionResult(unsigned startIndexOfCombinations,
                unsigned short nObjectsPerCombination,
                bool conditionResult) :
  m_startIndexOfCombinations(startIndexOfCombinations),
  m_nObjectsPerCombination(nObjectsPerCombination),
  m_conditionResult(conditionResult) {
}

L1GlobalTriggerObjectMaps::ConditionsInAlgorithm::
ConditionsInAlgorithm(ConditionResult const* conditionResults,
                      unsigned nConditions) :
  m_conditionResults(conditionResults),
  m_nConditions(nConditions) {
}

bool L1GlobalTriggerObjectMaps::ConditionsInAlgorithm::
getConditionResult(unsigned condition) const {
  if (condition >= m_nConditions) {
    cms::Exception ex("L1GlobalTrigger");
    ex << "argument out of range";
    ex.addContext("Calling L1GlobalTriggerObjectMaps::ConditionsInAlgorithm::getConditionResult");
    throw ex;
  }
  return (m_conditionResults + condition)->conditionResult();
}

L1GlobalTriggerObjectMaps::CombinationsInCondition::
CombinationsInCondition(unsigned char const* startOfObjectIndexes,
                        unsigned nCombinations,
                        unsigned short nObjectsPerCombination) :
  m_startOfObjectIndexes(startOfObjectIndexes),
  m_nCombinations(nCombinations),
  m_nObjectsPerCombination(nObjectsPerCombination) {
}

unsigned char L1GlobalTriggerObjectMaps::CombinationsInCondition::
getObjectIndex(unsigned combination,
               unsigned object) const {
  if (combination >= m_nCombinations ||
      object >=  m_nObjectsPerCombination) {
    cms::Exception ex("L1GlobalTrigger");
    ex << "arguments out of range";
    ex.addContext("Calling L1GlobalTriggerObjectMaps::CombinationsInCondition::getObjectIndex");
    throw ex;
  }
  return m_startOfObjectIndexes[combination * m_nObjectsPerCombination + object];
}

void L1GlobalTriggerObjectMaps::
getStartEndIndex(int algorithmBitNumber, unsigned& startIndex, unsigned& endIndex) const {
  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;
  }
}