/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_5/src/DQM/Physics/src/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/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"

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);
    ~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::Muon*>& muons, const std::vector<const reco::GsfElectron*>& 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::InputTag elecs_, muons_, jets_; 
    std::vector<edm::InputTag> mets_;

    edm::InputTag triggerTable_;
    std::vector<std::string> elecMuPaths_;
    std::vector<std::string> diMuonPaths_;

    edm::InputTag electronId_;
    int eidPattern_;
    StringCutObjectSelector<reco::GsfElectron>* elecIso_;
    StringCutObjectSelector<reco::GsfElectron>* elecSelect_;

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

    std::string jetCorrector_;
    edm::InputTag 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::Muon*>& muons, const std::vector<const reco::GsfElectron*>& 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_;
  }
  
  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, TopDiLeptonOffline::MonitorEnsemble*> > selection_;
};

#endif