#include <PhotonPostprocessing.h>

Inheritance diagram for PhotonPostprocessing:

Public Types
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

void	beginJob () override

void	endJob () override

void	endRun (const edm::Run &, const edm::EventSetup &) override

	PhotonPostprocessing (const edm::ParameterSet &pset)

	~PhotonPostprocessing () override

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () override

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

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

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	dividePlots (MonitorElement dividend, MonitorElement numerator, double denominator)

void	dividePlots (MonitorElement dividend, MonitorElement numerator, MonitorElement *denominator, std::string type)

virtual void	runPostprocessing ()

Private Attributes
std::string	analyzerName_

bool	batch_

MonitorElement *	bkgDeadChEt_

MonitorElement *	bkgDeadChEta_

MonitorElement *	bkgDeadChPhi_

MonitorElement *	bkgRecoEffEt_

MonitorElement *	bkgRecoEffEta_

MonitorElement *	bkgRecoEffPhi_

MonitorElement *	convEffEtaOneTrack_

MonitorElement *	convEffEtaTotal_

MonitorElement *	convEffEtaTwoTracks_

MonitorElement *	convEffEtaTwoTracksAndVtxProbGT0005_

MonitorElement *	convEffEtaTwoTracksAndVtxProbGT0_

MonitorElement *	convEffEtOneTrack_

MonitorElement *	convEffEtTotal_

MonitorElement *	convEffEtTwoTracks_

MonitorElement *	convEffPhiOneTrack_

MonitorElement *	convEffPhiTotal_

MonitorElement *	convEffPhiTwoTracks_

MonitorElement *	convEffROneTrack_

MonitorElement *	convEffRTotal_

MonitorElement *	convEffRTwoTracks_

MonitorElement *	convEffRTwoTracksAndVtxProbGT0005_

MonitorElement *	convEffRTwoTracksAndVtxProbGT0_

MonitorElement *	convEffZOneTrack_

MonitorElement *	convEffZTotal_

MonitorElement *	convEffZTwoTracks_

MonitorElement *	convFakeRateEtaTwoTracks_

MonitorElement *	convFakeRateEtTwoTracks_

MonitorElement *	convFakeRatePhiTwoTracks_

MonitorElement *	convFakeRateRTwoTracks_

MonitorElement *	convFakeRateZTwoTracks_

MonitorElement *	convVsEt_ [2]

std::stringstream	currentFolder_

DQMStore *	dbe_

int	etaBin

int	etaBin2

double	etaMax

double	etaMin

int	etBin

double	etMax

double	etMin

bool	fastSim_

MonitorElement *	h_simConvEtaMTotal_

MonitorElement *	h_simConvEtMTotal_

MonitorElement *	h_simConvPhiMTotal_

MonitorElement *	h_simConvRMTotal_

MonitorElement *	h_simConvZMTotal_

std::string	inputFileName_

bool	isRunCentrally_

std::string	outputFileName_

edm::ParameterSet	parameters_

int	phiBin

double	phiMax

double	phiMin

MonitorElement *	phoDeadChEt_

MonitorElement *	phoDeadChEta_

MonitorElement *	phoDeadChPhi_

MonitorElement *	phoRecoEffEt_

MonitorElement *	phoRecoEffEta_

MonitorElement *	phoRecoEffPhi_

int	rBin

double	rMax

double	rMin

bool	standAlone_

int	verbosity_

int	zBin

double	zMax

double	zMin

Additional Inherited Members
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

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

Detailed Description

$Id: PhotonPostprocessing author: Nancy Marinelli, U. of Notre Dame, US

$Id: PhotonPostprocessing authors: Nancy Marinelli, U. of Notre Dame, US

Definition at line 48 of file PhotonPostprocessing.h.

Member Typedef Documentation

◆ DQMStore

typedef dqm::legacy::DQMStore PhotonPostprocessing::DQMStore

Definition at line 50 of file PhotonPostprocessing.h.

◆ MonitorElement

typedef dqm::legacy::MonitorElement PhotonPostprocessing::MonitorElement

Definition at line 51 of file PhotonPostprocessing.h.

Constructor & Destructor Documentation

◆ PhotonPostprocessing()

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

explicit

Definition at line 21 of file PhotonPostprocessing.cc.

                                                                       {
   dbe_ = nullptr;
   dbe_ = edm::Service<DQMStore>().operator->();
   parameters_ = pset;
  
   analyzerName_ = pset.getParameter<std::string>("analyzerName");
   standAlone_ = pset.getParameter<bool>("standAlone");
   batch_ = pset.getParameter<bool>("batch");
   outputFileName_ = pset.getParameter<string>("OutputFileName");
   inputFileName_ = pset.getParameter<std::string>("InputFileName");
   isRunCentrally_ = pset.getParameter<bool>("isRunCentrally");
   fastSim_ = pset.getParameter<bool>("fastSim");
  
   etMin = parameters_.getParameter<double>("etMin");
   etMax = parameters_.getParameter<double>("etMax");
   etBin = parameters_.getParameter<int>("etBin");
  
   etaMin = parameters_.getParameter<double>("etaMin");
   etaMax = parameters_.getParameter<double>("etaMax");
   etaBin = parameters_.getParameter<int>("etaBin");
   etaBin2 = parameters_.getParameter<int>("etaBin2");
  
   phiMin = parameters_.getParameter<double>("phiMin");
   phiMax = parameters_.getParameter<double>("phiMax");
   phiBin = parameters_.getParameter<int>("phiBin");
  
   rMin = parameters_.getParameter<double>("rMin");
   rMax = parameters_.getParameter<double>("rMax");
   rBin = parameters_.getParameter<int>("rBin");
  
   zMin = parameters_.getParameter<double>("zMin");
   zMax = parameters_.getParameter<double>("zMax");
   zBin = parameters_.getParameter<int>("zBin");
 }

References dbe_, etaBin(), conversionPostprocessing_cfi::etaBin2, ALCARECOTkAlBeamHalo_cff::etaMax, ALCARECOTkAlBeamHalo_cff::etaMin, photonAnalyzer_cfi::etBin, cosmicPhotonAnalyzer_cfi::etMax, photonAnalyzer_cfi::etMin, BeamMonitor_cff::phiBin, AlignmentTrackSelector_cfi::phiMax, AlignmentTrackSelector_cfi::phiMin, muonDTDigis_cfi::pset, photonAnalyzer_cfi::rBin, photonAnalyzer_cfi::rMax, photonAnalyzer_cfi::rMin, AlCaHLTBitMon_QueryRunRegistry::string, photonAnalyzer_cfi::zBin, photonAnalyzer_cfi::zMax, and photonAnalyzer_cfi::zMin.

◆ ~PhotonPostprocessing()

PhotonPostprocessing::~PhotonPostprocessing ( )

override

Definition at line 56 of file PhotonPostprocessing.cc.

56 {}

Member Function Documentation

◆ analyze()

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

overridevirtual

Implements edm::EDAnalyzer.

Definition at line 60 of file PhotonPostprocessing.cc.

60 {}

◆ beginJob()

void PhotonPostprocessing::beginJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 58 of file PhotonPostprocessing.cc.

58 {}

◆ dividePlots() [1/2]

void PhotonPostprocessing::dividePlots	(	MonitorElement *	dividend,
		MonitorElement *	numerator,
		double	denominator
	)

private

Definition at line 422 of file PhotonPostprocessing.cc.

                                                                                                               {
   double value, err;
  
   if (nullptr == dividend or nullptr == numerator) {
     return;
   }
   for (int j = 1; j <= numerator->getNbinsX(); j++) {
     if (denominator != 0) {
       value = ((double)numerator->getBinContent(j)) / denominator;
       err = sqrt(value * (1 - value) / denominator);
       dividend->setBinContent(j, value);
       dividend->setBinError(j, err);
     } else {
       dividend->setBinContent(j, 0);
     }
   }
 }

References HLTTauDQMOffline_cfi::denominator, runTheMatrix::err, dqmiolumiharvest::j, HLTTauDQMOffline_cfi::numerator, or, dqm::impl::MonitorElement::setBinContent(), dqm::impl::MonitorElement::setBinError(), mathSSE::sqrt(), and relativeConstraints::value.

◆ dividePlots() [2/2]

void PhotonPostprocessing::dividePlots	(	MonitorElement *	dividend,
		MonitorElement *	numerator,
		MonitorElement *	denominator,
		std::string	type
	)

private

Definition at line 393 of file PhotonPostprocessing.cc.

                                                        {
   double value, err;
   if (nullptr == dividend or nullptr == denominator or nullptr == numerator) {
     return;
   }
   for (int j = 1; j <= numerator->getNbinsX(); j++) {
     dividend->setEfficiencyFlag();
  
     if (denominator->getBinContent(j) != 0) {
       if (type == "effic")
         value = ((double)numerator->getBinContent(j)) / ((double)denominator->getBinContent(j));
       else if (type == "fakerate")
         value = 1 - ((double)numerator->getBinContent(j)) / ((double)denominator->getBinContent(j));
       else
         return;
       err = sqrt(value * (1 - value) / ((double)denominator->getBinContent(j)));
       dividend->setBinContent(j, value);
       if (err != 0)
         dividend->setBinError(j, err);
     } else {
       dividend->setBinContent(j, 0);
       dividend->setBinError(j, 0);
     }
   }
 }

References HLTTauDQMOffline_cfi::denominator, runTheMatrix::err, dqmiolumiharvest::j, HLTTauDQMOffline_cfi::numerator, or, dqm::impl::MonitorElement::setBinContent(), dqm::impl::MonitorElement::setBinError(), dqm::impl::MonitorElement::setEfficiencyFlag(), mathSSE::sqrt(), and relativeConstraints::value.

◆ endJob()

void PhotonPostprocessing::endJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 62 of file PhotonPostprocessing.cc.

                                   {
   if (standAlone_)
     runPostprocessing();
 }

◆ endRun()

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

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 67 of file PhotonPostprocessing.cc.

                                                                                {
   if (!standAlone_)
     runPostprocessing();
 }

◆ runPostprocessing()

void PhotonPostprocessing::runPostprocessing ( )

privatevirtual

Definition at line 72 of file PhotonPostprocessing.cc.

                                              {
   std::string simInfoPathName = "EgammaV/" + analyzerName_ + "/SimulationInfo/";
   std::string convPathName = "EgammaV/" + analyzerName_ + "/ConversionInfo/";
   std::string effPathName = "EgammaV/" + analyzerName_ + "/Efficiencies/";
   std::string photonPathName = "EgammaV/" + analyzerName_ + "/Photons/";
  
   if (batch_)
     dbe_->open(inputFileName_);
  
   dbe_->setCurrentFolder(simInfoPathName);
   //  Numerators for Total efficiency
   string histname = "h_simConvEtaMTotal";
   h_simConvEtaMTotal_ = dbe_->book1D(histname, histname, etaBin2, etaMin, etaMax);
   histname = "h_simConvPhiMTotal";
   h_simConvPhiMTotal_ = dbe_->book1D(histname, histname, phiBin, phiMin, phiMax);
   histname = "h_simConvRMTotal";
   h_simConvRMTotal_ = dbe_->book1D(histname, histname, rBin, rMin, rMax);
   histname = "h_simConvZMTotal";
   h_simConvZMTotal_ = dbe_->book1D(histname, histname, zBin, zMin, zMax);
   histname = "h_simConvEtMTotal";
   h_simConvEtMTotal_ = dbe_->book1D(histname, histname, etBin, etMin, etMax);
  
   dbe_->setCurrentFolder(effPathName);
   //  Photon reconstruction efficiencies
   histname = "recoEffVsEta";
   phoRecoEffEta_ = dbe_->book1D(histname, "Photon reconstruction efficiency vs simulated #eta", etaBin, etaMin, etaMax);
   histname = "recoEffVsPhi";
   phoRecoEffPhi_ = dbe_->book1D(histname, "Photon reconstruction efficiency vs simulated #phi", phiBin, phiMin, phiMax);
   histname = "recoEffVsEt";
   phoRecoEffEt_ = dbe_->book1D(histname, "Photon reconstruction efficiency vs simulated Et", etBin, etMin, etMax);
   // Fraction of photons with at least one dead channel
   histname = "deadChVsEta";
   phoDeadChEta_ =
       dbe_->book1D(histname, "Fraction of photons with >=1 dead Xtal vs simulated #eta", etaBin, etaMin, etaMax);
   histname = "deadChVsPhi";
   phoDeadChPhi_ =
       dbe_->book1D(histname, "Fraction of photons with >=1 dead Xtal vs simulated #phi", phiBin, phiMin, phiMax);
   histname = "deadChVsEt";
   phoDeadChEt_ = dbe_->book1D(histname, "Fraction of photons with >=1 dead Xtal vs simulated Et", etBin, etMin, etMax);
  
   if (!isRunCentrally_) {
     histname = "convVsEt";
     convVsEt_[0] =
         dbe_->book1D(histname + "Barrel", "Fraction of good conversions in R9<0.93 vs Et ", etBin, etMin, etMax);
     convVsEt_[1] =
         dbe_->book1D(histname + "Endcap", "Fraction of good conversions in R9<0.93 vs Et ", etBin, etMin, etMax);
   }
  
   // Conversion reconstruction efficiency
   histname = "convEffVsEtaTwoTracks";
   convEffEtaTwoTracks_ = dbe_->book1D(histname, histname, etaBin2, etaMin, etaMax);
  
   histname = "convEffVsPhiTwoTracks";
   convEffPhiTwoTracks_ = dbe_->book1D(histname, histname, phiBin, phiMin, phiMax);
  
   histname = "convEffVsRTwoTracks";
   convEffRTwoTracks_ = dbe_->book1D(histname, histname, rBin, rMin, rMax);
  
   histname = "convEffVsZTwoTracks";
   convEffZTwoTracks_ = dbe_->book1D(histname, histname, zBin, zMin, zMax);
  
   histname = "convEffVsEtTwoTracks";
   convEffEtTwoTracks_ = dbe_->book1D(histname, histname, etBin, etMin, etMax);
   //
   histname = "convEffVsEtaTwoTracksAndVtxProbGT0";
   convEffEtaTwoTracksAndVtxProbGT0_ = dbe_->book1D(histname, histname, etaBin2, etaMin, etaMax);
   histname = "convEffVsEtaTwoTracksAndVtxProbGT0005";
   convEffEtaTwoTracksAndVtxProbGT0005_ = dbe_->book1D(histname, histname, etaBin2, etaMin, etaMax);
   histname = "convEffVsRTwoTracksAndVtxProbGT0";
   convEffRTwoTracksAndVtxProbGT0_ = dbe_->book1D(histname, histname, rBin, rMin, rMax);
   histname = "convEffVsRTwoTracksAndVtxProbGT0005";
   convEffRTwoTracksAndVtxProbGT0005_ = dbe_->book1D(histname, histname, rBin, rMin, rMax);
   //
   histname = "convEffVsEtaOneTrack";
   convEffEtaOneTrack_ = dbe_->book1D(histname, histname, etaBin2, etaMin, etaMax);
   histname = "convEffVsROneTrack";
   convEffROneTrack_ = dbe_->book1D(histname, histname, rBin, rMin, rMax);
   histname = "convEffVsZOneTrack";
   convEffZOneTrack_ = dbe_->book1D(histname, histname, rBin, rMin, rMax);
   histname = "convEffVsEtOneTrack";
   convEffEtOneTrack_ = dbe_->book1D(histname, histname, etBin, etMin, etMax);
   histname = "convEffVsPhiOneTrack";
   convEffPhiOneTrack_ = dbe_->book1D(histname, histname, phiBin, phiMin, phiMax);
   //
   histname = "convEffVsEtaTotal";
   convEffEtaTotal_ = dbe_->book1D(histname, histname, etaBin2, etaMin, etaMax);
   histname = "convEffVsRTotal";
   convEffRTotal_ = dbe_->book1D(histname, histname, rBin, rMin, rMax);
   histname = "convEffVsZTotal";
   convEffZTotal_ = dbe_->book1D(histname, histname, zBin, zMin, zMax);
   histname = "convEffVsEtTotal";
   convEffEtTotal_ = dbe_->book1D(histname, histname, etBin, etMin, etMax);
   histname = "convEffVsPhiTotal";
   convEffPhiTotal_ = dbe_->book1D(histname, histname, phiBin, phiMin, phiMax);
   // Fake rate
   histname = "convFakeRateVsEtaTwoTracks";
   convFakeRateEtaTwoTracks_ = dbe_->book1D(histname, histname, etaBin2, etaMin, etaMax);
   histname = "convFakeRateVsPhiTwoTracks";
   convFakeRatePhiTwoTracks_ = dbe_->book1D(histname, histname, phiBin, phiMin, phiMax);
   histname = "convFakeRateVsRTwoTracks";
   convFakeRateRTwoTracks_ = dbe_->book1D(histname, histname, rBin, rMin, rMax);
   histname = "convFakeRateVsZTwoTracks";
   convFakeRateZTwoTracks_ = dbe_->book1D(histname, histname, zBin, zMin, zMax);
   histname = "convFakeRateVsEtTwoTracks";
   convFakeRateEtTwoTracks_ = dbe_->book1D(histname, histname, etBin, etMin, etMax);
  
   histname = "bkgEffVsEta";
   bkgRecoEffEta_ = dbe_->book1D(histname, "Bkg reconstruction efficiency vs simulated #eta", etaBin, etaMin, etaMax);
   histname = "bkgEffVsPhi";
   bkgRecoEffPhi_ = dbe_->book1D(histname, "Bkg reconstruction efficiency vs simulated #phi", phiBin, phiMin, phiMax);
   histname = "bkgEffVsEt";
   bkgRecoEffEt_ = dbe_->book1D(histname, "Bkg reconstruction efficiency vs simulated Et", etBin, etMin, etMax);
   // Fraction of photons with at least one dead channel
   histname = "deadChVsEtaBkg";
   bkgDeadChEta_ =
       dbe_->book1D(histname, "Fraction of bkg  with >=1 dead Xtal vs simulated #eta", etaBin, etaMin, etaMax);
   histname = "deadChVsPhiBkg";
   bkgDeadChPhi_ =
       dbe_->book1D(histname, "Fraction of bkg with >=1 dead Xtal vs simulated #phi", phiBin, phiMin, phiMax);
   histname = "deadChVsEtBkg";
   bkgDeadChEt_ = dbe_->book1D(histname, "Fraction of bkg with >=1 dead Xtal vs simulated Et", etBin, etMin, etMax);
  
   //
   if ((dbe_->get(simInfoPathName + "h_SimConvOneMTracksEta")) != nullptr and
       (dbe_->get(convPathName + "h_RecoConvTwoMTracksEta") != nullptr)) {
     h_simConvEtaMTotal_->getTH1F()->Add(dbe_->get(simInfoPathName + "h_SimConvOneMTracksEta")->getTH1F(),
                                         dbe_->get(convPathName + "h_RecoConvTwoMTracksEta")->getTH1F());
   }
   if ((dbe_->get(simInfoPathName + "h_SimConvOneMTracksPhi") != nullptr) and
       (dbe_->get(convPathName + "h_RecoConvTwoMTracksPhi") != nullptr)) {
     h_simConvPhiMTotal_->getTH1F()->Add(dbe_->get(simInfoPathName + "h_SimConvOneMTracksPhi")->getTH1F(),
                                         dbe_->get(convPathName + "h_RecoConvTwoMTracksPhi")->getTH1F());
   }
   if ((dbe_->get(simInfoPathName + "h_SimConvOneMTracksR")->getTH1F() != nullptr) and
       (dbe_->get(convPathName + "h_RecoConvTwoMTracksR") != nullptr)) {
     h_simConvRMTotal_->getTH1F()->Add(dbe_->get(simInfoPathName + "h_SimConvOneMTracksR")->getTH1F(),
                                       dbe_->get(convPathName + "h_RecoConvTwoMTracksR")->getTH1F());
   }
   if ((dbe_->get(simInfoPathName + "h_SimConvOneMTracksZ") != nullptr) and
       (dbe_->get(convPathName + "h_RecoConvTwoMTracksZ") != nullptr)) {
     h_simConvZMTotal_->getTH1F()->Add(dbe_->get(simInfoPathName + "h_SimConvOneMTracksZ")->getTH1F(),
                                       dbe_->get(convPathName + "h_RecoConvTwoMTracksZ")->getTH1F());
   }
   if ((dbe_->get(simInfoPathName + "h_SimConvOneMTracksEt") != nullptr) and
       (dbe_->get(convPathName + "h_RecoConvTwoMTracksEt") != nullptr)) {
     h_simConvEtMTotal_->getTH1F()->Add(dbe_->get(simInfoPathName + "h_SimConvOneMTracksEt")->getTH1F(),
                                        dbe_->get(convPathName + "h_RecoConvTwoMTracksEt")->getTH1F());
   }
  
   // efficiencies
   if (!isRunCentrally_) {
     dividePlots(dbe_->get(effPathName + "convVsEtBarrel"),
                 dbe_->get(photonPathName + "EtR9Less093ConvBarrel"),
                 dbe_->get(photonPathName + "EtR9Less093Barrel"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convVsEtEndcap"),
                 dbe_->get(photonPathName + "EtR9Less093ConvEndcap"),
                 dbe_->get(photonPathName + "EtR9Less093Endcap"),
                 "effic");
   }
  
   dividePlots(dbe_->get(effPathName + "recoEffVsEta"),
               dbe_->get(simInfoPathName + "h_MatchedSimPhoEta"),
               dbe_->get(simInfoPathName + "h_SimPhoEta"),
               "effic");
   dividePlots(dbe_->get(effPathName + "recoEffVsPhi"),
               dbe_->get(simInfoPathName + "h_MatchedSimPhoPhi"),
               dbe_->get(simInfoPathName + "h_SimPhoPhi"),
               "effic");
   dividePlots(dbe_->get(effPathName + "recoEffVsEt"),
               dbe_->get(simInfoPathName + "h_MatchedSimPhoEt"),
               dbe_->get(simInfoPathName + "h_SimPhoEt"),
               "effic");
   // fraction of photons with at least one dead channel
   dividePlots(dbe_->get(effPathName + "deadChVsEta"),
               dbe_->get(simInfoPathName + "h_MatchedSimPhoBadChEta"),
               dbe_->get(simInfoPathName + "h_MatchedSimPhoEta"),
               "effic");
   dividePlots(dbe_->get(effPathName + "deadChVsPhi"),
               dbe_->get(simInfoPathName + "h_MatchedSimPhoBadChPhi"),
               dbe_->get(simInfoPathName + "h_MatchedSimPhoPhi"),
               "effic");
   dividePlots(dbe_->get(effPathName + "deadChVsEt"),
               dbe_->get(simInfoPathName + "h_MatchedSimPhoBadChEt"),
               dbe_->get(simInfoPathName + "h_MatchedSimPhoEt"),
               "effic");
   //
   if (!fastSim_) {
     dividePlots(dbe_->get(effPathName + "convEffVsEtaTwoTracks"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksEta"),
                 dbe_->get(simInfoPathName + "h_VisSimConvEta"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsPhiTwoTracks"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksPhi"),
                 dbe_->get(simInfoPathName + "h_VisSimConvPhi"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsRTwoTracks"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksR"),
                 dbe_->get(simInfoPathName + "h_VisSimConvR"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsZTwoTracks"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksZ"),
                 dbe_->get(simInfoPathName + "h_VisSimConvZ"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsEtTwoTracks"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksEt"),
                 dbe_->get(simInfoPathName + "h_VisSimConvEt"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsEtaTwoTracksAndVtxProbGT0"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksEtaAndVtxPGT0"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksEta"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsEtaTwoTracksAndVtxProbGT0005"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksEtaAndVtxPGT0005"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksEta"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsRTwoTracksAndVtxProbGT0"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksRAndVtxPGT0"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksR"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsRTwoTracksAndVtxProbGT0005"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksRAndVtxPGT0005"),
                 dbe_->get(simInfoPathName + "h_SimConvTwoMTracksR"),
                 "effic");
     //
     dividePlots(dbe_->get(effPathName + "convEffVsEtaOneTrack"),
                 dbe_->get(simInfoPathName + "h_SimConvOneMTracksEta"),
                 dbe_->get(simInfoPathName + "h_VisSimConvEta"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsPhiOneTrack"),
                 dbe_->get(simInfoPathName + "h_SimConvOneMTracksPhi"),
                 dbe_->get(simInfoPathName + "h_VisSimConvPhi"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsROneTrack"),
                 dbe_->get(simInfoPathName + "h_SimConvOneMTracksR"),
                 dbe_->get(simInfoPathName + "h_VisSimConvR"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsZOneTrack"),
                 dbe_->get(simInfoPathName + "h_SimConvOneMTracksZ"),
                 dbe_->get(simInfoPathName + "h_VisSimConvZ"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsEtOneTrack"),
                 dbe_->get(simInfoPathName + "h_SimConvOneMTracksEt"),
                 dbe_->get(simInfoPathName + "h_VisSimConvEt"),
                 "effic");
     //
     dividePlots(dbe_->get(effPathName + "convEffVsEtaTotal"),
                 dbe_->get(simInfoPathName + "h_simConvEtaMTotal"),
                 dbe_->get(simInfoPathName + "h_VisSimConvEta"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsPhiTotal"),
                 dbe_->get(simInfoPathName + "h_simConvPhiMTotal"),
                 dbe_->get(simInfoPathName + "h_VisSimConvPhi"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsRTotal"),
                 dbe_->get(simInfoPathName + "h_simConvRMTotal"),
                 dbe_->get(simInfoPathName + "h_VisSimConvR"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsZTotal"),
                 dbe_->get(simInfoPathName + "h_simConvZMTotal"),
                 dbe_->get(simInfoPathName + "h_VisSimConvZ"),
                 "effic");
     dividePlots(dbe_->get(effPathName + "convEffVsEtTotal"),
                 dbe_->get(simInfoPathName + "h_simConvEtMTotal"),
                 dbe_->get(simInfoPathName + "h_VisSimConvEt"),
                 "effic");
     // fake rate
     dividePlots(dbe_->get(effPathName + "convFakeRateVsEtaTwoTracks"),
                 dbe_->get(convPathName + "h_RecoConvTwoMTracksEta"),
                 dbe_->get(convPathName + "h_RecoConvTwoTracksEta"),
                 "fakerate");
     dividePlots(dbe_->get(effPathName + "convFakeRateVsPhiTwoTracks"),
                 dbe_->get(convPathName + "h_RecoConvTwoMTracksPhi"),
                 dbe_->get(convPathName + "h_RecoConvTwoTracksPhi"),
                 "fakerate");
     dividePlots(dbe_->get(effPathName + "convFakeRateVsRTwoTracks"),
                 dbe_->get(convPathName + "h_RecoConvTwoMTracksR"),
                 dbe_->get(convPathName + "h_RecoConvTwoTracksR"),
                 "fakerate");
     dividePlots(dbe_->get(effPathName + "convFakeRateVsZTwoTracks"),
                 dbe_->get(convPathName + "h_RecoConvTwoMTracksZ"),
                 dbe_->get(convPathName + "h_RecoConvTwoTracksZ"),
                 "fakerate");
     dividePlots(dbe_->get(effPathName + "convFakeRateVsEtTwoTracks"),
                 dbe_->get(convPathName + "h_RecoConvTwoMTracksEt"),
                 dbe_->get(convPathName + "h_RecoConvTwoTracksEt"),
                 "fakerate");
   }
   // Background efficiency
   dividePlots(dbe_->get(effPathName + "bkgEffVsEta"),
               dbe_->get(simInfoPathName + "h_MatchedSimJetEta"),
               dbe_->get(simInfoPathName + "h_SimJetEta"),
               "effic");
   dividePlots(dbe_->get(effPathName + "bkgEffVsPhi"),
               dbe_->get(simInfoPathName + "h_MatchedSimJetPhi"),
               dbe_->get(simInfoPathName + "h_SimJetPhi"),
               "effic");
   dividePlots(dbe_->get(effPathName + "bkgEffVsEt"),
               dbe_->get(simInfoPathName + "h_MatchedSimJetEt"),
               dbe_->get(simInfoPathName + "h_SimJetEt"),
               "effic");
   // fraction of photons with at least one dead channel
   dividePlots(dbe_->get(effPathName + "deadChVsEtaBkg"),
               dbe_->get(simInfoPathName + "h_MatchedSimJetBadChEta"),
               dbe_->get(simInfoPathName + "h_MatchedSimJetEta"),
               "effic");
   dividePlots(dbe_->get(effPathName + "deadChVsPhiBkg"),
               dbe_->get(simInfoPathName + "h_MatchedSimJetBadChPhi"),
               dbe_->get(simInfoPathName + "h_MatchedSimJetPhi"),
               "effic");
   dividePlots(dbe_->get(effPathName + "deadChVsEtBkg"),
               dbe_->get(simInfoPathName + "h_MatchedSimJetBadChEt"),
               dbe_->get(simInfoPathName + "h_MatchedSimJetEt"),
               "effic");
  
   if (standAlone_)
     dbe_->save(outputFileName_);
   else if (batch_)
     dbe_->save(inputFileName_);
 }

References dqm::implementation::IBooker::book1D(), dbe_, etaBin(), conversionPostprocessing_cfi::etaBin2, ALCARECOTkAlBeamHalo_cff::etaMax, ALCARECOTkAlBeamHalo_cff::etaMin, photonAnalyzer_cfi::etBin, cosmicPhotonAnalyzer_cfi::etMax, photonAnalyzer_cfi::etMin, dqm::implementation::IGetter::get(), dqm::legacy::MonitorElement::getTH1F(), dqm::implementation::DQMStore::open(), BeamMonitor_cff::phiBin, AlignmentTrackSelector_cfi::phiMax, AlignmentTrackSelector_cfi::phiMin, photonAnalyzer_cfi::rBin, photonAnalyzer_cfi::rMax, photonAnalyzer_cfi::rMin, dqm::implementation::DQMStore::save(), dqm::implementation::DQMStore::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, photonAnalyzer_cfi::zBin, photonAnalyzer_cfi::zMax, and photonAnalyzer_cfi::zMin.

Member Data Documentation

◆ analyzerName_

std::string PhotonPostprocessing::analyzerName_

private

Definition at line 78 of file PhotonPostprocessing.h.

◆ batch_

bool PhotonPostprocessing::batch_

private

Definition at line 75 of file PhotonPostprocessing.h.

◆ bkgDeadChEt_

MonitorElement* PhotonPostprocessing::bkgDeadChEt_

private

Definition at line 150 of file PhotonPostprocessing.h.

◆ bkgDeadChEta_

MonitorElement* PhotonPostprocessing::bkgDeadChEta_

private

Definition at line 148 of file PhotonPostprocessing.h.

◆ bkgDeadChPhi_

MonitorElement* PhotonPostprocessing::bkgDeadChPhi_

private

Definition at line 149 of file PhotonPostprocessing.h.

◆ bkgRecoEffEt_

MonitorElement* PhotonPostprocessing::bkgRecoEffEt_

private

Definition at line 146 of file PhotonPostprocessing.h.

◆ bkgRecoEffEta_

MonitorElement* PhotonPostprocessing::bkgRecoEffEta_

private

Definition at line 144 of file PhotonPostprocessing.h.

◆ bkgRecoEffPhi_

MonitorElement* PhotonPostprocessing::bkgRecoEffPhi_

private

Definition at line 145 of file PhotonPostprocessing.h.

◆ convEffEtaOneTrack_

MonitorElement* PhotonPostprocessing::convEffEtaOneTrack_

private

Definition at line 120 of file PhotonPostprocessing.h.

◆ convEffEtaTotal_

MonitorElement* PhotonPostprocessing::convEffEtaTotal_

private

Definition at line 132 of file PhotonPostprocessing.h.

◆ convEffEtaTwoTracks_

MonitorElement* PhotonPostprocessing::convEffEtaTwoTracks_

private

Definition at line 109 of file PhotonPostprocessing.h.

◆ convEffEtaTwoTracksAndVtxProbGT0005_

MonitorElement* PhotonPostprocessing::convEffEtaTwoTracksAndVtxProbGT0005_

private

Definition at line 116 of file PhotonPostprocessing.h.

◆ convEffEtaTwoTracksAndVtxProbGT0_

MonitorElement* PhotonPostprocessing::convEffEtaTwoTracksAndVtxProbGT0_

private

Definition at line 115 of file PhotonPostprocessing.h.

◆ convEffEtOneTrack_

MonitorElement* PhotonPostprocessing::convEffEtOneTrack_

private

Definition at line 124 of file PhotonPostprocessing.h.

◆ convEffEtTotal_

MonitorElement* PhotonPostprocessing::convEffEtTotal_

private

Definition at line 136 of file PhotonPostprocessing.h.

◆ convEffEtTwoTracks_

MonitorElement* PhotonPostprocessing::convEffEtTwoTracks_

private

Definition at line 113 of file PhotonPostprocessing.h.

◆ convEffPhiOneTrack_

MonitorElement* PhotonPostprocessing::convEffPhiOneTrack_

private

Definition at line 121 of file PhotonPostprocessing.h.

◆ convEffPhiTotal_

MonitorElement* PhotonPostprocessing::convEffPhiTotal_

private

Definition at line 133 of file PhotonPostprocessing.h.

◆ convEffPhiTwoTracks_

MonitorElement* PhotonPostprocessing::convEffPhiTwoTracks_

private

Definition at line 110 of file PhotonPostprocessing.h.

◆ convEffROneTrack_

MonitorElement* PhotonPostprocessing::convEffROneTrack_

private

Definition at line 122 of file PhotonPostprocessing.h.

◆ convEffRTotal_

MonitorElement* PhotonPostprocessing::convEffRTotal_

private

Definition at line 134 of file PhotonPostprocessing.h.

◆ convEffRTwoTracks_

MonitorElement* PhotonPostprocessing::convEffRTwoTracks_

private

Definition at line 111 of file PhotonPostprocessing.h.

◆ convEffRTwoTracksAndVtxProbGT0005_

MonitorElement* PhotonPostprocessing::convEffRTwoTracksAndVtxProbGT0005_

private

Definition at line 118 of file PhotonPostprocessing.h.

◆ convEffRTwoTracksAndVtxProbGT0_

MonitorElement* PhotonPostprocessing::convEffRTwoTracksAndVtxProbGT0_

private

Definition at line 117 of file PhotonPostprocessing.h.

◆ convEffZOneTrack_

MonitorElement* PhotonPostprocessing::convEffZOneTrack_

private

Definition at line 123 of file PhotonPostprocessing.h.

◆ convEffZTotal_

MonitorElement* PhotonPostprocessing::convEffZTotal_

private

Definition at line 135 of file PhotonPostprocessing.h.

◆ convEffZTwoTracks_

MonitorElement* PhotonPostprocessing::convEffZTwoTracks_

private

Definition at line 112 of file PhotonPostprocessing.h.

◆ convFakeRateEtaTwoTracks_

MonitorElement* PhotonPostprocessing::convFakeRateEtaTwoTracks_

private

Definition at line 138 of file PhotonPostprocessing.h.

◆ convFakeRateEtTwoTracks_

MonitorElement* PhotonPostprocessing::convFakeRateEtTwoTracks_

private

Definition at line 142 of file PhotonPostprocessing.h.

◆ convFakeRatePhiTwoTracks_

MonitorElement* PhotonPostprocessing::convFakeRatePhiTwoTracks_

private

Definition at line 139 of file PhotonPostprocessing.h.

◆ convFakeRateRTwoTracks_

MonitorElement* PhotonPostprocessing::convFakeRateRTwoTracks_

private

Definition at line 140 of file PhotonPostprocessing.h.

◆ convFakeRateZTwoTracks_

MonitorElement* PhotonPostprocessing::convFakeRateZTwoTracks_

private

Definition at line 141 of file PhotonPostprocessing.h.

◆ convVsEt_

MonitorElement* PhotonPostprocessing::convVsEt_[2]

private

Definition at line 152 of file PhotonPostprocessing.h.

◆ currentFolder_

std::stringstream PhotonPostprocessing::currentFolder_

private

Definition at line 82 of file PhotonPostprocessing.h.

◆ dbe_

DQMStore* PhotonPostprocessing::dbe_

private

Definition at line 69 of file PhotonPostprocessing.h.

◆ etaBin

int PhotonPostprocessing::etaBin

private

Definition at line 89 of file PhotonPostprocessing.h.

◆ etaBin2

int PhotonPostprocessing::etaBin2

private

Definition at line 90 of file PhotonPostprocessing.h.

◆ etaMax

double PhotonPostprocessing::etaMax

private

Definition at line 88 of file PhotonPostprocessing.h.

◆ etaMin

double PhotonPostprocessing::etaMin

private

Definition at line 87 of file PhotonPostprocessing.h.

◆ etBin

int PhotonPostprocessing::etBin

private

Definition at line 86 of file PhotonPostprocessing.h.

◆ etMax

double PhotonPostprocessing::etMax

private

Definition at line 85 of file PhotonPostprocessing.h.

◆ etMin

double PhotonPostprocessing::etMin

private

Definition at line 84 of file PhotonPostprocessing.h.

◆ fastSim_

bool PhotonPostprocessing::fastSim_

private

Definition at line 77 of file PhotonPostprocessing.h.

◆ h_simConvEtaMTotal_

MonitorElement* PhotonPostprocessing::h_simConvEtaMTotal_

private

Definition at line 126 of file PhotonPostprocessing.h.

◆ h_simConvEtMTotal_

MonitorElement* PhotonPostprocessing::h_simConvEtMTotal_

private

Definition at line 130 of file PhotonPostprocessing.h.

◆ h_simConvPhiMTotal_

MonitorElement* PhotonPostprocessing::h_simConvPhiMTotal_

private

Definition at line 127 of file PhotonPostprocessing.h.

◆ h_simConvRMTotal_

MonitorElement* PhotonPostprocessing::h_simConvRMTotal_

private

Definition at line 128 of file PhotonPostprocessing.h.

◆ h_simConvZMTotal_

MonitorElement* PhotonPostprocessing::h_simConvZMTotal_

private

Definition at line 129 of file PhotonPostprocessing.h.

◆ inputFileName_

std::string PhotonPostprocessing::inputFileName_

private

Definition at line 80 of file PhotonPostprocessing.h.

◆ isRunCentrally_

bool PhotonPostprocessing::isRunCentrally_

private

Definition at line 76 of file PhotonPostprocessing.h.

◆ outputFileName_

std::string PhotonPostprocessing::outputFileName_

private

Definition at line 79 of file PhotonPostprocessing.h.

◆ parameters_

edm::ParameterSet PhotonPostprocessing::parameters_

private

Definition at line 72 of file PhotonPostprocessing.h.

Referenced by Mixins._TypedParameterizable::clone(), Types.PSet::clone(), Types.EDAlias::clone(), and Mixins._TypedParameterizable::copy().

◆ phiBin

int PhotonPostprocessing::phiBin

private

Definition at line 93 of file PhotonPostprocessing.h.

◆ phiMax

double PhotonPostprocessing::phiMax

private

Definition at line 92 of file PhotonPostprocessing.h.

◆ phiMin

double PhotonPostprocessing::phiMin

private

Definition at line 91 of file PhotonPostprocessing.h.

◆ phoDeadChEt_

MonitorElement* PhotonPostprocessing::phoDeadChEt_

private

Definition at line 107 of file PhotonPostprocessing.h.

◆ phoDeadChEta_

MonitorElement* PhotonPostprocessing::phoDeadChEta_

private

Definition at line 105 of file PhotonPostprocessing.h.

◆ phoDeadChPhi_

MonitorElement* PhotonPostprocessing::phoDeadChPhi_

private

Definition at line 106 of file PhotonPostprocessing.h.

◆ phoRecoEffEt_

MonitorElement* PhotonPostprocessing::phoRecoEffEt_

private

Definition at line 103 of file PhotonPostprocessing.h.

◆ phoRecoEffEta_

MonitorElement* PhotonPostprocessing::phoRecoEffEta_

private

Definition at line 101 of file PhotonPostprocessing.h.

◆ phoRecoEffPhi_

MonitorElement* PhotonPostprocessing::phoRecoEffPhi_

private

Definition at line 102 of file PhotonPostprocessing.h.

◆ rBin

int PhotonPostprocessing::rBin

private

Definition at line 96 of file PhotonPostprocessing.h.

◆ rMax

double PhotonPostprocessing::rMax

private

Definition at line 95 of file PhotonPostprocessing.h.

◆ rMin

double PhotonPostprocessing::rMin

private

Definition at line 94 of file PhotonPostprocessing.h.

◆ standAlone_

bool PhotonPostprocessing::standAlone_

private

Definition at line 74 of file PhotonPostprocessing.h.

◆ verbosity_

int PhotonPostprocessing::verbosity_

private

Definition at line 70 of file PhotonPostprocessing.h.

◆ zBin

int PhotonPostprocessing::zBin

private

Definition at line 99 of file PhotonPostprocessing.h.

◆ zMax

double PhotonPostprocessing::zMax

private

Definition at line 98 of file PhotonPostprocessing.h.

◆ zMin

double PhotonPostprocessing::zMin

private

Definition at line 97 of file PhotonPostprocessing.h.

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ DQMStore

◆ MonitorElement

Constructor & Destructor Documentation

◆ PhotonPostprocessing()

◆ ~PhotonPostprocessing()

Member Function Documentation

◆ analyze()

◆ beginJob()

◆ dividePlots() [1/2]

◆ dividePlots() [2/2]

◆ endJob()

◆ endRun()

◆ runPostprocessing()

Member Data Documentation

◆ analyzerName_

◆ batch_

◆ bkgDeadChEt_

◆ bkgDeadChEta_

◆ bkgDeadChPhi_

◆ bkgRecoEffEt_

◆ bkgRecoEffEta_

◆ bkgRecoEffPhi_

◆ convEffEtaOneTrack_

◆ convEffEtaTotal_

◆ convEffEtaTwoTracks_

◆ convEffEtaTwoTracksAndVtxProbGT0005_

◆ convEffEtaTwoTracksAndVtxProbGT0_

◆ convEffEtOneTrack_

◆ convEffEtTotal_

◆ convEffEtTwoTracks_

◆ convEffPhiOneTrack_

◆ convEffPhiTotal_

◆ convEffPhiTwoTracks_

◆ convEffROneTrack_

◆ convEffRTotal_

◆ convEffRTwoTracks_

◆ convEffRTwoTracksAndVtxProbGT0005_

◆ convEffRTwoTracksAndVtxProbGT0_

◆ convEffZOneTrack_

◆ convEffZTotal_

◆ convEffZTwoTracks_

◆ convFakeRateEtaTwoTracks_

◆ convFakeRateEtTwoTracks_

◆ convFakeRatePhiTwoTracks_

◆ convFakeRateRTwoTracks_

◆ convFakeRateZTwoTracks_

◆ convVsEt_

◆ currentFolder_

◆ dbe_

◆ etaBin

◆ etaBin2

◆ etaMax

◆ etaMin

◆ etBin

◆ etMax

◆ etMin

◆ fastSim_

◆ h_simConvEtaMTotal_

◆ h_simConvEtMTotal_

◆ h_simConvPhiMTotal_

◆ h_simConvRMTotal_

◆ h_simConvZMTotal_

◆ inputFileName_

◆ isRunCentrally_

◆ outputFileName_

◆ parameters_

◆ phiBin

◆ phiMax

◆ phiMin

◆ phoDeadChEt_

◆ phoDeadChEta_

◆ phoDeadChPhi_

◆ phoRecoEffEt_