L1GTAlgoBlockProducer Class Reference

Inheritance diagram for L1GTAlgoBlockProducer:

Classes
struct	AlgoDefinition

Public Member Functions
void	beginRun (const edm::Run &iRun, const edm::EventSetup &iSetup) override
	L1GTAlgoBlockProducer (const edm::ParameterSet &)
	~L1GTAlgoBlockProducer () override=default
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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::map< std::string, AlgoDefinition >	algoDefinitions_
edm::GetterOfProducts< P2GTCandidateVectorRef >	getterOfPassedReferences_

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

Definition at line 314 of file L1GTAlgoBlockProducer.cc.

Constructor & Destructor Documentation

L1GTAlgoBlockProducer()

L1GTAlgoBlockProducer::L1GTAlgoBlockProducer ( const edm::ParameterSet &  config )

explicit

Definition at line 347 of file L1GTAlgoBlockProducer.cc.

References ALCARECOPromptCalibProdSiPixelAli0T_cff::algoConfig, algoDefinitions_, L1GTAlgoBlockProducer::AlgoDefinition::evaluator_, Exception, pathStatusExpression::ShuntingYardAlgorithm::finish(), getterOfPassedReferences_, hltEGL1SeedsForDoubleEleIsolatedFilter_cfi::logicalExpression, eostools::move(), Skims_PA_cff::name, hltMonBTagIPClient_cfi::pathName, pathStatusExpression::ShuntingYardAlgorithm::pathNames(), L1GTAlgoBlockProducer::AlgoDefinition::pathNames_, and AlCaHLTBitMon_QueryRunRegistry::string.

    : getterOfPassedReferences_(edm::TypeMatch(), this) {
  edm::ConsumesCollector iC(consumesCollector());

  for (const auto& algoConfig : config.getParameterSetVector("algorithms")) {
    const std::string logicalExpression = algoConfig.getParameter<std::string>("expression");
    std::string name = algoConfig.getParameter<std::string>("name");
    if (name.empty()) {
      name = logicalExpression;
    }

    pathStatusExpression::ShuntingYardAlgorithm shuntingYardAlgorithm;
    pathStatusExpression::Grammar<std::string::const_iterator> grammar(&shuntingYardAlgorithm);

    auto it = logicalExpression.cbegin();
    if (!qi::phrase_parse(it, logicalExpression.cend(), grammar, ascii::space) || (it != logicalExpression.cend())) {
      throw cms::Exception("Configuration") << "Syntax error in logical expression. Here is an example of how\n"
                                            << "the syntax should look:\n"
                                            << "    \"path1 and not (path2 or not path3)\"\n"
                                            << "The expression must contain alternating appearances of operands\n"
                                            << "which are path names and binary operators which can be \'and\'\n"
                                            << "or \'or\', with a path name at the beginning and end. There\n"
                                            << "must be at least one path name. In addition to the alternating\n"
                                            << "path names and binary operators, the unary operator \'not\' can\n"
                                            << "be inserted before a path name or a begin parenthesis.\n"
                                            << "Parentheses are allowed. Parentheses must come in matching pairs.\n"
                                            << "Matching begin and end parentheses must contain a complete and\n"
                                            << "syntactically correct logical expression. There must be at least\n"
                                            << "one space or parenthesis between operators and path names. Extra\n"
                                            << "space is ignored and OK. Path names can only contain upper and\n"
                                            << "lower case letters, numbers, and underscores. A path name cannot\n"
                                            << "be the same as an operator name.\n";
    }

    AlgoDefinition definition;

    for (const std::string& pathName : shuntingYardAlgorithm.pathNames()) {
      definition.pathNames_.push_back(pathName);
    }

    definition.evaluator_ = shuntingYardAlgorithm.finish();

    definition.evaluator_->init(iC);
    algoDefinitions_.emplace(std::move(name), std::move(definition));
  }

  callWhenNewProductsRegistered(getterOfPassedReferences_);
  produces<P2GTAlgoBlockCollection>();
}

~L1GTAlgoBlockProducer()

L1GTAlgoBlockProducer::~L1GTAlgoBlockProducer ( )

overridedefault

Member Function Documentation

beginRun()

void L1GTAlgoBlockProducer::beginRun ( const edm::Run &  iRun, const edm::EventSetup &  iSetup  )

override

Definition at line 397 of file L1GTAlgoBlockProducer.cc.

References algoDefinitions_, looper::cfg, edm::ProcessHistory::getConfigurationForProcess(), edm::pset::Registry::getMapped(), EgammaHLTValidationUtils::getProcessName(), edm::pset::Registry::instance(), instance, mod(), Skims_PA_cff::name, hltMonBTagIPClient_cfi::pathName, edm::Run::processHistory(), muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                    {
  const std::string& pName = edm::Service<edm::service::TriggerNamesService>()->getProcessName();

  edm::ProcessConfiguration cfg;

  iRun.processHistory().getConfigurationForProcess(pName, cfg);

  const edm::ParameterSet* pset = edm::pset::Registry::instance()->getMapped(cfg.parameterSetID());

  for (auto& [name, algoDef] : algoDefinitions_) {
    for (const std::string& pathName : algoDef.pathNames_) {
      if (pset->existsAs<std::vector<std::string>>(pathName)) {
        const auto& modules = pset->getParameter<std::vector<std::string>>(pathName);
        for (const auto& mod : modules) {
          if (mod.front() != std::string("-") && pset->exists(mod)) {
            const auto& modPSet = pset->getParameterSet(mod);
            if (modPSet.getParameter<std::string>("@module_edm_type") == "EDFilter") {
              if (modPSet.getParameter<std::string>("@module_type") == "L1GTSingleObjectCond") {
                algoDef.filtModules_.insert({mod, modPSet.getParameter<edm::InputTag>("tag").instance()});
              } else if (modPSet.getParameter<std::string>("@module_type") == "L1GTDoubleObjectCond") {
                algoDef.filtModules_.insert(
                    {mod, modPSet.getParameterSet("collection1").getParameter<edm::InputTag>("tag").instance()});
                algoDef.filtModules_.insert(
                    {mod, modPSet.getParameterSet("collection2").getParameter<edm::InputTag>("tag").instance()});
              } else if (modPSet.getParameter<std::string>("@module_type") == "L1GTTripleObjectCond") {
                algoDef.filtModules_.insert(
                    {mod, modPSet.getParameterSet("collection1").getParameter<edm::InputTag>("tag").instance()});
                algoDef.filtModules_.insert(
                    {mod, modPSet.getParameterSet("collection2").getParameter<edm::InputTag>("tag").instance()});
                algoDef.filtModules_.insert(
                    {mod, modPSet.getParameterSet("collection3").getParameter<edm::InputTag>("tag").instance()});
              } else if (modPSet.getParameter<std::string>("@module_type") == "L1GTQuadObjectCond") {
                algoDef.filtModules_.insert(
                    {mod, modPSet.getParameterSet("collection1").getParameter<edm::InputTag>("tag").instance()});
                algoDef.filtModules_.insert(
                    {mod, modPSet.getParameterSet("collection2").getParameter<edm::InputTag>("tag").instance()});
                algoDef.filtModules_.insert(
                    {mod, modPSet.getParameterSet("collection3").getParameter<edm::InputTag>("tag").instance()});
                algoDef.filtModules_.insert(
                    {mod, modPSet.getParameterSet("collection4").getParameter<edm::InputTag>("tag").instance()});
              }
            }
          }
        }
      }
    }
  }
}

fillDescriptions()

void L1GTAlgoBlockProducer::fillDescriptions ( edm::ConfigurationDescriptions &  description )

static

Definition at line 336 of file L1GTAlgoBlockProducer.cc.

References edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, makeListRunsInFiles::description, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                      {
  edm::ParameterSetDescription algoDesc;
  algoDesc.add<std::string>("name", "");
  algoDesc.add<std::string>("expression");

  edm::ParameterSetDescription desc;
  desc.addVPSet("algorithms", algoDesc);

  description.addWithDefaultLabel(desc);
}

produce()

void L1GTAlgoBlockProducer::produce ( edm::Event &  event, const edm::EventSetup &  eventSetup  )

overrideprivate

Definition at line 446 of file L1GTAlgoBlockProducer.cc.

References correctedPhotons_cfi::algoCollection, algoDefinitions_, edm::GetterOfProducts< T >::fillHandles(), getterOfPassedReferences_, patZpeak::handle, instance, eostools::move(), Skims_PA_cff::name, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                    {
  std::vector<edm::Handle<P2GTCandidateVectorRef>> handles;
  getterOfPassedReferences_.fillHandles(event, handles);

  std::unique_ptr<P2GTAlgoBlockCollection> algoCollection = std::make_unique<P2GTAlgoBlockCollection>();
  algoCollection->reserve(algoDefinitions_.size());

  for (const auto& [name, algoDef] : algoDefinitions_) {
    bool initial = algoDef.evaluator_->evaluate(event);
    // TODO apply prescale and bunch mask

    P2GTCandidateVectorRef trigObjects;

    if (initial) {
      for (const auto& handle : handles) {
        const std::string& module = handle.provenance()->moduleLabel();
        const std::string& instance = handle.provenance()->productInstanceName();

        if (algoDef.filtModules_.count({module, instance}) > 0) {
          trigObjects.insert(trigObjects.end(), handle->begin(), handle->end());
        }
      }
    }

    algoCollection->emplace_back(name, initial, initial, initial, std::move(trigObjects));
  }

  event.put(std::move(algoCollection));
}

Member Data Documentation

algoDefinitions_

std::map<std::string, AlgoDefinition> L1GTAlgoBlockProducer::algoDefinitions_

private

Definition at line 333 of file L1GTAlgoBlockProducer.cc.

Referenced by beginRun(), L1GTAlgoBlockProducer(), and produce().

getterOfPassedReferences_

edm::GetterOfProducts<P2GTCandidateVectorRef> L1GTAlgoBlockProducer::getterOfPassedReferences_

private

Definition at line 332 of file L1GTAlgoBlockProducer.cc.

Referenced by L1GTAlgoBlockProducer(), and produce().