#include <EwkTauDQM.h>

Public Types
typedef EwkTauDQM::DQMStore	DQMStore

typedef EwkTauDQM::MonitorElement	MonitorElement

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

	EwkElecTauHistManager (const edm::ParameterSet &)

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

void	finalizeHistograms ()

Private Types
enum	{ kPassedPreselection = 1, kPassedTrigger = 2, kPassedElectronId = 3, kPassedElectronTrackIso = 4, kPassedElectronEcalIso = 5, kPassedTauLeadTrack = 6, kPassedTauLeadTrackPt = 7, kPassedTauDiscrAgainstElectrons = 8, kPassedTauDiscrAgainstMuons = 9, kPassedTauTrackIso = 10, kPassedTauEcalIso = 11 }

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

Private Attributes
edm::InputTag	beamSpotSource_

edm::InputTag	caloMEtSource_

int	cfgError_

std::string	dqmDirectory_

double	electronEcalIsoCut_

double	electronEtaCut_

int	electronIsoMode_

double	electronPtCut_

edm::InputTag	electronSource_

double	electronTrackIsoCut_

MonitorElement *	hCaloMEtPt_

MonitorElement *	hCutFlowSummary_

MonitorElement *	hElecTauAcoplanarity_

MonitorElement *	hElecTauCharge_

MonitorElement *	hElectronEcalIsoPt_

MonitorElement *	hElectronEta_

MonitorElement *	hElectronPhi_

MonitorElement *	hElectronPt_

MonitorElement *	hElectronTrackIsoPt_

vstring	hltPaths_

MonitorElement *	hMtElecPFMEt_

MonitorElement *	hPFMEtPt_

MonitorElement *	hTauJetEta_

MonitorElement *	hTauJetPt_

MonitorElement *	hVertexZ_

MonitorElement *	hVisMass_

int	maxNumWarnings_

unsigned	numEventsAnalyzed_

unsigned	numEventsSelected_

long	numWarningsBeamSpot_

long	numWarningsCaloMEt_

long	numWarningsElectron_

long	numWarningsHLTpath_

long	numWarningsPFMEt_

long	numWarningsTauDiscrAgainstElectrons_

long	numWarningsTauDiscrAgainstMuons_

long	numWarningsTauDiscrByEcalIso_

long	numWarningsTauDiscrByLeadTrackFinding_

long	numWarningsTauDiscrByLeadTrackPtCut_

long	numWarningsTauDiscrByTrackIso_

long	numWarningsTauJet_

long	numWarningsTriggerResults_

long	numWarningsVertex_

edm::InputTag	pfMEtSource_

edm::InputTag	tauDiscrAgainstElectrons_

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 –> electron + tau-jet channel

Author: Joshua Swanson (modified by Christian Veelken)

Definition at line 68 of file EwkTauDQM.h.

Member Typedef Documentation

◆ DQMStore

typedef EwkTauDQM::DQMStore EwkElecTauHistManager::DQMStore

Definition at line 70 of file EwkTauDQM.h.

◆ MonitorElement

typedef EwkTauDQM::MonitorElement EwkElecTauHistManager::MonitorElement

Definition at line 71 of file EwkTauDQM.h.

◆ vstring

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

private

Definition at line 98 of file EwkTauDQM.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
kPassedPreselection
kPassedTrigger
kPassedElectronId
kPassedElectronTrackIso
kPassedElectronEcalIso
kPassedTauLeadTrack
kPassedTauLeadTrackPt
kPassedTauDiscrAgainstElectrons
kPassedTauDiscrAgainstMuons
kPassedTauTrackIso
kPassedTauEcalIso

Definition at line 156 of file EwkTauDQM.h.

        {
     kPassedPreselection = 1,
     kPassedTrigger = 2,
     kPassedElectronId = 3,
     kPassedElectronTrackIso = 4,
     kPassedElectronEcalIso = 5,
     kPassedTauLeadTrack = 6,
     kPassedTauLeadTrackPt = 7,
     kPassedTauDiscrAgainstElectrons = 8,
     kPassedTauDiscrAgainstMuons = 9,
     kPassedTauTrackIso = 10,
     kPassedTauEcalIso = 11
   };

Constructor & Destructor Documentation

◆ EwkElecTauHistManager()

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

Definition at line 91 of file EwkTauDQM.cc.

References beamSpotSource_, caloMEtSource_, looper::cfg, cfgError_, electronEcalIsoCut_, electronEtaCut_, electronIsoMode_, electronPtCut_, electronSource_, electronTrackIsoCut_, getIsoMode(), hltPaths_, maxNumWarnings_, pfMEtSource_, AlCaHLTBitMon_QueryRunRegistry::string, tauDiscrAgainstElectrons_, 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),
       numWarningsElectron_(0),
       numWarningsTauJet_(0),
       numWarningsTauDiscrByLeadTrackFinding_(0),
       numWarningsTauDiscrByLeadTrackPtCut_(0),
       numWarningsTauDiscrByTrackIso_(0),
       numWarningsTauDiscrByEcalIso_(0),
       numWarningsTauDiscrAgainstElectrons_(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");
   electronSource_ = cfg.getParameter<edm::InputTag>("electronSource");
   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");
   tauDiscrAgainstElectrons_ = cfg.getParameter<edm::InputTag>("tauDiscrAgainstElectrons");
   tauDiscrAgainstMuons_ = cfg.getParameter<edm::InputTag>("tauDiscrAgainstMuons");
 
   hltPaths_ = cfg.getParameter<vstring>("hltPaths");
 
   electronEtaCut_ = cfg.getParameter<double>("electronEtaCut");
   electronPtCut_ = cfg.getParameter<double>("electronPtCut");
   electronTrackIsoCut_ = cfg.getParameter<double>("electronTrackIsoCut");
   electronEcalIsoCut_ = cfg.getParameter<double>("electronEcalIsoCut");
   std::string electronIsoMode_string = cfg.getParameter<std::string>("electronIsoMode");
   electronIsoMode_ = getIsoMode(electronIsoMode_string, cfgError_);
 
   tauJetEtaCut_ = cfg.getParameter<double>("tauJetEtaCut");
   tauJetPtCut_ = cfg.getParameter<double>("tauJetPtCut");
 
   visMassCut_ = cfg.getParameter<double>("visMassCut");
 
   maxNumWarnings_ = cfg.exists("maxNumWarnings") ? cfg.getParameter<int>("maxNumWarnings") : 1;
 }

Member Function Documentation

◆ bookHistograms()

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

Definition at line 142 of file EwkTauDQM.cc.

References dqm::implementation::IBooker::book1D(), dqmDirectory_, hCaloMEtPt_, hCutFlowSummary_, hElecTauAcoplanarity_, hElecTauCharge_, hElectronEcalIsoPt_, hElectronEta_, hElectronPhi_, hElectronPt_, hElectronTrackIsoPt_, hMtElecPFMEt_, hPFMEtPt_, hTauJetEta_, hTauJetPt_, hVertexZ_, hVisMass_, kPassedElectronEcalIso, kPassedElectronId, kPassedElectronTrackIso, kPassedPreselection, kPassedTauDiscrAgainstElectrons, kPassedTauDiscrAgainstMuons, kPassedTauEcalIso, kPassedTauLeadTrack, kPassedTauLeadTrackPt, kPassedTauTrackIso, kPassedTrigger, Pi, dqm::impl::MonitorElement::setBinLabel(), and dqm::implementation::NavigatorBase::setCurrentFolder().

Referenced by EwkTauDQM::bookHistograms().

                                                                    {
   iBooker.setCurrentFolder(dqmDirectory_);
   hElectronPt_ = iBooker.book1D("ElectronPt", "P_{T}^{e}", 20, 0., 100.);
   hElectronEta_ = iBooker.book1D("ElectronEta", "#eta_{e}", 20, -4.0, +4.0);
   hElectronPhi_ = iBooker.book1D("ElectronPhi", "#phi_{e}", 20, -TMath::Pi(), +TMath::Pi());
   hElectronTrackIsoPt_ = iBooker.book1D("ElectronTrackIsoPt", "Electron Track Iso.", 20, -0.01, 0.5);
   hElectronEcalIsoPt_ = iBooker.book1D("ElectronEcalIsoPt", "Electron Ecal Iso.", 20, -0.01, 0.5);
   hTauJetPt_ = iBooker.book1D("TauJetPt", "P_{T}^{#tau-Jet}", 20, 0., 100.);
   hTauJetEta_ = iBooker.book1D("TauJetEta", "#eta_{#tau-Jet}", 20, -4.0, +4.0);
   hVisMass_ = iBooker.book1D("VisMass", "e + #tau-Jet visible Mass", 20, 20., 120.);
   hMtElecPFMEt_ = iBooker.book1D("MtElecPFMEt", "e + E_{T}^{miss} (PF) transverse Mass", 20, 20., 120.);
   hElecTauAcoplanarity_ =
       iBooker.book1D("ElecTauAcoplanarity", "#Delta #phi_{e #tau-Jet}", 20, -TMath::Pi(), +TMath::Pi());
   hElecTauCharge_ = iBooker.book1D("ElecTauCharge", "Q_{e * #tau-Jet}", 5, -2.5, +2.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(kPassedElectronId, "e ID");
   hCutFlowSummary_->setBinLabel(kPassedElectronTrackIso, "e Trk Iso.");
   hCutFlowSummary_->setBinLabel(kPassedElectronEcalIso, "e Ecal Iso.");
   hCutFlowSummary_->setBinLabel(kPassedTauLeadTrack, "#tau lead. Track");
   hCutFlowSummary_->setBinLabel(kPassedTauLeadTrackPt, "#tau lead. Track P_{T}");
   hCutFlowSummary_->setBinLabel(kPassedTauDiscrAgainstElectrons, "#tau anti-e Discr.");
   hCutFlowSummary_->setBinLabel(kPassedTauDiscrAgainstMuons, "#tau anti-#mu Discr.");
   hCutFlowSummary_->setBinLabel(kPassedTauTrackIso, "#tau Track Iso.");
   hCutFlowSummary_->setBinLabel(kPassedTauEcalIso, "#tau Ecal Iso.");
 }

◆ fillHistograms()

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

Definition at line 173 of file EwkTauDQM.cc.

References edm::HLTGlobalStatus::accept(), pwdgSkimBPark_cfi::beamSpot, beamSpotSource_, calcDeltaPhi(), calcMt(), caloMEtSource_, cfgError_, reco::LeafCandidate::charge(), reco::GsfElectron::dr03EcalRecHitSumEt(), reco::GsfElectron::dr03TkSumPt(), HPSPFTauProducerPuppi_cfi::electron, electronEcalIsoCut_, electronEtaCut_, electronIsoMode_, electronPtCut_, pwdgSkimBPark_cfi::electrons, electronSource_, electronTrackIsoCut_, reco::LeafCandidate::eta(), dqm::impl::MonitorElement::Fill(), getTheElectron(), getTheTauJet(), hCaloMEtPt_, hCutFlowSummary_, hElecTauAcoplanarity_, hElecTauCharge_, hElectronEcalIsoPt_, hElectronEta_, hElectronPhi_, hElectronPt_, hElectronTrackIsoPt_, TriggerAnalyzer::hltPath, hltPaths_, hMtElecPFMEt_, hPFMEtPt_, hTauJetEta_, hTauJetPt_, hVertexZ_, hVisMass_, isSelected(), kPassedElectronEcalIso, kPassedElectronId, kPassedElectronTrackIso, kPassedPreselection, kPassedTauDiscrAgainstElectrons, kPassedTauDiscrAgainstMuons, kPassedTauEcalIso, kPassedTauLeadTrack, kPassedTauLeadTrackPt, kPassedTauTrackIso, kPassedTrigger, kRelativeIso, maxNumWarnings_, numEventsAnalyzed_, numEventsSelected_, numWarningsBeamSpot_, numWarningsCaloMEt_, numWarningsElectron_, numWarningsHLTpath_, numWarningsPFMEt_, numWarningsTauDiscrAgainstElectrons_, numWarningsTauDiscrAgainstMuons_, numWarningsTauDiscrByEcalIso_, numWarningsTauDiscrByLeadTrackFinding_, numWarningsTauDiscrByLeadTrackPtCut_, numWarningsTauDiscrByTrackIso_, numWarningsTauJet_, numWarningsTriggerResults_, numWarningsVertex_, reco::LeafCandidate::p4(), reco::GsfElectron::p4(), passesElectronId(), pfMEtSource_, reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), readEventData(), ewkTauDQM_cfi::tauDiscrAgainstElectrons, tauDiscrAgainstElectrons_, ewkTauDQM_cfi::tauDiscrAgainstMuons, tauDiscrAgainstMuons_, ewkTauDQM_cfi::tauDiscrByEcalIso, ewkTauDQM_cfi::tauDiscrByLeadTrackFinding, tauDiscrByLeadTrackFinding_, ewkTauDQM_cfi::tauDiscrByLeadTrackPtCut, tauDiscrByLeadTrackPtCut_, ewkTauDQM_cfi::tauDiscrByTrackIso, tauDiscrByTrackIso_, tauJetEtaCut_, tauJetPtCut_, tauJetSource_, L1TEGammaOffline_cfi::triggerNames, edm::Event::triggerNames(), triggerResultsSource_, spclusmultinvestigator_cfi::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("EwkElecTauHistManager") << " 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 electrons from the event
   edm::Handle<reco::GsfElectronCollection> electrons;
   readEventData(evt,
                 electronSource_,
                 electrons,
                 numWarningsElectron_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access Electron collection");
   if (readError)
     return;
 
   const reco::GsfElectron* theElectron = getTheElectron(*electrons, electronEtaCut_, electronPtCut_);
 
   double theElectronTrackIsoPt = 1.e+3;
   double theElectronEcalIsoPt = 1.e+3;
   if (theElectron) {
     theElectronTrackIsoPt = theElectron->dr03TkSumPt();
     theElectronEcalIsoPt = theElectron->dr03EcalRecHitSumEt();
 
     if (electronIsoMode_ == kRelativeIso && theElectron->pt() > 0.) {
       theElectronTrackIsoPt /= theElectron->pt();
       theElectronEcalIsoPt /= theElectron->pt();
     }
   }
 
   //--- 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> tauDiscrAgainstElectrons;
   readEventData(evt,
                 tauDiscrAgainstElectrons_,
                 tauDiscrAgainstElectrons,
                 numWarningsTauDiscrAgainstElectrons_,
                 maxNumWarnings_,
                 readError,
                 "Failed to access collection of pf. Tau discriminators against "
                 "Electrons");
   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 theTauDiscrAgainstElectrons = -1.;
   double theTauDiscrAgainstMuons = -1.;
   if (theTauJetIndex != -1) {
     reco::PFTauRef theTauJetRef(tauJets, theTauJetIndex);
     theTauDiscrByLeadTrackFinding = (*tauDiscrByLeadTrackFinding)[theTauJetRef];
     theTauDiscrByLeadTrackPtCut = (*tauDiscrByLeadTrackPtCut)[theTauJetRef];
     theTauDiscrByTrackIso = (*tauDiscrByTrackIso)[theTauJetRef];
     theTauDiscrByEcalIso = (*tauDiscrByEcalIso)[theTauJetRef];
     theTauDiscrAgainstElectrons = (*tauDiscrAgainstElectrons)[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 (!(theElectron && theTauJet && theTauJetIndex != -1))
     return;
 
   //-----------------------------------------------------------------------------
   // compute EWK tau analysis specific quantities
   //-----------------------------------------------------------------------------
 
   double dPhiElecTau = calcDeltaPhi(theElectron->phi(), theTauJet->phi());
 
   double mElecTau = (theElectron->p4() + theTauJet->p4()).M();
 
   // double mtElecCaloMEt = calcMt(theElectron->px(), theElectron->py(),
   // caloMEt.px(), caloMEt.py());
   double mtElecPFMEt = calcMt(theElectron->px(), theElectron->py(), pfMEt.px(), pfMEt.py());
 
   // double pZetaCaloMEt = calcPzeta(theElectron->p4(), theTauJet->p4(),
   // caloMEt.px(), caloMEt.py());
   // double pZetaPFMEt = calcPzeta(theElectron->p4(), theTauJet->p4(),
   // pfMEt.px(), pfMEt.py());
 
   //-----------------------------------------------------------------------------
   // apply selection criteria; fill histograms
   //-----------------------------------------------------------------------------
 
   //--- fill electron multiplicity histogram
   unsigned numIdElectrons = 0;
   for (reco::GsfElectronCollection::const_iterator electron = electrons->begin(); electron != electrons->end();
        ++electron) {
     if (passesElectronId(*electron)) {
       ++numIdElectrons;
     }
   }
 
   // hNumIdElectrons_->Fill(numIdElectrons);
 
   ++numEventsAnalyzed_;
 
   bool isSelected = false;
   bool fullSelect = false;
   int cutFlowStatus = -1;
 
   if (mElecTau > visMassCut_) {
     cutFlowStatus = kPassedPreselection;
   }
   if (cutFlowStatus == kPassedPreselection && (isTriggered || hltPaths_.empty())) {
     cutFlowStatus = kPassedTrigger;
   }
   if (cutFlowStatus == kPassedTrigger && passesElectronId(*theElectron)) {
     cutFlowStatus = kPassedElectronId;
     hElectronTrackIsoPt_->Fill(theElectronTrackIsoPt);
   }
   if (cutFlowStatus == kPassedElectronId && theElectronTrackIsoPt < electronTrackIsoCut_) {
     cutFlowStatus = kPassedElectronTrackIso;
     hElectronEcalIsoPt_->Fill(theElectronEcalIsoPt);
   }
   if (cutFlowStatus == kPassedElectronTrackIso && theElectronEcalIsoPt < electronEcalIsoCut_) {
     cutFlowStatus = kPassedElectronEcalIso;
   }
   if (cutFlowStatus == kPassedElectronEcalIso && theTauDiscrByLeadTrackFinding > 0.5) {
     cutFlowStatus = kPassedTauLeadTrack;
     // if ( theTauJet->leadTrack().isAvailable() )
     // hTauLeadTrackPt_->Fill(theTauJet->leadTrack()->pt());
   }
   if (cutFlowStatus == kPassedTauLeadTrack && theTauDiscrByLeadTrackPtCut > 0.5) {
     cutFlowStatus = kPassedTauLeadTrackPt;
     // hTauTrackIsoPt_->Fill(theTauJet->isolationPFChargedHadrCandsPtSum());
   }
   if (cutFlowStatus == kPassedTauLeadTrackPt && theTauDiscrAgainstElectrons > 0.5) {
     cutFlowStatus = kPassedTauDiscrAgainstElectrons;
     // hTauDiscrAgainstMuons_->Fill(theTauDiscrAgainstMuons);
   }
   if (cutFlowStatus == kPassedTauDiscrAgainstElectrons && theTauDiscrAgainstMuons > 0.5) {
     cutFlowStatus = kPassedTauDiscrAgainstMuons;
     isSelected = true;
   }
   if (cutFlowStatus == kPassedTauDiscrAgainstMuons && theTauDiscrByTrackIso > 0.5) {
     cutFlowStatus = kPassedTauTrackIso;
     // hTauEcalIsoPt_->Fill(theTauJet->isolationPFGammaCandsEtSum());
   }
   if (cutFlowStatus == kPassedTauTrackIso && theTauDiscrByEcalIso > 0.5) {
     cutFlowStatus = kPassedTauEcalIso;
     fullSelect = true;
     // hTauDiscrAgainstElectrons_->Fill(theTauDiscrAgainstElectrons);
   }
 
   for (int iCut = 1; iCut <= cutFlowStatus; ++iCut) {
     hCutFlowSummary_->Fill(iCut);
   }
 
   if (isSelected) {
     hElectronPt_->Fill(theElectron->pt());
     hElectronEta_->Fill(theElectron->eta());
     hElectronPhi_->Fill(theElectron->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());
 
     if (fullSelect) {
       hVisMass_->Fill(mElecTau);
     }
     // hMtElecCaloMEt_->Fill(mtElecCaloMEt);
     hMtElecPFMEt_->Fill(mtElecPFMEt);
     // hPzetaCaloMEt_->Fill(pZetaCaloMEt);
     // hPzetaPFMEt_->Fill(pZetaPFMEt);
     hElecTauAcoplanarity_->Fill(dPhiElecTau);
     hElecTauCharge_->Fill(theElectron->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());
   }
 
   if (isSelected)
     ++numEventsSelected_;
 }

◆ finalizeHistograms()

void EwkElecTauHistManager::finalizeHistograms ( )

Definition at line 508 of file EwkTauDQM.cc.

References numEventsAnalyzed_, and numEventsSelected_.

Referenced by EwkTauDQM::dqmEndRun().

                                                {
   edm::LogInfo("EwkElecTauHistManager") << "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. << ")%";
   }
 }