PhotonAnalyzer Class Reference

EgammaCoreTools. More...

#include <PhotonAnalyzer.h>

Inheritance diagram for PhotonAnalyzer:

Public Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
	PhotonAnalyzer (const edm::ParameterSet &)
virtual	~PhotonAnalyzer ()
Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final
virtual void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer (void)
virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
uint32_t	streamId () const
Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDAnalyzerBase ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

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::PhotonRef &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_invMassTwoWithTracks_
MonitorElement *	h_invMassZeroWithTracks_
std::vector< std::vector < MonitorElement * > >	h_maxEXtalOver3x3VsEt_
std::vector< std::vector < MonitorElement * > >	h_maxEXtalOver3x3VsEta_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_nConv_
std::vector< std::vector < MonitorElement * > >	h_nHadIsoBarrel_
std::vector< std::vector < MonitorElement * > >	h_nHadIsoEndcap_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_nPho_
MonitorElement *	h_nRecoVtx_
std::vector< std::vector < MonitorElement * > >	h_nTrackIsolHollow_
std::vector< std::vector < MonitorElement * > >	h_nTrackIsolHollowVsEt_
std::vector< std::vector < MonitorElement * > >	h_nTrackIsolHollowVsEta_
std::vector< std::vector < MonitorElement * > >	h_nTrackIsolSolid_
std::vector< std::vector < MonitorElement * > >	h_nTrackIsolSolidVsEt_
std::vector< std::vector < MonitorElement * > >	h_nTrackIsolSolidVsEta_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_phoConvE_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_phoConvEt_
std::vector< std::vector < MonitorElement * > >	h_phoConvEta_
std::vector< std::vector < MonitorElement * > >	h_phoConvEtaForEfficiency_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_phoConvPhi_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_phoConvPhiForEfficiency_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_phoConvR9_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_phoE_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_phoEt_
std::vector< std::vector < MonitorElement * > >	h_phoEt_BadChannels_
MonitorElement *	h_phoEt_Loose_
MonitorElement *	h_phoEt_postHLT_
MonitorElement *	h_phoEt_preHLT_
MonitorElement *	h_phoEt_Tight_
std::vector< std::vector < MonitorElement * > >	h_phoEta_
std::vector< std::vector < MonitorElement * > >	h_phoEta_BadChannels_
MonitorElement *	h_phoEta_Loose_
MonitorElement *	h_phoEta_postHLT_
MonitorElement *	h_phoEta_preHLT_
MonitorElement *	h_phoEta_Tight_
MonitorElement *	h_phoEta_Vertex_
std::vector< std::vector < MonitorElement * > >	h_phoIsoBarrel_
std::vector< std::vector < MonitorElement * > >	h_phoIsoEndcap_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_phoPhi_
std::vector< std::vector < MonitorElement * > >	h_phoPhi_BadChannels_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_phoSigmaEoverE_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_phoSigmaIetaIeta_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_pOverETracks_
std::vector< std::vector < MonitorElement * > >	h_r1x5VsEt_
std::vector< std::vector < MonitorElement * > >	h_r1x5VsEta_
std::vector< std::vector < MonitorElement * > >	h_r2x5VsEt_
std::vector< std::vector < MonitorElement * > >	h_r2x5VsEta_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_r9_
std::vector< std::vector < MonitorElement * > >	h_r9VsEt_
std::vector< std::vector < MonitorElement * > >	h_r9VsEta_
std::vector< std::vector < MonitorElement * > >	h_scEta_
std::vector< std::vector < std::vector< MonitorElement * > > >	h_scPhi_
std::vector< std::vector < MonitorElement * > >	h_sigmaIetaIetaVsEta_
std::vector< std::vector < MonitorElement * > >	h_tkChi2_
std::vector< std::vector < MonitorElement * > >	h_trackPtSumHollow_
std::vector< std::vector < MonitorElement * > >	h_trackPtSumHollowVsEt_
std::vector< std::vector < MonitorElement * > >	h_trackPtSumHollowVsEta_
std::vector< std::vector < MonitorElement * > >	h_trackPtSumSolid_
std::vector< std::vector < MonitorElement * > >	h_trackPtSumSolidVsEt_
std::vector< std::vector < MonitorElement * > >	h_trackPtSumSolidVsEta_
std::vector< std::vector < MonitorElement * > >	h_vertexChi2Prob_
int	histo_index_conversions_
int	histo_index_efficiency_
int	histo_index_invMass_
int	histo_index_photons_
int	hOverEBin_
double	hOverEMax_
double	hOverEMin_
double	invMassEtCut_
bool	isHeavyIon_
int	isolationStrength_
bool	minimalSetOfHistos_
double	minPhoEtCut_
int	nEvt_
int	numberBin_
double	numberMax_
double	numberMin_
int	numberOfSteps_
edm::EDGetTokenT < reco::VertexCollection >	offline_pvToken_
std::vector< std::vector < MonitorElement * > >	p_dCotTracksVsEta_
std::vector< std::vector < MonitorElement * > >	p_e1x5VsEt_
std::vector< std::vector < MonitorElement * > >	p_e1x5VsEta_
std::vector< std::vector < MonitorElement * > >	p_e2x5VsEt_
std::vector< std::vector < MonitorElement * > >	p_e2x5VsEta_
std::vector< std::vector < std::vector< MonitorElement * > > >	p_ecalSumVsEt_
std::vector< std::vector < MonitorElement * > >	p_ecalSumVsEta_
std::vector< std::vector < std::vector< MonitorElement * > > >	p_hcalSumVsEt_
std::vector< std::vector < MonitorElement * > >	p_hcalSumVsEta_
std::vector< std::vector < MonitorElement * > >	p_hOverEVsEt_
std::vector< std::vector < MonitorElement * > >	p_hOverEVsEta_
std::vector< std::vector < MonitorElement * > >	p_maxEXtalOver3x3VsEt_
std::vector< std::vector < MonitorElement * > >	p_maxEXtalOver3x3VsEta_
std::vector< std::vector < MonitorElement * > >	p_nHitsVsEta_
std::vector< std::vector < MonitorElement * > >	p_nTrackIsolHollowVsEt_
std::vector< std::vector < MonitorElement * > >	p_nTrackIsolHollowVsEta_
std::vector< std::vector < MonitorElement * > >	p_nTrackIsolSolidVsEt_
std::vector< std::vector < MonitorElement * > >	p_nTrackIsolSolidVsEta_
std::vector< std::vector < std::vector< MonitorElement * > > >	p_phoSigmaEoverEvsNVtx_
std::vector< std::vector < MonitorElement * > >	p_r1x5VsEt_
std::vector< std::vector < MonitorElement * > >	p_r1x5VsEta_
std::vector< std::vector < MonitorElement * > >	p_r2x5VsEt_
std::vector< std::vector < MonitorElement * > >	p_r2x5VsEta_
std::vector< std::vector < MonitorElement * > >	p_r9VsEt_
std::vector< std::vector < MonitorElement * > >	p_r9VsEta_
std::vector< std::vector < MonitorElement * > >	p_sigmaIetaIetaVsEta_
std::vector< std::vector < MonitorElement * > >	p_tkChi2VsEta_
std::vector< std::vector < MonitorElement * > >	p_trackPtSumHollowVsEt_
std::vector< std::vector < MonitorElement * > >	p_trackPtSumHollowVsEta_
std::vector< std::vector < MonitorElement * > >	p_trackPtSumSolidVsEt_
std::vector< std::vector < MonitorElement * > >	p_trackPtSumSolidVsEta_
std::vector< std::string >	parts_
int	phiBin_
double	phiMax_
double	phiMin_
edm::EDGetTokenT< std::vector < reco::Photon > >	photon_token_
edm::EDGetTokenT < edm::ValueMap< bool > >	PhotonIDLoose_token_
edm::EDGetTokenT < edm::ValueMap< bool > >	PhotonIDTight_token_
double	photonMaxEta_
unsigned int	prescaleFactor_
int	r9Bin_
double	r9Max_
double	r9Min_
int	rBin_
int	reducedEtaBin_
int	reducedEtBin_
int	reducedR9Bin_
int	reducedSumBin_
double	rMax_
double	rMin_
int	sigmaIetaBin_
double	sigmaIetaMax_
double	sigmaIetaMin_
bool	standAlone_
int	sumBin_
double	sumMax_
double	sumMin_
MonitorElement *	totalNumberOfHistos_conversionsFolder
MonitorElement *	totalNumberOfHistos_efficiencyFolder
MonitorElement *	totalNumberOfHistos_invMassFolder
MonitorElement *	totalNumberOfHistos_photonsFolder
edm::EDGetTokenT < trigger::TriggerEvent >	triggerEvent_token_
std::vector< std::string >	types_
bool	useBinning_
bool	useTriggerFiltering_
int	xBin_
double	xMax_
double	xMin_
int	yBin_
double	yMax_
double	yMin_
int	zBin_
double	zMax_
double	zMin_

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T...>	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)
static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)
static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *, dqmDetails::NoCache *)
static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *, dqmDetails::NoCache *)
Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

EgammaCoreTools.

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

Definition at line 101 of file PhotonAnalyzer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 20 of file PhotonAnalyzer.cc.

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

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

virtual

Definition at line 140 of file PhotonAnalyzer.cc.

{
}

Member Function Documentation

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

virtual

End loop over Reco photons

Implements edm::stream::EDAnalyzerBase.

Definition at line 607 of file PhotonAnalyzer.cc.

References edm::SortedCollection< T, SORT >::begin(), ChiSquaredProbability(), conversions_cfi::conversions, GOODCOLL_filter_cfg::cut, deltaR(), reco::deltaR(), deltaRMax, edm::SortedCollection< T, SORT >::end(), HcalObjRepresent::Fill(), edm::Event::getByToken(), i, edm::EventBase::id(), edm::Ref< C, T, F >::isNonnull(), edm::HandleBase::isValid(), diffTwoXMLs::label, edm::Handle< T >::product(), hitfit::scalar(), edm::RefVector< C, T, F >::size(), python.multivaluedict::sort(), mathSSE::sqrt(), testEve_cfg::tracks, and funct::true.

{
  using namespace edm;

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

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

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

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

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


  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++) {
    reco::PhotonRef aPho(reco::PhotonRef(photonHandle, 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;

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

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

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

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

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

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

      if (passesCuts){
    //filling isolation variable histograms

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

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

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

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

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

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

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


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

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

    fill3DHistoVector(h_h1OverE_,aPho->hadronicDepth1OverEm(),cut,type,part);
    fill3DHistoVector(h_h2OverE_,aPho->hadronicDepth2OverEm(),cut,type,part);

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

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

    //energy variables

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

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

    //geometrical variables

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

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

    //shower shape variables

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

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

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

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

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

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

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

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

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

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

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

      reco::ConversionRef aConv=conversions[iConv];

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

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

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

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

      if(chi2Prob<0.0005) continue;

      fill2DHistoVector(h_vertexChi2Prob_,chi2Prob,cut,type);

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

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

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

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

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

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

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

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


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

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

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

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

      if (aConv->bcMatchingWithTracks().size() > 0 && 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++) {
    reco::PhotonRef aPho2(reco::PhotonRef(photonHandle, 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;

    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 ));}
      if(aPho->isEE() || aPho2->isEE()){h_invMassPhotonsEEndcap_ -> Fill(sqrt( gamgamMass2 ));}      
      
      if(conversions.size()!=0 && conversions[0]->nTracks() >= 2){
        if(conversions2.size()!=0 && conversions2[0]->nTracks() >= 2) h_invMassTwoWithTracks_ -> Fill(sqrt( gamgamMass2 ));
        else h_invMassOneWithTracks_ -> Fill(sqrt( gamgamMass2 ));
      }
      else if(conversions2.size()!=0 && conversions2[0]->nTracks() >= 2) h_invMassOneWithTracks_ -> Fill(sqrt( gamgamMass2 ));
      else h_invMassZeroWithTracks_ -> Fill(sqrt( gamgamMass2 ));
    }
      }
    }
  }

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

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

private

Definition at line 494 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), gather_cfg::cout, GOODCOLL_filter_cfg::cut, class-composition::kind, DQMStore::IBooker::pwd(), DQMStore::IBooker::setCurrentFolder(), indexGen::title, SiStripMonitorClusterAlca_cfi::xmax, SiStripMonitorClusterAlca_cfi::xmin, SiStripMonitorClusterAlca_cfi::ymax, and SiStripMonitorClusterAlca_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();
  }
}

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

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), gather_cfg::cout, GOODCOLL_filter_cfg::cut, class-composition::kind, DQMStore::IBooker::pwd(), DQMStore::IBooker::setCurrentFolder(), indexGen::title, SiStripMonitorClusterAlca_cfi::xmax, SiStripMonitorClusterAlca_cfi::xmin, SiStripMonitorClusterAlca_cfi::ymax, and SiStripMonitorClusterAlca_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();
  }
}

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

private

Definition at line 470 of file PhotonAnalyzer.cc.

References newFWLiteAna::bin, DQMStore::IBooker::book1D(), bookConverter::max, min(), DQMStore::IBooker::pwd(), and indexGen::title.

{
  int histo_index = 0;
  stringstream histo_number_stream;

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

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

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

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 144 of file PhotonAnalyzer.cc.

{
  bookHistogramsForHistogramCounts(iBooker);

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

  fillHistogramsForHistogramCounts(iBooker);
}

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

private

Definition at line 428 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::setCurrentFolder().

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

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

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

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

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

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

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

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

private

Definition at line 177 of file PhotonAnalyzer.cc.

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

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

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

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

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

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

  h_phoEta_Vertex_  = iBooker.book1D("phoEtaVertex",  "Converted Photons before valid vertex cut: #eta", etaBin_, etaMin_, etaMax_);
  
  // Some temporary vectors
  vector<MonitorElement*> temp1DVectorEta;
  vector<MonitorElement*> temp1DVectorPhi;
  vector<vector<MonitorElement*> > temp2DVectorPhi;

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

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

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

private

Definition at line 158 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::bookInt(), and DQMStore::IBooker::setCurrentFolder().

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

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

private

Definition at line 226 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::setCurrentFolder().

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

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

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

private

Definition at line 242 of file PhotonAnalyzer.cc.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

private

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

private

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

private

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

private

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

private

Definition at line 168 of file PhotonAnalyzer.cc.

References DQMStore::IBooker::setCurrentFolder().

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

float PhotonAnalyzer::phiNormalization ( float &  a )

private

Definition at line 1142 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;
}

bool PhotonAnalyzer::photonSelection ( const reco::PhotonRef &  p )

private

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

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

Definition at line 1181 of file PhotonAnalyzer.cc.

References edm::false, and query::result.

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

Member Data Documentation

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

private

Definition at line 151 of file PhotonAnalyzer.h.

int PhotonAnalyzer::chi2Bin_

private

Definition at line 239 of file PhotonAnalyzer.h.

double PhotonAnalyzer::chi2Max_

private

Definition at line 241 of file PhotonAnalyzer.h.

double PhotonAnalyzer::chi2Min_

private

Definition at line 240 of file PhotonAnalyzer.h.

std::stringstream PhotonAnalyzer::currentFolder_

private

Definition at line 176 of file PhotonAnalyzer.h.

double PhotonAnalyzer::cutStep_

private

Definition at line 160 of file PhotonAnalyzer.h.

int PhotonAnalyzer::dEtaTracksBin_

private

Definition at line 235 of file PhotonAnalyzer.h.

double PhotonAnalyzer::dEtaTracksMax_

private

Definition at line 237 of file PhotonAnalyzer.h.

double PhotonAnalyzer::dEtaTracksMin_

private

Definition at line 236 of file PhotonAnalyzer.h.

int PhotonAnalyzer::dPhiTracksBin_

private

Definition at line 231 of file PhotonAnalyzer.h.

double PhotonAnalyzer::dPhiTracksMax_

private

Definition at line 233 of file PhotonAnalyzer.h.

double PhotonAnalyzer::dPhiTracksMin_

private

Definition at line 232 of file PhotonAnalyzer.h.

int PhotonAnalyzer::eBin_

private

Definition at line 203 of file PhotonAnalyzer.h.

double PhotonAnalyzer::eMax_

private

Definition at line 205 of file PhotonAnalyzer.h.

double PhotonAnalyzer::eMin_

private

Definition at line 204 of file PhotonAnalyzer.h.

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

private

Definition at line 152 of file PhotonAnalyzer.h.

int PhotonAnalyzer::eOverPBin_

private

Definition at line 227 of file PhotonAnalyzer.h.

double PhotonAnalyzer::eOverPMax_

private

Definition at line 229 of file PhotonAnalyzer.h.

double PhotonAnalyzer::eOverPMin_

private

Definition at line 228 of file PhotonAnalyzer.h.

int PhotonAnalyzer::etaBin_

private

Definition at line 191 of file PhotonAnalyzer.h.

double PhotonAnalyzer::etaMax_

private

Definition at line 193 of file PhotonAnalyzer.h.

double PhotonAnalyzer::etaMin_

private

Definition at line 192 of file PhotonAnalyzer.h.

int PhotonAnalyzer::etBin_

private

Definition at line 195 of file PhotonAnalyzer.h.

double PhotonAnalyzer::etMax_

private

Definition at line 197 of file PhotonAnalyzer.h.

double PhotonAnalyzer::etMin_

private

Definition at line 196 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::excludeBkgHistos_

private

Definition at line 168 of file PhotonAnalyzer.h.

std::string PhotonAnalyzer::fName_

private

Definition at line 144 of file PhotonAnalyzer.h.

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

private

Definition at line 324 of file PhotonAnalyzer.h.

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

private

Definition at line 325 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_convEt_Loose_

private

Definition at line 283 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_convEt_Tight_

private

Definition at line 284 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_convEta_Loose_

private

Definition at line 281 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_convEta_Tight_

private

Definition at line 282 of file PhotonAnalyzer.h.

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

private

Definition at line 381 of file PhotonAnalyzer.h.

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

private

Definition at line 377 of file PhotonAnalyzer.h.

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

private

Definition at line 380 of file PhotonAnalyzer.h.

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

private

Definition at line 379 of file PhotonAnalyzer.h.

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

private

Definition at line 378 of file PhotonAnalyzer.h.

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

private

Definition at line 443 of file PhotonAnalyzer.h.

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

private

Definition at line 448 of file PhotonAnalyzer.h.

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

private

Definition at line 446 of file PhotonAnalyzer.h.

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

private

Definition at line 445 of file PhotonAnalyzer.h.

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

private

Definition at line 386 of file PhotonAnalyzer.h.

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

private

Definition at line 387 of file PhotonAnalyzer.h.

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

private

Definition at line 389 of file PhotonAnalyzer.h.

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

private

Definition at line 390 of file PhotonAnalyzer.h.

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

private

Definition at line 315 of file PhotonAnalyzer.h.

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

private

Definition at line 316 of file PhotonAnalyzer.h.

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

private

Definition at line 317 of file PhotonAnalyzer.h.

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

private

Definition at line 308 of file PhotonAnalyzer.h.

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

private

Definition at line 301 of file PhotonAnalyzer.h.

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

private

Definition at line 440 of file PhotonAnalyzer.h.

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

private

Definition at line 427 of file PhotonAnalyzer.h.

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

private

Definition at line 428 of file PhotonAnalyzer.h.

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

private

Definition at line 318 of file PhotonAnalyzer.h.

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

private

Definition at line 319 of file PhotonAnalyzer.h.

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

private

Definition at line 320 of file PhotonAnalyzer.h.

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

private

Definition at line 309 of file PhotonAnalyzer.h.

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

private

Definition at line 302 of file PhotonAnalyzer.h.

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

private

Definition at line 426 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassAllPhotons_

private

Definition at line 291 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassOneWithTracks_

private

Definition at line 289 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEBarrel_

private

Definition at line 292 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassPhotonsEEndcap_

private

Definition at line 293 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassTwoWithTracks_

private

Definition at line 288 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_invMassZeroWithTracks_

private

Definition at line 290 of file PhotonAnalyzer.h.

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

private

Definition at line 392 of file PhotonAnalyzer.h.

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

private

Definition at line 393 of file PhotonAnalyzer.h.

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

private

Definition at line 438 of file PhotonAnalyzer.h.

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

private

Definition at line 326 of file PhotonAnalyzer.h.

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

private

Definition at line 327 of file PhotonAnalyzer.h.

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

private

Definition at line 432 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_nRecoVtx_

private

Definition at line 269 of file PhotonAnalyzer.h.

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

private

Definition at line 313 of file PhotonAnalyzer.h.

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

private

Definition at line 306 of file PhotonAnalyzer.h.

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

private

Definition at line 299 of file PhotonAnalyzer.h.

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

private

Definition at line 311 of file PhotonAnalyzer.h.

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

private

Definition at line 304 of file PhotonAnalyzer.h.

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

private

Definition at line 297 of file PhotonAnalyzer.h.

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

private

Definition at line 434 of file PhotonAnalyzer.h.

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

private

Definition at line 435 of file PhotonAnalyzer.h.

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

private

Definition at line 375 of file PhotonAnalyzer.h.

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

private

Definition at line 369 of file PhotonAnalyzer.h.

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

private

Definition at line 424 of file PhotonAnalyzer.h.

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

private

Definition at line 423 of file PhotonAnalyzer.h.

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

private

Definition at line 436 of file PhotonAnalyzer.h.

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

private

Definition at line 416 of file PhotonAnalyzer.h.

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

private

Definition at line 419 of file PhotonAnalyzer.h.

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

private

Definition at line 372 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEt_Loose_

private

Definition at line 273 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEt_postHLT_

private

Definition at line 279 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEt_preHLT_

private

Definition at line 278 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEt_Tight_

private

Definition at line 274 of file PhotonAnalyzer.h.

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

private

Definition at line 366 of file PhotonAnalyzer.h.

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

private

Definition at line 371 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEta_Loose_

private

Definition at line 271 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEta_postHLT_

private

Definition at line 277 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEta_preHLT_

private

Definition at line 276 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEta_Tight_

private

Definition at line 272 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::h_phoEta_Vertex_

private

Definition at line 286 of file PhotonAnalyzer.h.

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

private

Definition at line 322 of file PhotonAnalyzer.h.

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

private

Definition at line 323 of file PhotonAnalyzer.h.

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

private

Definition at line 421 of file PhotonAnalyzer.h.

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

private

Definition at line 373 of file PhotonAnalyzer.h.

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

private

Definition at line 417 of file PhotonAnalyzer.h.

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

private

Definition at line 430 of file PhotonAnalyzer.h.

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

private

Definition at line 441 of file PhotonAnalyzer.h.

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

private

Definition at line 395 of file PhotonAnalyzer.h.

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

private

Definition at line 396 of file PhotonAnalyzer.h.

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

private

Definition at line 398 of file PhotonAnalyzer.h.

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

private

Definition at line 399 of file PhotonAnalyzer.h.

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

private

Definition at line 420 of file PhotonAnalyzer.h.

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

private

Definition at line 383 of file PhotonAnalyzer.h.

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

private

Definition at line 384 of file PhotonAnalyzer.h.

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

private

Definition at line 367 of file PhotonAnalyzer.h.

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

private

Definition at line 422 of file PhotonAnalyzer.h.

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

private

Definition at line 401 of file PhotonAnalyzer.h.

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

private

Definition at line 403 of file PhotonAnalyzer.h.

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

private

Definition at line 314 of file PhotonAnalyzer.h.

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

private

Definition at line 307 of file PhotonAnalyzer.h.

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

private

Definition at line 300 of file PhotonAnalyzer.h.

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

private

Definition at line 312 of file PhotonAnalyzer.h.

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

private

Definition at line 305 of file PhotonAnalyzer.h.

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

private

Definition at line 298 of file PhotonAnalyzer.h.

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

private

Definition at line 405 of file PhotonAnalyzer.h.

int PhotonAnalyzer::histo_index_conversions_

private

Definition at line 179 of file PhotonAnalyzer.h.

int PhotonAnalyzer::histo_index_efficiency_

private

Definition at line 180 of file PhotonAnalyzer.h.

int PhotonAnalyzer::histo_index_invMass_

private

Definition at line 181 of file PhotonAnalyzer.h.

int PhotonAnalyzer::histo_index_photons_

private

Definition at line 178 of file PhotonAnalyzer.h.

int PhotonAnalyzer::hOverEBin_

private

Definition at line 223 of file PhotonAnalyzer.h.

double PhotonAnalyzer::hOverEMax_

private

Definition at line 225 of file PhotonAnalyzer.h.

double PhotonAnalyzer::hOverEMin_

private

Definition at line 224 of file PhotonAnalyzer.h.

double PhotonAnalyzer::invMassEtCut_

private

Definition at line 158 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::isHeavyIon_

private

Definition at line 172 of file PhotonAnalyzer.h.

int PhotonAnalyzer::isolationStrength_

private

Definition at line 170 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::minimalSetOfHistos_

private

Definition at line 167 of file PhotonAnalyzer.h.

double PhotonAnalyzer::minPhoEtCut_

private

Definition at line 156 of file PhotonAnalyzer.h.

int PhotonAnalyzer::nEvt_

private

Definition at line 183 of file PhotonAnalyzer.h.

int PhotonAnalyzer::numberBin_

private

Definition at line 207 of file PhotonAnalyzer.h.

double PhotonAnalyzer::numberMax_

private

Definition at line 209 of file PhotonAnalyzer.h.

double PhotonAnalyzer::numberMin_

private

Definition at line 208 of file PhotonAnalyzer.h.

int PhotonAnalyzer::numberOfSteps_

private

Definition at line 161 of file PhotonAnalyzer.h.

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

private

Definition at line 154 of file PhotonAnalyzer.h.

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

private

Definition at line 361 of file PhotonAnalyzer.h.

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

private

Definition at line 344 of file PhotonAnalyzer.h.

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

private

Definition at line 345 of file PhotonAnalyzer.h.

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

private

Definition at line 347 of file PhotonAnalyzer.h.

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

private

Definition at line 348 of file PhotonAnalyzer.h.

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

private

Definition at line 413 of file PhotonAnalyzer.h.

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

private

Definition at line 333 of file PhotonAnalyzer.h.

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

private

Definition at line 414 of file PhotonAnalyzer.h.

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

private

Definition at line 334 of file PhotonAnalyzer.h.

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

private

Definition at line 364 of file PhotonAnalyzer.h.

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

private

Definition at line 363 of file PhotonAnalyzer.h.

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

private

Definition at line 350 of file PhotonAnalyzer.h.

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

private

Definition at line 351 of file PhotonAnalyzer.h.

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

private

Definition at line 407 of file PhotonAnalyzer.h.

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

private

Definition at line 338 of file PhotonAnalyzer.h.

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

private

Definition at line 331 of file PhotonAnalyzer.h.

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

private

Definition at line 336 of file PhotonAnalyzer.h.

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

private

Definition at line 329 of file PhotonAnalyzer.h.

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

private

Definition at line 418 of file PhotonAnalyzer.h.

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

private

Definition at line 353 of file PhotonAnalyzer.h.

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

private

Definition at line 354 of file PhotonAnalyzer.h.

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

private

Definition at line 356 of file PhotonAnalyzer.h.

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

private

Definition at line 357 of file PhotonAnalyzer.h.

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

private

Definition at line 341 of file PhotonAnalyzer.h.

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

private

Definition at line 342 of file PhotonAnalyzer.h.

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

private

Definition at line 359 of file PhotonAnalyzer.h.

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

private

Definition at line 409 of file PhotonAnalyzer.h.

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

private

Definition at line 339 of file PhotonAnalyzer.h.

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

private

Definition at line 332 of file PhotonAnalyzer.h.

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

private

Definition at line 337 of file PhotonAnalyzer.h.

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

private

Definition at line 330 of file PhotonAnalyzer.h.

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

private

Definition at line 186 of file PhotonAnalyzer.h.

int PhotonAnalyzer::phiBin_

private

Definition at line 199 of file PhotonAnalyzer.h.

double PhotonAnalyzer::phiMax_

private

Definition at line 201 of file PhotonAnalyzer.h.

double PhotonAnalyzer::phiMin_

private

Definition at line 200 of file PhotonAnalyzer.h.

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

private

Definition at line 148 of file PhotonAnalyzer.h.

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

private

Definition at line 149 of file PhotonAnalyzer.h.

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

private

Definition at line 150 of file PhotonAnalyzer.h.

double PhotonAnalyzer::photonMaxEta_

private

Definition at line 157 of file PhotonAnalyzer.h.

unsigned int PhotonAnalyzer::prescaleFactor_

private

Definition at line 146 of file PhotonAnalyzer.h.

int PhotonAnalyzer::r9Bin_

private

Definition at line 211 of file PhotonAnalyzer.h.

double PhotonAnalyzer::r9Max_

private

Definition at line 213 of file PhotonAnalyzer.h.

double PhotonAnalyzer::r9Min_

private

Definition at line 212 of file PhotonAnalyzer.h.

int PhotonAnalyzer::rBin_

private

Definition at line 247 of file PhotonAnalyzer.h.

int PhotonAnalyzer::reducedEtaBin_

private

Definition at line 260 of file PhotonAnalyzer.h.

int PhotonAnalyzer::reducedEtBin_

private

Definition at line 259 of file PhotonAnalyzer.h.

int PhotonAnalyzer::reducedR9Bin_

private

Definition at line 261 of file PhotonAnalyzer.h.

int PhotonAnalyzer::reducedSumBin_

private

Definition at line 262 of file PhotonAnalyzer.h.

double PhotonAnalyzer::rMax_

private

Definition at line 249 of file PhotonAnalyzer.h.

double PhotonAnalyzer::rMin_

private

Definition at line 248 of file PhotonAnalyzer.h.

int PhotonAnalyzer::sigmaIetaBin_

private

Definition at line 215 of file PhotonAnalyzer.h.

double PhotonAnalyzer::sigmaIetaMax_

private

Definition at line 217 of file PhotonAnalyzer.h.

double PhotonAnalyzer::sigmaIetaMin_

private

Definition at line 216 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::standAlone_

private

Definition at line 165 of file PhotonAnalyzer.h.

int PhotonAnalyzer::sumBin_

private

Definition at line 219 of file PhotonAnalyzer.h.

double PhotonAnalyzer::sumMax_

private

Definition at line 221 of file PhotonAnalyzer.h.

double PhotonAnalyzer::sumMin_

private

Definition at line 220 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_conversionsFolder

private

Definition at line 267 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_efficiencyFolder

private

Definition at line 264 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_invMassFolder

private

Definition at line 265 of file PhotonAnalyzer.h.

MonitorElement* PhotonAnalyzer::totalNumberOfHistos_photonsFolder

private

Definition at line 266 of file PhotonAnalyzer.h.

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

private

Definition at line 153 of file PhotonAnalyzer.h.

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

private

Definition at line 185 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::useBinning_

private

Definition at line 163 of file PhotonAnalyzer.h.

bool PhotonAnalyzer::useTriggerFiltering_

private

Definition at line 164 of file PhotonAnalyzer.h.

int PhotonAnalyzer::xBin_

private

Definition at line 251 of file PhotonAnalyzer.h.

double PhotonAnalyzer::xMax_

private

Definition at line 253 of file PhotonAnalyzer.h.

double PhotonAnalyzer::xMin_

private

Definition at line 252 of file PhotonAnalyzer.h.

int PhotonAnalyzer::yBin_

private

Definition at line 255 of file PhotonAnalyzer.h.

double PhotonAnalyzer::yMax_

private

Definition at line 257 of file PhotonAnalyzer.h.

double PhotonAnalyzer::yMin_

private

Definition at line 256 of file PhotonAnalyzer.h.

int PhotonAnalyzer::zBin_

private

Definition at line 243 of file PhotonAnalyzer.h.

double PhotonAnalyzer::zMax_

private

Definition at line 245 of file PhotonAnalyzer.h.

double PhotonAnalyzer::zMin_

private

Definition at line 244 of file PhotonAnalyzer.h.