#include <EwkTauDQM.h>

Public Types
typedef EwkTauDQM::DQMStore	DQMStore

typedef EwkTauDQM::MonitorElement	MonitorElement

Public Member Functions
void	bookHistograms (DQMStore::IBooker &)

	EwkMuTauHistManager (const edm::ParameterSet &)

void	fillHistograms (const edm::Event &, const edm::EventSetup &)

void	finalizeHistograms ()

Private Types
enum	{ kPassedPreselection = 1, kPassedTrigger = 2, kPassedMuonId = 3, kPassedTauLeadTrack = 4, kPassedTauLeadTrackPt = 5, kPassedTauDiscrAgainstMuons = 6, kPassedDeltaR = 7, kPassedMuonTrackIso = 8, kPassedMuonEcalIso = 9, kPassedTauTrackIso = 10, kPassedTauEcalIso = 11 }

typedef std::vector< std::string >	vstring

Private Attributes
edm::InputTag	beamSpotSource_

edm::InputTag	caloMEtSource_

int	cfgError_

double	deltaRCut_

std::string	dqmDirectory_

MonitorElement *	hCaloMEtPt_

MonitorElement *	hCutFlowSummary_

vstring	hltPaths_

MonitorElement *	hMtMuPFMEt_

MonitorElement *	hMuonCombIsoPt_

MonitorElement *	hMuonEcalIsoPt_

MonitorElement *	hMuonEta_

MonitorElement *	hMuonPhi_

MonitorElement *	hMuonPt_

MonitorElement *	hMuonTrackIsoPt_

MonitorElement *	hMuTauAcoplanarity_

MonitorElement *	hMuTauDeltaR_

MonitorElement *	hPFMEtPt_

MonitorElement *	hTauDiscrAgainstMuons_

MonitorElement *	hTauEcalIsoPt_

MonitorElement *	hTauJetCharge_

MonitorElement *	hTauJetEta_

MonitorElement *	hTauJetNumIsoTracks_

MonitorElement *	hTauJetNumSignalTracks_

MonitorElement *	hTauJetPhi_

MonitorElement *	hTauJetPt_

MonitorElement *	hTauLeadTrackPt_

MonitorElement *	hTauTrackIsoPt_

MonitorElement *	hVertexZ_

MonitorElement *	hVisMass_

MonitorElement *	hVisMassFinal_

int	maxNumWarnings_

double	muonCombIsoCut_

double	muonEcalIsoCut_

double	muonEtaCut_

int	muonIsoMode_

double	muonPtCut_

edm::InputTag	muonSource_

double	muonTrackIsoCut_

unsigned	numEventsAnalyzed_

unsigned	numEventsSelected_

long	numWarningsBeamSpot_

long	numWarningsCaloMEt_

long	numWarningsHLTpath_

long	numWarningsMuon_

long	numWarningsPFMEt_

long	numWarningsTauDiscrAgainstMuons_

long	numWarningsTauDiscrByEcalIso_

long	numWarningsTauDiscrByLeadTrackFinding_

long	numWarningsTauDiscrByLeadTrackPtCut_

long	numWarningsTauDiscrByTrackIso_

long	numWarningsTauJet_

long	numWarningsTriggerResults_

long	numWarningsVertex_

edm::InputTag	pfMEtSource_

edm::InputTag	tauDiscrAgainstMuons_

edm::InputTag	tauDiscrByEcalIso_

edm::InputTag	tauDiscrByLeadTrackFinding_

edm::InputTag	tauDiscrByLeadTrackPtCut_

edm::InputTag	tauDiscrByTrackIso_

double	tauJetEtaCut_

double	tauJetPtCut_

edm::InputTag	tauJetSource_

edm::InputTag	triggerResultsSource_

edm::InputTag	vertexSource_

double	visMassCut_

Detailed Description

Booking and filling of histograms for data-quality monitoring purposes in Z –> muon + tau-jet channel

Author: Letizia Lusito, Christian Veelken

Definition at line 217 of file EwkTauDQM.h.

Member Typedef Documentation

typedef EwkTauDQM::DQMStore EwkMuTauHistManager::DQMStore

Definition at line 219 of file EwkTauDQM.h.

typedef EwkTauDQM::MonitorElement EwkMuTauHistManager::MonitorElement

Definition at line 220 of file EwkTauDQM.h.

typedef std::vector<std::string> EwkMuTauHistManager::vstring

private

Definition at line 246 of file EwkTauDQM.h.

Member Enumeration Documentation

anonymous enum

private

Enumerator
kPassedPreselection
kPassedTrigger
kPassedMuonId
kPassedTauLeadTrack
kPassedTauLeadTrackPt
kPassedTauDiscrAgainstMuons
kPassedDeltaR
kPassedMuonTrackIso
kPassedMuonEcalIso
kPassedTauTrackIso
kPassedTauEcalIso

Definition at line 307 of file EwkTauDQM.h.

        {
     kPassedPreselection = 1,
     kPassedTrigger = 2,
     kPassedMuonId = 3,
     kPassedTauLeadTrack = 4,
     kPassedTauLeadTrackPt = 5,
     kPassedTauDiscrAgainstMuons = 6,
     kPassedDeltaR = 7,
     kPassedMuonTrackIso = 8,
     kPassedMuonEcalIso = 9,
     kPassedTauTrackIso = 10,
     kPassedTauEcalIso = 11
   };

Constructor & Destructor Documentation

EwkMuTauHistManager::EwkMuTauHistManager ( const edm::ParameterSet & cfg )

Definition at line 553 of file EwkTauDQM.cc.

References beamSpotSource_, caloMEtSource_, cfgError_, deltaRCut_, edm::ParameterSet::exists(), getIsoMode(), edm::ParameterSet::getParameter(), hltPaths_, maxNumWarnings_, muonCombIsoCut_, muonEcalIsoCut_, muonEtaCut_, muonIsoMode_, muonPtCut_, muonSource_, muonTrackIsoCut_, pfMEtSource_, AlCaHLTBitMon_QueryRunRegistry::string, tauDiscrAgainstMuons_, tauDiscrByEcalIso_, tauDiscrByLeadTrackFinding_, tauDiscrByLeadTrackPtCut_, tauDiscrByTrackIso_, tauJetEtaCut_, tauJetPtCut_, tauJetSource_, triggerResultsSource_, vertexSource_, and visMassCut_.

     : dqmDirectory_(cfg.getParameter<std::string>("dqmDirectory")),
       numEventsAnalyzed_(0),
       numEventsSelected_(0),
       cfgError_(0),
       numWarningsTriggerResults_(0),
       numWarningsHLTpath_(0),
       numWarningsVertex_(0),
       numWarningsBeamSpot_(0),
       numWarningsMuon_(0),
       numWarningsTauJet_(0),
       numWarningsTauDiscrByLeadTrackFinding_(0),
       numWarningsTauDiscrByLeadTrackPtCut_(0),
       numWarningsTauDiscrByTrackIso_(0),
       numWarningsTauDiscrByEcalIso_(0),
       numWarningsTauDiscrAgainstMuons_(0),
       numWarningsCaloMEt_(0),
       numWarningsPFMEt_(0) {
   triggerResultsSource_ = cfg.getParameter<edm::InputTag>("triggerResultsSource");
   vertexSource_ = cfg.getParameter<edm::InputTag>("vertexSource");
   beamSpotSource_ = cfg.getParameter<edm::InputTag>("beamSpotSource");
   muonSource_ = cfg.getParameter<edm::InputTag>("muonSource");
   tauJetSource_ = cfg.getParameter<edm::InputTag>("tauJetSource");
   caloMEtSource_ = cfg.getParameter<edm::InputTag>("caloMEtSource");
   pfMEtSource_ = cfg.getParameter<edm::InputTag>("pfMEtSource");
 
   tauDiscrByLeadTrackFinding_ = cfg.getParameter<edm::InputTag>("tauDiscrByLeadTrackFinding");
   tauDiscrByLeadTrackPtCut_ = cfg.getParameter<edm::InputTag>("tauDiscrByLeadTrackPtCut");
   tauDiscrByTrackIso_ = cfg.getParameter<edm::InputTag>("tauDiscrByTrackIso");
   tauDiscrByEcalIso_ = cfg.getParameter<edm::InputTag>("tauDiscrByEcalIso");
   tauDiscrAgainstMuons_ = cfg.getParameter<edm::InputTag>("tauDiscrAgainstMuons");
 
   hltPaths_ = cfg.getParameter<vstring>("hltPaths");
 
   muonEtaCut_ = cfg.getParameter<double>("muonEtaCut");
   muonPtCut_ = cfg.getParameter<double>("muonPtCut");
   muonTrackIsoCut_ = cfg.getParameter<double>("muonTrackIsoCut");
   muonEcalIsoCut_ = cfg.getParameter<double>("muonEcalIsoCut");
   muonCombIsoCut_ = cfg.getParameter<double>("muonCombIsoCut");
   std::string muonIsoMode_string = cfg.getParameter<std::string>("muonIsoMode");
   muonIsoMode_ = getIsoMode(muonIsoMode_string, cfgError_);
 
   tauJetEtaCut_ = cfg.getParameter<double>("tauJetEtaCut");
   tauJetPtCut_ = cfg.getParameter<double>("tauJetPtCut");
 
   visMassCut_ = cfg.getParameter<double>("visMassCut");
   deltaRCut_ = cfg.getParameter<double>("deltaRCut");
 
   maxNumWarnings_ = cfg.exists("maxNumWarnings") ? cfg.getParameter<int>("maxNumWarnings") : 1;
 }

Member Function Documentation

void EwkMuTauHistManager::bookHistograms ( DQMStore::IBooker & iBooker )

Definition at line 604 of file EwkTauDQM.cc.

References dqm::implementation::IBooker::book1D(), dqmDirectory_, hCaloMEtPt_, hCutFlowSummary_, hMtMuPFMEt_, hMuonCombIsoPt_, hMuonEcalIsoPt_, hMuonEta_, hMuonPhi_, hMuonPt_, hMuonTrackIsoPt_, hMuTauAcoplanarity_, hMuTauDeltaR_, hPFMEtPt_, hTauDiscrAgainstMuons_, hTauEcalIsoPt_, hTauJetEta_, hTauJetNumIsoTracks_, hTauJetNumSignalTracks_, hTauJetPhi_, hTauJetPt_, hTauLeadTrackPt_, hTauTrackIsoPt_, hVertexZ_, hVisMass_, hVisMassFinal_, kPassedDeltaR, kPassedMuonEcalIso, kPassedMuonId, kPassedMuonTrackIso, kPassedPreselection, kPassedTauDiscrAgainstMuons, kPassedTauEcalIso, kPassedTauLeadTrack, kPassedTauLeadTrackPt, kPassedTauTrackIso, kPassedTrigger, Pi, dqm::impl::MonitorElement::setBinLabel(), and dqm::implementation::NavigatorBase::setCurrentFolder().

Referenced by EwkTauDQM::bookHistograms().

                                                                  {
   iBooker.setCurrentFolder(dqmDirectory_);
 
   hMuonPt_ = iBooker.book1D("MuonPt", "P_{T}^{#mu}", 20, 0., 100.);
   hMuonEta_ = iBooker.book1D("MuonEta", "#eta_{#mu}", 20, -4.0, +4.0);
   hMuonPhi_ = iBooker.book1D("MuonPhi", "#phi_{#mu}", 20, -TMath::Pi(), +TMath::Pi());
   hMuonTrackIsoPt_ = iBooker.book1D("MuonTrackIsoPt", "Muon Track Iso.", 20, -0.01, 10.);
   hMuonEcalIsoPt_ = iBooker.book1D("MuonEcalIsoPt", "Muon Ecal Iso.", 20, -0.01, 10.);
   hMuonCombIsoPt_ = iBooker.book1D("MuonCombIsoPt", "Muon Comb Iso.", 20, -0.01, 1.);
 
   hTauJetPt_ = iBooker.book1D("TauJetPt", "P_{T}^{#tau-Jet}", 20, 0., 100.);
   hTauJetEta_ = iBooker.book1D("TauJetEta", "#eta_{#tau-Jet}", 20, -4.0, +4.0);
   hTauJetPhi_ = iBooker.book1D("TauJetPhi", "#phi_{#tau-Jet}", 20, -TMath::Pi(), +TMath::Pi());
   hTauLeadTrackPt_ = iBooker.book1D("TauLeadTrackPt", "P_{T}^{#tau-Jetldg trk}", 20, 0., 50.);
   hTauTrackIsoPt_ = iBooker.book1D("TauTrackIsoPt", "Tau Track Iso.", 20, -0.01, 40.);
   hTauEcalIsoPt_ = iBooker.book1D("TauEcalIsoPt", "Tau Ecal Iso.", 10, -0.01, 10.);
   hTauDiscrAgainstMuons_ = iBooker.book1D("TauDiscrAgainstMuons", "Tau Discr. against Muons", 2, -0.5, +1.5);
   hTauJetNumSignalTracks_ = iBooker.book1D("TauJetNumSignalTracks", "Num. Tau signal Cone Tracks", 20, -0.5, +19.5);
   hTauJetNumIsoTracks_ = iBooker.book1D("TauJetNumIsoTracks", "Num. Tau isolation Cone Tracks", 20, -0.5, +19.5);
 
   hVisMass_ = iBooker.book1D("VisMass", "#mu + #tau-Jet visible Mass", 20, 0., 120.);
   hVisMassFinal_ = iBooker.book1D("VisMassFinal", "#mu + #tau-Jet visible final Mass", 20, 0., 120.);
   hMtMuPFMEt_ = iBooker.book1D("MtMuPFMEt", "#mu + E_{T}^{miss} (PF) transverse Mass", 20, 0., 120.);
   hMuTauAcoplanarity_ =
       iBooker.book1D("MuTauAcoplanarity", "#Delta #phi_{#mu #tau-Jet}", 20, -TMath::Pi(), +TMath::Pi());
   hMuTauDeltaR_ = iBooker.book1D("MuTauDeltaR", "#Delta R_{#mu #tau-Jet}", 20, 0, 5);
   hVertexZ_ = iBooker.book1D("VertexZ", "Event Vertex z-Position", 20, -25., +25.);
   hCaloMEtPt_ = iBooker.book1D("CaloMEtPt", "E_{T}^{miss} (Calo)", 20, 0., 100.);
   hPFMEtPt_ = iBooker.book1D("PFMEtPt", "E_{T}^{miss} (PF)", 20, 0., 100.);
   hCutFlowSummary_ = iBooker.book1D("CutFlowSummary", "Cut-flow Summary", 11, 0.5, 11.5);
   hCutFlowSummary_->setBinLabel(kPassedPreselection, "Preselection");
   hCutFlowSummary_->setBinLabel(kPassedTrigger, "HLT");
   hCutFlowSummary_->setBinLabel(kPassedMuonId, "#mu ID");
   hCutFlowSummary_->setBinLabel(kPassedMuonTrackIso, "#mu Trk Iso.");
   hCutFlowSummary_->setBinLabel(kPassedMuonEcalIso, "#mu Ecal Iso.");
   hCutFlowSummary_->setBinLabel(kPassedTauLeadTrack, "#tau lead. Track");
   hCutFlowSummary_->setBinLabel(kPassedTauLeadTrackPt, "#tau lead. Track P_{T}");
   hCutFlowSummary_->setBinLabel(kPassedTauTrackIso, "#tau Track Iso.");
   hCutFlowSummary_->setBinLabel(kPassedTauEcalIso, "#tau Ecal Iso.");
   hCutFlowSummary_->setBinLabel(kPassedTauDiscrAgainstMuons, "#tau anti-#mu Discr.");
   hCutFlowSummary_->setBinLabel(kPassedDeltaR, "#DeltaR(#mu,#tau) ");
 }

void EwkMuTauHistManager::fillHistograms	(	const edm::Event &	evt,
		const edm::EventSetup &	es
	)

Definition at line 647 of file EwkTauDQM.cc.

References beam_dqm_sourceclient-live_cfg::beamSpot, beamSpotSource_, calcDeltaPhi(), calcMt(), caloMEtSource_, cfgError_, HLT_FULL_cff::DeltaR, deltaRCut_, reco::MuonIsolation::emEt, reco::LeafCandidate::eta(), dqm::impl::MonitorElement::Fill(), getTheMuon(), getTheTauJet(), hCaloMEtPt_, hCutFlowSummary_, hltPaths_, hMtMuPFMEt_, hMuonCombIsoPt_, hMuonEcalIsoPt_, hMuonEta_, hMuonPhi_, hMuonPt_, hMuonTrackIsoPt_, hMuTauAcoplanarity_, hMuTauDeltaR_, hPFMEtPt_, hTauDiscrAgainstMuons_, hTauEcalIsoPt_, hTauJetEta_, hTauJetNumIsoTracks_, hTauJetNumSignalTracks_, hTauJetPhi_, hTauJetPt_, hTauLeadTrackPt_, hTauTrackIsoPt_, hVertexZ_, hVisMass_, hVisMassFinal_, edm::RefVector< C, T, F >::isAvailable(), edm::Ref< C, T, F >::isAvailable(), reco::Muon::isGlobalMuon(), reco::PFTau::isolationPFChargedHadrCandsPtSum(), reco::PFTau::isolationPFGammaCandsEtSum(), reco::Muon::isolationR05(), reco::BaseTau::isolationTracks(), isSelected(), reco::Muon::isTrackerMuon(), kAbsoluteIso, kPassedDeltaR, kPassedMuonEcalIso, kPassedMuonId, kPassedMuonTrackIso, kPassedPreselection, kPassedTauDiscrAgainstMuons, kPassedTauEcalIso, kPassedTauLeadTrack, kPassedTauLeadTrackPt, kPassedTauTrackIso, kPassedTrigger, kRelativeIso, reco::BaseTau::leadTrack(), maxNumWarnings_, HLT_FULL_cff::muon, muonCombIsoCut_, muonEcalIsoCut_, muonEtaCut_, muonIsoMode_, muonPtCut_, patZpeak::muons, muonSource_, muonTrackIsoCut_, numEventsAnalyzed_, numEventsSelected_, numWarningsBeamSpot_, numWarningsCaloMEt_, numWarningsHLTpath_, numWarningsMuon_, numWarningsPFMEt_, numWarningsTauDiscrAgainstMuons_, numWarningsTauDiscrByEcalIso_, numWarningsTauDiscrByLeadTrackFinding_, numWarningsTauDiscrByLeadTrackPtCut_, numWarningsTauDiscrByTrackIso_, numWarningsTauJet_, numWarningsTriggerResults_, numWarningsVertex_, reco::RecoCandidate::p4, pfMEtSource_, reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), readEventData(), reco::BaseTau::signalTracks(), edm::TriggerNames::size(), edm::RefVector< C, T, F >::size(), reco::MuonIsolation::sumPt, tauDiscrAgainstMuons_, tauDiscrByLeadTrackFinding_, tauDiscrByLeadTrackPtCut_, tauDiscrByTrackIso_, tauJetEtaCut_, tauJetPtCut_, tauJetSource_, edm::TriggerNames::triggerIndex(), L1TMuonDQMOffline_cfi::triggerNames, edm::Event::triggerNames(), triggerResultsSource_, GoodVertex_cfg::vertexCollection, vertexSource_, visMassCut_, and reco::Vertex::z().

Referenced by EwkTauDQM::analyze().

                                                                                      {
   if (cfgError_)
     return;
 
   //-----------------------------------------------------------------------------
   // access event-level information
   //-----------------------------------------------------------------------------
 
   bool readError = false;
 
   //--- get decision of high-level trigger for the event
   edm::Handle<edm::TriggerResults> hltDecision;
   readEventData(evt,
                 triggerResultsSource_,
                 hltDecision,
                 numWarningsTriggerResults_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access Trigger results");
   if (readError)
     return;
 
   const edm::TriggerNames& triggerNames = evt.triggerNames(*hltDecision);
 
   bool isTriggered = false;
   for (vstring::const_iterator hltPath = hltPaths_.begin(); hltPath != hltPaths_.end(); ++hltPath) {
     unsigned int index = triggerNames.triggerIndex(*hltPath);
     if (index < triggerNames.size()) {
       if (hltDecision->accept(index))
         isTriggered = true;
     } else {
       if (numWarningsHLTpath_ < maxNumWarnings_ || maxNumWarnings_ == -1)
         edm::LogWarning("EwkMuTauHistManager") << " Undefined HLT path = " << (*hltPath) << " !!";
       ++numWarningsHLTpath_;
       continue;
     }
   }
 
   //--- get reconstructed primary event vertex of the event
   //   (take as "the" primary event vertex the first entry in the collection
   //    of vertex objects, corresponding to the vertex associated to the highest
   // Pt sum of tracks)
   edm::Handle<reco::VertexCollection> vertexCollection;
   readEventData(evt,
                 vertexSource_,
                 vertexCollection,
                 numWarningsVertex_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access Vertex collection");
   if (readError)
     return;
 
   const reco::Vertex* theEventVertex = (!vertexCollection->empty()) ? &(vertexCollection->at(0)) : nullptr;
 
   //--- get beam-spot (expected vertex position) for the event
   edm::Handle<reco::BeamSpot> beamSpot;
   readEventData(
       evt, beamSpotSource_, beamSpot, numWarningsBeamSpot_, maxNumWarnings_, readError, "Failed to access Beam-spot");
   if (readError)
     return;
 
   //--- get collections of reconstructed muons from the event
   edm::Handle<reco::MuonCollection> muons;
   readEventData(
       evt, muonSource_, muons, numWarningsMuon_, maxNumWarnings_, readError, "Failed to access Muon collection");
   if (readError)
     return;
 
   const reco::Muon* theMuon = getTheMuon(*muons, muonEtaCut_, muonPtCut_);
 
   double theMuonTrackIsoPt = 1.e+3;
   double theMuonEcalIsoPt = 1.e+3;
   double theMuonCombIsoPt = 1.e+3;
 
   if (theMuon) {
     theMuonTrackIsoPt = theMuon->isolationR05().sumPt;
     // mu.isolationR05().emEt + mu.isolationR05().hadEt +
     // mu.isolationR05().sumPt
     theMuonEcalIsoPt = theMuon->isolationR05().emEt;
 
     if (muonIsoMode_ == kRelativeIso && theMuon->pt() > 0.) {
       theMuonTrackIsoPt /= theMuon->pt();
       theMuonEcalIsoPt /= theMuon->pt();
       theMuonCombIsoPt = (theMuon->isolationR05().sumPt + theMuon->isolationR05().emEt) / theMuon->pt();
       // std::cout<<"Rel Iso ="<<theMuonCombIsoPt<<std::endl;
     }
   }
 
   //--- get collections of reconstructed tau-jets from the event
   edm::Handle<reco::PFTauCollection> tauJets;
   readEventData(evt,
                 tauJetSource_,
                 tauJets,
                 numWarningsTauJet_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access Tau-jet collection");
   if (readError)
     return;
 
   //--- get collections of tau-jet discriminators for those tau-jets
   edm::Handle<reco::PFTauDiscriminator> tauDiscrByLeadTrackFinding;
   readEventData(evt,
                 tauDiscrByLeadTrackFinding_,
                 tauDiscrByLeadTrackFinding,
                 numWarningsTauDiscrByLeadTrackFinding_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access collection of pf. Tau discriminators by "
                 "leading Track finding");
   edm::Handle<reco::PFTauDiscriminator> tauDiscrByLeadTrackPtCut;
   readEventData(evt,
                 tauDiscrByLeadTrackPtCut_,
                 tauDiscrByLeadTrackPtCut,
                 numWarningsTauDiscrByLeadTrackPtCut_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access collection of pf. Tau discriminators by "
                 "leading Track Pt cut");
   edm::Handle<reco::PFTauDiscriminator> tauDiscrByTrackIso;
   readEventData(evt,
                 tauDiscrByTrackIso_,
                 tauDiscrByTrackIso,
                 numWarningsTauDiscrByTrackIso_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access collection of pf. Tau discriminators by "
                 "Track isolation");
   edm::Handle<reco::PFTauDiscriminator> tauDiscrByEcalIso;
   readEventData(evt,
                 tauDiscrByTrackIso_,
                 tauDiscrByEcalIso,
                 numWarningsTauDiscrByEcalIso_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access collection of pf. Tau discriminators by ECAL "
                 "isolation");
   edm::Handle<reco::PFTauDiscriminator> tauDiscrAgainstMuons;
   readEventData(evt,
                 tauDiscrAgainstMuons_,
                 tauDiscrAgainstMuons,
                 numWarningsTauDiscrAgainstMuons_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access collection of pf. Tau discriminators against Muons");
   if (readError)
     return;
 
   int theTauJetIndex = -1;
   const reco::PFTau* theTauJet = getTheTauJet(*tauJets, tauJetEtaCut_, tauJetPtCut_, theTauJetIndex);
 
   double theTauDiscrByLeadTrackFinding = -1.;
   double theTauDiscrByLeadTrackPtCut = -1.;
   double theTauDiscrByTrackIso = -1.;
   double theTauDiscrByEcalIso = -1.;
   double theTauDiscrAgainstMuons = -1.;
   if (theTauJetIndex != -1) {
     reco::PFTauRef theTauJetRef(tauJets, theTauJetIndex);
     theTauDiscrByLeadTrackFinding = (*tauDiscrByLeadTrackFinding)[theTauJetRef];
     theTauDiscrByLeadTrackPtCut = (*tauDiscrByLeadTrackPtCut)[theTauJetRef];
     theTauDiscrByTrackIso = (*tauDiscrByTrackIso)[theTauJetRef];
     theTauDiscrByEcalIso = (*tauDiscrByEcalIso)[theTauJetRef];
     theTauDiscrAgainstMuons = (*tauDiscrAgainstMuons)[theTauJetRef];
   }
 
   //--- get missing transverse momentum
   //    measured by calorimeters/reconstructed by particle-flow algorithm
   edm::Handle<reco::CaloMETCollection> caloMEtCollection;
   readEventData(evt,
                 caloMEtSource_,
                 caloMEtCollection,
                 numWarningsCaloMEt_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access calo. MET collection");
   if (readError)
     return;
 
   const reco::CaloMET& caloMEt = caloMEtCollection->at(0);
 
   edm::Handle<reco::PFMETCollection> pfMEtCollection;
   readEventData(evt,
                 pfMEtSource_,
                 pfMEtCollection,
                 numWarningsPFMEt_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access pf. MET collection");
   if (readError)
     return;
 
   const reco::PFMET& pfMEt = pfMEtCollection->at(0);
 
   if (!(theMuon && theTauJet && theTauJetIndex != -1))
     return;
 
   //-----------------------------------------------------------------------------
   // compute EWK tau analysis specific quantities
   //-----------------------------------------------------------------------------
 
   double dPhiMuTau = calcDeltaPhi(theMuon->phi(), theTauJet->phi());
   // double dRMuTau = calcDeltaR(theMuon->p4(), theTauJet->p4());
   double dRMuTau = fabs(ROOT::Math::VectorUtil::DeltaR(theMuon->p4(), theTauJet->p4()));
   double mMuTau = (theMuon->p4() + theTauJet->p4()).M();
 
   // double mtMuCaloMEt = calcMt(theMuon->px(), theMuon->px(), caloMEt.px(),
   // caloMEt.py());
   double mtMuPFMEt = calcMt(theMuon->px(), theMuon->px(), pfMEt.px(), pfMEt.py());
 
   // double pZetaCaloMEt = calcPzeta(theMuon->p4(), theTauJet->p4(),
   // caloMEt.px(), caloMEt.py());
   // double pZetaPFMEt = calcPzeta(theMuon->p4(), theTauJet->p4(), pfMEt.px(),
   // pfMEt.py());
 
   //-----------------------------------------------------------------------------
   // apply selection criteria; fill histograms
   //-----------------------------------------------------------------------------
 
   //--- fill muon multiplicity histogram
   unsigned numGlobalMuons = 0;
   for (reco::MuonCollection::const_iterator muon = muons->begin(); muon != muons->end(); ++muon) {
     if (muon->isGlobalMuon()) {
       ++numGlobalMuons;
     }
   }
 
   // hNumGlobalMuons_->Fill(numGlobalMuons);
 
   ++numEventsAnalyzed_;
 
   bool isSelected = false;
   int cutFlowStatus = -1;
 
   // if ( muonIsoMode_ == kAbsoluteIso){
   if (mMuTau > visMassCut_) {
     cutFlowStatus = kPassedPreselection;
   }
   if (cutFlowStatus == kPassedPreselection && (isTriggered || hltPaths_.empty())) {
     cutFlowStatus = kPassedTrigger;
   }
   if (cutFlowStatus == kPassedTrigger && (theMuon->isGlobalMuon() || theMuon->isTrackerMuon())) {
     cutFlowStatus = kPassedMuonId;
   }
 
   if (cutFlowStatus == kPassedMuonId && (theTauDiscrByLeadTrackFinding > 0.5) && (theTauJet->eta() < tauJetEtaCut_) &&
       (theTauJet->pt() > tauJetPtCut_)) {
     cutFlowStatus = kPassedTauLeadTrack;
   }
   if (cutFlowStatus == kPassedTauLeadTrack && theTauDiscrByLeadTrackPtCut > 0.5) {
     cutFlowStatus = kPassedTauLeadTrackPt;
     // hTauTrackIsoPt_->Fill(theTauJet->isolationPFChargedHadrCandsPtSum());
   }
   if (cutFlowStatus == kPassedTauLeadTrackPt && theTauDiscrAgainstMuons > 0.5) {
     cutFlowStatus = kPassedTauDiscrAgainstMuons;
     // hTauEcalIsoPt_->Fill(theTauJet->isolationPFGammaCandsEtSum());
   }
   if (cutFlowStatus == kPassedTauDiscrAgainstMuons && dRMuTau > deltaRCut_) {
     cutFlowStatus = kPassedDeltaR;
     // hTauDiscrAgainstMuons_->Fill(theTauDiscrAgainstMuons);
 
     hMuonPt_->Fill(theMuon->pt());
     hMuonEta_->Fill(theMuon->eta());
     hMuonPhi_->Fill(theMuon->phi());
 
     hTauJetPt_->Fill(theTauJet->pt());
     hTauJetEta_->Fill(theTauJet->eta());
     hTauJetPhi_->Fill(theTauJet->phi());
 
     // hTauJetCharge_->Fill(theTauJet->charge());
     if (theTauJet->signalTracks().isAvailable())
       hTauJetNumSignalTracks_->Fill(theTauJet->signalTracks().size());
     if (theTauJet->isolationTracks().isAvailable())
       hTauJetNumIsoTracks_->Fill(theTauJet->isolationTracks().size());
 
     hVisMass_->Fill(mMuTau);
     // hMtMuCaloMEt_->Fill(mtMuCaloMEt);
     hMtMuPFMEt_->Fill(mtMuPFMEt);
     // hPzetaCaloMEt_->Fill(pZetaCaloMEt);
     // hPzetaPFMEt_->Fill(pZetaPFMEt);
     hMuTauAcoplanarity_->Fill(dPhiMuTau);
     hMuTauDeltaR_->Fill(dRMuTau);
     // hMuTauCharge_->Fill(theMuon->charge() + theTauJet->charge());
 
     if (theEventVertex) {
       // hVertexChi2_->Fill(theEventVertex->normalizedChi2());
       hVertexZ_->Fill(theEventVertex->z());
       // hVertexD0_->Fill(getVertexD0(*theEventVertex, *beamSpot));
     }
 
     hCaloMEtPt_->Fill(caloMEt.pt());
     // hCaloMEtPhi_->Fill(caloMEt.phi());
 
     hPFMEtPt_->Fill(pfMEt.pt());
     // hPFMEtPhi_->Fill(pfMEt.phi());
     hMuonTrackIsoPt_->Fill(theMuonTrackIsoPt);
     hMuonEcalIsoPt_->Fill(theMuonEcalIsoPt);
     hMuonCombIsoPt_->Fill(theMuonCombIsoPt);
     // hMuonCombIsoPt_->Fill((theMuonTrackIsoPt+theMuonEcalIsoPt)/theMuon->pt());
 
     // std::cout<<"Rel Iso Hist =
     // "<<(theMuonTrackIsoPt+theMuonEcalIsoPt)/theMuon->pt()<<std::endl;
     hTauEcalIsoPt_->Fill(theTauJet->isolationPFGammaCandsEtSum());
     hTauTrackIsoPt_->Fill(theTauJet->isolationPFChargedHadrCandsPtSum());
     hTauDiscrAgainstMuons_->Fill(theTauDiscrAgainstMuons);
     if (theTauJet->leadTrack().isAvailable())
       hTauLeadTrackPt_->Fill(theTauJet->leadTrack()->pt());
   }
 
   if ((cutFlowStatus == kPassedDeltaR) && (((theMuonTrackIsoPt < muonTrackIsoCut_) && (muonIsoMode_ == kAbsoluteIso)) ||
                                            ((1 > 0) && (muonIsoMode_ == kRelativeIso)))) {
     cutFlowStatus = kPassedMuonTrackIso;
     // isSelected = true;
   }
   if (cutFlowStatus == kPassedMuonTrackIso &&
       (((theMuonEcalIsoPt < muonEcalIsoCut_) && (muonIsoMode_ == kAbsoluteIso)) ||
        ((theMuonCombIsoPt < muonCombIsoCut_) && (muonIsoMode_ == kRelativeIso)))) {
     cutFlowStatus = kPassedMuonEcalIso;
     // isSelected = true;
   }
 
   if (cutFlowStatus == kPassedMuonEcalIso && theTauDiscrByTrackIso > 0.5) {
     cutFlowStatus = kPassedTauTrackIso;
   }
 
   if (cutFlowStatus == kPassedTauTrackIso && theTauDiscrByEcalIso > 0.5) {
     cutFlowStatus = kPassedTauEcalIso;
     isSelected = true;
   }
 
   for (int iCut = 1; iCut <= cutFlowStatus; ++iCut) {
     hCutFlowSummary_->Fill(iCut);
   }
 
   for (int iCut = 1; iCut <= cutFlowStatus; ++iCut) {
     hCutFlowSummary_->Fill(iCut);
   }
 
   //     }
 
   if (isSelected) {
     hVisMassFinal_->Fill(mMuTau);
     ++numEventsSelected_;
   }
 }

void EwkMuTauHistManager::finalizeHistograms ( )

Definition at line 993 of file EwkTauDQM.cc.

References numEventsAnalyzed_, and numEventsSelected_.

Referenced by EwkTauDQM::dqmEndRun().

                                              {
   edm::LogInfo("EwkMuTauHistManager") << "Filter-Statistics Summary:" << std::endl
                                       << " Events analyzed = " << numEventsAnalyzed_ << std::endl
                                       << " Events selected = " << numEventsSelected_;
   if (numEventsAnalyzed_ > 0) {
     double eff = numEventsSelected_ / (double)numEventsAnalyzed_;
     edm::LogInfo("") << "Overall efficiency = " << std::setprecision(4) << eff * 100. << " +/- " << std::setprecision(4)
                      << TMath::Sqrt(eff * (1 - eff) / numEventsAnalyzed_) * 100. << ")%";
   }
 }