/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_14/src/DQM/Physics/src/TopSingleLeptonDQM.h

Go to the documentation of this file.

#ifndef TOPSINGLELEPTONDQM
#define TOPSINGLELEPTONDQM

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

namespace TopSingleLepton {

  class MonitorEnsemble {
  public:
    enum Level{ STANDARD, VERBOSE, DEBUG };
    
  public:
    MonitorEnsemble(const char* label, const edm::ParameterSet& cfg);
    ~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::InputTag> mets_;
    edm::InputTag elecs_, muons_, jets_, pvs_; 

    edm::InputTag triggerTable_;
    std::vector<std::string> triggerPaths_;

    edm::InputTag 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::InputTag jetIDLabel_;
    StringCutObjectSelector<reco::JetID>* jetIDSelect_;
    std::string jetSelect_;
    bool includeBTag_;
    edm::InputTag btagEff_, btagPur_, btagVtx_;
    double btagEffWP_, btagPurWP_, btagVtxWP_;
    double lowerEdge_, upperEdge_;

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

  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_;
  };
  
  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_;
  std::vector<std::string> triggerPaths_;
  edm::InputTag vertex_;
  StringCutObjectSelector<reco::Vertex>* vertexSelect_;

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

  std::vector<std::string> selectionOrder_;
  std::map<std::string, std::pair<edm::ParameterSet, TopSingleLepton::MonitorEnsemble*> > selection_;
};

#endif