PATTriggerEventProducer.cc

Go to the documentation of this file.

//
//
 
#include "PhysicsTools/PatAlgos/plugins/PATTriggerEventProducer.h"
 
#include <cassert>
 
#include "FWCore/Utilities/interface/transform.h"
 
#include "FWCore/Framework/interface/InputTagMatch.h"
 
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/HLTReco/interface/TriggerEvent.h"
#include "CondFormats/L1TObjects/interface/L1GtTriggerMenu.h"
#include "CondFormats/DataRecord/interface/L1GtTriggerMenuRcd.h"
#include "DataFormats/Provenance/interface/ProcessHistory.h"
#include "FWCore/ParameterSet/interface/Registry.h"
 
#include "DataFormats/Common/interface/AssociativeIterator.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
using namespace pat;
using namespace edm;
 
PATTriggerEventProducer::PATTriggerEventProducer(const ParameterSet& iConfig)
    : nameProcess_(iConfig.getParameter<std::string>("processName")),
      autoProcessName_(nameProcess_ == "*"),
      tagTriggerProducer_("patTrigger"),
      tagsTriggerMatcher_(),
      // L1 configuration parameters
      tagL1Gt_(),
      // HLTConfigProvider
      hltConfigInit_(false),
      // HLT configuration parameters
      tagTriggerResults_("TriggerResults"),
      tagTriggerEvent_("hltTriggerSummaryAOD"),
      // Conditions configuration parameters
      tagCondGt_(),
      // Conditions
      condRun_(),
      condLumi_(),
      gtCondRunInit_(false),
      gtCondLumiInit_(false) {
  if (iConfig.exists("triggerResults"))
    tagTriggerResults_ = iConfig.getParameter<InputTag>("triggerResults");
  triggerResultsGetter_ =
      GetterOfProducts<TriggerResults>(InputTagMatch(InputTag(tagTriggerResults_.label(),
                                                              tagTriggerResults_.instance(),
                                                              autoProcessName_ ? std::string("") : nameProcess_)),
                                       this);
  if (iConfig.exists("triggerEvent"))
    tagTriggerEvent_ = iConfig.getParameter<InputTag>("triggerEvent");
  if (iConfig.exists("patTriggerProducer"))
    tagTriggerProducer_ = iConfig.getParameter<InputTag>("patTriggerProducer");
  triggerAlgorithmCollectionToken_ = mayConsume<TriggerAlgorithmCollection>(tagTriggerProducer_);
  triggerConditionCollectionToken_ = mayConsume<TriggerConditionCollection>(tagTriggerProducer_);
  triggerPathCollectionToken_ = mayConsume<TriggerPathCollection>(tagTriggerProducer_);
  triggerFilterCollectionToken_ = mayConsume<TriggerFilterCollection>(tagTriggerProducer_);
  triggerObjectCollectionToken_ = mayConsume<TriggerObjectCollection>(tagTriggerProducer_);
  if (iConfig.exists("condGtTag")) {
    tagCondGt_ = iConfig.getParameter<InputTag>("condGtTag");
    tagCondGtRunToken_ = mayConsume<ConditionsInRunBlock, InRun>(tagCondGt_);
    tagCondGtLumiToken_ = mayConsume<ConditionsInLumiBlock, InLumi>(tagCondGt_);
    tagCondGtEventToken_ = mayConsume<ConditionsInEventBlock>(tagCondGt_);
  }
  if (iConfig.exists("l1GtTag"))
    tagL1Gt_ = iConfig.getParameter<InputTag>("l1GtTag");
  l1GtToken_ = mayConsume<L1GlobalTriggerReadoutRecord>(tagL1Gt_);
  if (iConfig.exists("patTriggerMatches"))
    tagsTriggerMatcher_ = iConfig.getParameter<std::vector<InputTag> >("patTriggerMatches");
  triggerMatcherTokens_ = vector_transform(
      tagsTriggerMatcher_, [this](InputTag const& tag) { return mayConsume<TriggerObjectStandAloneMatch>(tag); });
 
  callWhenNewProductsRegistered([this](BranchDescription const& bd) {
    if (not(this->autoProcessName_ and bd.processName() == this->moduleDescription().processName())) {
      triggerResultsGetter_(bd);
    }
  });
 
  for (size_t iMatch = 0; iMatch < tagsTriggerMatcher_.size(); ++iMatch) {
    produces<TriggerObjectMatch>(tagsTriggerMatcher_.at(iMatch).label());
  }
  produces<TriggerEvent>();
}
 
void PATTriggerEventProducer::beginRun(const Run& iRun, const EventSetup& iSetup) {
  // Initialize process name
  if (autoProcessName_) {
    // reset
    nameProcess_ = "*";
    // determine process name from last run TriggerSummaryProducerAOD module in process history of input
    const ProcessHistory& processHistory(iRun.processHistory());
    ProcessConfiguration processConfiguration;
    ParameterSet processPSet;
    // unbroken loop, which relies on time ordering (accepts the last found entry)
    for (ProcessHistory::const_iterator iHist = processHistory.begin(); iHist != processHistory.end(); ++iHist) {
      if (processHistory.getConfigurationForProcess(iHist->processName(), processConfiguration) &&
          pset::Registry::instance()->getMapped(processConfiguration.parameterSetID(), processPSet) &&
          processPSet.exists(tagTriggerEvent_.label())) {
        nameProcess_ = iHist->processName();
        LogDebug("autoProcessName") << "HLT process name '" << nameProcess_ << "' discovered";
      }
    }
    // terminate, if nothing is found
    if (nameProcess_ == "*") {
      LogError("autoProcessName") << "trigger::TriggerEvent product with label '" << tagTriggerEvent_.label()
                                  << "' not produced according to process history of input data\n"
                                  << "No trigger information produced.";
      return;
    }
    LogInfo("autoProcessName") << "HLT process name " << nameProcess_ << " used for PAT trigger information";
  }
  // adapt configuration of used input tags
  if (tagTriggerResults_.process().empty() || tagTriggerResults_.process() == "*") {
    tagTriggerResults_ = InputTag(tagTriggerResults_.label(), tagTriggerResults_.instance(), nameProcess_);
  } else if (tagTriggerResults_.process() != nameProcess_) {
    LogWarning("triggerResultsTag") << "TriggerResults process name '" << tagTriggerResults_.process()
                                    << "' differs from HLT process name '" << nameProcess_ << "'";
  }
  if (tagTriggerEvent_.process().empty() || tagTriggerEvent_.process() == "*") {
    tagTriggerEvent_ = InputTag(tagTriggerEvent_.label(), tagTriggerEvent_.instance(), nameProcess_);
  } else if (tagTriggerEvent_.process() != nameProcess_) {
    LogWarning("triggerEventTag") << "TriggerEvent process name '" << tagTriggerEvent_.process()
                                  << "' differs from HLT process name '" << nameProcess_ << "'";
  }
 
  gtCondRunInit_ = false;
  if (!tagCondGt_.label().empty()) {
    Handle<ConditionsInRunBlock> condRunBlock;
    iRun.getByToken(tagCondGtRunToken_, condRunBlock);
    if (condRunBlock.isValid()) {
      condRun_ = *condRunBlock;
      gtCondRunInit_ = true;
    } else {
      LogError("conditionsInEdm") << "ConditionsInRunBlock product with InputTag '" << tagCondGt_.encode()
                                  << "' not in run";
    }
  }
 
  // Initialize HLTConfigProvider
  hltConfigInit_ = false;
  bool changed(true);
  if (!hltConfig_.init(iRun, iSetup, nameProcess_, changed)) {
    LogError("hltConfigExtraction") << "HLT config extraction error with process name '" << nameProcess_ << "'";
  } else if (hltConfig_.size() <= 0) {
    LogError("hltConfigSize") << "HLT config size error";
  } else
    hltConfigInit_ = true;
}
 
void PATTriggerEventProducer::beginLuminosityBlock(const LuminosityBlock& iLuminosityBlock, const EventSetup& iSetup) {
  // Terminate, if auto process name determination failed
  if (nameProcess_ == "*")
    return;
 
  gtCondLumiInit_ = false;
  if (!tagCondGt_.label().empty()) {
    Handle<ConditionsInLumiBlock> condLumiBlock;
    iLuminosityBlock.getByToken(tagCondGtLumiToken_, condLumiBlock);
    if (condLumiBlock.isValid()) {
      condLumi_ = *condLumiBlock;
      gtCondLumiInit_ = true;
    } else {
      LogError("conditionsInEdm") << "ConditionsInLumiBlock product with InputTag '" << tagCondGt_.encode()
                                  << "' not in lumi";
    }
  }
}
 
void PATTriggerEventProducer::produce(Event& iEvent, const EventSetup& iSetup) {
  // Terminate, if auto process name determination failed
  if (nameProcess_ == "*")
    return;
 
  if (!hltConfigInit_)
    return;
 
  ESHandle<L1GtTriggerMenu> handleL1GtTriggerMenu;
  iSetup.get<L1GtTriggerMenuRcd>().get(handleL1GtTriggerMenu);
  Handle<TriggerResults> handleTriggerResults;
  iEvent.getByLabel(tagTriggerResults_, handleTriggerResults);
  //   iEvent.getByToken( triggerResultsToken_, handleTriggerResults );
  if (!handleTriggerResults.isValid()) {
    LogError("triggerResultsValid") << "TriggerResults product with InputTag '" << tagTriggerResults_.encode()
                                    << "' not in event\n"
                                    << "No trigger information produced";
    return;
  }
  Handle<TriggerAlgorithmCollection> handleTriggerAlgorithms;
  iEvent.getByToken(triggerAlgorithmCollectionToken_, handleTriggerAlgorithms);
  Handle<TriggerConditionCollection> handleTriggerConditions;
  iEvent.getByToken(triggerConditionCollectionToken_, handleTriggerConditions);
  Handle<TriggerPathCollection> handleTriggerPaths;
  iEvent.getByToken(triggerPathCollectionToken_, handleTriggerPaths);
  Handle<TriggerFilterCollection> handleTriggerFilters;
  iEvent.getByToken(triggerFilterCollectionToken_, handleTriggerFilters);
  Handle<TriggerObjectCollection> handleTriggerObjects;
  iEvent.getByToken(triggerObjectCollectionToken_, handleTriggerObjects);
 
  bool physDecl(false);
  if (iEvent.isRealData() && !tagL1Gt_.label().empty()) {
    Handle<L1GlobalTriggerReadoutRecord> handleL1GlobalTriggerReadoutRecord;
    iEvent.getByToken(l1GtToken_, handleL1GlobalTriggerReadoutRecord);
    if (handleL1GlobalTriggerReadoutRecord.isValid()) {
      L1GtFdlWord fdlWord = handleL1GlobalTriggerReadoutRecord->gtFdlWord();
      if (fdlWord.physicsDeclared() == 1) {
        physDecl = true;
      }
    } else {
      LogError("l1GlobalTriggerReadoutRecordValid")
          << "L1GlobalTriggerReadoutRecord product with InputTag '" << tagL1Gt_.encode() << "' not in event";
    }
  } else {
    physDecl = true;
  }
 
  // produce trigger event
 
  auto triggerEvent = std::make_unique<TriggerEvent>(handleL1GtTriggerMenu->gtTriggerMenuName(),
                                                     std::string(hltConfig_.tableName()),
                                                     handleTriggerResults->wasrun(),
                                                     handleTriggerResults->accept(),
                                                     handleTriggerResults->error(),
                                                     physDecl);
  // set product references to trigger collections
  if (handleTriggerAlgorithms.isValid()) {
    triggerEvent->setAlgorithms(handleTriggerAlgorithms);
  } else {
    LogError("triggerAlgorithmsValid") << "pat::TriggerAlgorithmCollection product with InputTag '"
                                       << tagTriggerProducer_.encode() << "' not in event";
  }
  if (handleTriggerConditions.isValid()) {
    triggerEvent->setConditions(handleTriggerConditions);
  } else {
    LogError("triggerConditionsValid") << "pat::TriggerConditionCollection product with InputTag '"
                                       << tagTriggerProducer_.encode() << "' not in event";
  }
  if (handleTriggerPaths.isValid()) {
    triggerEvent->setPaths(handleTriggerPaths);
  } else {
    LogError("triggerPathsValid") << "pat::TriggerPathCollection product with InputTag '"
                                  << tagTriggerProducer_.encode() << "' not in event";
  }
  if (handleTriggerFilters.isValid()) {
    triggerEvent->setFilters(handleTriggerFilters);
  } else {
    LogError("triggerFiltersValid") << "pat::TriggerFilterCollection product with InputTag '"
                                    << tagTriggerProducer_.encode() << "' not in event";
  }
  if (handleTriggerObjects.isValid()) {
    triggerEvent->setObjects(handleTriggerObjects);
  } else {
    LogError("triggerObjectsValid") << "pat::TriggerObjectCollection product with InputTag '"
                                    << tagTriggerProducer_.encode() << "' not in event";
  }
  if (gtCondRunInit_) {
    triggerEvent->setLhcFill(condRun_.lhcFillNumber);
    triggerEvent->setBeamMode(condRun_.beamMode);
    triggerEvent->setBeamMomentum(condRun_.beamMomentum);
    triggerEvent->setBCurrentStart(condRun_.BStartCurrent);
    triggerEvent->setBCurrentStop(condRun_.BStopCurrent);
    triggerEvent->setBCurrentAvg(condRun_.BAvgCurrent);
  }
  if (gtCondLumiInit_) {
    triggerEvent->setIntensityBeam1(condLumi_.totalIntensityBeam1);
    triggerEvent->setIntensityBeam2(condLumi_.totalIntensityBeam2);
  }
  if (!tagCondGt_.label().empty()) {
    Handle<ConditionsInEventBlock> condEventBlock;
    iEvent.getByToken(tagCondGtEventToken_, condEventBlock);
    if (condEventBlock.isValid()) {
      triggerEvent->setBstMasterStatus(condEventBlock->bstMasterStatus);
      triggerEvent->setTurnCount(condEventBlock->turnCountNumber);
    } else {
      LogError("conditionsInEdm") << "ConditionsInEventBlock product with InputTag '" << tagCondGt_.encode()
                                  << "' not in event";
    }
  }
 
  // produce trigger match association and set references
  if (handleTriggerObjects.isValid()) {
    for (size_t iMatch = 0; iMatch < tagsTriggerMatcher_.size(); ++iMatch) {
      const std::string labelTriggerObjectMatcher(tagsTriggerMatcher_.at(iMatch).label());
      // copy trigger match association using TriggerObjectStandAlone to those using TriggerObject
      // relying on the fact, that only one candidate collection is present in the association
      Handle<TriggerObjectStandAloneMatch> handleTriggerObjectStandAloneMatch;
      iEvent.getByToken(triggerMatcherTokens_.at(iMatch), handleTriggerObjectStandAloneMatch);
      if (!handleTriggerObjectStandAloneMatch.isValid()) {
        LogError("triggerMatchValid") << "pat::TriggerObjectStandAloneMatch product with InputTag '"
                                      << labelTriggerObjectMatcher << "' not in event";
        continue;
      }
      auto it = makeAssociativeIterator<reco::CandidateBaseRef>(*handleTriggerObjectStandAloneMatch, iEvent);
      auto itEnd = it.end();
      Handle<reco::CandidateView> handleCands;
      if (it != itEnd)
        iEvent.get(it->first.id(), handleCands);
      std::vector<int> indices;
      while (it != itEnd) {
        indices.push_back(it->second.key());
        ++it;
      }
      auto triggerObjectMatch = std::make_unique<TriggerObjectMatch>(handleTriggerObjects);
      TriggerObjectMatch::Filler matchFiller(*triggerObjectMatch);
      if (handleCands.isValid()) {
        matchFiller.insert(handleCands, indices.begin(), indices.end());
      }
      matchFiller.fill();
      OrphanHandle<TriggerObjectMatch> handleTriggerObjectMatch(
          iEvent.put(std::move(triggerObjectMatch), labelTriggerObjectMatcher));
      // set product reference to trigger match association
      if (!handleTriggerObjectMatch.isValid()) {
        LogError("triggerMatchValid") << "pat::TriggerObjectMatch product with InputTag '" << labelTriggerObjectMatcher
                                      << "' not in event";
        continue;
      }
      if (!(triggerEvent->addObjectMatchResult(handleTriggerObjectMatch, labelTriggerObjectMatcher))) {
        LogWarning("triggerObjectMatchReplication")
            << "pat::TriggerEvent contains already a pat::TriggerObjectMatch from matcher module '"
            << labelTriggerObjectMatcher << "'";
      }
    }
  }
 
  iEvent.put(std::move(triggerEvent));
}
 
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(PATTriggerEventProducer);