#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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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 >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	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 48 of file ElectronConversionRejectionValidator.cc.

                                                                                                       {
   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;
 }

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

◆ ~ElectronConversionRejectionValidator()

ElectronConversionRejectionValidator::~ElectronConversionRejectionValidator ( )

override

Definition at line 78 of file ElectronConversionRejectionValidator.cc.

78 {}

Member Function Documentation

◆ analyze()

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

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 147 of file ElectronConversionRejectionValidator.cc.

                                                                                                {
   using namespace edm;
  
   nEvt_++;
   LogInfo("ElectronConversionRejectionValidator")
       << "ElectronConversionRejectionValidator Analyzing event number: " << e.id() << " Global Counter " << nEvt_
       << "\n";
  
   Handle<reco::ConversionCollection> convHandle;
   e.getByToken(convToken_, convHandle);
   if (!convHandle.isValid()) {
     edm::LogError("ElectronConversionRejectionValidator") << "Error! Can't get the Conversion collection " << std::endl;
     return;
   }
  
   Handle<reco::GsfElectronCollection> gsfElectronHandle;
   e.getByToken(gsfElecToken_, gsfElectronHandle);
   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
   edm::Handle<reco::VertexCollection> vertexHandle;
   e.getByToken(offline_pvToken_, vertexHandle);
   if (!vertexHandle.isValid()) {
     edm::LogError("ElectronConversionRejectionValidator") << "Error! Can't get the product primary Vertex Collection "
                                                           << "\n";
     return;
   }
   const reco::Vertex& thevtx = vertexHandle->at(0);
  
   edm::Handle<reco::BeamSpot> bsHandle;
   e.getByToken(beamspotToken_, bsHandle);
   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());
     }
   }
 }

References funct::abs(), reco::TrackBase::algo(), ChiSquaredProbability(), conv, MillePedeFileConverter_cfg::e, electronConversionRejectionValidator::gsfElectronCollection, edm::HandleBase::isValid(), ConversionTools::matchedConversion(), reco::HitPattern::MISSING_INNER_HITS, reco::BeamSpot::position(), reco::Vertex::position(), edm::Handle< T >::product(), and reco::TrackBase::pt().

◆ bookHistograms()

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 80 of file ElectronConversionRejectionValidator.cc.

                                                                                 {
   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, reco::TrackBase::algoSize - 0.5);
   h_convTrailTrackAlgo_ = ibooker.book1D(
       "convLeadTrackAlgo", "# of Electrons", reco::TrackBase::algoSize, -0.5, reco::TrackBase::algoSize - 0.5);
 }