TopDiLeptonOfflineDQM.h

Go to the documentation of this file.

#ifndef TOPDILEPTONOFFLINEDQM
#define TOPDILEPTONOFFLINEDQM

#include <string>
#include <vector>

#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 "DQM/Physics/interface/TopDQMHelpers.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/METReco/interface/CaloMET.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
#include "JetMETCorrections/Objects/interface/JetCorrector.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"
namespace TopDiLeptonOffline {

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(std::string directory);
  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.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:
  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_;
  StringCutObjectSelector<reco::PFCandidate>* elecIso_;
  StringCutObjectSelector<reco::PFCandidate>* elecSelect_;

  StringCutObjectSelector<reco::PFCandidate, true>* muonIso_;

  StringCutObjectSelector<reco::PFCandidate, true>* muonSelect_;

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

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

inline void MonitorEnsemble::loggerBinLabels(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 MonitorEnsemble::triggerBinLabels(
    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);
    hists_[(channel + "Eff_").c_str()]
        ->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_").c_str(), idx + 0.5);
      // take care to fill triggerMon_ before evts is being called
      int evts = hists_.find((channel + "Mon_").c_str())
                     ->second->getBinContent(idx + 1);
      double value = hists_.find((channel + "Eff_").c_str())
                         ->second->getBinContent(idx + 1);
      fill(
          (channel + "Eff_").c_str(), 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;
}
}

#include <utility>

#include "FWCore/Framework/interface/EDAnalyzer.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"

// using TopDiLeptonOffline::MonitorEnsemble;

class TopDiLeptonOfflineDQM : public edm::EDAnalyzer {
 public:
  TopDiLeptonOfflineDQM(const edm::ParameterSet& cfg);
  ~TopDiLeptonOfflineDQM() {
    if (beamspotSelect_) delete beamspotSelect_;
    if (vertexSelect_) delete vertexSelect_;

    if (MuonStep) delete MuonStep;

    if (ElectronStep) delete ElectronStep;

    if (PvStep) delete PvStep;

    if (METStep) delete METStep;

    for (unsigned int i = 0; i < JetSteps.size(); i++)

      if (JetSteps[i]) delete JetSteps[i];

    for (unsigned int i = 0; i < CaloJetSteps.size(); i++)

      if (CaloJetSteps[i]) delete CaloJetSteps[i];

    for (unsigned int i = 0; i < PFJetSteps.size(); i++)

      if (PFJetSteps[i]) delete PFJetSteps[i];
  }

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

 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_;
  StringCutObjectSelector<reco::Vertex>* vertexSelect_;
  edm::EDGetTokenT<reco::BeamSpot> beamspot_;
  StringCutObjectSelector<reco::BeamSpot>* beamspotSelect_;

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

#endif