EgammaCoreTools. More...

#include <PhotonAnalyzer.h>

Inheritance diagram for PhotonAnalyzer:

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

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

	PhotonAnalyzer (const edm::ParameterSet &)

	~PhotonAnalyzer () override

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

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

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

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer ()

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

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

virtual bool	getCanSaveByLumi ()

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Private Member Functions
void	book2DHistoVector (DQMStore::IBooker &, std::vector< std::vector< MonitorElement *> > &toFill, std::string histoType, std::string histoName, std::string title, int xbin, double xmin, double xmax, int ybin=1, double ymin=1, double ymax=2)

void	book3DHistoVector (DQMStore::IBooker &, std::vector< std::vector< std::vector< MonitorElement *> > > &toFill, std::string histoType, std::string histoName, std::string title, int xbin, double xmin, double xmax, int ybin=1, double ymin=1, double ymax=2)

MonitorElement *	bookHisto (DQMStore::IBooker &, std::string histoName, std::string title, int bin, double min, double max)

void	bookHistogramsConversions (DQMStore::IBooker &)

void	bookHistogramsEfficiency (DQMStore::IBooker &)

void	bookHistogramsForHistogramCounts (DQMStore::IBooker &)

void	bookHistogramsInvMass (DQMStore::IBooker &)

void	bookHistogramsPhotons (DQMStore::IBooker &)

void	fill2DHistoVector (std::vector< std::vector< MonitorElement *> > &histoVector, double x, int cut, int type)

void	fill2DHistoVector (std::vector< std::vector< MonitorElement *> > &histoVector, double x, double y, int cut, int type)

void	fill3DHistoVector (std::vector< std::vector< std::vector< MonitorElement *> > > &histoVector, double x, int cut, int type, int part)

void	fill3DHistoVector (std::vector< std::vector< std::vector< MonitorElement *> > > &histoVector, double x, double y, int cut, int type, int part)

void	fillHistogramsForHistogramCounts (DQMStore::IBooker &)

float	phiNormalization (float &a)

bool	photonSelection (const reco::Photon *p)

bool	photonSelectionSlimmed (const reco::Photon *p)

Private Attributes
edm::EDGetTokenT< edm::SortedCollection< EcalRecHit, edm::StrictWeakOrdering< EcalRecHit > > >	barrelRecHit_token_

int	chi2Bin_

double	chi2Max_

double	chi2Min_

std::stringstream	currentFolder_

double	cutStep_

int	dEtaTracksBin_

double	dEtaTracksMax_

double	dEtaTracksMin_

int	dPhiTracksBin_

double	dPhiTracksMax_

double	dPhiTracksMin_

int	eBin_

double	eMax_

double	eMin_

edm::EDGetTokenT< edm::SortedCollection< EcalRecHit, edm::StrictWeakOrdering< EcalRecHit > > >	endcapRecHit_token_

int	eOverPBin_

double	eOverPMax_

double	eOverPMin_

int	etaBin_

double	etaMax_

double	etaMin_

int	etBin_

double	etMax_

double	etMin_

bool	excludeBkgHistos_

std::string	fName_

std::vector< std::vector< MonitorElement * > >	h_chHadIsoBarrel_

std::vector< std::vector< MonitorElement * > >	h_chHadIsoEndcap_

MonitorElement *	h_convEt_Loose_

MonitorElement *	h_convEt_Tight_

MonitorElement *	h_convEta_Loose_

MonitorElement *	h_convEta_Tight_

std::vector< std::vector< MonitorElement * > >	h_convVtxR_

std::vector< std::vector< MonitorElement * > >	h_convVtxRvsZ_

std::vector< std::vector< MonitorElement * > >	h_convVtxYvsX_

std::vector< std::vector< MonitorElement * > >	h_convVtxZ_

std::vector< std::vector< MonitorElement * > >	h_convVtxZEndcap_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_dCotTracks_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_dEtaTracksAtEcal_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_dPhiTracksAtEcal_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_dPhiTracksAtVtx_

std::vector< std::vector< MonitorElement * > >	h_e1x5VsEt_

std::vector< std::vector< MonitorElement * > >	h_e1x5VsEta_

std::vector< std::vector< MonitorElement * > >	h_e2x5VsEt_

std::vector< std::vector< MonitorElement * > >	h_e2x5VsEta_

std::vector< std::vector< MonitorElement * > >	h_ecalSum_

std::vector< std::vector< MonitorElement * > >	h_ecalSumEBarrel_

std::vector< std::vector< MonitorElement * > >	h_ecalSumEEndcap_

std::vector< std::vector< MonitorElement * > >	h_ecalSumVsEt_

std::vector< std::vector< MonitorElement * > >	h_ecalSumVsEta_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_eOverPTracks_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_h1OverE_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_h2OverE_

std::vector< std::vector< MonitorElement * > >	h_hcalSum_

std::vector< std::vector< MonitorElement * > >	h_hcalSumEBarrel_

std::vector< std::vector< MonitorElement * > >	h_hcalSumEEndcap_

std::vector< std::vector< MonitorElement * > >	h_hcalSumVsEt_

std::vector< std::vector< MonitorElement * > >	h_hcalSumVsEta_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_hOverE_

MonitorElement *	h_invMassAllPhotons_

MonitorElement *	h_invMassOneWithTracks_

MonitorElement *	h_invMassPhotonsEBarrel_

MonitorElement *	h_invMassPhotonsEEndcap_

MonitorElement *	h_invMassPhotonsEEndcapEBarrel_

MonitorElement *	h_invMassTwoWithTracks_

MonitorElement *	h_invMassZeroWithTracks_

std::vector< std::vector< MonitorElement * > >	h_maxEXtalOver3x3VsEt_

std::vector< std::vector< MonitorElement * > >	h_maxEXtalOver3x3VsEta_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_nConv_

std::vector< std::vector< MonitorElement * > >	h_nHadIsoBarrel_

std::vector< std::vector< MonitorElement * > >	h_nHadIsoEndcap_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_nPho_

MonitorElement *	h_nRecoVtx_

std::vector< std::vector< MonitorElement * > >	h_nTrackIsolHollow_

std::vector< std::vector< MonitorElement * > >	h_nTrackIsolHollowVsEt_

std::vector< std::vector< MonitorElement * > >	h_nTrackIsolHollowVsEta_

std::vector< std::vector< MonitorElement * > >	h_nTrackIsolSolid_

std::vector< std::vector< MonitorElement * > >	h_nTrackIsolSolidVsEt_

std::vector< std::vector< MonitorElement * > >	h_nTrackIsolSolidVsEta_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoConvE_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoConvEt_

std::vector< std::vector< MonitorElement * > >	h_phoConvEta_

std::vector< std::vector< MonitorElement * > >	h_phoConvEtaForEfficiency_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoConvPhi_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoConvPhiForEfficiency_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoConvR9_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoE_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoEt_

std::vector< std::vector< MonitorElement * > >	h_phoEt_BadChannels_

MonitorElement *	h_phoEt_Loose_

MonitorElement *	h_phoEt_postHLT_

MonitorElement *	h_phoEt_preHLT_

MonitorElement *	h_phoEt_Tight_

std::vector< std::vector< MonitorElement * > >	h_phoEta_

std::vector< std::vector< MonitorElement * > >	h_phoEta_BadChannels_

MonitorElement *	h_phoEta_Loose_

MonitorElement *	h_phoEta_postHLT_

MonitorElement *	h_phoEta_preHLT_

MonitorElement *	h_phoEta_Tight_

MonitorElement *	h_phoEta_Vertex_

std::vector< std::vector< MonitorElement * > >	h_phoIsoBarrel_

std::vector< std::vector< MonitorElement * > >	h_phoIsoEndcap_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoPhi_

std::vector< std::vector< MonitorElement * > >	h_phoPhi_BadChannels_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoSigmaEoverE_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoSigmaIetaIeta_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_pOverETracks_

std::vector< std::vector< MonitorElement * > >	h_r1x5VsEt_

std::vector< std::vector< MonitorElement * > >	h_r1x5VsEta_

std::vector< std::vector< MonitorElement * > >	h_r2x5VsEt_

std::vector< std::vector< MonitorElement * > >	h_r2x5VsEta_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_r9_

std::vector< std::vector< MonitorElement * > >	h_r9VsEt_

std::vector< std::vector< MonitorElement * > >	h_r9VsEta_

std::vector< std::vector< MonitorElement * > >	h_scEta_

std::vector< std::vector< std::vector< MonitorElement * > > >	h_scPhi_

std::vector< std::vector< MonitorElement * > >	h_sigmaIetaIetaVsEta_

std::vector< std::vector< MonitorElement * > >	h_tkChi2_

std::vector< std::vector< MonitorElement * > >	h_trackPtSumHollow_

std::vector< std::vector< MonitorElement * > >	h_trackPtSumHollowVsEt_

std::vector< std::vector< MonitorElement * > >	h_trackPtSumHollowVsEta_

std::vector< std::vector< MonitorElement * > >	h_trackPtSumSolid_

std::vector< std::vector< MonitorElement * > >	h_trackPtSumSolidVsEt_

std::vector< std::vector< MonitorElement * > >	h_trackPtSumSolidVsEta_

std::vector< std::vector< MonitorElement * > >	h_vertexChi2Prob_

int	histo_index_conversions_

int	histo_index_efficiency_

int	histo_index_invMass_

int	histo_index_photons_

int	hOverEBin_

double	hOverEMax_

double	hOverEMin_

double	invMassEtCut_

bool	isHeavyIon_

int	isolationStrength_

bool	minimalSetOfHistos_

double	minPhoEtCut_

int	nEvt_

int	numberBin_

double	numberMax_

double	numberMin_

int	numberOfSteps_

edm::EDGetTokenT< reco::VertexCollection >	offline_pvToken_

std::vector< std::vector< MonitorElement * > >	p_dCotTracksVsEta_

std::vector< std::vector< MonitorElement * > >	p_e1x5VsEt_

std::vector< std::vector< MonitorElement * > >	p_e1x5VsEta_

std::vector< std::vector< MonitorElement * > >	p_e2x5VsEt_

std::vector< std::vector< MonitorElement * > >	p_e2x5VsEta_

std::vector< std::vector< std::vector< MonitorElement * > > >	p_ecalSumVsEt_

std::vector< std::vector< MonitorElement * > >	p_ecalSumVsEta_

std::vector< std::vector< std::vector< MonitorElement * > > >	p_hcalSumVsEt_

std::vector< std::vector< MonitorElement * > >	p_hcalSumVsEta_

std::vector< std::vector< MonitorElement * > >	p_hOverEVsEt_

std::vector< std::vector< MonitorElement * > >	p_hOverEVsEta_

std::vector< std::vector< MonitorElement * > >	p_maxEXtalOver3x3VsEt_

std::vector< std::vector< MonitorElement * > >	p_maxEXtalOver3x3VsEta_

std::vector< std::vector< MonitorElement * > >	p_nHitsVsEta_

std::vector< std::vector< MonitorElement * > >	p_nTrackIsolHollowVsEt_

std::vector< std::vector< MonitorElement * > >	p_nTrackIsolHollowVsEta_

std::vector< std::vector< MonitorElement * > >	p_nTrackIsolSolidVsEt_

std::vector< std::vector< MonitorElement * > >	p_nTrackIsolSolidVsEta_

std::vector< std::vector< std::vector< MonitorElement * > > >	p_phoSigmaEoverEvsNVtx_

std::vector< std::vector< MonitorElement * > >	p_r1x5VsEt_

std::vector< std::vector< MonitorElement * > >	p_r1x5VsEta_

std::vector< std::vector< MonitorElement * > >	p_r2x5VsEt_

std::vector< std::vector< MonitorElement * > >	p_r2x5VsEta_

std::vector< std::vector< MonitorElement * > >	p_r9VsEt_

std::vector< std::vector< MonitorElement * > >	p_r9VsEta_

std::vector< std::vector< MonitorElement * > >	p_sigmaIetaIetaVsEta_

std::vector< std::vector< MonitorElement * > >	p_tkChi2VsEta_

std::vector< std::vector< MonitorElement * > >	p_trackPtSumHollowVsEt_

std::vector< std::vector< MonitorElement * > >	p_trackPtSumHollowVsEta_

std::vector< std::vector< MonitorElement * > >	p_trackPtSumSolidVsEt_

std::vector< std::vector< MonitorElement * > >	p_trackPtSumSolidVsEta_

std::vector< std::string >	parts_

int	phiBin_

double	phiMax_

double	phiMin_

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

edm::EDGetTokenT< edm::ValueMap< bool > >	PhotonIDLoose_token_

edm::EDGetTokenT< edm::ValueMap< bool > >	PhotonIDTight_token_

double	photonMaxEta_

unsigned int	prescaleFactor_

int	r9Bin_

double	r9Max_

double	r9Min_

int	rBin_

int	reducedEtaBin_

int	reducedEtBin_

int	reducedR9Bin_

int	reducedSumBin_

double	rMax_

double	rMin_

int	sigmaIetaBin_

double	sigmaIetaMax_

double	sigmaIetaMin_

bool	standAlone_

int	sumBin_

double	sumMax_

double	sumMin_

MonitorElement *	totalNumberOfHistos_conversionsFolder

MonitorElement *	totalNumberOfHistos_efficiencyFolder

MonitorElement *	totalNumberOfHistos_invMassFolder

MonitorElement *	totalNumberOfHistos_photonsFolder

edm::EDGetTokenT< trigger::TriggerEvent >	triggerEvent_token_

std::vector< std::string >	types_

bool	useBinning_

bool	useTriggerFiltering_

int	xBin_

double	xMax_

double	xMin_

int	yBin_

double	yMax_

double	yMin_

int	zBin_

double	zMax_

double	zMin_

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

typedef dqm::reco::MonitorElement	MonitorElement

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

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

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

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

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

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

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

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

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

EgammaCoreTools.

$Id: PhotonAnalyzer authors: Nancy Marinelli, U. of Notre Dame, US Jamie Antonelli, U. of Notre Dame, US

$Id: PhotonAnalyzer authors: Nancy Marinelli, U. of Notre Dame, US
Jamie Antonelli, U. of Notre Dame, US

Definition at line 97 of file PhotonAnalyzer.h.

Constructor & Destructor Documentation

◆ PhotonAnalyzer()

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

explicit

Definition at line 19 of file PhotonAnalyzer.cc.

References HLT_2022v11_cff::InputTag, and muonDTDigis_cfi::pset.

                                                           {
   fName_ = pset.getParameter<string>("analyzerName");
   prescaleFactor_ = pset.getUntrackedParameter<int>("prescaleFactor", 1);
 
   photon_token_ = consumes<vector<reco::Photon> >(pset.getParameter<edm::InputTag>("phoProducer"));
   barrelRecHit_token_ = consumes<edm::SortedCollection<EcalRecHit, edm::StrictWeakOrdering<EcalRecHit> > >(
       pset.getParameter<edm::InputTag>("barrelRecHitProducer"));
   PhotonIDLoose_token_ = consumes<edm::ValueMap<bool> >(pset.getParameter<edm::InputTag>("photonIDLoose"));
   PhotonIDTight_token_ = consumes<edm::ValueMap<bool> >(pset.getParameter<edm::InputTag>("photonIDTight"));
   endcapRecHit_token_ = consumes<edm::SortedCollection<EcalRecHit, edm::StrictWeakOrdering<EcalRecHit> > >(
       pset.getParameter<edm::InputTag>("endcapRecHitProducer"));
   triggerEvent_token_ = consumes<trigger::TriggerEvent>(pset.getParameter<edm::InputTag>("triggerEvent"));
   offline_pvToken_ = consumes<reco::VertexCollection>(
       pset.getUntrackedParameter<edm::InputTag>("offlinePV", edm::InputTag("offlinePrimaryVertices")));
 
   minPhoEtCut_ = pset.getParameter<double>("minPhoEtCut");
   photonMaxEta_ = pset.getParameter<double>("maxPhoEta");
   invMassEtCut_ = pset.getParameter<double>("invMassEtCut");
   cutStep_ = pset.getParameter<double>("cutStep");
   numberOfSteps_ = pset.getParameter<int>("numberOfSteps");
   useBinning_ = pset.getParameter<bool>("useBinning");
   useTriggerFiltering_ = pset.getParameter<bool>("useTriggerFiltering");
   minimalSetOfHistos_ = pset.getParameter<bool>("minimalSetOfHistos");
   excludeBkgHistos_ = pset.getParameter<bool>("excludeBkgHistos");
   standAlone_ = pset.getParameter<bool>("standAlone");
   isolationStrength_ = pset.getParameter<int>("isolationStrength");
   isHeavyIon_ = pset.getUntrackedParameter<bool>("isHeavyIon", false);
 
   histo_index_photons_ = 0;
   histo_index_conversions_ = 0;
   histo_index_efficiency_ = 0;
   histo_index_invMass_ = 0;
 
   nEvt_ = 0;
 
   // Determining parts...
   parts_.push_back("AllEcal");
   parts_.push_back("Barrel");
   parts_.push_back("Endcaps");
   // ...and types
   types_.push_back("All");
   types_.push_back("GoodCandidate");
   if (!excludeBkgHistos_) {
     types_.push_back("Background");
   }
 
   // Histogram parameters
   etaBin_ = pset.getParameter<int>("etaBin");
   etaMin_ = pset.getParameter<double>("etaMin");
   etaMax_ = pset.getParameter<double>("etaMax");
 
   etBin_ = pset.getParameter<int>("etBin");
   etMin_ = pset.getParameter<double>("etMin");
   etMax_ = pset.getParameter<double>("etMax");
 
   phiBin_ = pset.getParameter<int>("phiBin");
   phiMin_ = pset.getParameter<double>("phiMin");
   phiMax_ = pset.getParameter<double>("phiMax");
 
   eBin_ = pset.getParameter<int>("eBin");
   eMin_ = pset.getParameter<double>("eMin");
   eMax_ = pset.getParameter<double>("eMax");
 
   numberBin_ = pset.getParameter<int>("numberBin");
   numberMin_ = pset.getParameter<double>("numberMin");
   numberMax_ = pset.getParameter<double>("numberMax");
 
   r9Bin_ = pset.getParameter<int>("r9Bin");
   r9Min_ = pset.getParameter<double>("r9Min");
   r9Max_ = pset.getParameter<double>("r9Max");
 
   sigmaIetaBin_ = pset.getParameter<int>("sigmaIetaBin");
   sigmaIetaMin_ = pset.getParameter<double>("sigmaIetaMin");
   sigmaIetaMax_ = pset.getParameter<double>("sigmaIetaMax");
 
   sumBin_ = pset.getParameter<int>("sumBin");
   sumMin_ = pset.getParameter<double>("sumMin");
   sumMax_ = pset.getParameter<double>("sumMax");
 
   hOverEBin_ = pset.getParameter<int>("hOverEBin");
   hOverEMin_ = pset.getParameter<double>("hOverEMin");
   hOverEMax_ = pset.getParameter<double>("hOverEMax");
 
   eOverPBin_ = pset.getParameter<int>("eOverPBin");
   eOverPMin_ = pset.getParameter<double>("eOverPMin");
   eOverPMax_ = pset.getParameter<double>("eOverPMax");
 
   dPhiTracksBin_ = pset.getParameter<int>("dPhiTracksBin");
   dPhiTracksMin_ = pset.getParameter<double>("dPhiTracksMin");
   dPhiTracksMax_ = pset.getParameter<double>("dPhiTracksMax");
 
   dEtaTracksBin_ = pset.getParameter<int>("dEtaTracksBin");
   dEtaTracksMin_ = pset.getParameter<double>("dEtaTracksMin");
   dEtaTracksMax_ = pset.getParameter<double>("dEtaTracksMax");
 
   chi2Bin_ = pset.getParameter<int>("chi2Bin");
   chi2Min_ = pset.getParameter<double>("chi2Min");
   chi2Max_ = pset.getParameter<double>("chi2Max");
 
   zBin_ = pset.getParameter<int>("zBin");
   zMin_ = pset.getParameter<double>("zMin");
   zMax_ = pset.getParameter<double>("zMax");
 
   rBin_ = pset.getParameter<int>("rBin");
   rMin_ = pset.getParameter<double>("rMin");
   rMax_ = pset.getParameter<double>("rMax");
 
   xBin_ = pset.getParameter<int>("xBin");
   xMin_ = pset.getParameter<double>("xMin");
   xMax_ = pset.getParameter<double>("xMax");
 
   yBin_ = pset.getParameter<int>("yBin");
   yMin_ = pset.getParameter<double>("yMin");
   yMax_ = pset.getParameter<double>("yMax");
 
   reducedEtBin_ = etBin_ / 4;
   reducedEtaBin_ = etaBin_ / 4;
   reducedR9Bin_ = r9Bin_ / 4;
   reducedSumBin_ = sumBin_ / 4;
 }

◆ ~PhotonAnalyzer()

PhotonAnalyzer::~PhotonAnalyzer ( )

override

Definition at line 140 of file PhotonAnalyzer.cc.

140 {}

Member Function Documentation

◆ analyze()

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

overridevirtual

End loop over Reco photons

Reimplemented from DQMEDAnalyzer.

Definition at line 1415 of file PhotonAnalyzer.cc.

References edm::SortedCollection< T, SORT >::begin(), reco::Photon::chargedHadronIso(), ChiSquaredProbability(), pwdgSkimBPark_cfi::conversions, reco::Photon::conversions(), PA_MinBiasSkim_cff::cut, reco::deltaR(), PbPb_ZMuSkimMuonDPG_cff::deltaR, deltaRMax, PFJetFilter_cfi::deltaRMin, MillePedeFileConverter_cfg::e, reco::Photon::e1x5(), reco::Photon::e2x5(), reco::Photon::e3x3(), reco::Photon::ecalRecHitSumEtConeDR04(), edm::RefVector< C, T, F >::empty(), edm::SortedCollection< T, SORT >::end(), reco::LeafCandidate::energy(), reco::LeafCandidate::et(), reco::LeafCandidate::eta(), dqmMemoryStats::float, reco::Photon::getCandidateP4type(), reco::Photon::getCorrectedEnergyError(), reco::Photon::hadronicOverEm(), reco::Photon::hasConversionTracks(), reco::Photon::hcalTowerSumEtConeDR04(), mps_fire::i, reco::Photon::isEB(), reco::Photon::isEE(), edm::Ref< C, T, F >::isNonnull(), edm::HandleBase::isValid(), label, reco::Photon::maxEnergyXtal(), reco::Photon::neutralHadronIso(), TrackCollections2monitor_cff::normalizedChi2, reco::Photon::nTrkHollowConeDR04(), reco::Photon::nTrkSolidConeDR04(), TrackCollections2monitor_cff::numberOfValidHits, reco::Photon::p4(), reco::LeafCandidate::phi(), ExoticaDQM_cfi::photonCollection, reco::Photon::photonIso(), PhotonMonitor_cff::photonSelection, edm::Handle< T >::product(), reco::Photon::r1x5(), reco::Photon::r2x5(), reco::Photon::r9(), hitfit::scalar(), reco::Photon::sigmaIetaIeta(), jetUpdater_cfi::sort, mathSSE::sqrt(), reco::Photon::superCluster(), tracks, PDWG_DiPhoton_SD_cff::triggerEvent, reco::Photon::trkSumPtHollowConeDR04(), reco::Photon::trkSumPtSolidConeDR04(), parallelization::uint, and trackerHitRTTI::vector.

                                                                          {
   using namespace edm;
 
   if (nEvt_ % prescaleFactor_)
     return;
   nEvt_++;
   LogInfo(fName_) << "PhotonAnalyzer Analyzing event number: " << e.id() << " Global Counter " << nEvt_ << "\n";
 
   // Get the trigger results
   bool validTriggerEvent = true;
   edm::Handle<trigger::TriggerEvent> triggerEventHandle;
   const trigger::TriggerEvent dummyTE;
   e.getByToken(triggerEvent_token_, triggerEventHandle);
   if (!triggerEventHandle.isValid()) {
     edm::LogInfo(fName_) << "Error! Can't get the product: triggerEvent_" << endl;
     validTriggerEvent = false;
   }
   const trigger::TriggerEvent& triggerEvent(validTriggerEvent ? *(triggerEventHandle.product()) : dummyTE);
 
   // Get the reconstructed photons
   //  bool validPhotons=true;
   Handle<reco::PhotonCollection> photonHandle;
   e.getByToken(photon_token_, photonHandle);
   if (!photonHandle.isValid()) {
     edm::LogInfo(fName_) << "Error! Can't get the product: photon_token_" << endl;
     // validPhotons=false;
   }
   const reco::PhotonCollection& photonCollection(*(photonHandle.product()));
 
   // Get the PhotonId objects
   //  bool validloosePhotonID=true;
   Handle<edm::ValueMap<bool> > loosePhotonFlag;
   e.getByToken(PhotonIDLoose_token_, loosePhotonFlag);
   if (!loosePhotonFlag.isValid()) {
     edm::LogInfo(fName_) << "Error! Can't get the product: PhotonIDLoose_token_" << endl;
     //    validloosePhotonID=false;
   }
   //  edm::ValueMap<bool> dummyLPID;
   //  const edm::ValueMap<bool>& loosePhotonID(validloosePhotonID? *(loosePhotonFlag.product()) : dummyLPID);
 
   //  bool validtightPhotonID=true;
   Handle<edm::ValueMap<bool> > tightPhotonFlag;
   e.getByToken(PhotonIDTight_token_, tightPhotonFlag);
   if (!tightPhotonFlag.isValid()) {
     edm::LogInfo(fName_) << "Error! Can't get the product: PhotonIDTight_token_" << endl;
     //    validtightPhotonID=false;
   }
   //  edm::ValueMap<bool> dummyTPI;
   //  const edm::ValueMap<bool>& tightPhotonID(validtightPhotonID ? *(tightPhotonFlag.product()) : dummyTPI);
 
   edm::Handle<reco::VertexCollection> vtxH;
   if (!isHeavyIon_) {
     e.getByToken(offline_pvToken_, vtxH);
     h_nRecoVtx_->Fill(float(vtxH->size()));
   }
 
   // Create array to hold #photons/event information
   int nPho[100][3][3];
 
   for (int cut = 0; cut != 100; ++cut) {
     for (unsigned int type = 0; type != types_.size(); ++type) {
       for (unsigned int part = 0; part != parts_.size(); ++part) {
         nPho[cut][type][part] = 0;
       }
     }
   }
   // Create array to hold #conversions/event information
   int nConv[100][3][3];
 
   for (int cut = 0; cut != 100; ++cut) {
     for (unsigned int type = 0; type != types_.size(); ++type) {
       for (unsigned int part = 0; part != parts_.size(); ++part) {
         nConv[cut][type][part] = 0;
       }
     }
   }
 
   //Prepare list of photon-related HLT filter names
   vector<int> Keys;
 
   for (uint filterIndex = 0; filterIndex < triggerEvent.sizeFilters();
        ++filterIndex) {  //loop over all trigger filters in event (i.e. filters passed)
     string label = triggerEvent.filterTag(filterIndex).label();
     if (label.find("Photon") != string::npos) {  //get photon-related filters
       for (uint filterKeyIndex = 0; filterKeyIndex < triggerEvent.filterKeys(filterIndex).size();
            ++filterKeyIndex) {  //loop over keys to objects passing this filter
         Keys.push_back(
             triggerEvent.filterKeys(filterIndex)[filterKeyIndex]);  //add keys to a vector for later reference
       }
     }
   }
 
   // sort Keys vector in ascending order
   // and erases duplicate entries from the vector
   sort(Keys.begin(), Keys.end());
   for (uint i = 0; i < Keys.size();) {
     if (i != (Keys.size() - 1)) {
       if (Keys[i] == Keys[i + 1])
         Keys.erase(Keys.begin() + i + 1);
       else
         ++i;
     } else
       ++i;
   }
 
   //We now have a vector of unique keys to TriggerObjects passing a photon-related filter
 
   // old int photonCounter = 0;
 
   for (unsigned int iPho = 0; iPho < photonHandle->size(); iPho++) {
     const reco::Photon* aPho = &photonCollection[iPho];
     //  for( reco::PhotonCollection::const_iterator  iPho = photonCollection.begin(); iPho != photonCollection.end(); iPho++) {
 
     //for HLT efficiency plots
 
     h_phoEta_preHLT_->Fill(aPho->eta());
     h_phoEt_preHLT_->Fill(aPho->et());
 
     double deltaR = 1000.;
     double deltaRMin = 1000.;
     double deltaRMax = 0.05;  //sets deltaR threshold for matching photons to trigger objects
 
     for (vector<int>::const_iterator objectKey = Keys.begin(); objectKey != Keys.end();
          objectKey++) {  //loop over keys to objects that fired photon triggers
 
       deltaR = reco::deltaR(triggerEvent.getObjects()[(*objectKey)].eta(),
                             triggerEvent.getObjects()[(*objectKey)].phi(),
                             aPho->superCluster()->eta(),
                             aPho->superCluster()->phi());
       if (deltaR < deltaRMin)
         deltaRMin = deltaR;
     }
 
     if (deltaRMin > deltaRMax) {  //photon fails delta R cut
       if (useTriggerFiltering_)
         continue;  //throw away photons that haven't passed any photon filters
     }
 
     if (deltaRMin <= deltaRMax) {  //photon passes delta R cut
       h_phoEta_postHLT_->Fill(aPho->eta());
       h_phoEt_postHLT_->Fill(aPho->et());
     }
 
     //    if (aPho->et()  < minPhoEtCut_) continue;
     bool isLoosePhoton(false), isTightPhoton(false);
     if (photonSelection(aPho))
       isLoosePhoton = true;
 
     //find out which part of the Ecal contains the photon
     bool phoIsInBarrel = false;
     bool phoIsInEndcap = false;
     float etaPho = aPho->superCluster()->eta();
     if (fabs(etaPho) < 1.479)
       phoIsInBarrel = true;
     else {
       phoIsInEndcap = true;
     }
 
     int part = 0;
     if (phoIsInBarrel)
       part = 1;
     if (phoIsInEndcap)
       part = 2;
 
     bool isIsolated = false;
     if (isolationStrength_ == 0)
       isIsolated = isLoosePhoton;
     if (isolationStrength_ == 1)
       isIsolated = isTightPhoton;
     if (isolationStrength_ == 2)
       isIsolated = photonSelectionSlimmed(aPho);
 
     int type = 0;
     if (isIsolated)
       type = 1;
     if (!excludeBkgHistos_ && !isIsolated)
       type = 2;
 
     //get rechit collection containing this photon
     bool validEcalRecHits = true;
     edm::Handle<EcalRecHitCollection> ecalRecHitHandle;
     EcalRecHitCollection ecalRecHitCollection;
     if (phoIsInBarrel) {
       // Get handle to barrel rec hits
       e.getByToken(barrelRecHit_token_, ecalRecHitHandle);
       if (!ecalRecHitHandle.isValid()) {
         edm::LogError(fName_) << "Error! Can't get the product: barrelRecHit_token_";
         validEcalRecHits = false;
       }
     } else if (phoIsInEndcap) {
       // Get handle to endcap rec hits
       e.getByToken(endcapRecHit_token_, ecalRecHitHandle);
       if (!ecalRecHitHandle.isValid()) {
         edm::LogError(fName_) << "Error! Can't get the product: endcapRecHit_token";
         validEcalRecHits = false;
       }
     }
     if (validEcalRecHits)
       ecalRecHitCollection = *(ecalRecHitHandle.product());
 
     //if (aPho->isEBEEGap()) continue;  //cut out gap photons
 
     //filling histograms to make isolation efficiencies
     if (isLoosePhoton) {
       h_phoEta_Loose_->Fill(aPho->eta());
       h_phoEt_Loose_->Fill(aPho->et());
     }
     if (isTightPhoton) {
       h_phoEta_Tight_->Fill(aPho->eta());
       h_phoEt_Tight_->Fill(aPho->et());
     }
 
     for (int cut = 0; cut != numberOfSteps_; ++cut) {  //loop over different transverse energy cuts
       double Et = aPho->et();
       bool passesCuts = false;
 
       //sorting the photon into the right Et-dependant folder
       if (useBinning_ && Et > (cut + 1) * cutStep_ && ((Et < (cut + 2) * cutStep_) | (cut == numberOfSteps_ - 1))) {
         passesCuts = true;
       } else if (!useBinning_ && Et > (cut + 1) * cutStep_) {
         passesCuts = true;
       }
 
       if (passesCuts) {
         //filling isolation variable histograms
 
         //tracker isolation variables
         fill2DHistoVector(h_nTrackIsolSolid_, aPho->nTrkSolidConeDR04(), cut, type);
         fill2DHistoVector(h_nTrackIsolHollow_, aPho->nTrkHollowConeDR04(), cut, type);
 
         if (standAlone_)
           fill2DHistoVector(h_nTrackIsolSolidVsEta_, aPho->eta(), aPho->nTrkSolidConeDR04(), cut, type);
         fill2DHistoVector(p_nTrackIsolSolidVsEta_, aPho->eta(), aPho->nTrkSolidConeDR04(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_nTrackIsolHollowVsEta_, aPho->eta(), aPho->nTrkHollowConeDR04(), cut, type);
         fill2DHistoVector(p_nTrackIsolHollowVsEta_, aPho->eta(), aPho->nTrkHollowConeDR04(), cut, type);
 
         if (standAlone_)
           fill2DHistoVector(h_nTrackIsolSolidVsEt_, aPho->et(), aPho->nTrkSolidConeDR04(), cut, type);
         fill2DHistoVector(p_nTrackIsolSolidVsEt_, aPho->et(), aPho->nTrkSolidConeDR04(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_nTrackIsolHollowVsEt_, aPho->et(), aPho->nTrkHollowConeDR04(), cut, type);
         fill2DHistoVector(p_nTrackIsolHollowVsEt_, aPho->et(), aPho->nTrkHollowConeDR04(), cut, type);
 
         fill2DHistoVector(h_trackPtSumSolid_, aPho->trkSumPtSolidConeDR04(), cut, type);
         fill2DHistoVector(h_trackPtSumHollow_, aPho->trkSumPtSolidConeDR04(), cut, type);
 
         if (standAlone_)
           fill2DHistoVector(h_trackPtSumSolidVsEta_, aPho->eta(), aPho->trkSumPtSolidConeDR04(), cut, type);
         fill2DHistoVector(p_trackPtSumSolidVsEta_, aPho->eta(), aPho->trkSumPtSolidConeDR04(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_trackPtSumHollowVsEta_, aPho->eta(), aPho->trkSumPtHollowConeDR04(), cut, type);
         fill2DHistoVector(p_trackPtSumHollowVsEta_, aPho->eta(), aPho->trkSumPtHollowConeDR04(), cut, type);
 
         if (standAlone_)
           fill2DHistoVector(h_trackPtSumSolidVsEt_, aPho->et(), aPho->trkSumPtSolidConeDR04(), cut, type);
         fill2DHistoVector(p_trackPtSumSolidVsEt_, aPho->et(), aPho->trkSumPtSolidConeDR04(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_trackPtSumHollowVsEt_, aPho->et(), aPho->trkSumPtHollowConeDR04(), cut, type);
         fill2DHistoVector(p_trackPtSumHollowVsEt_, aPho->et(), aPho->trkSumPtHollowConeDR04(), cut, type);
         //calorimeter isolation variables
 
         fill2DHistoVector(h_ecalSum_, aPho->ecalRecHitSumEtConeDR04(), cut, type);
         if (aPho->isEB()) {
           fill2DHistoVector(h_ecalSumEBarrel_, aPho->ecalRecHitSumEtConeDR04(), cut, type);
         }
         if (aPho->isEE()) {
           fill2DHistoVector(h_ecalSumEEndcap_, aPho->ecalRecHitSumEtConeDR04(), cut, type);
         }
         if (standAlone_)
           fill2DHistoVector(h_ecalSumVsEta_, aPho->eta(), aPho->ecalRecHitSumEtConeDR04(), cut, type);
         fill2DHistoVector(p_ecalSumVsEta_, aPho->eta(), aPho->ecalRecHitSumEtConeDR04(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_ecalSumVsEt_, aPho->et(), aPho->ecalRecHitSumEtConeDR04(), cut, type);
         fill3DHistoVector(p_ecalSumVsEt_, aPho->et(), aPho->ecalRecHitSumEtConeDR04(), cut, type, part);
 
 
         fill2DHistoVector(h_hcalSum_, aPho->hcalTowerSumEtConeDR04(), cut, type);
         if (aPho->isEB()) {
           fill2DHistoVector(h_hcalSumEBarrel_, aPho->hcalTowerSumEtConeDR04(), cut, type);
         }
         if (aPho->isEE()) {
           fill2DHistoVector(h_hcalSumEEndcap_, aPho->hcalTowerSumEtConeDR04(), cut, type);
         }
         if (standAlone_)
           fill2DHistoVector(h_hcalSumVsEta_, aPho->eta(), aPho->hcalTowerSumEtConeDR04(), cut, type);
         fill2DHistoVector(p_hcalSumVsEta_, aPho->eta(), aPho->hcalTowerSumEtConeDR04(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_hcalSumVsEt_, aPho->et(), aPho->hcalTowerSumEtConeDR04(), cut, type);
         fill3DHistoVector(p_hcalSumVsEt_, aPho->et(), aPho->hcalTowerSumEtConeDR04(), cut, type, part);
 
         fill3DHistoVector(h_hOverE_, aPho->hadronicOverEm(), cut, type, part);
         fill2DHistoVector(p_hOverEVsEta_, aPho->eta(), aPho->hadronicOverEm(), cut, type);
         fill2DHistoVector(p_hOverEVsEt_, aPho->et(), aPho->hadronicOverEm(), cut, type);
 
         fill3DHistoVector(h_h1OverE_, aPho->hadronicOverEm(1), cut, type, part);
         fill3DHistoVector(h_h2OverE_, aPho->hadronicOverEm(2), cut, type, part);
 
         // filling pf isolation variables
         if (aPho->isEB()) {
           fill2DHistoVector(h_phoIsoBarrel_, aPho->photonIso(), cut, type);
           fill2DHistoVector(h_chHadIsoBarrel_, aPho->chargedHadronIso(), cut, type);
           fill2DHistoVector(h_nHadIsoBarrel_, aPho->neutralHadronIso(), cut, type);
         }
         if (aPho->isEE()) {
           fill2DHistoVector(h_phoIsoEndcap_, aPho->photonIso(), cut, type);
           fill2DHistoVector(h_chHadIsoEndcap_, aPho->chargedHadronIso(), cut, type);
           fill2DHistoVector(h_nHadIsoEndcap_, aPho->neutralHadronIso(), cut, type);
         }
 
         //filling photon histograms
         nPho[cut][0][0]++;
         nPho[cut][0][part]++;
         if (type != 0) {
           nPho[cut][type][0]++;
           nPho[cut][type][part]++;
         }
 
         //energy variables
 
         fill3DHistoVector(h_phoE_, aPho->energy(), cut, type, part);
         fill3DHistoVector(h_phoSigmaEoverE_,
                           aPho->getCorrectedEnergyError(aPho->getCandidateP4type()) / aPho->energy(),
                           cut,
                           type,
                           part);
 
         if (!isHeavyIon_)
           fill3DHistoVector(p_phoSigmaEoverEvsNVtx_,
                             float(vtxH->size()),
                             aPho->getCorrectedEnergyError(aPho->getCandidateP4type()) / aPho->energy(),
                             cut,
                             type,
                             part);
 
         fill3DHistoVector(h_phoEt_, aPho->et(), cut, type, part);
 
         //geometrical variables
 
         fill2DHistoVector(h_phoEta_, aPho->eta(), cut, type);
         fill2DHistoVector(h_scEta_, aPho->superCluster()->eta(), cut, type);
 
         fill3DHistoVector(h_phoPhi_, aPho->phi(), cut, type, part);
         fill3DHistoVector(h_scPhi_, aPho->superCluster()->phi(), cut, type, part);
 
         //shower shape variables
 
         fill3DHistoVector(h_r9_, aPho->r9(), cut, type, part);
         if (standAlone_)
           fill2DHistoVector(h_r9VsEta_, aPho->eta(), aPho->r9(), cut, type);
         fill2DHistoVector(p_r9VsEta_, aPho->eta(), aPho->r9(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_r9VsEt_, aPho->et(), aPho->r9(), cut, type);
         fill2DHistoVector(p_r9VsEt_, aPho->et(), aPho->r9(), cut, type);
 
         if (standAlone_)
           fill2DHistoVector(h_e1x5VsEta_, aPho->eta(), aPho->e1x5(), cut, type);
         fill2DHistoVector(p_e1x5VsEta_, aPho->eta(), aPho->e1x5(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_e1x5VsEt_, aPho->et(), aPho->e1x5(), cut, type);
         fill2DHistoVector(p_e1x5VsEt_, aPho->et(), aPho->e1x5(), cut, type);
 
         if (standAlone_)
           fill2DHistoVector(h_e2x5VsEta_, aPho->eta(), aPho->e2x5(), cut, type);
         fill2DHistoVector(p_e2x5VsEta_, aPho->eta(), aPho->e2x5(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_e2x5VsEt_, aPho->et(), aPho->e2x5(), cut, type);
         fill2DHistoVector(p_e2x5VsEt_, aPho->et(), aPho->e2x5(), cut, type);
 
         if (standAlone_)
           fill2DHistoVector(h_maxEXtalOver3x3VsEta_, aPho->eta(), aPho->maxEnergyXtal() / aPho->e3x3(), cut, type);
         fill2DHistoVector(p_maxEXtalOver3x3VsEta_, aPho->eta(), aPho->maxEnergyXtal() / aPho->e3x3(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_maxEXtalOver3x3VsEt_, aPho->et(), aPho->maxEnergyXtal() / aPho->e3x3(), cut, type);
         fill2DHistoVector(p_maxEXtalOver3x3VsEt_, aPho->et(), aPho->maxEnergyXtal() / aPho->e3x3(), cut, type);
 
         if (standAlone_)
           fill2DHistoVector(h_r1x5VsEta_, aPho->eta(), aPho->r1x5(), cut, type);
         fill2DHistoVector(p_r1x5VsEta_, aPho->eta(), aPho->r1x5(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_r1x5VsEt_, aPho->et(), aPho->r1x5(), cut, type);
         fill2DHistoVector(p_r1x5VsEt_, aPho->et(), aPho->r1x5(), cut, type);
 
         if (standAlone_)
           fill2DHistoVector(h_r2x5VsEta_, aPho->eta(), aPho->r2x5(), cut, type);
         fill2DHistoVector(p_r2x5VsEta_, aPho->eta(), aPho->r2x5(), cut, type);
         if (standAlone_)
           fill2DHistoVector(h_r2x5VsEt_, aPho->et(), aPho->r2x5(), cut, type);
         fill2DHistoVector(p_r2x5VsEt_, aPho->et(), aPho->r2x5(), cut, type);
 
         fill3DHistoVector(h_phoSigmaIetaIeta_, aPho->sigmaIetaIeta(), cut, type, part);
         if (standAlone_)
           fill2DHistoVector(h_sigmaIetaIetaVsEta_, aPho->eta(), aPho->sigmaIetaIeta(), cut, type);
         fill2DHistoVector(p_sigmaIetaIetaVsEta_, aPho->eta(), aPho->sigmaIetaIeta(), cut, type);
 
         //filling histograms for photons containing a bad ECAL channel
         bool atLeastOneDeadChannel = false;
         for (reco::CaloCluster_iterator bcIt = aPho->superCluster()->clustersBegin();
              bcIt != aPho->superCluster()->clustersEnd();
              ++bcIt) {  //loop over basic clusters in SC
           for (vector<pair<DetId, float> >::const_iterator rhIt = (*bcIt)->hitsAndFractions().begin();
                rhIt != (*bcIt)->hitsAndFractions().end();
                ++rhIt) {  //loop over rec hits in basic cluster
 
             for (EcalRecHitCollection::const_iterator it = ecalRecHitCollection.begin();
                  it != ecalRecHitCollection.end();
                  ++it) {                        //loop over all rec hits to find the right ones
               if (rhIt->first == (*it).id()) {  //found the matching rechit
                 if ((*it).recoFlag() == 9) {    //has a bad channel
                   atLeastOneDeadChannel = true;
                   break;
                 }
               }
             }
           }
         }
         if (atLeastOneDeadChannel) {
           fill2DHistoVector(h_phoPhi_BadChannels_, aPho->phi(), cut, type);
           fill2DHistoVector(h_phoEta_BadChannels_, aPho->eta(), cut, type);
           fill2DHistoVector(h_phoEt_BadChannels_, aPho->et(), cut, type);
         }
 
         // filling conversion-related histograms
         if (aPho->hasConversionTracks()) {
           nConv[cut][0][0]++;
           nConv[cut][0][part]++;
           nConv[cut][type][0]++;
           nConv[cut][type][part]++;
         }
 
         //loop over conversions (don't forget, we're still inside the photon loop,
         // i.e. these are all the conversions for this ONE photon, not for all the photons in the event)
         reco::ConversionRefVector conversions = aPho->conversions();
         for (unsigned int iConv = 0; iConv < conversions.size(); iConv++) {
           reco::ConversionRef aConv = conversions[iConv];
 
           if (aConv->nTracks() < 2)
             continue;
 
           //fill histogram for denominator of vertex reconstruction efficiency plot
           if (cut == 0)
             h_phoEta_Vertex_->Fill(aConv->refittedPairMomentum().eta());
 
           if (!(aConv->conversionVertex().isValid()))
             continue;
 
           float chi2Prob = ChiSquaredProbability(aConv->conversionVertex().chi2(), aConv->conversionVertex().ndof());
 
           if (chi2Prob < 0.0005)
             continue;
 
           fill2DHistoVector(h_vertexChi2Prob_, chi2Prob, cut, type);
 
           fill3DHistoVector(h_phoConvE_, aPho->energy(), cut, type, part);
           fill3DHistoVector(h_phoConvEt_, aPho->et(), cut, type, part);
           fill3DHistoVector(h_phoConvR9_, aPho->r9(), cut, type, part);
 
           if (cut == 0 && isLoosePhoton) {
             h_convEta_Loose_->Fill(aPho->eta());
             h_convEt_Loose_->Fill(aPho->et());
           }
           if (cut == 0 && isTightPhoton) {
             h_convEta_Tight_->Fill(aPho->eta());
             h_convEt_Tight_->Fill(aPho->et());
           }
 
           fill2DHistoVector(h_phoConvEta_, aConv->refittedPairMomentum().eta(), cut, type);
           fill3DHistoVector(h_phoConvPhi_, aConv->refittedPairMomentum().phi(), cut, type, part);
 
           //we use the photon position because we'll be dividing it by a photon histogram (not a conversion histogram)
           fill2DHistoVector(h_phoConvEtaForEfficiency_, aPho->eta(), cut, type);
           fill3DHistoVector(h_phoConvPhiForEfficiency_, aPho->phi(), cut, type, part);
 
           //vertex histograms
           double convR = sqrt(aConv->conversionVertex().position().perp2());
           double scalar = aConv->conversionVertex().position().x() * aConv->refittedPairMomentum().x() +
                           aConv->conversionVertex().position().y() * aConv->refittedPairMomentum().y();
           if (scalar < 0)
             convR = -convR;
 
           fill2DHistoVector(h_convVtxRvsZ_,
                             aConv->conversionVertex().position().z(),
                             convR,
                             cut,
                             type);  //trying to "see" R-Z view of tracker
           fill2DHistoVector(h_convVtxZ_, aConv->conversionVertex().position().z(), cut, type);
 
           if (fabs(aPho->eta()) > 1.5) {  //trying to "see" tracker endcaps
             fill2DHistoVector(h_convVtxZEndcap_, aConv->conversionVertex().position().z(), cut, type);
           } else if (fabs(aPho->eta()) < 1) {  //trying to "see" tracker barrel
             fill2DHistoVector(h_convVtxR_, convR, cut, type);
             fill2DHistoVector(h_convVtxYvsX_,
                               aConv->conversionVertex().position().x(),
                               aConv->conversionVertex().position().y(),
                               cut,
                               type);
           }
 
           const std::vector<edm::RefToBase<reco::Track> > tracks = aConv->tracks();
 
           for (unsigned int i = 0; i < tracks.size(); i++) {
             fill2DHistoVector(h_tkChi2_, tracks[i]->normalizedChi2(), cut, type);
             fill2DHistoVector(p_tkChi2VsEta_, aPho->eta(), tracks[i]->normalizedChi2(), cut, type);
             fill2DHistoVector(p_dCotTracksVsEta_, aPho->eta(), aConv->pairCotThetaSeparation(), cut, type);
             fill2DHistoVector(p_nHitsVsEta_, aPho->eta(), float(tracks[i]->numberOfValidHits()), cut, type);
           }
 
           //calculating delta eta and delta phi of the two tracks
 
           float DPhiTracksAtVtx = -99;
           float dPhiTracksAtEcal = -99;
           float dEtaTracksAtEcal = -99;
 
           float phiTk1 = aConv->tracksPin()[0].phi();
           float phiTk2 = aConv->tracksPin()[1].phi();
           DPhiTracksAtVtx = phiTk1 - phiTk2;
           DPhiTracksAtVtx = phiNormalization(DPhiTracksAtVtx);
 
           if (!aConv->bcMatchingWithTracks().empty() && aConv->bcMatchingWithTracks()[0].isNonnull() &&
               aConv->bcMatchingWithTracks()[1].isNonnull()) {
             float recoPhi1 = aConv->ecalImpactPosition()[0].phi();
             float recoPhi2 = aConv->ecalImpactPosition()[1].phi();
             float recoEta1 = aConv->ecalImpactPosition()[0].eta();
             float recoEta2 = aConv->ecalImpactPosition()[1].eta();
 
             recoPhi1 = phiNormalization(recoPhi1);
             recoPhi2 = phiNormalization(recoPhi2);
 
             dPhiTracksAtEcal = recoPhi1 - recoPhi2;
             dPhiTracksAtEcal = phiNormalization(dPhiTracksAtEcal);
             dEtaTracksAtEcal = recoEta1 - recoEta2;
           }
 
           fill3DHistoVector(h_dPhiTracksAtVtx_, DPhiTracksAtVtx, cut, type, part);
           fill3DHistoVector(h_dPhiTracksAtEcal_, fabs(dPhiTracksAtEcal), cut, type, part);
           fill3DHistoVector(h_dEtaTracksAtEcal_, dEtaTracksAtEcal, cut, type, part);
           fill3DHistoVector(h_eOverPTracks_, aConv->EoverPrefittedTracks(), cut, type, part);
           fill3DHistoVector(h_pOverETracks_, 1. / aConv->EoverPrefittedTracks(), cut, type, part);
           fill3DHistoVector(h_dCotTracks_, aConv->pairCotThetaSeparation(), cut, type, part);
         }  //end loop over conversions
       }    //end loop over photons passing cuts
     }      //end loop over transverse energy cuts
 
     //make invariant mass plots
 
     if (isIsolated && aPho->et() >= invMassEtCut_) {
       for (unsigned int iPho2 = iPho + 1; iPho2 < photonHandle->size(); iPho2++) {
         const reco::Photon* aPho2 = &photonCollection[iPho2];
 
         //      for (reco::PhotonCollection::const_iterator iPho2=iPho+1; iPho2!=photonCollection.end(); iPho2++){
 
         //  edm::Ref<reco::PhotonCollection> photonref2(photonHandle, photonCounter); //note: it's correct to use photonCounter and not photonCounter+1
         //since it has already been incremented earlier
 
         bool isTightPhoton2(false), isLoosePhoton2(false);
         if (photonSelection(aPho2))
           isLoosePhoton2 = true;
 
         // Old if ( !isHeavyIon_ ) {
         //  isTightPhoton2 = (tightPhotonID)[aPho2];
         // isLoosePhoton2 = (loosePhotonID)[aPho2];
         //  }
 
         bool isIsolated2 = false;
         if (isolationStrength_ == 0)
           isIsolated2 = isLoosePhoton2;
         if (isolationStrength_ == 1)
           isIsolated2 = isTightPhoton2;
         if (isolationStrength_ == 2)
           isIsolated2 = photonSelectionSlimmed(aPho2);
 
         reco::ConversionRefVector conversions = aPho->conversions();
         reco::ConversionRefVector conversions2 = aPho2->conversions();
 
         if (isIsolated2 && aPho2->et() >= invMassEtCut_) {
           math::XYZTLorentzVector p12 = aPho->p4() + aPho2->p4();
           float gamgamMass2 = p12.Dot(p12);
 
           h_invMassAllPhotons_->Fill(sqrt(gamgamMass2));
           if (aPho->isEB() && aPho2->isEB()) {
             h_invMassPhotonsEBarrel_->Fill(sqrt(gamgamMass2));
           } else if (aPho->isEE() && aPho2->isEE()) {
             h_invMassPhotonsEEndcap_->Fill(sqrt(gamgamMass2));
           } else {
             h_invMassPhotonsEEndcapEBarrel_->Fill(sqrt(gamgamMass2));
           }
 
           if (!conversions.empty() && conversions[0]->nTracks() >= 2) {
             if (!conversions2.empty() && conversions2[0]->nTracks() >= 2)
               h_invMassTwoWithTracks_->Fill(sqrt(gamgamMass2));
             else
               h_invMassOneWithTracks_->Fill(sqrt(gamgamMass2));
           } else if (!conversions2.empty() && conversions2[0]->nTracks() >= 2)
             h_invMassOneWithTracks_->Fill(sqrt(gamgamMass2));
           else
             h_invMassZeroWithTracks_->Fill(sqrt(gamgamMass2));
         }
       }
     }
   }  
 
   //filling number of photons/conversions per event histograms
   for (int cut = 0; cut != numberOfSteps_; ++cut) {
     for (uint type = 0; type != types_.size(); ++type) {
       for (uint part = 0; part != parts_.size(); ++part) {
         h_nPho_[cut][type][part]->Fill(float(nPho[cut][type][part]));
         h_nConv_[cut][type][part]->Fill(float(nConv[cut][type][part]));
       }
     }
   }
 }  //End of Analyze method

◆ book2DHistoVector()

void PhotonAnalyzer::book2DHistoVector	(	DQMStore::IBooker &	,
		std::vector< std::vector< MonitorElement *> > &	toFill,
		std::string	histoType,
		std::string	histoName,
		std::string	title,
		int	xbin,
		double	xmin,
		double	xmax,
		int	ybin = `1`,
		double	ymin = `1`,
		double	ymax = `2`
	)

private

Definition at line 1253 of file PhotonAnalyzer.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::IBooker::bookProfile(), gather_cfg::cout, PA_MinBiasSkim_cff::cut, HltBtagPostValidation_cff::histoName, CalibrationSummaryClient_cfi::kind, dqm::implementation::NavigatorBase::pwd(), dqm::implementation::NavigatorBase::setCurrentFolder(), runGCPTkAlMap::title, parallelization::uint, TrackerOfflineValidation_Dqm_cff::xmax, TrackerOfflineValidation_Dqm_cff::xmin, L1TOccupancyClient_cfi::ymax, and L1TOccupancyClient_cfi::ymin.

                                                     {
   int histo_index = 0;
 
   vector<MonitorElement*> temp1DVector;
 
   //determining which folder we're in
   bool conversionPlot = false;
   if (iBooker.pwd().find("Conversions") != string::npos)
     conversionPlot = true;
   bool TwoDPlot = false;
   if (histoName.find("2D") != string::npos)
     TwoDPlot = true;
 
   if (conversionPlot) {
     histo_index_conversions_++;
     histo_index = histo_index_conversions_;
   } else {
     histo_index_photons_++;
     histo_index = histo_index_photons_;
   }
 
   stringstream histo_number_stream;
   histo_number_stream << "h_";
   if (histo_index < 10)
     histo_number_stream << "0";
   histo_number_stream << histo_index << "_";
 
   for (int cut = 0; cut != numberOfSteps_; ++cut) {       //looping over Et cut values
     for (uint type = 0; type != types_.size(); ++type) {  //looping over isolation type
       currentFolder_.str("");
       currentFolder_ << "Egamma/" + fName_ + "/" << types_[type] << "Photons/Et above " << (cut + 1) * cutStep_
                      << " GeV";
       if (conversionPlot)
         currentFolder_ << "/Conversions";
 
       iBooker.setCurrentFolder(currentFolder_.str());
 
       string kind;
       if (conversionPlot)
         kind = " Conversions: ";
       else
         kind = " Photons: ";
 
       if (histoType == "1D")
         temp1DVector.push_back(
             iBooker.book1D(histo_number_stream.str() + histoName, types_[type] + kind + title, xbin, xmin, xmax));
       else if (histoType == "2D") {
         if ((TwoDPlot && type == 0) || !TwoDPlot) {  //only book the 2D plots in the "AllPhotons" folder
           temp1DVector.push_back(iBooker.book2D(
               histo_number_stream.str() + histoName, types_[type] + kind + title, xbin, xmin, xmax, ybin, ymin, ymax));
         }
       } else if (histoType == "Profile")
         temp1DVector.push_back(iBooker.bookProfile(
             histo_number_stream.str() + histoName, types_[type] + kind + title, xbin, xmin, xmax, ybin, ymin, ymax, ""));
       else
         cout << "bad histoType\n";
     }
 
     temp2DVector.push_back(temp1DVector);
     temp1DVector.clear();
   }
 }

◆ book3DHistoVector()

void PhotonAnalyzer::book3DHistoVector	(	DQMStore::IBooker &	,
		std::vector< std::vector< std::vector< MonitorElement *> > > &	toFill,
		std::string	histoType,
		std::string	histoName,
		std::string	title,
		int	xbin,
		double	xmin,
		double	xmax,
		int	ybin = `1`,
		double	ymin = `1`,
		double	ymax = `2`
	)

private

Definition at line 1326 of file PhotonAnalyzer.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::IBooker::bookProfile(), gather_cfg::cout, PA_MinBiasSkim_cff::cut, HltBtagPostValidation_cff::histoName, CalibrationSummaryClient_cfi::kind, dqm::implementation::NavigatorBase::pwd(), dqm::implementation::NavigatorBase::setCurrentFolder(), runGCPTkAlMap::title, parallelization::uint, TrackerOfflineValidation_Dqm_cff::xmax, TrackerOfflineValidation_Dqm_cff::xmin, L1TOccupancyClient_cfi::ymax, and L1TOccupancyClient_cfi::ymin.

                                                     {
   int histo_index = 0;
 
   vector<MonitorElement*> temp1DVector;
   vector<vector<MonitorElement*> > temp2DVector;
 
   //determining which folder we're in
   bool conversionPlot = false;
   if (iBooker.pwd().find("Conversions") != string::npos)
     conversionPlot = true;
 
   if (conversionPlot) {
     histo_index_conversions_++;
     histo_index = histo_index_conversions_;
   } else {
     histo_index_photons_++;
     histo_index = histo_index_photons_;
   }
 
   stringstream histo_number_stream;
   histo_number_stream << "h_";
   if (histo_index < 10)
     histo_number_stream << "0";
   histo_number_stream << histo_index << "_";
 
   for (int cut = 0; cut != numberOfSteps_; ++cut) {         //looping over Et cut values
     for (uint type = 0; type != types_.size(); ++type) {    //looping over isolation type
       for (uint part = 0; part != parts_.size(); ++part) {  //looping over different parts of the ecal
         currentFolder_.str("");
         currentFolder_ << "Egamma/" + fName_ + "/" << types_[type] << "Photons/Et above " << (cut + 1) * cutStep_
                        << " GeV";
         if (conversionPlot)
           currentFolder_ << "/Conversions";
         iBooker.setCurrentFolder(currentFolder_.str());
 
         string kind;
         if (conversionPlot)
           kind = " Conversions: ";
         else
           kind = " Photons: ";
 
         if (histoType == "1D")
           temp1DVector.push_back(iBooker.book1D(histo_number_stream.str() + histoName + parts_[part],
                                                 types_[type] + kind + parts_[part] + ": " + title,
                                                 xbin,
                                                 xmin,
                                                 xmax));
         else if (histoType == "2D")
           temp1DVector.push_back(iBooker.book2D(histo_number_stream.str() + histoName + parts_[part],
                                                 types_[type] + kind + parts_[part] + ": " + title,
                                                 xbin,
                                                 xmin,
                                                 xmax,
                                                 ybin,
                                                 ymin,
                                                 ymax));
         else if (histoType == "Profile")
           temp1DVector.push_back(iBooker.bookProfile(histo_number_stream.str() + histoName + parts_[part],
                                                      types_[type] + kind + parts_[part] + ": " + title,
                                                      xbin,
                                                      xmin,
                                                      xmax,
                                                      ybin,
                                                      ymin,
                                                      ymax,
                                                      ""));
         else
           cout << "bad histoType\n";
       }
       temp2DVector.push_back(temp1DVector);
       temp1DVector.clear();
     }
     temp3DVector.push_back(temp2DVector);
     temp2DVector.clear();
   }
 }

◆ bookHisto()

PhotonAnalyzer::MonitorElement * PhotonAnalyzer::bookHisto	(	DQMStore::IBooker &	,
		std::string	histoName,
		std::string	title,
		int	bin,
		double	min,
		double	max
	)

private

Definition at line 1230 of file PhotonAnalyzer.cc.

References newFWLiteAna::bin, dqm::implementation::IBooker::book1D(), HltBtagPostValidation_cff::histoName, SiStripPI::max, SiStripPI::min, dqm::implementation::NavigatorBase::pwd(), and runGCPTkAlMap::title.

                                                                                                {
   int histo_index = 0;
   stringstream histo_number_stream;
 
   //determining which folder we're in
   if (iBooker.pwd().find("InvMass") != string::npos) {
     histo_index_invMass_++;
     histo_index = histo_index_invMass_;
   }
   if (iBooker.pwd().find("Efficiencies") != string::npos) {
     histo_index_efficiency_++;
     histo_index = histo_index_efficiency_;
   }
 
   histo_number_stream << "h_";
   if (histo_index < 10)
     histo_number_stream << "0";
   histo_number_stream << histo_index;
 
   return iBooker.book1D(histo_number_stream.str() + "_" + histoName, title, bin, min, max);
 }

◆ bookHistograms()

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 142 of file PhotonAnalyzer.cc.

                                                             {
   bookHistogramsForHistogramCounts(iBooker);
 
   bookHistogramsEfficiency(iBooker);
   bookHistogramsInvMass(iBooker);
   bookHistogramsPhotons(iBooker);
   bookHistogramsConversions(iBooker);
 
   fillHistogramsForHistogramCounts(iBooker);
 }

◆ bookHistogramsConversions()

void PhotonAnalyzer::bookHistogramsConversions ( DQMStore::IBooker & iBooker )

private

Definition at line 1095 of file PhotonAnalyzer.cc.

References dqm::implementation::NavigatorBase::setCurrentFolder().

                                                                        {
   // Set folder
   iBooker.setCurrentFolder("Egamma/" + fName_ + "/AllPhotons/Et Above 0 GeV/Conversions");
 
   //ENERGY VARIABLES
   book3DHistoVector(iBooker, h_phoConvE_, "1D", "phoConvE", "E;E (GeV)", eBin_, eMin_, eMax_);
   book3DHistoVector(iBooker, h_phoConvEt_, "1D", "phoConvEt", "E_{T};E_{T} (GeV)", etBin_, etMin_, etMax_);
 
   //GEOMETRICAL VARIABLES
   book2DHistoVector(iBooker, h_phoConvEta_, "1D", "phoConvEta", "#eta;#eta", etaBin_, etaMin_, etaMax_);
   book3DHistoVector(iBooker, h_phoConvPhi_, "1D", "phoConvPhi", "#phi;#phi", phiBin_, phiMin_, phiMax_);
 
   //NUMBER OF PHOTONS
   book3DHistoVector(iBooker,
                     h_nConv_,
                     "1D",
                     "nConv",
                     "Number Of Conversions per Event ;# conversions",
                     numberBin_,
                     numberMin_,
                     numberMax_);
 
   //SHOWER SHAPE VARIABLES
   book3DHistoVector(iBooker, h_phoConvR9_, "1D", "phoConvR9", "R9;R9", r9Bin_, r9Min_, r9Max_);
 
   //TRACK RELATED VARIABLES
   book3DHistoVector(iBooker, h_eOverPTracks_, "1D", "eOverPTracks", "E/P;E/P", eOverPBin_, eOverPMin_, eOverPMax_);
   book3DHistoVector(iBooker, h_pOverETracks_, "1D", "pOverETracks", "P/E;P/E", eOverPBin_, eOverPMin_, eOverPMax_);
   book3DHistoVector(iBooker,
                     h_dPhiTracksAtVtx_,
                     "1D",
                     "dPhiTracksAtVtx",
                     "#Delta#phi of Tracks at Vertex;#Delta#phi",
                     dPhiTracksBin_,
                     dPhiTracksMin_,
                     dPhiTracksMax_);
   book3DHistoVector(iBooker,
                     h_dPhiTracksAtEcal_,
                     "1D",
                     "dPhiTracksAtEcal",
                     "Abs(#Delta#phi) of Tracks at Ecal;#Delta#phi",
                     dPhiTracksBin_,
                     0.,
                     dPhiTracksMax_);
   book3DHistoVector(iBooker,
                     h_dEtaTracksAtEcal_,
                     "1D",
                     "dEtaTracksAtEcal",
                     "#Delta#eta of Tracks at Ecal;#Delta#eta",
                     dEtaTracksBin_,
                     dEtaTracksMin_,
                     dEtaTracksMax_);
   book3DHistoVector(iBooker,
                     h_dCotTracks_,
                     "1D",
                     "dCotTracks",
                     "#Deltacot(#theta) of Tracks;#Deltacot(#theta)",
                     dEtaTracksBin_,
                     dEtaTracksMin_,
                     dEtaTracksMax_);
   book2DHistoVector(iBooker,
                     p_dCotTracksVsEta_,
                     "Profile",
                     "dCotTracksVsEta",
                     "Avg #Deltacot(#theta) of Tracks vs #eta;#eta;#Deltacot(#theta)",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     dEtaTracksBin_,
                     dEtaTracksMin_,
                     dEtaTracksMax_);
   book2DHistoVector(iBooker,
                     p_nHitsVsEta_,
                     "Profile",
                     "nHitsVsEta",
                     "Avg Number of Hits per Track vs #eta;#eta;# hits",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     etaBin_,
                     0,
                     16);
   book2DHistoVector(
       iBooker, h_tkChi2_, "1D", "tkChi2", "#chi^{2} of Track Fitting;#chi^{2}", chi2Bin_, chi2Min_, chi2Max_);
   book2DHistoVector(iBooker,
                     p_tkChi2VsEta_,
                     "Profile",
                     "tkChi2VsEta",
                     "Avg #chi^{2} of Track Fitting vs #eta;#eta;#chi^{2}",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     chi2Bin_,
                     chi2Min_,
                     chi2Max_);
 
   //VERTEX RELATED VARIABLES
   book2DHistoVector(iBooker,
                     h_convVtxRvsZ_,
                     "2D",
                     "convVtxRvsZ",
                     "Vertex Position;Z (cm);R (cm)",
                     500,
                     zMin_,
                     zMax_,
                     rBin_,
                     rMin_,
                     rMax_);
   book2DHistoVector(
       iBooker, h_convVtxZEndcap_, "1D", "convVtxZEndcap", "Vertex Position: #eta > 1.5;Z (cm)", zBin_, zMin_, zMax_);
   book2DHistoVector(iBooker, h_convVtxZ_, "1D", "convVtxZ", "Vertex Position;Z (cm)", zBin_, zMin_, zMax_);
   book2DHistoVector(iBooker, h_convVtxR_, "1D", "convVtxR", "Vertex Position: #eta < 1;R (cm)", rBin_, rMin_, rMax_);
   book2DHistoVector(iBooker,
                     h_convVtxYvsX_,
                     "2D",
                     "convVtxYvsX",
                     "Vertex Position: #eta < 1;X (cm);Y (cm)",
                     xBin_,
                     xMin_,
                     xMax_,
                     yBin_,
                     yMin_,
                     yMax_);
   book2DHistoVector(iBooker,
                     h_vertexChi2Prob_,
                     "1D",
                     "vertexChi2Prob",
                     "#chi^{2} Probability of Vertex Fitting;#chi^{2}",
                     100,
                     0.,
                     1.0);
 }

◆ bookHistogramsEfficiency()

void PhotonAnalyzer::bookHistogramsEfficiency ( DQMStore::IBooker & iBooker )

private

Definition at line 172 of file PhotonAnalyzer.cc.

References dqm::implementation::IBooker::book1D(), PA_MinBiasSkim_cff::cut, dqm::implementation::NavigatorBase::setCurrentFolder(), and parallelization::uint.

                                                                       {
   // Set folder
   iBooker.setCurrentFolder("Egamma/" + fName_ + "/Efficiencies");
 
   // Don't number these histograms with the "bookHisto" method, since they'll be erased in the offline client
   h_phoEta_Loose_ = iBooker.book1D("phoEtaLoose", "Loose Photon #eta", etaBin_, etaMin_, etaMax_);
   h_phoEta_Tight_ = iBooker.book1D("phoEtaTight", "Tight Photon #eta", etaBin_, etaMin_, etaMax_);
 
   h_phoEt_Loose_ = iBooker.book1D("phoEtLoose", "Loose Photon E_{T}", etBin_, etMin_, etMax_);
   h_phoEt_Tight_ = iBooker.book1D("phoEtTight", "Tight Photon E_{T}", etBin_, etMin_, etMax_);
 
   h_phoEta_preHLT_ = iBooker.book1D("phoEtaPreHLT", "Photon #eta: before HLT", etaBin_, etaMin_, etaMax_);
   h_phoEta_postHLT_ = iBooker.book1D("phoEtaPostHLT", "Photon #eta: after HLT", etaBin_, etaMin_, etaMax_);
   h_phoEt_preHLT_ = iBooker.book1D("phoEtPreHLT", "Photon E_{T}: before HLT", etBin_, etMin_, etMax_);
   h_phoEt_postHLT_ = iBooker.book1D("phoEtPostHLT", "Photon E_{T}: after HLT", etBin_, etMin_, etMax_);
 
   h_convEta_Loose_ = iBooker.book1D("convEtaLoose", "Converted Loose Photon #eta", etaBin_, etaMin_, etaMax_);
   h_convEta_Tight_ = iBooker.book1D("convEtaTight", "Converted Tight Photon #eta", etaBin_, etaMin_, etaMax_);
   h_convEt_Loose_ = iBooker.book1D("convEtLoose", "Converted Loose Photon E_{T}", etBin_, etMin_, etMax_);
   h_convEt_Tight_ = iBooker.book1D("convEtTight", "Converted Tight Photon E_{T}", etBin_, etMin_, etMax_);
 
   h_phoEta_Vertex_ =
       iBooker.book1D("phoEtaVertex", "Converted Photons before valid vertex cut: #eta", etaBin_, etaMin_, etaMax_);
 
   // Some temporary vectors
   vector<MonitorElement*> temp1DVectorEta;
   vector<MonitorElement*> temp1DVectorPhi;
   vector<vector<MonitorElement*> > temp2DVectorPhi;
 
   for (int cut = 0; cut != numberOfSteps_; ++cut) {       //looping over Et cut values
     for (uint type = 0; type != types_.size(); ++type) {  //looping over isolation type
       currentFolder_.str("");
       currentFolder_ << "Egamma/" + fName_ + "/" << types_[type] << "Photons/Et above " << (cut + 1) * cutStep_
                      << " GeV/Conversions";
       iBooker.setCurrentFolder(currentFolder_.str());
 
       temp1DVectorEta.push_back(
           iBooker.book1D("phoConvEtaForEfficiency", "Converted Photon #eta;#eta", etaBin_, etaMin_, etaMax_));
       for (uint part = 0; part != parts_.size(); ++part) {
         temp1DVectorPhi.push_back(iBooker.book1D(
             "phoConvPhiForEfficiency" + parts_[part], "Converted Photon #phi;#phi", phiBin_, phiMin_, phiMax_));
       }
       temp2DVectorPhi.push_back(temp1DVectorPhi);
       temp1DVectorPhi.clear();
     }
     h_phoConvEtaForEfficiency_.push_back(temp1DVectorEta);
     temp1DVectorEta.clear();
     h_phoConvPhiForEfficiency_.push_back(temp2DVectorPhi);
     temp2DVectorPhi.clear();
   }
 }

◆ bookHistogramsForHistogramCounts()

void PhotonAnalyzer::bookHistogramsForHistogramCounts ( DQMStore::IBooker & iBooker )

private

Definition at line 155 of file PhotonAnalyzer.cc.

References dqm::implementation::IBooker::bookInt(), and dqm::implementation::NavigatorBase::setCurrentFolder().

                                                                               {
   iBooker.setCurrentFolder("Egamma/" + fName_ + "/");
   // Int values stored in MEs to keep track of how many histograms are in each folder
   totalNumberOfHistos_efficiencyFolder = iBooker.bookInt("numberOfHistogramsInEfficiencyFolder");
   totalNumberOfHistos_invMassFolder = iBooker.bookInt("numberOfHistogramsInInvMassFolder");
   totalNumberOfHistos_photonsFolder = iBooker.bookInt("numberOfHistogramsInPhotonsFolder");
   totalNumberOfHistos_conversionsFolder = iBooker.bookInt("numberOfHistogramsInConversionsFolder");
 }

◆ bookHistogramsInvMass()

void PhotonAnalyzer::bookHistogramsInvMass ( DQMStore::IBooker & iBooker )

private

Definition at line 224 of file PhotonAnalyzer.cc.

References dqm::implementation::NavigatorBase::setCurrentFolder().

                                                                    {
   // Set folder
   iBooker.setCurrentFolder("Egamma/" + fName_ + "/InvMass");
 
   h_invMassAllPhotons_ = bookHisto(iBooker,
                                    "invMassAllIsolatedPhotons",
                                    "Two photon invariant mass: All isolated photons;M (GeV)",
                                    etBin_,
                                    etMin_,
                                    etMax_);
   h_invMassPhotonsEBarrel_ = bookHisto(iBooker,
                                        "invMassIsoPhotonsEBarrel",
                                        "Two photon invariant mass: isolated photons in barrel; M (GeV)",
                                        etBin_,
                                        etMin_,
                                        etMax_);
   h_invMassPhotonsEEndcap_ = bookHisto(iBooker,
                                        "invMassIsoPhotonsEEndcap",
                                        "Two photon invariant mass: isolated photons in endcap; M (GeV)",
                                        etBin_,
                                        etMin_,
                                        etMax_);
   h_invMassPhotonsEEndcapEBarrel_ = bookHisto(iBooker,
                                               "invMassIsoPhotonsEEndcapEBarrel",
                                               "Two photon invariant mass: isolated photons in endcap-barrel; M (GeV)",
                                               etBin_,
                                               etMin_,
                                               etMax_);
 
   h_invMassZeroWithTracks_ = bookHisto(
       iBooker, "invMassZeroWithTracks", "Two photon invariant mass: Neither has tracks;M (GeV)", etBin_, etMin_, etMax_);
   h_invMassOneWithTracks_ = bookHisto(
       iBooker, "invMassOneWithTracks", "Two photon invariant mass: Only one has tracks;M (GeV)", etBin_, etMin_, etMax_);
   h_invMassTwoWithTracks_ = bookHisto(
       iBooker, "invMassTwoWithTracks", "Two photon invariant mass: Both have tracks;M (GeV)", etBin_, etMin_, etMax_);
 
   h_nRecoVtx_ = bookHisto(iBooker, "nOfflineVtx", "# of Offline Vertices", 200, -0.5, 199.5);
 }

◆ bookHistogramsPhotons()

void PhotonAnalyzer::bookHistogramsPhotons ( DQMStore::IBooker & iBooker )

private

Definition at line 263 of file PhotonAnalyzer.cc.

                                                                    {
   // Set folder
   // Folder is set by the book2DHistoVector and book3DHistoVector methods
 
   //ENERGY VARIABLES
   book3DHistoVector(iBooker, h_phoE_, "1D", "phoE", "Energy;E (GeV)", eBin_, eMin_, eMax_);
   book3DHistoVector(iBooker, h_phoSigmaEoverE_, "1D", "phoSigmaEoverE", "#sigma_{E}/E; #sigma_{E}/E", 100, 0., 0.08);
   book3DHistoVector(iBooker,
                     p_phoSigmaEoverEvsNVtx_,
                     "Profile",
                     "phoSigmaEoverEvsNVtx",
                     "#sigma_{E}/E vs NVtx; N_{vtx}; #sigma_{E}/E",
                     200,
                     -0.5,
                     199.5,
                     100,
                     0.,
                     0.08);
   book3DHistoVector(iBooker, h_phoEt_, "1D", "phoEt", "E_{T};E_{T} (GeV)", etBin_, etMin_, etMax_);
 
   //NUMBER OF PHOTONS
   book3DHistoVector(
       iBooker, h_nPho_, "1D", "nPho", "Number of Photons per Event;# #gamma", numberBin_, numberMin_, numberMax_);
 
   //GEOMETRICAL VARIABLES
   //photon eta/phi
   book2DHistoVector(iBooker, h_phoEta_, "1D", "phoEta", "#eta;#eta", etaBin_, etaMin_, etaMax_);
   book3DHistoVector(iBooker, h_phoPhi_, "1D", "phoPhi", "#phi;#phi", phiBin_, phiMin_, phiMax_);
 
   //supercluster eta/phi
   book2DHistoVector(iBooker, h_scEta_, "1D", "scEta", "SuperCluster #eta;#eta", etaBin_, etaMin_, etaMax_);
   book3DHistoVector(iBooker, h_scPhi_, "1D", "scPhi", "SuperCluster #phi;#phi", phiBin_, phiMin_, phiMax_);
 
   //SHOWER SHAPE VARIABLES
   //r9
   book3DHistoVector(iBooker, h_r9_, "1D", "r9", "R9;R9", r9Bin_, r9Min_, r9Max_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_r9VsEt_,
                       "2D",
                       "r9VsEt2D",
                       "R9 vs E_{T};E_{T} (GeV);R9",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       reducedR9Bin_,
                       r9Min_,
                       r9Max_);
   }
   book2DHistoVector(iBooker,
                     p_r9VsEt_,
                     "Profile",
                     "r9VsEt",
                     "Avg R9 vs E_{T};E_{T} (GeV);R9",
                     etBin_,
                     etMin_,
                     etMax_,
                     r9Bin_,
                     r9Min_,
                     r9Max_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_r9VsEta_,
                       "2D",
                       "r9VsEta2D",
                       "R9 vs #eta;#eta;R9",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       reducedR9Bin_,
                       r9Min_,
                       r9Max_);
   }
   book2DHistoVector(iBooker,
                     p_r9VsEta_,
                     "Profile",
                     "r9VsEta",
                     "Avg R9 vs #eta;#eta;R9",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     r9Bin_,
                     r9Min_,
                     r9Max_);
 
   //sigma ieta ieta
   book3DHistoVector(iBooker,
                     h_phoSigmaIetaIeta_,
                     "1D",
                     "phoSigmaIetaIeta",
                     "#sigma_{i#etai#eta};#sigma_{i#etai#eta}",
                     sigmaIetaBin_,
                     sigmaIetaMin_,
                     sigmaIetaMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_sigmaIetaIetaVsEta_,
                       "2D",
                       "sigmaIetaIetaVsEta2D",
                       "#sigma_{i#etai#eta} vs #eta;#eta;#sigma_{i#etai#eta}",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       sigmaIetaBin_,
                       sigmaIetaMin_,
                       sigmaIetaMax_);
   }
   book2DHistoVector(iBooker,
                     p_sigmaIetaIetaVsEta_,
                     "Profile",
                     "sigmaIetaIetaVsEta",
                     "Avg #sigma_{i#etai#eta} vs #eta;#eta;#sigma_{i#etai#eta}",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     sigmaIetaBin_,
                     sigmaIetaMin_,
                     sigmaIetaMax_);
 
   //e1x5
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_e1x5VsEt_,
                       "2D",
                       "e1x5VsEt2D",
                       "E1x5 vs E_{T};E_{T} (GeV);E1X5 (GeV)",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       reducedEtBin_,
                       etMin_,
                       etMax_);
   }
   book2DHistoVector(iBooker,
                     p_e1x5VsEt_,
                     "Profile",
                     "e1x5VsEt",
                     "Avg E1x5 vs E_{T};E_{T} (GeV);E1X5 (GeV)",
                     etBin_,
                     etMin_,
                     etMax_,
                     etBin_,
                     etMin_,
                     etMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_e1x5VsEta_,
                       "2D",
                       "e1x5VsEta2D",
                       "E1x5 vs #eta;#eta;E1X5 (GeV)",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       reducedEtBin_,
                       etMin_,
                       etMax_);
   }
   book2DHistoVector(iBooker,
                     p_e1x5VsEta_,
                     "Profile",
                     "e1x5VsEta",
                     "Avg E1x5 vs #eta;#eta;E1X5 (GeV)",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     etBin_,
                     etMin_,
                     etMax_);
 
   //e2x5
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_e2x5VsEt_,
                       "2D",
                       "e2x5VsEt2D",
                       "E2x5 vs E_{T};E_{T} (GeV);E2X5 (GeV)",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       reducedEtBin_,
                       etMin_,
                       etMax_);
   }
   book2DHistoVector(iBooker,
                     p_e2x5VsEt_,
                     "Profile",
                     "e2x5VsEt",
                     "Avg E2x5 vs E_{T};E_{T} (GeV);E2X5 (GeV)",
                     etBin_,
                     etMin_,
                     etMax_,
                     etBin_,
                     etMin_,
                     etMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_e2x5VsEta_,
                       "2D",
                       "e2x5VsEta2D",
                       "E2x5 vs #eta;#eta;E2X5 (GeV)",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       reducedEtBin_,
                       etMin_,
                       etMax_);
   }
   book2DHistoVector(iBooker,
                     p_e2x5VsEta_,
                     "Profile",
                     "e2x5VsEta",
                     "Avg E2x5 vs #eta;#eta;E2X5 (GeV)",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     etBin_,
                     etMin_,
                     etMax_);
 
   //r1x5
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_r1x5VsEt_,
                       "2D",
                       "r1x5VsEt2D",
                       "R1x5 vs E_{T};E_{T} (GeV);R1X5",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       reducedR9Bin_,
                       r9Min_,
                       r9Max_);
   }
   book2DHistoVector(iBooker,
                     p_r1x5VsEt_,
                     "Profile",
                     "r1x5VsEt",
                     "Avg R1x5 vs E_{T};E_{T} (GeV);R1X5",
                     etBin_,
                     etMin_,
                     etMax_,
                     r9Bin_,
                     r9Min_,
                     r9Max_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_r1x5VsEta_,
                       "2D",
                       "r1x5VsEta2D",
                       "R1x5 vs #eta;#eta;R1X5",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       reducedR9Bin_,
                       r9Min_,
                       r9Max_);
   }
   book2DHistoVector(iBooker,
                     p_r1x5VsEta_,
                     "Profile",
                     "r1x5VsEta",
                     "Avg R1x5 vs #eta;#eta;R1X5",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     r9Bin_,
                     r9Min_,
                     r9Max_);
 
   //r2x5
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_r2x5VsEt_,
                       "2D",
                       "r2x5VsEt2D",
                       "R2x5 vs E_{T};E_{T} (GeV);R2X5",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       reducedR9Bin_,
                       r9Min_,
                       r9Max_);
   }
   book2DHistoVector(iBooker,
                     p_r2x5VsEt_,
                     "Profile",
                     "r2x5VsEt",
                     "Avg R2x5 vs E_{T};E_{T} (GeV);R2X5",
                     etBin_,
                     etMin_,
                     etMax_,
                     r9Bin_,
                     r9Min_,
                     r9Max_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_r2x5VsEta_,
                       "2D",
                       "r2x5VsEta2D",
                       "R2x5 vs #eta;#eta;R2X5",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       reducedR9Bin_,
                       r9Min_,
                       r9Max_);
   }
   book2DHistoVector(iBooker,
                     p_r2x5VsEta_,
                     "Profile",
                     "r2x5VsEta",
                     "Avg R2x5 vs #eta;#eta;R2X5",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     r9Bin_,
                     r9Min_,
                     r9Max_);
 
   //maxEXtalOver3x3
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_maxEXtalOver3x3VsEt_,
                       "2D",
                       "maxEXtalOver3x3VsEt2D",
                       "(Max Xtal E)/E3x3 vs E_{T};E_{T} (GeV);(Max Xtal E)/E3x3",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       r9Bin_,
                       r9Min_,
                       r9Max_);
   }
   book2DHistoVector(iBooker,
                     p_maxEXtalOver3x3VsEt_,
                     "Profile",
                     "maxEXtalOver3x3VsEt",
                     "Avg (Max Xtal E)/E3x3 vs E_{T};E_{T} (GeV);(Max Xtal E)/E3x3",
                     etBin_,
                     etMin_,
                     etMax_,
                     r9Bin_,
                     r9Min_,
                     r9Max_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_maxEXtalOver3x3VsEta_,
                       "2D",
                       "maxEXtalOver3x3VsEta2D",
                       "(Max Xtal E)/E3x3 vs #eta;#eta;(Max Xtal E)/E3x3",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       r9Bin_,
                       r9Min_,
                       r9Max_);
   }
   book2DHistoVector(iBooker,
                     p_maxEXtalOver3x3VsEta_,
                     "Profile",
                     "maxEXtalOver3x3VsEta",
                     "Avg (Max Xtal E)/E3x3 vs #eta;#eta;(Max Xtal E)/E3x3",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     r9Bin_,
                     r9Min_,
                     r9Max_);
 
   //TRACK ISOLATION VARIABLES
   //nTrackIsolSolid
   book2DHistoVector(iBooker,
                     h_nTrackIsolSolid_,
                     "1D",
                     "nIsoTracksSolid",
                     "Number Of Tracks in the Solid Iso Cone;# tracks",
                     numberBin_,
                     numberMin_,
                     numberMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_nTrackIsolSolidVsEt_,
                       "2D",
                       "nIsoTracksSolidVsEt2D",
                       "Number Of Tracks in the Solid Iso Cone vs E_{T};E_{T};# tracks",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       numberBin_,
                       numberMin_,
                       numberMax_);
   }
   book2DHistoVector(iBooker,
                     p_nTrackIsolSolidVsEt_,
                     "Profile",
                     "nIsoTracksSolidVsEt",
                     "Avg Number Of Tracks in the Solid Iso Cone vs E_{T};E_{T};# tracks",
                     etBin_,
                     etMin_,
                     etMax_,
                     numberBin_,
                     numberMin_,
                     numberMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_nTrackIsolSolidVsEta_,
                       "2D",
                       "nIsoTracksSolidVsEta2D",
                       "Number Of Tracks in the Solid Iso Cone vs #eta;#eta;# tracks",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       numberBin_,
                       numberMin_,
                       numberMax_);
   }
   book2DHistoVector(iBooker,
                     p_nTrackIsolSolidVsEta_,
                     "Profile",
                     "nIsoTracksSolidVsEta",
                     "Avg Number Of Tracks in the Solid Iso Cone vs #eta;#eta;# tracks",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     numberBin_,
                     numberMin_,
                     numberMax_);
 
   //nTrackIsolHollow
   book2DHistoVector(iBooker,
                     h_nTrackIsolHollow_,
                     "1D",
                     "nIsoTracksHollow",
                     "Number Of Tracks in the Hollow Iso Cone;# tracks",
                     numberBin_,
                     numberMin_,
                     numberMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_nTrackIsolHollowVsEt_,
                       "2D",
                       "nIsoTracksHollowVsEt2D",
                       "Number Of Tracks in the Hollow Iso Cone vs E_{T};E_{T};# tracks",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       numberBin_,
                       numberMin_,
                       numberMax_);
   }
   book2DHistoVector(iBooker,
                     p_nTrackIsolHollowVsEt_,
                     "Profile",
                     "nIsoTracksHollowVsEt",
                     "Avg Number Of Tracks in the Hollow Iso Cone vs E_{T};E_{T};# tracks",
                     etBin_,
                     etMin_,
                     etMax_,
                     numberBin_,
                     numberMin_,
                     numberMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_nTrackIsolHollowVsEta_,
                       "2D",
                       "nIsoTracksHollowVsEta2D",
                       "Number Of Tracks in the Hollow Iso Cone vs #eta;#eta;# tracks",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       numberBin_,
                       numberMin_,
                       numberMax_);
   }
   book2DHistoVector(iBooker,
                     p_nTrackIsolHollowVsEta_,
                     "Profile",
                     "nIsoTracksHollowVsEta",
                     "Avg Number Of Tracks in the Hollow Iso Cone vs #eta;#eta;# tracks",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     numberBin_,
                     numberMin_,
                     numberMax_);
 
   //trackPtSumSolid
   book2DHistoVector(iBooker,
                     h_trackPtSumSolid_,
                     "1D",
                     "isoPtSumSolid",
                     "Track P_{T} Sum in the Solid Iso Cone;P_{T} (GeV)",
                     sumBin_,
                     sumMin_,
                     sumMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_trackPtSumSolidVsEt_,
                       "2D",
                       "isoPtSumSolidVsEt2D",
                       "Track P_{T} Sum in the Solid Iso Cone;E_{T} (GeV);P_{T} (GeV)",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       reducedSumBin_,
                       sumMin_,
                       sumMax_);
   }
   book2DHistoVector(iBooker,
                     p_trackPtSumSolidVsEt_,
                     "Profile",
                     "isoPtSumSolidVsEt",
                     "Avg Track P_{T} Sum in the Solid Iso Cone vs E_{T};E_{T} (GeV);P_{T} (GeV)",
                     etBin_,
                     etMin_,
                     etMax_,
                     sumBin_,
                     sumMin_,
                     sumMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_trackPtSumSolidVsEta_,
                       "2D",
                       "isoPtSumSolidVsEta2D",
                       "Track P_{T} Sum in the Solid Iso Cone;#eta;P_{T} (GeV)",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       reducedSumBin_,
                       sumMin_,
                       sumMax_);
   }
   book2DHistoVector(iBooker,
                     p_trackPtSumSolidVsEta_,
                     "Profile",
                     "isoPtSumSolidVsEta",
                     "Avg Track P_{T} Sum in the Solid Iso Cone vs #eta;#eta;P_{T} (GeV)",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     sumBin_,
                     sumMin_,
                     sumMax_);
 
   //trackPtSumHollow
   book2DHistoVector(iBooker,
                     h_trackPtSumHollow_,
                     "1D",
                     "isoPtSumHollow",
                     "Track P_{T} Sum in the Hollow Iso Cone;P_{T} (GeV)",
                     sumBin_,
                     sumMin_,
                     sumMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_trackPtSumHollowVsEt_,
                       "2D",
                       "isoPtSumHollowVsEt2D",
                       "Track P_{T} Sum in the Hollow Iso Cone;E_{T} (GeV);P_{T} (GeV)",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       reducedSumBin_,
                       sumMin_,
                       sumMax_);
   }
   book2DHistoVector(iBooker,
                     p_trackPtSumHollowVsEt_,
                     "Profile",
                     "isoPtSumHollowVsEt",
                     "Avg Track P_{T} Sum in the Hollow Iso Cone vs E_{T};E_{T} (GeV);P_{T} (GeV)",
                     etBin_,
                     etMin_,
                     etMax_,
                     sumBin_,
                     sumMin_,
                     sumMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_trackPtSumHollowVsEta_,
                       "2D",
                       "isoPtSumHollowVsEta2D",
                       "Track P_{T} Sum in the Hollow Iso Cone;#eta;P_{T} (GeV)",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       reducedSumBin_,
                       sumMin_,
                       sumMax_);
   }
   book2DHistoVector(iBooker,
                     p_trackPtSumHollowVsEta_,
                     "Profile",
                     "isoPtSumHollowVsEta",
                     "Avg Track P_{T} Sum in the Hollow Iso Cone vs #eta;#eta;P_{T} (GeV)",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     sumBin_,
                     sumMin_,
                     sumMax_);
 
   //CALORIMETER ISOLATION VARIABLES
   //ecal sum
   book2DHistoVector(
       iBooker, h_ecalSum_, "1D", "ecalSum", "Ecal Sum in the Iso Cone;E (GeV)", sumBin_, sumMin_, sumMax_);
   book2DHistoVector(iBooker,
                     h_ecalSumEBarrel_,
                     "1D",
                     "ecalSumEBarrel",
                     "Ecal Sum in the IsoCone for Barrel;E (GeV)",
                     sumBin_,
                     sumMin_,
                     sumMax_);
   book2DHistoVector(iBooker,
                     h_ecalSumEEndcap_,
                     "1D",
                     "ecalSumEEndcap",
                     "Ecal Sum in the IsoCone for Endcap;E (GeV)",
                     sumBin_,
                     sumMin_,
                     sumMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_ecalSumVsEt_,
                       "2D",
                       "ecalSumVsEt2D",
                       "Ecal Sum in the Iso Cone;E_{T} (GeV);E (GeV)",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       reducedSumBin_,
                       sumMin_,
                       sumMax_);
   }
   book3DHistoVector(iBooker,
                     p_ecalSumVsEt_,
                     "Profile",
                     "ecalSumVsEt",
                     "Avg Ecal Sum in the Iso Cone vs E_{T};E_{T} (GeV);E (GeV)",
                     etBin_,
                     etMin_,
                     etMax_,
                     sumBin_,
                     sumMin_,
                     sumMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_ecalSumVsEta_,
                       "2D",
                       "ecalSumVsEta2D",
                       "Ecal Sum in the Iso Cone;#eta;E (GeV)",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       reducedSumBin_,
                       sumMin_,
                       sumMax_);
   }
   book2DHistoVector(iBooker,
                     p_ecalSumVsEta_,
                     "Profile",
                     "ecalSumVsEta",
                     "Avg Ecal Sum in the Iso Cone vs #eta;#eta;E (GeV)",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     sumBin_,
                     sumMin_,
                     sumMax_);
 
   //hcal sum
   book2DHistoVector(
       iBooker, h_hcalSum_, "1D", "hcalSum", "Hcal Sum in the Iso Cone;E (GeV)", sumBin_, sumMin_, sumMax_);
   book2DHistoVector(iBooker,
                     h_hcalSumEBarrel_,
                     "1D",
                     "hcalSumEBarrel",
                     "Hcal Sum in the IsoCone for Barrel;E (GeV)",
                     sumBin_,
                     sumMin_,
                     sumMax_);
   book2DHistoVector(iBooker,
                     h_hcalSumEEndcap_,
                     "1D",
                     "hcalSumEEndcap",
                     "Hcal Sum in the IsoCone for Endcap;E (GeV)",
                     sumBin_,
                     sumMin_,
                     sumMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_hcalSumVsEt_,
                       "2D",
                       "hcalSumVsEt2D",
                       "Hcal Sum in the Iso Cone;E_{T} (GeV);E (GeV)",
                       reducedEtBin_,
                       etMin_,
                       etMax_,
                       reducedSumBin_,
                       sumMin_,
                       sumMax_);
   }
   book3DHistoVector(iBooker,
                     p_hcalSumVsEt_,
                     "Profile",
                     "hcalSumVsEt",
                     "Avg Hcal Sum in the Iso Cone vs E_{T};E_{T} (GeV);E (GeV)",
                     etBin_,
                     etMin_,
                     etMax_,
                     sumBin_,
                     sumMin_,
                     sumMax_);
   if (standAlone_) {
     book2DHistoVector(iBooker,
                       h_hcalSumVsEta_,
                       "2D",
                       "hcalSumVsEta2D",
                       "Hcal Sum in the Iso Cone;#eta;E (GeV)",
                       reducedEtaBin_,
                       etaMin_,
                       etaMax_,
                       reducedSumBin_,
                       sumMin_,
                       sumMax_);
   }
   book2DHistoVector(iBooker,
                     p_hcalSumVsEta_,
                     "Profile",
                     "hcalSumVsEta",
                     "Avg Hcal Sum in the Iso Cone vs #eta;#eta;E (GeV)",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     sumBin_,
                     sumMin_,
                     sumMax_);
 
   //h over e
   book3DHistoVector(iBooker, h_hOverE_, "1D", "hOverE", "H/E;H/E", hOverEBin_, hOverEMin_, hOverEMax_);
   book2DHistoVector(iBooker,
                     p_hOverEVsEt_,
                     "Profile",
                     "hOverEVsEt",
                     "Avg H/E vs Et;E_{T} (GeV);H/E",
                     etBin_,
                     etMin_,
                     etMax_,
                     hOverEBin_,
                     hOverEMin_,
                     hOverEMax_);
   book2DHistoVector(iBooker,
                     p_hOverEVsEta_,
                     "Profile",
                     "hOverEVsEta",
                     "Avg H/E vs #eta;#eta;H/E",
                     etaBin_,
                     etaMin_,
                     etaMax_,
                     hOverEBin_,
                     hOverEMin_,
                     hOverEMax_);
   book3DHistoVector(iBooker, h_h1OverE_, "1D", "h1OverE", "H/E for Depth 1;H/E", hOverEBin_, hOverEMin_, hOverEMax_);
   book3DHistoVector(iBooker, h_h2OverE_, "1D", "h2OverE", "H/E for Depth 2;H/E", hOverEBin_, hOverEMin_, hOverEMax_);
 
   // pf isolation
   book2DHistoVector(
       iBooker, h_phoIsoBarrel_, "1D", "phoIsoBarrel", "PF photon iso Barrel;E (GeV)", reducedEtBin_, etMin_, 25.);
   book2DHistoVector(
       iBooker, h_phoIsoEndcap_, "1D", "phoIsoEndcap", "PF photon iso Endcap;E (GeV)", reducedEtBin_, etMin_, 25.);
   book2DHistoVector(iBooker,
                     h_chHadIsoBarrel_,
                     "1D",
                     "chHadIsoBarrel",
                     "PF charged Had iso Barrel;E (GeV)",
                     reducedEtBin_,
                     etMin_,
                     25.);
   book2DHistoVector(iBooker,
                     h_chHadIsoEndcap_,
                     "1D",
                     "chHadIsoEndcap",
                     "PF charged Had iso Endcap;E (GeV)",
                     reducedEtBin_,
                     etMin_,
                     25.);
   book2DHistoVector(iBooker,
                     h_nHadIsoBarrel_,
                     "1D",
                     "neutralHadIsoBarrel",
                     "PF neutral Had iso Barrel;E (GeV)",
                     reducedEtBin_,
                     etMin_,
                     25.);
   book2DHistoVector(iBooker,
                     h_nHadIsoEndcap_,
                     "1D",
                     "neutralHadIsoEndcap",
                     "PF neutral Had iso Endcap;E (GeV)",
                     reducedEtBin_,
                     etMin_,
                     25.);
 
   //OTHER VARIABLES
   //bad channel histograms
   book2DHistoVector(iBooker,
                     h_phoEt_BadChannels_,
                     "1D",
                     "phoEtBadChannels",
                     "Fraction Containing Bad Channels: E_{T};E_{T} (GeV)",
                     etBin_,
                     etMin_,
                     etMax_);
   book2DHistoVector(iBooker,
                     h_phoEta_BadChannels_,
                     "1D",
                     "phoEtaBadChannels",
                     "Fraction Containing Bad Channels: #eta;#eta",
                     etaBin_,
                     etaMin_,
                     etaMax_);
   book2DHistoVector(iBooker,
                     h_phoPhi_BadChannels_,
                     "1D",
                     "phoPhiBadChannels",
                     "Fraction Containing Bad Channels: #phi;#phi",
                     phiBin_,
                     phiMin_,
                     phiMax_);
 }

◆ fill2DHistoVector() [1/2]

void PhotonAnalyzer::fill2DHistoVector	(	std::vector< std::vector< MonitorElement *> > &	histoVector,
		double	x,
		int	cut,
		int	type
	)

private

◆ fill2DHistoVector() [2/2]

void PhotonAnalyzer::fill2DHistoVector	(	std::vector< std::vector< MonitorElement *> > &	histoVector,
		double	x,
		double	y,
		int	cut,
		int	type
	)

private

◆ fill3DHistoVector() [1/2]

void PhotonAnalyzer::fill3DHistoVector	(	std::vector< std::vector< std::vector< MonitorElement *> > > &	histoVector,
		double	x,
		int	cut,
		int	type,
		int	part
	)

private

◆ fill3DHistoVector() [2/2]

void PhotonAnalyzer::fill3DHistoVector	(	std::vector< std::vector< std::vector< MonitorElement *> > > &	histoVector,
		double	x,
		double	y,
		int	cut,
		int	type,
		int	part
	)

private

◆ fillHistogramsForHistogramCounts()

void PhotonAnalyzer::fillHistogramsForHistogramCounts ( DQMStore::IBooker & iBooker )

private

Definition at line 164 of file PhotonAnalyzer.cc.

References dqm::implementation::NavigatorBase::setCurrentFolder().

                                                                               {
   iBooker.setCurrentFolder("Egamma/" + fName_ + "/");
   totalNumberOfHistos_efficiencyFolder->Fill(histo_index_efficiency_);
   totalNumberOfHistos_invMassFolder->Fill(histo_index_invMass_);
   totalNumberOfHistos_photonsFolder->Fill(histo_index_photons_);
   totalNumberOfHistos_conversionsFolder->Fill(histo_index_conversions_);
 }

◆ phiNormalization()

float PhotonAnalyzer::phiNormalization ( float & a )

private

Definition at line 2033 of file PhotonAnalyzer.cc.

References PI, and TWOPI.

                                                  {
   const float PI = 3.1415927;
   const float TWOPI = 2.0 * PI;
 
   if (phi > PI) {
     phi = phi - TWOPI;
   }
   if (phi < -PI) {
     phi = phi + TWOPI;
   }
 
   return phi;
 }

◆ photonSelection()

bool PhotonAnalyzer::photonSelection ( const reco::Photon * p )

private

remove after moriond if (EtCorrEcalIso>4.0) result=false;

remove after moriond if (EtCorrEcalIso>50.0) result=false;

Definition at line 2075 of file PhotonAnalyzer.cc.

References reco::Photon::chargedHadronIso(), reco::LeafCandidate::eta(), reco::Photon::hadTowOverEm(), reco::Photon::hcalTowerSumEtConeDR03(), reco::Photon::isEB(), reco::Photon::isEBEEGap(), reco::Photon::isEE(), reco::LeafCandidate::pt(), reco::Photon::r9(), mps_fire::result, reco::Photon::sigmaIetaIeta(), and reco::Photon::trkSumPtHollowConeDR03().

                                                           {
   bool result = true;
   if (pho->pt() < minPhoEtCut_)
     result = false;
   if (fabs(pho->eta()) > photonMaxEta_)
     result = false;
   if (pho->isEBEEGap())
     result = false;
 
   double EtCorrHcalIso = pho->hcalTowerSumEtConeDR03() - 0.005 * pho->pt();
   double EtCorrTrkIso = pho->trkSumPtHollowConeDR03() - 0.002 * pho->pt();
 
   if (pho->r9() <= 0.9) {
     if (pho->isEB() && (pho->hadTowOverEm() > 0.075 || pho->sigmaIetaIeta() > 0.014))
       result = false;
     if (pho->isEE() && (pho->hadTowOverEm() > 0.075 || pho->sigmaIetaIeta() > 0.034))
       result = false;
     if (EtCorrHcalIso > 4.0)
       result = false;
     if (EtCorrTrkIso > 4.0)
       result = false;
     if (pho->chargedHadronIso() > 4)
       result = false;
   } else {
     if (pho->isEB() && (pho->hadTowOverEm() > 0.082 || pho->sigmaIetaIeta() > 0.014))
       result = false;
     if (pho->isEE() && (pho->hadTowOverEm() > 0.075 || pho->sigmaIetaIeta() > 0.034))
       result = false;
     if (EtCorrHcalIso > 50.0)
       result = false;
     if (EtCorrTrkIso > 50.0)
       result = false;
     if (pho->chargedHadronIso() > 4)
       result = false;
   }
   return result;
 }

◆ photonSelectionSlimmed()

bool PhotonAnalyzer::photonSelectionSlimmed ( const reco::Photon * p )

private

Definition at line 2115 of file PhotonAnalyzer.cc.

References reco::LeafCandidate::eta(), reco::Photon::isEBEEGap(), reco::LeafCandidate::pt(), and mps_fire::result.

                                                                  {
   bool result = true;
 
   if (pho->pt() < minPhoEtCut_)
     result = false;
   if (fabs(pho->eta()) > photonMaxEta_)
     result = false;
   if (pho->isEBEEGap())
     result = false;
 
   return result;
 }

Member Data Documentation

◆ barrelRecHit_token_

edm::EDGetTokenT<edm::SortedCollection<EcalRecHit, edm::StrictWeakOrdering<EcalRecHit> > > PhotonAnalyzer::barrelRecHit_token_

private

Definition at line 164 of file PhotonAnalyzer.h.

◆ chi2Bin_

int PhotonAnalyzer::chi2Bin_

private

Definition at line 252 of file PhotonAnalyzer.h.

◆ chi2Max_

double PhotonAnalyzer::chi2Max_

private

Definition at line 254 of file PhotonAnalyzer.h.

◆ chi2Min_

double PhotonAnalyzer::chi2Min_

private

Definition at line 253 of file PhotonAnalyzer.h.

◆ currentFolder_

std::stringstream PhotonAnalyzer::currentFolder_

private

Definition at line 189 of file PhotonAnalyzer.h.

◆ cutStep_

double PhotonAnalyzer::cutStep_

private

Definition at line 173 of file PhotonAnalyzer.h.

◆ dEtaTracksBin_

int PhotonAnalyzer::dEtaTracksBin_

private

Definition at line 248 of file PhotonAnalyzer.h.

◆ dEtaTracksMax_

double PhotonAnalyzer::dEtaTracksMax_

private

Definition at line 250 of file PhotonAnalyzer.h.

◆ dEtaTracksMin_

double PhotonAnalyzer::dEtaTracksMin_

private

Definition at line 249 of file PhotonAnalyzer.h.

◆ dPhiTracksBin_

int PhotonAnalyzer::dPhiTracksBin_

private

Definition at line 244 of file PhotonAnalyzer.h.

◆ dPhiTracksMax_

double PhotonAnalyzer::dPhiTracksMax_

private

Definition at line 246 of file PhotonAnalyzer.h.

◆ dPhiTracksMin_

double PhotonAnalyzer::dPhiTracksMin_

private

Definition at line 245 of file PhotonAnalyzer.h.

◆ eBin_

int PhotonAnalyzer::eBin_

private

Definition at line 216 of file PhotonAnalyzer.h.

◆ eMax_

double PhotonAnalyzer::eMax_

private

Definition at line 218 of file PhotonAnalyzer.h.

◆ eMin_

double PhotonAnalyzer::eMin_

private

Definition at line 217 of file PhotonAnalyzer.h.

◆ endcapRecHit_token_

edm::EDGetTokenT<edm::SortedCollection<EcalRecHit, edm::StrictWeakOrdering<EcalRecHit> > > PhotonAnalyzer::endcapRecHit_token_

private

Definition at line 165 of file PhotonAnalyzer.h.

◆ eOverPBin_

int PhotonAnalyzer::eOverPBin_

private

Definition at line 240 of file PhotonAnalyzer.h.

◆ eOverPMax_

double PhotonAnalyzer::eOverPMax_

private

Definition at line 242 of file PhotonAnalyzer.h.

◆ eOverPMin_

double PhotonAnalyzer::eOverPMin_

private

Definition at line 241 of file PhotonAnalyzer.h.

◆ etaBin_

int PhotonAnalyzer::etaBin_

private

Definition at line 204 of file PhotonAnalyzer.h.

◆ etaMax_

double PhotonAnalyzer::etaMax_

private

Definition at line 206 of file PhotonAnalyzer.h.

◆ etaMin_

double PhotonAnalyzer::etaMin_

private

Definition at line 205 of file PhotonAnalyzer.h.

◆ etBin_

int PhotonAnalyzer::etBin_

private

Definition at line 208 of file PhotonAnalyzer.h.

◆ etMax_

double PhotonAnalyzer::etMax_

private

Definition at line 210 of file PhotonAnalyzer.h.

◆ etMin_

double PhotonAnalyzer::etMin_

private

Definition at line 209 of file PhotonAnalyzer.h.

◆ excludeBkgHistos_

bool PhotonAnalyzer::excludeBkgHistos_

private

Definition at line 181 of file PhotonAnalyzer.h.

◆ fName_

std::string PhotonAnalyzer::fName_

private

Definition at line 157 of file PhotonAnalyzer.h.

◆ h_chHadIsoBarrel_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_chHadIsoBarrel_

private

Definition at line 338 of file PhotonAnalyzer.h.

◆ h_chHadIsoEndcap_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_chHadIsoEndcap_

private

Definition at line 339 of file PhotonAnalyzer.h.

◆ h_convEt_Loose_

MonitorElement* PhotonAnalyzer::h_convEt_Loose_

private

Definition at line 296 of file PhotonAnalyzer.h.

◆ h_convEt_Tight_

MonitorElement* PhotonAnalyzer::h_convEt_Tight_

private

Definition at line 297 of file PhotonAnalyzer.h.

◆ h_convEta_Loose_

MonitorElement* PhotonAnalyzer::h_convEta_Loose_

private

Definition at line 294 of file PhotonAnalyzer.h.

◆ h_convEta_Tight_

MonitorElement* PhotonAnalyzer::h_convEta_Tight_

private

Definition at line 295 of file PhotonAnalyzer.h.

◆ h_convVtxR_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_convVtxR_

private

Definition at line 395 of file PhotonAnalyzer.h.

◆ h_convVtxRvsZ_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_convVtxRvsZ_

private

Definition at line 391 of file PhotonAnalyzer.h.

◆ h_convVtxYvsX_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_convVtxYvsX_

private

Definition at line 394 of file PhotonAnalyzer.h.

◆ h_convVtxZ_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_convVtxZ_

private

Definition at line 393 of file PhotonAnalyzer.h.

◆ h_convVtxZEndcap_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_convVtxZEndcap_

private

Definition at line 392 of file PhotonAnalyzer.h.

◆ h_dCotTracks_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_dCotTracks_

private

Definition at line 457 of file PhotonAnalyzer.h.

◆ h_dEtaTracksAtEcal_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_dEtaTracksAtEcal_

private

Definition at line 462 of file PhotonAnalyzer.h.

◆ h_dPhiTracksAtEcal_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_dPhiTracksAtEcal_

private

Definition at line 460 of file PhotonAnalyzer.h.

◆ h_dPhiTracksAtVtx_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_dPhiTracksAtVtx_

private

Definition at line 459 of file PhotonAnalyzer.h.

◆ h_e1x5VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_e1x5VsEt_

private

Definition at line 400 of file PhotonAnalyzer.h.

◆ h_e1x5VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_e1x5VsEta_

private

Definition at line 401 of file PhotonAnalyzer.h.

◆ h_e2x5VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_e2x5VsEt_

private

Definition at line 403 of file PhotonAnalyzer.h.

◆ h_e2x5VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_e2x5VsEta_

private

Definition at line 404 of file PhotonAnalyzer.h.

◆ h_ecalSum_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_ecalSum_

private

Definition at line 329 of file PhotonAnalyzer.h.

◆ h_ecalSumEBarrel_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_ecalSumEBarrel_

private

Definition at line 330 of file PhotonAnalyzer.h.

◆ h_ecalSumEEndcap_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_ecalSumEEndcap_

private

Definition at line 331 of file PhotonAnalyzer.h.

◆ h_ecalSumVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_ecalSumVsEt_

private

Definition at line 322 of file PhotonAnalyzer.h.

◆ h_ecalSumVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_ecalSumVsEta_

private

Definition at line 315 of file PhotonAnalyzer.h.

◆ h_eOverPTracks_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_eOverPTracks_

private

Definition at line 454 of file PhotonAnalyzer.h.

◆ h_h1OverE_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_h1OverE_

private

Definition at line 441 of file PhotonAnalyzer.h.

◆ h_h2OverE_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_h2OverE_

private

Definition at line 442 of file PhotonAnalyzer.h.

◆ h_hcalSum_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_hcalSum_

private

Definition at line 332 of file PhotonAnalyzer.h.

◆ h_hcalSumEBarrel_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_hcalSumEBarrel_

private

Definition at line 333 of file PhotonAnalyzer.h.

◆ h_hcalSumEEndcap_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_hcalSumEEndcap_

private

Definition at line 334 of file PhotonAnalyzer.h.

◆ h_hcalSumVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_hcalSumVsEt_

private

Definition at line 323 of file PhotonAnalyzer.h.

◆ h_hcalSumVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_hcalSumVsEta_

private

Definition at line 316 of file PhotonAnalyzer.h.

◆ h_hOverE_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_hOverE_

private

Definition at line 440 of file PhotonAnalyzer.h.

◆ h_invMassAllPhotons_

MonitorElement* PhotonAnalyzer::h_invMassAllPhotons_

private

Definition at line 304 of file PhotonAnalyzer.h.

◆ h_invMassOneWithTracks_

MonitorElement* PhotonAnalyzer::h_invMassOneWithTracks_

private

Definition at line 302 of file PhotonAnalyzer.h.

◆ h_invMassPhotonsEBarrel_

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEBarrel_

private

Definition at line 305 of file PhotonAnalyzer.h.

◆ h_invMassPhotonsEEndcap_

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEEndcap_

private

Definition at line 306 of file PhotonAnalyzer.h.

◆ h_invMassPhotonsEEndcapEBarrel_

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEEndcapEBarrel_

private

Definition at line 307 of file PhotonAnalyzer.h.

◆ h_invMassTwoWithTracks_

MonitorElement* PhotonAnalyzer::h_invMassTwoWithTracks_

private

Definition at line 301 of file PhotonAnalyzer.h.

◆ h_invMassZeroWithTracks_

MonitorElement* PhotonAnalyzer::h_invMassZeroWithTracks_

private

Definition at line 303 of file PhotonAnalyzer.h.

◆ h_maxEXtalOver3x3VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_maxEXtalOver3x3VsEt_

private

Definition at line 406 of file PhotonAnalyzer.h.

◆ h_maxEXtalOver3x3VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_maxEXtalOver3x3VsEta_

private

Definition at line 407 of file PhotonAnalyzer.h.

◆ h_nConv_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_nConv_

private

Definition at line 452 of file PhotonAnalyzer.h.

◆ h_nHadIsoBarrel_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_nHadIsoBarrel_

private

Definition at line 340 of file PhotonAnalyzer.h.

◆ h_nHadIsoEndcap_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_nHadIsoEndcap_

private

Definition at line 341 of file PhotonAnalyzer.h.

◆ h_nPho_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_nPho_

private

Definition at line 446 of file PhotonAnalyzer.h.

◆ h_nRecoVtx_

MonitorElement* PhotonAnalyzer::h_nRecoVtx_

private

Definition at line 282 of file PhotonAnalyzer.h.

◆ h_nTrackIsolHollow_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_nTrackIsolHollow_

private

Definition at line 327 of file PhotonAnalyzer.h.

◆ h_nTrackIsolHollowVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_nTrackIsolHollowVsEt_

private

Definition at line 320 of file PhotonAnalyzer.h.

◆ h_nTrackIsolHollowVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_nTrackIsolHollowVsEta_

private

Definition at line 313 of file PhotonAnalyzer.h.

◆ h_nTrackIsolSolid_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_nTrackIsolSolid_

private

Definition at line 325 of file PhotonAnalyzer.h.

◆ h_nTrackIsolSolidVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_nTrackIsolSolidVsEt_

private

Definition at line 318 of file PhotonAnalyzer.h.

◆ h_nTrackIsolSolidVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_nTrackIsolSolidVsEta_

private

Definition at line 311 of file PhotonAnalyzer.h.

◆ h_phoConvE_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_phoConvE_

private

Definition at line 448 of file PhotonAnalyzer.h.

◆ h_phoConvEt_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_phoConvEt_

private

Definition at line 449 of file PhotonAnalyzer.h.

◆ h_phoConvEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_phoConvEta_

private

Definition at line 389 of file PhotonAnalyzer.h.

◆ h_phoConvEtaForEfficiency_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_phoConvEtaForEfficiency_

private

Definition at line 383 of file PhotonAnalyzer.h.

◆ h_phoConvPhi_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_phoConvPhi_

private

Definition at line 438 of file PhotonAnalyzer.h.

◆ h_phoConvPhiForEfficiency_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_phoConvPhiForEfficiency_

private

Definition at line 437 of file PhotonAnalyzer.h.

◆ h_phoConvR9_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_phoConvR9_

private

Definition at line 450 of file PhotonAnalyzer.h.

◆ h_phoE_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_phoE_

private

Definition at line 430 of file PhotonAnalyzer.h.

◆ h_phoEt_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_phoEt_

private

Definition at line 433 of file PhotonAnalyzer.h.

◆ h_phoEt_BadChannels_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_phoEt_BadChannels_

private

Definition at line 386 of file PhotonAnalyzer.h.

◆ h_phoEt_Loose_

MonitorElement* PhotonAnalyzer::h_phoEt_Loose_

private

Definition at line 286 of file PhotonAnalyzer.h.

◆ h_phoEt_postHLT_

MonitorElement* PhotonAnalyzer::h_phoEt_postHLT_

private

Definition at line 292 of file PhotonAnalyzer.h.

◆ h_phoEt_preHLT_

MonitorElement* PhotonAnalyzer::h_phoEt_preHLT_

private

Definition at line 291 of file PhotonAnalyzer.h.

◆ h_phoEt_Tight_

MonitorElement* PhotonAnalyzer::h_phoEt_Tight_

private

Definition at line 287 of file PhotonAnalyzer.h.

◆ h_phoEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_phoEta_

private

Definition at line 380 of file PhotonAnalyzer.h.

◆ h_phoEta_BadChannels_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_phoEta_BadChannels_

private

Definition at line 385 of file PhotonAnalyzer.h.

◆ h_phoEta_Loose_

MonitorElement* PhotonAnalyzer::h_phoEta_Loose_

private

Definition at line 284 of file PhotonAnalyzer.h.

◆ h_phoEta_postHLT_

MonitorElement* PhotonAnalyzer::h_phoEta_postHLT_

private

Definition at line 290 of file PhotonAnalyzer.h.

◆ h_phoEta_preHLT_

MonitorElement* PhotonAnalyzer::h_phoEta_preHLT_

private

Definition at line 289 of file PhotonAnalyzer.h.

◆ h_phoEta_Tight_

MonitorElement* PhotonAnalyzer::h_phoEta_Tight_

private

Definition at line 285 of file PhotonAnalyzer.h.

◆ h_phoEta_Vertex_

MonitorElement* PhotonAnalyzer::h_phoEta_Vertex_

private

Definition at line 299 of file PhotonAnalyzer.h.

◆ h_phoIsoBarrel_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_phoIsoBarrel_

private

Definition at line 336 of file PhotonAnalyzer.h.

◆ h_phoIsoEndcap_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_phoIsoEndcap_

private

Definition at line 337 of file PhotonAnalyzer.h.

◆ h_phoPhi_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_phoPhi_

private

Definition at line 435 of file PhotonAnalyzer.h.

◆ h_phoPhi_BadChannels_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_phoPhi_BadChannels_

private

Definition at line 387 of file PhotonAnalyzer.h.

◆ h_phoSigmaEoverE_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_phoSigmaEoverE_

private

Definition at line 431 of file PhotonAnalyzer.h.

◆ h_phoSigmaIetaIeta_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_phoSigmaIetaIeta_

private

Definition at line 444 of file PhotonAnalyzer.h.

◆ h_pOverETracks_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_pOverETracks_

private

Definition at line 455 of file PhotonAnalyzer.h.

◆ h_r1x5VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_r1x5VsEt_

private

Definition at line 409 of file PhotonAnalyzer.h.

◆ h_r1x5VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_r1x5VsEta_

private

Definition at line 410 of file PhotonAnalyzer.h.

◆ h_r2x5VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_r2x5VsEt_

private

Definition at line 412 of file PhotonAnalyzer.h.

◆ h_r2x5VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_r2x5VsEta_

private

Definition at line 413 of file PhotonAnalyzer.h.

◆ h_r9_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_r9_

private

Definition at line 434 of file PhotonAnalyzer.h.

◆ h_r9VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_r9VsEt_

private

Definition at line 397 of file PhotonAnalyzer.h.

◆ h_r9VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_r9VsEta_

private

Definition at line 398 of file PhotonAnalyzer.h.

◆ h_scEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_scEta_

private

Definition at line 381 of file PhotonAnalyzer.h.

◆ h_scPhi_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::h_scPhi_

private

Definition at line 436 of file PhotonAnalyzer.h.

◆ h_sigmaIetaIetaVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_sigmaIetaIetaVsEta_

private

Definition at line 415 of file PhotonAnalyzer.h.

◆ h_tkChi2_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_tkChi2_

private

Definition at line 417 of file PhotonAnalyzer.h.

◆ h_trackPtSumHollow_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_trackPtSumHollow_

private

Definition at line 328 of file PhotonAnalyzer.h.

◆ h_trackPtSumHollowVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_trackPtSumHollowVsEt_

private

Definition at line 321 of file PhotonAnalyzer.h.

◆ h_trackPtSumHollowVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_trackPtSumHollowVsEta_

private

Definition at line 314 of file PhotonAnalyzer.h.

◆ h_trackPtSumSolid_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_trackPtSumSolid_

private

Definition at line 326 of file PhotonAnalyzer.h.

◆ h_trackPtSumSolidVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_trackPtSumSolidVsEt_

private

Definition at line 319 of file PhotonAnalyzer.h.

◆ h_trackPtSumSolidVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_trackPtSumSolidVsEta_

private

Definition at line 312 of file PhotonAnalyzer.h.

◆ h_vertexChi2Prob_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::h_vertexChi2Prob_

private

Definition at line 419 of file PhotonAnalyzer.h.

◆ histo_index_conversions_

int PhotonAnalyzer::histo_index_conversions_

private

Definition at line 192 of file PhotonAnalyzer.h.

◆ histo_index_efficiency_

int PhotonAnalyzer::histo_index_efficiency_

private

Definition at line 193 of file PhotonAnalyzer.h.

◆ histo_index_invMass_

int PhotonAnalyzer::histo_index_invMass_

private

Definition at line 194 of file PhotonAnalyzer.h.

◆ histo_index_photons_

int PhotonAnalyzer::histo_index_photons_

private

Definition at line 191 of file PhotonAnalyzer.h.

◆ hOverEBin_

int PhotonAnalyzer::hOverEBin_

private

Definition at line 236 of file PhotonAnalyzer.h.

◆ hOverEMax_

double PhotonAnalyzer::hOverEMax_

private

Definition at line 238 of file PhotonAnalyzer.h.

◆ hOverEMin_

double PhotonAnalyzer::hOverEMin_

private

Definition at line 237 of file PhotonAnalyzer.h.

◆ invMassEtCut_

double PhotonAnalyzer::invMassEtCut_

private

Definition at line 171 of file PhotonAnalyzer.h.

◆ isHeavyIon_

bool PhotonAnalyzer::isHeavyIon_

private

Definition at line 185 of file PhotonAnalyzer.h.

◆ isolationStrength_

int PhotonAnalyzer::isolationStrength_

private

Definition at line 183 of file PhotonAnalyzer.h.

◆ minimalSetOfHistos_

bool PhotonAnalyzer::minimalSetOfHistos_

private

Definition at line 180 of file PhotonAnalyzer.h.

◆ minPhoEtCut_

double PhotonAnalyzer::minPhoEtCut_

private

Definition at line 169 of file PhotonAnalyzer.h.

◆ nEvt_

int PhotonAnalyzer::nEvt_

private

Definition at line 196 of file PhotonAnalyzer.h.

◆ numberBin_

int PhotonAnalyzer::numberBin_

private

Definition at line 220 of file PhotonAnalyzer.h.

◆ numberMax_

double PhotonAnalyzer::numberMax_

private

Definition at line 222 of file PhotonAnalyzer.h.

◆ numberMin_

double PhotonAnalyzer::numberMin_

private

Definition at line 221 of file PhotonAnalyzer.h.

◆ numberOfSteps_

int PhotonAnalyzer::numberOfSteps_

private

Definition at line 174 of file PhotonAnalyzer.h.

◆ offline_pvToken_

edm::EDGetTokenT<reco::VertexCollection> PhotonAnalyzer::offline_pvToken_

private

Definition at line 167 of file PhotonAnalyzer.h.

◆ p_dCotTracksVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_dCotTracksVsEta_

private

Definition at line 375 of file PhotonAnalyzer.h.

◆ p_e1x5VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_e1x5VsEt_

private

Definition at line 358 of file PhotonAnalyzer.h.

◆ p_e1x5VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_e1x5VsEta_

private

Definition at line 359 of file PhotonAnalyzer.h.

◆ p_e2x5VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_e2x5VsEt_

private

Definition at line 361 of file PhotonAnalyzer.h.

◆ p_e2x5VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_e2x5VsEta_

private

Definition at line 362 of file PhotonAnalyzer.h.

◆ p_ecalSumVsEt_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::p_ecalSumVsEt_

private

Definition at line 427 of file PhotonAnalyzer.h.

◆ p_ecalSumVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_ecalSumVsEta_

private

Definition at line 347 of file PhotonAnalyzer.h.

◆ p_hcalSumVsEt_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::p_hcalSumVsEt_

private

Definition at line 428 of file PhotonAnalyzer.h.

◆ p_hcalSumVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_hcalSumVsEta_

private

Definition at line 348 of file PhotonAnalyzer.h.

◆ p_hOverEVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_hOverEVsEt_

private

Definition at line 378 of file PhotonAnalyzer.h.

◆ p_hOverEVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_hOverEVsEta_

private

Definition at line 377 of file PhotonAnalyzer.h.

◆ p_maxEXtalOver3x3VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_maxEXtalOver3x3VsEt_

private

Definition at line 364 of file PhotonAnalyzer.h.

◆ p_maxEXtalOver3x3VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_maxEXtalOver3x3VsEta_

private

Definition at line 365 of file PhotonAnalyzer.h.

◆ p_nHitsVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_nHitsVsEta_

private

Definition at line 421 of file PhotonAnalyzer.h.

◆ p_nTrackIsolHollowVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_nTrackIsolHollowVsEt_

private

Definition at line 352 of file PhotonAnalyzer.h.

◆ p_nTrackIsolHollowVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_nTrackIsolHollowVsEta_

private

Definition at line 345 of file PhotonAnalyzer.h.

◆ p_nTrackIsolSolidVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_nTrackIsolSolidVsEt_

private

Definition at line 350 of file PhotonAnalyzer.h.

◆ p_nTrackIsolSolidVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_nTrackIsolSolidVsEta_

private

Definition at line 343 of file PhotonAnalyzer.h.

◆ p_phoSigmaEoverEvsNVtx_

std::vector<std::vector<std::vector<MonitorElement*> > > PhotonAnalyzer::p_phoSigmaEoverEvsNVtx_

private

Definition at line 432 of file PhotonAnalyzer.h.

◆ p_r1x5VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_r1x5VsEt_

private

Definition at line 367 of file PhotonAnalyzer.h.

◆ p_r1x5VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_r1x5VsEta_

private

Definition at line 368 of file PhotonAnalyzer.h.

◆ p_r2x5VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_r2x5VsEt_

private

Definition at line 370 of file PhotonAnalyzer.h.

◆ p_r2x5VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_r2x5VsEta_

private

Definition at line 371 of file PhotonAnalyzer.h.

◆ p_r9VsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_r9VsEt_

private

Definition at line 355 of file PhotonAnalyzer.h.

◆ p_r9VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_r9VsEta_

private

Definition at line 356 of file PhotonAnalyzer.h.

◆ p_sigmaIetaIetaVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_sigmaIetaIetaVsEta_

private

Definition at line 373 of file PhotonAnalyzer.h.

◆ p_tkChi2VsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_tkChi2VsEta_

private

Definition at line 423 of file PhotonAnalyzer.h.

◆ p_trackPtSumHollowVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_trackPtSumHollowVsEt_

private

Definition at line 353 of file PhotonAnalyzer.h.

◆ p_trackPtSumHollowVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_trackPtSumHollowVsEta_

private

Definition at line 346 of file PhotonAnalyzer.h.

◆ p_trackPtSumSolidVsEt_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_trackPtSumSolidVsEt_

private

Definition at line 351 of file PhotonAnalyzer.h.

◆ p_trackPtSumSolidVsEta_

std::vector<std::vector<MonitorElement*> > PhotonAnalyzer::p_trackPtSumSolidVsEta_

private

Definition at line 344 of file PhotonAnalyzer.h.

◆ parts_

std::vector<std::string> PhotonAnalyzer::parts_

private

Definition at line 199 of file PhotonAnalyzer.h.

◆ phiBin_

int PhotonAnalyzer::phiBin_

private

Definition at line 212 of file PhotonAnalyzer.h.

◆ phiMax_

double PhotonAnalyzer::phiMax_

private

Definition at line 214 of file PhotonAnalyzer.h.

◆ phiMin_

double PhotonAnalyzer::phiMin_

private

Definition at line 213 of file PhotonAnalyzer.h.

◆ photon_token_

edm::EDGetTokenT<std::vector<reco::Photon> > PhotonAnalyzer::photon_token_

private

Definition at line 161 of file PhotonAnalyzer.h.

◆ PhotonIDLoose_token_

edm::EDGetTokenT<edm::ValueMap<bool> > PhotonAnalyzer::PhotonIDLoose_token_

private

Definition at line 162 of file PhotonAnalyzer.h.

◆ PhotonIDTight_token_

edm::EDGetTokenT<edm::ValueMap<bool> > PhotonAnalyzer::PhotonIDTight_token_

private

Definition at line 163 of file PhotonAnalyzer.h.

◆ photonMaxEta_

double PhotonAnalyzer::photonMaxEta_

private

Definition at line 170 of file PhotonAnalyzer.h.

◆ prescaleFactor_

unsigned int PhotonAnalyzer::prescaleFactor_

private

Definition at line 159 of file PhotonAnalyzer.h.

◆ r9Bin_

int PhotonAnalyzer::r9Bin_

private

Definition at line 224 of file PhotonAnalyzer.h.

◆ r9Max_

double PhotonAnalyzer::r9Max_

private

Definition at line 226 of file PhotonAnalyzer.h.

◆ r9Min_

double PhotonAnalyzer::r9Min_

private

Definition at line 225 of file PhotonAnalyzer.h.

◆ rBin_

int PhotonAnalyzer::rBin_

private

Definition at line 260 of file PhotonAnalyzer.h.

◆ reducedEtaBin_

int PhotonAnalyzer::reducedEtaBin_

private

Definition at line 273 of file PhotonAnalyzer.h.

◆ reducedEtBin_

int PhotonAnalyzer::reducedEtBin_

private

Definition at line 272 of file PhotonAnalyzer.h.

◆ reducedR9Bin_

int PhotonAnalyzer::reducedR9Bin_

private

Definition at line 274 of file PhotonAnalyzer.h.

◆ reducedSumBin_

int PhotonAnalyzer::reducedSumBin_

private

Definition at line 275 of file PhotonAnalyzer.h.

◆ rMax_

double PhotonAnalyzer::rMax_

private

Definition at line 262 of file PhotonAnalyzer.h.

◆ rMin_

double PhotonAnalyzer::rMin_

private

Definition at line 261 of file PhotonAnalyzer.h.

◆ sigmaIetaBin_

int PhotonAnalyzer::sigmaIetaBin_

private

Definition at line 228 of file PhotonAnalyzer.h.

◆ sigmaIetaMax_

double PhotonAnalyzer::sigmaIetaMax_

private

Definition at line 230 of file PhotonAnalyzer.h.

◆ sigmaIetaMin_

double PhotonAnalyzer::sigmaIetaMin_

private

Definition at line 229 of file PhotonAnalyzer.h.

◆ standAlone_

bool PhotonAnalyzer::standAlone_

private

Definition at line 178 of file PhotonAnalyzer.h.

◆ sumBin_

int PhotonAnalyzer::sumBin_

private

Definition at line 232 of file PhotonAnalyzer.h.

◆ sumMax_

double PhotonAnalyzer::sumMax_

private

Definition at line 234 of file PhotonAnalyzer.h.

◆ sumMin_

double PhotonAnalyzer::sumMin_

private

Definition at line 233 of file PhotonAnalyzer.h.

◆ totalNumberOfHistos_conversionsFolder

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_conversionsFolder

private

Definition at line 280 of file PhotonAnalyzer.h.

◆ totalNumberOfHistos_efficiencyFolder

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_efficiencyFolder

private

Definition at line 277 of file PhotonAnalyzer.h.

◆ totalNumberOfHistos_invMassFolder

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_invMassFolder

private

Definition at line 278 of file PhotonAnalyzer.h.

◆ totalNumberOfHistos_photonsFolder

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_photonsFolder

private

Definition at line 279 of file PhotonAnalyzer.h.

◆ triggerEvent_token_

edm::EDGetTokenT<trigger::TriggerEvent> PhotonAnalyzer::triggerEvent_token_

private

Definition at line 166 of file PhotonAnalyzer.h.

◆ types_

std::vector<std::string> PhotonAnalyzer::types_

private

Definition at line 198 of file PhotonAnalyzer.h.

◆ useBinning_

bool PhotonAnalyzer::useBinning_

private

Definition at line 176 of file PhotonAnalyzer.h.

◆ useTriggerFiltering_

bool PhotonAnalyzer::useTriggerFiltering_

private

Definition at line 177 of file PhotonAnalyzer.h.

◆ xBin_

int PhotonAnalyzer::xBin_

private

Definition at line 264 of file PhotonAnalyzer.h.

◆ xMax_

double PhotonAnalyzer::xMax_

private

Definition at line 266 of file PhotonAnalyzer.h.

◆ xMin_

double PhotonAnalyzer::xMin_

private

Definition at line 265 of file PhotonAnalyzer.h.

◆ yBin_

int PhotonAnalyzer::yBin_

private

Definition at line 268 of file PhotonAnalyzer.h.

◆ yMax_

double PhotonAnalyzer::yMax_

private

Definition at line 270 of file PhotonAnalyzer.h.

◆ yMin_

double PhotonAnalyzer::yMin_

private

Definition at line 269 of file PhotonAnalyzer.h.

◆ zBin_

int PhotonAnalyzer::zBin_

private

Definition at line 256 of file PhotonAnalyzer.h.

◆ zMax_

double PhotonAnalyzer::zMax_

private

Definition at line 258 of file PhotonAnalyzer.h.

◆ zMin_

double PhotonAnalyzer::zMin_

private

Definition at line 257 of file PhotonAnalyzer.h.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PhotonAnalyzer()

◆ ~PhotonAnalyzer()

Member Function Documentation

◆ analyze()

◆ book2DHistoVector()

◆ book3DHistoVector()

◆ bookHisto()

◆ bookHistograms()

◆ bookHistogramsConversions()

◆ bookHistogramsEfficiency()

◆ bookHistogramsForHistogramCounts()

◆ bookHistogramsInvMass()

◆ bookHistogramsPhotons()

◆ fill2DHistoVector() [1/2]

◆ fill2DHistoVector() [2/2]

◆ fill3DHistoVector() [1/2]

◆ fill3DHistoVector() [2/2]

◆ fillHistogramsForHistogramCounts()

◆ phiNormalization()

◆ photonSelection()

◆ photonSelectionSlimmed()

Member Data Documentation

◆ barrelRecHit_token_

◆ chi2Bin_

◆ chi2Max_

◆ chi2Min_

◆ currentFolder_

◆ cutStep_

◆ dEtaTracksBin_

◆ dEtaTracksMax_

◆ dEtaTracksMin_

◆ dPhiTracksBin_

◆ dPhiTracksMax_

◆ dPhiTracksMin_

◆ eBin_

◆ eMax_

◆ eMin_

◆ endcapRecHit_token_

◆ eOverPBin_

◆ eOverPMax_

◆ eOverPMin_

◆ etaBin_

◆ etaMax_

◆ etaMin_

◆ etBin_

◆ etMax_

◆ etMin_

◆ excludeBkgHistos_

◆ fName_

◆ h_chHadIsoBarrel_

◆ h_chHadIsoEndcap_

◆ h_convEt_Loose_

◆ h_convEt_Tight_

◆ h_convEta_Loose_

◆ h_convEta_Tight_

◆ h_convVtxR_

◆ h_convVtxRvsZ_

◆ h_convVtxYvsX_

◆ h_convVtxZ_

◆ h_convVtxZEndcap_

◆ h_dCotTracks_

◆ h_dEtaTracksAtEcal_

◆ h_dPhiTracksAtEcal_

◆ h_dPhiTracksAtVtx_

◆ h_e1x5VsEt_

◆ h_e1x5VsEta_

◆ h_e2x5VsEt_

◆ h_e2x5VsEta_

◆ h_ecalSum_

◆ h_ecalSumEBarrel_

◆ h_ecalSumEEndcap_

◆ h_ecalSumVsEt_

◆ h_ecalSumVsEta_

◆ h_eOverPTracks_