TopDiLeptonOfflineDQM.h

Go to the documentation of this file.

#ifndef TOPDILEPTONOFFLINEDQM
#define TOPDILEPTONOFFLINEDQM

#include "DQMServices/Core/interface/DQMOneEDAnalyzer.h"

#include <string>
#include <vector>

#include "DataFormats/Math/interface/deltaR.h"
#include "DataFormats/JetReco/interface/Jet.h"
#include "DQM/Physics/interface/TopDQMHelpers.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/METReco/interface/CaloMET.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "FWCore/Framework/interface/EDConsumerBase.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "JetMETCorrections/JetCorrector/interface/JetCorrector.h"
namespace TopDiLeptonOffline {
  using dqm::legacy::DQMStore;
  using dqm::legacy::MonitorElement;

  class MonitorEnsemble {
  public:
    enum Level { STANDARD, VERBOSE, DEBUG };
    typedef reco::LeafCandidate::LorentzVector LorentzVector;
    enum DecayChannel { NONE, DIMUON, DIELEC, ELECMU };

  public:
    MonitorEnsemble(const char* label, const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC);
    ~MonitorEnsemble(){};

    void book(DQMStore::IBooker& ibooker);
    void fill(const edm::Event& event, const edm::EventSetup& setup);

  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(':')); };
    DecayChannel decayChannel(const std::vector<const reco::PFCandidate*>& muons,
                              const std::vector<const reco::PFCandidate*>& elecs) const;

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

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

  private:
    Level verbosity_;
    std::string label_;
    edm::EDGetTokenT<edm::View<reco::Jet> > jets_;
    edm::EDGetTokenT<edm::View<reco::PFCandidate> > muons_;
    edm::EDGetTokenT<edm::View<reco::PFCandidate> > elecs_;

    std::vector<edm::EDGetTokenT<edm::View<reco::MET> > > mets_;

    edm::EDGetTokenT<edm::TriggerResults> triggerTable_;
    std::vector<std::string> elecMuPaths_;
    std::vector<std::string> diMuonPaths_;

    edm::EDGetTokenT<edm::ValueMap<float> > electronId_;
    // int eidPattern_;
    // the cut for the MVA Id
    double eidCutValue_;
    std::unique_ptr<StringCutObjectSelector<reco::PFCandidate> > elecIso_;
    std::unique_ptr<StringCutObjectSelector<reco::PFCandidate> > elecSelect_;

    std::unique_ptr<StringCutObjectSelector<reco::PFCandidate, true> > muonIso_;

    std::unique_ptr<StringCutObjectSelector<reco::PFCandidate, true> > muonSelect_;

    edm::EDGetTokenT<reco::JetCorrector> 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 directory_;
  };

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

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

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

  inline void MonitorEnsemble::fill(const edm::Event& event,
                                    const edm::TriggerResults& triggerTable,
                                    std::string channel,
                                    const std::vector<std::string> labels) const {
    for (unsigned int idx = 0; idx < labels.size(); ++idx) {
      if (accept(event, triggerTable, monitorPath(labels[idx]))) {
        fill(channel + "Mon_", idx + 0.5);
        // take care to fill triggerMon_ before evts is being called
        int evts = hists_.find(channel + "Mon_")->second->getBinContent(idx + 1);
        double value = hists_.find(channel + "Eff_")->second->getBinContent(idx + 1);
        fill(
            channel + "Eff_", idx + 0.5, 1. / evts * (accept(event, triggerTable, selectionPath(labels[idx])) - value));
      }
    }
  }

  inline MonitorEnsemble::DecayChannel MonitorEnsemble::decayChannel(
      const std::vector<const reco::PFCandidate*>& muons, const std::vector<const reco::PFCandidate*>& elecs) const {
    DecayChannel type = NONE;
    if (muons.size() > 1) {
      type = DIMUON;
    } else if (elecs.size() > 1) {
      type = DIELEC;
    } else if (!elecs.empty() && !muons.empty()) {
      type = ELECMU;
    }
    return type;
  }
}  // namespace TopDiLeptonOffline

#include <utility>

#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"

// using TopDiLeptonOffline::MonitorEnsemble;

class TopDiLeptonOfflineDQM : public DQMOneEDAnalyzer<> {
public:
  TopDiLeptonOfflineDQM(const edm::ParameterSet& cfg);
  ~TopDiLeptonOfflineDQM() override {}

  void analyze(const edm::Event& event, const edm::EventSetup& setup) override;

protected:
  //Book histograms
  void bookHistograms(DQMStore::IBooker&, 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_;

  std::vector<std::string> selectionOrder_;
  std::map<std::string, std::pair<edm::ParameterSet, std::unique_ptr<TopDiLeptonOffline::MonitorEnsemble> > > selection_;
  std::unique_ptr<SelectionStep<reco::PFCandidate> > MuonStep;
  std::unique_ptr<SelectionStep<reco::PFCandidate> > ElectronStep;
  std::unique_ptr<SelectionStep<reco::Vertex> > PvStep;
  std::unique_ptr<SelectionStep<reco::MET> > METStep;
  std::vector<std::unique_ptr<SelectionStep<reco::Jet> > > JetSteps;
  std::vector<std::unique_ptr<SelectionStep<reco::CaloJet> > > CaloJetSteps;
  std::vector<std::unique_ptr<SelectionStep<reco::PFJet> > > PFJetSteps;

  std::vector<edm::ParameterSet> sel_;
  edm::ParameterSet setup_;
};

#endif