#include <L1TEGammaOffline.h>

Inheritance diagram for L1TEGammaOffline:

Public Member Functions
	L1TEGammaOffline (const edm::ParameterSet &ps)

	~L1TEGammaOffline () override

Public Member Functions inherited from DQMEDAnalyzer
void	beginRun (edm::Run const &, edm::EventSetup const &) final

void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer ()

void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &eSetup) override

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &eSetup) override

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

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

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &eSetup) override

void	endRun (edm::Run const &run, edm::EventSetup const &eSetup) override

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Private Member Functions
void	bookElectronHistos (DQMStore::IBooker &)

void	bookPhotonHistos (DQMStore::IBooker &)

double	calcDeltaPhi (double phi1, double phi2)

double	Distance (const reco::Candidate &c1, const reco::Candidate &c2)

double	DistancePhi (const reco::Candidate &c1, const reco::Candidate &c2)

void	fillElectrons (edm::Event const &e, const unsigned int nVertex)

void	fillPhotons (edm::Event const &e, const unsigned int nVertex)

bool	findTagAndProbePair (edm::Handle< reco::GsfElectronCollection > const &electrons)

bool	passesLooseEleId (reco::GsfElectron const &electron) const

bool	passesMediumEleId (reco::GsfElectron const &electron) const

Private Attributes
std::vector< double >	deepInspectionElectronThresholds_

std::string	efficiencyFolder_

std::vector< double >	electronEfficiencyBins_

std::vector< double >	electronEfficiencyThresholds_

std::map< double, MonitorElement * >	h_efficiencyElectronET_EB_EE_pass_

std::map< double, MonitorElement * >	h_efficiencyElectronET_EB_EE_total_

std::map< double, MonitorElement * >	h_efficiencyElectronET_EB_pass_

std::map< double, MonitorElement * >	h_efficiencyElectronET_EB_total_

std::map< double, MonitorElement * >	h_efficiencyElectronET_EE_pass_

std::map< double, MonitorElement * >	h_efficiencyElectronET_EE_total_

std::map< double, MonitorElement * >	h_efficiencyElectronEta_pass_

std::map< double, MonitorElement * >	h_efficiencyElectronEta_total_

std::map< double, MonitorElement * >	h_efficiencyElectronNVertex_pass_

std::map< double, MonitorElement * >	h_efficiencyElectronNVertex_total_

std::map< double, MonitorElement * >	h_efficiencyElectronPhi_pass_

std::map< double, MonitorElement * >	h_efficiencyElectronPhi_total_

std::map< double, MonitorElement * >	h_efficiencyElectronPhi_vs_Eta_pass_

std::map< double, MonitorElement * >	h_efficiencyElectronPhi_vs_Eta_total_

std::map< double, MonitorElement * >	h_efficiencyPhotonET_EB_EE_pass_

std::map< double, MonitorElement * >	h_efficiencyPhotonET_EB_EE_total_

std::map< double, MonitorElement * >	h_efficiencyPhotonET_EB_pass_

std::map< double, MonitorElement * >	h_efficiencyPhotonET_EB_total_

std::map< double, MonitorElement * >	h_efficiencyPhotonET_EE_pass_

std::map< double, MonitorElement * >	h_efficiencyPhotonET_EE_total_

MonitorElement *	h_L1EGammaEtavsElectronEta_

MonitorElement *	h_L1EGammaEtavsPhotonEta_

MonitorElement *	h_L1EGammaETvsElectronET_EB_

MonitorElement *	h_L1EGammaETvsElectronET_EB_EE_

MonitorElement *	h_L1EGammaETvsElectronET_EE_

MonitorElement *	h_L1EGammaETvsPhotonET_EB_

MonitorElement *	h_L1EGammaETvsPhotonET_EB_EE_

MonitorElement *	h_L1EGammaETvsPhotonET_EE_

MonitorElement *	h_L1EGammaPhivsElectronPhi_EB_

MonitorElement *	h_L1EGammaPhivsElectronPhi_EB_EE_

MonitorElement *	h_L1EGammaPhivsElectronPhi_EE_

MonitorElement *	h_L1EGammaPhivsPhotonPhi_EB_

MonitorElement *	h_L1EGammaPhivsPhotonPhi_EB_EE_

MonitorElement *	h_L1EGammaPhivsPhotonPhi_EE_

MonitorElement *	h_nVertex_

MonitorElement *	h_resolutionElectronET_EB_

MonitorElement *	h_resolutionElectronET_EB_EE_

MonitorElement *	h_resolutionElectronET_EE_

MonitorElement *	h_resolutionElectronEta_

MonitorElement *	h_resolutionElectronPhi_EB_

MonitorElement *	h_resolutionElectronPhi_EB_EE_

MonitorElement *	h_resolutionElectronPhi_EE_

MonitorElement *	h_resolutionPhotonET_EB_

MonitorElement *	h_resolutionPhotonET_EB_EE_

MonitorElement *	h_resolutionPhotonET_EE_

MonitorElement *	h_resolutionPhotonEta_

MonitorElement *	h_resolutionPhotonPhi_EB_

MonitorElement *	h_resolutionPhotonPhi_EB_EE_

MonitorElement *	h_resolutionPhotonPhi_EE_

MonitorElement *	h_tagAndProbeMass_

std::string	histFolder_

std::vector< double >	photonEfficiencyBins_

std::vector< double >	photonEfficiencyThresholds_

reco::GsfElectron	probeElectron_

double	probeToL1Offset_

math::XYZPoint	PVPoint_

edm::EDGetTokenT< l1t::EGammaBxCollection >	stage2CaloLayer2EGammaToken_

double	tagAndProbleInvariantMass_

reco::GsfElectron	tagElectron_

edm::EDGetTokenT< reco::BeamSpot >	theBSCollection_

edm::EDGetTokenT< reco::GsfElectronCollection >	theGsfElectronCollection_

edm::EDGetTokenT< std::vector< reco::Photon > >	thePhotonCollection_

edm::EDGetTokenT< reco::VertexCollection >	thePVCollection_

edm::EDGetTokenT< trigger::TriggerEvent >	triggerEvent_

edm::InputTag	triggerFilter_

std::string	triggerPath_

edm::EDGetTokenT< edm::TriggerResults >	triggerResults_

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
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

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

Definition at line 37 of file L1TEGammaOffline.h.

Constructor & Destructor Documentation

L1TEGammaOffline::L1TEGammaOffline ( const edm::ParameterSet & ps )

Definition at line 23 of file L1TEGammaOffline.cc.

                                                             :
         theGsfElectronCollection_(
             consumes < reco::GsfElectronCollection > (ps.getParameter < edm::InputTag > ("electronCollection"))),
         thePhotonCollection_(
             consumes < std::vector<reco::Photon> > (ps.getParameter < edm::InputTag > ("photonCollection"))),
         thePVCollection_(consumes < reco::VertexCollection > (ps.getParameter < edm::InputTag > ("PVCollection"))),
         theBSCollection_(consumes < reco::BeamSpot > (ps.getParameter < edm::InputTag > ("beamSpotCollection"))),
         triggerEvent_(consumes < trigger::TriggerEvent > (ps.getParameter < edm::InputTag > ("TriggerEvent"))),
         triggerResults_(consumes < edm::TriggerResults > (ps.getParameter < edm::InputTag > ("TriggerResults"))),
         triggerFilter_(ps.getParameter < edm::InputTag > ("TriggerFilter")),
         triggerPath_(ps.getParameter < std::string > ("TriggerPath")),
         histFolder_(ps.getParameter < std::string > ("histFolder")),
         efficiencyFolder_(histFolder_ + "/efficiency_raw"),
         stage2CaloLayer2EGammaToken_(
             consumes < l1t::EGammaBxCollection > (ps.getParameter < edm::InputTag > ("stage2CaloLayer2EGammaSource"))),
         electronEfficiencyThresholds_(ps.getParameter < std::vector<double> > ("electronEfficiencyThresholds")),
         electronEfficiencyBins_(ps.getParameter < std::vector<double> > ("electronEfficiencyBins")),
         probeToL1Offset_(ps.getParameter <double> ("probeToL1Offset")),
         deepInspectionElectronThresholds_(ps.getParameter < std::vector<double> > ("deepInspectionElectronThresholds")),
         photonEfficiencyThresholds_(ps.getParameter < std::vector<double> > ("photonEfficiencyThresholds")),
         photonEfficiencyBins_(ps.getParameter < std::vector<double> > ("photonEfficiencyBins")),
         tagElectron_(),
         probeElectron_(),
         tagAndProbleInvariantMass_(-1.)
 {
   edm::LogInfo("L1TEGammaOffline") << "Constructor " << "L1TEGammaOffline::L1TEGammaOffline " << std::endl;
 }

L1TEGammaOffline::~L1TEGammaOffline ( )

override

Definition at line 54 of file L1TEGammaOffline.cc.

 {
   edm::LogInfo("L1TEGammaOffline") << "Destructor L1TEGammaOffline::~L1TEGammaOffline " << std::endl;
 }

Member Function Documentation

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

overrideprotectedvirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 89 of file L1TEGammaOffline.cc.

References fillElectrons(), fillPhotons(), dqmoffline::l1t::fillWithinLimits(), edm::Event::getByToken(), h_nVertex_, edm::HandleBase::isValid(), and thePVCollection_.

 {
   edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::analyze" << std::endl;
 
   edm::Handle < reco::VertexCollection > vertexHandle;
   e.getByToken(thePVCollection_, vertexHandle);
   if (!vertexHandle.isValid()) {
     edm::LogWarning("L1TEGammaOffline") << "invalid collection: vertex " << std::endl;
     return;
   }
 
   unsigned int nVertex = vertexHandle->size();
   dqmoffline::l1t::fillWithinLimits(h_nVertex_, nVertex);
 
   // L1T
   fillElectrons(e, nVertex);
   fillPhotons(e, nVertex);
 }

void L1TEGammaOffline::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	eSetup
	)

overrideprotectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 81 of file L1TEGammaOffline.cc.

 {
   edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::beginLuminosityBlock" << std::endl;
 }

void L1TEGammaOffline::bookElectronHistos ( DQMStore::IBooker & ibooker )

private

Definition at line 509 of file L1TEGammaOffline.cc.

Referenced by bookHistograms().

 {
   ibooker.cd();
   ibooker.setCurrentFolder(histFolder_);
   h_nVertex_ = ibooker.book1D("nVertex", "Number of event vertices in collection", 40, -0.5, 39.5);
   h_tagAndProbeMass_ = ibooker.book1D("tagAndProbeMass", "Invariant mass of tag & probe pair", 100, 40, 140);
   // electron reco vs L1
   h_L1EGammaETvsElectronET_EB_ = ibooker.book2D("L1EGammaETvsElectronET_EB",
       "L1 EGamma E_{T} vs GSF Electron E_{T} (EB); GSF Electron E_{T} (GeV); L1 EGamma E_{T} (GeV)", 300, 0, 300, 300,
       0, 300);
   h_L1EGammaETvsElectronET_EE_ = ibooker.book2D("L1EGammaETvsElectronET_EE",
       "L1 EGamma E_{T} vs GSF Electron E_{T} (EE); GSF Electron E_{T} (GeV); L1 EGamma E_{T} (GeV)", 300, 0, 300, 300,
       0, 300);
   h_L1EGammaETvsElectronET_EB_EE_ = ibooker.book2D("L1EGammaETvsElectronET_EB_EE",
       "L1 EGamma E_{T} vs GSF Electron E_{T} (EB+EE); GSF Electron E_{T} (GeV); L1 EGamma E_{T} (GeV)", 300, 0, 300,
       300, 0, 300);
 
   h_L1EGammaPhivsElectronPhi_EB_ = ibooker.book2D("L1EGammaPhivsElectronPhi_EB",
       "#phi_{electron}^{L1} vs #phi_{electron}^{offline} (EB); #phi_{electron}^{offline}; #phi_{electron}^{L1}", 100,
       -4, 4, 100, -4, 4);
   h_L1EGammaPhivsElectronPhi_EE_ = ibooker.book2D("L1EGammaPhivsElectronPhi_EE",
       "#phi_{electron}^{L1} vs #phi_{electron}^{offline} (EE); #phi_{electron}^{offline}; #phi_{electron}^{L1}", 100,
       -4, 4, 100, -4, 4);
   h_L1EGammaPhivsElectronPhi_EB_EE_ = ibooker.book2D("L1EGammaPhivsElectronPhi_EB_EE",
       "#phi_{electron}^{L1} vs #phi_{electron}^{offline} (EB+EE); #phi_{electron}^{offline}; #phi_{electron}^{L1}", 100,
       -4, 4, 100, -4, 4);
 
   h_L1EGammaEtavsElectronEta_ = ibooker.book2D("L1EGammaEtavsElectronEta",
       "L1 EGamma #eta vs GSF Electron #eta; GSF Electron #eta; L1 EGamma #eta", 100, -3, 3, 100, -3, 3);
 
   // electron resolutions
   h_resolutionElectronET_EB_ = ibooker.book1D("resolutionElectronET_EB",
       "electron ET resolution (EB); (L1 EGamma E_{T} - GSF Electron E_{T})/GSF Electron E_{T}; events", 50, -1, 1.5);
   h_resolutionElectronET_EE_ = ibooker.book1D("resolutionElectronET_EE",
       "electron ET resolution (EE); (L1 EGamma E_{T} - GSF Electron E_{T})/GSF Electron E_{T}; events", 50, -1, 1.5);
   h_resolutionElectronET_EB_EE_ = ibooker.book1D("resolutionElectronET_EB_EE",
       "electron ET resolution (EB+EE); (L1 EGamma E_{T} - GSF Electron E_{T})/GSF Electron E_{T}; events", 50, -1, 1.5);
 
   h_resolutionElectronPhi_EB_ =
       ibooker.book1D("resolutionElectronPhi_EB",
           "#phi_{electron} resolution (EB); (#phi_{electron}^{L1} - #phi_{electron}^{offline})/#phi_{electron}^{offline}; events",
           120, -0.3, 0.3);
   h_resolutionElectronPhi_EE_ =
       ibooker.book1D("resolutionElectronPhi_EE",
           "electron #phi resolution (EE); (#phi_{electron}^{L1} - #phi_{electron}^{offline})/#phi_{electron}^{offline}; events",
           120, -0.3, 0.3);
   h_resolutionElectronPhi_EB_EE_ =
       ibooker.book1D("resolutionElectronPhi_EB_EE",
           "electron #phi resolution (EB+EE); (#phi_{electron}^{L1} - #phi_{electron}^{offline})/#phi_{electron}^{offline}; events",
           120, -0.3, 0.3);
 
   h_resolutionElectronEta_ = ibooker.book1D("resolutionElectronEta",
       "electron #eta resolution  (EB); (L1 EGamma #eta - GSF Electron #eta)/GSF Electron #eta; events", 120, -0.3, 0.3);
 
   // electron turn-ons
   ibooker.setCurrentFolder(efficiencyFolder_);
   std::vector<float> electronBins(electronEfficiencyBins_.begin(), electronEfficiencyBins_.end());
   int nBins = electronBins.size() - 1;
   float* electronBinArray = &(electronBins[0]);
 
   for (auto threshold : electronEfficiencyThresholds_) {
     std::string str_threshold = std::to_string(int(threshold));
     h_efficiencyElectronET_EB_pass_[threshold] = ibooker.book1D(
         "efficiencyElectronET_EB_threshold_" + str_threshold + "_Num",
         "electron efficiency (EB) (numerator); GSF Electron E_{T} (GeV); events", nBins, electronBinArray);
     h_efficiencyElectronET_EE_pass_[threshold] = ibooker.book1D(
         "efficiencyElectronET_EE_threshold_" + str_threshold + "_Num",
         "electron efficiency (EE) (numerator); GSF Electron E_{T} (GeV); events", nBins, electronBinArray);
     h_efficiencyElectronET_EB_EE_pass_[threshold] = ibooker.book1D(
         "efficiencyElectronET_EB_EE_threshold_" + str_threshold + "_Num",
         "electron efficiency (EB+EE) (numerator); GSF Electron E_{T} (GeV); events", nBins, electronBinArray);
     h_efficiencyElectronPhi_vs_Eta_pass_[threshold] = ibooker.book2D(
       "efficiencyElectronPhi_vs_Eta_threshold_" + str_threshold + "_Num",
       "electron efficiency (numerator); GSF Electron #eta; GSF Electron #phi",
       50, -2.5, 2.5, 32, -3.2, 3.2);
 
     h_efficiencyElectronET_EB_total_[threshold] = ibooker.book1D(
         "efficiencyElectronET_EB_threshold_" + str_threshold + "_Den",
         "electron efficiency (EB) (denominator); GSF Electron E_{T} (GeV); events", nBins, electronBinArray);
     h_efficiencyElectronET_EE_total_[threshold] = ibooker.book1D(
         "efficiencyElectronET_EE_threshold_" + str_threshold + "_Den",
         "electron efficiency (EE) (denominator); GSF Electron E_{T} (GeV); events", nBins, electronBinArray);
     h_efficiencyElectronET_EB_EE_total_[threshold] = ibooker.book1D(
         "efficiencyElectronET_EB_EE_threshold_" + str_threshold + "_Den",
         "electron efficiency (EB+EE) (denominator); GSF Electron E_{T} (GeV); events", nBins, electronBinArray);
     h_efficiencyElectronPhi_vs_Eta_total_[threshold] = ibooker.book2D(
         "efficiencyElectronPhi_vs_Eta_threshold_" + str_threshold + "_Den",
         "electron efficiency (denominator); GSF Electron #eta; GSF Electron #phi",
         50, -2.5, 2.5, 32, -3.2, 3.2);
   }
 
   for (auto threshold: deepInspectionElectronThresholds_) {
     std::string str_threshold = std::to_string(int(threshold));
     h_efficiencyElectronEta_pass_[threshold] = ibooker.book1D(
       "efficiencyElectronEta_threshold_" + str_threshold + "_Num",
       "electron efficiency (numerator); GSF Electron #eta; events", 50, -2.5, 2.5);
     h_efficiencyElectronPhi_pass_[threshold] = ibooker.book1D(
       "efficiencyElectronPhi_threshold_" + str_threshold + "_Num",
       "electron efficiency (numerator); GSF Electron #phi; events", 32, -3.2, 3.2);
     h_efficiencyElectronNVertex_pass_[threshold] = ibooker.book1D(
       "efficiencyElectronNVertex_threshold_" + str_threshold + "_Num",
       "electron efficiency (numerator); Nvtx; events", 30, 0, 60);
 
     h_efficiencyElectronEta_total_[threshold] = ibooker.book1D(
       "efficiencyElectronEta_threshold_" + str_threshold + "_Den",
       "electron efficiency (denominator); GSF Electron #eta; events", 50, -2.5, 2.5);
     h_efficiencyElectronPhi_total_[threshold] = ibooker.book1D(
       "efficiencyElectronPhi_threshold_" + str_threshold + "_Den",
       "electron efficiency (denominator); GSF Electron #phi; events", 32, -3.2, 3.2);
     h_efficiencyElectronNVertex_total_[threshold] = ibooker.book1D(
       "efficiencyElectronNVertex_threshold_" + str_threshold + "_Den",
       "electron efficiency (denominator); Nvtx; events", 30, 0, 60);
   }
 
 
   ibooker.cd();
 }

void L1TEGammaOffline::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	,
		edm::EventSetup const &
	)

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 70 of file L1TEGammaOffline.cc.

References bookElectronHistos(), and bookPhotonHistos().

 {
   edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::bookHistograms" << std::endl;
 
   //book at beginRun
   bookElectronHistos(ibooker);
   bookPhotonHistos(ibooker);
 }

void L1TEGammaOffline::bookPhotonHistos ( DQMStore::IBooker & ibooker )

private

Definition at line 627 of file L1TEGammaOffline.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::cd(), DEFINE_FWK_MODULE, efficiencyFolder_, h_efficiencyPhotonET_EB_EE_pass_, h_efficiencyPhotonET_EB_EE_total_, h_efficiencyPhotonET_EB_pass_, h_efficiencyPhotonET_EB_total_, h_efficiencyPhotonET_EE_pass_, h_efficiencyPhotonET_EE_total_, h_L1EGammaEtavsPhotonEta_, h_L1EGammaETvsPhotonET_EB_, h_L1EGammaETvsPhotonET_EB_EE_, h_L1EGammaETvsPhotonET_EE_, h_L1EGammaPhivsPhotonPhi_EB_, h_L1EGammaPhivsPhotonPhi_EB_EE_, h_L1EGammaPhivsPhotonPhi_EE_, h_resolutionPhotonET_EB_, h_resolutionPhotonET_EB_EE_, h_resolutionPhotonET_EE_, h_resolutionPhotonEta_, h_resolutionPhotonPhi_EB_, h_resolutionPhotonPhi_EB_EE_, h_resolutionPhotonPhi_EE_, histFolder_, photonEfficiencyBins_, photonEfficiencyThresholds_, DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, and electronIdCutBased_cfi::threshold.

Referenced by bookHistograms().

 {
   ibooker.cd();
   ibooker.setCurrentFolder(histFolder_);
   h_L1EGammaETvsPhotonET_EB_ = ibooker.book2D("L1EGammaETvsPhotonET_EB",
       "L1 EGamma E_{T} vs  Photon E_{T} (EB);  Photon E_{T} (GeV); L1 EGamma E_{T} (GeV)", 300, 0, 300, 300, 0, 300);
   h_L1EGammaETvsPhotonET_EE_ = ibooker.book2D("L1EGammaETvsPhotonET_EE",
       "L1 EGamma E_{T} vs  Photon E_{T} (EE);  Photon E_{T} (GeV); L1 EGamma E_{T} (GeV)", 300, 0, 300, 300, 0, 300);
   h_L1EGammaETvsPhotonET_EB_EE_ = ibooker.book2D("L1EGammaETvsPhotonET_EB_EE",
       "L1 EGamma E_{T} vs  Photon E_{T} (EB+EE);  Photon E_{T} (GeV); L1 EGamma E_{T} (GeV)", 300, 0, 300, 300, 0, 300);
 
   h_L1EGammaPhivsPhotonPhi_EB_ = ibooker.book2D("L1EGammaPhivsPhotonPhi_EB",
       "#phi_{photon}^{L1} vs #phi_{photon}^{offline} (EB); #phi_{photon}^{offline}; #phi_{photon}^{L1}", 100, -4, 4,
       100, -4, 4);
   h_L1EGammaPhivsPhotonPhi_EE_ = ibooker.book2D("L1EGammaPhivsPhotonPhi_EE",
       "#phi_{photon}^{L1} vs #phi_{photon}^{offline} (EE); #phi_{photon}^{offline}; #phi_{photon}^{L1}", 100, -4, 4,
       100, -4, 4);
   h_L1EGammaPhivsPhotonPhi_EB_EE_ = ibooker.book2D("L1EGammaPhivsPhotonPhi_EB_EE",
       "#phi_{photon}^{L1} vs #phi_{photon}^{offline} (EB+EE); #phi_{photon}^{offline}; #phi_{photon}^{L1}", 100, -4, 4,
       100, -4, 4);
 
   h_L1EGammaEtavsPhotonEta_ = ibooker.book2D("L1EGammaEtavsPhotonEta",
       "L1 EGamma #eta vs  Photon #eta;  Photon #eta; L1 EGamma #eta", 100, -3, 3, 100, -3, 3);
 
   // photon resolutions
   h_resolutionPhotonET_EB_ = ibooker.book1D("resolutionPhotonET_EB",
       "photon ET resolution (EB); (L1 EGamma E_{T} -  Photon E_{T})/ Photon E_{T}; events", 50, -1, 1.5);
   h_resolutionPhotonET_EE_ = ibooker.book1D("resolutionPhotonET_EE",
       "photon ET resolution (EE); (L1 EGamma E_{T} -  Photon E_{T})/ Photon E_{T}; events", 50, -1, 1.5);
   h_resolutionPhotonET_EB_EE_ = ibooker.book1D("resolutionPhotonET_EB_EE",
       "photon ET resolution (EB+EE); (L1 EGamma E_{T} -  Photon E_{T})/ Photon E_{T}; events", 50, -1, 1.5);
 
   h_resolutionPhotonPhi_EB_ = ibooker.book1D("resolutionPhotonPhi_EB",
       "#phi_{photon} resolution (EB); (#phi_{photon}^{L1} - #phi_{photon}^{offline})/#phi_{photon}^{offline}; events",
       120, -0.3, 0.3);
   h_resolutionPhotonPhi_EE_ = ibooker.book1D("resolutionPhotonPhi_EE",
       "photon #phi resolution (EE); (#phi_{photon}^{L1} - #phi_{photon}^{offline})/#phi_{photon}^{offline}; events",
       120, -0.3, 0.3);
   h_resolutionPhotonPhi_EB_EE_ = ibooker.book1D("resolutionPhotonPhi_EB_EE",
       "photon #phi resolution (EB+EE); (#phi_{photon}^{L1} - #phi_{photon}^{offline})/#phi_{photon}^{offline}; events",
       120, -0.3, 0.3);
 
   h_resolutionPhotonEta_ = ibooker.book1D("resolutionPhotonEta",
       "photon #eta resolution  (EB); (L1 EGamma #eta -  Photon #eta)/ Photon #eta; events", 120, -0.3, 0.3);
 
   // photon turn-ons
   ibooker.setCurrentFolder(efficiencyFolder_);
   std::vector<float> photonBins(photonEfficiencyBins_.begin(), photonEfficiencyBins_.end());
   int nBins = photonBins.size() - 1;
   float* photonBinArray = &(photonBins[0]);
 
   for (auto threshold : photonEfficiencyThresholds_) {
     std::string str_threshold = std::to_string(int(threshold));
     h_efficiencyPhotonET_EB_pass_[threshold] = ibooker.book1D(
         "efficiencyPhotonET_EB_threshold_" + str_threshold + "_Num",
         "photon efficiency (EB) (numerator);  Photon E_{T} (GeV); events", nBins, photonBinArray);
     h_efficiencyPhotonET_EE_pass_[threshold] = ibooker.book1D(
         "efficiencyPhotonET_EE_threshold_" + str_threshold + "_Num",
         "photon efficiency (EE) (numerator);  Photon E_{T} (GeV); events", nBins, photonBinArray);
     h_efficiencyPhotonET_EB_EE_pass_[threshold] = ibooker.book1D(
         "efficiencyPhotonET_EB_EE_threshold_" + str_threshold + "_Num",
         "photon efficiency (EB+EE) (numerator);  Photon E_{T} (GeV); events", nBins, photonBinArray);
 
     h_efficiencyPhotonET_EB_total_[threshold] = ibooker.book1D(
         "efficiencyPhotonET_EB_threshold_" + str_threshold + "_Den",
         "photon efficiency (EB) (denominator);  Photon E_{T} (GeV); events", nBins, photonBinArray);
     h_efficiencyPhotonET_EE_total_[threshold] = ibooker.book1D(
         "efficiencyPhotonET_EE_threshold_" + str_threshold + "_Den",
         "photon efficiency (EE) (denominator);  Photon E_{T} (GeV); events", nBins, photonBinArray);
     h_efficiencyPhotonET_EB_EE_total_[threshold] = ibooker.book1D(
         "efficiencyPhotonET_EB_EE_threshold_" + str_threshold + "_Den",
         "photon efficiency (EB+EE) (denominator);  Photon E_{T} (GeV); events", nBins, photonBinArray);
   }
 
   ibooker.cd();
 }

double L1TEGammaOffline::calcDeltaPhi	(	double	phi1,
		double	phi2
	)

private

double L1TEGammaOffline::Distance	(	const reco::Candidate &	c1,
		const reco::Candidate &	c2
	)

private

double L1TEGammaOffline::DistancePhi	(	const reco::Candidate &	c1,
		const reco::Candidate &	c2
	)

private

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 62 of file L1TEGammaOffline.cc.

 {
   edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::beginRun" << std::endl;
 }

void L1TEGammaOffline::endLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	eSetup
	)

overrideprotectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 493 of file L1TEGammaOffline.cc.

 {
   edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::endLuminosityBlock" << std::endl;
 }

void L1TEGammaOffline::endRun	(	edm::Run const &	run,
		edm::EventSetup const &	eSetup
	)

overrideprotectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 501 of file L1TEGammaOffline.cc.

 {
   edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::endRun" << std::endl;
 }

void L1TEGammaOffline::fillElectrons	(	edm::Event const &	e,
		const unsigned int	nVertex
	)

private

Definition at line 108 of file L1TEGammaOffline.cc.

Referenced by analyze().

 {
   edm::Handle<l1t::EGammaBxCollection> l1EGamma;
   e.getByToken(stage2CaloLayer2EGammaToken_, l1EGamma);
 
   edm::Handle < reco::GsfElectronCollection > gsfElectrons;
   e.getByToken(theGsfElectronCollection_, gsfElectrons);
 
   if (!gsfElectrons.isValid()) {
     edm::LogWarning("L1TEGammaOffline") << "invalid collection: GSF electrons " << std::endl;
     return;
   }
   if (gsfElectrons->empty()) {
     LogDebug("L1TEGammaOffline") << "empty collection: GSF electrons " << std::endl;
     return;
   }
   if (!l1EGamma.isValid()) {
     edm::LogWarning("L1TEGammaOffline") << "invalid collection: L1 EGamma " << std::endl;
     return;
   }
   if (!findTagAndProbePair(gsfElectrons)) {
     LogDebug("L1TEGammaOffline") << "Could not find a tag & probe pair" << std::endl;
     return; //continue to next event
   }
 
   auto probeElectron = probeElectron_;
 
   // find corresponding L1 EG
   double minDeltaR = 0.3;
   l1t::EGamma closestL1EGamma;
   bool foundMatch = false;
 
   int bunchCrossing = 0;
   for (auto egamma = l1EGamma->begin(bunchCrossing); egamma != l1EGamma->end(bunchCrossing); ++egamma) {
     double currentDeltaR = deltaR(egamma->eta(), egamma->phi(), probeElectron.eta(), probeElectron.phi());
     if (currentDeltaR > minDeltaR) {
       continue;
     } else {
       minDeltaR = currentDeltaR;
       closestL1EGamma = *egamma;
       foundMatch = true;
     }
 
   }
 
   if (!foundMatch) {
     LogDebug("L1TEGammaOffline") << "Could not find a matching L1 EGamma " << std::endl;
     return;
   }
 
   double recoEt = probeElectron.et();
   double recoEta = probeElectron.eta();
   double recoPhi = probeElectron.phi();
 
   double l1Et = closestL1EGamma.et();
   double l1Eta = closestL1EGamma.eta();
   double l1Phi = closestL1EGamma.phi();
 
   // if no reco value, relative resolution does not make sense -> sort to overflow
   double outOfBounds = 9999;
   double resolutionEt = recoEt > 0 ? (l1Et - recoEt) / recoEt : outOfBounds;
   double resolutionEta = std::abs(recoEta) > 0 ? (l1Eta - recoEta) / recoEta : outOfBounds;
   double resolutionPhi = std::abs(recoPhi) > 0 ? (l1Phi - recoPhi) / recoPhi : outOfBounds;
 
   using namespace dqmoffline::l1t;
   // eta
   fill2DWithinLimits(h_L1EGammaEtavsElectronEta_, recoEta, l1Eta);
   fillWithinLimits(h_resolutionElectronEta_, resolutionEta);
 
   // plots for deeper inspection
   for (auto threshold : deepInspectionElectronThresholds_) {
     fillWithinLimits(h_efficiencyElectronEta_total_[threshold], recoEta);
     fillWithinLimits(h_efficiencyElectronPhi_total_[threshold], recoPhi);
     fillWithinLimits(h_efficiencyElectronNVertex_total_[threshold], nVertex);
     if(recoEt > threshold){
       fillWithinLimits(h_efficiencyElectronEta_pass_[threshold], recoEta);
       fillWithinLimits(h_efficiencyElectronPhi_pass_[threshold], recoPhi);
       fillWithinLimits(h_efficiencyElectronNVertex_pass_[threshold], nVertex);
     }
   }
 
   for (auto threshold : electronEfficiencyThresholds_) {
     fill2DWithinLimits(h_efficiencyElectronPhi_vs_Eta_total_[threshold],
       recoEta, recoPhi);
     if(l1Et > threshold + probeToL1Offset_){
       fill2DWithinLimits(h_efficiencyElectronPhi_vs_Eta_pass_[threshold],
         recoEta, recoPhi);
     }
   }
 
   if (std::abs(recoEta) <= 1.479) { // barrel
     // et
     fill2DWithinLimits(h_L1EGammaETvsElectronET_EB_, recoEt, l1Et);
     fill2DWithinLimits(h_L1EGammaETvsElectronET_EB_EE_, recoEt, l1Et);
     //resolution
     fillWithinLimits(h_resolutionElectronET_EB_, resolutionEt);
     fillWithinLimits(h_resolutionElectronET_EB_EE_, resolutionEt);
     // phi
     fill2DWithinLimits(h_L1EGammaPhivsElectronPhi_EB_, recoPhi, l1Phi);
     fill2DWithinLimits(h_L1EGammaPhivsElectronPhi_EB_EE_, recoPhi, l1Phi);
     // resolution
     fillWithinLimits(h_resolutionElectronPhi_EB_, resolutionPhi);
     fillWithinLimits(h_resolutionElectronPhi_EB_EE_, resolutionPhi);
 
     // turn-ons
     for (auto threshold : electronEfficiencyThresholds_) {
       fillWithinLimits(h_efficiencyElectronET_EB_total_[threshold], recoEt);
       fillWithinLimits(h_efficiencyElectronET_EB_EE_total_[threshold], recoEt);
       if (l1Et > threshold) {
         fillWithinLimits(h_efficiencyElectronET_EB_pass_[threshold], recoEt);
         fillWithinLimits(h_efficiencyElectronET_EB_EE_pass_[threshold], recoEt);
       }
     }
   } else { // end-cap
     // et
     fill2DWithinLimits(h_L1EGammaETvsElectronET_EE_, recoEt, l1Et);
     fill2DWithinLimits(h_L1EGammaETvsElectronET_EB_EE_, recoEt, l1Et);
     //resolution
     fillWithinLimits(h_resolutionElectronET_EE_, resolutionEt);
     fillWithinLimits(h_resolutionElectronET_EB_EE_, resolutionEt);
     // phi
     fill2DWithinLimits(h_L1EGammaPhivsElectronPhi_EE_, recoPhi, l1Phi);
     fill2DWithinLimits(h_L1EGammaPhivsElectronPhi_EB_EE_, recoPhi, l1Phi);
     // resolution
     fillWithinLimits(h_resolutionElectronPhi_EE_, resolutionPhi);
     fillWithinLimits(h_resolutionElectronPhi_EB_EE_, resolutionPhi);
 
     // turn-ons
     for (auto threshold : electronEfficiencyThresholds_) {
       fillWithinLimits(h_efficiencyElectronET_EE_total_[threshold], recoEt);
       fillWithinLimits(h_efficiencyElectronET_EB_EE_total_[threshold], recoEt);
       if (l1Et > threshold) {
         fillWithinLimits(h_efficiencyElectronET_EE_pass_[threshold], recoEt);
         fillWithinLimits(h_efficiencyElectronET_EB_EE_pass_[threshold], recoEt);
       }
     }
   }
 }

void L1TEGammaOffline::fillPhotons	(	edm::Event const &	e,
		const unsigned int	nVertex
	)

private

Definition at line 375 of file L1TEGammaOffline.cc.

References funct::abs(), BXVector< T >::begin(), deltaR(), BXVector< T >::end(), reco::LeafCandidate::et(), reco::LeafCandidate::eta(), dqmoffline::l1t::fill2DWithinLimits(), dqmoffline::l1t::fillWithinLimits(), edm::Event::getByToken(), h_efficiencyPhotonET_EB_EE_pass_, h_efficiencyPhotonET_EB_EE_total_, h_efficiencyPhotonET_EB_pass_, h_efficiencyPhotonET_EB_total_, h_efficiencyPhotonET_EE_pass_, h_efficiencyPhotonET_EE_total_, h_L1EGammaEtavsPhotonEta_, h_L1EGammaETvsPhotonET_EB_, h_L1EGammaETvsPhotonET_EB_EE_, h_L1EGammaETvsPhotonET_EE_, h_L1EGammaPhivsPhotonPhi_EB_, h_L1EGammaPhivsPhotonPhi_EB_EE_, h_L1EGammaPhivsPhotonPhi_EE_, h_resolutionPhotonET_EB_, h_resolutionPhotonET_EB_EE_, h_resolutionPhotonET_EE_, h_resolutionPhotonEta_, h_resolutionPhotonPhi_EB_, h_resolutionPhotonPhi_EB_EE_, h_resolutionPhotonPhi_EE_, edm::HandleBase::isValid(), LogDebug, reco::LeafCandidate::phi(), photonEfficiencyThresholds_, nano_cff::photons, stage2CaloLayer2EGammaToken_, thePhotonCollection_, and electronIdCutBased_cfi::threshold.

Referenced by analyze().

 {
   // TODO - just an example here
   edm::Handle<l1t::EGammaBxCollection> l1EGamma;
   e.getByToken(stage2CaloLayer2EGammaToken_, l1EGamma);
 
   edm::Handle < reco::PhotonCollection > photons;
   e.getByToken(thePhotonCollection_, photons);
 
   if (!photons.isValid()) {
     edm::LogWarning("L1TEGammaOffline") << "invalid collection: reco::Photons " << std::endl;
     return;
   }
   if (!l1EGamma.isValid()) {
      edm::LogWarning("L1TEGammaOffline") << "invalid collection: L1 EGamma " << std::endl;
     return;
   }
 
   if(photons->empty()){
     LogDebug("L1TEGammaOffline") << "No photons found in event." << std::endl;
     return;
   }
 
   auto probePhoton = photons->at(0);
 
   double minDeltaR = 0.3;
   l1t::EGamma closestL1EGamma;
   bool foundMatch = false;
 
   int bunchCrossing = 0;
   for (auto egamma = l1EGamma->begin(bunchCrossing); egamma != l1EGamma->end(bunchCrossing); ++egamma) {
     double currentDeltaR = deltaR(egamma->eta(), egamma->phi(), probePhoton.eta(), probePhoton.phi());
     if (currentDeltaR > minDeltaR) {
       continue;
     } else {
       minDeltaR = currentDeltaR;
       closestL1EGamma = *egamma;
       foundMatch = true;
     }
 
   }
 
   if (!foundMatch) {
     LogDebug("L1TEGammaOffline") << "Could not find a matching L1 EGamma " << std::endl;
     return;
   }
 
   double recoEt = probePhoton.et();
   double recoEta = probePhoton.eta();
   double recoPhi = probePhoton.phi();
 
   double l1Et = closestL1EGamma.et();
   double l1Eta = closestL1EGamma.eta();
   double l1Phi = closestL1EGamma.phi();
 
   // if no reco value, relative resolution does not make sense -> sort to overflow
   double outOfBounds = 9999;
   double resolutionEt = recoEt > 0 ? (l1Et - recoEt) / recoEt : outOfBounds;
   double resolutionEta = std::abs(recoEta) > 0 ? (l1Eta - recoEta) / recoEta : outOfBounds;
   double resolutionPhi = std::abs(recoPhi) > 0 ? (l1Phi - recoPhi) / recoPhi : outOfBounds;
 
   using namespace dqmoffline::l1t;
   // eta
   fill2DWithinLimits(h_L1EGammaEtavsPhotonEta_, recoEta, l1Eta);
   fillWithinLimits(h_resolutionPhotonEta_, resolutionEta);
 
   if (std::abs(recoEta) <= 1.479) { // barrel
     // et
     fill2DWithinLimits(h_L1EGammaETvsPhotonET_EB_, recoEt, l1Et);
     fill2DWithinLimits(h_L1EGammaETvsPhotonET_EB_EE_, recoEt, l1Et);
     //resolution
     fillWithinLimits(h_resolutionPhotonET_EB_, resolutionEt);
     fillWithinLimits(h_resolutionPhotonET_EB_EE_, resolutionEt);
     // phi
     fill2DWithinLimits(h_L1EGammaPhivsPhotonPhi_EB_, recoPhi, l1Phi);
     fill2DWithinLimits(h_L1EGammaPhivsPhotonPhi_EB_EE_, recoPhi, l1Phi);
     // resolution
     fillWithinLimits(h_resolutionPhotonPhi_EB_, resolutionPhi);
     fillWithinLimits(h_resolutionPhotonPhi_EB_EE_, resolutionPhi);
 
     // turn-ons
     for (auto threshold : photonEfficiencyThresholds_) {
       fillWithinLimits(h_efficiencyPhotonET_EB_total_[threshold], recoEt);
       fillWithinLimits(h_efficiencyPhotonET_EB_EE_total_[threshold], recoEt);
       if (l1Et > threshold) {
         fillWithinLimits(h_efficiencyPhotonET_EB_pass_[threshold], recoEt);
         fillWithinLimits(h_efficiencyPhotonET_EB_EE_pass_[threshold], recoEt);
       }
     }
   } else { // end-cap
     // et
     fill2DWithinLimits(h_L1EGammaETvsPhotonET_EE_, recoEt, l1Et);
     fill2DWithinLimits(h_L1EGammaETvsPhotonET_EB_EE_, recoEt, l1Et);
     //resolution
     fillWithinLimits(h_resolutionPhotonET_EE_, resolutionEt);
     fillWithinLimits(h_resolutionPhotonET_EB_EE_, resolutionEt);
     // phi
     fill2DWithinLimits(h_L1EGammaPhivsPhotonPhi_EE_, recoPhi, l1Phi);
     fill2DWithinLimits(h_L1EGammaPhivsPhotonPhi_EB_EE_, recoPhi, l1Phi);
     // resolution
     fillWithinLimits(h_resolutionPhotonPhi_EE_, resolutionPhi);
     fillWithinLimits(h_resolutionPhotonPhi_EB_EE_, resolutionPhi);
 
     // turn-ons
     for (auto threshold : photonEfficiencyThresholds_) {
       fillWithinLimits(h_efficiencyPhotonET_EE_total_[threshold], recoEt);
       fillWithinLimits(h_efficiencyPhotonET_EB_EE_total_[threshold], recoEt);
       if (l1Et > threshold) {
         fillWithinLimits(h_efficiencyPhotonET_EE_pass_[threshold], recoEt);
         fillWithinLimits(h_efficiencyPhotonET_EB_EE_pass_[threshold], recoEt);
       }
     }
   }
 }

bool L1TEGammaOffline::findTagAndProbePair ( edm::Handle< reco::GsfElectronCollection > const & electrons )

private

From https://cds.cern.ch/record/2202966/files/DP2016_044.pdf slide 8 Filter on HLT_Ele30WP60_Ele8_Mass55 (TODO) HLT_Ele30WP60_SC4_Mass55 (TODO) Seeded by L1SingleEG, unprescaled required

Tag & probe selection Electron required to be within ECAL fiducial volume (|η|<1.4442 || 1.566<|η|<2.5). 60 < m(ee) < 120 GeV. Opposite charge requirement. Tag required to pass medium electron ID and ET > 30 GeV. Probe required to pass loose electron ID.

Parameters

electrons

Returns

Definition at line 265 of file L1TEGammaOffline.cc.

References funct::abs(), dqmoffline::l1t::fillWithinLimits(), h_tagAndProbeMass_, jets_cff::nElectrons, passesLooseEleId(), passesMediumEleId(), probeElectron_, and tagElectron_.

Referenced by fillElectrons().

 {
   bool foundBoth(false);
   auto nElectrons = electrons->size();
   if (nElectrons < 2)
     return false;
 
   for (auto tagElectron : *electrons) {
     for (auto probeElectron : *electrons) {
       if (tagElectron.p4() == probeElectron.p4())
         continue;
 
       auto combined(tagElectron.p4() + probeElectron.p4());
       auto tagAbsEta = std::abs(tagElectron.eta());
       auto probeAbsEta = std::abs(probeElectron.eta());
 
       // EB-EE transition region
       bool isEBEEGap = tagElectron.isEBEEGap() || probeElectron.isEBEEGap();
       bool passesEta = !isEBEEGap && tagAbsEta < 2.5 && probeAbsEta < 2.5;
       bool passesCharge = tagElectron.charge() == -probeElectron.charge();
 
       // https://github.com/ikrav/cmssw/blob/egm_id_80X_v1/RecoEgamma/ElectronIdentification/plugins/cuts/GsfEleFull5x5SigmaIEtaIEtaCut.cc#L45
       bool tagPassesMediumID = passesMediumEleId(tagElectron) && tagElectron.et() > 30.;
       bool probePassesLooseID = passesLooseEleId(probeElectron);
       bool passesInvariantMass = combined.M() > 60 && combined.M() < 120;
 
       if (passesEta && passesInvariantMass && passesCharge && tagPassesMediumID && probePassesLooseID) {
         foundBoth = true;
         tagElectron_ = tagElectron;
         probeElectron_ = probeElectron;
         // plot tag & probe invariant mass
         dqmoffline::l1t::fillWithinLimits(h_tagAndProbeMass_, combined.M());
         break;
       }
     }
 
   }
   return foundBoth;
 }

bool L1TEGammaOffline::passesLooseEleId ( reco::GsfElectron const & electron ) const

private

Structure from https://github.com/cms-sw/cmssw/blob/CMSSW_9_0_X/DQMOffline/EGamma/plugins/ElectronAnalyzer.cc Values from https://twiki.cern.ch/twiki/bin/view/CMS/CutBasedElectronIdentificationRun2

Definition at line 311 of file L1TEGammaOffline.cc.

References funct::abs(), reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx(), reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx(), reco::GsfElectron::ecalEnergy(), reco::GsfElectron::eSuperClusterOverP(), reco::GsfElectron::hadronicOverEm(), reco::GsfElectron::isEB(), reco::GsfElectron::isEE(), and reco::GsfElectron::scSigmaIEtaIEta().

Referenced by findTagAndProbePair().

 {
   const float ecal_energy_inverse = 1.0 / electron.ecalEnergy();
   const float eSCoverP = electron.eSuperClusterOverP();
   const float eOverP = std::abs(1.0 - eSCoverP) * ecal_energy_inverse;
 
   if (electron.isEB() && eOverP > 0.241)
     return false;
   if (electron.isEE() && eOverP > 0.14)
     return false;
   if (electron.isEB() && std::abs(electron.deltaEtaSuperClusterTrackAtVtx()) > 0.00477)
     return false;
   if (electron.isEE() && std::abs(electron.deltaEtaSuperClusterTrackAtVtx()) > 0.00868)
     return false;
   if (electron.isEB() && std::abs(electron.deltaPhiSuperClusterTrackAtVtx()) > 0.222)
     return false;
   if (electron.isEE() && std::abs(electron.deltaPhiSuperClusterTrackAtVtx()) > 0.213)
     return false;
   if (electron.isEB() && electron.scSigmaIEtaIEta() > 0.011)
     return false;
   if (electron.isEE() && electron.scSigmaIEtaIEta() > 0.0314)
     return false;
   if (electron.isEB() && electron.hadronicOverEm() > 0.298)
     return false;
   if (electron.isEE() && electron.hadronicOverEm() > 0.101)
     return false;
   return true;
 }

bool L1TEGammaOffline::passesMediumEleId ( reco::GsfElectron const & electron ) const

private

Definition at line 346 of file L1TEGammaOffline.cc.

References funct::abs(), reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx(), reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx(), reco::GsfElectron::ecalEnergy(), reco::GsfElectron::eSuperClusterOverP(), reco::GsfElectron::hadronicOverEm(), reco::GsfElectron::isEB(), reco::GsfElectron::isEE(), and reco::GsfElectron::scSigmaIEtaIEta().

Referenced by findTagAndProbePair().

 {
   const float ecal_energy_inverse = 1.0 / electron.ecalEnergy();
   const float eSCoverP = electron.eSuperClusterOverP();
   const float eOverP = std::abs(1.0 - eSCoverP) * ecal_energy_inverse;
 
   if (electron.isEB() && eOverP < 0.134)
     return false;
   if (electron.isEE() && eOverP > 0.13)
     return false;
   if (electron.isEB() && std::abs(electron.deltaEtaSuperClusterTrackAtVtx()) > 0.00311)
     return false;
   if (electron.isEE() && std::abs(electron.deltaEtaSuperClusterTrackAtVtx()) > 0.00609)
     return false;
   if (electron.isEB() && std::abs(electron.deltaPhiSuperClusterTrackAtVtx()) > 0.103)
     return false;
   if (electron.isEE() && std::abs(electron.deltaPhiSuperClusterTrackAtVtx()) > 0.045)
     return false;
   if (electron.isEB() && electron.scSigmaIEtaIEta() > 0.00998)
     return false;
   if (electron.isEE() && electron.scSigmaIEtaIEta() > 0.0298)
     return false;
   if (electron.isEB() && electron.hadronicOverEm() > 0.253)
     return false;
   if (electron.isEE() && electron.hadronicOverEm() > 0.0878)
     return false;
   return true;
 }