ConvertObjectMapRecord Class Reference

#include <ConvertObjectMapRecord.h>

Inheritance diagram for ConvertObjectMapRecord:

Public Member Functions
	ConvertObjectMapRecord (const edm::ParameterSet &pset)
void	produce (edm::Event &event, const edm::EventSetup &es) override
	~ConvertObjectMapRecord () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

Private Attributes
edm::EDGetTokenT< L1GlobalTriggerObjectMapRecord >	m_l1GtObjectMapToken

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Description: see header file.

Implementation: <TODO: enter implementation details>

Author

: Vasile Mihai Ghete - HEPHY Vienna

: W. David Dagenhart

Description: Reads in the L1GlobalTriggerObjectMapRecord and copies the information it contains into a L1GlobalTriggerObjectMaps object and also puts the names it contains into the ParameterSet registry.

Implementation: <TODO: enter implementation details>

Author

: Vasile Mihai Ghete - HEPHY Vienna

: W. David Dagenhart

Definition at line 28 of file ConvertObjectMapRecord.h.

Constructor & Destructor Documentation

ConvertObjectMapRecord()

ConvertObjectMapRecord::ConvertObjectMapRecord ( const edm::ParameterSet &  pset )

explicit

Definition at line 34 of file ConvertObjectMapRecord.cc.

    : m_l1GtObjectMapToken(
          consumes<L1GlobalTriggerObjectMapRecord>(pset.getParameter<edm::InputTag>("L1GtObjectMapTag"))) {
  produces<L1GlobalTriggerObjectMaps>();
}

~ConvertObjectMapRecord()

ConvertObjectMapRecord::~ConvertObjectMapRecord ( )

override

Definition at line 40 of file ConvertObjectMapRecord.cc.

{}

Member Function Documentation

produce()

void ConvertObjectMapRecord::produce ( edm::Event &  event, const edm::EventSetup &  es  )

override

Definition at line 42 of file ConvertObjectMapRecord.cc.

                                                                             {
  // Read in the existing object from the data
  edm::Handle<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord;
  event.getByToken(m_l1GtObjectMapToken, gtObjectMapRecord);
 
  if (!gtObjectMapRecord.isValid()) {
    return;
  }
 
  // Create the new object we are going to copy the information to
  std::unique_ptr<L1GlobalTriggerObjectMaps> gtObjectMaps(new L1GlobalTriggerObjectMaps);
 
  // get the algorithm bit numbers and sort them
  std::vector<int> algoBitNumbers;
  std::vector<L1GlobalTriggerObjectMap> const &vectorInRecord = gtObjectMapRecord->gtObjectMap();
  algoBitNumbers.reserve(vectorInRecord.size());
  for (std::vector<L1GlobalTriggerObjectMap>::const_iterator i = vectorInRecord.begin(), iEnd = vectorInRecord.end();
       i != iEnd;
       ++i) {
    algoBitNumbers.push_back(i->algoBitNumber());
  }
  edm::sort_all(algoBitNumbers);
 
  gtObjectMaps->reserveForAlgorithms(algoBitNumbers.size());
 
  if (!algoBitNumbers.empty() && algoBitNumbers[0] < 0) {
    cms::Exception ex("L1GlobalTrigger");
    ex << "Negative algorithm bit number";
    ex.addContext("Calling ConvertObjectMapRecord::produce");
    throw ex;
  }
 
  unsigned sizeOfNamesVector = 0;
  if (!algoBitNumbers.empty()) {
    sizeOfNamesVector = static_cast<unsigned>(algoBitNumbers.back()) + 1;
  }
  std::vector<std::string> savedNames(sizeOfNamesVector);
 
  // Loop over the object map record and copy the algorithm information
  // Just count the condition and index information so we can reserve
  // memory for them before filling them.
  unsigned startIndexOfConditions = 0;
  unsigned nIndexes = 0;
 
  for (std::vector<int>::const_iterator iBit = algoBitNumbers.begin(), endBits = algoBitNumbers.end(); iBit != endBits;
       ++iBit) {
    L1GlobalTriggerObjectMap const *objMap = gtObjectMapRecord->getObjectMap(*iBit);
 
    gtObjectMaps->pushBackAlgorithm(startIndexOfConditions, objMap->algoBitNumber(), objMap->algoGtlResult());
 
    savedNames.at(static_cast<unsigned>(*iBit)) = objMap->algoName();
 
    std::vector<L1GtLogicParser::OperandToken> const &operandTokens = objMap->operandTokenVector();
 
    startIndexOfConditions += operandTokens.size();
 
    int tokenCounter = 0;
    for (std::vector<L1GtLogicParser::OperandToken>::const_iterator iToken = operandTokens.begin(),
                                                                    endTokens = operandTokens.end();
         iToken != endTokens;
         ++iToken, ++tokenCounter) {
      if (tokenCounter != iToken->tokenNumber) {
        cms::Exception ex("L1GlobalTrigger");
        ex << "Token numbers not sequential";
        ex.addContext("Calling ConvertObjectMapRecord::produce");
        throw ex;
      }
 
      CombinationsInCond const *combos = objMap->getCombinationsInCond(iToken->tokenNumber);
      for (CombinationsInCond::const_iterator iCombo = combos->begin(), endCombos = combos->end(); iCombo != endCombos;
           ++iCombo) {
        for (std::vector<int>::const_iterator iIndex = iCombo->begin(), endIndexes = iCombo->end();
             iIndex != endIndexes;
             ++iIndex) {
          ++nIndexes;
        }
      }
    }
  }
  gtObjectMaps->reserveForConditions(startIndexOfConditions);
  gtObjectMaps->reserveForObjectIndexes(nIndexes);
 
  edm::ParameterSet namesPset;
  namesPset.addParameter<std::vector<std::string>>(std::string("@algorithmNames"), savedNames);
 
  // Now loop a second time and fill the condition and index
  // information.
  unsigned startIndexOfCombinations = 0;
  for (std::vector<int>::const_iterator iBit = algoBitNumbers.begin(), endBits = algoBitNumbers.end(); iBit != endBits;
       ++iBit) {
    L1GlobalTriggerObjectMap const *objMap = gtObjectMapRecord->getObjectMap(*iBit);
 
    std::vector<L1GtLogicParser::OperandToken> const &operandTokens = objMap->operandTokenVector();
 
    savedNames.clear();
    if (savedNames.capacity() < operandTokens.size()) {
      savedNames.reserve(operandTokens.size());
    }
 
    for (std::vector<L1GtLogicParser::OperandToken>::const_iterator iToken = operandTokens.begin(),
                                                                    endTokens = operandTokens.end();
         iToken != endTokens;
         ++iToken) {
      savedNames.push_back(iToken->tokenName);
 
      unsigned short nObjectsPerCombination = 0;
      bool first = true;
      unsigned nIndexesInCombination = 0;
 
      CombinationsInCond const *combos = objMap->getCombinationsInCond(iToken->tokenNumber);
      for (CombinationsInCond::const_iterator iCombo = combos->begin(), endCombos = combos->end(); iCombo != endCombos;
           ++iCombo) {
        if (first) {
          if (iCombo->size() > std::numeric_limits<unsigned short>::max()) {
            cms::Exception ex("L1GlobalTrigger");
            ex << "Number of objects per combination out of range";
            ex.addContext("Calling ConvertObjectMapRecord::produce");
            throw ex;
          }
          nObjectsPerCombination = iCombo->size();
          first = false;
        } else {
          if (nObjectsPerCombination != iCombo->size()) {
            cms::Exception ex("L1GlobalTrigger");
            ex << "inconsistent number of objects per condition";
            ex.addContext("Calling ConvertObjectMapRecord::produce");
            throw ex;
          }
        }
 
        for (std::vector<int>::const_iterator iIndex = iCombo->begin(), endIndexes = iCombo->end();
             iIndex != endIndexes;
             ++iIndex) {
          if (*iIndex < 0 || *iIndex > std::numeric_limits<unsigned char>::max()) {
            cms::Exception ex("L1GlobalTrigger");
            ex << "object index too large, out of range";
            ex.addContext("Calling ConvertObjectMapRecord::produce");
            throw ex;
          }
          gtObjectMaps->pushBackObjectIndex(*iIndex);
          ++nIndexesInCombination;
        }
      }
      gtObjectMaps->pushBackCondition(startIndexOfCombinations, nObjectsPerCombination, iToken->tokenResult);
      startIndexOfCombinations += nIndexesInCombination;
    }
    namesPset.addParameter<std::vector<std::string>>(objMap->algoName(), savedNames);
  }
  namesPset.registerIt();
  gtObjectMaps->setNamesParameterSetID(namesPset.id());
 
  gtObjectMaps->consistencyCheck();
  event.put(std::move(gtObjectMaps));
}

References cms::Exception::addContext(), edm::ParameterSet::addParameter(), L1GlobalTriggerObjectMap::algoBitNumber(), L1GlobalTriggerObjectMap::algoGtlResult(), L1GlobalTriggerObjectMap::algoName(), dqmdumpme::first, L1GlobalTriggerObjectMap::getCombinationsInCond(), L1GlobalTriggerObjectMapRecord::getObjectMap(), L1GlobalTriggerObjectMapRecord::gtObjectMap(), mps_fire::i, edm::ParameterSet::id(), edm::HandleBase::isValid(), m_l1GtObjectMapToken, SiStripPI::max, eostools::move(), L1GlobalTriggerObjectMap::operandTokenVector(), edm::ParameterSet::registerIt(), edm::sort_all(), and AlCaHLTBitMon_QueryRunRegistry::string.

Member Data Documentation

m_l1GtObjectMapToken

edm::EDGetTokenT<L1GlobalTriggerObjectMapRecord> ConvertObjectMapRecord::m_l1GtObjectMapToken

private

Definition at line 36 of file ConvertObjectMapRecord.h.

Referenced by produce().