TauValidationMiniAOD Class Reference

#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
int	findDecayMode (int Nc, int Np)
	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
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Private Attributes
std::vector< edm::ParameterSet >	againstXs_
std::map< std::string, MonitorElement * >	byDeepTau2018v2p5VSerawMap
std::map< std::string, MonitorElement * >	byDeepTau2018v2p5VSjetrawMap
std::map< std::string, MonitorElement * >	byDeepTau2018v2p5VSmurawMap
std::map< std::string, MonitorElement * >	decayModeFindingMap
std::map< std::string, MonitorElement * >	decayModeMap
std::vector< edm::ParameterSet >	discriminators_
std::map< std::string, MonitorElement * >	dmMigrationMap
std::map< std::string, MonitorElement * >	etaLoosevsEleMap
std::map< std::string, MonitorElement * >	etaLoosevsJetMap
std::map< std::string, MonitorElement * >	etaLoosevsMuoMap
std::map< std::string, MonitorElement * >	etaMap
std::map< std::string, MonitorElement * >	etaMediumvsEleMap
std::map< std::string, MonitorElement * >	etaMediumvsJetMap
std::map< std::string, MonitorElement * >	etaMediumvsMuoMap
std::map< std::string, MonitorElement * >	etaTightvsEleMap
std::map< std::string, MonitorElement * >	etaTightvsJetMap
std::map< std::string, MonitorElement * >	etaTightvsMuoMap
std::string	extensionName_
edm::EDGetTokenT< std::vector< reco::GenJet > >	genJetsToken_
edm::ParameterSet	histoSettings_
std::map< std::string, MonitorElement * >	massLoosevsEleMap
std::map< std::string, MonitorElement * >	massLoosevsJetMap
std::map< std::string, MonitorElement * >	massLoosevsMuoMap
std::map< std::string, MonitorElement * >	massMap
std::map< std::string, MonitorElement * >	massMediumvsEleMap
std::map< std::string, MonitorElement * >	massMediumvsJetMap
std::map< std::string, MonitorElement * >	massMediumvsMuoMap
std::map< std::string, MonitorElement * >	massTightvsEleMap
std::map< std::string, MonitorElement * >	massTightvsJetMap
std::map< std::string, MonitorElement * >	massTightvsMuoMap
std::map< std::string, MonitorElement * >	mtau_dm0Map
std::map< std::string, MonitorElement * >	mtau_dm10Map
std::map< std::string, MonitorElement * >	mtau_dm11Map
std::map< std::string, MonitorElement * >	mtau_dm1p2Map
std::map< std::string, MonitorElement * >	mtau_dm5Map
std::map< std::string, MonitorElement * >	mtau_dm6Map
std::map< std::string, MonitorElement * >	ntau_vs_dmMap
std::map< std::string, MonitorElement * >	phiLoosevsEleMap
std::map< std::string, MonitorElement * >	phiLoosevsJetMap
std::map< std::string, MonitorElement * >	phiLoosevsMuoMap
std::map< std::string, MonitorElement * >	phiMap
std::map< std::string, MonitorElement * >	phiMediumvsEleMap
std::map< std::string, MonitorElement * >	phiMediumvsJetMap
std::map< std::string, MonitorElement * >	phiMediumvsMuoMap
std::map< std::string, MonitorElement * >	phiTightvsEleMap
std::map< std::string, MonitorElement * >	phiTightvsJetMap
std::map< std::string, MonitorElement * >	phiTightvsMuoMap
edm::EDGetTokenT< std::vector< reco::Vertex > >	primaryVertexCollectionToken_
edm::EDGetTokenT< std::vector< reco::GenParticle > >	prunedGenToken_
std::map< std::string, MonitorElement * >	ptLoosevsEleMap
std::map< std::string, MonitorElement * >	ptLoosevsJetMap
std::map< std::string, MonitorElement * >	ptLoosevsMuoMap
std::map< std::string, MonitorElement * >	ptMap
std::map< std::string, MonitorElement * >	ptMediumvsEleMap
std::map< std::string, MonitorElement * >	ptMediumvsJetMap
std::map< std::string, MonitorElement * >	ptMediumvsMuoMap
std::map< std::string, MonitorElement * >	pTOverProng_dm0Map
std::map< std::string, MonitorElement * >	pTOverProng_dm10Map
std::map< std::string, MonitorElement * >	pTOverProng_dm11Map
std::map< std::string, MonitorElement * >	pTOverProng_dm1p2Map
std::map< std::string, MonitorElement * >	pTOverProng_dm5Map
std::map< std::string, MonitorElement * >	pTOverProng_dm6Map
std::map< std::string, MonitorElement * >	ptTightvsEleMap
std::map< std::string, MonitorElement * >	ptTightvsJetMap
std::map< std::string, MonitorElement * >	ptTightvsMuoMap
std::map< std::string, MonitorElement * >	puLoosevsEleMap
std::map< std::string, MonitorElement * >	puLoosevsJetMap
std::map< std::string, MonitorElement * >	puLoosevsMuoMap
std::map< std::string, MonitorElement * >	puMap
std::map< std::string, MonitorElement * >	puMediumvsEleMap
std::map< std::string, MonitorElement * >	puMediumvsJetMap
std::map< std::string, MonitorElement * >	puMediumvsMuoMap
std::map< std::string, MonitorElement * >	puTightvsEleMap
std::map< std::string, MonitorElement * >	puTightvsJetMap
std::map< std::string, MonitorElement * >	puTightvsMuoMap
std::string	qcd
std::string	real_data
std::string	real_eledata
std::string	real_mudata
edm::EDGetTokenT< edm::View< reco::Candidate > >	refCollectionInputTagToken_
std::map< std::string, MonitorElement * >	summaryMap
edm::EDGetTokenT< std::vector< pat::Tau > >	tauCollection_
std::string	zee
std::string	zmm
std::string	ztt

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

Detailed Description

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

Class used to do the Validation of the Tau in miniAOD

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

Definition at line 51 of file TauValidationMiniAOD.h.

Constructor & Destructor Documentation

TauValidationMiniAOD()

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

explicit

Definition at line 29 of file TauValidationMiniAOD.cc.

References edm::ParameterSet::getParameter().

                                                                         {
  // Input collection of legitimate taus:
  tauCollection_ = consumes<pat::TauCollection>(iConfig.getParameter<InputTag>("tauCollection"));
  // Input collection to compare to taus:
  refCollectionInputTagToken_ = consumes<edm::View<reco::Candidate>>(iConfig.getParameter<InputTag>("RefCollection"));
  // Information about reference collection:
  extensionName_ = iConfig.getParameter<string>("ExtensionName");
  // List of discriminators and their cuts:
  discriminators_ = iConfig.getParameter<std::vector<edm::ParameterSet>>("discriminators");
  // Input primaryVertex collection:
  primaryVertexCollectionToken_ = consumes<std::vector<reco::Vertex>>(iConfig.getParameter<InputTag>("PVCollection"));
  // Input genetated particle collection:
  prunedGenToken_ = consumes<std::vector<reco::GenParticle>>(iConfig.getParameter<InputTag>("GenCollection"));
}

~TauValidationMiniAOD()

TauValidationMiniAOD::~TauValidationMiniAOD ( )

override

Definition at line 44 of file TauValidationMiniAOD.cc.

{}

Member Function Documentation

analyze()

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

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 478 of file TauValidationMiniAOD.cc.

References funct::abs(), DMR_cfg::cerr, reco::CompositeRefCandidateT< D >::daughter(), HLTMuonOfflineAnalyzer_cfi::deltaR2, HGC3DClusterGenMatchSelector_cfi::dR, HLT_2024v11_cff::dRmin, jetAnalyzer_cfi::etaMap, AJJGenJetFilter_cfi::genParticles, iEvent, mkLumiAveragedPlots::isPV, reco::isTau(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, reco::CompositeRefCandidateT< D >::numberOfDaughters(), reco::LeafCandidate::pdgId(), PDWG_TauSkim_cff::selectionCut, reco::LeafCandidate::status(), metsig::tau, and Tau3MuMonitor_cff::taus.

                                                                                      {
  // create a handle to the tau collection
  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;
  }

  // create a handle to the gen Part collection
  edm::Handle<std::vector<reco::GenParticle>> genParticles;
  iEvent.getByToken(prunedGenToken_, genParticles);

  // create a handle to the reference collection
  typedef edm::View<reco::Candidate> refCandidateCollection;
  edm::Handle<refCandidateCollection> ReferenceCollection;
  bool isRef = iEvent.getByToken(refCollectionInputTagToken_, ReferenceCollection);
  if (!isRef) {
    std::cerr << "ERROR: Reference collection not found while running TauValidationMiniAOD.cc \n " << std::endl;
    return;
  }

  // create a handle to the primary vertex collection
  Handle<std::vector<reco::Vertex>> pvHandle;
  bool isPV = iEvent.getByToken(primaryVertexCollectionToken_, pvHandle);
  if (!isPV) {
    edm::LogWarning("TauValidationMiniAOD") << " PV collection not found while running TauValidationMiniAOD.cc ";
  }
  std::vector<const reco::GenParticle *> GenTaus;

  // dR match reference object to tau
  for (refCandidateCollection::const_iterator RefJet = ReferenceCollection->begin();
       RefJet != ReferenceCollection->end();
       RefJet++) {
    float dRmin = 0.15;
    int matchedTauIndex = -99;
    float gendRmin = 0.15;
    int genmatchedTauIndex = -99;

    // find best matched tau
    for (unsigned iTau = 0; iTau < taus->size(); iTau++) {
      pat::TauRef tau(taus, iTau);

      float dR = deltaR2(tau->eta(), tau->phi(), RefJet->eta(), RefJet->phi());
      if (dR < dRmin) {
        dRmin = dR;
        matchedTauIndex = iTau;
      }
    }
    if (dRmin < 0.15) {
      pat::TauRef matchedTau(taus, matchedTauIndex);

      // fill histograms with matchedTau quantities
      ptMap.find("")->second->Fill(matchedTau->pt());
      etaMap.find("")->second->Fill(matchedTau->eta());
      phiMap.find("")->second->Fill(matchedTau->phi());
      massMap.find("")->second->Fill(matchedTau->mass());
      puMap.find("")->second->Fill(pvHandle->size());
      decayModeMap.find("pftau")->second->Fill(matchedTau->decayMode());

      // fill select discriminators with matchedTau quantities
      if (matchedTau->isTauIDAvailable("decayModeFindingNewDMs"))
        decayModeFindingMap.find("")->second->Fill(matchedTau->tauID("decayModeFindingNewDMs"));
      if (matchedTau->isTauIDAvailable("byDeepTau2018v2p5VSeraw"))
        byDeepTau2018v2p5VSerawMap.find("")->second->Fill(matchedTau->tauID("byDeepTau2018v2p5VSeraw"));
      if (matchedTau->isTauIDAvailable("byDeepTau2018v2p5VSjetraw"))
        byDeepTau2018v2p5VSjetrawMap.find("")->second->Fill(matchedTau->tauID("byDeepTau2018v2p5VSjetraw"));
      if (matchedTau->isTauIDAvailable("byDeepTau2018v2p5VSmuraw"))
        byDeepTau2018v2p5VSmurawMap.find("")->second->Fill(matchedTau->tauID("byDeepTau2018v2p5VSmuraw"));

      // fill tau mass for decay modes 0,1+2,5,6,7,10,11
      if (matchedTau->decayMode() == 0) {
        mtau_dm0Map.find("")->second->Fill(matchedTau->mass());
        pTOverProng_dm0Map.find("")->second->Fill(matchedTau->pt(), matchedTau->ptLeadChargedCand());
      } else if (matchedTau->decayMode() == 1 || matchedTau->decayMode() == 2) {
        mtau_dm1p2Map.find("")->second->Fill(matchedTau->mass());
        pTOverProng_dm1p2Map.find("")->second->Fill(matchedTau->pt(), matchedTau->ptLeadChargedCand());
      } else if (matchedTau->decayMode() == 5) {
        mtau_dm5Map.find("")->second->Fill(matchedTau->mass());
        pTOverProng_dm5Map.find("")->second->Fill(matchedTau->pt(), matchedTau->ptLeadChargedCand());
      } else if (matchedTau->decayMode() == 6) {
        mtau_dm6Map.find("")->second->Fill(matchedTau->mass());
        pTOverProng_dm6Map.find("")->second->Fill(matchedTau->pt(), matchedTau->ptLeadChargedCand());
      } else if (matchedTau->decayMode() == 10) {
        mtau_dm10Map.find("")->second->Fill(matchedTau->mass());
        pTOverProng_dm10Map.find("")->second->Fill(matchedTau->pt(), matchedTau->ptLeadChargedCand());
      } else if (matchedTau->decayMode() == 11) {
        mtau_dm11Map.find("")->second->Fill(matchedTau->mass());
        pTOverProng_dm11Map.find("")->second->Fill(matchedTau->pt(), matchedTau->ptLeadChargedCand());
      }

      // fill decay mode population plot
      ntau_vs_dmMap.find("")->second->Fill(taus->size(), matchedTau->decayMode());

      //Fill decay mode migration 2D histogragms
      //First do a gen Matching
      unsigned genindex = 0;
      for (const auto &genParticle : *genParticles) {
        if (abs(genParticle.pdgId()) == 15) {
          float gendR = deltaR2(matchedTau->eta(), matchedTau->phi(), genParticle.eta(), genParticle.phi());
          if (gendR < gendRmin) {
            gendRmin = gendR;
            genmatchedTauIndex = genindex;
          }
        }
        genindex = genindex + 1;
      }

      if (gendRmin < 0.15) {
        int nPi0s = 0;
        int nPis = 0;
        auto &gentau = genParticles->at(genmatchedTauIndex);
        for (unsigned idtr = 0; idtr < gentau.numberOfDaughters(); idtr++) {
          const reco::GenParticle *dtr = dynamic_cast<const reco::GenParticle *>(gentau.daughter(idtr));
          int dtrpdgID = std::abs(dtr->pdgId());
          int dtrstatus = dtr->status();
          if (dtrpdgID == 12 || dtrpdgID == 14 || dtrpdgID == 16)
            continue;
          if (dtrpdgID == 111 || dtrpdgID == 311)
            nPi0s++;
          else if (dtrpdgID == 211 || dtrpdgID == 321)
            nPis++;
          else if (dtrpdgID == 15 && dtrstatus == 2 /*&& dtr->isLastCopy()*/) {
            for (unsigned idtr2 = 0; idtr2 < dtr->numberOfDaughters(); idtr2++) {
              const reco::GenParticle *dtr2 = dynamic_cast<const reco::GenParticle *>(dtr->daughter(idtr2));
              int dtr2pdgID = std::abs(dtr2->pdgId());
              if (dtr2pdgID == 12 || dtr2pdgID == 14 || dtr2pdgID == 16)
                continue;
              if (dtr2pdgID == 111 || dtr2pdgID == 311)
                nPi0s++;
              else if (dtr2pdgID == 211 || dtr2pdgID == 321)
                nPis++;
            }
          }
        }
        int genTau_dm = findDecayMode(nPis, nPi0s);
        decayModeMap.find("gentau")->second->Fill(genTau_dm);
        dmMigrationMap.find("")->second->Fill(genTau_dm, matchedTau->decayMode());
      }

      // count number of taus passing each discriminator's selection cut
      unsigned 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;
      }

      // fill the vsXXX histograms against (jet, e, mu)
      // vsJet/
      if (extensionName_.compare(qcd) == 0 || extensionName_.compare(real_data) == 0 ||
          extensionName_.compare(ztt) == 0) {
        // vsJet/tight
        if (matchedTau->tauID("byTightDeepTau2018v2p5VSjet") >= 0.5) {
          ptTightvsJetMap.find("")->second->Fill(matchedTau->pt());
          etaTightvsJetMap.find("")->second->Fill(matchedTau->eta());
          phiTightvsJetMap.find("")->second->Fill(matchedTau->phi());
          massTightvsJetMap.find("")->second->Fill(matchedTau->mass());
          puTightvsJetMap.find("")->second->Fill(pvHandle->size());
        }
        // vsJet/medium
        if (matchedTau->tauID("byMediumDeepTau2018v2p5VSjet") >= 0.5) {
          ptMediumvsJetMap.find("")->second->Fill(matchedTau->pt());
          etaMediumvsJetMap.find("")->second->Fill(matchedTau->eta());
          phiMediumvsJetMap.find("")->second->Fill(matchedTau->phi());
          massMediumvsJetMap.find("")->second->Fill(matchedTau->mass());
          puMediumvsJetMap.find("")->second->Fill(pvHandle->size());
        }
        // vsJet/loose
        if (matchedTau->tauID("byLooseDeepTau2018v2p5VSjet") >= 0.5) {
          ptLoosevsJetMap.find("")->second->Fill(matchedTau->pt());
          etaLoosevsJetMap.find("")->second->Fill(matchedTau->eta());
          phiLoosevsJetMap.find("")->second->Fill(matchedTau->phi());
          massLoosevsJetMap.find("")->second->Fill(matchedTau->mass());
          puLoosevsJetMap.find("")->second->Fill(pvHandle->size());
        }
      }
      // vsEle/
      if (extensionName_.compare(real_eledata) == 0 || extensionName_.compare(zee) == 0 ||
          extensionName_.compare(ztt) == 0) {
        // vsEle/tight
        if (matchedTau->tauID("byTightDeepTau2018v2p5VSe") >= 0.5) {
          ptTightvsEleMap.find("")->second->Fill(matchedTau->pt());
          etaTightvsEleMap.find("")->second->Fill(matchedTau->eta());
          phiTightvsEleMap.find("")->second->Fill(matchedTau->phi());
          massTightvsEleMap.find("")->second->Fill(matchedTau->mass());
          puTightvsEleMap.find("")->second->Fill(pvHandle->size());
        }
        // vsEle/medium
        if (matchedTau->tauID("byMediumDeepTau2018v2p5VSe") >= 0.5) {
          ptMediumvsEleMap.find("")->second->Fill(matchedTau->pt());
          etaMediumvsEleMap.find("")->second->Fill(matchedTau->eta());
          phiMediumvsEleMap.find("")->second->Fill(matchedTau->phi());
          massMediumvsEleMap.find("")->second->Fill(matchedTau->mass());
          puMediumvsEleMap.find("")->second->Fill(pvHandle->size());
        }
        // vsEle/loose
        if (matchedTau->tauID("byLooseDeepTau2018v2p5VSe") >= 0.5) {
          ptLoosevsEleMap.find("")->second->Fill(matchedTau->pt());
          etaLoosevsEleMap.find("")->second->Fill(matchedTau->eta());
          phiLoosevsEleMap.find("")->second->Fill(matchedTau->phi());
          massLoosevsEleMap.find("")->second->Fill(matchedTau->mass());
          puLoosevsEleMap.find("")->second->Fill(pvHandle->size());
        }
      }
      // vsMuo/
      if (extensionName_.compare(real_mudata) == 0 || extensionName_.compare(zmm) == 0 ||
          extensionName_.compare(ztt) == 0) {
        // vsMuo/tight
        if (matchedTau->tauID("byTightDeepTau2018v2p5VSmu") >= 0.5) {
          ptTightvsMuoMap.find("")->second->Fill(matchedTau->pt());
          etaTightvsMuoMap.find("")->second->Fill(matchedTau->eta());
          phiTightvsMuoMap.find("")->second->Fill(matchedTau->phi());
          massTightvsMuoMap.find("")->second->Fill(matchedTau->mass());
          puTightvsMuoMap.find("")->second->Fill(pvHandle->size());
        }
        // vsMuo/medium
        if (matchedTau->tauID("byMediumDeepTau2018v2p5VSmu") >= 0.5) {
          ptMediumvsMuoMap.find("")->second->Fill(matchedTau->pt());
          etaMediumvsMuoMap.find("")->second->Fill(matchedTau->eta());
          phiMediumvsMuoMap.find("")->second->Fill(matchedTau->phi());
          massMediumvsMuoMap.find("")->second->Fill(matchedTau->mass());
          puMediumvsMuoMap.find("")->second->Fill(pvHandle->size());
        }
        // vsMuo/loose
        if (matchedTau->tauID("byLooseDeepTau2018v2p5VSmu") >= 0.5) {
          ptLoosevsMuoMap.find("")->second->Fill(matchedTau->pt());
          etaLoosevsMuoMap.find("")->second->Fill(matchedTau->eta());
          phiLoosevsMuoMap.find("")->second->Fill(matchedTau->phi());
          massLoosevsMuoMap.find("")->second->Fill(matchedTau->mass());
          puLoosevsMuoMap.find("")->second->Fill(pvHandle->size());
        }
      }
    }
  }
}

bookHistograms()

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 46 of file TauValidationMiniAOD.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), jetAnalyzer_cfi::etaMap, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, histoInfo::max, histoInfo::min, histoInfo::nbins, dqm::implementation::NavigatorBase::setCurrentFolder(), dqm::impl::MonitorElement::setXTitle(), and dqm::impl::MonitorElement::setYTitle().

                                                                   {
  MonitorElement *ptTightvsJet, *etaTightvsJet, *phiTightvsJet, *massTightvsJet, *puTightvsJet;
  MonitorElement *ptTightvsEle, *etaTightvsEle, *phiTightvsEle, *massTightvsEle, *puTightvsEle;
  MonitorElement *ptTightvsMuo, *etaTightvsMuo, *phiTightvsMuo, *massTightvsMuo, *puTightvsMuo;
  MonitorElement *ptMediumvsJet, *etaMediumvsJet, *phiMediumvsJet, *massMediumvsJet, *puMediumvsJet;
  MonitorElement *ptMediumvsEle, *etaMediumvsEle, *phiMediumvsEle, *massMediumvsEle, *puMediumvsEle;
  MonitorElement *ptMediumvsMuo, *etaMediumvsMuo, *phiMediumvsMuo, *massMediumvsMuo, *puMediumvsMuo;
  MonitorElement *ptLoosevsJet, *etaLoosevsJet, *phiLoosevsJet, *massLoosevsJet, *puLoosevsJet;
  MonitorElement *ptLoosevsEle, *etaLoosevsEle, *phiLoosevsEle, *massLoosevsEle, *puLoosevsEle;
  MonitorElement *ptLoosevsMuo, *etaLoosevsMuo, *phiLoosevsMuo, *massLoosevsMuo, *puLoosevsMuo;
  MonitorElement *ptTemp, *etaTemp, *phiTemp, *massTemp, *puTemp;
  MonitorElement *decayModeFindingTemp, *decayModeTemp, *byDeepTau2018v2p5VSerawTemp;
  MonitorElement *byDeepTau2018v2p5VSjetrawTemp, *byDeepTau2018v2p5VSmurawTemp, *summaryTemp;
  MonitorElement *mtau_dm0, *mtau_dm1p2, *mtau_dm5, *mtau_dm6, *mtau_dm10, *mtau_dm11;
  MonitorElement *dmMigration, *ntau_vs_dm;
  MonitorElement *pTOverProng_dm0, *pTOverProng_dm1p2, *pTOverProng_dm5, *pTOverProng_dm6, *pTOverProng_dm10,
      *pTOverProng_dm11;

  // ---------------------------- Book, Map Summary Histograms -------------------------------

  ibooker.setCurrentFolder("RecoTauV/miniAODValidation/" + extensionName_ + "/Summary");
  histoInfo summaryHinfo = (histoSettings_.exists("summary"))
                               ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("summary"))
                               : histoInfo(15, -0.5, 14.5);

  summaryTemp = ibooker.book1D(
      "summaryPlotNum", "Summary Plot: Numerator", summaryHinfo.nbins, summaryHinfo.min, summaryHinfo.max);
  summaryTemp->setYTitle("nTaus passing discriminants");
  summaryMap.insert(std::make_pair("Num", summaryTemp));

  summaryTemp = ibooker.book1D(
      "summaryPlotDen", "Summary Plot: Denominator", summaryHinfo.nbins, summaryHinfo.min, summaryHinfo.max);
  summaryTemp->setYTitle("nTaus passing discriminants");
  summaryMap.insert(std::make_pair("Den", summaryTemp));

  summaryTemp =
      ibooker.book1D("summaryPlot", "Summary Plot: Efficiency", summaryHinfo.nbins, summaryHinfo.min, summaryHinfo.max);
  summaryTemp->setYTitle("Efficiency of discriminants");
  summaryMap.insert(std::make_pair("", summaryTemp));

  histoInfo mtauHinfo = histoInfo(20, 0.0, 2.0);

  mtau_dm0 = ibooker.book1D("mtau_dm0", "mtau: DM = 0", mtauHinfo.nbins, mtauHinfo.min, mtauHinfo.max);
  mtau_dm0Map.insert(std::make_pair("", mtau_dm0));

  mtau_dm1p2 = ibooker.book1D("mtau_dm1p2", "mtau: DM = 1+2", mtauHinfo.nbins, mtauHinfo.min, mtauHinfo.max);
  mtau_dm1p2Map.insert(std::make_pair("", mtau_dm1p2));

  mtau_dm5 = ibooker.book1D("mtau_dm5", "mtau: DM = 5", mtauHinfo.nbins, mtauHinfo.min, mtauHinfo.max);
  mtau_dm5Map.insert(std::make_pair("", mtau_dm5));

  mtau_dm6 = ibooker.book1D("mtau_dm6", "mtau: DM = 6", mtauHinfo.nbins, mtauHinfo.min, mtauHinfo.max);
  mtau_dm6Map.insert(std::make_pair("", mtau_dm6));

  mtau_dm10 = ibooker.book1D("mtau_dm10", "mtau: DM = 10", mtauHinfo.nbins, mtauHinfo.min, mtauHinfo.max);
  mtau_dm10Map.insert(std::make_pair("", mtau_dm10));

  mtau_dm11 = ibooker.book1D("mtau_dm11", "mtau: DM = 11", mtauHinfo.nbins, mtauHinfo.min, mtauHinfo.max);
  mtau_dm11Map.insert(std::make_pair("", mtau_dm11));

  dmMigration = ibooker.book2D("dmMigration", "DM Migration", 15, -0.5, 14.5, 15, -0.5, 14.5);
  dmMigration->setXTitle("Generated tau DM");
  dmMigration->setYTitle("Reconstructed tau DM");
  dmMigrationMap.insert(std::make_pair("", dmMigration));

  histoInfo pTOverProngHinfo = (histoSettings_.exists("pTOverProng"))
                                   ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("pTOverProng"))
                                   : histoInfo(50, 0, 1000);

  pTOverProng_dm0 = ibooker.book2D("pTOverProng_dm0",
                                   "pTOverProng: DM = 0",
                                   pTOverProngHinfo.nbins,
                                   pTOverProngHinfo.min,
                                   pTOverProngHinfo.max,
                                   pTOverProngHinfo.nbins,
                                   pTOverProngHinfo.min,
                                   pTOverProngHinfo.max);
  pTOverProng_dm0->setXTitle("pT of reconstructed tau");
  pTOverProng_dm0->setYTitle("pT of lead charged cand");
  pTOverProng_dm0Map.insert(std::make_pair("", pTOverProng_dm0));

  pTOverProng_dm1p2 = ibooker.book2D("pTOverProng_dm1p2",
                                     "pTOverProng: DM = 1+2",
                                     pTOverProngHinfo.nbins,
                                     pTOverProngHinfo.min,
                                     pTOverProngHinfo.max,
                                     pTOverProngHinfo.nbins,
                                     pTOverProngHinfo.min,
                                     pTOverProngHinfo.max);
  pTOverProng_dm1p2->setXTitle("pT of reconstructed tau");
  pTOverProng_dm1p2->setYTitle("pT of lead charged cand");
  pTOverProng_dm1p2Map.insert(std::make_pair("", pTOverProng_dm1p2));

  pTOverProng_dm5 = ibooker.book2D("pTOverProng_dm5",
                                   "pTOverProng: DM = 5",
                                   pTOverProngHinfo.nbins,
                                   pTOverProngHinfo.min,
                                   pTOverProngHinfo.max,
                                   pTOverProngHinfo.nbins,
                                   pTOverProngHinfo.min,
                                   pTOverProngHinfo.max);
  pTOverProng_dm5->setXTitle("pT of reconstructed tau");
  pTOverProng_dm5->setYTitle("pT of lead charged cand");
  pTOverProng_dm5Map.insert(std::make_pair("", pTOverProng_dm5));

  pTOverProng_dm6 = ibooker.book2D("pTOverProng_dm6",
                                   "pTOverProng: DM = 6",
                                   pTOverProngHinfo.nbins,
                                   pTOverProngHinfo.min,
                                   pTOverProngHinfo.max,
                                   pTOverProngHinfo.nbins,
                                   pTOverProngHinfo.min,
                                   pTOverProngHinfo.max);
  pTOverProng_dm6->setXTitle("pT of reconstructed tau");
  pTOverProng_dm6->setYTitle("pT of lead charged cand");
  pTOverProng_dm6Map.insert(std::make_pair("", pTOverProng_dm6));

  pTOverProng_dm10 = ibooker.book2D("pTOverProng_dm10",
                                    "pTOverProng: DM = 10",
                                    pTOverProngHinfo.nbins,
                                    pTOverProngHinfo.min,
                                    pTOverProngHinfo.max,
                                    pTOverProngHinfo.nbins,
                                    pTOverProngHinfo.min,
                                    pTOverProngHinfo.max);
  pTOverProng_dm10->setXTitle("pT of reconstructed tau");
  pTOverProng_dm10->setYTitle("pT of lead charged cand");
  pTOverProng_dm10Map.insert(std::make_pair("", pTOverProng_dm10));

  pTOverProng_dm11 = ibooker.book2D("pTOverProng_dm11",
                                    "pTOverProng: DM = 11",
                                    pTOverProngHinfo.nbins,
                                    pTOverProngHinfo.min,
                                    pTOverProngHinfo.max,
                                    pTOverProngHinfo.nbins,
                                    pTOverProngHinfo.min,
                                    pTOverProngHinfo.max);
  pTOverProng_dm11->setXTitle("pT of reconstructed tau");
  pTOverProng_dm11->setYTitle("pT of lead charged cand");
  pTOverProng_dm11Map.insert(std::make_pair("", pTOverProng_dm11));

  ntau_vs_dm = ibooker.book2D("ntau_vs_dm", "DM vs nTau", 15, 0, 15, 15, 0, 15);
  ntau_vs_dm->setXTitle("nTau");
  ntau_vs_dm->setYTitle("tau DM");
  ntau_vs_dmMap.insert(std::make_pair("", ntau_vs_dm));

  // add discriminator labels to summary plots
  unsigned 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;
  }

  // --------------- Book, Map Discriminator/Kinematic Histograms -----------------------

  // pt, eta, phi, mass, pileup
  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(60, -3, 3.);
  histoInfo phiHinfo = (histoSettings_.exists("phi")) ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("phi"))
                                                      : histoInfo(60, -3, 3.);
  histoInfo massHinfo = (histoSettings_.exists("mass"))
                            ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("mass"))
                            : histoInfo(200, 0, 10.);
  histoInfo puHinfo = (histoSettings_.exists("pileup"))
                          ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("pileup"))
                          : histoInfo(100, 0., 100.);

  // decayMode, decayModeFinding
  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(15, -0.5, 14.5);

  // raw distributions for deepTau (e, jet, mu)
  histoInfo byDeepTau2018v2p5VSerawHinfo =
      (histoSettings_.exists("byDeepTau2018v2p5VSeraw"))
          ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("byDeepTau2018v2p5VSeraw"))
          : histoInfo(200, 0., 1.);
  histoInfo byDeepTau2018v2p5VSjetrawHinfo =
      (histoSettings_.exists("byDeepTau2018v2p5VSjetraw"))
          ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("byDeepTau2018v2p5VSjetraw"))
          : histoInfo(200, 0., 1.);
  histoInfo byDeepTau2018v2p5VSmurawHinfo =
      (histoSettings_.exists("byDeepTau2018v2p5VSmuraw"))
          ? histoInfo(histoSettings_.getParameter<edm::ParameterSet>("byDeepTau2018v2p5VSmuraw"))
          : histoInfo(200, 0., 1.);

  // book the temp histograms
  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);
  puTemp = ibooker.book1D("tau_pu", "tau pileup", puHinfo.nbins, puHinfo.min, puHinfo.max);

  // map the histograms
  ptMap.insert(std::make_pair("", ptTemp));
  etaMap.insert(std::make_pair("", etaTemp));
  phiMap.insert(std::make_pair("", phiTemp));
  massMap.insert(std::make_pair("", massTemp));
  puMap.insert(std::make_pair("", puTemp));

  // book decay mode histograms
  decayModeFindingTemp = ibooker.book1D("tau_decayModeFinding",
                                        "tau decayModeFinding",
                                        decayModeFindingHinfo.nbins,
                                        decayModeFindingHinfo.min,
                                        decayModeFindingHinfo.max);
  decayModeFindingMap.insert(std::make_pair("", decayModeFindingTemp));

  decayModeTemp = ibooker.book1D("tau_decayMode_reco",
                                 "DecayMode: Reconstructed tau",
                                 decayModeHinfo.nbins,
                                 decayModeHinfo.min,
                                 decayModeHinfo.max);
  decayModeMap.insert(std::make_pair("pftau", decayModeTemp));

  decayModeTemp = ibooker.book1D(
      "tau_decayMode_gen", "DecayMode: Generated tau", decayModeHinfo.nbins, decayModeHinfo.min, decayModeHinfo.max);
  decayModeMap.insert(std::make_pair("gentau", decayModeTemp));

  // book the deepTau histograms
  byDeepTau2018v2p5VSerawTemp = ibooker.book1D("tau_byDeepTau2018v2p5VSeraw",
                                               "byDeepTau2018v2p5VSeraw",
                                               byDeepTau2018v2p5VSerawHinfo.nbins,
                                               byDeepTau2018v2p5VSerawHinfo.min,
                                               byDeepTau2018v2p5VSerawHinfo.max);
  byDeepTau2018v2p5VSjetrawTemp = ibooker.book1D("tau_byDeepTau2018v2p5VSjetraw",
                                                 "byDeepTau2018v2p5VSjetraw",
                                                 byDeepTau2018v2p5VSjetrawHinfo.nbins,
                                                 byDeepTau2018v2p5VSjetrawHinfo.min,
                                                 byDeepTau2018v2p5VSjetrawHinfo.max);
  byDeepTau2018v2p5VSmurawTemp = ibooker.book1D("tau_byDeepTau2018v2p5VSmuraw",
                                                "byDeepTau2018v2p5VSmuraw",
                                                byDeepTau2018v2p5VSmurawHinfo.nbins,
                                                byDeepTau2018v2p5VSmurawHinfo.min,
                                                byDeepTau2018v2p5VSmurawHinfo.max);

  // map the deepTau histograms
  byDeepTau2018v2p5VSerawMap.insert(std::make_pair("", byDeepTau2018v2p5VSerawTemp));
  byDeepTau2018v2p5VSjetrawMap.insert(std::make_pair("", byDeepTau2018v2p5VSjetrawTemp));
  byDeepTau2018v2p5VSmurawMap.insert(std::make_pair("", byDeepTau2018v2p5VSmurawTemp));

  qcd = "QCD";
  real_data = "RealData";
  real_eledata = "RealElectronsData";
  real_mudata = "RealMuonsData";
  ztt = "ZTT";
  zee = "ZEE";
  zmm = "ZMM";

  // ---------------------------- /vsJet/ ---------------------------------------------
  if (extensionName_.compare(qcd) == 0 || extensionName_.compare(real_data) == 0 || extensionName_.compare(ztt) == 0) {
    // ---------------------------- /vsJet/tight ---------------------------------------------
    ibooker.setCurrentFolder("RecoTauV/miniAODValidation/" + extensionName_ + "/vsJet/tight");

    ptTightvsJet = ibooker.book1D("tau_tightvsJet_pt", "tau_tightvsJet_pt", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
    etaTightvsJet =
        ibooker.book1D("tau_tightvsJet_eta", "tau_tightvsJet_eta", etaHinfo.nbins, etaHinfo.min, etaHinfo.max);
    phiTightvsJet =
        ibooker.book1D("tau_tightvsJet_phi", "tau_tightvsJet_phi", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
    massTightvsJet =
        ibooker.book1D("tau_tightvsJet_mass", "tau_tightvsJet_mass", massHinfo.nbins, massHinfo.min, massHinfo.max);
    puTightvsJet = ibooker.book1D("tau_tightvsJet_pu", "tau_tightvsJet_pu", puHinfo.nbins, puHinfo.min, puHinfo.max);

    ptTightvsJetMap.insert(std::make_pair("", ptTightvsJet));
    etaTightvsJetMap.insert(std::make_pair("", etaTightvsJet));
    phiTightvsJetMap.insert(std::make_pair("", phiTightvsJet));
    massTightvsJetMap.insert(std::make_pair("", massTightvsJet));
    puTightvsJetMap.insert(std::make_pair("", puTightvsJet));

    // ---------------------------- /vsJet/medium -------------------------------------------
    ibooker.setCurrentFolder("RecoTauV/miniAODValidation/" + extensionName_ + "/vsJet/medium");

    ptMediumvsJet = ibooker.book1D("tau_mediumvsJet_pt", "tau_mediumvsJet_pt", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
    etaMediumvsJet =
        ibooker.book1D("tau_mediumvsJet_eta", "tau_mediumvsJet_eta", etaHinfo.nbins, etaHinfo.min, etaHinfo.max);
    phiMediumvsJet =
        ibooker.book1D("tau_mediumvsJet_phi", "tau_mediumvsJet_phi", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
    massMediumvsJet =
        ibooker.book1D("tau_mediumvsJet_mass", "tau_mediumvsJet_mass", massHinfo.nbins, massHinfo.min, massHinfo.max);
    puMediumvsJet = ibooker.book1D("tau_mediumvsJet_pu", "tau_mediumvsJet_pu", puHinfo.nbins, puHinfo.min, puHinfo.max);

    ptMediumvsJetMap.insert(std::make_pair("", ptMediumvsJet));
    etaMediumvsJetMap.insert(std::make_pair("", etaMediumvsJet));
    phiMediumvsJetMap.insert(std::make_pair("", phiMediumvsJet));
    massMediumvsJetMap.insert(std::make_pair("", massMediumvsJet));
    puMediumvsJetMap.insert(std::make_pair("", puMediumvsJet));

    // ---------------------------- /vsJet/loose --------------------------------------------
    ibooker.setCurrentFolder("RecoTauV/miniAODValidation/" + extensionName_ + "/vsJet/loose");

    ptLoosevsJet = ibooker.book1D("tau_loosevsJet_pt", "tau_loosevsJet_pt", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
    etaLoosevsJet =
        ibooker.book1D("tau_loosevsJet_eta", "tau_loosevsJet_eta", etaHinfo.nbins, etaHinfo.min, etaHinfo.max);
    phiLoosevsJet =
        ibooker.book1D("tau_loosevsJet_phi", "tau_loosevsJet_phi", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
    massLoosevsJet =
        ibooker.book1D("tau_loosevsJet_mass", "tau_loosevsJet_mass", massHinfo.nbins, massHinfo.min, massHinfo.max);
    puLoosevsJet = ibooker.book1D("tau_loosevsJet_pu", "tau_loosevsJet_pu", puHinfo.nbins, puHinfo.min, puHinfo.max);

    ptLoosevsJetMap.insert(std::make_pair("", ptLoosevsJet));
    etaLoosevsJetMap.insert(std::make_pair("", etaLoosevsJet));
    phiLoosevsJetMap.insert(std::make_pair("", phiLoosevsJet));
    massLoosevsJetMap.insert(std::make_pair("", massLoosevsJet));
    puLoosevsJetMap.insert(std::make_pair("", puLoosevsJet));
  }
  // ---------------------------- /vsEle/ ---------------------------------------------
  //if (strcmp(extensionName_, real_eledata) == 0 || strcmp(extensionName_, zee) == 0 || strcmp(extensionName_, ztt) == 0) {
  if (extensionName_.compare(real_eledata) == 0 || extensionName_.compare(zee) == 0 ||
      extensionName_.compare(ztt) == 0) {
    // ---------------------------- /vsEle/tight ---------------------------------------------
    ibooker.setCurrentFolder("RecoTauV/miniAODValidation/" + extensionName_ + "/vsEle/tight");

    ptTightvsEle = ibooker.book1D("tau_tightvsEle_pt", "tau_tightvsEle_pt", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
    etaTightvsEle =
        ibooker.book1D("tau_tightvsEle_eta", "tau_tightvsEle_eta", etaHinfo.nbins, etaHinfo.min, etaHinfo.max);
    phiTightvsEle =
        ibooker.book1D("tau_tightvsEle_phi", "tau_tightvsEle_phi", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
    massTightvsEle =
        ibooker.book1D("tau_tightvsEle_mass", "tau_tightvsEle_mass", massHinfo.nbins, massHinfo.min, massHinfo.max);
    puTightvsEle = ibooker.book1D("tau_tightvsEle_pu", "tau_tightvsEle_pu", puHinfo.nbins, puHinfo.min, puHinfo.max);

    ptTightvsEleMap.insert(std::make_pair("", ptTightvsEle));
    etaTightvsEleMap.insert(std::make_pair("", etaTightvsEle));
    phiTightvsEleMap.insert(std::make_pair("", phiTightvsEle));
    massTightvsEleMap.insert(std::make_pair("", massTightvsEle));
    puTightvsEleMap.insert(std::make_pair("", puTightvsEle));

    // ---------------------------- /vsEle/medium -------------------------------------------
    ibooker.setCurrentFolder("RecoTauV/miniAODValidation/" + extensionName_ + "/vsEle/medium");

    ptMediumvsEle = ibooker.book1D("tau_mediumvsEle_pt", "tau_mediumvsEle_pt", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
    etaMediumvsEle =
        ibooker.book1D("tau_mediumvsEle_eta", "tau_mediumvsEle_eta", etaHinfo.nbins, etaHinfo.min, etaHinfo.max);
    phiMediumvsEle =
        ibooker.book1D("tau_mediumvsEle_phi", "tau_mediumvsEle_phi", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
    massMediumvsEle =
        ibooker.book1D("tau_mediumvsEle_mass", "tau_mediumvsEle_mass", massHinfo.nbins, massHinfo.min, massHinfo.max);
    puMediumvsEle = ibooker.book1D("tau_mediumvsEle_pu", "tau_mediumvsEle_pu", puHinfo.nbins, puHinfo.min, puHinfo.max);

    ptMediumvsEleMap.insert(std::make_pair("", ptMediumvsEle));
    etaMediumvsEleMap.insert(std::make_pair("", etaMediumvsEle));
    phiMediumvsEleMap.insert(std::make_pair("", phiMediumvsEle));
    massMediumvsEleMap.insert(std::make_pair("", massMediumvsEle));
    puMediumvsEleMap.insert(std::make_pair("", puMediumvsEle));

    // ---------------------------- /vsEle/loose --------------------------------------------
    ibooker.setCurrentFolder("RecoTauV/miniAODValidation/" + extensionName_ + "/vsEle/loose");

    ptLoosevsEle = ibooker.book1D("tau_loosevsEle_pt", "tau_loosevsEle_pt", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
    etaLoosevsEle =
        ibooker.book1D("tau_loosevsEle_eta", "tau_loosevsEle_eta", etaHinfo.nbins, etaHinfo.min, etaHinfo.max);
    phiLoosevsEle =
        ibooker.book1D("tau_loosevsEle_phi", "tau_loosevsEle_phi", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
    massLoosevsEle =
        ibooker.book1D("tau_loosevsEle_mass", "tau_loosevsEle_mass", massHinfo.nbins, massHinfo.min, massHinfo.max);
    puLoosevsEle = ibooker.book1D("tau_loosevsEle_pu", "tau_loosevsEle_pu", puHinfo.nbins, puHinfo.min, puHinfo.max);

    ptLoosevsEleMap.insert(std::make_pair("", ptLoosevsEle));
    etaLoosevsEleMap.insert(std::make_pair("", etaLoosevsEle));
    phiLoosevsEleMap.insert(std::make_pair("", phiLoosevsEle));
    massLoosevsEleMap.insert(std::make_pair("", massLoosevsEle));
    puLoosevsEleMap.insert(std::make_pair("", puLoosevsEle));
  }
  // ---------------------------- /vsMuo/ ---------------------------------------------
  //if (strcmp(extensionName_, real_mudata) == 0 || strcmp(extensionName_, zmm) == 0 || strcmp(extensionName_, ztt) == 0) {
  if (extensionName_.compare(real_mudata) == 0 || extensionName_.compare(zmm) == 0 ||
      extensionName_.compare(ztt) == 0) {
    // ---------------------------- /vsMuo/tight ---------------------------------------------
    ibooker.setCurrentFolder("RecoTauV/miniAODValidation/" + extensionName_ + "/vsMuo/tight");

    ptTightvsMuo = ibooker.book1D("tau_tightvsMuo_pt", "tau_tightvsMuo_pt", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
    etaTightvsMuo =
        ibooker.book1D("tau_tightvsMuo_eta", "tau_tightvsMuo_eta", etaHinfo.nbins, etaHinfo.min, etaHinfo.max);
    phiTightvsMuo =
        ibooker.book1D("tau_tightvsMuo_phi", "tau_tightvsMuo_phi", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
    massTightvsMuo =
        ibooker.book1D("tau_tightvsMuo_mass", "tau_tightvsMuo_mass", massHinfo.nbins, massHinfo.min, massHinfo.max);
    puTightvsMuo = ibooker.book1D("tau_tightvsMuo_pu", "tau_tightvsMuo_pu", puHinfo.nbins, puHinfo.min, puHinfo.max);

    ptTightvsMuoMap.insert(std::make_pair("", ptTightvsMuo));
    etaTightvsMuoMap.insert(std::make_pair("", etaTightvsMuo));
    phiTightvsMuoMap.insert(std::make_pair("", phiTightvsMuo));
    massTightvsMuoMap.insert(std::make_pair("", massTightvsMuo));
    puTightvsMuoMap.insert(std::make_pair("", puTightvsMuo));

    // ---------------------------- /vsMuo/medium -------------------------------------------
    ibooker.setCurrentFolder("RecoTauV/miniAODValidation/" + extensionName_ + "/vsMuo/medium");

    ptMediumvsMuo = ibooker.book1D("tau_mediumvsMuo_pt", "tau_mediumvsMuo_pt", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
    etaMediumvsMuo =
        ibooker.book1D("tau_mediumvsMuo_eta", "tau_mediumvsMuo_eta", etaHinfo.nbins, etaHinfo.min, etaHinfo.max);
    phiMediumvsMuo =
        ibooker.book1D("tau_mediumvsMuo_phi", "tau_mediumvsMuo_phi", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
    massMediumvsMuo =
        ibooker.book1D("tau_mediumvsMuo_mass", "tau_mediumvsMuo_mass", massHinfo.nbins, massHinfo.min, massHinfo.max);
    puMediumvsMuo = ibooker.book1D("tau_mediumvsMuo_pu", "tau_mediumvsMuo_pu", puHinfo.nbins, puHinfo.min, puHinfo.max);

    ptMediumvsMuoMap.insert(std::make_pair("", ptMediumvsMuo));
    etaMediumvsMuoMap.insert(std::make_pair("", etaMediumvsMuo));
    phiMediumvsMuoMap.insert(std::make_pair("", phiMediumvsMuo));
    massMediumvsMuoMap.insert(std::make_pair("", massMediumvsMuo));
    puMediumvsMuoMap.insert(std::make_pair("", puMediumvsMuo));

    // ---------------------------- /vsMuo/loose --------------------------------------------
    ibooker.setCurrentFolder("RecoTauV/miniAODValidation/" + extensionName_ + "/vsMuo/loose");

    ptLoosevsMuo = ibooker.book1D("tau_loosevsMuo_pt", "tau_loosevsMuo_pt", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
    etaLoosevsMuo =
        ibooker.book1D("tau_loosevsMuo_eta", "tau_loosevsMuo_eta", etaHinfo.nbins, etaHinfo.min, etaHinfo.max);
    phiLoosevsMuo =
        ibooker.book1D("tau_loosevsMuo_phi", "tau_loosevsMuo_phi", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
    massLoosevsMuo =
        ibooker.book1D("tau_loosevsMuo_mass", "tau_loosevsMuo_mass", massHinfo.nbins, massHinfo.min, massHinfo.max);
    puLoosevsMuo = ibooker.book1D("tau_loosevsMuo_pu", "tau_loosevsMuo_pu", puHinfo.nbins, puHinfo.min, puHinfo.max);

    ptLoosevsMuoMap.insert(std::make_pair("", ptLoosevsMuo));
    etaLoosevsMuoMap.insert(std::make_pair("", etaLoosevsMuo));
    phiLoosevsMuoMap.insert(std::make_pair("", phiLoosevsMuo));
    massLoosevsMuoMap.insert(std::make_pair("", massLoosevsMuo));
    puLoosevsMuoMap.insert(std::make_pair("", puLoosevsMuo));
  }
}

findDecayMode()

int TauValidationMiniAOD::findDecayMode ( int  Nc, int  Np  )

inline

Definition at line 59 of file TauValidationMiniAOD.h.

{ return 5 * (Nc - 1) + Np; };

Member Data Documentation

againstXs_

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

private

Definition at line 97 of file TauValidationMiniAOD.h.

byDeepTau2018v2p5VSerawMap

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

private

Definition at line 87 of file TauValidationMiniAOD.h.

byDeepTau2018v2p5VSjetrawMap

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

private

Definition at line 87 of file TauValidationMiniAOD.h.

byDeepTau2018v2p5VSmurawMap

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

private

Definition at line 87 of file TauValidationMiniAOD.h.

decayModeFindingMap

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

private

Definition at line 87 of file TauValidationMiniAOD.h.

decayModeMap

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

private

Definition at line 87 of file TauValidationMiniAOD.h.

discriminators_

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

private

Definition at line 96 of file TauValidationMiniAOD.h.

dmMigrationMap

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

private

Definition at line 91 of file TauValidationMiniAOD.h.

etaLoosevsEleMap

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

private

Definition at line 83 of file TauValidationMiniAOD.h.

etaLoosevsJetMap

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

private

Definition at line 81 of file TauValidationMiniAOD.h.

etaLoosevsMuoMap

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

private

Definition at line 85 of file TauValidationMiniAOD.h.

etaMap

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

private

Definition at line 68 of file TauValidationMiniAOD.h.

etaMediumvsEleMap

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

private

Definition at line 77 of file TauValidationMiniAOD.h.

etaMediumvsJetMap

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

private

Definition at line 75 of file TauValidationMiniAOD.h.

etaMediumvsMuoMap

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

private

Definition at line 79 of file TauValidationMiniAOD.h.

etaTightvsEleMap

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

private

Definition at line 71 of file TauValidationMiniAOD.h.

etaTightvsJetMap

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

private

Definition at line 69 of file TauValidationMiniAOD.h.

etaTightvsMuoMap

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

private

Definition at line 73 of file TauValidationMiniAOD.h.

extensionName_

std::string TauValidationMiniAOD::extensionName_

private

Definition at line 95 of file TauValidationMiniAOD.h.

genJetsToken_

edm::EDGetTokenT<std::vector<reco::GenJet> > TauValidationMiniAOD::genJetsToken_

private

Definition at line 66 of file TauValidationMiniAOD.h.

histoSettings_

edm::ParameterSet TauValidationMiniAOD::histoSettings_

private

Definition at line 94 of file TauValidationMiniAOD.h.

massLoosevsEleMap

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

private

Definition at line 83 of file TauValidationMiniAOD.h.

massLoosevsJetMap

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

private

Definition at line 81 of file TauValidationMiniAOD.h.

massLoosevsMuoMap

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

private

Definition at line 85 of file TauValidationMiniAOD.h.

massMap

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

private

Definition at line 68 of file TauValidationMiniAOD.h.

massMediumvsEleMap

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

private

Definition at line 77 of file TauValidationMiniAOD.h.

massMediumvsJetMap

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

private

Definition at line 75 of file TauValidationMiniAOD.h.

massMediumvsMuoMap

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

private

Definition at line 79 of file TauValidationMiniAOD.h.

massTightvsEleMap

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

private

Definition at line 71 of file TauValidationMiniAOD.h.

massTightvsJetMap

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

private

Definition at line 69 of file TauValidationMiniAOD.h.

massTightvsMuoMap

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

private

Definition at line 73 of file TauValidationMiniAOD.h.

mtau_dm0Map

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

private

Definition at line 89 of file TauValidationMiniAOD.h.

mtau_dm10Map

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

private

Definition at line 89 of file TauValidationMiniAOD.h.

mtau_dm11Map

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

private

Definition at line 89 of file TauValidationMiniAOD.h.

mtau_dm1p2Map

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

private

Definition at line 89 of file TauValidationMiniAOD.h.

mtau_dm5Map

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

private

Definition at line 89 of file TauValidationMiniAOD.h.

mtau_dm6Map

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

private

Definition at line 89 of file TauValidationMiniAOD.h.

ntau_vs_dmMap

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

private

Definition at line 91 of file TauValidationMiniAOD.h.

phiLoosevsEleMap

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

private

Definition at line 83 of file TauValidationMiniAOD.h.

phiLoosevsJetMap

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

private

Definition at line 81 of file TauValidationMiniAOD.h.

phiLoosevsMuoMap

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

private

Definition at line 85 of file TauValidationMiniAOD.h.

phiMap

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

private

Definition at line 68 of file TauValidationMiniAOD.h.

phiMediumvsEleMap

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

private

Definition at line 77 of file TauValidationMiniAOD.h.

phiMediumvsJetMap

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

private

Definition at line 75 of file TauValidationMiniAOD.h.

phiMediumvsMuoMap

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

private

Definition at line 79 of file TauValidationMiniAOD.h.

phiTightvsEleMap

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

private

Definition at line 71 of file TauValidationMiniAOD.h.

phiTightvsJetMap

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

private

Definition at line 69 of file TauValidationMiniAOD.h.

phiTightvsMuoMap

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

private

Definition at line 73 of file TauValidationMiniAOD.h.

primaryVertexCollectionToken_

edm::EDGetTokenT<std::vector<reco::Vertex> > TauValidationMiniAOD::primaryVertexCollectionToken_

private

Definition at line 64 of file TauValidationMiniAOD.h.

prunedGenToken_

edm::EDGetTokenT<std::vector<reco::GenParticle> > TauValidationMiniAOD::prunedGenToken_

private

Definition at line 65 of file TauValidationMiniAOD.h.

ptLoosevsEleMap

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

private

Definition at line 83 of file TauValidationMiniAOD.h.

ptLoosevsJetMap

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

private

Definition at line 81 of file TauValidationMiniAOD.h.

ptLoosevsMuoMap

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

private

Definition at line 85 of file TauValidationMiniAOD.h.

ptMap

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

private

Definition at line 68 of file TauValidationMiniAOD.h.

ptMediumvsEleMap

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

private

Definition at line 77 of file TauValidationMiniAOD.h.

ptMediumvsJetMap

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

private

Definition at line 75 of file TauValidationMiniAOD.h.

ptMediumvsMuoMap

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

private

Definition at line 79 of file TauValidationMiniAOD.h.

pTOverProng_dm0Map

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

private

Definition at line 92 of file TauValidationMiniAOD.h.

pTOverProng_dm10Map

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

private

Definition at line 92 of file TauValidationMiniAOD.h.

pTOverProng_dm11Map

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

private

Definition at line 92 of file TauValidationMiniAOD.h.

pTOverProng_dm1p2Map

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

private

Definition at line 92 of file TauValidationMiniAOD.h.

pTOverProng_dm5Map

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

private

Definition at line 92 of file TauValidationMiniAOD.h.

pTOverProng_dm6Map

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

private

Definition at line 92 of file TauValidationMiniAOD.h.

ptTightvsEleMap

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

private

Definition at line 71 of file TauValidationMiniAOD.h.

ptTightvsJetMap

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

private

Definition at line 69 of file TauValidationMiniAOD.h.

ptTightvsMuoMap

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

private

Definition at line 73 of file TauValidationMiniAOD.h.

puLoosevsEleMap

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

private

Definition at line 83 of file TauValidationMiniAOD.h.

puLoosevsJetMap

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

private

Definition at line 81 of file TauValidationMiniAOD.h.

puLoosevsMuoMap

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

private

Definition at line 85 of file TauValidationMiniAOD.h.

puMap

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

private

Definition at line 68 of file TauValidationMiniAOD.h.

puMediumvsEleMap

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

private

Definition at line 77 of file TauValidationMiniAOD.h.

puMediumvsJetMap

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

private

Definition at line 75 of file TauValidationMiniAOD.h.

puMediumvsMuoMap

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

private

Definition at line 79 of file TauValidationMiniAOD.h.

puTightvsEleMap

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

private

Definition at line 71 of file TauValidationMiniAOD.h.

puTightvsJetMap

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

private

Definition at line 69 of file TauValidationMiniAOD.h.

puTightvsMuoMap

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

private

Definition at line 73 of file TauValidationMiniAOD.h.

qcd

std::string TauValidationMiniAOD::qcd

private

Definition at line 98 of file TauValidationMiniAOD.h.

real_data

std::string TauValidationMiniAOD::real_data

private

Definition at line 99 of file TauValidationMiniAOD.h.

real_eledata

std::string TauValidationMiniAOD::real_eledata

private

Definition at line 100 of file TauValidationMiniAOD.h.

real_mudata

std::string TauValidationMiniAOD::real_mudata

private

Definition at line 101 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 87 of file TauValidationMiniAOD.h.

tauCollection_

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

private

Definition at line 59 of file TauValidationMiniAOD.h.

zee

std::string TauValidationMiniAOD::zee

private

Definition at line 103 of file TauValidationMiniAOD.h.

zmm

std::string TauValidationMiniAOD::zmm

private

Definition at line 104 of file TauValidationMiniAOD.h.

ztt

std::string TauValidationMiniAOD::ztt

private

Definition at line 102 of file TauValidationMiniAOD.h.