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	beginRun (edm::Run const &, edm::EventSetup const &) final

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer (void)

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

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

uint32_t	streamId () const

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

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

	~EDAnalyzerBase () override

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

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

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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

virtual	~EDConsumerBase () noexcept(false)

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 edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

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

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

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

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

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

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

Detailed Description

EgammaCoreTools.

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

Definition at line 101 of file PhotonAnalyzer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 20 of file PhotonAnalyzer.cc.

References edm::ParameterSet::getParameter(), and edm::ParameterSet::getUntrackedParameter().

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

override

Definition at line 140 of file PhotonAnalyzer.cc.

141 {

142 }

Member Function Documentation

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

override

End loop over Reco photons

Definition at line 608 of file PhotonAnalyzer.cc.

References edm::SortedCollection< T, SORT >::begin(), reco::Photon::chargedHadronIso(), ChiSquaredProbability(), conversions_cfi::conversions, reco::Photon::conversions(), TkAlMuonSelectors_cfi::cut, deltaR(), reco::deltaR(), deltaRMax, PFJetFilter_cfi::deltaRMin, 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(), HcalObjRepresent::Fill(), trigger::TriggerEvent::filterKeys(), trigger::TriggerEvent::filterTag(), objects.autophobj::float, edm::Event::getByToken(), reco::Photon::getCandidateP4type(), reco::Photon::getCorrectedEnergyError(), trigger::TriggerEvent::getObjects(), reco::Photon::hadronicDepth1OverEm(), reco::Photon::hadronicDepth2OverEm(), reco::Photon::hadronicOverEm(), reco::Photon::hasConversionTracks(), reco::Photon::hcalTowerSumEtConeDR04(), mps_fire::i, edm::EventBase::id(), reco::Photon::isEB(), reco::Photon::isEE(), edm::Ref< C, T, F >::isNonnull(), edm::HandleBase::isValid(), edm::InputTag::label(), diffTwoXMLs::label, reco::Photon::maxEnergyXtal(), reco::Photon::neutralHadronIso(), reco::Photon::nTrkHollowConeDR04(), reco::Photon::nTrkSolidConeDR04(), reco::Photon::p4(), reco::LeafCandidate::phi(), correctedPhotons_cfi::photonCollection, reco::Photon::photonIso(), edm::Handle< T >::product(), reco::Photon::r1x5(), reco::Photon::r2x5(), reco::Photon::r9(), hitfit::scalar(), reco::Photon::sigmaIetaIeta(), edm::RefVector< C, T, F >::size(), trigger::TriggerEvent::sizeFilters(), mathSSE::sqrt(), reco::Photon::superCluster(), l1t::tracks, reco::Photon::trkSumPtHollowConeDR04(), reco::Photon::trkSumPtSolidConeDR04(), and funct::true.

 {
   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->hadronicDepth1OverEm(),cut,type,part);
     fill3DHistoVector(h_h2OverE_,aPho->hadronicDepth2OverEm(),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

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 495 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), gather_cfg::cout, TkAlMuonSelectors_cfi::cut, callgraph::kind, DQMStore::IBooker::pwd(), DQMStore::IBooker::setCurrentFolder(), fftjetcommon_cfi::title, TrackerOfflineValidation_Dqm_cff::xmax, TrackerOfflineValidation_Dqm_cff::xmin, Phase2TrackerMonitorDigi_cff::ymax, and Phase2TrackerMonitorDigi_cff::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();
   }
 }

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 552 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), gather_cfg::cout, TkAlMuonSelectors_cfi::cut, callgraph::kind, DQMStore::IBooker::pwd(), DQMStore::IBooker::setCurrentFolder(), fftjetcommon_cfi::title, TrackerOfflineValidation_Dqm_cff::xmax, TrackerOfflineValidation_Dqm_cff::xmin, Phase2TrackerMonitorDigi_cff::ymax, and Phase2TrackerMonitorDigi_cff::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();
   }
 }

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

private

Definition at line 471 of file PhotonAnalyzer.cc.

References stringResolutionProvider_cfi::bin, DQMStore::IBooker::book1D(), SiStripPI::max, min(), DQMStore::IBooker::pwd(), and fftjetcommon_cfi::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);
 }

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 144 of file PhotonAnalyzer.cc.

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

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

private

Definition at line 429 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::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);
 }

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

private

Definition at line 177 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::book1D(), TkAlMuonSelectors_cfi::cut, and DQMStore::IBooker::setCurrentFolder().

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

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

private

Definition at line 158 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::bookInt(), and DQMStore::IBooker::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");
 }

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

private

Definition at line 226 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::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",                                          80,    -0.5,  79.5);    
 }

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

private

Definition at line 243 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",80, -0.5, 79.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_);
 }

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

private

Referenced by phiNormalization().

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

private

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

private

Referenced by phiNormalization().

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

private

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

private

Definition at line 168 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::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_);
 }

float PhotonAnalyzer::phiNormalization ( float & a )

private

Definition at line 1146 of file PhotonAnalyzer.cc.

References TkAlMuonSelectors_cfi::cut, fill2DHistoVector(), fill3DHistoVector(), PI, findQualityFiles::size, 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;
 }

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 1185 of file PhotonAnalyzer.cc.

References reco::Photon::chargedHadronIso(), reco::LeafCandidate::eta(), funct::false, 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;  
 }

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

private

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

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

private

Definition at line 152 of file PhotonAnalyzer.h.

int PhotonAnalyzer::chi2Bin_

private

Definition at line 240 of file PhotonAnalyzer.h.

double PhotonAnalyzer::chi2Max_

private

Definition at line 242 of file PhotonAnalyzer.h.

double PhotonAnalyzer::chi2Min_

private

Definition at line 241 of file PhotonAnalyzer.h.

std::stringstream PhotonAnalyzer::currentFolder_

private

Definition at line 177 of file PhotonAnalyzer.h.

double PhotonAnalyzer::cutStep_

private

Definition at line 161 of file PhotonAnalyzer.h.

int PhotonAnalyzer::dEtaTracksBin_

private

Definition at line 236 of file PhotonAnalyzer.h.

double PhotonAnalyzer::dEtaTracksMax_

private

Definition at line 238 of file PhotonAnalyzer.h.

double PhotonAnalyzer::dEtaTracksMin_

private

Definition at line 237 of file PhotonAnalyzer.h.

int PhotonAnalyzer::dPhiTracksBin_

private

Definition at line 232 of file PhotonAnalyzer.h.

double PhotonAnalyzer::dPhiTracksMax_

private

Definition at line 234 of file PhotonAnalyzer.h.

double PhotonAnalyzer::dPhiTracksMin_

private

Definition at line 233 of file PhotonAnalyzer.h.

int PhotonAnalyzer::eBin_

private

Definition at line 204 of file PhotonAnalyzer.h.

double PhotonAnalyzer::eMax_

private

Definition at line 206 of file PhotonAnalyzer.h.

double PhotonAnalyzer::eMin_

private

Definition at line 205 of file PhotonAnalyzer.h.

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

private

Definition at line 153 of file PhotonAnalyzer.h.

int PhotonAnalyzer::eOverPBin_

private

Definition at line 228 of file PhotonAnalyzer.h.

double PhotonAnalyzer::eOverPMax_

private

Definition at line 230 of file PhotonAnalyzer.h.

double PhotonAnalyzer::eOverPMin_

private

Definition at line 229 of file PhotonAnalyzer.h.

int PhotonAnalyzer::etaBin_

private

Definition at line 192 of file PhotonAnalyzer.h.

double PhotonAnalyzer::etaMax_

private

Definition at line 194 of file PhotonAnalyzer.h.

double PhotonAnalyzer::etaMin_

private

Definition at line 193 of file PhotonAnalyzer.h.

int PhotonAnalyzer::etBin_

private

Definition at line 196 of file PhotonAnalyzer.h.

double PhotonAnalyzer::etMax_

private

Definition at line 198 of file PhotonAnalyzer.h.

double PhotonAnalyzer::etMin_

private

Definition at line 197 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::excludeBkgHistos_

private

Definition at line 169 of file PhotonAnalyzer.h.

std::string PhotonAnalyzer::fName_

private

Definition at line 145 of file PhotonAnalyzer.h.

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

private

Definition at line 326 of file PhotonAnalyzer.h.

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

private

Definition at line 327 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_convEt_Loose_

private

Definition at line 284 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_convEt_Tight_

private

Definition at line 285 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_convEta_Loose_

private

Definition at line 282 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_convEta_Tight_

private

Definition at line 283 of file PhotonAnalyzer.h.

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

private

Definition at line 383 of file PhotonAnalyzer.h.

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

private

Definition at line 379 of file PhotonAnalyzer.h.

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

private

Definition at line 382 of file PhotonAnalyzer.h.

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

private

Definition at line 381 of file PhotonAnalyzer.h.

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

private

Definition at line 380 of file PhotonAnalyzer.h.

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

private

Definition at line 445 of file PhotonAnalyzer.h.

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

private

Definition at line 450 of file PhotonAnalyzer.h.

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

private

Definition at line 448 of file PhotonAnalyzer.h.

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

private

Definition at line 447 of file PhotonAnalyzer.h.

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

private

Definition at line 388 of file PhotonAnalyzer.h.

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

private

Definition at line 389 of file PhotonAnalyzer.h.

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

private

Definition at line 391 of file PhotonAnalyzer.h.

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

private

Definition at line 392 of file PhotonAnalyzer.h.

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

private

Definition at line 317 of file PhotonAnalyzer.h.

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

private

Definition at line 318 of file PhotonAnalyzer.h.

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

private

Definition at line 319 of file PhotonAnalyzer.h.

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

private

Definition at line 310 of file PhotonAnalyzer.h.

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

private

Definition at line 303 of file PhotonAnalyzer.h.

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

private

Definition at line 442 of file PhotonAnalyzer.h.

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

private

Definition at line 429 of file PhotonAnalyzer.h.

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

private

Definition at line 430 of file PhotonAnalyzer.h.

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

private

Definition at line 320 of file PhotonAnalyzer.h.

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

private

Definition at line 321 of file PhotonAnalyzer.h.

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

private

Definition at line 322 of file PhotonAnalyzer.h.

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

private

Definition at line 311 of file PhotonAnalyzer.h.

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

private

Definition at line 304 of file PhotonAnalyzer.h.

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

private

Definition at line 428 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassAllPhotons_

private

Definition at line 292 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassOneWithTracks_

private

Definition at line 290 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEBarrel_

private

Definition at line 293 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEEndcap_

private

Definition at line 294 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEEndcapEBarrel_

private

Definition at line 295 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassTwoWithTracks_

private

Definition at line 289 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassZeroWithTracks_

private

Definition at line 291 of file PhotonAnalyzer.h.

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

private

Definition at line 394 of file PhotonAnalyzer.h.

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

private

Definition at line 395 of file PhotonAnalyzer.h.

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

private

Definition at line 440 of file PhotonAnalyzer.h.

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

private

Definition at line 328 of file PhotonAnalyzer.h.

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

private

Definition at line 329 of file PhotonAnalyzer.h.

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

private

Definition at line 434 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_nRecoVtx_

private

Definition at line 270 of file PhotonAnalyzer.h.

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

private

Definition at line 315 of file PhotonAnalyzer.h.

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

private

Definition at line 308 of file PhotonAnalyzer.h.

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

private

Definition at line 301 of file PhotonAnalyzer.h.

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

private

Definition at line 313 of file PhotonAnalyzer.h.

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

private

Definition at line 306 of file PhotonAnalyzer.h.

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

private

Definition at line 299 of file PhotonAnalyzer.h.

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

private

Definition at line 436 of file PhotonAnalyzer.h.

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

private

Definition at line 437 of file PhotonAnalyzer.h.

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

private

Definition at line 377 of file PhotonAnalyzer.h.

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

private

Definition at line 371 of file PhotonAnalyzer.h.

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

private

Definition at line 426 of file PhotonAnalyzer.h.

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

private

Definition at line 425 of file PhotonAnalyzer.h.

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

private

Definition at line 438 of file PhotonAnalyzer.h.

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

private

Definition at line 418 of file PhotonAnalyzer.h.

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

private

Definition at line 421 of file PhotonAnalyzer.h.

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

private

Definition at line 374 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEt_Loose_

private

Definition at line 274 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEt_postHLT_

private

Definition at line 280 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEt_preHLT_

private

Definition at line 279 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEt_Tight_

private

Definition at line 275 of file PhotonAnalyzer.h.

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

private

Definition at line 368 of file PhotonAnalyzer.h.

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

private

Definition at line 373 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEta_Loose_

private

Definition at line 272 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEta_postHLT_

private

Definition at line 278 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEta_preHLT_

private

Definition at line 277 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEta_Tight_

private

Definition at line 273 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEta_Vertex_

private

Definition at line 287 of file PhotonAnalyzer.h.

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

private

Definition at line 324 of file PhotonAnalyzer.h.

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

private

Definition at line 325 of file PhotonAnalyzer.h.

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

private

Definition at line 423 of file PhotonAnalyzer.h.

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

private

Definition at line 375 of file PhotonAnalyzer.h.

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

private

Definition at line 419 of file PhotonAnalyzer.h.

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

private

Definition at line 432 of file PhotonAnalyzer.h.

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

private

Definition at line 443 of file PhotonAnalyzer.h.

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

private

Definition at line 397 of file PhotonAnalyzer.h.

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

private

Definition at line 398 of file PhotonAnalyzer.h.

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

private

Definition at line 400 of file PhotonAnalyzer.h.

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

private

Definition at line 401 of file PhotonAnalyzer.h.

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

private

Definition at line 422 of file PhotonAnalyzer.h.

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

private

Definition at line 385 of file PhotonAnalyzer.h.

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

private

Definition at line 386 of file PhotonAnalyzer.h.

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

private

Definition at line 369 of file PhotonAnalyzer.h.

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

private

Definition at line 424 of file PhotonAnalyzer.h.

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

private

Definition at line 403 of file PhotonAnalyzer.h.

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

private

Definition at line 405 of file PhotonAnalyzer.h.

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

private

Definition at line 316 of file PhotonAnalyzer.h.

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

private

Definition at line 309 of file PhotonAnalyzer.h.

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

private

Definition at line 302 of file PhotonAnalyzer.h.

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

private

Definition at line 314 of file PhotonAnalyzer.h.

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

private

Definition at line 307 of file PhotonAnalyzer.h.

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

private

Definition at line 300 of file PhotonAnalyzer.h.

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

private

Definition at line 407 of file PhotonAnalyzer.h.

int PhotonAnalyzer::histo_index_conversions_

private

Definition at line 180 of file PhotonAnalyzer.h.

int PhotonAnalyzer::histo_index_efficiency_

private

Definition at line 181 of file PhotonAnalyzer.h.

int PhotonAnalyzer::histo_index_invMass_

private

Definition at line 182 of file PhotonAnalyzer.h.

int PhotonAnalyzer::histo_index_photons_

private

Definition at line 179 of file PhotonAnalyzer.h.

int PhotonAnalyzer::hOverEBin_

private

Definition at line 224 of file PhotonAnalyzer.h.

double PhotonAnalyzer::hOverEMax_

private

Definition at line 226 of file PhotonAnalyzer.h.

double PhotonAnalyzer::hOverEMin_

private

Definition at line 225 of file PhotonAnalyzer.h.

double PhotonAnalyzer::invMassEtCut_

private

Definition at line 159 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::isHeavyIon_

private

Definition at line 173 of file PhotonAnalyzer.h.

int PhotonAnalyzer::isolationStrength_

private

Definition at line 171 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::minimalSetOfHistos_

private

Definition at line 168 of file PhotonAnalyzer.h.

double PhotonAnalyzer::minPhoEtCut_

private

Definition at line 157 of file PhotonAnalyzer.h.

int PhotonAnalyzer::nEvt_

private

Definition at line 184 of file PhotonAnalyzer.h.

int PhotonAnalyzer::numberBin_

private

Definition at line 208 of file PhotonAnalyzer.h.

double PhotonAnalyzer::numberMax_

private

Definition at line 210 of file PhotonAnalyzer.h.

double PhotonAnalyzer::numberMin_

private

Definition at line 209 of file PhotonAnalyzer.h.

int PhotonAnalyzer::numberOfSteps_

private

Definition at line 162 of file PhotonAnalyzer.h.

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

private

Definition at line 155 of file PhotonAnalyzer.h.

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

private

Definition at line 363 of file PhotonAnalyzer.h.

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

private

Definition at line 346 of file PhotonAnalyzer.h.

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

private

Definition at line 347 of file PhotonAnalyzer.h.

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

private

Definition at line 349 of file PhotonAnalyzer.h.

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

private

Definition at line 350 of file PhotonAnalyzer.h.

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

private

Definition at line 415 of file PhotonAnalyzer.h.

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

private

Definition at line 335 of file PhotonAnalyzer.h.

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

private

Definition at line 416 of file PhotonAnalyzer.h.

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

private

Definition at line 336 of file PhotonAnalyzer.h.

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

private

Definition at line 366 of file PhotonAnalyzer.h.

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

private

Definition at line 365 of file PhotonAnalyzer.h.

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

private

Definition at line 352 of file PhotonAnalyzer.h.

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

private

Definition at line 353 of file PhotonAnalyzer.h.

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

private

Definition at line 409 of file PhotonAnalyzer.h.

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

private

Definition at line 340 of file PhotonAnalyzer.h.

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

private

Definition at line 333 of file PhotonAnalyzer.h.

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

private

Definition at line 338 of file PhotonAnalyzer.h.

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

private

Definition at line 331 of file PhotonAnalyzer.h.

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

private

Definition at line 420 of file PhotonAnalyzer.h.

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

private

Definition at line 355 of file PhotonAnalyzer.h.

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

private

Definition at line 356 of file PhotonAnalyzer.h.

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

private

Definition at line 358 of file PhotonAnalyzer.h.

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

private

Definition at line 359 of file PhotonAnalyzer.h.

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

private

Definition at line 343 of file PhotonAnalyzer.h.

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

private

Definition at line 344 of file PhotonAnalyzer.h.

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

private

Definition at line 361 of file PhotonAnalyzer.h.

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

private

Definition at line 411 of file PhotonAnalyzer.h.

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

private

Definition at line 341 of file PhotonAnalyzer.h.

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

private

Definition at line 334 of file PhotonAnalyzer.h.

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

private

Definition at line 339 of file PhotonAnalyzer.h.

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

private

Definition at line 332 of file PhotonAnalyzer.h.

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

private

Definition at line 187 of file PhotonAnalyzer.h.

int PhotonAnalyzer::phiBin_

private

Definition at line 200 of file PhotonAnalyzer.h.

double PhotonAnalyzer::phiMax_

private

Definition at line 202 of file PhotonAnalyzer.h.

double PhotonAnalyzer::phiMin_

private

Definition at line 201 of file PhotonAnalyzer.h.

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

private

Definition at line 149 of file PhotonAnalyzer.h.

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

private

Definition at line 150 of file PhotonAnalyzer.h.

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

private

Definition at line 151 of file PhotonAnalyzer.h.

double PhotonAnalyzer::photonMaxEta_

private

Definition at line 158 of file PhotonAnalyzer.h.

unsigned int PhotonAnalyzer::prescaleFactor_

private

Definition at line 147 of file PhotonAnalyzer.h.

int PhotonAnalyzer::r9Bin_

private

Definition at line 212 of file PhotonAnalyzer.h.

double PhotonAnalyzer::r9Max_

private

Definition at line 214 of file PhotonAnalyzer.h.

double PhotonAnalyzer::r9Min_

private

Definition at line 213 of file PhotonAnalyzer.h.

int PhotonAnalyzer::rBin_

private

Definition at line 248 of file PhotonAnalyzer.h.

int PhotonAnalyzer::reducedEtaBin_

private

Definition at line 261 of file PhotonAnalyzer.h.

int PhotonAnalyzer::reducedEtBin_

private

Definition at line 260 of file PhotonAnalyzer.h.

int PhotonAnalyzer::reducedR9Bin_

private

Definition at line 262 of file PhotonAnalyzer.h.

int PhotonAnalyzer::reducedSumBin_

private

Definition at line 263 of file PhotonAnalyzer.h.

double PhotonAnalyzer::rMax_

private

Definition at line 250 of file PhotonAnalyzer.h.

double PhotonAnalyzer::rMin_

private

Definition at line 249 of file PhotonAnalyzer.h.

int PhotonAnalyzer::sigmaIetaBin_

private

Definition at line 216 of file PhotonAnalyzer.h.

double PhotonAnalyzer::sigmaIetaMax_

private

Definition at line 218 of file PhotonAnalyzer.h.

double PhotonAnalyzer::sigmaIetaMin_

private

Definition at line 217 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::standAlone_

private

Definition at line 166 of file PhotonAnalyzer.h.

int PhotonAnalyzer::sumBin_

private

Definition at line 220 of file PhotonAnalyzer.h.

double PhotonAnalyzer::sumMax_

private

Definition at line 222 of file PhotonAnalyzer.h.

double PhotonAnalyzer::sumMin_

private

Definition at line 221 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_conversionsFolder

private

Definition at line 268 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_efficiencyFolder

private

Definition at line 265 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_invMassFolder

private

Definition at line 266 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_photonsFolder

private

Definition at line 267 of file PhotonAnalyzer.h.

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

private

Definition at line 154 of file PhotonAnalyzer.h.

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

private

Definition at line 186 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::useBinning_

private

Definition at line 164 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::useTriggerFiltering_

private

Definition at line 165 of file PhotonAnalyzer.h.

int PhotonAnalyzer::xBin_

private

Definition at line 252 of file PhotonAnalyzer.h.

double PhotonAnalyzer::xMax_

private

Definition at line 254 of file PhotonAnalyzer.h.

double PhotonAnalyzer::xMin_

private

Definition at line 253 of file PhotonAnalyzer.h.

int PhotonAnalyzer::yBin_

private

Definition at line 256 of file PhotonAnalyzer.h.

double PhotonAnalyzer::yMax_

private

Definition at line 258 of file PhotonAnalyzer.h.

double PhotonAnalyzer::yMin_

private

Definition at line 257 of file PhotonAnalyzer.h.

int PhotonAnalyzer::zBin_

private

Definition at line 244 of file PhotonAnalyzer.h.

double PhotonAnalyzer::zMax_

private

Definition at line 246 of file PhotonAnalyzer.h.

double PhotonAnalyzer::zMin_

private

Definition at line 245 of file PhotonAnalyzer.h.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation