#include <ElectronConversionRejectionValidator.h>

Inheritance diagram for ElectronConversionRejectionValidator:

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	bookHistograms (DQMStore::IBooker &bei, edm::Run const &, edm::EventSetup const &) override

	ElectronConversionRejectionValidator (const edm::ParameterSet &)

	~ElectronConversionRejectionValidator () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

void	beginStream (edm::StreamID id) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamspotToken_

std::string	conversionCollection_

std::string	conversionCollectionProducer_

edm::EDGetTokenT< reco::ConversionCollection >	convToken_

std::string	dqmpath_

float	eleD0Max_

int	eleExpectedHitsInnerMax_

float	elePtMin_

std::string	fName_

edm::EDGetTokenT< reco::GsfElectronCollection >	gsfElecToken_

std::string	gsfElectronCollection_

std::string	gsfElectronCollectionProducer_

MonitorElement *	h_convEta_

MonitorElement *	h_convLeadTrackAlgo_

MonitorElement *	h_convLeadTrackpt_

MonitorElement *	h_convLog10TrailTrackpt_

MonitorElement *	h_convPhi_

MonitorElement *	h_convProb_

MonitorElement *	h_convPt_

MonitorElement *	h_convRho_

MonitorElement *	h_convTrailTrackAlgo_

MonitorElement *	h_convTrailTrackpt_

MonitorElement *	h_convZ_

MonitorElement *	h_eleEtaAll_

MonitorElement *	h_eleEtaEff_

MonitorElement *	h_eleEtaFail_

MonitorElement *	h_eleEtaPass_

MonitorElement *	h_elePhiAll_

MonitorElement *	h_elePhiEff_

MonitorElement *	h_elePhiFail_

MonitorElement *	h_elePhiPass_

MonitorElement *	h_elePtAll_

MonitorElement *	h_elePtEff_

MonitorElement *	h_elePtFail_

MonitorElement *	h_elePtPass_

bool	isRunCentrally_

int	nEntry_

int	nEvt_

edm::EDGetTokenT< reco::VertexCollection >	offline_pvToken_

edm::ParameterSet	parameters_

int	verbosity_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

$Id: ElectronConversionRejectionValidator

Author: J.Bendavid

Definition at line 42 of file ElectronConversionRejectionValidator.h.

Constructor & Destructor Documentation

◆ ElectronConversionRejectionValidator()

ElectronConversionRejectionValidator::ElectronConversionRejectionValidator ( const edm::ParameterSet & pset )

explicit

Definition at line 41 of file ElectronConversionRejectionValidator.cc.

References ProducerED_cfi::InputTag, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                       {
   fName_ = pset.getUntrackedParameter<std::string>("Name");
   verbosity_ = pset.getUntrackedParameter<int>("Verbosity");
   parameters_ = pset;
 
   gsfElectronCollectionProducer_ = pset.getParameter<std::string>("gsfElectronProducer");
   gsfElectronCollection_ = pset.getParameter<std::string>("gsfElectronCollection");
 
   conversionCollectionProducer_ = pset.getParameter<std::string>("convProducer");
   conversionCollection_ = pset.getParameter<std::string>("conversionCollection");
   // conversionTrackProducer_ = pset.getParameter<std::string>("trackProducer");
   gsfElecToken_ =
       consumes<reco::GsfElectronCollection>(edm::InputTag(gsfElectronCollectionProducer_, gsfElectronCollection_));
   convToken_ =
       consumes<reco::ConversionCollection>(edm::InputTag(conversionCollectionProducer_, conversionCollection_));
 
   isRunCentrally_ = pset.getParameter<bool>("isRunCentrally");
 
   elePtMin_ = pset.getParameter<double>("elePtMin");
   eleExpectedHitsInnerMax_ = pset.getParameter<int>("eleExpectedHitsInnerMax");
   eleD0Max_ = pset.getParameter<double>("eleD0Max");
   offline_pvToken_ = consumes<reco::VertexCollection>(
       pset.getUntrackedParameter<edm::InputTag>("offlinePV", edm::InputTag("offlinePrimaryVertices")));
   beamspotToken_ =
       consumes<reco::BeamSpot>(pset.getUntrackedParameter<edm::InputTag>("beamspot", edm::InputTag("offlineBeamSpot")));
 
   nEvt_ = 0;
   nEntry_ = 0;
 }

◆ ~ElectronConversionRejectionValidator()

ElectronConversionRejectionValidator::~ElectronConversionRejectionValidator ( )

override

Definition at line 71 of file ElectronConversionRejectionValidator.cc.

71 {}

Member Function Documentation

◆ analyze()

void ElectronConversionRejectionValidator::analyze	(	const edm::Event &	e,
		const edm::EventSetup &
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 146 of file ElectronConversionRejectionValidator.cc.

References funct::abs(), reco::TrackBase::algo(), ChiSquaredProbability(), conv, MillePedeFileConverter_cfg::e, electronConversionRejectionValidator::gsfElectronCollection, ConversionTools::matchedConversion(), reco::HitPattern::MISSING_INNER_HITS, reco::BeamSpot::position(), reco::Vertex::position(), and reco::TrackBase::pt().

                                                                                           {
   using namespace edm;
 
   nEvt_++;
   LogInfo("ElectronConversionRejectionValidator")
       << "ElectronConversionRejectionValidator Analyzing event number: " << e.id() << " Global Counter " << nEvt_
       << "\n";
 
   auto convHandle = e.getHandle(convToken_);
   if (!convHandle.isValid()) {
     edm::LogError("ElectronConversionRejectionValidator") << "Error! Can't get the Conversion collection " << std::endl;
     return;
   }
 
   auto gsfElectronHandle = e.getHandle(gsfElecToken_);
   const reco::GsfElectronCollection& gsfElectronCollection = *(gsfElectronHandle.product());
   if (!gsfElectronHandle.isValid()) {
     edm::LogError("ElectronConversionRejectionValidator") << "Error! Can't get the Electron collection " << std::endl;
     return;
   }
 
   // offline  Primary vertex
   auto vertexHandle = e.getHandle(offline_pvToken_);
   if (!vertexHandle.isValid()) {
     edm::LogError("ElectronConversionRejectionValidator") << "Error! Can't get the product primary Vertex Collection "
                                                           << "\n";
     return;
   }
   const reco::Vertex& thevtx = vertexHandle->at(0);
 
   auto bsHandle = e.getHandle(beamspotToken_);
   if (!bsHandle.isValid()) {
     edm::LogError("ElectronConversionRejectionValidator") << "Error! Can't get the product beamspot Collection "
                                                           << "\n";
     return;
   }
   const reco::BeamSpot& thebs = *bsHandle.product();
 
   //loop over electrons
   for (reco::GsfElectronCollection::const_iterator iele = gsfElectronCollection.begin();
        iele != gsfElectronCollection.end();
        ++iele) {
     //apply basic pre-selection cuts to remove the conversions with obviously displaced tracks which will anyways be
     //removed from the analysis by the hit pattern or impact parameter requirements
     if (iele->pt() < elePtMin_)
       continue;
     if (iele->gsfTrack()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) >
         eleExpectedHitsInnerMax_)
       continue;
     if (std::abs(iele->gsfTrack()->dxy(thevtx.position())) > eleD0Max_)
       continue;
 
     //fill information for all electrons
     h_elePtAll_->Fill(iele->pt());
     h_eleEtaAll_->Fill(iele->eta());
     h_elePhiAll_->Fill(iele->phi());
 
     //find matching conversion if any
     reco::Conversion const* conv = ConversionTools::matchedConversion(*iele, *convHandle, thebs.position());
     //fill information on passing electrons only if there is no matching conversion (electron passed the conversion rejection cut!)
     if (conv == nullptr) {
       h_elePtPass_->Fill(iele->pt());
       h_eleEtaPass_->Fill(iele->eta());
       h_elePhiPass_->Fill(iele->phi());
     } else {
       //matching conversion, electron failed conversion rejection cut
       //fill information on electron and matching conversion
       //(Note that in case of multiple matching conversions passing the requirements, the conversion tools returns the one closest to the IP,
       //which is most likely to be the conversion of the primary photon in case there was one.)
 
       //fill electron info
       h_elePtFail_->Fill(iele->pt());
       h_eleEtaFail_->Fill(iele->eta());
       h_elePhiFail_->Fill(iele->phi());
 
       //fill conversion info
       math::XYZVectorF convmom = conv->refittedPairMomentum();
       h_convPt_->Fill(convmom.rho());
       h_convEta_->Fill(convmom.eta());
       h_convPhi_->Fill(convmom.phi());
       h_convRho_->Fill(conv->conversionVertex().position().rho());
       h_convZ_->Fill(conv->conversionVertex().position().z());
       h_convProb_->Fill(ChiSquaredProbability(conv->conversionVertex().chi2(), conv->conversionVertex().ndof()));
 
       //fill information about conversion tracks
       if (conv->tracks().size() < 2)
         continue;
 
       RefToBase<reco::Track> tk1 = conv->tracks().front();
       RefToBase<reco::Track> tk2 = conv->tracks().back();
 
       RefToBase<reco::Track> tklead;
       RefToBase<reco::Track> tktrail;
       if (tk1->pt() >= tk2->pt()) {
         tklead = tk1;
         tktrail = tk2;
       } else {
         tklead = tk2;
         tktrail = tk1;
       }
       h_convLeadTrackpt_->Fill(tklead->pt());
       h_convTrailTrackpt_->Fill(tktrail->pt());
       h_convLog10TrailTrackpt_->Fill(log10(tktrail->pt()));
       h_convLeadTrackAlgo_->Fill(tklead->algo());
       h_convTrailTrackAlgo_->Fill(tktrail->algo());
     }
   }
 }

◆ bookHistograms()

void ElectronConversionRejectionValidator::bookHistograms	(	DQMStore::IBooker &	bei,
		edm::Run const &	,
		edm::EventSetup const &
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 73 of file ElectronConversionRejectionValidator.cc.

References reco::TrackBase::algoSize, dqm::implementation::IBooker::book1D(), muonRecoAnalyzer_cfi::etaBin, ALCARECOTkAlBeamHalo_cff::etaMax, ALCARECOTkAlBeamHalo_cff::etaMin, BeamMonitor_cff::phiBin, AlignmentTrackSelector_cfi::phiMax, AlignmentTrackSelector_cfi::phiMin, Pi, muonRecoAnalyzer_cfi::ptBin, AlignmentTrackSelector_cfi::ptMax, ptMin, electronConversionRejectionValidator::rhoBin, HLT_2024v14_cff::rhoMax, electronConversionRejectionValidator::rhoMin, dqm::implementation::NavigatorBase::setCurrentFolder(), electronConversionRejectionValidator::trackptBin, electronConversionRejectionValidator::trackptMax, electronConversionRejectionValidator::trackptMin, photonAnalyzer_cfi::zBin, photonAnalyzer_cfi::zMax, and photonAnalyzer_cfi::zMin.

                                                                                 {
   double ptMin = parameters_.getParameter<double>("ptMin");
   double ptMax = parameters_.getParameter<double>("ptMax");
   int ptBin = parameters_.getParameter<int>("ptBin");
 
   double trackptMin = parameters_.getParameter<double>("trackptMin");
   double trackptMax = parameters_.getParameter<double>("trackptMax");
   int trackptBin = parameters_.getParameter<int>("trackptBin");
 
   double etaMin = parameters_.getParameter<double>("etaMin");
   double etaMax = parameters_.getParameter<double>("etaMax");
   int etaBin = parameters_.getParameter<int>("etaBin");
 
   double phiMin = -TMath::Pi();
   double phiMax = TMath::Pi();
   int phiBin = parameters_.getParameter<int>("phiBin");
 
   double rhoMin = parameters_.getParameter<double>("rhoMin");
   double rhoMax = parameters_.getParameter<double>("rhoMax");
   int rhoBin = parameters_.getParameter<int>("rhoBin");
 
   double zMin = parameters_.getParameter<double>("zMin");
   double zMax = parameters_.getParameter<double>("zMax");
   int zBin = parameters_.getParameter<int>("zBin");
 
   // SC from reco photons
 
   //TString simfolder = TString(
   //std::string simpath = dqmpath_ + "SimulationInfo";
   ibooker.setCurrentFolder(dqmpath_);
   //
   // simulation information about conversions
   // Histograms for efficiencies
   h_elePtAll_ = ibooker.book1D("elePtAll", "# of Electrons", ptBin, ptMin, ptMax);
   h_eleEtaAll_ = ibooker.book1D("eleEtaAll", "# of Electrons", etaBin, etaMin, etaMax);
   h_elePhiAll_ = ibooker.book1D("elePhiAll", "# of Electrons", phiBin, phiMin, phiMax);
 
   h_elePtPass_ = ibooker.book1D("elePtPass", "# of Electrons", ptBin, ptMin, ptMax);
   h_eleEtaPass_ = ibooker.book1D("eleEtaPass", "# of Electrons", etaBin, etaMin, etaMax);
   h_elePhiPass_ = ibooker.book1D("elePhiPass", "# of Electrons", phiBin, phiMin, phiMax);
 
   h_elePtFail_ = ibooker.book1D("elePtFail", "# of Electrons", ptBin, ptMin, ptMax);
   h_eleEtaFail_ = ibooker.book1D("eleEtaFail", "# of Electrons", etaBin, etaMin, etaMax);
   h_elePhiFail_ = ibooker.book1D("elePhiFail", "# of Electrons", phiBin, phiMin, phiMax);
 
   h_convPt_ = ibooker.book1D("convPt", "# of Electrons", ptBin, ptMin, ptMax);
   h_convEta_ = ibooker.book1D("convEta", "# of Electrons", etaBin, etaMin, etaMax);
   h_convPhi_ = ibooker.book1D("convPhi", "# of Electrons", phiBin, phiMin, phiMax);
   h_convRho_ = ibooker.book1D("convRho", "# of Electrons", rhoBin, rhoMin, rhoMax);
   h_convZ_ = ibooker.book1D("convZ", "# of Electrons", zBin, zMin, zMax);
   h_convProb_ = ibooker.book1D("convProb", "# of Electrons", 100, 0.0, 1.0);
 
   h_convLeadTrackpt_ = ibooker.book1D("convLeadTrackpt", "# of Electrons", trackptBin, trackptMin, trackptMax);
 
   h_convTrailTrackpt_ = ibooker.book1D("convTrailTrackpt", "# of Electrons", trackptBin, trackptMin, trackptMax);
 
   h_convLog10TrailTrackpt_ = ibooker.book1D("convLog10TrailTrackpt", "# of Electrons", ptBin, -2.0, 3.0);
 
   h_convLeadTrackAlgo_ = ibooker.book1D("convLeadTrackAlgo",
                                         "# of Electrons",
                                         reco::TrackBase::algoSize,
                                         -0.5,
                                         static_cast<double>(reco::TrackBase::algoSize) - 0.5);
   h_convTrailTrackAlgo_ = ibooker.book1D("convLeadTrackAlgo",
                                          "# of Electrons",
                                          reco::TrackBase::algoSize,
                                          -0.5,
                                          static_cast<double>(reco::TrackBase::algoSize) - 0.5);
 }