#include <TauValidationMiniAOD.h>

Inheritance diagram for TauValidationMiniAOD:

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

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

	TauValidationMiniAOD (const edm::ParameterSet &)

	~TauValidationMiniAOD () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

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

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Attributes
std::map< std::string, MonitorElement * >	byDeepTau2017v2p1VSerawMap

std::map< std::string, MonitorElement * >	byDeepTau2017v2p1VSjetrawMap

std::map< std::string, MonitorElement * >	byDeepTau2017v2p1VSmurawMap

std::map< std::string, MonitorElement * >	decayModeFindingMap

std::map< std::string, MonitorElement * >	decayModeMap

std::vector< edm::ParameterSet >	discriminators_

std::map< std::string, MonitorElement * >	etaMap

std::string	extensionName_

edm::ParameterSet	histoSettings_

std::map< std::string, MonitorElement * >	massMap

std::map< std::string, MonitorElement * >	phiMap

std::map< std::string, MonitorElement * >	ptMap

edm::EDGetTokenT< edm::View< reco::Candidate > >	refCollectionInputTagToken_

std::map< std::string, MonitorElement * >	summaryMap

edm::EDGetTokenT< std::vector< pat::Tau > >	tauCollection_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
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

Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Description: <one line="" class="" summary>="">

Class used to do the Validation of the Tau in miniAOD

Implementation: <Notes on="" implementation>="">

Definition at line 53 of file TauValidationMiniAOD.h.

Constructor & Destructor Documentation

◆ TauValidationMiniAOD()

TauValidationMiniAOD::TauValidationMiniAOD ( const edm::ParameterSet & iConfig )

explicit

Definition at line 26 of file TauValidationMiniAOD.cc.

                                                                          {
   tauCollection_ = consumes<pat::TauCollection>(iConfig.getParameter<InputTag>("tauCollection"));
   refCollectionInputTagToken_ = consumes<edm::View<reco::Candidate> >(iConfig.getParameter<InputTag>("RefCollection"));
   extensionName_ = iConfig.getParameter<string>("ExtensionName");
   discriminators_ = iConfig.getParameter<std::vector<edm::ParameterSet> >("discriminators");
 }

References edm::ParameterSet::getParameter().

◆ ~TauValidationMiniAOD()

TauValidationMiniAOD::~TauValidationMiniAOD ( )

override

Definition at line 33 of file TauValidationMiniAOD.cc.

33 {}

Member Function Documentation

◆ analyze()

void TauValidationMiniAOD::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 129 of file TauValidationMiniAOD.cc.

                                                                                       {
   edm::Handle<pat::TauCollection> taus;
   bool isTau = iEvent.getByToken(tauCollection_, taus);
   if (!isTau) {
     edm::LogWarning("TauValidationMiniAOD") << " Tau collection not found while running TauValidationMiniAOD.cc ";
     return;
   }
   typedef edm::View<reco::Candidate> refCandidateCollection;
   Handle<refCandidateCollection> ReferenceCollection;
   bool isRef = iEvent.getByToken(refCollectionInputTagToken_, ReferenceCollection);
   if (!isRef) {
     edm::LogWarning("TauValidationMiniAOD") << " Reference collection not found while running TauValidationMiniAOD.cc ";
     return;
   }
   for (refCandidateCollection::const_iterator RefJet = ReferenceCollection->begin();
        RefJet != ReferenceCollection->end();
        RefJet++) {
     float dRmin = 0.15;
     unsigned matchedTauIndex = -99;
     for (unsigned iTau = 0; iTau < taus->size(); iTau++) {
       pat::TauRef tau(taus, iTau);
       //for (pat::TauCollection::const_iterator tau = taus->begin(); tau != taus->end(); tau++) {
       //pat::TauRef matchedTau(*tau);
       float dR = deltaR(tau->eta(), tau->phi(), RefJet->eta(), RefJet->phi());
       if (dR < dRmin) {
         dRmin = dR;
         matchedTauIndex = iTau;
       }
     }
     if (dRmin < 0.15) {
       pat::TauRef matchedTau(taus, matchedTauIndex);
       ptMap.find("")->second->Fill(matchedTau->pt());
       etaMap.find("")->second->Fill(matchedTau->eta());
       phiMap.find("")->second->Fill(matchedTau->phi());
       massMap.find("")->second->Fill(matchedTau->mass());
       decayModeMap.find("")->second->Fill(matchedTau->decayMode());
       if (matchedTau->isTauIDAvailable("decayModeFinding"))
         decayModeFindingMap.find("")->second->Fill(matchedTau->tauID("decayModeFinding"));
       if (matchedTau->isTauIDAvailable("byDeepTau2017v2p1VSeraw"))
         byDeepTau2017v2p1VSerawMap.find("")->second->Fill(matchedTau->tauID("byDeepTau2017v2p1VSeraw"));
       if (matchedTau->isTauIDAvailable("byDeepTau2017v2p1VSjetraw"))
         byDeepTau2017v2p1VSjetrawMap.find("")->second->Fill(matchedTau->tauID("byDeepTau2017v2p1VSjetraw"));
       if (matchedTau->isTauIDAvailable("byDeepTau2017v2p1VSmuraw"))
         byDeepTau2017v2p1VSmurawMap.find("")->second->Fill(matchedTau->tauID("byDeepTau2017v2p1VSmuraw"));
       int j = 0;
       for (const auto& it : discriminators_) {
         string currentDiscriminator = it.getParameter<string>("discriminator");
         double selectionCut = it.getParameter<double>("selectionCut");
         summaryMap.find("Den")->second->Fill(j);
         if (matchedTau->tauID(currentDiscriminator) >= selectionCut)
           summaryMap.find("Num")->second->Fill(j);
         j = j + 1;
       }
     }
   }
 }

References PbPb_ZMuSkimMuonDPG_cff::deltaR, HGC3DClusterGenMatchSelector_cfi::dR, jetAnalyzer_cfi::etaMap, iEvent, reco::isTau(), dqmiolumiharvest::j, PDWG_TauSkim_cff::selectionCut, metsig::tau, and Tau3MuMonitor_cff::taus.

◆ bookHistograms()

void TauValidationMiniAOD::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	iRun,
		edm::EventSetup const &
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 35 of file TauValidationMiniAOD.cc.

                                                                   {
   MonitorElement *ptTemp, *etaTemp, *phiTemp, *massTemp, *decayModeFindingTemp, *decayModeTemp,
       *byDeepTau2017v2p1VSerawTemp, *byDeepTau2017v2p1VSjetrawTemp, *byDeepTau2017v2p1VSmurawTemp, *summaryTemp;
   ibooker.setCurrentFolder("RecoTauV/miniAODValidation" + extensionName_);
  
   //summary plots
   histoInfo summaryHinfo = (histoSettings_.exists("summary"))
                                ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("summary"))
                                : histoInfo(21, -0.5, 20.5);
   summaryTemp =
       ibooker.book1D("summaryPlotNum", "summaryPlotNum", summaryHinfo.nbins, summaryHinfo.min, summaryHinfo.max);
   summaryMap.insert(std::make_pair("Num", summaryTemp));
   summaryTemp =
       ibooker.book1D("summaryPlotDen", "summaryPlotDen", summaryHinfo.nbins, summaryHinfo.min, summaryHinfo.max);
   summaryMap.insert(std::make_pair("Den", summaryTemp));
   summaryTemp = ibooker.book1D("summaryPlot", "summaryPlot", summaryHinfo.nbins, summaryHinfo.min, summaryHinfo.max);
   summaryMap.insert(std::make_pair("", summaryTemp));
  
   int j = 0;
   for (const auto& it : discriminators_) {
     string DiscriminatorLabel = it.getParameter<string>("discriminator");
     summaryMap.find("Den")->second->setBinLabel(j + 1, DiscriminatorLabel);
     summaryMap.find("Num")->second->setBinLabel(j + 1, DiscriminatorLabel);
     summaryMap.find("")->second->setBinLabel(j + 1, DiscriminatorLabel);
     j = j + 1;
   }
  
   //other plots
   histoInfo ptHinfo = (histoSettings_.exists("pt")) ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("pt"))
                                                     : histoInfo(200, 0., 1000.);
   histoInfo etaHinfo = (histoSettings_.exists("eta")) ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("eta"))
                                                       : histoInfo(200, -3, 3.);
   histoInfo phiHinfo = (histoSettings_.exists("phi")) ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("phi"))
                                                       : histoInfo(200, -3, 3.);
   histoInfo massHinfo = (histoSettings_.exists("mass"))
                             ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("mass"))
                             : histoInfo(200, 0, 10.);
   histoInfo decayModeFindingHinfo = (histoSettings_.exists("decayModeFinding"))
                                         ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("decayModeFinding"))
                                         : histoInfo(2, -0.5, 1.5);
   histoInfo decayModeHinfo = (histoSettings_.exists("decayMode"))
                                  ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("decayMode"))
                                  : histoInfo(11, -0.5, 10.5);
   histoInfo byDeepTau2017v2p1VSerawHinfo =
       (histoSettings_.exists("byDeepTau2017v2p1VSeraw"))
           ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("byDeepTau2017v2p1VSeraw"))
           : histoInfo(200, 0., 1.);
   histoInfo byDeepTau2017v2p1VSjetrawHinfo =
       (histoSettings_.exists("byDeepTau2017v2p1VSjetraw"))
           ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("byDeepTau2017v2p1VSjetraw"))
           : histoInfo(200, 0., 1.);
   histoInfo byDeepTau2017v2p1VSmurawHinfo =
       (histoSettings_.exists("byDeepTau2017v2p1VSmuraw"))
           ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("byDeepTau2017v2p1VSmuraw"))
           : histoInfo(200, 0., 1.);
   ptTemp = ibooker.book1D("tau_pt", "tau_pt", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
   etaTemp = ibooker.book1D("tau_eta", "tau_eta", etaHinfo.nbins, etaHinfo.min, etaHinfo.max);
   phiTemp = ibooker.book1D("tau_phi", "tau_phi", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
   massTemp = ibooker.book1D("tau_mass", "tau_mass", massHinfo.nbins, massHinfo.min, massHinfo.max);
   decayModeFindingTemp = ibooker.book1D("tau_decayModeFinding",
                                         "tau_decayModeFinding",
                                         decayModeFindingHinfo.nbins,
                                         decayModeFindingHinfo.min,
                                         decayModeFindingHinfo.max);
   decayModeTemp =
       ibooker.book1D("tau_decayMode", "tau_decayMode", decayModeHinfo.nbins, decayModeHinfo.min, decayModeHinfo.max);
   byDeepTau2017v2p1VSerawTemp = ibooker.book1D("tau_byDeepTau2017v2p1VSeraw",
                                                "tau_byDeepTau2017v2p1VSeraw",
                                                byDeepTau2017v2p1VSerawHinfo.nbins,
                                                byDeepTau2017v2p1VSerawHinfo.min,
                                                byDeepTau2017v2p1VSerawHinfo.max);
   byDeepTau2017v2p1VSjetrawTemp = ibooker.book1D("tau_byDeepTau2017v2p1VSjetraw",
                                                  "tau_byDeepTau2017v2p1VSjetraw",
                                                  byDeepTau2017v2p1VSjetrawHinfo.nbins,
                                                  byDeepTau2017v2p1VSjetrawHinfo.min,
                                                  byDeepTau2017v2p1VSjetrawHinfo.max);
   byDeepTau2017v2p1VSmurawTemp = ibooker.book1D("tau_byDeepTau2017v2p1VSmuraw",
                                                 "tau_byDeepTau2017v2p1VSmuraw",
                                                 byDeepTau2017v2p1VSmurawHinfo.nbins,
                                                 byDeepTau2017v2p1VSmurawHinfo.min,
                                                 byDeepTau2017v2p1VSmurawHinfo.max);
   ptMap.insert(std::make_pair("", ptTemp));
   etaMap.insert(std::make_pair("", etaTemp));
   phiMap.insert(std::make_pair("", phiTemp));
   massMap.insert(std::make_pair("", massTemp));
   decayModeFindingMap.insert(std::make_pair("", decayModeFindingTemp));
   decayModeMap.insert(std::make_pair("", decayModeTemp));
   byDeepTau2017v2p1VSerawMap.insert(std::make_pair("", byDeepTau2017v2p1VSerawTemp));
   byDeepTau2017v2p1VSjetrawMap.insert(std::make_pair("", byDeepTau2017v2p1VSjetrawTemp));
   byDeepTau2017v2p1VSmurawMap.insert(std::make_pair("", byDeepTau2017v2p1VSmurawTemp));
 }

References dqm::implementation::IBooker::book1D(), jetAnalyzer_cfi::etaMap, dqmiolumiharvest::j, histoInfo::max, histoInfo::min, histoInfo::nbins, and dqm::implementation::NavigatorBase::setCurrentFolder().

Member Data Documentation

◆ byDeepTau2017v2p1VSerawMap

std::map<std::string, MonitorElement *> TauValidationMiniAOD::byDeepTau2017v2p1VSerawMap

private

Definition at line 64 of file TauValidationMiniAOD.h.

◆ byDeepTau2017v2p1VSjetrawMap

std::map<std::string, MonitorElement *> TauValidationMiniAOD::byDeepTau2017v2p1VSjetrawMap

private

Definition at line 64 of file TauValidationMiniAOD.h.

◆ byDeepTau2017v2p1VSmurawMap

std::map<std::string, MonitorElement *> TauValidationMiniAOD::byDeepTau2017v2p1VSmurawMap

private

Definition at line 64 of file TauValidationMiniAOD.h.

◆ decayModeFindingMap

std::map<std::string, MonitorElement *> TauValidationMiniAOD::decayModeFindingMap

private

Definition at line 64 of file TauValidationMiniAOD.h.

◆ decayModeMap

std::map<std::string, MonitorElement *> TauValidationMiniAOD::decayModeMap

private

Definition at line 64 of file TauValidationMiniAOD.h.

◆ discriminators_

std::vector<edm::ParameterSet> TauValidationMiniAOD::discriminators_

private

Definition at line 68 of file TauValidationMiniAOD.h.

◆ etaMap

std::map<std::string, MonitorElement *> TauValidationMiniAOD::etaMap

private

Definition at line 64 of file TauValidationMiniAOD.h.

◆ extensionName_

std::string TauValidationMiniAOD::extensionName_

private

Definition at line 67 of file TauValidationMiniAOD.h.

◆ histoSettings_

edm::ParameterSet TauValidationMiniAOD::histoSettings_

private

Definition at line 66 of file TauValidationMiniAOD.h.

◆ massMap

std::map<std::string, MonitorElement *> TauValidationMiniAOD::massMap

private

Definition at line 64 of file TauValidationMiniAOD.h.

◆ phiMap

std::map<std::string, MonitorElement *> TauValidationMiniAOD::phiMap

private

Definition at line 64 of file TauValidationMiniAOD.h.

◆ ptMap

std::map<std::string, MonitorElement *> TauValidationMiniAOD::ptMap

private

Definition at line 64 of file TauValidationMiniAOD.h.

◆ refCollectionInputTagToken_

edm::EDGetTokenT<edm::View<reco::Candidate> > TauValidationMiniAOD::refCollectionInputTagToken_

private

Definition at line 63 of file TauValidationMiniAOD.h.

◆ summaryMap

std::map<std::string, MonitorElement *> TauValidationMiniAOD::summaryMap

private

Definition at line 64 of file TauValidationMiniAOD.h.

◆ tauCollection_

edm::EDGetTokenT<std::vector<pat::Tau> > TauValidationMiniAOD::tauCollection_

private

Definition at line 62 of file TauValidationMiniAOD.h.

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TauValidationMiniAOD()

◆ ~TauValidationMiniAOD()

Member Function Documentation

◆ analyze()

◆ bookHistograms()

Member Data Documentation

◆ byDeepTau2017v2p1VSerawMap

◆ byDeepTau2017v2p1VSjetrawMap

◆ byDeepTau2017v2p1VSmurawMap

◆ decayModeFindingMap

◆ decayModeMap

◆ discriminators_

◆ etaMap

◆ extensionName_

◆ histoSettings_

◆ massMap

◆ phiMap

◆ ptMap

◆ refCollectionInputTagToken_

◆ summaryMap

◆ tauCollection_