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 "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 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(){delete pvSelect_;}
    
    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_;
    //    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_;

    int eidPattern_;
    //    StringCutObjectSelector<reco::GsfElectron>* elecIso_;
    std::string elecIso_;
    //StringCutObjectSelector<reco::GsfElectron>* elecSelect_;
    std::string elecSelect_;
    
    StringCutObjectSelector<reco::Vertex>* pvSelect_;
    
    //StringCutObjectSelector<reco::Muon>* muonIso_;
    std::string muonIso_;
    //StringCutObjectSelector<reco::Muon>* muonSelect_;
    std::string muonSelect_;

    std::string jetCorrector_;
    //    edm::InputTag jetIDLabel_;
    edm::EDGetTokenT<reco::JetIDValueMap> jetIDLabel_;

    StringCutObjectSelector<reco::JetID>* jetIDSelect_;
    std::string jetSelect_;
    bool includeBTag_;
    //    edm::InputTag btagEff_, btagPur_, btagVtx_, btagCombVtx_;
    edm::EDGetTokenT<reco::JetTagCollection> btagEff_, btagPur_, btagVtx_, btagCombVtx_;

    double btagEffWP_, btagPurWP_, btagVtxWP_, btagCombVtxWP_;
    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 SingleTopTChannelLepton::MonitorEnsemble;

class SingleTopTChannelLeptonDQM : public edm::EDAnalyzer  {
 public: 
  SingleTopTChannelLeptonDQM(const edm::ParameterSet& cfg);
  ~SingleTopTChannelLeptonDQM(){
    if( vertexSelect_ ) delete vertexSelect_;
    if( beamspotSelect_ ) delete beamspotSelect_;
    if( MuonStep) delete MuonStep;
    if( PFMuonStep) delete PFMuonStep;
    if( ElectronStep) delete ElectronStep;
    if( PFElectronStep) delete PFElectronStep;
    if( PvStep) delete PvStep;
    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];
    if( METStep) delete METStep;




  };



  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::InputTag triggerTable_;
  edm::EDGetTokenT<edm::TriggerResults> triggerTable__;

  std::vector<std::string> triggerPaths_;
  edm::InputTag vertex_;
  edm::EDGetTokenT<reco::Vertex> 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, SingleTopTChannelLepton::MonitorEnsemble*> > selection_;
  SelectionStep<reco::Muon> * MuonStep;
  SelectionStep<reco::PFCandidate> * PFMuonStep;
  SelectionStep<reco::GsfElectron> * ElectronStep;
  SelectionStep<reco::PFCandidate> * PFElectronStep;
  SelectionStep<reco::Vertex> * PvStep;
  std::vector<SelectionStep<reco::Jet> * > JetSteps;
  std::vector<SelectionStep<reco::CaloJet> * > CaloJetSteps;
  std::vector<SelectionStep<reco::PFJet> * > PFJetSteps;
  SelectionStep<reco::MET> * METStep;


};

#endif