L1TEGammaOffline Class Reference

#include <L1TEGammaOffline.h>

Inheritance diagram for L1TEGammaOffline:

Public Types
enum	PlotConfig { nVertex, ETvsET, PHIvsPHI }
Public Types inherited from DQMOneEDAnalyzer<>
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType
Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >
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 DQMOneEDAnalyzer<>
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) override
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
	DQMOneEDAnalyzer ()
void	endRun (edm::Run const &, edm::EventSetup const &) final
void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::Accumulator, Args... >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () 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
std::vector< bool > const &	recordProvenanceList () 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)
TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...
	~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
ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
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::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)
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	dqmEndRun (edm::Run const &run, edm::EventSetup const &eSetup) override
Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...
template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()
template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()
template<Transition Tr = Transition::Event>
auto	produces () noexcept
ProducesCollector	producesCollector ()
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
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)
void	resetItemsToGetFrom (BranchType iType)

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 DQMOneEDAnalyzer<>
edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 38 of file L1TEGammaOffline.h.

Member Enumeration Documentation

PlotConfig

enum L1TEGammaOffline::PlotConfig

Enumerator
nVertex
ETvsET
PHIvsPHI

Definition at line 43 of file L1TEGammaOffline.h.

{ nVertex, ETvsET, PHIvsPHI };

Constructor & Destructor Documentation

L1TEGammaOffline()

L1TEGammaOffline::L1TEGammaOffline

(

const edm::ParameterSet &

ps

)

Definition at line 28 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::~L1TEGammaOffline ( )

override

Definition at line 110 of file L1TEGammaOffline.cc.

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

Member Function Documentation

analyze()

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

overrideprotectedvirtual

Reimplemented from DQMOneEDAnalyzer<>.

Definition at line 143 of file L1TEGammaOffline.cc.

References MillePedeFileConverter_cfg::e, fillElectrons(), dqmoffline::l1t::fillWithinLimits(), 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);
}

bookElectronHistos()

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

private

Definition at line 581 of file L1TEGammaOffline.cc.

References dqmoffline::l1t::HistDefinition::binsX, dqmoffline::l1t::HistDefinition::binsY, dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::NavigatorBase::cd(), deepInspectionElectronThresholds_, efficiencyFolder_, electronEfficiencyBins_, electronEfficiencyThresholds_, L1TEGammaOffline_cfi::ETvsET, h_efficiencyElectronET_EB_EE_pass_, h_efficiencyElectronET_EB_EE_total_, h_efficiencyElectronET_EB_pass_, h_efficiencyElectronET_EB_total_, h_efficiencyElectronET_EE_pass_, h_efficiencyElectronET_EE_total_, h_efficiencyElectronEta_pass_, h_efficiencyElectronEta_total_, h_efficiencyElectronNVertex_pass_, h_efficiencyElectronNVertex_total_, h_efficiencyElectronPhi_pass_, h_efficiencyElectronPhi_total_, h_efficiencyElectronPhi_vs_Eta_pass_, h_efficiencyElectronPhi_vs_Eta_total_, h_L1EGammaEtavsElectronEta_, h_L1EGammaETvsElectronET_EB_, h_L1EGammaETvsElectronET_EB_EE_, h_L1EGammaETvsElectronET_EE_, h_L1EGammaPhivsElectronPhi_EB_, h_L1EGammaPhivsElectronPhi_EB_EE_, h_L1EGammaPhivsElectronPhi_EE_, h_nVertex_, h_resolutionElectronET_EB_, h_resolutionElectronET_EB_EE_, h_resolutionElectronET_EE_, h_resolutionElectronEta_, h_resolutionElectronPhi_EB_, h_resolutionElectronPhi_EB_EE_, h_resolutionElectronPhi_EE_, h_tagAndProbeMass_, histDefinitions_, histFolder_, dqmoffline::l1t::HistDefinition::name, seedmultiplicitymonitor_newtracking_cfi::nBins, dqmoffline::l1t::HistDefinition::nbinsX, dqmoffline::l1t::HistDefinition::nbinsY, L1TEGammaOffline_cfi::nVertex, L1TEGammaOffline_cfi::PHIvsPHI, dqm::implementation::NavigatorBase::setCurrentFolder(), dqm::implementation::IBooker::setScope(), AlCaHLTBitMon_QueryRunRegistry::string, DiMuonV_cfg::threshold, dqmoffline::l1t::HistDefinition::title, to_string(), dqmoffline::l1t::HistDefinition::xmax, dqmoffline::l1t::HistDefinition::xmin, dqmoffline::l1t::HistDefinition::ymax, and dqmoffline::l1t::HistDefinition::ymin.

Referenced by bookHistograms().

                                                                  {
  ibooker.cd();
  ibooker.setCurrentFolder(histFolder_);
  // since there are endRun manipulations.
  ibooker.setScope(MonitorElementData::Scope::RUN);

  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();
}

bookHistograms()

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

overrideprotectedvirtual

Implements DQMOneEDAnalyzer<>.

Definition at line 132 of file L1TEGammaOffline.cc.

References bookElectronHistos().

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

  //book at beginRun
  bookElectronHistos(ibooker);
  // bookPhotonHistos(ibooker);
}

bookPhotonHistos()

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

private

Definition at line 801 of file L1TEGammaOffline.cc.

References dqmoffline::l1t::HistDefinition::binsX, dqmoffline::l1t::HistDefinition::binsY, dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::NavigatorBase::cd(), efficiencyFolder_, L1TEGammaOffline_cfi::ETvsET, 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_, histDefinitions_, histFolder_, seedmultiplicitymonitor_newtracking_cfi::nBins, dqmoffline::l1t::HistDefinition::nbinsX, dqmoffline::l1t::HistDefinition::nbinsY, L1TEGammaOffline_cfi::PHIvsPHI, photonEfficiencyBins_, photonEfficiencyThresholds_, dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, DiMuonV_cfg::threshold, to_string(), dqmoffline::l1t::HistDefinition::xmax, dqmoffline::l1t::HistDefinition::xmin, dqmoffline::l1t::HistDefinition::ymax, and dqmoffline::l1t::HistDefinition::ymin.

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

calcDeltaPhi()

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

private

Distance()

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

private

DistancePhi()

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

private

dqmBeginRun()

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

overrideprotectedvirtual

Reimplemented from DQMOneEDAnalyzer<>.

Definition at line 117 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());
  }
}

dqmEndRun()

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

overrideprotectedvirtual

Reimplemented from DQMOneEDAnalyzer<>.

Definition at line 574 of file L1TEGammaOffline.cc.

References normalise2DHistogramsToBinArea().

                                                                               {
  normalise2DHistogramsToBinArea();
}

fillElectrons()

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

private

Definition at line 180 of file L1TEGammaOffline.cc.

References funct::abs(), BXVector< T >::begin(), deepInspectionElectronThresholds_, reco::deltaPhi(), PbPb_ZMuSkimMuonDPG_cff::deltaR, MillePedeFileConverter_cfg::e, electronEfficiencyThresholds_, BXVector< T >::end(), reco::LeafCandidate::et(), reco::LeafCandidate::eta(), dqmoffline::l1t::fill2DWithinLimits(), dqmoffline::l1t::fillWithinLimits(), findTagAndProbePair(), electronIsolatorFromEffectiveArea_cfi::gsfElectrons, h_efficiencyElectronET_EB_EE_pass_, h_efficiencyElectronET_EB_EE_total_, h_efficiencyElectronET_EB_pass_, h_efficiencyElectronET_EB_total_, h_efficiencyElectronET_EE_pass_, h_efficiencyElectronET_EE_total_, h_efficiencyElectronEta_pass_, h_efficiencyElectronEta_total_, h_efficiencyElectronNVertex_pass_, h_efficiencyElectronNVertex_total_, h_efficiencyElectronPhi_pass_, h_efficiencyElectronPhi_total_, h_efficiencyElectronPhi_vs_Eta_pass_, h_efficiencyElectronPhi_vs_Eta_total_, h_L1EGammaEtavsElectronEta_, h_L1EGammaETvsElectronET_EB_, h_L1EGammaETvsElectronET_EB_EE_, h_L1EGammaETvsElectronET_EE_, h_L1EGammaPhivsElectronPhi_EB_, h_L1EGammaPhivsElectronPhi_EB_EE_, h_L1EGammaPhivsElectronPhi_EE_, h_resolutionElectronET_EB_, h_resolutionElectronET_EB_EE_, h_resolutionElectronET_EE_, h_resolutionElectronEta_, h_resolutionElectronPhi_EB_, h_resolutionElectronPhi_EB_EE_, h_resolutionElectronPhi_EE_, edm::HandleBase::isValid(), LogDebug, maxDeltaRForL1Matching_, HLT_2024v14_cff::minDeltaR, nVertex, reco::LeafCandidate::phi(), probeElectron_, probeToL1Offset_, recoToL1TThresholdFactor_, HLTMuonOfflineAnalyzer_cfi::resolutionEta, HLTMuonOfflineAnalyzer_cfi::resolutionPhi, stage2CaloLayer2EGammaToken_, theGsfElectronCollection_, and DiMuonV_cfg::threshold.

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

fillPhotons()

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

private

Definition at line 458 of file L1TEGammaOffline.cc.

References funct::abs(), BXVector< T >::begin(), reco::deltaPhi(), PbPb_ZMuSkimMuonDPG_cff::deltaR, MillePedeFileConverter_cfg::e, BXVector< T >::end(), reco::LeafCandidate::et(), reco::LeafCandidate::eta(), dqmoffline::l1t::fill2DWithinLimits(), dqmoffline::l1t::fillWithinLimits(), 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, HLT_2024v14_cff::minDeltaR, reco::LeafCandidate::phi(), photonEfficiencyThresholds_, BPHMonitor_cfi::photons, HLTMuonOfflineAnalyzer_cfi::resolutionEta, HLTMuonOfflineAnalyzer_cfi::resolutionPhi, stage2CaloLayer2EGammaToken_, thePhotonCollection_, and DiMuonV_cfg::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);
      }
    }
  }
}

findTagAndProbePair()

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 337 of file L1TEGammaOffline.cc.

References funct::abs(), pwdgSkimBPark_cfi::electrons, dqmoffline::l1t::fillWithinLimits(), h_tagAndProbeMass_, matchesAnHLTObject(), custom_jme_cff::nElectrons, passesLooseEleId(), passesMediumEleId(), probeElectron_, and tagElectron_.

Referenced by fillElectrons().

                                                                                                {
  bool foundBoth(false);
  auto nElectrons = electrons->size();
  if (nElectrons < 2)
    return false;

  for (const auto& tagElectron : *electrons) {
    for (const 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;
}

matchesAnHLTObject()

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

private

Definition at line 445 of file L1TEGammaOffline.cc.

References PVValHelper::eta, dqmoffline::l1t::getFiredTriggerIndices(), dqmoffline::l1t::getHLTFilters(), dqmoffline::l1t::getMatchedTriggerObjects(), dqmoffline::l1t::getTriggerObjects(), dqmoffline::l1t::getTriggerResults(), hltConfig_, maxDeltaRForHLTMatching_, phi, mysort::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();
}

normalise2DHistogramsToBinArea()

void L1TEGammaOffline::normalise2DHistogramsToBinArea ( )

private

Definition at line 946 of file L1TEGammaOffline.cc.

References 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 dqmEndRun().

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

passesLooseEleId()

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 383 of file L1TEGammaOffline.cc.

References funct::abs(), HPSPFTauProducerPuppi_cfi::electron, and EgHLTOffHistBins_cfi::eOverP.

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

passesMediumEleId()

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

private

Definition at line 417 of file L1TEGammaOffline.cc.

References funct::abs(), HPSPFTauProducerPuppi_cfi::electron, and EgHLTOffHistBins_cfi::eOverP.

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

deepInspectionElectronThresholds_

std::vector<double> L1TEGammaOffline::deepInspectionElectronThresholds_

private

Definition at line 90 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

efficiencyFolder_

std::string L1TEGammaOffline::efficiencyFolder_

private

Definition at line 83 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and bookPhotonHistos().

electronEfficiencyBins_

std::vector<double> L1TEGammaOffline::electronEfficiencyBins_

private

Definition at line 88 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos().

electronEfficiencyThresholds_

std::vector<double> L1TEGammaOffline::electronEfficiencyThresholds_

private

Definition at line 87 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronET_EB_EE_pass_

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

private

Definition at line 139 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronET_EB_EE_total_

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

private

Definition at line 150 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronET_EB_pass_

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

private

Definition at line 137 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronET_EB_total_

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

private

Definition at line 148 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronET_EE_pass_

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

private

Definition at line 138 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronET_EE_total_

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

private

Definition at line 149 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronEta_pass_

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

private

Definition at line 142 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronEta_total_

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

private

Definition at line 153 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronNVertex_pass_

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

private

Definition at line 144 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronNVertex_total_

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

private

Definition at line 155 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronPhi_pass_

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

private

Definition at line 143 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronPhi_total_

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

private

Definition at line 154 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronPhi_vs_Eta_pass_

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

private

Definition at line 140 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyElectronPhi_vs_Eta_total_

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

private

Definition at line 151 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_efficiencyPhotonET_EB_EE_pass_

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

private

Definition at line 182 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_efficiencyPhotonET_EB_EE_total_

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

private

Definition at line 188 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_efficiencyPhotonET_EB_pass_

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

private

Definition at line 180 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_efficiencyPhotonET_EB_total_

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

private

Definition at line 186 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_efficiencyPhotonET_EE_pass_

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

private

Definition at line 181 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_efficiencyPhotonET_EE_total_

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

private

Definition at line 187 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_L1EGammaEtavsElectronEta_

MonitorElement* L1TEGammaOffline::h_L1EGammaEtavsElectronEta_

private

Definition at line 123 of file L1TEGammaOffline.h.

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

h_L1EGammaEtavsPhotonEta_

MonitorElement* L1TEGammaOffline::h_L1EGammaEtavsPhotonEta_

private

Definition at line 166 of file L1TEGammaOffline.h.

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

h_L1EGammaETvsElectronET_EB_

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsElectronET_EB_

private

Definition at line 115 of file L1TEGammaOffline.h.

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

h_L1EGammaETvsElectronET_EB_EE_

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsElectronET_EB_EE_

private

Definition at line 117 of file L1TEGammaOffline.h.

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

h_L1EGammaETvsElectronET_EE_

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsElectronET_EE_

private

Definition at line 116 of file L1TEGammaOffline.h.

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

h_L1EGammaETvsPhotonET_EB_

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsPhotonET_EB_

private

Definition at line 158 of file L1TEGammaOffline.h.

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

h_L1EGammaETvsPhotonET_EB_EE_

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsPhotonET_EB_EE_

private

Definition at line 160 of file L1TEGammaOffline.h.

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

h_L1EGammaETvsPhotonET_EE_

MonitorElement* L1TEGammaOffline::h_L1EGammaETvsPhotonET_EE_

private

Definition at line 159 of file L1TEGammaOffline.h.

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

h_L1EGammaPhivsElectronPhi_EB_

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsElectronPhi_EB_

private

Definition at line 119 of file L1TEGammaOffline.h.

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

h_L1EGammaPhivsElectronPhi_EB_EE_

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsElectronPhi_EB_EE_

private

Definition at line 121 of file L1TEGammaOffline.h.

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

h_L1EGammaPhivsElectronPhi_EE_

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsElectronPhi_EE_

private

Definition at line 120 of file L1TEGammaOffline.h.

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

h_L1EGammaPhivsPhotonPhi_EB_

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsPhotonPhi_EB_

private

Definition at line 162 of file L1TEGammaOffline.h.

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

h_L1EGammaPhivsPhotonPhi_EB_EE_

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsPhotonPhi_EB_EE_

private

Definition at line 164 of file L1TEGammaOffline.h.

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

h_L1EGammaPhivsPhotonPhi_EE_

MonitorElement* L1TEGammaOffline::h_L1EGammaPhivsPhotonPhi_EE_

private

Definition at line 163 of file L1TEGammaOffline.h.

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

h_nVertex_

MonitorElement* L1TEGammaOffline::h_nVertex_

private

Definition at line 111 of file L1TEGammaOffline.h.

Referenced by analyze(), and bookElectronHistos().

h_resolutionElectronET_EB_

MonitorElement* L1TEGammaOffline::h_resolutionElectronET_EB_

private

Definition at line 126 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_resolutionElectronET_EB_EE_

MonitorElement* L1TEGammaOffline::h_resolutionElectronET_EB_EE_

private

Definition at line 128 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_resolutionElectronET_EE_

MonitorElement* L1TEGammaOffline::h_resolutionElectronET_EE_

private

Definition at line 127 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_resolutionElectronEta_

MonitorElement* L1TEGammaOffline::h_resolutionElectronEta_

private

Definition at line 134 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_resolutionElectronPhi_EB_

MonitorElement* L1TEGammaOffline::h_resolutionElectronPhi_EB_

private

Definition at line 130 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_resolutionElectronPhi_EB_EE_

MonitorElement* L1TEGammaOffline::h_resolutionElectronPhi_EB_EE_

private

Definition at line 132 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_resolutionElectronPhi_EE_

MonitorElement* L1TEGammaOffline::h_resolutionElectronPhi_EE_

private

Definition at line 131 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and fillElectrons().

h_resolutionPhotonET_EB_

MonitorElement* L1TEGammaOffline::h_resolutionPhotonET_EB_

private

Definition at line 169 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_resolutionPhotonET_EB_EE_

MonitorElement* L1TEGammaOffline::h_resolutionPhotonET_EB_EE_

private

Definition at line 171 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_resolutionPhotonET_EE_

MonitorElement* L1TEGammaOffline::h_resolutionPhotonET_EE_

private

Definition at line 170 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_resolutionPhotonEta_

MonitorElement* L1TEGammaOffline::h_resolutionPhotonEta_

private

Definition at line 177 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_resolutionPhotonPhi_EB_

MonitorElement* L1TEGammaOffline::h_resolutionPhotonPhi_EB_

private

Definition at line 173 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_resolutionPhotonPhi_EB_EE_

MonitorElement* L1TEGammaOffline::h_resolutionPhotonPhi_EB_EE_

private

Definition at line 175 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_resolutionPhotonPhi_EE_

MonitorElement* L1TEGammaOffline::h_resolutionPhotonPhi_EE_

private

Definition at line 174 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

h_tagAndProbeMass_

MonitorElement* L1TEGammaOffline::h_tagAndProbeMass_

private

Definition at line 112 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and findTagAndProbePair().

histDefinitions_

dqmoffline::l1t::HistDefinitions L1TEGammaOffline::histDefinitions_

private

Definition at line 107 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and bookPhotonHistos().

histFolder_

std::string L1TEGammaOffline::histFolder_

private

Definition at line 82 of file L1TEGammaOffline.h.

Referenced by bookElectronHistos(), and bookPhotonHistos().

hltConfig_

HLTConfigProvider L1TEGammaOffline::hltConfig_

private

Definition at line 103 of file L1TEGammaOffline.h.

Referenced by dqmBeginRun(), and matchesAnHLTObject().

maxDeltaRForHLTMatching_

double L1TEGammaOffline::maxDeltaRForHLTMatching_

private

Definition at line 96 of file L1TEGammaOffline.h.

Referenced by matchesAnHLTObject().

maxDeltaRForL1Matching_

double L1TEGammaOffline::maxDeltaRForL1Matching_

private

Definition at line 95 of file L1TEGammaOffline.h.

Referenced by fillElectrons().

photonEfficiencyBins_

std::vector<double> L1TEGammaOffline::photonEfficiencyBins_

private

Definition at line 93 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos().

photonEfficiencyThresholds_

std::vector<double> L1TEGammaOffline::photonEfficiencyThresholds_

private

Definition at line 92 of file L1TEGammaOffline.h.

Referenced by bookPhotonHistos(), and fillPhotons().

PlotConfigNames

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

static

Initial value:

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

Definition at line 45 of file L1TEGammaOffline.h.

probeElectron_

reco::GsfElectron L1TEGammaOffline::probeElectron_

private

Definition at line 100 of file L1TEGammaOffline.h.

Referenced by fillElectrons(), and findTagAndProbePair().

probeToL1Offset_

double L1TEGammaOffline::probeToL1Offset_

private

Definition at line 89 of file L1TEGammaOffline.h.

Referenced by fillElectrons().

PVPoint_

math::XYZPoint L1TEGammaOffline::PVPoint_

private

Definition at line 71 of file L1TEGammaOffline.h.

recoToL1TThresholdFactor_

double L1TEGammaOffline::recoToL1TThresholdFactor_

private

Definition at line 97 of file L1TEGammaOffline.h.

Referenced by fillElectrons().

stage2CaloLayer2EGammaToken_

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

private

Definition at line 85 of file L1TEGammaOffline.h.

Referenced by fillElectrons(), and fillPhotons().

tagAndProbleInvariantMass_

double L1TEGammaOffline::tagAndProbleInvariantMass_

private

Definition at line 101 of file L1TEGammaOffline.h.

tagElectron_

reco::GsfElectron L1TEGammaOffline::tagElectron_

private

Definition at line 99 of file L1TEGammaOffline.h.

Referenced by findTagAndProbePair().

theBSCollection_

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

private

Definition at line 77 of file L1TEGammaOffline.h.

theGsfElectronCollection_

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

private

Definition at line 74 of file L1TEGammaOffline.h.

Referenced by fillElectrons().

thePhotonCollection_

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

private

Definition at line 75 of file L1TEGammaOffline.h.

Referenced by fillPhotons().

thePVCollection_

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

private

Definition at line 76 of file L1TEGammaOffline.h.

Referenced by analyze().

triggerEvent_

trigger::TriggerEvent L1TEGammaOffline::triggerEvent_

private

Definition at line 106 of file L1TEGammaOffline.h.

Referenced by analyze(), and matchesAnHLTObject().

triggerIndices_

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

private

Definition at line 104 of file L1TEGammaOffline.h.

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

triggerInputTag_

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

private

Definition at line 78 of file L1TEGammaOffline.h.

Referenced by analyze().

triggerNames_

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

private

Definition at line 81 of file L1TEGammaOffline.h.

Referenced by dqmBeginRun().

triggerProcess_

std::string L1TEGammaOffline::triggerProcess_

private

Definition at line 80 of file L1TEGammaOffline.h.

Referenced by dqmBeginRun(), and matchesAnHLTObject().

triggerResults_

edm::TriggerResults L1TEGammaOffline::triggerResults_

private

Definition at line 105 of file L1TEGammaOffline.h.

Referenced by analyze(), and matchesAnHLTObject().

triggerResultsInputTag_

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

private

Definition at line 79 of file L1TEGammaOffline.h.

Referenced by analyze().