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
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Private Attributes
edm::EDGetTokenT< L1GlobalTriggerObjectMapRecord >	m_l1GtObjectMapToken

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::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.

References cms::Exception::addContext(), edm::ParameterSet::addParameter(), L1GlobalTriggerObjectMap::algoBitNumber(), L1GlobalTriggerObjectMap::algoGtlResult(), L1GlobalTriggerObjectMap::algoName(), 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.

                                                                             {
  // 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));
}

Member Data Documentation

m_l1GtObjectMapToken

edm::EDGetTokenT<L1GlobalTriggerObjectMapRecord> ConvertObjectMapRecord::m_l1GtObjectMapToken

private

Definition at line 36 of file ConvertObjectMapRecord.h.

Referenced by produce().