SingleTopTChannelLeptonDQM.h

Go to the documentation of this file.

#ifndef SINGLETOPTCHANNELLEPTONDQM
#define SINGLETOPTCHANNELLEPTONDQM

#include <string>
#include <vector>

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

#include "DataFormats/JetReco/interface/Jet.h"
#include "DQM/Physics/interface/TopDQMHelpers.h"
#include "DataFormats/MuonReco/interface/Muon.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 "DataFormats/VertexReco/interface/Vertex.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "FWCore/Framework/interface/EDConsumerBase.h"
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "JetMETCorrections/JetCorrector/interface/JetCorrector.h"

namespace SingleTopTChannelLepton {

class MonitorEnsemble {
 public:
  enum Level {
    STANDARD,
    VERBOSE,
    DEBUG
  };

 public:
  MonitorEnsemble(const char* label, const edm::ParameterSet& cfg,
                  const edm::VParameterSet& vcfg, 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(':'));
  };

  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_;
  std::vector<edm::EDGetTokenT<edm::View<reco::MET> > > mets_;
  //    std::vector<edm::InputTag> mets_;
  edm::EDGetTokenT<edm::View<reco::Jet> > jets_;
  edm::EDGetTokenT<edm::View<reco::PFCandidate> > muons_;
  edm::EDGetTokenT<edm::View<reco::GsfElectron> > elecs_gsf_;
  edm::EDGetTokenT<edm::View<reco::PFCandidate> > elecs_;
  edm::EDGetTokenT<edm::View<reco::Vertex> > pvs_;

  //    edm::InputTag elecs_, elecs_gsf_, muons_, muons_reco_, jets_, pvs_;

  //    edm::InputTag triggerTable_;
  edm::EDGetTokenT<edm::TriggerResults> triggerTable_;

  std::vector<std::string> triggerPaths_;

  //    edm::InputTag electronId_;
  edm::EDGetTokenT<edm::ValueMap<float> > electronId_;
    // Jet corrector
  edm::EDGetTokenT<reco::JetCorrector> mJetCorrector;
  // int eidPattern_;
  // the cut for the MVA Id
  double eidCutValue_;
  std::string elecIso_;
  std::unique_ptr<StringCutObjectSelector<reco::PFCandidate> > elecSelect_;
    edm::InputTag rhoTag;

  std::unique_ptr<StringCutObjectSelector<reco::Vertex> > pvSelect_;

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

  std::unique_ptr<StringCutObjectSelector<reco::PFCandidate> > muonSelect_;
  std::string jetCorrector_;
  edm::EDGetTokenT<reco::JetIDValueMap> jetIDLabel_;

  std::unique_ptr<StringCutObjectSelector<reco::JetID> > jetIDSelect_;
    std::unique_ptr<StringCutObjectSelector<reco::PFJet> > jetlooseSelection_;
  std::unique_ptr<StringCutObjectSelector<reco::PFJet> > jetSelection_;
  std::string jetSelect_;
  bool includeBTag_;
  //    edm::InputTag btagEff_, btagPur_, btagVtx_, btagCombVtx_;
  edm::EDGetTokenT<reco::JetTagCollection> btagEff_, btagPur_, btagVtx_, btagCSV_,
      btagCombVtx_;

  double btagEffWP_, btagPurWP_, btagVtxWP_, btagCSVWP_, btagCombVtxWP_;
  double lowerEdge_, upperEdge_;

  int logged_;
  std::map<std::string, MonitorElement*> hists_;
  edm::EDConsumerBase tmpConsumerBase;

  std::string directory_;

  std::unique_ptr<StringCutObjectSelector<reco::PFCandidate, true> > muonSelect;
  std::unique_ptr<StringCutObjectSelector<reco::PFCandidate, true> > muonIso;
  
  
  std::unique_ptr<StringCutObjectSelector<reco::PFCandidate, true> > elecSelect;
  std::unique_ptr<StringCutObjectSelector<reco::PFCandidate, true> > elecIso;


};

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));
    }
  }
}
}

#include <utility>

#include "DQM/Physics/interface/TopDQMHelpers.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 "DQMServices/Core/interface/DQMEDAnalyzer.h"

// using SingleTopTChannelLepton::MonitorEnsemble;

class SingleTopTChannelLeptonDQM : public DQMEDAnalyzer {
 public:
  SingleTopTChannelLeptonDQM(const edm::ParameterSet& cfg);
  ~SingleTopTChannelLeptonDQM() 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::InputTag vertex_;
  edm::EDGetTokenT<reco::Vertex> vertex__;
  std::unique_ptr<StringCutObjectSelector<reco::Vertex> > vertexSelect_;

  edm::InputTag beamspot_;
  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<SingleTopTChannelLepton::MonitorEnsemble> > >
      selection_;

  std::unique_ptr<SelectionStep<reco::Muon> > MuonStep;
  std::unique_ptr<SelectionStep<reco::PFCandidate> > PFMuonStep;
  std::unique_ptr<SelectionStep<reco::GsfElectron> > ElectronStep;
  std::unique_ptr<SelectionStep<reco::PFCandidate> > PFElectronStep;
  std::unique_ptr<SelectionStep<reco::Vertex> > PvStep;

  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::unique_ptr<SelectionStep<reco::MET> > METStep;
  std::vector<edm::ParameterSet> sel;
};

#endif