#include <ConversionPostprocessing.h>

Inheritance diagram for ConversionPostprocessing:

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

void	beginJob () override

	ConversionPostprocessing (const edm::ParameterSet &pset)

void	endJob () override

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

	~ConversionPostprocessing () 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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

virtual	~EDConsumerBase () noexcept(false)

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

void	dividePlots (MonitorElement dividend, MonitorElement numerator, double denominator)

virtual void	runPostprocessing ()

Private Attributes
bool	batch_

MonitorElement *	convEffEtaTwoTracks_

MonitorElement *	convEffEtaTwoTracksAndVtxProbGT0005_

MonitorElement *	convEffEtaTwoTracksAndVtxProbGT0_

MonitorElement *	convEffEtTwoTracks_

MonitorElement *	convEffPhiTwoTracks_

MonitorElement *	convEffRTwoTracks_

MonitorElement *	convEffRTwoTracksAndVtxProbGT0005_

MonitorElement *	convEffRTwoTracksAndVtxProbGT0_

MonitorElement *	convEffZTwoTracks_

MonitorElement *	convFakeRateEtaTwoTracks_

MonitorElement *	convFakeRateEtTwoTracks_

MonitorElement *	convFakeRatePhiTwoTracks_

MonitorElement *	convFakeRateRTwoTracks_

MonitorElement *	convFakeRateZTwoTracks_

std::stringstream	currentFolder_

DQMStore *	dbe_

int	etaBin

int	etaBin2

double	etaMax

double	etaMin

int	etBin

double	etMax

double	etMin

std::string	inputFileName_

std::string	outputFileName_

edm::ParameterSet	parameters_

int	phiBin

double	phiMax

double	phiMin

int	rBin

double	rMax

double	rMin

bool	standAlone_

int	verbosity_

int	zBin

double	zMax

double	zMin

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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
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

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

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

Definition at line 52 of file ConversionPostprocessing.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 23 of file ConversionPostprocessing.cc.

 {
 
   dbe_ = nullptr;
   dbe_ = edm::Service<DQMStore>().operator->();
   dbe_->setVerbose(0);
   parameters_ = pset;
 
 
   standAlone_ = pset.getParameter<bool>("standAlone");
   batch_ = pset.getParameter<bool>("batch");
   outputFileName_ = pset.getParameter<string>("OutputFileName");
   inputFileName_  = pset.getParameter<std::string>("InputFileName");
 
 
   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");
 
 
 
 }

ConversionPostprocessing::~ConversionPostprocessing ( )

override

Definition at line 65 of file ConversionPostprocessing.cc.

66 {}

Member Function Documentation

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

override

Definition at line 73 of file ConversionPostprocessing.cc.

74 {}

void ConversionPostprocessing::beginJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 68 of file ConversionPostprocessing.cc.

 {
 
 }

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

private

Definition at line 170 of file ConversionPostprocessing.cc.

References MonitorElement::getBinContent(), MonitorElement::getNbinsX(), MonitorElement::setBinContent(), MonitorElement::setBinError(), mathSSE::sqrt(), and relativeConstraints::value.

                                                                                                                                             {
   double value,err;
   
   //quick fix to avoid seg. faults due to null pointers.
   if (dividend==nullptr || numerator==nullptr || denominator==nullptr)return;
 
   for (int j=1; j<=numerator->getNbinsX(); j++){
 
     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);
     }
 
   }
 
 
 }

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

private

Definition at line 199 of file ConversionPostprocessing.cc.

References MonitorElement::getBinContent(), MonitorElement::getNbinsX(), MonitorElement::setBinContent(), MonitorElement::setBinError(), mathSSE::sqrt(), and relativeConstraints::value.

                                                                                                                   {
   double value,err;
 
   //quick fix to avoid seg. faults due to null pointers.
   if (dividend==nullptr || numerator==nullptr )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);
     }
   }
 
 }

void ConversionPostprocessing::endJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 77 of file ConversionPostprocessing.cc.

                                       {
 
 if(standAlone_) runPostprocessing();
 
 }

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

override

Definition at line 83 of file ConversionPostprocessing.cc.

                                                                                    {
 
   if(!standAlone_) runPostprocessing();
 
 }

void ConversionPostprocessing::runPostprocessing ( )

privatevirtual

Definition at line 91 of file ConversionPostprocessing.cc.

 {
 
 
 
   std::string simInfoPathName = "EgammaV/ConversionValidator/SimulationInfo/";
   std::string convPathName    = "EgammaV/ConversionValidator/ConversionInfo/";
   std::string effPathName     = "EgammaV/ConversionValidator/EfficienciesAndFakeRate/";
 
 
   if(batch_)  dbe_->open(inputFileName_);
 
   dbe_->setCurrentFolder(effPathName);
   // Conversion reconstruction efficiency
   std::string 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);
   //
   // 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);
 
   // efficiencies
   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");
 
 
   // fake rate
   dividePlots(dbe_->get(effPathName+"convFakeRateVsEtaTwoTracks"),dbe_->get(convPathName+"convEtaAss2"),dbe_->get(convPathName+"convEta2"),"fakerate");
   dividePlots(dbe_->get(effPathName+"convFakeRateVsPhiTwoTracks"),dbe_->get(convPathName+"convPhiAss"),dbe_->get(convPathName+"convPhi"),"fakerate");
   dividePlots(dbe_->get(effPathName+"convFakeRateVsRTwoTracks"),dbe_->get(convPathName+"convRAss"),dbe_->get(convPathName+"convR"),"fakerate");
   dividePlots(dbe_->get(effPathName+"convFakeRateVsZTwoTracks"),dbe_->get(convPathName+"convZAss"),dbe_->get(convPathName+"convZ"),"fakerate");
   dividePlots(dbe_->get(effPathName+"convFakeRateVsEtTwoTracks"),dbe_->get(convPathName+"convPtAss"),dbe_->get(convPathName+"convPt"),"fakerate");
 
 
 
   if(standAlone_) dbe_->save(outputFileName_);
   else if(batch_) dbe_->save(inputFileName_);
 }