#include <L1TEGammaOffline.h>

Inheritance diagram for L1TEGammaOffline:

Public Types
enum	PlotConfig { nVertex, ETvsET, PHIvsPHI }

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

	~L1TEGammaOffline () override

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

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

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

	DQMEDAnalyzer ()

	DQMEDAnalyzer (DQMEDAnalyzer const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer &&)=delete

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

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

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

void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) override

	~DQMEDAnalyzer () override=default

Public Member Functions inherited from edm::one::EDProducer< edm::Accumulator, edm::EndLuminosityBlockProducer, edm::EndRunProducer, edm::one::WatchLuminosityBlocks, edm::one::WatchRuns >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) 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)

Static Public Attributes
static const std::map< std::string, unsigned int >	PlotConfigNames

Protected Member Functions
void	analyze (edm::Event const &e, 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	endJob () 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	matchesAnHLTObject (double eta, double phi) const

void	normalise2DHistogramsToBinArea ()

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_

dqmoffline::l1t::HistDefinitions	histDefinitions_

std::string	histFolder_

HLTConfigProvider	hltConfig_

double	maxDeltaRForHLTMatching_

double	maxDeltaRForL1Matching_

std::vector< double >	photonEfficiencyBins_

std::vector< double >	photonEfficiencyThresholds_

reco::GsfElectron	probeElectron_

double	probeToL1Offset_

math::XYZPoint	PVPoint_

double	recoToL1TThresholdFactor_

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_

trigger::TriggerEvent	triggerEvent_

std::vector< unsigned int >	triggerIndices_

edm::EDGetTokenT< trigger::TriggerEvent >	triggerInputTag_

std::vector< std::string >	triggerNames_

std::string	triggerProcess_

edm::TriggerResults	triggerResults_

edm::EDGetTokenT< edm::TriggerResults >	triggerResultsInputTag_

Additional Inherited Members
Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 39 of file L1TEGammaOffline.h.

Member Enumeration Documentation

enum L1TEGammaOffline::PlotConfig

Enumerator
nVertex
ETvsET
PHIvsPHI

Definition at line 46 of file L1TEGammaOffline.h.

                   {
     nVertex,
     ETvsET,
     PHIvsPHI
   };

Constructor & Destructor Documentation

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

Definition at line 32 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"))),
         triggerInputTag_(consumes < trigger::TriggerEvent > (ps.getParameter < edm::InputTag > ("triggerInputTag"))),
         triggerResultsInputTag_(consumes<edm::TriggerResults>(ps.getParameter<edm::InputTag>("triggerResults"))),
         triggerProcess_(ps.getParameter < std::string > ("triggerProcess")),
         triggerNames_(ps.getParameter < std::vector<std::string> > ("triggerNames")),
         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")),
         maxDeltaRForL1Matching_(ps.getParameter <double> ("maxDeltaRForL1Matching")),
         maxDeltaRForHLTMatching_(ps.getParameter <double> ("maxDeltaRForHLTMatching")),
         recoToL1TThresholdFactor_(ps.getParameter <double> ("recoToL1TThresholdFactor")),
         tagElectron_(),
         probeElectron_(),
         tagAndProbleInvariantMass_(-1.),
         hltConfig_(),
         triggerIndices_(),
         triggerResults_(),
         triggerEvent_(),
         histDefinitions_(dqmoffline::l1t::readHistDefinitions(ps.getParameterSet("histDefinitions"), PlotConfigNames)),
         h_nVertex_(),
         h_tagAndProbeMass_(),
         h_L1EGammaETvsElectronET_EB_(),
         h_L1EGammaETvsElectronET_EE_(),
         h_L1EGammaETvsElectronET_EB_EE_(),
         h_L1EGammaPhivsElectronPhi_EB_(),
         h_L1EGammaPhivsElectronPhi_EE_(),
         h_L1EGammaPhivsElectronPhi_EB_EE_(),
         h_L1EGammaEtavsElectronEta_(),
         h_resolutionElectronET_EB_(),
         h_resolutionElectronET_EE_(),
         h_resolutionElectronET_EB_EE_(),
         h_resolutionElectronPhi_EB_(),
         h_resolutionElectronPhi_EE_(),
         h_resolutionElectronPhi_EB_EE_(),
         h_resolutionElectronEta_(),
         h_efficiencyElectronET_EB_pass_(),
         h_efficiencyElectronET_EE_pass_(),
         h_efficiencyElectronET_EB_EE_pass_(),
         h_efficiencyElectronPhi_vs_Eta_pass_(),
         h_efficiencyElectronEta_pass_(),
         h_efficiencyElectronPhi_pass_(),
         h_efficiencyElectronNVertex_pass_(),
         h_efficiencyElectronET_EB_total_(),
         h_efficiencyElectronET_EE_total_(),
         h_efficiencyElectronET_EB_EE_total_(),
         h_efficiencyElectronPhi_vs_Eta_total_(),
         h_efficiencyElectronEta_total_(),
         h_efficiencyElectronPhi_total_(),
         h_efficiencyElectronNVertex_total_(),
         h_L1EGammaETvsPhotonET_EB_(),
         h_L1EGammaETvsPhotonET_EE_(),
         h_L1EGammaETvsPhotonET_EB_EE_(),
         h_L1EGammaPhivsPhotonPhi_EB_(),
         h_L1EGammaPhivsPhotonPhi_EE_(),
         h_L1EGammaPhivsPhotonPhi_EB_EE_(),
         h_L1EGammaEtavsPhotonEta_(),
         h_resolutionPhotonEta_(),
         h_efficiencyPhotonET_EB_pass_(),
         h_efficiencyPhotonET_EE_pass_(),
         h_efficiencyPhotonET_EB_EE_pass_(),
         h_efficiencyPhotonET_EB_total_(),
         h_efficiencyPhotonET_EE_total_(),
         h_efficiencyPhotonET_EB_EE_total_()
 {
   edm::LogInfo("L1TEGammaOffline") << "Constructor " << "L1TEGammaOffline::L1TEGammaOffline " << std::endl;
 }

L1TEGammaOffline::~L1TEGammaOffline ( )

override

Definition at line 115 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

Reimplemented from DQMEDAnalyzer.

Definition at line 152 of file L1TEGammaOffline.cc.

References fillElectrons(), dqmoffline::l1t::fillWithinLimits(), edm::Event::getByToken(), h_nVertex_, edm::HandleBase::isValid(), nVertex, dqmoffline::l1t::passesAnyTriggerFromList(), thePVCollection_, triggerEvent_, triggerIndices_, triggerInputTag_, triggerResults_, and triggerResultsInputTag_.

 {
   edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::analyze" << std::endl;
 
   edm::Handle<edm::TriggerResults> triggerResultHandle;
   e.getByToken(triggerResultsInputTag_, triggerResultHandle);
   if (!triggerResultHandle.isValid()) {
     edm::LogWarning("L1TEGammaOffline") << "invalid edm::TriggerResults handle" << std::endl;
     return;
   }
   triggerResults_ = *triggerResultHandle;
 
   edm::Handle<trigger::TriggerEvent> triggerEventHandle;
   e.getByToken(triggerInputTag_, triggerEventHandle);
   if (!triggerEventHandle.isValid()) {
     edm::LogWarning("L1TEGammaOffline") << "invalid trigger::TriggerEvent handle" << std::endl;
     return;
   }
   triggerEvent_ = *triggerEventHandle;
 
   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);
 
   if(!dqmoffline::l1t::passesAnyTriggerFromList(triggerIndices_, triggerResults_)){
     return;
   }
   // L1T
   fillElectrons(e, nVertex);
   // fillPhotons(e, nVertex);
 }

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

private

Definition at line 599 of file L1TEGammaOffline.cc.

Referenced by bookHistograms().

 {
   ibooker.cd();
   ibooker.setCurrentFolder(histFolder_);
 
   dqmoffline::l1t::HistDefinition nVertexDef = histDefinitions_[PlotConfig::nVertex];
   h_nVertex_ = ibooker.book1D(
     nVertexDef.name, nVertexDef.title, nVertexDef.nbinsX, nVertexDef.xmin, nVertexDef.xmax
   );
   h_tagAndProbeMass_ = ibooker.book1D("tagAndProbeMass", "Invariant mass of tag & probe pair", 100, 40, 140);
   // electron reco vs L1
   dqmoffline::l1t::HistDefinition templateETvsET = histDefinitions_[PlotConfig::ETvsET];
   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)",
       templateETvsET.nbinsX, &templateETvsET.binsX[0], templateETvsET.nbinsY, &templateETvsET.binsY[0]);
   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)",
       templateETvsET.nbinsX, &templateETvsET.binsX[0], templateETvsET.nbinsY, &templateETvsET.binsY[0]);
   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)",
       templateETvsET.nbinsX, &templateETvsET.binsX[0], templateETvsET.nbinsY, &templateETvsET.binsY[0]);
 
   dqmoffline::l1t::HistDefinition templatePHIvsPHI = histDefinitions_[PlotConfig::PHIvsPHI];
   h_L1EGammaPhivsElectronPhi_EB_ = ibooker.book2D("L1EGammaPhivsElectronPhi_EB",
       "#phi_{electron}^{L1} vs #phi_{electron}^{offline} (EB); #phi_{electron}^{offline}; #phi_{electron}^{L1}",
       templatePHIvsPHI.nbinsX, templatePHIvsPHI.xmin, templatePHIvsPHI.xmax,
       templatePHIvsPHI.nbinsY, templatePHIvsPHI.ymin, templatePHIvsPHI.ymax);
   h_L1EGammaPhivsElectronPhi_EE_ = ibooker.book2D("L1EGammaPhivsElectronPhi_EE",
       "#phi_{electron}^{L1} vs #phi_{electron}^{offline} (EE); #phi_{electron}^{offline}; #phi_{electron}^{L1}",
       templatePHIvsPHI.nbinsX, templatePHIvsPHI.xmin, templatePHIvsPHI.xmax,
       templatePHIvsPHI.nbinsY, templatePHIvsPHI.ymin, templatePHIvsPHI.ymax);
   h_L1EGammaPhivsElectronPhi_EB_EE_ = ibooker.book2D("L1EGammaPhivsElectronPhi_EB_EE",
       "#phi_{electron}^{L1} vs #phi_{electron}^{offline} (EB+EE); #phi_{electron}^{offline}; #phi_{electron}^{L1}",
       templatePHIvsPHI.nbinsX, templatePHIvsPHI.xmin, templatePHIvsPHI.xmax,
       templatePHIvsPHI.nbinsY, templatePHIvsPHI.ymin, templatePHIvsPHI.ymax);
 
   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}; events",
           120, -0.3, 0.3);
   h_resolutionElectronPhi_EE_ =
       ibooker.book1D("resolutionElectronPhi_EE",
           "electron #phi resolution (EE); #phi_{electron}^{L1} - #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}; events",
           120, -0.3, 0.3);
 
   h_resolutionElectronEta_ = ibooker.book1D("resolutionElectronEta",
       "electron #eta resolution  (EB); L1 EGamma #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 140 of file L1TEGammaOffline.cc.

References bookElectronHistos().

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

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

private

Definition at line 726 of file L1TEGammaOffline.cc.

 {
   ibooker.cd();
   ibooker.setCurrentFolder(histFolder_);
 
   dqmoffline::l1t::HistDefinition templateETvsET = histDefinitions_[PlotConfig::ETvsET];
   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)",
       templateETvsET.nbinsX, &templateETvsET.binsX[0], templateETvsET.nbinsY, &templateETvsET.binsY[0]);
   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)",
       templateETvsET.nbinsX, &templateETvsET.binsX[0], templateETvsET.nbinsY, &templateETvsET.binsY[0]);
   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)",
       templateETvsET.nbinsX, &templateETvsET.binsX[0], templateETvsET.nbinsY, &templateETvsET.binsY[0]);
 
   dqmoffline::l1t::HistDefinition templatePHIvsPHI = histDefinitions_[PlotConfig::PHIvsPHI];
   h_L1EGammaPhivsPhotonPhi_EB_ = ibooker.book2D("L1EGammaPhivsPhotonPhi_EB",
       "#phi_{photon}^{L1} vs #phi_{photon}^{offline} (EB); #phi_{photon}^{offline}; #phi_{photon}^{L1}",
       templatePHIvsPHI.nbinsX, templatePHIvsPHI.xmin, templatePHIvsPHI.xmax,
       templatePHIvsPHI.nbinsY, templatePHIvsPHI.ymin, templatePHIvsPHI.ymax);
   h_L1EGammaPhivsPhotonPhi_EE_ = ibooker.book2D("L1EGammaPhivsPhotonPhi_EE",
       "#phi_{photon}^{L1} vs #phi_{photon}^{offline} (EE); #phi_{photon}^{offline}; #phi_{photon}^{L1}",
       templatePHIvsPHI.nbinsX, templatePHIvsPHI.xmin, templatePHIvsPHI.xmax,
       templatePHIvsPHI.nbinsY, templatePHIvsPHI.ymin, templatePHIvsPHI.ymax);
   h_L1EGammaPhivsPhotonPhi_EB_EE_ = ibooker.book2D("L1EGammaPhivsPhotonPhi_EB_EE",
       "#phi_{photon}^{L1} vs #phi_{photon}^{offline} (EB+EE); #phi_{photon}^{offline}; #phi_{photon}^{L1}",
       templatePHIvsPHI.nbinsX, templatePHIvsPHI.xmin, templatePHIvsPHI.xmax,
       templatePHIvsPHI.nbinsY, templatePHIvsPHI.ymin, templatePHIvsPHI.ymax);
 
   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}; events",
       120, -0.3, 0.3);
   h_resolutionPhotonPhi_EE_ = ibooker.book1D("resolutionPhotonPhi_EE",
       "photon #phi resolution (EE); #phi_{photon}^{L1} - #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}; events",
       120, -0.3, 0.3);
 
   h_resolutionPhotonEta_ = ibooker.book1D("resolutionPhotonEta",
       "photon #eta resolution  (EB); L1 EGamma #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 &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 123 of file L1TEGammaOffline.cc.

References dqmoffline::l1t::getTriggerIndices(), hltConfig_, HLTConfigProvider::init(), triggerIndices_, HLTConfigProvider::triggerNames(), triggerNames_, and triggerProcess_.

 {
   edm::LogInfo("L1TEGammaOffline") << "L1TEGammaOffline::beginRun" << std::endl;
   bool changed(true);
   if (!hltConfig_.init(iRun, iSetup, triggerProcess_, changed)) {
     edm::LogError("L1TEGammaOffline")
         << " HLT config extraction failure with process name "
         << triggerProcess_<< std::endl;
     triggerNames_.clear();
   } else {
     triggerIndices_ = dqmoffline::l1t::getTriggerIndices(triggerNames_, hltConfig_.triggerNames());
   }
 }

void L1TEGammaOffline::endJob ( void )

overrideprotectedvirtual

Reimplemented from edm::one::EDProducerBase.

Definition at line 812 of file L1TEGammaOffline.cc.

References normalise2DHistogramsToBinArea().

                              {
   normalise2DHistogramsToBinArea();
 }

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

overrideprotected

Definition at line 591 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 190 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 = maxDeltaRForL1Matching_;
   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 = l1Eta - recoEta;
   double resolutionPhi = reco::deltaPhi(l1Phi, recoPhi);
 
   using namespace dqmoffline::l1t;
   // eta
   fill2DWithinLimits(h_L1EGammaEtavsElectronEta_, recoEta, l1Eta);
   fillWithinLimits(h_resolutionElectronEta_, resolutionEta);
 
   // plots for deeper inspection
   for (auto threshold : deepInspectionElectronThresholds_) {
     if (recoEt > threshold * recoToL1TThresholdFactor_) {
         fillWithinLimits(h_efficiencyElectronEta_total_[threshold], recoEta);
         fillWithinLimits(h_efficiencyElectronPhi_total_[threshold], recoPhi);
         fillWithinLimits(h_efficiencyElectronNVertex_total_[threshold], nVertex);
         if (l1Et > threshold + probeToL1Offset_) {
             fillWithinLimits(h_efficiencyElectronEta_pass_[threshold], recoEta);
             fillWithinLimits(h_efficiencyElectronPhi_pass_[threshold], recoPhi);
             fillWithinLimits(h_efficiencyElectronNVertex_pass_[threshold], nVertex);
         }
     }
 }
 
   for (auto threshold : electronEfficiencyThresholds_) {
     if (recoEt > threshold * recoToL1TThresholdFactor_) {
         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 473 of file L1TEGammaOffline.cc.

References funct::abs(), BXVector< T >::begin(), reco::deltaPhi(), 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.

 {
   // 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 = l1Eta - recoEta;
   double resolutionPhi = reco::deltaPhi(l1Phi, recoPhi);
 
   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 349 of file L1TEGammaOffline.cc.

References funct::abs(), dqmoffline::l1t::fillWithinLimits(), h_tagAndProbeMass_, matchesAnHLTObject(), 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;
       bool tagMatchesHLTObject = matchesAnHLTObject(tagElectron.eta(), tagElectron.phi());
 
       if (passesEta && passesInvariantMass && passesCharge && tagPassesMediumID &&
           probePassesLooseID && tagMatchesHLTObject) {
         foundBoth = true;
         tagElectron_ = tagElectron;
         probeElectron_ = probeElectron;
         // plot tag & probe invariant mass
         dqmoffline::l1t::fillWithinLimits(h_tagAndProbeMass_, combined.M());
         return foundBoth;
       }
     }
 
   }
   return foundBoth;
 }

bool L1TEGammaOffline::matchesAnHLTObject	(	double	eta,
		double	phi
	)		const

private

Definition at line 461 of file L1TEGammaOffline.cc.

References dqmoffline::l1t::getFiredTriggerIndices(), dqmoffline::l1t::getHLTFilters(), dqmoffline::l1t::getMatchedTriggerObjects(), dqmoffline::l1t::getTriggerObjects(), dqmoffline::l1t::getTriggerResults(), hltConfig_, maxDeltaRForHLTMatching_, mps_update::results, triggerEvent_, triggerIndices_, triggerProcess_, and triggerResults_.

Referenced by findTagAndProbePair().

                                                                      {
   // get HLT objects of fired triggers
   using namespace dqmoffline::l1t;
   std::vector<bool> results = getTriggerResults(triggerIndices_, triggerResults_);
   std::vector<unsigned int> firedTriggers = getFiredTriggerIndices(triggerIndices_, results);
   std::vector<edm::InputTag> hltFilters = getHLTFilters(firedTriggers, hltConfig_, triggerProcess_);
   const trigger::TriggerObjectCollection hltObjects = getTriggerObjects(hltFilters, triggerEvent_);
   const trigger::TriggerObjectCollection matchedObjects = getMatchedTriggerObjects(eta, phi, maxDeltaRForHLTMatching_, hltObjects);
 
   return !matchedObjects.empty();
 }

void L1TEGammaOffline::normalise2DHistogramsToBinArea ( )

private

Definition at line 816 of file L1TEGammaOffline.cc.

References DEFINE_FWK_MODULE, h, h_L1EGammaEtavsElectronEta_, h_L1EGammaEtavsPhotonEta_, h_L1EGammaETvsElectronET_EB_, h_L1EGammaETvsElectronET_EB_EE_, h_L1EGammaETvsElectronET_EE_, h_L1EGammaETvsPhotonET_EB_, h_L1EGammaETvsPhotonET_EB_EE_, h_L1EGammaETvsPhotonET_EE_, h_L1EGammaPhivsElectronPhi_EB_, h_L1EGammaPhivsElectronPhi_EB_EE_, h_L1EGammaPhivsElectronPhi_EE_, h_L1EGammaPhivsPhotonPhi_EB_, h_L1EGammaPhivsPhotonPhi_EB_EE_, h_L1EGammaPhivsPhotonPhi_EE_, and LaserDQM_cfi::mon.

Referenced by endJob().

                                                       {
   std::vector<MonitorElement *> monElementstoNormalize = {
       h_L1EGammaETvsElectronET_EB_,    h_L1EGammaETvsElectronET_EE_,
       h_L1EGammaETvsElectronET_EB_EE_, h_L1EGammaPhivsElectronPhi_EB_,
       h_L1EGammaPhivsElectronPhi_EE_,  h_L1EGammaPhivsElectronPhi_EB_EE_,
       h_L1EGammaEtavsElectronEta_,     h_L1EGammaETvsPhotonET_EB_,
       h_L1EGammaETvsPhotonET_EE_,      h_L1EGammaETvsPhotonET_EB_EE_,
       h_L1EGammaPhivsPhotonPhi_EB_,    h_L1EGammaPhivsPhotonPhi_EE_,
       h_L1EGammaPhivsPhotonPhi_EB_EE_, h_L1EGammaEtavsPhotonEta_
   };
 
   for (auto mon : monElementstoNormalize) {
     if (mon != nullptr) {
       auto h = mon->getTH2F();
       if (h != nullptr) {
         h->Scale(1, "width");
       }
     }
   }
 }

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 397 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 432 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;
 }

Member Data Documentation

std::vector<double> L1TEGammaOffline::deepInspectionElectronThresholds_

private

Definition at line 99 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::string L1TEGammaOffline::efficiencyFolder_

private

Definition at line 92 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and bookPhotonHistos().

std::vector<double> L1TEGammaOffline::electronEfficiencyBins_

private

Definition at line 97 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos().

std::vector<double> L1TEGammaOffline::electronEfficiencyThresholds_

private

Definition at line 96 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronET_EB_EE_pass_

private

Definition at line 148 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronET_EB_EE_total_

private

Definition at line 159 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronET_EB_pass_

private

Definition at line 146 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronET_EB_total_

private

Definition at line 157 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronET_EE_pass_

private

Definition at line 147 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronET_EE_total_

private

Definition at line 158 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronEta_pass_

private

Definition at line 151 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronEta_total_

private

Definition at line 162 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronNVertex_pass_

private

Definition at line 153 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronNVertex_total_

private

Definition at line 164 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronPhi_pass_

private

Definition at line 152 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronPhi_total_

private

Definition at line 163 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronPhi_vs_Eta_pass_

private

Definition at line 149 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyElectronPhi_vs_Eta_total_

private

Definition at line 160 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyPhotonET_EB_EE_pass_

private

Definition at line 191 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyPhotonET_EB_EE_total_

private

Definition at line 197 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyPhotonET_EB_pass_

private

Definition at line 189 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyPhotonET_EB_total_

private

Definition at line 195 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyPhotonET_EE_pass_

private

Definition at line 190 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

std::map<double, MonitorElement*> L1TEGammaOffline::h_efficiencyPhotonET_EE_total_

private

Definition at line 196 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

MonitorElement* L1TEGammaOffline::h_L1EGammaEtavsElectronEta_

private

Definition at line 132 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), fillElectrons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaEtavsPhotonEta_

private

Definition at line 175 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), fillPhotons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsElectronET_EB_

private

Definition at line 124 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), fillElectrons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsElectronET_EB_EE_

private

Definition at line 126 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), fillElectrons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsElectronET_EE_

private

Definition at line 125 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), fillElectrons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsPhotonET_EB_

private

Definition at line 167 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), fillPhotons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsPhotonET_EB_EE_

private

Definition at line 169 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), fillPhotons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsPhotonET_EE_

private

Definition at line 168 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), fillPhotons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsElectronPhi_EB_

private

Definition at line 128 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), fillElectrons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsElectronPhi_EB_EE_

private

Definition at line 130 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), fillElectrons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsElectronPhi_EE_

private

Definition at line 129 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), fillElectrons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsPhotonPhi_EB_

private

Definition at line 171 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), fillPhotons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsPhotonPhi_EB_EE_

private

Definition at line 173 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), fillPhotons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsPhotonPhi_EE_

private

Definition at line 172 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), fillPhotons(), and normalise2DHistogramsToBinArea().

MonitorElement* L1TEGammaOffline::h_nVertex_

private

Definition at line 120 of file L1TEGammaOffline.h.

Referenced by analyze(), and bookElectronHistos().

MonitorElement* L1TEGammaOffline::h_resolutionElectronET_EB_

private

Definition at line 135 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

MonitorElement* L1TEGammaOffline::h_resolutionElectronET_EB_EE_

private

Definition at line 137 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

MonitorElement* L1TEGammaOffline::h_resolutionElectronET_EE_

private

Definition at line 136 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

MonitorElement* L1TEGammaOffline::h_resolutionElectronEta_

private

Definition at line 143 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

MonitorElement* L1TEGammaOffline::h_resolutionElectronPhi_EB_

private

Definition at line 139 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

MonitorElement* L1TEGammaOffline::h_resolutionElectronPhi_EB_EE_

private

Definition at line 141 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

MonitorElement* L1TEGammaOffline::h_resolutionElectronPhi_EE_

private

Definition at line 140 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

MonitorElement* L1TEGammaOffline::h_resolutionPhotonET_EB_

private

Definition at line 178 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

MonitorElement* L1TEGammaOffline::h_resolutionPhotonET_EB_EE_

private

Definition at line 180 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

MonitorElement* L1TEGammaOffline::h_resolutionPhotonET_EE_

private

Definition at line 179 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

MonitorElement* L1TEGammaOffline::h_resolutionPhotonEta_

private

Definition at line 186 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

MonitorElement* L1TEGammaOffline::h_resolutionPhotonPhi_EB_

private

Definition at line 182 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

MonitorElement* L1TEGammaOffline::h_resolutionPhotonPhi_EB_EE_

private

Definition at line 184 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

MonitorElement* L1TEGammaOffline::h_resolutionPhotonPhi_EE_

private

Definition at line 183 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

MonitorElement* L1TEGammaOffline::h_tagAndProbeMass_

private

Definition at line 121 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and findTagAndProbePair().

dqmoffline::l1t::HistDefinitions L1TEGammaOffline::histDefinitions_

private

Definition at line 116 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and bookPhotonHistos().

std::string L1TEGammaOffline::histFolder_

private

Definition at line 91 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and bookPhotonHistos().

HLTConfigProvider L1TEGammaOffline::hltConfig_

private

Definition at line 112 of file L1TEGammaOffline.h.

Referenced by dqmBeginRun(), and matchesAnHLTObject().

double L1TEGammaOffline::maxDeltaRForHLTMatching_

private

Definition at line 105 of file L1TEGammaOffline.h.

Referenced by matchesAnHLTObject().

double L1TEGammaOffline::maxDeltaRForL1Matching_

private

Definition at line 104 of file L1TEGammaOffline.h.

Referenced by fillElectrons().

std::vector<double> L1TEGammaOffline::photonEfficiencyBins_

private

Definition at line 102 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos().

std::vector<double> L1TEGammaOffline::photonEfficiencyThresholds_

private

Definition at line 101 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

const std::map< std::string, unsigned int > L1TEGammaOffline::PlotConfigNames

static

Initial value:

= {
  {"nVertex", PlotConfig::nVertex},
  {"ETvsET", PlotConfig::ETvsET},
  {"PHIvsPHI", PlotConfig::PHIvsPHI}
}

Definition at line 52 of file L1TEGammaOffline.h.

reco::GsfElectron L1TEGammaOffline::probeElectron_

private

Definition at line 109 of file L1TEGammaOffline.h.

Referenced by fillElectrons(), and findTagAndProbePair().

double L1TEGammaOffline::probeToL1Offset_

private

Definition at line 98 of file L1TEGammaOffline.h.

Referenced by fillElectrons().

math::XYZPoint L1TEGammaOffline::PVPoint_

private

Definition at line 80 of file L1TEGammaOffline.h.

double L1TEGammaOffline::recoToL1TThresholdFactor_

private

Definition at line 106 of file L1TEGammaOffline.h.

Referenced by fillElectrons().

edm::EDGetTokenT<l1t::EGammaBxCollection> L1TEGammaOffline::stage2CaloLayer2EGammaToken_

private

Definition at line 94 of file L1TEGammaOffline.h.

Referenced by fillElectrons(), and fillPhotons().

double L1TEGammaOffline::tagAndProbleInvariantMass_

private

Definition at line 110 of file L1TEGammaOffline.h.

reco::GsfElectron L1TEGammaOffline::tagElectron_

private

Definition at line 108 of file L1TEGammaOffline.h.

Referenced by findTagAndProbePair().

edm::EDGetTokenT<reco::BeamSpot> L1TEGammaOffline::theBSCollection_

private

Definition at line 86 of file L1TEGammaOffline.h.

edm::EDGetTokenT<reco::GsfElectronCollection> L1TEGammaOffline::theGsfElectronCollection_

private

Definition at line 83 of file L1TEGammaOffline.h.

Referenced by fillElectrons().

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

private

Definition at line 84 of file L1TEGammaOffline.h.

Referenced by fillPhotons().

edm::EDGetTokenT<reco::VertexCollection> L1TEGammaOffline::thePVCollection_

private

Definition at line 85 of file L1TEGammaOffline.h.

Referenced by analyze().

trigger::TriggerEvent L1TEGammaOffline::triggerEvent_

private

Definition at line 115 of file L1TEGammaOffline.h.

Referenced by analyze(), and matchesAnHLTObject().

std::vector<unsigned int> L1TEGammaOffline::triggerIndices_

private

Definition at line 113 of file L1TEGammaOffline.h.

Referenced by analyze(), dqmBeginRun(), and matchesAnHLTObject().

edm::EDGetTokenT<trigger::TriggerEvent> L1TEGammaOffline::triggerInputTag_

private

Definition at line 87 of file L1TEGammaOffline.h.

Referenced by analyze().

std::vector<std::string> L1TEGammaOffline::triggerNames_

private

Definition at line 90 of file L1TEGammaOffline.h.

Referenced by dqmBeginRun().

std::string L1TEGammaOffline::triggerProcess_

private

Definition at line 89 of file L1TEGammaOffline.h.

Referenced by dqmBeginRun(), and matchesAnHLTObject().

edm::TriggerResults L1TEGammaOffline::triggerResults_

private

Definition at line 114 of file L1TEGammaOffline.h.

Referenced by analyze(), and matchesAnHLTObject().

edm::EDGetTokenT<edm::TriggerResults> L1TEGammaOffline::triggerResultsInputTag_

private

Definition at line 88 of file L1TEGammaOffline.h.

Referenced by analyze().

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation