PhotonAnalyzer Class Reference

EgammaCoreTools. More...

#include <PhotonAnalyzer.h>

Inheritance diagram for PhotonAnalyzer:

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
	PhotonAnalyzer (const edm::ParameterSet &)
	~PhotonAnalyzer () override
Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer ()
void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
void	book2DHistoVector (DQMStore::IBooker &, std::vector< std::vector< MonitorElement *> > &toFill, std::string histoType, std::string histoName, std::string title, int xbin, double xmin, double xmax, int ybin=1, double ymin=1, double ymax=2)
void	book3DHistoVector (DQMStore::IBooker &, std::vector< std::vector< std::vector< MonitorElement *> > > &toFill, std::string histoType, std::string histoName, std::string title, int xbin, double xmin, double xmax, int ybin=1, double ymin=1, double ymax=2)
MonitorElement *	bookHisto (DQMStore::IBooker &, std::string histoName, std::string title, int bin, double min, double max)
void	bookHistogramsConversions (DQMStore::IBooker &)
void	bookHistogramsEfficiency (DQMStore::IBooker &)
void	bookHistogramsForHistogramCounts (DQMStore::IBooker &)
void	bookHistogramsInvMass (DQMStore::IBooker &)
void	bookHistogramsPhotons (DQMStore::IBooker &)
void	fill2DHistoVector (std::vector< std::vector< MonitorElement *> > &histoVector, double x, int cut, int type)
void	fill2DHistoVector (std::vector< std::vector< MonitorElement *> > &histoVector, double x, double y, int cut, int type)
void	fill3DHistoVector (std::vector< std::vector< std::vector< MonitorElement *> > > &histoVector, double x, int cut, int type, int part)
void	fill3DHistoVector (std::vector< std::vector< std::vector< MonitorElement *> > > &histoVector, double x, double y, int cut, int type, int part)
void	fillHistogramsForHistogramCounts (DQMStore::IBooker &)
float	phiNormalization (float &a)
bool	photonSelection (const reco::Photon *p)
bool	photonSelectionSlimmed (const reco::Photon *p)

Private Attributes
edm::EDGetTokenT< edm::SortedCollection< EcalRecHit, edm::StrictWeakOrdering< EcalRecHit > > >	barrelRecHit_token_
int	chi2Bin_
double	chi2Max_
double	chi2Min_
std::stringstream	currentFolder_
double	cutStep_
int	dEtaTracksBin_
double	dEtaTracksMax_
double	dEtaTracksMin_
int	dPhiTracksBin_
double	dPhiTracksMax_
double	dPhiTracksMin_
int	eBin_
double	eMax_
double	eMin_
edm::EDGetTokenT< edm::SortedCollection< EcalRecHit, edm::StrictWeakOrdering< EcalRecHit > > >	endcapRecHit_token_
int	eOverPBin_
double	eOverPMax_
double	eOverPMin_
int	etaBin_
double	etaMax_
double	etaMin_
int	etBin_
double	etMax_
double	etMin_
bool	excludeBkgHistos_
std::string	fName_
std::vector< std::vector< MonitorElement * > >	h_chHadIsoBarrel_
std::vector< std::vector< MonitorElement * > >	h_chHadIsoEndcap_
MonitorElement *	h_convEt_Loose_
MonitorElement *	h_convEt_Tight_
MonitorElement *	h_convEta_Loose_
MonitorElement *	h_convEta_Tight_
std::vector< std::vector< MonitorElement * > >	h_convVtxR_
std::vector< std::vector< MonitorElement * > >	h_convVtxRvsZ_
std::vector< std::vector< MonitorElement * > >	h_convVtxYvsX_
std::vector< std::vector< MonitorElement * > >	h_convVtxZ_
std::vector< std::vector< MonitorElement * > >	h_convVtxZEndcap_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_dCotTracks_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_dEtaTracksAtEcal_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_dPhiTracksAtEcal_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_dPhiTracksAtVtx_
std::vector< std::vector< MonitorElement * > >	h_e1x5VsEt_
std::vector< std::vector< MonitorElement * > >	h_e1x5VsEta_
std::vector< std::vector< MonitorElement * > >	h_e2x5VsEt_
std::vector< std::vector< MonitorElement * > >	h_e2x5VsEta_
std::vector< std::vector< MonitorElement * > >	h_ecalSum_
std::vector< std::vector< MonitorElement * > >	h_ecalSumEBarrel_
std::vector< std::vector< MonitorElement * > >	h_ecalSumEEndcap_
std::vector< std::vector< MonitorElement * > >	h_ecalSumVsEt_
std::vector< std::vector< MonitorElement * > >	h_ecalSumVsEta_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_eOverPTracks_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_h1OverE_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_h2OverE_
std::vector< std::vector< MonitorElement * > >	h_hcalSum_
std::vector< std::vector< MonitorElement * > >	h_hcalSumEBarrel_
std::vector< std::vector< MonitorElement * > >	h_hcalSumEEndcap_
std::vector< std::vector< MonitorElement * > >	h_hcalSumVsEt_
std::vector< std::vector< MonitorElement * > >	h_hcalSumVsEta_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_hOverE_
MonitorElement *	h_invMassAllPhotons_
MonitorElement *	h_invMassOneWithTracks_
MonitorElement *	h_invMassPhotonsEBarrel_
MonitorElement *	h_invMassPhotonsEEndcap_
MonitorElement *	h_invMassPhotonsEEndcapEBarrel_
MonitorElement *	h_invMassTwoWithTracks_
MonitorElement *	h_invMassZeroWithTracks_
std::vector< std::vector< MonitorElement * > >	h_maxEXtalOver3x3VsEt_
std::vector< std::vector< MonitorElement * > >	h_maxEXtalOver3x3VsEta_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_nConv_
std::vector< std::vector< MonitorElement * > >	h_nHadIsoBarrel_
std::vector< std::vector< MonitorElement * > >	h_nHadIsoEndcap_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_nPho_
MonitorElement *	h_nRecoVtx_
std::vector< std::vector< MonitorElement * > >	h_nTrackIsolHollow_
std::vector< std::vector< MonitorElement * > >	h_nTrackIsolHollowVsEt_
std::vector< std::vector< MonitorElement * > >	h_nTrackIsolHollowVsEta_
std::vector< std::vector< MonitorElement * > >	h_nTrackIsolSolid_
std::vector< std::vector< MonitorElement * > >	h_nTrackIsolSolidVsEt_
std::vector< std::vector< MonitorElement * > >	h_nTrackIsolSolidVsEta_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoConvE_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoConvEt_
std::vector< std::vector< MonitorElement * > >	h_phoConvEta_
std::vector< std::vector< MonitorElement * > >	h_phoConvEtaForEfficiency_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoConvPhi_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoConvPhiForEfficiency_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoConvR9_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoE_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoEt_
std::vector< std::vector< MonitorElement * > >	h_phoEt_BadChannels_
MonitorElement *	h_phoEt_Loose_
MonitorElement *	h_phoEt_postHLT_
MonitorElement *	h_phoEt_preHLT_
MonitorElement *	h_phoEt_Tight_
std::vector< std::vector< MonitorElement * > >	h_phoEta_
std::vector< std::vector< MonitorElement * > >	h_phoEta_BadChannels_
MonitorElement *	h_phoEta_Loose_
MonitorElement *	h_phoEta_postHLT_
MonitorElement *	h_phoEta_preHLT_
MonitorElement *	h_phoEta_Tight_
MonitorElement *	h_phoEta_Vertex_
std::vector< std::vector< MonitorElement * > >	h_phoIsoBarrel_
std::vector< std::vector< MonitorElement * > >	h_phoIsoEndcap_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoPhi_
std::vector< std::vector< MonitorElement * > >	h_phoPhi_BadChannels_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoSigmaEoverE_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_phoSigmaIetaIeta_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_pOverETracks_
std::vector< std::vector< MonitorElement * > >	h_r1x5VsEt_
std::vector< std::vector< MonitorElement * > >	h_r1x5VsEta_
std::vector< std::vector< MonitorElement * > >	h_r2x5VsEt_
std::vector< std::vector< MonitorElement * > >	h_r2x5VsEta_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_r9_
std::vector< std::vector< MonitorElement * > >	h_r9VsEt_
std::vector< std::vector< MonitorElement * > >	h_r9VsEta_
std::vector< std::vector< MonitorElement * > >	h_scEta_
std::vector< std::vector< std::vector< MonitorElement * > > >	h_scPhi_
std::vector< std::vector< MonitorElement * > >	h_sigmaIetaIetaVsEta_
std::vector< std::vector< MonitorElement * > >	h_tkChi2_
std::vector< std::vector< MonitorElement * > >	h_trackPtSumHollow_
std::vector< std::vector< MonitorElement * > >	h_trackPtSumHollowVsEt_
std::vector< std::vector< MonitorElement * > >	h_trackPtSumHollowVsEta_
std::vector< std::vector< MonitorElement * > >	h_trackPtSumSolid_
std::vector< std::vector< MonitorElement * > >	h_trackPtSumSolidVsEt_
std::vector< std::vector< MonitorElement * > >	h_trackPtSumSolidVsEta_
std::vector< std::vector< MonitorElement * > >	h_vertexChi2Prob_
int	histo_index_conversions_
int	histo_index_efficiency_
int	histo_index_invMass_
int	histo_index_photons_
int	hOverEBin_
double	hOverEMax_
double	hOverEMin_
double	invMassEtCut_
bool	isHeavyIon_
int	isolationStrength_
bool	minimalSetOfHistos_
double	minPhoEtCut_
int	nEvt_
int	numberBin_
double	numberMax_
double	numberMin_
int	numberOfSteps_
edm::EDGetTokenT< reco::VertexCollection >	offline_pvToken_
std::vector< std::vector< MonitorElement * > >	p_dCotTracksVsEta_
std::vector< std::vector< MonitorElement * > >	p_e1x5VsEt_
std::vector< std::vector< MonitorElement * > >	p_e1x5VsEta_
std::vector< std::vector< MonitorElement * > >	p_e2x5VsEt_
std::vector< std::vector< MonitorElement * > >	p_e2x5VsEta_
std::vector< std::vector< std::vector< MonitorElement * > > >	p_ecalSumVsEt_
std::vector< std::vector< MonitorElement * > >	p_ecalSumVsEta_
std::vector< std::vector< std::vector< MonitorElement * > > >	p_hcalSumVsEt_
std::vector< std::vector< MonitorElement * > >	p_hcalSumVsEta_
std::vector< std::vector< MonitorElement * > >	p_hOverEVsEt_
std::vector< std::vector< MonitorElement * > >	p_hOverEVsEta_
std::vector< std::vector< MonitorElement * > >	p_maxEXtalOver3x3VsEt_
std::vector< std::vector< MonitorElement * > >	p_maxEXtalOver3x3VsEta_
std::vector< std::vector< MonitorElement * > >	p_nHitsVsEta_
std::vector< std::vector< MonitorElement * > >	p_nTrackIsolHollowVsEt_
std::vector< std::vector< MonitorElement * > >	p_nTrackIsolHollowVsEta_
std::vector< std::vector< MonitorElement * > >	p_nTrackIsolSolidVsEt_
std::vector< std::vector< MonitorElement * > >	p_nTrackIsolSolidVsEta_
std::vector< std::vector< std::vector< MonitorElement * > > >	p_phoSigmaEoverEvsNVtx_
std::vector< std::vector< MonitorElement * > >	p_r1x5VsEt_
std::vector< std::vector< MonitorElement * > >	p_r1x5VsEta_
std::vector< std::vector< MonitorElement * > >	p_r2x5VsEt_
std::vector< std::vector< MonitorElement * > >	p_r2x5VsEta_
std::vector< std::vector< MonitorElement * > >	p_r9VsEt_
std::vector< std::vector< MonitorElement * > >	p_r9VsEta_
std::vector< std::vector< MonitorElement * > >	p_sigmaIetaIetaVsEta_
std::vector< std::vector< MonitorElement * > >	p_tkChi2VsEta_
std::vector< std::vector< MonitorElement * > >	p_trackPtSumHollowVsEt_
std::vector< std::vector< MonitorElement * > >	p_trackPtSumHollowVsEta_
std::vector< std::vector< MonitorElement * > >	p_trackPtSumSolidVsEt_
std::vector< std::vector< MonitorElement * > >	p_trackPtSumSolidVsEta_
std::vector< std::string >	parts_
int	phiBin_
double	phiMax_
double	phiMin_
edm::EDGetTokenT< std::vector< reco::Photon > >	photon_token_
edm::EDGetTokenT< edm::ValueMap< bool > >	PhotonIDLoose_token_
edm::EDGetTokenT< edm::ValueMap< bool > >	PhotonIDTight_token_
double	photonMaxEta_
unsigned int	prescaleFactor_
int	r9Bin_
double	r9Max_
double	r9Min_
int	rBin_
int	reducedEtaBin_
int	reducedEtBin_
int	reducedR9Bin_
int	reducedSumBin_
double	rMax_
double	rMin_
int	sigmaIetaBin_
double	sigmaIetaMax_
double	sigmaIetaMin_
bool	standAlone_
int	sumBin_
double	sumMax_
double	sumMin_
MonitorElement *	totalNumberOfHistos_conversionsFolder
MonitorElement *	totalNumberOfHistos_efficiencyFolder
MonitorElement *	totalNumberOfHistos_invMassFolder
MonitorElement *	totalNumberOfHistos_photonsFolder
edm::EDGetTokenT< trigger::TriggerEvent >	triggerEvent_token_
std::vector< std::string >	types_
bool	useBinning_
bool	useTriggerFiltering_
int	xBin_
double	xMax_
double	xMin_
int	yBin_
double	yMax_
double	yMin_
int	zBin_
double	zMax_
double	zMin_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)
static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Detailed Description

EgammaCoreTools.

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

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

Definition at line 97 of file PhotonAnalyzer.h.

Constructor & Destructor Documentation

PhotonAnalyzer()

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

explicit

Definition at line 19 of file PhotonAnalyzer.cc.

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

                                                          {
  fName_ = pset.getParameter<string>("analyzerName");
  prescaleFactor_ = pset.getUntrackedParameter<int>("prescaleFactor", 1);

  photon_token_ = consumes<vector<reco::Photon> >(pset.getParameter<edm::InputTag>("phoProducer"));
  barrelRecHit_token_ = consumes<edm::SortedCollection<EcalRecHit, edm::StrictWeakOrdering<EcalRecHit> > >(
      pset.getParameter<edm::InputTag>("barrelRecHitProducer"));
  PhotonIDLoose_token_ = consumes<edm::ValueMap<bool> >(pset.getParameter<edm::InputTag>("photonIDLoose"));
  PhotonIDTight_token_ = consumes<edm::ValueMap<bool> >(pset.getParameter<edm::InputTag>("photonIDTight"));
  endcapRecHit_token_ = consumes<edm::SortedCollection<EcalRecHit, edm::StrictWeakOrdering<EcalRecHit> > >(
      pset.getParameter<edm::InputTag>("endcapRecHitProducer"));
  triggerEvent_token_ = consumes<trigger::TriggerEvent>(pset.getParameter<edm::InputTag>("triggerEvent"));
  offline_pvToken_ = consumes<reco::VertexCollection>(
      pset.getUntrackedParameter<edm::InputTag>("offlinePV", edm::InputTag("offlinePrimaryVertices")));

  minPhoEtCut_ = pset.getParameter<double>("minPhoEtCut");
  photonMaxEta_ = pset.getParameter<double>("maxPhoEta");
  invMassEtCut_ = pset.getParameter<double>("invMassEtCut");
  cutStep_ = pset.getParameter<double>("cutStep");
  numberOfSteps_ = pset.getParameter<int>("numberOfSteps");
  useBinning_ = pset.getParameter<bool>("useBinning");
  useTriggerFiltering_ = pset.getParameter<bool>("useTriggerFiltering");
  minimalSetOfHistos_ = pset.getParameter<bool>("minimalSetOfHistos");
  excludeBkgHistos_ = pset.getParameter<bool>("excludeBkgHistos");
  standAlone_ = pset.getParameter<bool>("standAlone");
  isolationStrength_ = pset.getParameter<int>("isolationStrength");
  isHeavyIon_ = pset.getUntrackedParameter<bool>("isHeavyIon", false);

  histo_index_photons_ = 0;
  histo_index_conversions_ = 0;
  histo_index_efficiency_ = 0;
  histo_index_invMass_ = 0;

  nEvt_ = 0;

  // Determining parts...
  parts_.push_back("AllEcal");
  parts_.push_back("Barrel");
  parts_.push_back("Endcaps");
  // ...and types
  types_.push_back("All");
  types_.push_back("GoodCandidate");
  if (!excludeBkgHistos_) {
    types_.push_back("Background");
  }

  // Histogram parameters
  etaBin_ = pset.getParameter<int>("etaBin");
  etaMin_ = pset.getParameter<double>("etaMin");
  etaMax_ = pset.getParameter<double>("etaMax");

  etBin_ = pset.getParameter<int>("etBin");
  etMin_ = pset.getParameter<double>("etMin");
  etMax_ = pset.getParameter<double>("etMax");

  phiBin_ = pset.getParameter<int>("phiBin");
  phiMin_ = pset.getParameter<double>("phiMin");
  phiMax_ = pset.getParameter<double>("phiMax");

  eBin_ = pset.getParameter<int>("eBin");
  eMin_ = pset.getParameter<double>("eMin");
  eMax_ = pset.getParameter<double>("eMax");

  numberBin_ = pset.getParameter<int>("numberBin");
  numberMin_ = pset.getParameter<double>("numberMin");
  numberMax_ = pset.getParameter<double>("numberMax");

  r9Bin_ = pset.getParameter<int>("r9Bin");
  r9Min_ = pset.getParameter<double>("r9Min");
  r9Max_ = pset.getParameter<double>("r9Max");

  sigmaIetaBin_ = pset.getParameter<int>("sigmaIetaBin");
  sigmaIetaMin_ = pset.getParameter<double>("sigmaIetaMin");
  sigmaIetaMax_ = pset.getParameter<double>("sigmaIetaMax");

  sumBin_ = pset.getParameter<int>("sumBin");
  sumMin_ = pset.getParameter<double>("sumMin");
  sumMax_ = pset.getParameter<double>("sumMax");

  hOverEBin_ = pset.getParameter<int>("hOverEBin");
  hOverEMin_ = pset.getParameter<double>("hOverEMin");
  hOverEMax_ = pset.getParameter<double>("hOverEMax");

  eOverPBin_ = pset.getParameter<int>("eOverPBin");
  eOverPMin_ = pset.getParameter<double>("eOverPMin");
  eOverPMax_ = pset.getParameter<double>("eOverPMax");

  dPhiTracksBin_ = pset.getParameter<int>("dPhiTracksBin");
  dPhiTracksMin_ = pset.getParameter<double>("dPhiTracksMin");
  dPhiTracksMax_ = pset.getParameter<double>("dPhiTracksMax");

  dEtaTracksBin_ = pset.getParameter<int>("dEtaTracksBin");
  dEtaTracksMin_ = pset.getParameter<double>("dEtaTracksMin");
  dEtaTracksMax_ = pset.getParameter<double>("dEtaTracksMax");

  chi2Bin_ = pset.getParameter<int>("chi2Bin");
  chi2Min_ = pset.getParameter<double>("chi2Min");
  chi2Max_ = pset.getParameter<double>("chi2Max");

  zBin_ = pset.getParameter<int>("zBin");
  zMin_ = pset.getParameter<double>("zMin");
  zMax_ = pset.getParameter<double>("zMax");

  rBin_ = pset.getParameter<int>("rBin");
  rMin_ = pset.getParameter<double>("rMin");
  rMax_ = pset.getParameter<double>("rMax");

  xBin_ = pset.getParameter<int>("xBin");
  xMin_ = pset.getParameter<double>("xMin");
  xMax_ = pset.getParameter<double>("xMax");

  yBin_ = pset.getParameter<int>("yBin");
  yMin_ = pset.getParameter<double>("yMin");
  yMax_ = pset.getParameter<double>("yMax");

  reducedEtBin_ = etBin_ / 4;
  reducedEtaBin_ = etaBin_ / 4;
  reducedR9Bin_ = r9Bin_ / 4;
  reducedSumBin_ = sumBin_ / 4;
}

~PhotonAnalyzer()

PhotonAnalyzer::~PhotonAnalyzer ( )

override

Definition at line 140 of file PhotonAnalyzer.cc.

{}

Member Function Documentation

analyze()

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

overridevirtual

End loop over Reco photons

Reimplemented from DQMEDAnalyzer.

Definition at line 1415 of file PhotonAnalyzer.cc.

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

                                                                         {
  using namespace edm;

  if (nEvt_ % prescaleFactor_)
    return;
  nEvt_++;
  LogInfo(fName_) << "PhotonAnalyzer Analyzing event number: " << e.id() << " Global Counter " << nEvt_ << "\n";

  // Get the trigger results
  bool validTriggerEvent = true;
  edm::Handle<trigger::TriggerEvent> triggerEventHandle;
  const trigger::TriggerEvent dummyTE;
  e.getByToken(triggerEvent_token_, triggerEventHandle);
  if (!triggerEventHandle.isValid()) {
    edm::LogInfo(fName_) << "Error! Can't get the product: triggerEvent_" << endl;
    validTriggerEvent = false;
  }
  const trigger::TriggerEvent& triggerEvent(validTriggerEvent ? *(triggerEventHandle.product()) : dummyTE);

  // Get the reconstructed photons
  //  bool validPhotons=true;
  Handle<reco::PhotonCollection> photonHandle;
  e.getByToken(photon_token_, photonHandle);
  if (!photonHandle.isValid()) {
    edm::LogInfo(fName_) << "Error! Can't get the product: photon_token_" << endl;
    // validPhotons=false;
  }
  const reco::PhotonCollection& photonCollection(*(photonHandle.product()));

  // Get the PhotonId objects
  //  bool validloosePhotonID=true;
  Handle<edm::ValueMap<bool> > loosePhotonFlag;
  e.getByToken(PhotonIDLoose_token_, loosePhotonFlag);
  if (!loosePhotonFlag.isValid()) {
    edm::LogInfo(fName_) << "Error! Can't get the product: PhotonIDLoose_token_" << endl;
    //    validloosePhotonID=false;
  }
  //  edm::ValueMap<bool> dummyLPID;
  //  const edm::ValueMap<bool>& loosePhotonID(validloosePhotonID? *(loosePhotonFlag.product()) : dummyLPID);

  //  bool validtightPhotonID=true;
  Handle<edm::ValueMap<bool> > tightPhotonFlag;
  e.getByToken(PhotonIDTight_token_, tightPhotonFlag);
  if (!tightPhotonFlag.isValid()) {
    edm::LogInfo(fName_) << "Error! Can't get the product: PhotonIDTight_token_" << endl;
    //    validtightPhotonID=false;
  }
  //  edm::ValueMap<bool> dummyTPI;
  //  const edm::ValueMap<bool>& tightPhotonID(validtightPhotonID ? *(tightPhotonFlag.product()) : dummyTPI);

  edm::Handle<reco::VertexCollection> vtxH;
  if (!isHeavyIon_) {
    e.getByToken(offline_pvToken_, vtxH);
    h_nRecoVtx_->Fill(float(vtxH->size()));
  }

  // Create array to hold #photons/event information
  int nPho[100][3][3];

  for (int cut = 0; cut != 100; ++cut) {
    for (unsigned int type = 0; type != types_.size(); ++type) {
      for (unsigned int part = 0; part != parts_.size(); ++part) {
        nPho[cut][type][part] = 0;
      }
    }
  }
  // Create array to hold #conversions/event information
  int nConv[100][3][3];

  for (int cut = 0; cut != 100; ++cut) {
    for (unsigned int type = 0; type != types_.size(); ++type) {
      for (unsigned int part = 0; part != parts_.size(); ++part) {
        nConv[cut][type][part] = 0;
      }
    }
  }

  //Prepare list of photon-related HLT filter names
  vector<int> Keys;

  for (uint filterIndex = 0; filterIndex < triggerEvent.sizeFilters();
       ++filterIndex) {  //loop over all trigger filters in event (i.e. filters passed)
    string label = triggerEvent.filterTag(filterIndex).label();
    if (label.find("Photon") != string::npos) {  //get photon-related filters
      for (uint filterKeyIndex = 0; filterKeyIndex < triggerEvent.filterKeys(filterIndex).size();
           ++filterKeyIndex) {  //loop over keys to objects passing this filter
        Keys.push_back(
            triggerEvent.filterKeys(filterIndex)[filterKeyIndex]);  //add keys to a vector for later reference
      }
    }
  }

  // sort Keys vector in ascending order
  // and erases duplicate entries from the vector
  sort(Keys.begin(), Keys.end());
  for (uint i = 0; i < Keys.size();) {
    if (i != (Keys.size() - 1)) {
      if (Keys[i] == Keys[i + 1])
        Keys.erase(Keys.begin() + i + 1);
      else
        ++i;
    } else
      ++i;
  }

  //We now have a vector of unique keys to TriggerObjects passing a photon-related filter

  // old int photonCounter = 0;

  for (unsigned int iPho = 0; iPho < photonHandle->size(); iPho++) {
    const reco::Photon* aPho = &photonCollection[iPho];
    //  for( reco::PhotonCollection::const_iterator  iPho = photonCollection.begin(); iPho != photonCollection.end(); iPho++) {

    //for HLT efficiency plots

    h_phoEta_preHLT_->Fill(aPho->eta());
    h_phoEt_preHLT_->Fill(aPho->et());

    double deltaR = 1000.;
    double deltaRMin = 1000.;
    double deltaRMax = 0.05;  //sets deltaR threshold for matching photons to trigger objects

    for (vector<int>::const_iterator objectKey = Keys.begin(); objectKey != Keys.end();
         objectKey++) {  //loop over keys to objects that fired photon triggers

      deltaR = reco::deltaR(triggerEvent.getObjects()[(*objectKey)].eta(),
                            triggerEvent.getObjects()[(*objectKey)].phi(),
                            aPho->superCluster()->eta(),
                            aPho->superCluster()->phi());
      if (deltaR < deltaRMin)
        deltaRMin = deltaR;
    }

    if (deltaRMin > deltaRMax) {  //photon fails delta R cut
      if (useTriggerFiltering_)
        continue;  //throw away photons that haven't passed any photon filters
    }

    if (deltaRMin <= deltaRMax) {  //photon passes delta R cut
      h_phoEta_postHLT_->Fill(aPho->eta());
      h_phoEt_postHLT_->Fill(aPho->et());
    }

    //    if (aPho->et()  < minPhoEtCut_) continue;
    bool isLoosePhoton(false), isTightPhoton(false);
    if (photonSelection(aPho))
      isLoosePhoton = true;

    //find out which part of the Ecal contains the photon
    bool phoIsInBarrel = false;
    bool phoIsInEndcap = false;
    float etaPho = aPho->superCluster()->eta();
    if (fabs(etaPho) < 1.479)
      phoIsInBarrel = true;
    else {
      phoIsInEndcap = true;
    }

    int part = 0;
    if (phoIsInBarrel)
      part = 1;
    if (phoIsInEndcap)
      part = 2;

    bool isIsolated = false;
    if (isolationStrength_ == 0)
      isIsolated = isLoosePhoton;
    if (isolationStrength_ == 1)
      isIsolated = isTightPhoton;
    if (isolationStrength_ == 2)
      isIsolated = photonSelectionSlimmed(aPho);

    int type = 0;
    if (isIsolated)
      type = 1;
    if (!excludeBkgHistos_ && !isIsolated)
      type = 2;

    //get rechit collection containing this photon
    bool validEcalRecHits = true;
    edm::Handle<EcalRecHitCollection> ecalRecHitHandle;
    EcalRecHitCollection ecalRecHitCollection;
    if (phoIsInBarrel) {
      // Get handle to barrel rec hits
      e.getByToken(barrelRecHit_token_, ecalRecHitHandle);
      if (!ecalRecHitHandle.isValid()) {
        edm::LogError(fName_) << "Error! Can't get the product: barrelRecHit_token_";
        validEcalRecHits = false;
      }
    } else if (phoIsInEndcap) {
      // Get handle to endcap rec hits
      e.getByToken(endcapRecHit_token_, ecalRecHitHandle);
      if (!ecalRecHitHandle.isValid()) {
        edm::LogError(fName_) << "Error! Can't get the product: endcapRecHit_token";
        validEcalRecHits = false;
      }
    }
    if (validEcalRecHits)
      ecalRecHitCollection = *(ecalRecHitHandle.product());

    //if (aPho->isEBEEGap()) continue;  //cut out gap photons

    //filling histograms to make isolation efficiencies
    if (isLoosePhoton) {
      h_phoEta_Loose_->Fill(aPho->eta());
      h_phoEt_Loose_->Fill(aPho->et());
    }
    if (isTightPhoton) {
      h_phoEta_Tight_->Fill(aPho->eta());
      h_phoEt_Tight_->Fill(aPho->et());
    }

    for (int cut = 0; cut != numberOfSteps_; ++cut) {  //loop over different transverse energy cuts
      double Et = aPho->et();
      bool passesCuts = false;

      //sorting the photon into the right Et-dependant folder
      if (useBinning_ && Et > (cut + 1) * cutStep_ && ((Et < (cut + 2) * cutStep_) | (cut == numberOfSteps_ - 1))) {
        passesCuts = true;
      } else if (!useBinning_ && Et > (cut + 1) * cutStep_) {
        passesCuts = true;
      }

      if (passesCuts) {
        //filling isolation variable histograms

        //tracker isolation variables
        fill2DHistoVector(h_nTrackIsolSolid_, aPho->nTrkSolidConeDR04(), cut, type);
        fill2DHistoVector(h_nTrackIsolHollow_, aPho->nTrkHollowConeDR04(), cut, type);

        if (standAlone_)
          fill2DHistoVector(h_nTrackIsolSolidVsEta_, aPho->eta(), aPho->nTrkSolidConeDR04(), cut, type);
        fill2DHistoVector(p_nTrackIsolSolidVsEta_, aPho->eta(), aPho->nTrkSolidConeDR04(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_nTrackIsolHollowVsEta_, aPho->eta(), aPho->nTrkHollowConeDR04(), cut, type);
        fill2DHistoVector(p_nTrackIsolHollowVsEta_, aPho->eta(), aPho->nTrkHollowConeDR04(), cut, type);

        if (standAlone_)
          fill2DHistoVector(h_nTrackIsolSolidVsEt_, aPho->et(), aPho->nTrkSolidConeDR04(), cut, type);
        fill2DHistoVector(p_nTrackIsolSolidVsEt_, aPho->et(), aPho->nTrkSolidConeDR04(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_nTrackIsolHollowVsEt_, aPho->et(), aPho->nTrkHollowConeDR04(), cut, type);
        fill2DHistoVector(p_nTrackIsolHollowVsEt_, aPho->et(), aPho->nTrkHollowConeDR04(), cut, type);

        fill2DHistoVector(h_trackPtSumSolid_, aPho->trkSumPtSolidConeDR04(), cut, type);
        fill2DHistoVector(h_trackPtSumHollow_, aPho->trkSumPtSolidConeDR04(), cut, type);

        if (standAlone_)
          fill2DHistoVector(h_trackPtSumSolidVsEta_, aPho->eta(), aPho->trkSumPtSolidConeDR04(), cut, type);
        fill2DHistoVector(p_trackPtSumSolidVsEta_, aPho->eta(), aPho->trkSumPtSolidConeDR04(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_trackPtSumHollowVsEta_, aPho->eta(), aPho->trkSumPtHollowConeDR04(), cut, type);
        fill2DHistoVector(p_trackPtSumHollowVsEta_, aPho->eta(), aPho->trkSumPtHollowConeDR04(), cut, type);

        if (standAlone_)
          fill2DHistoVector(h_trackPtSumSolidVsEt_, aPho->et(), aPho->trkSumPtSolidConeDR04(), cut, type);
        fill2DHistoVector(p_trackPtSumSolidVsEt_, aPho->et(), aPho->trkSumPtSolidConeDR04(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_trackPtSumHollowVsEt_, aPho->et(), aPho->trkSumPtHollowConeDR04(), cut, type);
        fill2DHistoVector(p_trackPtSumHollowVsEt_, aPho->et(), aPho->trkSumPtHollowConeDR04(), cut, type);
        //calorimeter isolation variables

        fill2DHistoVector(h_ecalSum_, aPho->ecalRecHitSumEtConeDR04(), cut, type);
        if (aPho->isEB()) {
          fill2DHistoVector(h_ecalSumEBarrel_, aPho->ecalRecHitSumEtConeDR04(), cut, type);
        }
        if (aPho->isEE()) {
          fill2DHistoVector(h_ecalSumEEndcap_, aPho->ecalRecHitSumEtConeDR04(), cut, type);
        }
        if (standAlone_)
          fill2DHistoVector(h_ecalSumVsEta_, aPho->eta(), aPho->ecalRecHitSumEtConeDR04(), cut, type);
        fill2DHistoVector(p_ecalSumVsEta_, aPho->eta(), aPho->ecalRecHitSumEtConeDR04(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_ecalSumVsEt_, aPho->et(), aPho->ecalRecHitSumEtConeDR04(), cut, type);
        fill3DHistoVector(p_ecalSumVsEt_, aPho->et(), aPho->ecalRecHitSumEtConeDR04(), cut, type, part);


        fill2DHistoVector(h_hcalSum_, aPho->hcalTowerSumEtConeDR04(), cut, type);
        if (aPho->isEB()) {
          fill2DHistoVector(h_hcalSumEBarrel_, aPho->hcalTowerSumEtConeDR04(), cut, type);
        }
        if (aPho->isEE()) {
          fill2DHistoVector(h_hcalSumEEndcap_, aPho->hcalTowerSumEtConeDR04(), cut, type);
        }
        if (standAlone_)
          fill2DHistoVector(h_hcalSumVsEta_, aPho->eta(), aPho->hcalTowerSumEtConeDR04(), cut, type);
        fill2DHistoVector(p_hcalSumVsEta_, aPho->eta(), aPho->hcalTowerSumEtConeDR04(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_hcalSumVsEt_, aPho->et(), aPho->hcalTowerSumEtConeDR04(), cut, type);
        fill3DHistoVector(p_hcalSumVsEt_, aPho->et(), aPho->hcalTowerSumEtConeDR04(), cut, type, part);

        fill3DHistoVector(h_hOverE_, aPho->hadronicOverEm(), cut, type, part);
        fill2DHistoVector(p_hOverEVsEta_, aPho->eta(), aPho->hadronicOverEm(), cut, type);
        fill2DHistoVector(p_hOverEVsEt_, aPho->et(), aPho->hadronicOverEm(), cut, type);

        fill3DHistoVector(h_h1OverE_, aPho->hadronicOverEm(1), cut, type, part);
        fill3DHistoVector(h_h2OverE_, aPho->hadronicOverEm(2), cut, type, part);

        // filling pf isolation variables
        if (aPho->isEB()) {
          fill2DHistoVector(h_phoIsoBarrel_, aPho->photonIso(), cut, type);
          fill2DHistoVector(h_chHadIsoBarrel_, aPho->chargedHadronIso(), cut, type);
          fill2DHistoVector(h_nHadIsoBarrel_, aPho->neutralHadronIso(), cut, type);
        }
        if (aPho->isEE()) {
          fill2DHistoVector(h_phoIsoEndcap_, aPho->photonIso(), cut, type);
          fill2DHistoVector(h_chHadIsoEndcap_, aPho->chargedHadronIso(), cut, type);
          fill2DHistoVector(h_nHadIsoEndcap_, aPho->neutralHadronIso(), cut, type);
        }

        //filling photon histograms
        nPho[cut][0][0]++;
        nPho[cut][0][part]++;
        if (type != 0) {
          nPho[cut][type][0]++;
          nPho[cut][type][part]++;
        }

        //energy variables

        fill3DHistoVector(h_phoE_, aPho->energy(), cut, type, part);
        fill3DHistoVector(h_phoSigmaEoverE_,
                          aPho->getCorrectedEnergyError(aPho->getCandidateP4type()) / aPho->energy(),
                          cut,
                          type,
                          part);

        if (!isHeavyIon_)
          fill3DHistoVector(p_phoSigmaEoverEvsNVtx_,
                            float(vtxH->size()),
                            aPho->getCorrectedEnergyError(aPho->getCandidateP4type()) / aPho->energy(),
                            cut,
                            type,
                            part);

        fill3DHistoVector(h_phoEt_, aPho->et(), cut, type, part);

        //geometrical variables

        fill2DHistoVector(h_phoEta_, aPho->eta(), cut, type);
        fill2DHistoVector(h_scEta_, aPho->superCluster()->eta(), cut, type);

        fill3DHistoVector(h_phoPhi_, aPho->phi(), cut, type, part);
        fill3DHistoVector(h_scPhi_, aPho->superCluster()->phi(), cut, type, part);

        //shower shape variables

        fill3DHistoVector(h_r9_, aPho->r9(), cut, type, part);
        if (standAlone_)
          fill2DHistoVector(h_r9VsEta_, aPho->eta(), aPho->r9(), cut, type);
        fill2DHistoVector(p_r9VsEta_, aPho->eta(), aPho->r9(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_r9VsEt_, aPho->et(), aPho->r9(), cut, type);
        fill2DHistoVector(p_r9VsEt_, aPho->et(), aPho->r9(), cut, type);

        if (standAlone_)
          fill2DHistoVector(h_e1x5VsEta_, aPho->eta(), aPho->e1x5(), cut, type);
        fill2DHistoVector(p_e1x5VsEta_, aPho->eta(), aPho->e1x5(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_e1x5VsEt_, aPho->et(), aPho->e1x5(), cut, type);
        fill2DHistoVector(p_e1x5VsEt_, aPho->et(), aPho->e1x5(), cut, type);

        if (standAlone_)
          fill2DHistoVector(h_e2x5VsEta_, aPho->eta(), aPho->e2x5(), cut, type);
        fill2DHistoVector(p_e2x5VsEta_, aPho->eta(), aPho->e2x5(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_e2x5VsEt_, aPho->et(), aPho->e2x5(), cut, type);
        fill2DHistoVector(p_e2x5VsEt_, aPho->et(), aPho->e2x5(), cut, type);

        if (standAlone_)
          fill2DHistoVector(h_maxEXtalOver3x3VsEta_, aPho->eta(), aPho->maxEnergyXtal() / aPho->e3x3(), cut, type);
        fill2DHistoVector(p_maxEXtalOver3x3VsEta_, aPho->eta(), aPho->maxEnergyXtal() / aPho->e3x3(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_maxEXtalOver3x3VsEt_, aPho->et(), aPho->maxEnergyXtal() / aPho->e3x3(), cut, type);
        fill2DHistoVector(p_maxEXtalOver3x3VsEt_, aPho->et(), aPho->maxEnergyXtal() / aPho->e3x3(), cut, type);

        if (standAlone_)
          fill2DHistoVector(h_r1x5VsEta_, aPho->eta(), aPho->r1x5(), cut, type);
        fill2DHistoVector(p_r1x5VsEta_, aPho->eta(), aPho->r1x5(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_r1x5VsEt_, aPho->et(), aPho->r1x5(), cut, type);
        fill2DHistoVector(p_r1x5VsEt_, aPho->et(), aPho->r1x5(), cut, type);

        if (standAlone_)
          fill2DHistoVector(h_r2x5VsEta_, aPho->eta(), aPho->r2x5(), cut, type);
        fill2DHistoVector(p_r2x5VsEta_, aPho->eta(), aPho->r2x5(), cut, type);
        if (standAlone_)
          fill2DHistoVector(h_r2x5VsEt_, aPho->et(), aPho->r2x5(), cut, type);
        fill2DHistoVector(p_r2x5VsEt_, aPho->et(), aPho->r2x5(), cut, type);

        fill3DHistoVector(h_phoSigmaIetaIeta_, aPho->sigmaIetaIeta(), cut, type, part);
        if (standAlone_)
          fill2DHistoVector(h_sigmaIetaIetaVsEta_, aPho->eta(), aPho->sigmaIetaIeta(), cut, type);
        fill2DHistoVector(p_sigmaIetaIetaVsEta_, aPho->eta(), aPho->sigmaIetaIeta(), cut, type);

        //filling histograms for photons containing a bad ECAL channel
        bool atLeastOneDeadChannel = false;
        for (reco::CaloCluster_iterator bcIt = aPho->superCluster()->clustersBegin();
             bcIt != aPho->superCluster()->clustersEnd();
             ++bcIt) {  //loop over basic clusters in SC
          for (vector<pair<DetId, float> >::const_iterator rhIt = (*bcIt)->hitsAndFractions().begin();
               rhIt != (*bcIt)->hitsAndFractions().end();
               ++rhIt) {  //loop over rec hits in basic cluster

            for (EcalRecHitCollection::const_iterator it = ecalRecHitCollection.begin();
                 it != ecalRecHitCollection.end();
                 ++it) {                        //loop over all rec hits to find the right ones
              if (rhIt->first == (*it).id()) {  //found the matching rechit
                if ((*it).recoFlag() == 9) {    //has a bad channel
                  atLeastOneDeadChannel = true;
                  break;
                }
              }
            }
          }
        }
        if (atLeastOneDeadChannel) {
          fill2DHistoVector(h_phoPhi_BadChannels_, aPho->phi(), cut, type);
          fill2DHistoVector(h_phoEta_BadChannels_, aPho->eta(), cut, type);
          fill2DHistoVector(h_phoEt_BadChannels_, aPho->et(), cut, type);
        }

        // filling conversion-related histograms
        if (aPho->hasConversionTracks()) {
          nConv[cut][0][0]++;
          nConv[cut][0][part]++;
          nConv[cut][type][0]++;
          nConv[cut][type][part]++;
        }

        //loop over conversions (don't forget, we're still inside the photon loop,
        // i.e. these are all the conversions for this ONE photon, not for all the photons in the event)
        reco::ConversionRefVector conversions = aPho->conversions();
        for (unsigned int iConv = 0; iConv < conversions.size(); iConv++) {
          reco::ConversionRef aConv = conversions[iConv];

          if (aConv->nTracks() < 2)
            continue;

          //fill histogram for denominator of vertex reconstruction efficiency plot
          if (cut == 0)
            h_phoEta_Vertex_->Fill(aConv->refittedPairMomentum().eta());

          if (!(aConv->conversionVertex().isValid()))
            continue;

          float chi2Prob = ChiSquaredProbability(aConv->conversionVertex().chi2(), aConv->conversionVertex().ndof());

          if (chi2Prob < 0.0005)
            continue;

          fill2DHistoVector(h_vertexChi2Prob_, chi2Prob, cut, type);

          fill3DHistoVector(h_phoConvE_, aPho->energy(), cut, type, part);
          fill3DHistoVector(h_phoConvEt_, aPho->et(), cut, type, part);
          fill3DHistoVector(h_phoConvR9_, aPho->r9(), cut, type, part);

          if (cut == 0 && isLoosePhoton) {
            h_convEta_Loose_->Fill(aPho->eta());
            h_convEt_Loose_->Fill(aPho->et());
          }
          if (cut == 0 && isTightPhoton) {
            h_convEta_Tight_->Fill(aPho->eta());
            h_convEt_Tight_->Fill(aPho->et());
          }

          fill2DHistoVector(h_phoConvEta_, aConv->refittedPairMomentum().eta(), cut, type);
          fill3DHistoVector(h_phoConvPhi_, aConv->refittedPairMomentum().phi(), cut, type, part);

          //we use the photon position because we'll be dividing it by a photon histogram (not a conversion histogram)
          fill2DHistoVector(h_phoConvEtaForEfficiency_, aPho->eta(), cut, type);
          fill3DHistoVector(h_phoConvPhiForEfficiency_, aPho->phi(), cut, type, part);

          //vertex histograms
          double convR = sqrt(aConv->conversionVertex().position().perp2());
          double scalar = aConv->conversionVertex().position().x() * aConv->refittedPairMomentum().x() +
                          aConv->conversionVertex().position().y() * aConv->refittedPairMomentum().y();
          if (scalar < 0)
            convR = -convR;

          fill2DHistoVector(h_convVtxRvsZ_,
                            aConv->conversionVertex().position().z(),
                            convR,
                            cut,
                            type);  //trying to "see" R-Z view of tracker
          fill2DHistoVector(h_convVtxZ_, aConv->conversionVertex().position().z(), cut, type);

          if (fabs(aPho->eta()) > 1.5) {  //trying to "see" tracker endcaps
            fill2DHistoVector(h_convVtxZEndcap_, aConv->conversionVertex().position().z(), cut, type);
          } else if (fabs(aPho->eta()) < 1) {  //trying to "see" tracker barrel
            fill2DHistoVector(h_convVtxR_, convR, cut, type);
            fill2DHistoVector(h_convVtxYvsX_,
                              aConv->conversionVertex().position().x(),
                              aConv->conversionVertex().position().y(),
                              cut,
                              type);
          }

          const std::vector<edm::RefToBase<reco::Track> > tracks = aConv->tracks();

          for (unsigned int i = 0; i < tracks.size(); i++) {
            fill2DHistoVector(h_tkChi2_, tracks[i]->normalizedChi2(), cut, type);
            fill2DHistoVector(p_tkChi2VsEta_, aPho->eta(), tracks[i]->normalizedChi2(), cut, type);
            fill2DHistoVector(p_dCotTracksVsEta_, aPho->eta(), aConv->pairCotThetaSeparation(), cut, type);
            fill2DHistoVector(p_nHitsVsEta_, aPho->eta(), float(tracks[i]->numberOfValidHits()), cut, type);
          }

          //calculating delta eta and delta phi of the two tracks

          float DPhiTracksAtVtx = -99;
          float dPhiTracksAtEcal = -99;
          float dEtaTracksAtEcal = -99;

          float phiTk1 = aConv->tracksPin()[0].phi();
          float phiTk2 = aConv->tracksPin()[1].phi();
          DPhiTracksAtVtx = phiTk1 - phiTk2;
          DPhiTracksAtVtx = phiNormalization(DPhiTracksAtVtx);

          if (!aConv->bcMatchingWithTracks().empty() && aConv->bcMatchingWithTracks()[0].isNonnull() &&
              aConv->bcMatchingWithTracks()[1].isNonnull()) {
            float recoPhi1 = aConv->ecalImpactPosition()[0].phi();
            float recoPhi2 = aConv->ecalImpactPosition()[1].phi();
            float recoEta1 = aConv->ecalImpactPosition()[0].eta();
            float recoEta2 = aConv->ecalImpactPosition()[1].eta();

            recoPhi1 = phiNormalization(recoPhi1);
            recoPhi2 = phiNormalization(recoPhi2);

            dPhiTracksAtEcal = recoPhi1 - recoPhi2;
            dPhiTracksAtEcal = phiNormalization(dPhiTracksAtEcal);
            dEtaTracksAtEcal = recoEta1 - recoEta2;
          }

          fill3DHistoVector(h_dPhiTracksAtVtx_, DPhiTracksAtVtx, cut, type, part);
          fill3DHistoVector(h_dPhiTracksAtEcal_, fabs(dPhiTracksAtEcal), cut, type, part);
          fill3DHistoVector(h_dEtaTracksAtEcal_, dEtaTracksAtEcal, cut, type, part);
          fill3DHistoVector(h_eOverPTracks_, aConv->EoverPrefittedTracks(), cut, type, part);
          fill3DHistoVector(h_pOverETracks_, 1. / aConv->EoverPrefittedTracks(), cut, type, part);
          fill3DHistoVector(h_dCotTracks_, aConv->pairCotThetaSeparation(), cut, type, part);
        }  //end loop over conversions
      }  //end loop over photons passing cuts
    }  //end loop over transverse energy cuts

    //make invariant mass plots

    if (isIsolated && aPho->et() >= invMassEtCut_) {
      for (unsigned int iPho2 = iPho + 1; iPho2 < photonHandle->size(); iPho2++) {
        const reco::Photon* aPho2 = &photonCollection[iPho2];

        //      for (reco::PhotonCollection::const_iterator iPho2=iPho+1; iPho2!=photonCollection.end(); iPho2++){

        //  edm::Ref<reco::PhotonCollection> photonref2(photonHandle, photonCounter); //note: it's correct to use photonCounter and not photonCounter+1
        //since it has already been incremented earlier

        bool isTightPhoton2(false), isLoosePhoton2(false);
        if (photonSelection(aPho2))
          isLoosePhoton2 = true;

        // Old if ( !isHeavyIon_ ) {
        //  isTightPhoton2 = (tightPhotonID)[aPho2];
        // isLoosePhoton2 = (loosePhotonID)[aPho2];
        //  }

        bool isIsolated2 = false;
        if (isolationStrength_ == 0)
          isIsolated2 = isLoosePhoton2;
        if (isolationStrength_ == 1)
          isIsolated2 = isTightPhoton2;
        if (isolationStrength_ == 2)
          isIsolated2 = photonSelectionSlimmed(aPho2);

        reco::ConversionRefVector conversions = aPho->conversions();
        reco::ConversionRefVector conversions2 = aPho2->conversions();

        if (isIsolated2 && aPho2->et() >= invMassEtCut_) {
          math::XYZTLorentzVector p12 = aPho->p4() + aPho2->p4();
          float gamgamMass2 = p12.Dot(p12);

          h_invMassAllPhotons_->Fill(sqrt(gamgamMass2));
          if (aPho->isEB() && aPho2->isEB()) {
            h_invMassPhotonsEBarrel_->Fill(sqrt(gamgamMass2));
          } else if (aPho->isEE() && aPho2->isEE()) {
            h_invMassPhotonsEEndcap_->Fill(sqrt(gamgamMass2));
          } else {
            h_invMassPhotonsEEndcapEBarrel_->Fill(sqrt(gamgamMass2));
          }

          if (!conversions.empty() && conversions[0]->nTracks() >= 2) {
            if (!conversions2.empty() && conversions2[0]->nTracks() >= 2)
              h_invMassTwoWithTracks_->Fill(sqrt(gamgamMass2));
            else
              h_invMassOneWithTracks_->Fill(sqrt(gamgamMass2));
          } else if (!conversions2.empty() && conversions2[0]->nTracks() >= 2)
            h_invMassOneWithTracks_->Fill(sqrt(gamgamMass2));
          else
            h_invMassZeroWithTracks_->Fill(sqrt(gamgamMass2));
        }
      }
    }
  }  

  //filling number of photons/conversions per event histograms
  for (int cut = 0; cut != numberOfSteps_; ++cut) {
    for (uint type = 0; type != types_.size(); ++type) {
      for (uint part = 0; part != parts_.size(); ++part) {
        h_nPho_[cut][type][part]->Fill(float(nPho[cut][type][part]));
        h_nConv_[cut][type][part]->Fill(float(nConv[cut][type][part]));
      }
    }
  }
}  //End of Analyze method

book2DHistoVector()

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

private

Definition at line 1253 of file PhotonAnalyzer.cc.

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

                                                    {
  int histo_index = 0;

  vector<MonitorElement*> temp1DVector;

  //determining which folder we're in
  bool conversionPlot = false;
  if (iBooker.pwd().find("Conversions") != string::npos)
    conversionPlot = true;
  bool TwoDPlot = false;
  if (histoName.find("2D") != string::npos)
    TwoDPlot = true;

  if (conversionPlot) {
    histo_index_conversions_++;
    histo_index = histo_index_conversions_;
  } else {
    histo_index_photons_++;
    histo_index = histo_index_photons_;
  }

  stringstream histo_number_stream;
  histo_number_stream << "h_";
  if (histo_index < 10)
    histo_number_stream << "0";
  histo_number_stream << histo_index << "_";

  for (int cut = 0; cut != numberOfSteps_; ++cut) {       //looping over Et cut values
    for (uint type = 0; type != types_.size(); ++type) {  //looping over isolation type
      currentFolder_.str("");
      currentFolder_ << "Egamma/" + fName_ + "/" << types_[type] << "Photons/Et above " << (cut + 1) * cutStep_
                     << " GeV";
      if (conversionPlot)
        currentFolder_ << "/Conversions";

      iBooker.setCurrentFolder(currentFolder_.str());

      string kind;
      if (conversionPlot)
        kind = " Conversions: ";
      else
        kind = " Photons: ";

      if (histoType == "1D")
        temp1DVector.push_back(
            iBooker.book1D(histo_number_stream.str() + histoName, types_[type] + kind + title, xbin, xmin, xmax));
      else if (histoType == "2D") {
        if ((TwoDPlot && type == 0) || !TwoDPlot) {  //only book the 2D plots in the "AllPhotons" folder
          temp1DVector.push_back(iBooker.book2D(
              histo_number_stream.str() + histoName, types_[type] + kind + title, xbin, xmin, xmax, ybin, ymin, ymax));
        }
      } else if (histoType == "Profile")
        temp1DVector.push_back(iBooker.bookProfile(
            histo_number_stream.str() + histoName, types_[type] + kind + title, xbin, xmin, xmax, ybin, ymin, ymax, ""));
      else
        cout << "bad histoType\n";
    }

    temp2DVector.push_back(temp1DVector);
    temp1DVector.clear();
  }
}

book3DHistoVector()

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

private

Definition at line 1326 of file PhotonAnalyzer.cc.

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

                                                    {
  int histo_index = 0;

  vector<MonitorElement*> temp1DVector;
  vector<vector<MonitorElement*> > temp2DVector;

  //determining which folder we're in
  bool conversionPlot = false;
  if (iBooker.pwd().find("Conversions") != string::npos)
    conversionPlot = true;

  if (conversionPlot) {
    histo_index_conversions_++;
    histo_index = histo_index_conversions_;
  } else {
    histo_index_photons_++;
    histo_index = histo_index_photons_;
  }

  stringstream histo_number_stream;
  histo_number_stream << "h_";
  if (histo_index < 10)
    histo_number_stream << "0";
  histo_number_stream << histo_index << "_";

  for (int cut = 0; cut != numberOfSteps_; ++cut) {         //looping over Et cut values
    for (uint type = 0; type != types_.size(); ++type) {    //looping over isolation type
      for (uint part = 0; part != parts_.size(); ++part) {  //looping over different parts of the ecal
        currentFolder_.str("");
        currentFolder_ << "Egamma/" + fName_ + "/" << types_[type] << "Photons/Et above " << (cut + 1) * cutStep_
                       << " GeV";
        if (conversionPlot)
          currentFolder_ << "/Conversions";
        iBooker.setCurrentFolder(currentFolder_.str());

        string kind;
        if (conversionPlot)
          kind = " Conversions: ";
        else
          kind = " Photons: ";

        if (histoType == "1D")
          temp1DVector.push_back(iBooker.book1D(histo_number_stream.str() + histoName + parts_[part],
                                                types_[type] + kind + parts_[part] + ": " + title,
                                                xbin,
                                                xmin,
                                                xmax));
        else if (histoType == "2D")
          temp1DVector.push_back(iBooker.book2D(histo_number_stream.str() + histoName + parts_[part],
                                                types_[type] + kind + parts_[part] + ": " + title,
                                                xbin,
                                                xmin,
                                                xmax,
                                                ybin,
                                                ymin,
                                                ymax));
        else if (histoType == "Profile")
          temp1DVector.push_back(iBooker.bookProfile(histo_number_stream.str() + histoName + parts_[part],
                                                     types_[type] + kind + parts_[part] + ": " + title,
                                                     xbin,
                                                     xmin,
                                                     xmax,
                                                     ybin,
                                                     ymin,
                                                     ymax,
                                                     ""));
        else
          cout << "bad histoType\n";
      }
      temp2DVector.push_back(temp1DVector);
      temp1DVector.clear();
    }
    temp3DVector.push_back(temp2DVector);
    temp2DVector.clear();
  }
}

bookHisto()

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

private

Definition at line 1230 of file PhotonAnalyzer.cc.

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

                                                                                               {
  int histo_index = 0;
  stringstream histo_number_stream;

  //determining which folder we're in
  if (iBooker.pwd().find("InvMass") != string::npos) {
    histo_index_invMass_++;
    histo_index = histo_index_invMass_;
  }
  if (iBooker.pwd().find("Efficiencies") != string::npos) {
    histo_index_efficiency_++;
    histo_index = histo_index_efficiency_;
  }

  histo_number_stream << "h_";
  if (histo_index < 10)
    histo_number_stream << "0";
  histo_number_stream << histo_index;

  return iBooker.book1D(histo_number_stream.str() + "_" + histoName, title, bin, min, max);
}

bookHistograms()

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 142 of file PhotonAnalyzer.cc.

                                                            {
  bookHistogramsForHistogramCounts(iBooker);

  bookHistogramsEfficiency(iBooker);
  bookHistogramsInvMass(iBooker);
  bookHistogramsPhotons(iBooker);
  bookHistogramsConversions(iBooker);

  fillHistogramsForHistogramCounts(iBooker);
}

bookHistogramsConversions()

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

private

Definition at line 1095 of file PhotonAnalyzer.cc.

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

                                                                       {
  // Set folder
  iBooker.setCurrentFolder("Egamma/" + fName_ + "/AllPhotons/Et Above 0 GeV/Conversions");

  //ENERGY VARIABLES
  book3DHistoVector(iBooker, h_phoConvE_, "1D", "phoConvE", "E;E (GeV)", eBin_, eMin_, eMax_);
  book3DHistoVector(iBooker, h_phoConvEt_, "1D", "phoConvEt", "E_{T};E_{T} (GeV)", etBin_, etMin_, etMax_);

  //GEOMETRICAL VARIABLES
  book2DHistoVector(iBooker, h_phoConvEta_, "1D", "phoConvEta", "#eta;#eta", etaBin_, etaMin_, etaMax_);
  book3DHistoVector(iBooker, h_phoConvPhi_, "1D", "phoConvPhi", "#phi;#phi", phiBin_, phiMin_, phiMax_);

  //NUMBER OF PHOTONS
  book3DHistoVector(iBooker,
                    h_nConv_,
                    "1D",
                    "nConv",
                    "Number Of Conversions per Event ;# conversions",
                    numberBin_,
                    numberMin_,
                    numberMax_);

  //SHOWER SHAPE VARIABLES
  book3DHistoVector(iBooker, h_phoConvR9_, "1D", "phoConvR9", "R9;R9", r9Bin_, r9Min_, r9Max_);

  //TRACK RELATED VARIABLES
  book3DHistoVector(iBooker, h_eOverPTracks_, "1D", "eOverPTracks", "E/P;E/P", eOverPBin_, eOverPMin_, eOverPMax_);
  book3DHistoVector(iBooker, h_pOverETracks_, "1D", "pOverETracks", "P/E;P/E", eOverPBin_, eOverPMin_, eOverPMax_);
  book3DHistoVector(iBooker,
                    h_dPhiTracksAtVtx_,
                    "1D",
                    "dPhiTracksAtVtx",
                    "#Delta#phi of Tracks at Vertex;#Delta#phi",
                    dPhiTracksBin_,
                    dPhiTracksMin_,
                    dPhiTracksMax_);
  book3DHistoVector(iBooker,
                    h_dPhiTracksAtEcal_,
                    "1D",
                    "dPhiTracksAtEcal",
                    "Abs(#Delta#phi) of Tracks at Ecal;#Delta#phi",
                    dPhiTracksBin_,
                    0.,
                    dPhiTracksMax_);
  book3DHistoVector(iBooker,
                    h_dEtaTracksAtEcal_,
                    "1D",
                    "dEtaTracksAtEcal",
                    "#Delta#eta of Tracks at Ecal;#Delta#eta",
                    dEtaTracksBin_,
                    dEtaTracksMin_,
                    dEtaTracksMax_);
  book3DHistoVector(iBooker,
                    h_dCotTracks_,
                    "1D",
                    "dCotTracks",
                    "#Deltacot(#theta) of Tracks;#Deltacot(#theta)",
                    dEtaTracksBin_,
                    dEtaTracksMin_,
                    dEtaTracksMax_);
  book2DHistoVector(iBooker,
                    p_dCotTracksVsEta_,
                    "Profile",
                    "dCotTracksVsEta",
                    "Avg #Deltacot(#theta) of Tracks vs #eta;#eta;#Deltacot(#theta)",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    dEtaTracksBin_,
                    dEtaTracksMin_,
                    dEtaTracksMax_);
  book2DHistoVector(iBooker,
                    p_nHitsVsEta_,
                    "Profile",
                    "nHitsVsEta",
                    "Avg Number of Hits per Track vs #eta;#eta;# hits",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    etaBin_,
                    0,
                    16);
  book2DHistoVector(
      iBooker, h_tkChi2_, "1D", "tkChi2", "#chi^{2} of Track Fitting;#chi^{2}", chi2Bin_, chi2Min_, chi2Max_);
  book2DHistoVector(iBooker,
                    p_tkChi2VsEta_,
                    "Profile",
                    "tkChi2VsEta",
                    "Avg #chi^{2} of Track Fitting vs #eta;#eta;#chi^{2}",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    chi2Bin_,
                    chi2Min_,
                    chi2Max_);

  //VERTEX RELATED VARIABLES
  book2DHistoVector(iBooker,
                    h_convVtxRvsZ_,
                    "2D",
                    "convVtxRvsZ",
                    "Vertex Position;Z (cm);R (cm)",
                    500,
                    zMin_,
                    zMax_,
                    rBin_,
                    rMin_,
                    rMax_);
  book2DHistoVector(
      iBooker, h_convVtxZEndcap_, "1D", "convVtxZEndcap", "Vertex Position: #eta > 1.5;Z (cm)", zBin_, zMin_, zMax_);
  book2DHistoVector(iBooker, h_convVtxZ_, "1D", "convVtxZ", "Vertex Position;Z (cm)", zBin_, zMin_, zMax_);
  book2DHistoVector(iBooker, h_convVtxR_, "1D", "convVtxR", "Vertex Position: #eta < 1;R (cm)", rBin_, rMin_, rMax_);
  book2DHistoVector(iBooker,
                    h_convVtxYvsX_,
                    "2D",
                    "convVtxYvsX",
                    "Vertex Position: #eta < 1;X (cm);Y (cm)",
                    xBin_,
                    xMin_,
                    xMax_,
                    yBin_,
                    yMin_,
                    yMax_);
  book2DHistoVector(iBooker,
                    h_vertexChi2Prob_,
                    "1D",
                    "vertexChi2Prob",
                    "#chi^{2} Probability of Vertex Fitting;#chi^{2}",
                    100,
                    0.,
                    1.0);
}

bookHistogramsEfficiency()

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

private

Definition at line 172 of file PhotonAnalyzer.cc.

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

                                                                      {
  // Set folder
  iBooker.setCurrentFolder("Egamma/" + fName_ + "/Efficiencies");

  // Don't number these histograms with the "bookHisto" method, since they'll be erased in the offline client
  h_phoEta_Loose_ = iBooker.book1D("phoEtaLoose", "Loose Photon #eta", etaBin_, etaMin_, etaMax_);
  h_phoEta_Tight_ = iBooker.book1D("phoEtaTight", "Tight Photon #eta", etaBin_, etaMin_, etaMax_);

  h_phoEt_Loose_ = iBooker.book1D("phoEtLoose", "Loose Photon E_{T}", etBin_, etMin_, etMax_);
  h_phoEt_Tight_ = iBooker.book1D("phoEtTight", "Tight Photon E_{T}", etBin_, etMin_, etMax_);

  h_phoEta_preHLT_ = iBooker.book1D("phoEtaPreHLT", "Photon #eta: before HLT", etaBin_, etaMin_, etaMax_);
  h_phoEta_postHLT_ = iBooker.book1D("phoEtaPostHLT", "Photon #eta: after HLT", etaBin_, etaMin_, etaMax_);
  h_phoEt_preHLT_ = iBooker.book1D("phoEtPreHLT", "Photon E_{T}: before HLT", etBin_, etMin_, etMax_);
  h_phoEt_postHLT_ = iBooker.book1D("phoEtPostHLT", "Photon E_{T}: after HLT", etBin_, etMin_, etMax_);

  h_convEta_Loose_ = iBooker.book1D("convEtaLoose", "Converted Loose Photon #eta", etaBin_, etaMin_, etaMax_);
  h_convEta_Tight_ = iBooker.book1D("convEtaTight", "Converted Tight Photon #eta", etaBin_, etaMin_, etaMax_);
  h_convEt_Loose_ = iBooker.book1D("convEtLoose", "Converted Loose Photon E_{T}", etBin_, etMin_, etMax_);
  h_convEt_Tight_ = iBooker.book1D("convEtTight", "Converted Tight Photon E_{T}", etBin_, etMin_, etMax_);

  h_phoEta_Vertex_ =
      iBooker.book1D("phoEtaVertex", "Converted Photons before valid vertex cut: #eta", etaBin_, etaMin_, etaMax_);

  // Some temporary vectors
  vector<MonitorElement*> temp1DVectorEta;
  vector<MonitorElement*> temp1DVectorPhi;
  vector<vector<MonitorElement*> > temp2DVectorPhi;

  for (int cut = 0; cut != numberOfSteps_; ++cut) {       //looping over Et cut values
    for (uint type = 0; type != types_.size(); ++type) {  //looping over isolation type
      currentFolder_.str("");
      currentFolder_ << "Egamma/" + fName_ + "/" << types_[type] << "Photons/Et above " << (cut + 1) * cutStep_
                     << " GeV/Conversions";
      iBooker.setCurrentFolder(currentFolder_.str());

      temp1DVectorEta.push_back(
          iBooker.book1D("phoConvEtaForEfficiency", "Converted Photon #eta;#eta", etaBin_, etaMin_, etaMax_));
      for (uint part = 0; part != parts_.size(); ++part) {
        temp1DVectorPhi.push_back(iBooker.book1D(
            "phoConvPhiForEfficiency" + parts_[part], "Converted Photon #phi;#phi", phiBin_, phiMin_, phiMax_));
      }
      temp2DVectorPhi.push_back(temp1DVectorPhi);
      temp1DVectorPhi.clear();
    }
    h_phoConvEtaForEfficiency_.push_back(temp1DVectorEta);
    temp1DVectorEta.clear();
    h_phoConvPhiForEfficiency_.push_back(temp2DVectorPhi);
    temp2DVectorPhi.clear();
  }
}

bookHistogramsForHistogramCounts()

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

private

Definition at line 155 of file PhotonAnalyzer.cc.

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

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

bookHistogramsInvMass()

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

private

Definition at line 224 of file PhotonAnalyzer.cc.

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

                                                                   {
  // Set folder
  iBooker.setCurrentFolder("Egamma/" + fName_ + "/InvMass");

  h_invMassAllPhotons_ = bookHisto(iBooker,
                                   "invMassAllIsolatedPhotons",
                                   "Two photon invariant mass: All isolated photons;M (GeV)",
                                   etBin_,
                                   etMin_,
                                   etMax_);
  h_invMassPhotonsEBarrel_ = bookHisto(iBooker,
                                       "invMassIsoPhotonsEBarrel",
                                       "Two photon invariant mass: isolated photons in barrel; M (GeV)",
                                       etBin_,
                                       etMin_,
                                       etMax_);
  h_invMassPhotonsEEndcap_ = bookHisto(iBooker,
                                       "invMassIsoPhotonsEEndcap",
                                       "Two photon invariant mass: isolated photons in endcap; M (GeV)",
                                       etBin_,
                                       etMin_,
                                       etMax_);
  h_invMassPhotonsEEndcapEBarrel_ = bookHisto(iBooker,
                                              "invMassIsoPhotonsEEndcapEBarrel",
                                              "Two photon invariant mass: isolated photons in endcap-barrel; M (GeV)",
                                              etBin_,
                                              etMin_,
                                              etMax_);

  h_invMassZeroWithTracks_ = bookHisto(
      iBooker, "invMassZeroWithTracks", "Two photon invariant mass: Neither has tracks;M (GeV)", etBin_, etMin_, etMax_);
  h_invMassOneWithTracks_ = bookHisto(
      iBooker, "invMassOneWithTracks", "Two photon invariant mass: Only one has tracks;M (GeV)", etBin_, etMin_, etMax_);
  h_invMassTwoWithTracks_ = bookHisto(
      iBooker, "invMassTwoWithTracks", "Two photon invariant mass: Both have tracks;M (GeV)", etBin_, etMin_, etMax_);

  h_nRecoVtx_ = bookHisto(iBooker, "nOfflineVtx", "# of Offline Vertices", 200, -0.5, 199.5);
}

bookHistogramsPhotons()

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

private

Definition at line 263 of file PhotonAnalyzer.cc.

                                                                   {
  // Set folder
  // Folder is set by the book2DHistoVector and book3DHistoVector methods

  //ENERGY VARIABLES
  book3DHistoVector(iBooker, h_phoE_, "1D", "phoE", "Energy;E (GeV)", eBin_, eMin_, eMax_);
  book3DHistoVector(iBooker, h_phoSigmaEoverE_, "1D", "phoSigmaEoverE", "#sigma_{E}/E; #sigma_{E}/E", 100, 0., 0.08);
  book3DHistoVector(iBooker,
                    p_phoSigmaEoverEvsNVtx_,
                    "Profile",
                    "phoSigmaEoverEvsNVtx",
                    "#sigma_{E}/E vs NVtx; N_{vtx}; #sigma_{E}/E",
                    200,
                    -0.5,
                    199.5,
                    100,
                    0.,
                    0.08);
  book3DHistoVector(iBooker, h_phoEt_, "1D", "phoEt", "E_{T};E_{T} (GeV)", etBin_, etMin_, etMax_);

  //NUMBER OF PHOTONS
  book3DHistoVector(
      iBooker, h_nPho_, "1D", "nPho", "Number of Photons per Event;# #gamma", numberBin_, numberMin_, numberMax_);

  //GEOMETRICAL VARIABLES
  //photon eta/phi
  book2DHistoVector(iBooker, h_phoEta_, "1D", "phoEta", "#eta;#eta", etaBin_, etaMin_, etaMax_);
  book3DHistoVector(iBooker, h_phoPhi_, "1D", "phoPhi", "#phi;#phi", phiBin_, phiMin_, phiMax_);

  //supercluster eta/phi
  book2DHistoVector(iBooker, h_scEta_, "1D", "scEta", "SuperCluster #eta;#eta", etaBin_, etaMin_, etaMax_);
  book3DHistoVector(iBooker, h_scPhi_, "1D", "scPhi", "SuperCluster #phi;#phi", phiBin_, phiMin_, phiMax_);

  //SHOWER SHAPE VARIABLES
  //r9
  book3DHistoVector(iBooker, h_r9_, "1D", "r9", "R9;R9", r9Bin_, r9Min_, r9Max_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_r9VsEt_,
                      "2D",
                      "r9VsEt2D",
                      "R9 vs E_{T};E_{T} (GeV);R9",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      reducedR9Bin_,
                      r9Min_,
                      r9Max_);
  }
  book2DHistoVector(iBooker,
                    p_r9VsEt_,
                    "Profile",
                    "r9VsEt",
                    "Avg R9 vs E_{T};E_{T} (GeV);R9",
                    etBin_,
                    etMin_,
                    etMax_,
                    r9Bin_,
                    r9Min_,
                    r9Max_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_r9VsEta_,
                      "2D",
                      "r9VsEta2D",
                      "R9 vs #eta;#eta;R9",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      reducedR9Bin_,
                      r9Min_,
                      r9Max_);
  }
  book2DHistoVector(iBooker,
                    p_r9VsEta_,
                    "Profile",
                    "r9VsEta",
                    "Avg R9 vs #eta;#eta;R9",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    r9Bin_,
                    r9Min_,
                    r9Max_);

  //sigma ieta ieta
  book3DHistoVector(iBooker,
                    h_phoSigmaIetaIeta_,
                    "1D",
                    "phoSigmaIetaIeta",
                    "#sigma_{i#etai#eta};#sigma_{i#etai#eta}",
                    sigmaIetaBin_,
                    sigmaIetaMin_,
                    sigmaIetaMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_sigmaIetaIetaVsEta_,
                      "2D",
                      "sigmaIetaIetaVsEta2D",
                      "#sigma_{i#etai#eta} vs #eta;#eta;#sigma_{i#etai#eta}",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      sigmaIetaBin_,
                      sigmaIetaMin_,
                      sigmaIetaMax_);
  }
  book2DHistoVector(iBooker,
                    p_sigmaIetaIetaVsEta_,
                    "Profile",
                    "sigmaIetaIetaVsEta",
                    "Avg #sigma_{i#etai#eta} vs #eta;#eta;#sigma_{i#etai#eta}",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    sigmaIetaBin_,
                    sigmaIetaMin_,
                    sigmaIetaMax_);

  //e1x5
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_e1x5VsEt_,
                      "2D",
                      "e1x5VsEt2D",
                      "E1x5 vs E_{T};E_{T} (GeV);E1X5 (GeV)",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      reducedEtBin_,
                      etMin_,
                      etMax_);
  }
  book2DHistoVector(iBooker,
                    p_e1x5VsEt_,
                    "Profile",
                    "e1x5VsEt",
                    "Avg E1x5 vs E_{T};E_{T} (GeV);E1X5 (GeV)",
                    etBin_,
                    etMin_,
                    etMax_,
                    etBin_,
                    etMin_,
                    etMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_e1x5VsEta_,
                      "2D",
                      "e1x5VsEta2D",
                      "E1x5 vs #eta;#eta;E1X5 (GeV)",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      reducedEtBin_,
                      etMin_,
                      etMax_);
  }
  book2DHistoVector(iBooker,
                    p_e1x5VsEta_,
                    "Profile",
                    "e1x5VsEta",
                    "Avg E1x5 vs #eta;#eta;E1X5 (GeV)",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    etBin_,
                    etMin_,
                    etMax_);

  //e2x5
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_e2x5VsEt_,
                      "2D",
                      "e2x5VsEt2D",
                      "E2x5 vs E_{T};E_{T} (GeV);E2X5 (GeV)",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      reducedEtBin_,
                      etMin_,
                      etMax_);
  }
  book2DHistoVector(iBooker,
                    p_e2x5VsEt_,
                    "Profile",
                    "e2x5VsEt",
                    "Avg E2x5 vs E_{T};E_{T} (GeV);E2X5 (GeV)",
                    etBin_,
                    etMin_,
                    etMax_,
                    etBin_,
                    etMin_,
                    etMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_e2x5VsEta_,
                      "2D",
                      "e2x5VsEta2D",
                      "E2x5 vs #eta;#eta;E2X5 (GeV)",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      reducedEtBin_,
                      etMin_,
                      etMax_);
  }
  book2DHistoVector(iBooker,
                    p_e2x5VsEta_,
                    "Profile",
                    "e2x5VsEta",
                    "Avg E2x5 vs #eta;#eta;E2X5 (GeV)",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    etBin_,
                    etMin_,
                    etMax_);

  //r1x5
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_r1x5VsEt_,
                      "2D",
                      "r1x5VsEt2D",
                      "R1x5 vs E_{T};E_{T} (GeV);R1X5",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      reducedR9Bin_,
                      r9Min_,
                      r9Max_);
  }
  book2DHistoVector(iBooker,
                    p_r1x5VsEt_,
                    "Profile",
                    "r1x5VsEt",
                    "Avg R1x5 vs E_{T};E_{T} (GeV);R1X5",
                    etBin_,
                    etMin_,
                    etMax_,
                    r9Bin_,
                    r9Min_,
                    r9Max_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_r1x5VsEta_,
                      "2D",
                      "r1x5VsEta2D",
                      "R1x5 vs #eta;#eta;R1X5",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      reducedR9Bin_,
                      r9Min_,
                      r9Max_);
  }
  book2DHistoVector(iBooker,
                    p_r1x5VsEta_,
                    "Profile",
                    "r1x5VsEta",
                    "Avg R1x5 vs #eta;#eta;R1X5",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    r9Bin_,
                    r9Min_,
                    r9Max_);

  //r2x5
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_r2x5VsEt_,
                      "2D",
                      "r2x5VsEt2D",
                      "R2x5 vs E_{T};E_{T} (GeV);R2X5",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      reducedR9Bin_,
                      r9Min_,
                      r9Max_);
  }
  book2DHistoVector(iBooker,
                    p_r2x5VsEt_,
                    "Profile",
                    "r2x5VsEt",
                    "Avg R2x5 vs E_{T};E_{T} (GeV);R2X5",
                    etBin_,
                    etMin_,
                    etMax_,
                    r9Bin_,
                    r9Min_,
                    r9Max_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_r2x5VsEta_,
                      "2D",
                      "r2x5VsEta2D",
                      "R2x5 vs #eta;#eta;R2X5",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      reducedR9Bin_,
                      r9Min_,
                      r9Max_);
  }
  book2DHistoVector(iBooker,
                    p_r2x5VsEta_,
                    "Profile",
                    "r2x5VsEta",
                    "Avg R2x5 vs #eta;#eta;R2X5",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    r9Bin_,
                    r9Min_,
                    r9Max_);

  //maxEXtalOver3x3
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_maxEXtalOver3x3VsEt_,
                      "2D",
                      "maxEXtalOver3x3VsEt2D",
                      "(Max Xtal E)/E3x3 vs E_{T};E_{T} (GeV);(Max Xtal E)/E3x3",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      r9Bin_,
                      r9Min_,
                      r9Max_);
  }
  book2DHistoVector(iBooker,
                    p_maxEXtalOver3x3VsEt_,
                    "Profile",
                    "maxEXtalOver3x3VsEt",
                    "Avg (Max Xtal E)/E3x3 vs E_{T};E_{T} (GeV);(Max Xtal E)/E3x3",
                    etBin_,
                    etMin_,
                    etMax_,
                    r9Bin_,
                    r9Min_,
                    r9Max_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_maxEXtalOver3x3VsEta_,
                      "2D",
                      "maxEXtalOver3x3VsEta2D",
                      "(Max Xtal E)/E3x3 vs #eta;#eta;(Max Xtal E)/E3x3",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      r9Bin_,
                      r9Min_,
                      r9Max_);
  }
  book2DHistoVector(iBooker,
                    p_maxEXtalOver3x3VsEta_,
                    "Profile",
                    "maxEXtalOver3x3VsEta",
                    "Avg (Max Xtal E)/E3x3 vs #eta;#eta;(Max Xtal E)/E3x3",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    r9Bin_,
                    r9Min_,
                    r9Max_);

  //TRACK ISOLATION VARIABLES
  //nTrackIsolSolid
  book2DHistoVector(iBooker,
                    h_nTrackIsolSolid_,
                    "1D",
                    "nIsoTracksSolid",
                    "Number Of Tracks in the Solid Iso Cone;# tracks",
                    numberBin_,
                    numberMin_,
                    numberMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_nTrackIsolSolidVsEt_,
                      "2D",
                      "nIsoTracksSolidVsEt2D",
                      "Number Of Tracks in the Solid Iso Cone vs E_{T};E_{T};# tracks",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      numberBin_,
                      numberMin_,
                      numberMax_);
  }
  book2DHistoVector(iBooker,
                    p_nTrackIsolSolidVsEt_,
                    "Profile",
                    "nIsoTracksSolidVsEt",
                    "Avg Number Of Tracks in the Solid Iso Cone vs E_{T};E_{T};# tracks",
                    etBin_,
                    etMin_,
                    etMax_,
                    numberBin_,
                    numberMin_,
                    numberMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_nTrackIsolSolidVsEta_,
                      "2D",
                      "nIsoTracksSolidVsEta2D",
                      "Number Of Tracks in the Solid Iso Cone vs #eta;#eta;# tracks",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      numberBin_,
                      numberMin_,
                      numberMax_);
  }
  book2DHistoVector(iBooker,
                    p_nTrackIsolSolidVsEta_,
                    "Profile",
                    "nIsoTracksSolidVsEta",
                    "Avg Number Of Tracks in the Solid Iso Cone vs #eta;#eta;# tracks",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    numberBin_,
                    numberMin_,
                    numberMax_);

  //nTrackIsolHollow
  book2DHistoVector(iBooker,
                    h_nTrackIsolHollow_,
                    "1D",
                    "nIsoTracksHollow",
                    "Number Of Tracks in the Hollow Iso Cone;# tracks",
                    numberBin_,
                    numberMin_,
                    numberMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_nTrackIsolHollowVsEt_,
                      "2D",
                      "nIsoTracksHollowVsEt2D",
                      "Number Of Tracks in the Hollow Iso Cone vs E_{T};E_{T};# tracks",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      numberBin_,
                      numberMin_,
                      numberMax_);
  }
  book2DHistoVector(iBooker,
                    p_nTrackIsolHollowVsEt_,
                    "Profile",
                    "nIsoTracksHollowVsEt",
                    "Avg Number Of Tracks in the Hollow Iso Cone vs E_{T};E_{T};# tracks",
                    etBin_,
                    etMin_,
                    etMax_,
                    numberBin_,
                    numberMin_,
                    numberMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_nTrackIsolHollowVsEta_,
                      "2D",
                      "nIsoTracksHollowVsEta2D",
                      "Number Of Tracks in the Hollow Iso Cone vs #eta;#eta;# tracks",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      numberBin_,
                      numberMin_,
                      numberMax_);
  }
  book2DHistoVector(iBooker,
                    p_nTrackIsolHollowVsEta_,
                    "Profile",
                    "nIsoTracksHollowVsEta",
                    "Avg Number Of Tracks in the Hollow Iso Cone vs #eta;#eta;# tracks",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    numberBin_,
                    numberMin_,
                    numberMax_);

  //trackPtSumSolid
  book2DHistoVector(iBooker,
                    h_trackPtSumSolid_,
                    "1D",
                    "isoPtSumSolid",
                    "Track P_{T} Sum in the Solid Iso Cone;P_{T} (GeV)",
                    sumBin_,
                    sumMin_,
                    sumMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_trackPtSumSolidVsEt_,
                      "2D",
                      "isoPtSumSolidVsEt2D",
                      "Track P_{T} Sum in the Solid Iso Cone;E_{T} (GeV);P_{T} (GeV)",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      reducedSumBin_,
                      sumMin_,
                      sumMax_);
  }
  book2DHistoVector(iBooker,
                    p_trackPtSumSolidVsEt_,
                    "Profile",
                    "isoPtSumSolidVsEt",
                    "Avg Track P_{T} Sum in the Solid Iso Cone vs E_{T};E_{T} (GeV);P_{T} (GeV)",
                    etBin_,
                    etMin_,
                    etMax_,
                    sumBin_,
                    sumMin_,
                    sumMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_trackPtSumSolidVsEta_,
                      "2D",
                      "isoPtSumSolidVsEta2D",
                      "Track P_{T} Sum in the Solid Iso Cone;#eta;P_{T} (GeV)",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      reducedSumBin_,
                      sumMin_,
                      sumMax_);
  }
  book2DHistoVector(iBooker,
                    p_trackPtSumSolidVsEta_,
                    "Profile",
                    "isoPtSumSolidVsEta",
                    "Avg Track P_{T} Sum in the Solid Iso Cone vs #eta;#eta;P_{T} (GeV)",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    sumBin_,
                    sumMin_,
                    sumMax_);

  //trackPtSumHollow
  book2DHistoVector(iBooker,
                    h_trackPtSumHollow_,
                    "1D",
                    "isoPtSumHollow",
                    "Track P_{T} Sum in the Hollow Iso Cone;P_{T} (GeV)",
                    sumBin_,
                    sumMin_,
                    sumMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_trackPtSumHollowVsEt_,
                      "2D",
                      "isoPtSumHollowVsEt2D",
                      "Track P_{T} Sum in the Hollow Iso Cone;E_{T} (GeV);P_{T} (GeV)",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      reducedSumBin_,
                      sumMin_,
                      sumMax_);
  }
  book2DHistoVector(iBooker,
                    p_trackPtSumHollowVsEt_,
                    "Profile",
                    "isoPtSumHollowVsEt",
                    "Avg Track P_{T} Sum in the Hollow Iso Cone vs E_{T};E_{T} (GeV);P_{T} (GeV)",
                    etBin_,
                    etMin_,
                    etMax_,
                    sumBin_,
                    sumMin_,
                    sumMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_trackPtSumHollowVsEta_,
                      "2D",
                      "isoPtSumHollowVsEta2D",
                      "Track P_{T} Sum in the Hollow Iso Cone;#eta;P_{T} (GeV)",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      reducedSumBin_,
                      sumMin_,
                      sumMax_);
  }
  book2DHistoVector(iBooker,
                    p_trackPtSumHollowVsEta_,
                    "Profile",
                    "isoPtSumHollowVsEta",
                    "Avg Track P_{T} Sum in the Hollow Iso Cone vs #eta;#eta;P_{T} (GeV)",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    sumBin_,
                    sumMin_,
                    sumMax_);

  //CALORIMETER ISOLATION VARIABLES
  //ecal sum
  book2DHistoVector(
      iBooker, h_ecalSum_, "1D", "ecalSum", "Ecal Sum in the Iso Cone;E (GeV)", sumBin_, sumMin_, sumMax_);
  book2DHistoVector(iBooker,
                    h_ecalSumEBarrel_,
                    "1D",
                    "ecalSumEBarrel",
                    "Ecal Sum in the IsoCone for Barrel;E (GeV)",
                    sumBin_,
                    sumMin_,
                    sumMax_);
  book2DHistoVector(iBooker,
                    h_ecalSumEEndcap_,
                    "1D",
                    "ecalSumEEndcap",
                    "Ecal Sum in the IsoCone for Endcap;E (GeV)",
                    sumBin_,
                    sumMin_,
                    sumMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_ecalSumVsEt_,
                      "2D",
                      "ecalSumVsEt2D",
                      "Ecal Sum in the Iso Cone;E_{T} (GeV);E (GeV)",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      reducedSumBin_,
                      sumMin_,
                      sumMax_);
  }
  book3DHistoVector(iBooker,
                    p_ecalSumVsEt_,
                    "Profile",
                    "ecalSumVsEt",
                    "Avg Ecal Sum in the Iso Cone vs E_{T};E_{T} (GeV);E (GeV)",
                    etBin_,
                    etMin_,
                    etMax_,
                    sumBin_,
                    sumMin_,
                    sumMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_ecalSumVsEta_,
                      "2D",
                      "ecalSumVsEta2D",
                      "Ecal Sum in the Iso Cone;#eta;E (GeV)",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      reducedSumBin_,
                      sumMin_,
                      sumMax_);
  }
  book2DHistoVector(iBooker,
                    p_ecalSumVsEta_,
                    "Profile",
                    "ecalSumVsEta",
                    "Avg Ecal Sum in the Iso Cone vs #eta;#eta;E (GeV)",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    sumBin_,
                    sumMin_,
                    sumMax_);

  //hcal sum
  book2DHistoVector(
      iBooker, h_hcalSum_, "1D", "hcalSum", "Hcal Sum in the Iso Cone;E (GeV)", sumBin_, sumMin_, sumMax_);
  book2DHistoVector(iBooker,
                    h_hcalSumEBarrel_,
                    "1D",
                    "hcalSumEBarrel",
                    "Hcal Sum in the IsoCone for Barrel;E (GeV)",
                    sumBin_,
                    sumMin_,
                    sumMax_);
  book2DHistoVector(iBooker,
                    h_hcalSumEEndcap_,
                    "1D",
                    "hcalSumEEndcap",
                    "Hcal Sum in the IsoCone for Endcap;E (GeV)",
                    sumBin_,
                    sumMin_,
                    sumMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_hcalSumVsEt_,
                      "2D",
                      "hcalSumVsEt2D",
                      "Hcal Sum in the Iso Cone;E_{T} (GeV);E (GeV)",
                      reducedEtBin_,
                      etMin_,
                      etMax_,
                      reducedSumBin_,
                      sumMin_,
                      sumMax_);
  }
  book3DHistoVector(iBooker,
                    p_hcalSumVsEt_,
                    "Profile",
                    "hcalSumVsEt",
                    "Avg Hcal Sum in the Iso Cone vs E_{T};E_{T} (GeV);E (GeV)",
                    etBin_,
                    etMin_,
                    etMax_,
                    sumBin_,
                    sumMin_,
                    sumMax_);
  if (standAlone_) {
    book2DHistoVector(iBooker,
                      h_hcalSumVsEta_,
                      "2D",
                      "hcalSumVsEta2D",
                      "Hcal Sum in the Iso Cone;#eta;E (GeV)",
                      reducedEtaBin_,
                      etaMin_,
                      etaMax_,
                      reducedSumBin_,
                      sumMin_,
                      sumMax_);
  }
  book2DHistoVector(iBooker,
                    p_hcalSumVsEta_,
                    "Profile",
                    "hcalSumVsEta",
                    "Avg Hcal Sum in the Iso Cone vs #eta;#eta;E (GeV)",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    sumBin_,
                    sumMin_,
                    sumMax_);

  //h over e
  book3DHistoVector(iBooker, h_hOverE_, "1D", "hOverE", "H/E;H/E", hOverEBin_, hOverEMin_, hOverEMax_);
  book2DHistoVector(iBooker,
                    p_hOverEVsEt_,
                    "Profile",
                    "hOverEVsEt",
                    "Avg H/E vs Et;E_{T} (GeV);H/E",
                    etBin_,
                    etMin_,
                    etMax_,
                    hOverEBin_,
                    hOverEMin_,
                    hOverEMax_);
  book2DHistoVector(iBooker,
                    p_hOverEVsEta_,
                    "Profile",
                    "hOverEVsEta",
                    "Avg H/E vs #eta;#eta;H/E",
                    etaBin_,
                    etaMin_,
                    etaMax_,
                    hOverEBin_,
                    hOverEMin_,
                    hOverEMax_);
  book3DHistoVector(iBooker, h_h1OverE_, "1D", "h1OverE", "H/E for Depth 1;H/E", hOverEBin_, hOverEMin_, hOverEMax_);
  book3DHistoVector(iBooker, h_h2OverE_, "1D", "h2OverE", "H/E for Depth 2;H/E", hOverEBin_, hOverEMin_, hOverEMax_);

  // pf isolation
  book2DHistoVector(
      iBooker, h_phoIsoBarrel_, "1D", "phoIsoBarrel", "PF photon iso Barrel;E (GeV)", reducedEtBin_, etMin_, 25.);
  book2DHistoVector(
      iBooker, h_phoIsoEndcap_, "1D", "phoIsoEndcap", "PF photon iso Endcap;E (GeV)", reducedEtBin_, etMin_, 25.);
  book2DHistoVector(iBooker,
                    h_chHadIsoBarrel_,
                    "1D",
                    "chHadIsoBarrel",
                    "PF charged Had iso Barrel;E (GeV)",
                    reducedEtBin_,
                    etMin_,
                    25.);
  book2DHistoVector(iBooker,
                    h_chHadIsoEndcap_,
                    "1D",
                    "chHadIsoEndcap",
                    "PF charged Had iso Endcap;E (GeV)",
                    reducedEtBin_,
                    etMin_,
                    25.);
  book2DHistoVector(iBooker,
                    h_nHadIsoBarrel_,
                    "1D",
                    "neutralHadIsoBarrel",
                    "PF neutral Had iso Barrel;E (GeV)",
                    reducedEtBin_,
                    etMin_,
                    25.);
  book2DHistoVector(iBooker,
                    h_nHadIsoEndcap_,
                    "1D",
                    "neutralHadIsoEndcap",
                    "PF neutral Had iso Endcap;E (GeV)",
                    reducedEtBin_,
                    etMin_,
                    25.);

  //OTHER VARIABLES
  //bad channel histograms
  book2DHistoVector(iBooker,
                    h_phoEt_BadChannels_,
                    "1D",
                    "phoEtBadChannels",
                    "Fraction Containing Bad Channels: E_{T};E_{T} (GeV)",
                    etBin_,
                    etMin_,
                    etMax_);
  book2DHistoVector(iBooker,
                    h_phoEta_BadChannels_,
                    "1D",
                    "phoEtaBadChannels",
                    "Fraction Containing Bad Channels: #eta;#eta",
                    etaBin_,
                    etaMin_,
                    etaMax_);
  book2DHistoVector(iBooker,
                    h_phoPhi_BadChannels_,
                    "1D",
                    "phoPhiBadChannels",
                    "Fraction Containing Bad Channels: #phi;#phi",
                    phiBin_,
                    phiMin_,
                    phiMax_);
}

fill2DHistoVector() [1/2]

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

private

fill2DHistoVector() [2/2]

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

private

fill3DHistoVector() [1/2]

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

private

fill3DHistoVector() [2/2]

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

private

fillHistogramsForHistogramCounts()

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

private

Definition at line 164 of file PhotonAnalyzer.cc.

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

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

phiNormalization()

float PhotonAnalyzer::phiNormalization ( float &  a )

private

Definition at line 2033 of file PhotonAnalyzer.cc.

References PI, and TWOPI.

                                                 {
  const float PI = 3.1415927;
  const float TWOPI = 2.0 * PI;

  if (phi > PI) {
    phi = phi - TWOPI;
  }
  if (phi < -PI) {
    phi = phi + TWOPI;
  }

  return phi;
}

photonSelection()

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

private

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

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

Definition at line 2075 of file PhotonAnalyzer.cc.

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

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

  double EtCorrHcalIso = pho->hcalTowerSumEtConeDR03() - 0.005 * pho->pt();
  double EtCorrTrkIso = pho->trkSumPtHollowConeDR03() - 0.002 * pho->pt();

  if (pho->r9() <= 0.9) {
    if (pho->isEB() && (pho->hadTowOverEm() > 0.075 || pho->sigmaIetaIeta() > 0.014))
      result = false;
    if (pho->isEE() && (pho->hadTowOverEm() > 0.075 || pho->sigmaIetaIeta() > 0.034))
      result = false;
    if (EtCorrHcalIso > 4.0)
      result = false;
    if (EtCorrTrkIso > 4.0)
      result = false;
    if (pho->chargedHadronIso() > 4)
      result = false;
  } else {
    if (pho->isEB() && (pho->hadTowOverEm() > 0.082 || pho->sigmaIetaIeta() > 0.014))
      result = false;
    if (pho->isEE() && (pho->hadTowOverEm() > 0.075 || pho->sigmaIetaIeta() > 0.034))
      result = false;
    if (EtCorrHcalIso > 50.0)
      result = false;
    if (EtCorrTrkIso > 50.0)
      result = false;
    if (pho->chargedHadronIso() > 4)
      result = false;
  }
  return result;
}

photonSelectionSlimmed()

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

private

Definition at line 2115 of file PhotonAnalyzer.cc.

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

                                                                 {
  bool result = true;

  if (pho->pt() < minPhoEtCut_)
    result = false;
  if (fabs(pho->eta()) > photonMaxEta_)
    result = false;
  if (pho->isEBEEGap())
    result = false;

  return result;
}

Member Data Documentation

barrelRecHit_token_

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

private

Definition at line 164 of file PhotonAnalyzer.h.

chi2Bin_

int PhotonAnalyzer::chi2Bin_

private

Definition at line 252 of file PhotonAnalyzer.h.

chi2Max_

double PhotonAnalyzer::chi2Max_

private

Definition at line 254 of file PhotonAnalyzer.h.

chi2Min_

double PhotonAnalyzer::chi2Min_

private

Definition at line 253 of file PhotonAnalyzer.h.

currentFolder_

std::stringstream PhotonAnalyzer::currentFolder_

private

Definition at line 189 of file PhotonAnalyzer.h.

cutStep_

double PhotonAnalyzer::cutStep_

private

Definition at line 173 of file PhotonAnalyzer.h.

dEtaTracksBin_

int PhotonAnalyzer::dEtaTracksBin_

private

Definition at line 248 of file PhotonAnalyzer.h.

dEtaTracksMax_

double PhotonAnalyzer::dEtaTracksMax_

private

Definition at line 250 of file PhotonAnalyzer.h.

dEtaTracksMin_

double PhotonAnalyzer::dEtaTracksMin_

private

Definition at line 249 of file PhotonAnalyzer.h.

dPhiTracksBin_

int PhotonAnalyzer::dPhiTracksBin_

private

Definition at line 244 of file PhotonAnalyzer.h.

dPhiTracksMax_

double PhotonAnalyzer::dPhiTracksMax_

private

Definition at line 246 of file PhotonAnalyzer.h.

dPhiTracksMin_

double PhotonAnalyzer::dPhiTracksMin_

private

Definition at line 245 of file PhotonAnalyzer.h.

eBin_

int PhotonAnalyzer::eBin_

private

Definition at line 216 of file PhotonAnalyzer.h.

eMax_

double PhotonAnalyzer::eMax_

private

Definition at line 218 of file PhotonAnalyzer.h.

eMin_

double PhotonAnalyzer::eMin_

private

Definition at line 217 of file PhotonAnalyzer.h.

endcapRecHit_token_

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

private

Definition at line 165 of file PhotonAnalyzer.h.

eOverPBin_

int PhotonAnalyzer::eOverPBin_

private

Definition at line 240 of file PhotonAnalyzer.h.

eOverPMax_

double PhotonAnalyzer::eOverPMax_

private

Definition at line 242 of file PhotonAnalyzer.h.

eOverPMin_

double PhotonAnalyzer::eOverPMin_

private

Definition at line 241 of file PhotonAnalyzer.h.

etaBin_

int PhotonAnalyzer::etaBin_

private

Definition at line 204 of file PhotonAnalyzer.h.

etaMax_

double PhotonAnalyzer::etaMax_

private

Definition at line 206 of file PhotonAnalyzer.h.

etaMin_

double PhotonAnalyzer::etaMin_

private

Definition at line 205 of file PhotonAnalyzer.h.

etBin_

int PhotonAnalyzer::etBin_

private

Definition at line 208 of file PhotonAnalyzer.h.

etMax_

double PhotonAnalyzer::etMax_

private

Definition at line 210 of file PhotonAnalyzer.h.

etMin_

double PhotonAnalyzer::etMin_

private

Definition at line 209 of file PhotonAnalyzer.h.

excludeBkgHistos_

bool PhotonAnalyzer::excludeBkgHistos_

private

Definition at line 181 of file PhotonAnalyzer.h.

fName_

std::string PhotonAnalyzer::fName_

private

Definition at line 157 of file PhotonAnalyzer.h.

h_chHadIsoBarrel_

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

private

Definition at line 338 of file PhotonAnalyzer.h.

h_chHadIsoEndcap_

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

private

Definition at line 339 of file PhotonAnalyzer.h.

h_convEt_Loose_

MonitorElement* PhotonAnalyzer::h_convEt_Loose_

private

Definition at line 296 of file PhotonAnalyzer.h.

h_convEt_Tight_

MonitorElement* PhotonAnalyzer::h_convEt_Tight_

private

Definition at line 297 of file PhotonAnalyzer.h.

h_convEta_Loose_

MonitorElement* PhotonAnalyzer::h_convEta_Loose_

private

Definition at line 294 of file PhotonAnalyzer.h.

h_convEta_Tight_

MonitorElement* PhotonAnalyzer::h_convEta_Tight_

private

Definition at line 295 of file PhotonAnalyzer.h.

h_convVtxR_

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

private

Definition at line 395 of file PhotonAnalyzer.h.

h_convVtxRvsZ_

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

private

Definition at line 391 of file PhotonAnalyzer.h.

h_convVtxYvsX_

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

private

Definition at line 394 of file PhotonAnalyzer.h.

h_convVtxZ_

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

private

Definition at line 393 of file PhotonAnalyzer.h.

h_convVtxZEndcap_

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

private

Definition at line 392 of file PhotonAnalyzer.h.

h_dCotTracks_

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

private

Definition at line 457 of file PhotonAnalyzer.h.

h_dEtaTracksAtEcal_

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

private

Definition at line 462 of file PhotonAnalyzer.h.

h_dPhiTracksAtEcal_

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

private

Definition at line 460 of file PhotonAnalyzer.h.

h_dPhiTracksAtVtx_

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

private

Definition at line 459 of file PhotonAnalyzer.h.

h_e1x5VsEt_

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

private

Definition at line 400 of file PhotonAnalyzer.h.

h_e1x5VsEta_

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

private

Definition at line 401 of file PhotonAnalyzer.h.

h_e2x5VsEt_

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

private

Definition at line 403 of file PhotonAnalyzer.h.

h_e2x5VsEta_

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

private

Definition at line 404 of file PhotonAnalyzer.h.

h_ecalSum_

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

private

Definition at line 329 of file PhotonAnalyzer.h.

h_ecalSumEBarrel_

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

private

Definition at line 330 of file PhotonAnalyzer.h.

h_ecalSumEEndcap_

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

private

Definition at line 331 of file PhotonAnalyzer.h.

h_ecalSumVsEt_

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

private

Definition at line 322 of file PhotonAnalyzer.h.

h_ecalSumVsEta_

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

private

Definition at line 315 of file PhotonAnalyzer.h.

h_eOverPTracks_

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

private

Definition at line 454 of file PhotonAnalyzer.h.

h_h1OverE_

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

private

Definition at line 441 of file PhotonAnalyzer.h.

h_h2OverE_

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

private

Definition at line 442 of file PhotonAnalyzer.h.

h_hcalSum_

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

private

Definition at line 332 of file PhotonAnalyzer.h.

h_hcalSumEBarrel_

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

private

Definition at line 333 of file PhotonAnalyzer.h.

h_hcalSumEEndcap_

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

private

Definition at line 334 of file PhotonAnalyzer.h.

h_hcalSumVsEt_

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

private

Definition at line 323 of file PhotonAnalyzer.h.

h_hcalSumVsEta_

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

private

Definition at line 316 of file PhotonAnalyzer.h.

h_hOverE_

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

private

Definition at line 440 of file PhotonAnalyzer.h.

h_invMassAllPhotons_

MonitorElement* PhotonAnalyzer::h_invMassAllPhotons_

private

Definition at line 304 of file PhotonAnalyzer.h.

h_invMassOneWithTracks_

MonitorElement* PhotonAnalyzer::h_invMassOneWithTracks_

private

Definition at line 302 of file PhotonAnalyzer.h.

h_invMassPhotonsEBarrel_

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEBarrel_

private

Definition at line 305 of file PhotonAnalyzer.h.

h_invMassPhotonsEEndcap_

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEEndcap_

private

Definition at line 306 of file PhotonAnalyzer.h.

h_invMassPhotonsEEndcapEBarrel_

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEEndcapEBarrel_

private

Definition at line 307 of file PhotonAnalyzer.h.

h_invMassTwoWithTracks_

MonitorElement* PhotonAnalyzer::h_invMassTwoWithTracks_

private

Definition at line 301 of file PhotonAnalyzer.h.

h_invMassZeroWithTracks_

MonitorElement* PhotonAnalyzer::h_invMassZeroWithTracks_

private

Definition at line 303 of file PhotonAnalyzer.h.

h_maxEXtalOver3x3VsEt_

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

private

Definition at line 406 of file PhotonAnalyzer.h.

h_maxEXtalOver3x3VsEta_

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

private

Definition at line 407 of file PhotonAnalyzer.h.

h_nConv_

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

private

Definition at line 452 of file PhotonAnalyzer.h.

h_nHadIsoBarrel_

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

private

Definition at line 340 of file PhotonAnalyzer.h.

h_nHadIsoEndcap_

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

private

Definition at line 341 of file PhotonAnalyzer.h.

h_nPho_

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

private

Definition at line 446 of file PhotonAnalyzer.h.

h_nRecoVtx_

MonitorElement* PhotonAnalyzer::h_nRecoVtx_

private

Definition at line 282 of file PhotonAnalyzer.h.

h_nTrackIsolHollow_

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

private

Definition at line 327 of file PhotonAnalyzer.h.

h_nTrackIsolHollowVsEt_

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

private

Definition at line 320 of file PhotonAnalyzer.h.

h_nTrackIsolHollowVsEta_

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

private

Definition at line 313 of file PhotonAnalyzer.h.

h_nTrackIsolSolid_

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

private

Definition at line 325 of file PhotonAnalyzer.h.

h_nTrackIsolSolidVsEt_

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

private

Definition at line 318 of file PhotonAnalyzer.h.

h_nTrackIsolSolidVsEta_

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

private

Definition at line 311 of file PhotonAnalyzer.h.

h_phoConvE_

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

private

Definition at line 448 of file PhotonAnalyzer.h.

h_phoConvEt_

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

private

Definition at line 449 of file PhotonAnalyzer.h.

h_phoConvEta_

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

private

Definition at line 389 of file PhotonAnalyzer.h.

h_phoConvEtaForEfficiency_

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

private

Definition at line 383 of file PhotonAnalyzer.h.

h_phoConvPhi_

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

private

Definition at line 438 of file PhotonAnalyzer.h.

h_phoConvPhiForEfficiency_

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

private

Definition at line 437 of file PhotonAnalyzer.h.

h_phoConvR9_

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

private

Definition at line 450 of file PhotonAnalyzer.h.

h_phoE_

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

private

Definition at line 430 of file PhotonAnalyzer.h.

h_phoEt_

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

private

Definition at line 433 of file PhotonAnalyzer.h.

h_phoEt_BadChannels_

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

private

Definition at line 386 of file PhotonAnalyzer.h.

h_phoEt_Loose_

MonitorElement* PhotonAnalyzer::h_phoEt_Loose_

private

Definition at line 286 of file PhotonAnalyzer.h.

h_phoEt_postHLT_

MonitorElement* PhotonAnalyzer::h_phoEt_postHLT_

private

Definition at line 292 of file PhotonAnalyzer.h.

h_phoEt_preHLT_

MonitorElement* PhotonAnalyzer::h_phoEt_preHLT_

private

Definition at line 291 of file PhotonAnalyzer.h.

h_phoEt_Tight_

MonitorElement* PhotonAnalyzer::h_phoEt_Tight_

private

Definition at line 287 of file PhotonAnalyzer.h.

h_phoEta_

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

private

Definition at line 380 of file PhotonAnalyzer.h.

h_phoEta_BadChannels_

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

private

Definition at line 385 of file PhotonAnalyzer.h.

h_phoEta_Loose_

MonitorElement* PhotonAnalyzer::h_phoEta_Loose_

private

Definition at line 284 of file PhotonAnalyzer.h.

h_phoEta_postHLT_

MonitorElement* PhotonAnalyzer::h_phoEta_postHLT_

private

Definition at line 290 of file PhotonAnalyzer.h.

h_phoEta_preHLT_

MonitorElement* PhotonAnalyzer::h_phoEta_preHLT_

private

Definition at line 289 of file PhotonAnalyzer.h.

h_phoEta_Tight_

MonitorElement* PhotonAnalyzer::h_phoEta_Tight_

private

Definition at line 285 of file PhotonAnalyzer.h.

h_phoEta_Vertex_

MonitorElement* PhotonAnalyzer::h_phoEta_Vertex_

private

Definition at line 299 of file PhotonAnalyzer.h.

h_phoIsoBarrel_

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

private

Definition at line 336 of file PhotonAnalyzer.h.

h_phoIsoEndcap_

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

private

Definition at line 337 of file PhotonAnalyzer.h.

h_phoPhi_

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

private

Definition at line 435 of file PhotonAnalyzer.h.

h_phoPhi_BadChannels_

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

private

Definition at line 387 of file PhotonAnalyzer.h.

h_phoSigmaEoverE_

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

private

Definition at line 431 of file PhotonAnalyzer.h.

h_phoSigmaIetaIeta_

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

private

Definition at line 444 of file PhotonAnalyzer.h.

h_pOverETracks_

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

private

Definition at line 455 of file PhotonAnalyzer.h.

h_r1x5VsEt_

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

private

Definition at line 409 of file PhotonAnalyzer.h.

h_r1x5VsEta_

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

private

Definition at line 410 of file PhotonAnalyzer.h.

h_r2x5VsEt_

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

private

Definition at line 412 of file PhotonAnalyzer.h.

h_r2x5VsEta_

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

private

Definition at line 413 of file PhotonAnalyzer.h.

h_r9_

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

private

Definition at line 434 of file PhotonAnalyzer.h.

h_r9VsEt_

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

private

Definition at line 397 of file PhotonAnalyzer.h.

h_r9VsEta_

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

private

Definition at line 398 of file PhotonAnalyzer.h.

h_scEta_

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

private

Definition at line 381 of file PhotonAnalyzer.h.

h_scPhi_

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

private

Definition at line 436 of file PhotonAnalyzer.h.

h_sigmaIetaIetaVsEta_

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

private

Definition at line 415 of file PhotonAnalyzer.h.

h_tkChi2_

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

private

Definition at line 417 of file PhotonAnalyzer.h.

h_trackPtSumHollow_

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

private

Definition at line 328 of file PhotonAnalyzer.h.

h_trackPtSumHollowVsEt_

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

private

Definition at line 321 of file PhotonAnalyzer.h.

h_trackPtSumHollowVsEta_

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

private

Definition at line 314 of file PhotonAnalyzer.h.

h_trackPtSumSolid_

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

private

Definition at line 326 of file PhotonAnalyzer.h.

h_trackPtSumSolidVsEt_

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

private

Definition at line 319 of file PhotonAnalyzer.h.

h_trackPtSumSolidVsEta_

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

private

Definition at line 312 of file PhotonAnalyzer.h.

h_vertexChi2Prob_

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

private

Definition at line 419 of file PhotonAnalyzer.h.

histo_index_conversions_

int PhotonAnalyzer::histo_index_conversions_

private

Definition at line 192 of file PhotonAnalyzer.h.

histo_index_efficiency_

int PhotonAnalyzer::histo_index_efficiency_

private

Definition at line 193 of file PhotonAnalyzer.h.

histo_index_invMass_

int PhotonAnalyzer::histo_index_invMass_

private

Definition at line 194 of file PhotonAnalyzer.h.

histo_index_photons_

int PhotonAnalyzer::histo_index_photons_

private

Definition at line 191 of file PhotonAnalyzer.h.

hOverEBin_

int PhotonAnalyzer::hOverEBin_

private

Definition at line 236 of file PhotonAnalyzer.h.

hOverEMax_

double PhotonAnalyzer::hOverEMax_

private

Definition at line 238 of file PhotonAnalyzer.h.

hOverEMin_

double PhotonAnalyzer::hOverEMin_

private

Definition at line 237 of file PhotonAnalyzer.h.

invMassEtCut_

double PhotonAnalyzer::invMassEtCut_

private

Definition at line 171 of file PhotonAnalyzer.h.

isHeavyIon_

bool PhotonAnalyzer::isHeavyIon_

private

Definition at line 185 of file PhotonAnalyzer.h.

isolationStrength_

int PhotonAnalyzer::isolationStrength_

private

Definition at line 183 of file PhotonAnalyzer.h.

minimalSetOfHistos_

bool PhotonAnalyzer::minimalSetOfHistos_

private

Definition at line 180 of file PhotonAnalyzer.h.

minPhoEtCut_

double PhotonAnalyzer::minPhoEtCut_

private

Definition at line 169 of file PhotonAnalyzer.h.

nEvt_

int PhotonAnalyzer::nEvt_

private

Definition at line 196 of file PhotonAnalyzer.h.

numberBin_

int PhotonAnalyzer::numberBin_

private

Definition at line 220 of file PhotonAnalyzer.h.

numberMax_

double PhotonAnalyzer::numberMax_

private

Definition at line 222 of file PhotonAnalyzer.h.

numberMin_

double PhotonAnalyzer::numberMin_

private

Definition at line 221 of file PhotonAnalyzer.h.

numberOfSteps_

int PhotonAnalyzer::numberOfSteps_

private

Definition at line 174 of file PhotonAnalyzer.h.

offline_pvToken_

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

private

Definition at line 167 of file PhotonAnalyzer.h.

p_dCotTracksVsEta_

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

private

Definition at line 375 of file PhotonAnalyzer.h.

p_e1x5VsEt_

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

private

Definition at line 358 of file PhotonAnalyzer.h.

p_e1x5VsEta_

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

private

Definition at line 359 of file PhotonAnalyzer.h.

p_e2x5VsEt_

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

private

Definition at line 361 of file PhotonAnalyzer.h.

p_e2x5VsEta_

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

private

Definition at line 362 of file PhotonAnalyzer.h.

p_ecalSumVsEt_

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

private

Definition at line 427 of file PhotonAnalyzer.h.

p_ecalSumVsEta_

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

private

Definition at line 347 of file PhotonAnalyzer.h.

p_hcalSumVsEt_

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

private

Definition at line 428 of file PhotonAnalyzer.h.

p_hcalSumVsEta_

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

private

Definition at line 348 of file PhotonAnalyzer.h.

p_hOverEVsEt_

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

private

Definition at line 378 of file PhotonAnalyzer.h.

p_hOverEVsEta_

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

private

Definition at line 377 of file PhotonAnalyzer.h.

p_maxEXtalOver3x3VsEt_

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

private

Definition at line 364 of file PhotonAnalyzer.h.

p_maxEXtalOver3x3VsEta_

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

private

Definition at line 365 of file PhotonAnalyzer.h.

p_nHitsVsEta_

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

private

Definition at line 421 of file PhotonAnalyzer.h.

p_nTrackIsolHollowVsEt_

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

private

Definition at line 352 of file PhotonAnalyzer.h.

p_nTrackIsolHollowVsEta_

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

private

Definition at line 345 of file PhotonAnalyzer.h.

p_nTrackIsolSolidVsEt_

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

private

Definition at line 350 of file PhotonAnalyzer.h.

p_nTrackIsolSolidVsEta_

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

private

Definition at line 343 of file PhotonAnalyzer.h.

p_phoSigmaEoverEvsNVtx_

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

private

Definition at line 432 of file PhotonAnalyzer.h.

p_r1x5VsEt_

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

private

Definition at line 367 of file PhotonAnalyzer.h.

p_r1x5VsEta_

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

private

Definition at line 368 of file PhotonAnalyzer.h.

p_r2x5VsEt_

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

private

Definition at line 370 of file PhotonAnalyzer.h.

p_r2x5VsEta_

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

private

Definition at line 371 of file PhotonAnalyzer.h.

p_r9VsEt_

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

private

Definition at line 355 of file PhotonAnalyzer.h.

p_r9VsEta_

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

private

Definition at line 356 of file PhotonAnalyzer.h.

p_sigmaIetaIetaVsEta_

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

private

Definition at line 373 of file PhotonAnalyzer.h.

p_tkChi2VsEta_

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

private

Definition at line 423 of file PhotonAnalyzer.h.

p_trackPtSumHollowVsEt_

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

private

Definition at line 353 of file PhotonAnalyzer.h.

p_trackPtSumHollowVsEta_

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

private

Definition at line 346 of file PhotonAnalyzer.h.

p_trackPtSumSolidVsEt_

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

private

Definition at line 351 of file PhotonAnalyzer.h.

p_trackPtSumSolidVsEta_

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

private

Definition at line 344 of file PhotonAnalyzer.h.

parts_

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

private

Definition at line 199 of file PhotonAnalyzer.h.

phiBin_

int PhotonAnalyzer::phiBin_

private

Definition at line 212 of file PhotonAnalyzer.h.

phiMax_

double PhotonAnalyzer::phiMax_

private

Definition at line 214 of file PhotonAnalyzer.h.

phiMin_

double PhotonAnalyzer::phiMin_

private

Definition at line 213 of file PhotonAnalyzer.h.

photon_token_

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

private

Definition at line 161 of file PhotonAnalyzer.h.

PhotonIDLoose_token_

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

private

Definition at line 162 of file PhotonAnalyzer.h.

PhotonIDTight_token_

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

private

Definition at line 163 of file PhotonAnalyzer.h.

photonMaxEta_

double PhotonAnalyzer::photonMaxEta_

private

Definition at line 170 of file PhotonAnalyzer.h.

prescaleFactor_

unsigned int PhotonAnalyzer::prescaleFactor_

private

Definition at line 159 of file PhotonAnalyzer.h.

r9Bin_

int PhotonAnalyzer::r9Bin_

private

Definition at line 224 of file PhotonAnalyzer.h.

r9Max_

double PhotonAnalyzer::r9Max_

private

Definition at line 226 of file PhotonAnalyzer.h.

r9Min_

double PhotonAnalyzer::r9Min_

private

Definition at line 225 of file PhotonAnalyzer.h.

rBin_

int PhotonAnalyzer::rBin_

private

Definition at line 260 of file PhotonAnalyzer.h.

reducedEtaBin_

int PhotonAnalyzer::reducedEtaBin_

private

Definition at line 273 of file PhotonAnalyzer.h.

reducedEtBin_

int PhotonAnalyzer::reducedEtBin_

private

Definition at line 272 of file PhotonAnalyzer.h.

reducedR9Bin_

int PhotonAnalyzer::reducedR9Bin_

private

Definition at line 274 of file PhotonAnalyzer.h.

reducedSumBin_

int PhotonAnalyzer::reducedSumBin_

private

Definition at line 275 of file PhotonAnalyzer.h.

rMax_

double PhotonAnalyzer::rMax_

private

Definition at line 262 of file PhotonAnalyzer.h.

rMin_

double PhotonAnalyzer::rMin_

private

Definition at line 261 of file PhotonAnalyzer.h.

sigmaIetaBin_

int PhotonAnalyzer::sigmaIetaBin_

private

Definition at line 228 of file PhotonAnalyzer.h.

sigmaIetaMax_

double PhotonAnalyzer::sigmaIetaMax_

private

Definition at line 230 of file PhotonAnalyzer.h.

sigmaIetaMin_

double PhotonAnalyzer::sigmaIetaMin_

private

Definition at line 229 of file PhotonAnalyzer.h.

standAlone_

bool PhotonAnalyzer::standAlone_

private

Definition at line 178 of file PhotonAnalyzer.h.

sumBin_

int PhotonAnalyzer::sumBin_

private

Definition at line 232 of file PhotonAnalyzer.h.

sumMax_

double PhotonAnalyzer::sumMax_

private

Definition at line 234 of file PhotonAnalyzer.h.

sumMin_

double PhotonAnalyzer::sumMin_

private

Definition at line 233 of file PhotonAnalyzer.h.

totalNumberOfHistos_conversionsFolder

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_conversionsFolder

private

Definition at line 280 of file PhotonAnalyzer.h.

totalNumberOfHistos_efficiencyFolder

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_efficiencyFolder

private

Definition at line 277 of file PhotonAnalyzer.h.

totalNumberOfHistos_invMassFolder

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_invMassFolder

private

Definition at line 278 of file PhotonAnalyzer.h.

totalNumberOfHistos_photonsFolder

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_photonsFolder

private

Definition at line 279 of file PhotonAnalyzer.h.

triggerEvent_token_

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

private

Definition at line 166 of file PhotonAnalyzer.h.

types_

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

private

Definition at line 198 of file PhotonAnalyzer.h.

useBinning_

bool PhotonAnalyzer::useBinning_

private

Definition at line 176 of file PhotonAnalyzer.h.

useTriggerFiltering_

bool PhotonAnalyzer::useTriggerFiltering_

private

Definition at line 177 of file PhotonAnalyzer.h.

xBin_

int PhotonAnalyzer::xBin_

private

Definition at line 264 of file PhotonAnalyzer.h.

xMax_

double PhotonAnalyzer::xMax_

private

Definition at line 266 of file PhotonAnalyzer.h.

xMin_

double PhotonAnalyzer::xMin_

private

Definition at line 265 of file PhotonAnalyzer.h.

yBin_

int PhotonAnalyzer::yBin_

private

Definition at line 268 of file PhotonAnalyzer.h.

yMax_

double PhotonAnalyzer::yMax_

private

Definition at line 270 of file PhotonAnalyzer.h.

yMin_

double PhotonAnalyzer::yMin_

private

Definition at line 269 of file PhotonAnalyzer.h.

zBin_

int PhotonAnalyzer::zBin_

private

Definition at line 256 of file PhotonAnalyzer.h.

zMax_

double PhotonAnalyzer::zMax_

private

Definition at line 258 of file PhotonAnalyzer.h.

zMin_

double PhotonAnalyzer::zMin_

private

Definition at line 257 of file PhotonAnalyzer.h.