TopDiLeptonHLTOfflineDQM.h

Go to the documentation of this file.

#ifndef TOPDILEPTONHLTOFFLINEDQM
#define TOPDILEPTONHLTOFFLINEDQM

#include <string>
#include <vector>
#include <memory>

#include "FWCore/Framework/interface/Event.h"
#include "DQMServices/Core/interface/DQMStore.h"
#include "DQMServices/Core/interface/MonitorElement.h"

#include "DataFormats/Math/interface/deltaR.h"
#include "DataFormats/JetReco/interface/Jet.h"
#include "DQMOffline/Trigger/interface/TopHLTOfflineDQMHelper.h"
#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/METReco/interface/CaloMET.h"
#include "JetMETCorrections/Objects/interface/JetCorrector.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"

#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
#include "DataFormats/HLTReco/interface/TriggerEventWithRefs.h"

#include "FWCore/Framework/interface/ConsumesCollector.h"

//*Originally from DQM/Physics by R. Wolf and J. Andrea*/

namespace HLTOfflineDQMTopDiLepton {

  class MonitorDiLepton {
    public:
      using LorentzVector = reco::LeafCandidate::LorentzVector;
      enum DecayChannel{ NONE, DIMUON, DIELEC, ELECMU };

    public:
      MonitorDiLepton(const char* label, const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC);
      ~MonitorDiLepton()= default;;

      void book(DQMStore::IBooker& store_);
      void fill(const edm::Event& event, const edm::EventSetup& setup, const HLTConfigProvider& hltConfig, const std::vector<std::string>& triggerPaths);

    private:
      std::string monitorPath(const std::string& label) const { return label.substr(label.find(':')+1); };  
      std::string selectionPath(const std::string& label) const { return label.substr(0, label.find(':')); };  

      void loggerBinLabels(const std::string& hist);
      void triggerBinLabels(const std::string& channel, const std::vector<std::string>& labels);
      void fill(const edm::Event& event, const edm::TriggerResults& triggerTable, const std::string& channel, const std::vector<std::string>& labels) const;

      bool booked(const std::string& histName) const { return hists_.find(histName.c_str())!=hists_.end(); };
      void fill(const std::string& histName, double value) const { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(value); };
      void fill(const std::string& histName, double xValue, double yValue) const { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(xValue, yValue); };
      void fill(const std::string& histName, double xValue, double yValue, double zValue) const { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(xValue, yValue, zValue); };

    private:
      std::string folder_;
      std::string label_;
      edm::EDGetTokenT< edm::View<reco::GsfElectron> > elecs_;
      edm::EDGetTokenT< edm::View<reco::Muon> > muons_;
      edm::EDGetTokenT< edm::View<reco::Jet> > jets_; 
      std::vector< edm::EDGetTokenT< edm::View<reco::MET> > > mets_;

      edm::EDGetTokenT< edm::TriggerResults > triggerTable_;
//      edm::EDGetTokenT< trigger::TriggerEventWithRefs > triggerEventWithRefsTag_;
      edm::EDGetTokenT <trigger::TriggerEventWithRefs> triggerSummaryTokenRAW;
      edm::EDGetTokenT <trigger::TriggerEventWithRefs> triggerSummaryTokenAOD;
      bool hasRawTriggerSummary;

      std::vector<std::string> elecMuPaths_;
      std::vector<std::string> diMuonPaths_;
      std::vector<std::string> diElecPaths_;

      edm::EDGetTokenT< edm::ValueMap<float> > electronId_;
      int eidPattern_;
      std::unique_ptr<StringCutObjectSelector<reco::GsfElectron>> elecIso_;
      std::unique_ptr<StringCutObjectSelector<reco::GsfElectron>> elecSelect_;

      std::unique_ptr<StringCutObjectSelector<reco::Muon>> muonIso_;
      std::unique_ptr<StringCutObjectSelector<reco::Muon>> muonSelect_;

      std::string jetCorrector_;
      edm::EDGetTokenT< reco::JetIDValueMap > jetIDLabel_;
      std::unique_ptr<StringCutObjectSelector<reco::JetID>> jetIDSelect_;
      std::string jetSelect_;
      double lowerEdge_, upperEdge_;

      int elecMuLogged_, diMuonLogged_, diElecLogged_;
      std::map<std::string,MonitorElement*> hists_;

      std::string          processName_;
      trigger::Vids        electronIds_;
      trigger::VRelectron  electronRefs_;
      trigger::Vids        muonIds_;
      trigger::VRmuon      muonRefs_;
  };

  inline void 
    MonitorDiLepton::loggerBinLabels(const std::string& hist)
    {
      // set axes titles for selected events
      hists_[hist.c_str()]->getTH1()->SetOption("TEXT");
      hists_[hist.c_str()]->setBinLabel( 1 , "Run"             , 1);
      hists_[hist.c_str()]->setBinLabel( 2 , "Block"           , 1);
      hists_[hist.c_str()]->setBinLabel( 3 , "Event"           , 1);
      hists_[hist.c_str()]->setBinLabel( 6 , "pt_{L2L3}(jet1)" , 1);
      hists_[hist.c_str()]->setBinLabel( 7 , "pt_{L2L3}(jet2)" , 1);
      hists_[hist.c_str()]->setBinLabel( 8 , "MET_{Calo}"      , 1);
      hists_[hist.c_str()]->setAxisTitle("logged evts"         , 2);

      if(hist=="diMuonLogger_"){
        hists_[hist.c_str()]->setBinLabel( 4 , "pt(muon)" , 1);
        hists_[hist.c_str()]->setBinLabel( 5 , "pt(muon)" , 1);
      }
      if(hist=="diElecLogger_"){
        hists_[hist.c_str()]->setBinLabel( 4 , "pt(elec)" , 1);
        hists_[hist.c_str()]->setBinLabel( 5 , "pt(elec)" , 1);
      }
      if(hist=="elecMuLogger_"){
        hists_[hist.c_str()]->setBinLabel( 4 , "pt(elec)" , 1);
        hists_[hist.c_str()]->setBinLabel( 5 , "pt(muon)" , 1);
      }
    }

  inline void 
    MonitorDiLepton::triggerBinLabels(const std::string& channel, const std::vector<std::string>& labels)
    {
      for(unsigned int idx=0; idx<labels.size(); ++idx){
        hists_[(channel+"Mon_").c_str()]->setBinLabel( idx+1, "["+monitorPath(labels[idx])+"]", 1);
      }
    }

  inline void 
    MonitorDiLepton::fill(const edm::Event& event, const edm::TriggerResults& triggerTable, const std::string& channel, const std::vector<std::string>& labels) const
    {
      for(unsigned int idx=0; idx<labels.size(); ++idx){
        if( acceptHLT(event, triggerTable, monitorPath(labels[idx])) ){
          fill((channel+"Mon_").c_str(), idx+0.5 );
        }
      }
    }

}

#include <utility>

#include "DQMServices/Core/interface/DQMEDAnalyzer.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "FWCore/Common/interface/TriggerNames.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"


//using TopDiLeptonOffline::MonitorDiLepton;

class TopDiLeptonHLTOfflineDQM : public DQMEDAnalyzer  {
  public: 
    TopDiLeptonHLTOfflineDQM(const edm::ParameterSet& cfg);

    void dqmBeginRun(const edm::Run& r, const edm::EventSetup& c) override;
    void analyze(const edm::Event& event, const edm::EventSetup& setup) override;
    void bookHistograms(DQMStore::IBooker &i, edm::Run const&, edm::EventSetup const&) override;

  private:
    std::string objectType(const std::string& label) { return label.substr(0, label.find(':')); };  
    std::string selectionStep(const std::string& label) { return label.substr(label.find(':')+1); };  

  private:
    edm::EDGetTokenT< edm::TriggerResults > triggerTable_;
    std::vector<std::string> triggerPaths_;
    edm::EDGetTokenT< std::vector<reco::Vertex> > vertex_;
    std::unique_ptr<StringCutObjectSelector<reco::Vertex>> vertexSelect_;
    edm::EDGetTokenT< reco::BeamSpot > beamspot_;
    std::unique_ptr<StringCutObjectSelector<reco::BeamSpot>> beamspotSelect_;

    HLTConfigProvider hltConfig_;

    std::vector<std::string> selectionOrder_;
    std::map<std::string, std::pair<edm::ParameterSet, std::unique_ptr<HLTOfflineDQMTopDiLepton::MonitorDiLepton>> > selection_;

    std::map<std::string, std::unique_ptr<SelectionStepHLTBase>> selectmap_;
};

#endif