HLTTauDQMOfflineSource.cc

Go to the documentation of this file.

#include "DQMOffline/Trigger/interface/HLTTauDQMOfflineSource.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "DataFormats/HLTReco/interface/TriggerEvent.h"

using namespace std;
using namespace edm;
using namespace reco;
using namespace trigger;

//
// constructors and destructor
//
HLTTauDQMOfflineSource::HLTTauDQMOfflineSource( const edm::ParameterSet& ps ):
  hltProcessName_(ps.getUntrackedParameter<std::string>("HLTProcessName","HLT")),
  triggerResultsSrc_(ps.getUntrackedParameter<edm::InputTag>("TriggerResultsSrc")),
  triggerResultsToken_(consumes<edm::TriggerResults>(triggerResultsSrc_)),
  triggerEventSrc_(ps.getUntrackedParameter<edm::InputTag>("TriggerEventSrc")),
  triggerEventToken_(consumes<trigger::TriggerEvent>(triggerEventSrc_)),
  pathRegex_(ps.getUntrackedParameter<std::string>("Paths")),
  nPtBins_(ps.getUntrackedParameter<int>("PtHistoBins", 20)),
  nEtaBins_(ps.getUntrackedParameter<int>("EtaHistoBins",12)),
  nPhiBins_(ps.getUntrackedParameter<int>("PhiHistoBins",18)),
  ptMax_(ps.getUntrackedParameter<double>("PtHistoMax",200)),
  highPtMax_(ps.getUntrackedParameter<double>("HighPtHistoMax",1000)),
  l1MatchDr_(ps.getUntrackedParameter<double>("L1MatchDeltaR", 0.5)),
  hltMatchDr_(ps.getUntrackedParameter<double>("HLTMatchDeltaR", 0.5)),
  dqmBaseFolder_(ps.getUntrackedParameter<std::string>("DQMBaseFolder")),
  counterEvt_(0),
  prescaleEvt_(ps.getUntrackedParameter<int>("prescaleEvt", -1))
{
  edm::ParameterSet matching = ps.getParameter<edm::ParameterSet>("Matching");
  doRefAnalysis_ = matching.getUntrackedParameter<bool>("doMatching");

  if(ps.exists("L1Plotter") && !ps.exists("TagAndProbe")) {
    l1Plotter_ = std::make_unique<HLTTauDQML1Plotter>(ps.getUntrackedParameter<edm::ParameterSet>("L1Plotter"), consumesCollector(),
                                            nPhiBins_, ptMax_, highPtMax_, doRefAnalysis_, l1MatchDr_, dqmBaseFolder_);
  }
  if(ps.exists("PathSummaryPlotter")) {
    pathSummaryPlotter_ = std::make_unique<HLTTauDQMPathSummaryPlotter>(ps.getUntrackedParameter<edm::ParameterSet>("PathSummaryPlotter"),
                                                              doRefAnalysis_, dqmBaseFolder_, hltMatchDr_);
  }
  tagAndProbe_ = false;
  if(ps.exists("TagAndProbe")) {
    tagAndProbePaths = ps.getUntrackedParameter<std::vector<edm::ParameterSet> >("TagAndProbe");
    tagAndProbe_ = true;
  }

  if(doRefAnalysis_) {
    using VPSet = std::vector<edm::ParameterSet>;
    VPSet matchObjects = matching.getUntrackedParameter<VPSet>("matchFilters");
    for(const edm::ParameterSet& pset: matchObjects) {
      refObjects_.push_back(RefObject{pset.getUntrackedParameter<int>("matchObjectID"),
            consumes<LVColl>(pset.getUntrackedParameter<edm::InputTag>("FilterName"))});
    }
  }
}

HLTTauDQMOfflineSource::~HLTTauDQMOfflineSource() = default;

//--------------------------------------------------------
void HLTTauDQMOfflineSource::dqmBeginRun(const edm::Run& iRun, const edm::EventSetup& iSetup) {
  //Evaluate configuration for every new trigger menu
  bool hltMenuChanged = false;
  if(HLTCP_.init(iRun, iSetup, hltProcessName_, hltMenuChanged)) {
    LogDebug("HLTTauDQMOffline") << "dqmBeginRun(), hltMenuChanged " << hltMenuChanged;
    if(hltMenuChanged) {
      if(!tagAndProbe_) {
        // Find all paths to monitor
        std::vector<std::string> foundPaths;
    std::smatch what;
    LogDebug("HLTTauDQMOffline") << "Looking for paths with regex " << pathRegex_;
    for(const std::string& pathName: HLTCP_.triggerNames()) {
      if(std::regex_search(pathName, what, pathRegex_)) {
        LogDebug("HLTTauDQMOffline") << "Found path " << pathName;
        foundPaths.emplace_back(pathName);
      }
    }
    std::sort(foundPaths.begin(), foundPaths.end());

        // Construct path plotters
        std::vector<const HLTTauDQMPath *> pathObjects;
        pathPlotters_.reserve(foundPaths.size());  
        pathObjects.reserve(foundPaths.size());
        for(const std::string& pathName: foundPaths) {  
          pathPlotters_.emplace_back(pathName, HLTCP_, doRefAnalysis_, dqmBaseFolder_, hltProcessName_, nPtBins_, nEtaBins_, nPhiBins_, ptMax_, highPtMax_, l1MatchDr_, hltMatchDr_);
          if(pathPlotters_.back().isValid()) {
            pathObjects.push_back(pathPlotters_.back().getPathObject());
          }
        }

        // Update paths to the summary plotter
        if(pathSummaryPlotter_) {
          pathSummaryPlotter_->setPathObjects(pathObjects);
        }
      }else{ // tag and probe
        // Find all paths to monitor
    std::vector<std::string> foundPaths;
    std::smatch what;

    for(const edm::ParameterSet& tpset: tagAndProbePaths) {
          std::vector<std::string> moduleLabels;
          edm::ParameterSet denpset = tpset.getParameter<edm::ParameterSet>("denominator");
          std::vector<std::string> denominators = denpset.getParameter<std::vector<std::string> >("hltPaths");
          std::vector<std::string> updatedDenominators;
          for(size_t i = 0; i < denominators.size(); ++i){
            const std::regex denRegex_(denominators[i]);
            for(const std::string& pathName: HLTCP_.triggerNames()) {
              if(std::regex_search(pathName, what, denRegex_)) {
                updatedDenominators.push_back(pathName);
                moduleLabels = HLTCP_.moduleLabels(pathName);
              }
            }
          }
          denpset.addParameter<std::vector<std::string> >("hltPaths",updatedDenominators);



      edm::ParameterSet numpset = tpset.getParameter<edm::ParameterSet>("numerator");
          std::vector<std::string> numerators = numpset.getParameter<std::vector<std::string> >("hltPaths");

          const std::regex numRegex_(numerators[0]);
          for(const std::string& pathName: HLTCP_.triggerNames()) {
              if(std::regex_search(pathName, what, numRegex_)) {

                  edm::ParameterSet new_tpset = tpset;
                  new_tpset.addParameter<std::string>("name",pathName);
                  std::vector<std::string> updatedHltPaths;
                  updatedHltPaths.push_back(pathName);
                  numpset.addParameter<std::vector<std::string> >("hltPaths",updatedHltPaths);
                  new_tpset.addParameter<edm::ParameterSet>("numerator",numpset);
                  new_tpset.addParameter<edm::ParameterSet>("denominator",denpset);

                  tagandprobePlotters_.emplace_back( new HLTTauDQMTagAndProbePlotter(new_tpset,moduleLabels,dqmBaseFolder_));
              }
          }
    }
      }
    }
  } else {
    edm::LogWarning("HLTTauDQMOffline") << "HLT config extraction failure with process name '" << hltProcessName_ << "'";
  }
}

//--------------------------------------------------------
void HLTTauDQMOfflineSource::bookHistograms(DQMStore::IBooker &iBooker, const edm::Run& iRun, const EventSetup& iSetup ) {
  if(l1Plotter_) {
    l1Plotter_->bookHistograms(iBooker);
  }
  for(auto& pathPlotter: pathPlotters_) {
    pathPlotter.bookHistograms(iBooker);
  }
  for(auto& tpPlotter: tagandprobePlotters_) {
    tpPlotter->bookHistograms(iBooker,iRun,iSetup);
  }
  if(pathSummaryPlotter_) {
    pathSummaryPlotter_->bookHistograms(iBooker);
  }
}

// ----------------------------------------------------------
void HLTTauDQMOfflineSource::analyze(const Event& iEvent, const EventSetup& iSetup ) {
    //Apply the prescaler
    if (counterEvt_ > prescaleEvt_) {
        //Do Analysis here
        counterEvt_ = 0;

        edm::Handle<edm::TriggerResults> triggerResultsHandle;
        iEvent.getByToken(triggerResultsToken_, triggerResultsHandle);
        if(!triggerResultsHandle.isValid()) {
          edm::LogWarning("HLTTauDQMOffline") << "Unable to read edm::TriggerResults with label " << triggerResultsSrc_;
          return;
        }

        edm::Handle<trigger::TriggerEvent> triggerEventHandle;
        iEvent.getByToken(triggerEventToken_, triggerEventHandle);
        if(!triggerEventHandle.isValid()) {
          edm::LogWarning("HLTTauDQMOffline") << "Unable to read trigger::TriggerEvent with label " << triggerEventSrc_;
          return;
        }

        //Create match collections
        HLTTauDQMOfflineObjects refC;
        if (doRefAnalysis_) {
          for(RefObject& refObj: refObjects_) {
            edm::Handle<LVColl> collHandle;
            iEvent.getByToken(refObj.token, collHandle);
            if(!collHandle.isValid())
              continue;

            if(refObj.objID == 11) {
              refC.electrons.insert(refC.electrons.end(), collHandle->begin(), collHandle->end());
            }
            else if(refObj.objID == 13) {
              refC.muons.insert(refC.muons.end(), collHandle->begin(), collHandle->end());
            }
            else if(refObj.objID == 15) {
              refC.taus.insert(refC.taus.end(), collHandle->begin(), collHandle->end());
            }
            else if(refObj.objID == 0) {
              refC.met.insert(refC.met.end(), collHandle->begin(), collHandle->end());
            }
          }
        }
        
        //Path Plotters
        for(auto& pathPlotter: pathPlotters_) {
          if(pathPlotter.isValid())
            pathPlotter.analyze(*triggerResultsHandle, *triggerEventHandle, refC);
        }
        
        if(pathSummaryPlotter_ && pathSummaryPlotter_->isValid()) {
          pathSummaryPlotter_->analyze(*triggerResultsHandle, *triggerEventHandle, refC);
        }
        
        //L1 Plotter
        if(l1Plotter_ && l1Plotter_->isValid()) {
          l1Plotter_->analyze(iEvent, iSetup, refC);
        }

        //Tag and probe plotters
        for(auto& tpPlotter: tagandprobePlotters_) {
          if(tpPlotter->isValid())
        tpPlotter->analyze(iEvent,*triggerResultsHandle, *triggerEventHandle, refC);
        }

    } else {
        counterEvt_++;
    }
}