TopSingleLeptonDQM.h

Go to the documentation of this file.

#ifndef TOPSINGLELEPTONDQM
#define TOPSINGLELEPTONDQM

#include <string>
#include <vector>
#include "FWCore/Utilities/interface/EDGetToken.h"
#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 "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"
namespace TopSingleLepton {

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

  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(':')); };

    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_;
    std::vector<edm::EDGetTokenT<edm::View<reco::MET> > > mets_;
    edm::EDGetTokenT<edm::View<reco::Jet> >  jets_; 
    edm::EDGetTokenT<edm::View<reco::Muon> > muons_;
    edm::EDGetTokenT<edm::View<reco::GsfElectron> > elecs_;
    edm::EDGetTokenT<edm::View<reco::Vertex> > pvs_;
    edm::EDGetTokenT<edm::TriggerResults> triggerTable_;
    std::vector<std::string> triggerPaths_;

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

    StringCutObjectSelector<reco::Vertex>* pvSelect_;

    StringCutObjectSelector<reco::Muon>* muonIso_;
    StringCutObjectSelector<reco::Muon>* muonSelect_;

    std::string jetCorrector_;
    edm::EDGetTokenT<reco::JetIDValueMap> jetIDLabel_;
    StringCutObjectSelector<reco::JetID>* jetIDSelect_;
    std::string jetSelect_;
    bool includeBTag_;
    edm::EDGetTokenT<reco::JetTagCollection> btagEff_, btagPur_, btagVtx_, btagCSV_;
    double btagEffWP_, btagPurWP_, btagVtxWP_, btagCSVWP_;
    double lowerEdge_, upperEdge_;

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

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

}

#include <utility>

#include "DQM/Physics/interface/TopDQMHelpers.h"
#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 TopSingleLepton::MonitorEnsemble;

class TopSingleLeptonDQM : public edm::EDAnalyzer  {
 public:
  TopSingleLeptonDQM(const edm::ParameterSet& cfg);
  ~TopSingleLeptonDQM(){
    if( vertexSelect_ ) delete vertexSelect_;
    if( beamspotSelect_ ) delete beamspotSelect_;
    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::InputTag vertex_;
  StringCutObjectSelector<reco::Vertex>* vertexSelect_;

  edm::InputTag beamspot_;
  edm::EDGetTokenT<reco::BeamSpot> beamspot__;
  StringCutObjectSelector<reco::BeamSpot>* beamspotSelect_;

  std::vector<std::string> selectionOrder_;
  std::map<std::string, std::pair<edm::ParameterSet, TopSingleLepton::MonitorEnsemble*> > selection_;
  SelectionStep<reco::Muon> * MuonStep;
  SelectionStep<reco::GsfElectron> * 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

/* Local Variables: */
/* show-trailing-whitespace: t */
/* truncate-lines: t */
/* End: */