#include <L1TTauOffline.h>

Inheritance diagram for L1TTauOffline:

Public Member Functions
	L1TTauOffline (const edm::ParameterSet &ps)

	~L1TTauOffline () override

Public Member Functions inherited from DQMEDAnalyzer
void	beginRun (edm::Run const &, edm::EventSetup const &) final

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer (void)

void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

	~EDAnalyzerBase () 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

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

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &eSetup) override

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &eSetup) override

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

void	dqmBeginRun (const edm::Run &run, const edm::EventSetup &iSetup) override

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &eSetup) override

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

const reco::Vertex	getPrimaryVertex (edm::Handle< reco::VertexCollection > const &vertex, edm::Handle< reco::BeamSpot > const &beamSpot)

void	getProbeTaus (const edm::Event &e, edm::Handle< reco::PFTauCollection > const &taus, edm::Handle< reco::MuonCollection > const &muons, const reco::Vertex &vertex)

void	getTauL1tPairs (edm::Handle< l1t::TauBxCollection > const &l1tCands)

void	getTightMuons (edm::Handle< reco::MuonCollection > const &muons, edm::Handle< reco::PFMETCollection > const &mets, const reco::Vertex &vertex, edm::Handle< trigger::TriggerEvent > const &trigEvent)

bool	matchHlt (edm::Handle< trigger::TriggerEvent > const &triggerEvent, const reco::Muon *muon)

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)

Private Member Functions
void	bookTauHistos (DQMStore::IBooker &)

double	calcDeltaPhi (double phi1, double phi2)

double	Distance (const reco::Candidate &c1, const reco::Candidate &c2)

double	DistancePhi (const reco::Candidate &c1, const reco::Candidate &c2)

Private Attributes
edm::EDGetTokenT< reco::PFTauDiscriminator >	AntiEleInputTag_

edm::EDGetTokenT< reco::PFTauDiscriminator >	AntiMuInputTag_

edm::EDGetTokenT< reco::BeamSpot >	BsInputTag_

edm::EDGetTokenT< reco::PFTauDiscriminator >	comb3TInputTag_

edm::EDGetTokenT< reco::PFTauDiscriminator >	DecayModeFindingInputTag_

std::string	efficiencyFolder_

std::map< double, MonitorElement * >	h_efficiencyIsoTauET_EB_EE_pass_

std::map< double, MonitorElement * >	h_efficiencyIsoTauET_EB_EE_total_

std::map< double, MonitorElement * >	h_efficiencyIsoTauET_EB_pass_

std::map< double, MonitorElement * >	h_efficiencyIsoTauET_EB_total_

std::map< double, MonitorElement * >	h_efficiencyIsoTauET_EE_pass_

std::map< double, MonitorElement * >	h_efficiencyIsoTauET_EE_total_

std::map< double, MonitorElement * >	h_efficiencyNonIsoTauET_EB_EE_pass_

std::map< double, MonitorElement * >	h_efficiencyNonIsoTauET_EB_EE_total_

std::map< double, MonitorElement * >	h_efficiencyNonIsoTauET_EB_pass_

std::map< double, MonitorElement * >	h_efficiencyNonIsoTauET_EB_total_

std::map< double, MonitorElement * >	h_efficiencyNonIsoTauET_EE_pass_

std::map< double, MonitorElement * >	h_efficiencyNonIsoTauET_EE_total_

MonitorElement *	h_L1TauEtavsTauEta_

MonitorElement *	h_L1TauETvsTauET_EB_

MonitorElement *	h_L1TauETvsTauET_EB_EE_

MonitorElement *	h_L1TauETvsTauET_EE_

MonitorElement *	h_L1TauPhivsTauPhi_EB_

MonitorElement *	h_L1TauPhivsTauPhi_EB_EE_

MonitorElement *	h_L1TauPhivsTauPhi_EE_

MonitorElement *	h_nVertex_

MonitorElement *	h_resolutionTauET_EB_

MonitorElement *	h_resolutionTauET_EB_EE_

MonitorElement *	h_resolutionTauET_EE_

MonitorElement *	h_resolutionTauEta_

MonitorElement *	h_resolutionTauPhi_EB_

MonitorElement *	h_resolutionTauPhi_EB_EE_

MonitorElement *	h_resolutionTauPhi_EE_

MonitorElement *	h_tagAndProbeMass_

std::string	histFolder_

edm::ESHandle< MagneticField >	m_BField

HLTConfigProvider	m_hltConfig

BXVector< l1t::Tau >	m_L1tL1tTaus

std::vector< int >	m_L1tPtCuts

std::vector< l1t::TauBxCollection >	m_L1tTaus

float	m_MaxHltTauDR

float	m_MaxL1tTauDR

float	m_MaxTauEta

std::vector< const reco::PFTau * >	m_ProbeTaus

edm::ESHandle< Propagator >	m_propagatorAlong

edm::ESHandle< Propagator >	m_propagatorOpposite

std::vector< reco::PFTau >	m_RecoRecoTaus

std::vector< reco::PFTauCollection >	m_RecoTaus

std::vector< TauL1TPair >	m_TauL1tPairs

std::vector< const reco::Muon * >	m_TightMuons

std::vector< int >	m_trigIndices

edm::EDGetTokenT< reco::PFMETCollection >	MetInputTag_

edm::EDGetTokenT< reco::MuonCollection >	MuonInputTag_

math::XYZPoint	PVPoint_

edm::EDGetTokenT< l1t::TauBxCollection >	stage2CaloLayer2TauToken_

std::vector< double >	tauEfficiencyBins_

std::vector< int >	tauEfficiencyThresholds_

edm::EDGetTokenT< reco::PFTauCollection >	theTauCollection_

edm::EDGetTokenT< trigger::TriggerEvent >	triggerEvent_

std::vector< std::string >	triggerPath_

edm::EDGetTokenT< edm::TriggerResults >	triggerResults_

std::string	trigProcess_

edm::EDGetTokenT< reco::VertexCollection >	VtxInputTag_

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

Definition at line 80 of file L1TTauOffline.h.

Constructor & Destructor Documentation

L1TTauOffline::L1TTauOffline ( const edm::ParameterSet & ps )

Definition at line 48 of file L1TTauOffline.cc.

                                                       :
         theTauCollection_(consumes < reco::PFTauCollection > (ps.getUntrackedParameter < edm::InputTag > ("tauInputTag"))),
     AntiMuInputTag_(consumes<reco::PFTauDiscriminator>(ps.getUntrackedParameter<edm::InputTag>("antiMuInputTag"))),
     AntiEleInputTag_(consumes<reco::PFTauDiscriminator>(ps.getUntrackedParameter<edm::InputTag>("antiEleInputTag"))),
     DecayModeFindingInputTag_(consumes<reco::PFTauDiscriminator>(ps.getUntrackedParameter<edm::InputTag>("decayModeFindingInputTag"))),
     comb3TInputTag_(consumes<reco::PFTauDiscriminator>(ps.getUntrackedParameter<edm::InputTag>("comb3TInputTag"))),
     MuonInputTag_(consumes<reco::MuonCollection>(ps.getUntrackedParameter<edm::InputTag>("muonInputTag"))),
     MetInputTag_(consumes<reco::PFMETCollection>(ps.getUntrackedParameter<edm::InputTag>("metInputTag"))),
     VtxInputTag_(consumes<reco::VertexCollection>(ps.getUntrackedParameter<edm::InputTag>("vtxInputTag"))),
     BsInputTag_(consumes<reco::BeamSpot>(ps.getUntrackedParameter<edm::InputTag>("bsInputTag"))),
         triggerEvent_(consumes < trigger::TriggerEvent > (ps.getUntrackedParameter < edm::InputTag > ("trigInputTag"))),
     trigProcess_(ps.getUntrackedParameter<string>("trigProcess")),
         triggerResults_(consumes < edm::TriggerResults > (ps.getUntrackedParameter < edm::InputTag > ("trigProcess_token"))),
         triggerPath_(ps.getUntrackedParameter < vector<std::string> > ("triggerNames")),
         histFolder_(ps.getParameter < std::string > ("histFolder")),
         efficiencyFolder_(histFolder_ + "/efficiency_raw"),
         stage2CaloLayer2TauToken_(consumes < l1t::TauBxCollection > (ps.getUntrackedParameter < edm::InputTag > ("l1tInputTag"))),
         tauEfficiencyThresholds_(ps.getParameter < std::vector<int> > ("tauEfficiencyThresholds")),
         tauEfficiencyBins_(ps.getParameter < std::vector<double> > ("tauEfficiencyBins"))
 {
   edm::LogInfo("L1TTauOffline") << "Constructor " << "L1TTauOffline::L1TTauOffline " << std::endl;
 }

L1TTauOffline::~L1TTauOffline ( )

override

Definition at line 74 of file L1TTauOffline.cc.

 {
   edm::LogInfo("L1TTauOffline") << "Destructor L1TTauOffline::~L1TTauOffline " << std::endl;
 }

Member Function Documentation

void L1TTauOffline::analyze	(	edm::Event const &	e,
		edm::EventSetup const &	eSetup
	)

overrideprotectedvirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 134 of file L1TTauOffline.cc.

References ecalDrivenElectronSeedsParameters_cff::beamSpot, BXVector< T >::begin(), BsInputTag_, counter, BXVector< T >::end(), PVValHelper::eta, MonitorElement::Fill(), edm::EventSetup::get(), edm::Event::getByToken(), getPrimaryVertex(), getProbeTaus(), getTauL1tPairs(), getTightMuons(), h_efficiencyIsoTauET_EB_EE_pass_, h_efficiencyIsoTauET_EB_EE_total_, h_efficiencyIsoTauET_EB_pass_, h_efficiencyIsoTauET_EB_total_, h_efficiencyIsoTauET_EE_pass_, h_efficiencyIsoTauET_EE_total_, h_efficiencyNonIsoTauET_EB_EE_pass_, h_efficiencyNonIsoTauET_EB_EE_total_, h_efficiencyNonIsoTauET_EB_pass_, h_efficiencyNonIsoTauET_EB_total_, h_efficiencyNonIsoTauET_EE_pass_, h_efficiencyNonIsoTauET_EE_total_, h_L1TauEtavsTauEta_, h_L1TauETvsTauET_EB_, h_L1TauETvsTauET_EB_EE_, h_L1TauETvsTauET_EE_, h_L1TauPhivsTauPhi_EB_, h_L1TauPhivsTauPhi_EB_EE_, h_L1TauPhivsTauPhi_EE_, h_resolutionTauET_EB_, h_resolutionTauET_EB_EE_, h_resolutionTauET_EE_, h_resolutionTauEta_, h_resolutionTauPhi_EB_, h_resolutionTauPhi_EB_EE_, h_resolutionTauPhi_EE_, edm::HandleBase::isValid(), m_BField, m_MaxHltTauDR, m_MaxL1tTauDR, m_MaxTauEta, m_TauL1tPairs, MetInputTag_, TtSemiLepSignalSelMVAComputer_cfi::mets, MuonInputTag_, extraflags_cff::muons, phi, impactParameterTagInfos_cfi::primaryVertex, EnergyCorrector::pt, BXVector< T >::size(), stage2CaloLayer2TauToken_, AlCaHLTBitMon_QueryRunRegistry::string, metsig::tau, tauEfficiencyThresholds_, nano_cff::taus, theTauCollection_, electronIdCutBased_cfi::threshold, triggerEvent_, triggerResults_, and VtxInputTag_.

 {
 
   m_MaxTauEta   = 2.1;
   m_MaxL1tTauDR = 0.5;
   m_MaxHltTauDR = 0.5;
 
   edm::Handle<reco::PFTauCollection> taus;
   e.getByToken(theTauCollection_, taus);
 
   if(!taus.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: reco::PFTauCollection " << std::endl;
       return; 
     }
 
   edm::Handle<reco::MuonCollection> muons;
   e.getByToken(MuonInputTag_, muons);
 
   if(!muons.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: reco::MuonCollection " << std::endl;
       return; 
     }    
 
   edm::Handle<reco::BeamSpot> beamSpot;
   e.getByToken(BsInputTag_, beamSpot);
 
   if(!beamSpot.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: reco::BeamSpot " << std::endl;
       return; 
     }
 
   edm::Handle<reco::VertexCollection> vertex;
   e.getByToken(VtxInputTag_, vertex);
 
   if(!vertex.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: reco::VertexCollection " << std::endl;
       return; 
     }
 
   edm::Handle<l1t::TauBxCollection> l1tCands;               
   e.getByToken(stage2CaloLayer2TauToken_,l1tCands);
   
   if(!l1tCands.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: l1t::TauBxCollection " << std::endl;
       return;        
     }
   
   edm::Handle<edm::TriggerResults> trigResults;
   e.getByToken(triggerResults_,trigResults);
 
   if(!trigResults.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: edm::TriggerResults " << std::endl;
       return;      
     }
   
   edm::Handle<trigger::TriggerEvent> trigEvent;
   e.getByToken(triggerEvent_,trigEvent);
 
   if(!trigEvent.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: trigger::TriggerEvent " << std::endl;
       return;      
     }
 
   edm::Handle<reco::PFMETCollection> mets;
   e.getByToken(MetInputTag_, mets);
 
   if(!mets.isValid()) {
     //edm::LogError("L1TTauOffline") << "invalid collection: reco::PFMETCollection " << std::endl;
     return;
   }
 
   eSetup.get<IdealMagneticFieldRecord>().get(m_BField);                                 
   const reco::Vertex primaryVertex = getPrimaryVertex(vertex,beamSpot);
 
   getTightMuons(muons,mets,primaryVertex,trigEvent);
   getProbeTaus(e,taus,muons,primaryVertex);
   getTauL1tPairs(l1tCands);
 
   vector<l1t::Tau> l1tContainer;
   l1tContainer.reserve(l1tCands->size()+1);
 
   for (auto tau = l1tCands->begin(0); tau != l1tCands->end(0); ++tau) {
     l1tContainer.push_back(*tau);
   } 
      
   for(auto tauL1tPairsIt=m_TauL1tPairs.begin(); tauL1tPairsIt!=m_TauL1tPairs.end(); ++tauL1tPairsIt) {
 
     float eta = tauL1tPairsIt->eta();
     float phi = tauL1tPairsIt->phi();
     float pt  = tauL1tPairsIt->pt();
 
     // unmatched gmt cands have l1tPt = -1. 
     float l1tPt  = tauL1tPairsIt->l1tPt();
 
     int counter = 0;
 
     for (auto threshold : tauEfficiencyThresholds_) {
       std::string str_threshold = std::to_string(threshold);
 
       int l1tPtCut = threshold;
       bool l1tAboveCut = (l1tPt >= l1tPtCut);
 
       stringstream ptCutToTag; ptCutToTag << l1tPtCut;
       string ptTag = ptCutToTag.str();
 
       if (fabs(eta) < m_MaxTauEta) {
         if(counter==0) {
           if(fabs(eta)<1.5) {
             h_L1TauETvsTauET_EB_->Fill(pt,l1tPt);
             h_L1TauPhivsTauPhi_EB_->Fill(phi,tauL1tPairsIt->l1tPhi());
             h_resolutionTauET_EB_->Fill((l1tPt-pt)/pt);
             h_resolutionTauPhi_EB_->Fill(tauL1tPairsIt->l1tPhi()-phi);
           } else {
             h_L1TauETvsTauET_EE_->Fill(pt,l1tPt);
             h_L1TauPhivsTauPhi_EE_->Fill(phi,tauL1tPairsIt->l1tPhi());
             h_resolutionTauET_EE_->Fill((l1tPt-pt)/pt);
             h_resolutionTauPhi_EE_->Fill(tauL1tPairsIt->l1tPhi()-phi);
           }
           h_L1TauETvsTauET_EB_EE_->Fill(pt,l1tPt);
           h_L1TauPhivsTauPhi_EB_EE_->Fill(phi,tauL1tPairsIt->l1tPhi());
           h_L1TauEtavsTauEta_->Fill(eta,tauL1tPairsIt->l1tEta());
           h_resolutionTauET_EB_EE_->Fill((l1tPt-pt)/pt);
           h_resolutionTauPhi_EB_EE_->Fill(tauL1tPairsIt->l1tPhi()-phi);
           h_resolutionTauEta_->Fill(tauL1tPairsIt->l1tEta()-eta);
 
           ++counter;
         }
 
         if(fabs(eta)<1.5) {
           h_efficiencyNonIsoTauET_EB_total_[threshold]->Fill(pt);
           h_efficiencyIsoTauET_EB_total_[threshold]->Fill(pt);
         } else {
           h_efficiencyNonIsoTauET_EE_total_[threshold]->Fill(pt);
           h_efficiencyIsoTauET_EE_total_[threshold]->Fill(pt);
         }
         h_efficiencyNonIsoTauET_EB_EE_total_[threshold]->Fill(pt);
         h_efficiencyIsoTauET_EB_EE_total_[threshold]->Fill(pt);
 
         if(l1tAboveCut) {
           if(fabs(eta)<1.5) h_efficiencyNonIsoTauET_EB_pass_[threshold]->Fill(pt);
           else h_efficiencyNonIsoTauET_EE_pass_[threshold]->Fill(pt);
           h_efficiencyNonIsoTauET_EB_EE_pass_[threshold]->Fill(pt);
 
           if(tauL1tPairsIt->l1tIso()>0.5) {
             if(fabs(eta)<1.5) h_efficiencyIsoTauET_EB_pass_[threshold]->Fill(pt);
             else h_efficiencyIsoTauET_EE_pass_[threshold]->Fill(pt);
             h_efficiencyIsoTauET_EB_EE_pass_[threshold]->Fill(pt);
           }
         }
       }
     }
   }//loop over tau-L1 pairs
 }

void L1TTauOffline::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	eSetup
	)

overrideprotectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 126 of file L1TTauOffline.cc.

 {
   edm::LogInfo("L1TTauOffline") << "L1TTauOffline::beginLuminosityBlock" << std::endl;
 }

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 94 of file L1TTauOffline.cc.

References bookTauHistos(), runEdmFileComparison::found, createfilelist::int, m_hltConfig, m_trigIndices, HLTConfigProvider::size(), AlCaHLTBitMon_QueryRunRegistry::string, HLTConfigProvider::triggerName(), and triggerPath_.

 {
   edm::LogInfo("L1TTauOffline") << "L1TTauOffline::bookHistograms" << std::endl;
 
   //book at beginRun
   bookTauHistos(ibooker);
  
   for ( auto trigNamesIt = triggerPath_.begin() ; trigNamesIt!=triggerPath_.end() ; trigNamesIt++){
 
     std::string tNameTmp = (*trigNamesIt); 
     std::string tNamePattern = "";
     std::size_t found0 = tNameTmp.find("*");
     if(found0!=std::string::npos) tNamePattern = tNameTmp.substr(0,tNameTmp.size()-1);
     else tNamePattern = tNameTmp;
 
     int tIndex = -1;
     
     for (unsigned ipath = 0; ipath < m_hltConfig.size(); ++ipath) {
       
       std::string tmpName = m_hltConfig.triggerName(ipath);
       
       std::size_t found=tmpName.find(tNamePattern);
       if (found!=std::string::npos){  
     tIndex = int(ipath);
     m_trigIndices.push_back(tIndex);
       }
     }
   }
 }

void L1TTauOffline::bookTauHistos ( DQMStore::IBooker & ibooker )

private

Definition at line 314 of file L1TTauOffline.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::cd(), efficiencyFolder_, h_efficiencyIsoTauET_EB_EE_pass_, h_efficiencyIsoTauET_EB_EE_total_, h_efficiencyIsoTauET_EB_pass_, h_efficiencyIsoTauET_EB_total_, h_efficiencyIsoTauET_EE_pass_, h_efficiencyIsoTauET_EE_total_, h_efficiencyNonIsoTauET_EB_EE_pass_, h_efficiencyNonIsoTauET_EB_EE_total_, h_efficiencyNonIsoTauET_EB_pass_, h_efficiencyNonIsoTauET_EB_total_, h_efficiencyNonIsoTauET_EE_pass_, h_efficiencyNonIsoTauET_EE_total_, h_L1TauEtavsTauEta_, h_L1TauETvsTauET_EB_, h_L1TauETvsTauET_EB_EE_, h_L1TauETvsTauET_EE_, h_L1TauPhivsTauPhi_EB_, h_L1TauPhivsTauPhi_EB_EE_, h_L1TauPhivsTauPhi_EE_, h_nVertex_, h_resolutionTauET_EB_, h_resolutionTauET_EB_EE_, h_resolutionTauET_EE_, h_resolutionTauEta_, h_resolutionTauPhi_EB_, h_resolutionTauPhi_EB_EE_, h_resolutionTauPhi_EE_, h_tagAndProbeMass_, histFolder_, DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, tauEfficiencyBins_, tauEfficiencyThresholds_, and electronIdCutBased_cfi::threshold.

Referenced by bookHistograms().

 {
   ibooker.cd();
   ibooker.setCurrentFolder(histFolder_);
   h_nVertex_ = ibooker.book1D("nVertex", "Number of event vertices in collection", 40, -0.5, 39.5);
   h_tagAndProbeMass_ = ibooker.book1D("tagAndProbeMass", "Invariant mass of tag & probe pair", 100, 40, 140);
 
   h_L1TauETvsTauET_EB_ = ibooker.book2D("L1TauETvsTauET_EB",
       "L1 Tau E_{T} vs PFTau E_{T} (EB); PFTau E_{T} (GeV); L1 Tau E_{T} (GeV)", 300, 0, 300, 300,
       0, 300);
   h_L1TauETvsTauET_EE_ = ibooker.book2D("L1TauETvsTauET_EE",
       "L1 Tau E_{T} vs PFTau E_{T} (EE); PFTau E_{T} (GeV); L1 Tau E_{T} (GeV)", 300, 0, 300, 300,
       0, 300);
   h_L1TauETvsTauET_EB_EE_ = ibooker.book2D("L1TauETvsTauET_EB_EE",
       "L1 Tau E_{T} vs PFTau E_{T} (EB+EE); PFTau E_{T} (GeV); L1 Tau E_{T} (GeV)", 300, 0, 300,
       300, 0, 300);
 
   h_L1TauPhivsTauPhi_EB_ = ibooker.book2D("L1TauPhivsTauPhi_EB",
       "#phi_{tau}^{L1} vs #phi_{tau}^{offline} (EB); #phi_{tau}^{offline}; #phi_{tau}^{L1}", 100,
       -4, 4, 100, -4, 4);
   h_L1TauPhivsTauPhi_EE_ = ibooker.book2D("L1TauPhivsTauPhi_EE",
       "#phi_{tau}^{L1} vs #phi_{tau}^{offline} (EE); #phi_{tau}^{offline}; #phi_{tau}^{L1}", 100,
       -4, 4, 100, -4, 4);
   h_L1TauPhivsTauPhi_EB_EE_ = ibooker.book2D("L1TauPhivsTauPhi_EB_EE",
       "#phi_{tau}^{L1} vs #phi_{tau}^{offline} (EB+EE); #phi_{tau}^{offline}; #phi_{tau}^{L1}", 100,
       -4, 4, 100, -4, 4);
 
   h_L1TauEtavsTauEta_ = ibooker.book2D("L1TauEtavsTauEta",
       "L1 Tau #eta vs PFTau #eta; PFTau #eta; L1 Tau #eta", 100, -3, 3, 100, -3, 3);
 
   // tau resolutions
   h_resolutionTauET_EB_ = ibooker.book1D("resolutionTauET_EB",
       "tau ET resolution (EB); (L1 Tau E_{T} - PFTau E_{T})/PFTau E_{T}; events", 50, -1, 1.5);
   h_resolutionTauET_EE_ = ibooker.book1D("resolutionTauET_EE",
       "tau ET resolution (EE); (L1 Tau E_{T} - PFTau E_{T})/PFTau E_{T}; events", 50, -1, 1.5);
   h_resolutionTauET_EB_EE_ = ibooker.book1D("resolutionTauET_EB_EE",
       "tau ET resolution (EB+EE); (L1 Tau E_{T} - PFTau E_{T})/PFTau E_{T}; events", 50, -1, 1.5);
 
   h_resolutionTauPhi_EB_ =
       ibooker.book1D("resolutionTauPhi_EB",
           "#phi_{tau} resolution (EB); #phi_{tau}^{L1} - #phi_{tau}^{offline}; events",
           120, -0.3, 0.3);
   h_resolutionTauPhi_EE_ =
       ibooker.book1D("resolutionTauPhi_EE",
           "tau #phi resolution (EE); #phi_{tau}^{L1} - #phi_{tau}^{offline}; events",
           120, -0.3, 0.3);
   h_resolutionTauPhi_EB_EE_ =
       ibooker.book1D("resolutionTauPhi_EB_EE",
           "tau #phi resolution (EB+EE); #phi_{tau}^{L1} - #phi_{tau}^{offline}; events",
           120, -0.3, 0.3);
 
   h_resolutionTauEta_ = ibooker.book1D("resolutionTauEta",
       "tau #eta resolution  (EB); L1 Tau #eta - PFTau #eta; events", 120, -0.3, 0.3);
 
   // tau turn-ons
   ibooker.setCurrentFolder(efficiencyFolder_);
   std::vector<float> tauBins(tauEfficiencyBins_.begin(), tauEfficiencyBins_.end());
   int nBins = tauBins.size() - 1;
   float* tauBinArray = &(tauBins[0]);
 
   for (auto threshold : tauEfficiencyThresholds_) {
     std::string str_threshold = std::to_string(int(threshold));
     h_efficiencyIsoTauET_EB_pass_[threshold] = ibooker.book1D(
         "efficiencyIsoTauET_EB_threshold_" + str_threshold + "_Num",
         "iso tau efficiency (EB); PFTau E_{T} (GeV); events", nBins, tauBinArray);
     h_efficiencyIsoTauET_EE_pass_[threshold] = ibooker.book1D(
         "efficiencyIsoTauET_EE_threshold_" + str_threshold + "_Num",
         "iso tau efficiency (EE); PFTau E_{T} (GeV); events", nBins, tauBinArray);
     h_efficiencyIsoTauET_EB_EE_pass_[threshold] = ibooker.book1D(
         "efficiencyIsoTauET_EB_EE_threshold_" + str_threshold + "_Num",
         "iso tau efficiency (EB+EE); PFTau E_{T} (GeV); events", nBins, tauBinArray);
 
     h_efficiencyIsoTauET_EB_total_[threshold] = ibooker.book1D(
         "efficiencyIsoTauET_EB_threshold_" + str_threshold + "_Den",
         "iso tau efficiency (EB); PFTau E_{T} (GeV); events", nBins, tauBinArray);
     h_efficiencyIsoTauET_EE_total_[threshold] = ibooker.book1D(
         "efficiencyIsoTauET_EE_threshold_" + str_threshold + "_Den",
         "iso tau efficiency (EE); PFTau E_{T} (GeV); events", nBins, tauBinArray);
     h_efficiencyIsoTauET_EB_EE_total_[threshold] = ibooker.book1D(
         "efficiencyIsoTauET_EB_EE_threshold_" + str_threshold + "_Den",
         "iso tau efficiency (EB+EE); PFTau E_{T} (GeV); events", nBins, tauBinArray);
 
 
     //non iso
     h_efficiencyNonIsoTauET_EB_pass_[threshold] = ibooker.book1D(
         "efficiencyNonIsoTauET_EB_threshold_" + str_threshold + "_Num",
         "inclusive tau efficiency (EB); PFTau E_{T} (GeV); events", nBins, tauBinArray);
     h_efficiencyNonIsoTauET_EE_pass_[threshold] = ibooker.book1D(
         "efficiencyNonIsoTauET_EE_threshold_" + str_threshold + "_Num",
         "inclusive tau efficiency (EE); PFTau E_{T} (GeV); events", nBins, tauBinArray);
     h_efficiencyNonIsoTauET_EB_EE_pass_[threshold] = ibooker.book1D(
         "efficiencyNonIsoTauET_EB_EE_threshold_" + str_threshold + "_Num",
         "inclusive tau efficiency (EB+EE); PFTau E_{T} (GeV); events", nBins, tauBinArray);
 
     h_efficiencyNonIsoTauET_EB_total_[threshold] = ibooker.book1D(
         "efficiencyNonIsoTauET_EB_threshold_" + str_threshold + "_Den",
         "inclusive tau efficiency (EB); PFTau E_{T} (GeV); events", nBins, tauBinArray);
     h_efficiencyNonIsoTauET_EE_total_[threshold] = ibooker.book1D(
         "efficiencyNonIsoTauET_EE_threshold_" + str_threshold + "_Den",
         "inclusive tau efficiency (EE); PFTau E_{T} (GeV); events", nBins, tauBinArray);
     h_efficiencyNonIsoTauET_EB_EE_total_[threshold] = ibooker.book1D(
         "efficiencyNonIsoTauET_EB_EE_threshold_" + str_threshold + "_Den",
         "inclusive tau efficiency (EB+EE); PFTau E_{T} (GeV); events", nBins, tauBinArray);
 
   }
 
   ibooker.cd();
 
   return;
 
 }

double L1TTauOffline::calcDeltaPhi	(	double	phi1,
		double	phi2
	)

private

double L1TTauOffline::Distance	(	const reco::Candidate &	c1,
		const reco::Candidate &	c2
	)

private

double L1TTauOffline::DistancePhi	(	const reco::Candidate &	c1,
		const reco::Candidate &	c2
	)

private

void L1TTauOffline::dqmBeginRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

overrideprotected

Definition at line 82 of file L1TTauOffline.cc.

References HLTConfigProvider::init(), m_hltConfig, and trigProcess_.

 {
   bool changed = true;
   m_hltConfig.init(run,iSetup,trigProcess_,changed);
 
   edm::LogInfo("L1TTauOffline") << "L1TTauOffline::beginRun" << std::endl;
 }

void L1TTauOffline::endLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	eSetup
	)

overrideprotectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 298 of file L1TTauOffline.cc.

 {
   edm::LogInfo("L1TTauOffline") << "L1TTauOffline::endLuminosityBlock" << std::endl;
 }

void L1TTauOffline::endRun	(	edm::Run const &	run,
		edm::EventSetup const &	eSetup
	)

overrideprotectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 306 of file L1TTauOffline.cc.

 {
   edm::LogInfo("L1TTauOffline") << "L1TTauOffline::endRun" << std::endl;
 }

const reco::Vertex L1TTauOffline::getPrimaryVertex	(	edm::Handle< reco::VertexCollection > const &	vertex,
		edm::Handle< reco::BeamSpot > const &	beamSpot
	)

protected

Definition at line 426 of file L1TTauOffline.cc.

References reco::BeamSpot::BeamWidthX(), reco::BeamSpot::BeamWidthY(), edm::HandleBase::isValid(), reco::BeamSpot::position(), reco::Vertex::position(), impactParameterTagInfos_cfi::primaryVertex, and reco::BeamSpot::sigmaZ().

Referenced by analyze().

                                                                                                                                          {
   
   reco::Vertex::Point posVtx;
   reco::Vertex::Error errVtx;
   
   bool hasPrimaryVertex = false;
 
   if (vertex.isValid())
     {
       for (auto vertexIt=vertex->begin();vertexIt!=vertex->end();++vertexIt) 
     {
       if (vertexIt->isValid() && 
           !vertexIt->isFake()) 
         {
           posVtx = vertexIt->position();
           errVtx = vertexIt->error();
           hasPrimaryVertex = true;        
           break;
         }
     }
     }
 
   if ( !hasPrimaryVertex ) {
     posVtx = beamSpot->position();
     errVtx(0,0) = beamSpot->BeamWidthX();
     errVtx(1,1) = beamSpot->BeamWidthY();
     errVtx(2,2) = beamSpot->sigmaZ();
   }
 
   const reco::Vertex primaryVertex(posVtx,errVtx);
   
   return primaryVertex;
 }

void L1TTauOffline::getProbeTaus	(	const edm::Event &	e,
		edm::Handle< reco::PFTauCollection > const &	taus,
		edm::Handle< reco::MuonCollection > const &	muons,
		const reco::Vertex &	vertex
	)

protected

Definition at line 551 of file L1TTauOffline.cc.

References AntiEleInputTag_, AntiMuInputTag_, comb3TInputTag_, DecayModeFindingInputTag_, DEFINE_FWK_MODULE, PVValHelper::eta, edm::Event::getByToken(), edm::HandleBase::isValid(), m_ProbeTaus, m_TightMuons, phi, and EnergyCorrector::pt.

Referenced by analyze().

                                                                                                                                                                           {
 
   m_ProbeTaus.clear();
 
   edm::Handle<reco::PFTauDiscriminator> antimu;
   iEvent.getByToken(AntiMuInputTag_, antimu);
   if(!antimu.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: reco::PFTauDiscriminator " << std::endl;
       return;  
     }
 
   edm::Handle<reco::PFTauDiscriminator> dmf;
   iEvent.getByToken(DecayModeFindingInputTag_, dmf);
   if(!dmf.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: reco::PFTauDiscriminator " << std::endl;
       return;  
     }
 
   edm::Handle<reco::PFTauDiscriminator> antiele;
   iEvent.getByToken(AntiEleInputTag_, antiele);
   if(!antiele.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: reco::PFTauDiscriminator " << std::endl;
       return;  
     }
 
   edm::Handle<reco::PFTauDiscriminator> comb3T;
   iEvent.getByToken(comb3TInputTag_, comb3T);
   if(!comb3T.isValid())
     {
       //edm::LogError("L1TTauOffline") << "invalid collection: reco::PFTauDiscriminator " << std::endl;
       return;  
     }
 
   if (!m_TightMuons.empty()){
      TLorentzVector mymu;
      mymu.SetPtEtaPhiE(m_TightMuons[0]->pt(),m_TightMuons[0]->eta(),m_TightMuons[0]->phi(),m_TightMuons[0]->energy());
      int iTau=0;
      for(auto tauIt  = taus->begin(); tauIt!=taus->end(); ++tauIt,++iTau) {
         reco::PFTauRef tauCandidate(taus, iTau);
     TLorentzVector mytau;
     mytau.SetPtEtaPhiE(tauIt->pt(),tauIt->eta(),tauIt->phi(),tauIt->energy());
 
         if (fabs(tauIt->charge())==1 && fabs(tauIt->eta())< 2.1 && tauIt->pt()>20 && (*antimu)[tauCandidate] > 0.5 && (*antiele)[tauCandidate] > 0.5 && (*dmf)[tauCandidate] > 0.5 && (*comb3T)[tauCandidate] > 0.5) {
         if (mymu.DeltaR(mytau)>0.5 && (mymu+mytau).M()>40 && (mymu+mytau).M()<80 && m_TightMuons[0]->charge()*tauIt->charge()<0){
                m_ProbeTaus.push_back(&(*tauIt));
         }
         }
      }
   }
 }

void L1TTauOffline::getTauL1tPairs ( edm::Handle< l1t::TauBxCollection > const & l1tCands )

protected

Definition at line 492 of file L1TTauOffline.cc.

References BXVector< T >::begin(), TauL1TPair::dR(), BXVector< T >::end(), TauL1TPair::l1tPt(), m_MaxL1tTauDR, m_ProbeTaus, m_TauL1tPairs, BXVector< T >::size(), and metsig::tau.

Referenced by analyze().

                                                                                 {                   
 
   m_TauL1tPairs.clear();
   
   vector<l1t::Tau> l1tContainer;
   l1tContainer.reserve(l1tCands->size()+1);
   
   for (auto tau = l1tCands->begin(0); tau != l1tCands->end(0); ++tau) {
     l1tContainer.push_back(*tau);
   }
             
   for (auto probeTauIt = m_ProbeTaus.begin(); probeTauIt!=m_ProbeTaus.end(); ++probeTauIt) {    
 
     TauL1TPair pairBestCand((*probeTauIt),nullptr);    
     
     for(auto l1tIt =  l1tContainer.begin() ; l1tIt!=l1tContainer.end(); ++l1tIt) {
       
       TauL1TPair pairTmpCand((*probeTauIt),&(*l1tIt));
 
       if (pairTmpCand.dR() < m_MaxL1tTauDR && pairTmpCand.l1tPt() > pairBestCand.l1tPt())
     pairBestCand = pairTmpCand;
 
     }
 
     m_TauL1tPairs.push_back(pairBestCand);
   
   }
 
 }

void L1TTauOffline::getTightMuons	(	edm::Handle< reco::MuonCollection > const &	muons,
		edm::Handle< reco::PFMETCollection > const &	mets,
		const reco::Vertex &	vertex,
		edm::Handle< trigger::TriggerEvent > const &	trigEvent
	)

protected

Definition at line 522 of file L1TTauOffline.cc.

References muon::isLooseMuon(), m_TightMuons, matchHlt(), SiStripPI::max, TtSemiLepEvtBuilder_cfi::mt, funct::pow(), reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), and mathSSE::sqrt().

Referenced by analyze().

                                                                                                                                                                                                      {
 
   m_TightMuons.clear();
 
   const reco::PFMET *pfmet=nullptr;
   pfmet=&(mets->front());
 
   int nb_mu=0;
 
   for(auto muonIt2 = muons->begin(); muonIt2!=muons->end(); ++muonIt2) {
     if (fabs(muonIt2->eta())< 2.4 && muonIt2->pt()>10 && muon::isLooseMuon((*muonIt2)) && (muonIt2->pfIsolationR04().sumChargedHadronPt+max(muonIt2->pfIsolationR04().sumNeutralHadronEt+muonIt2->pfIsolationR04().sumPhotonEt-0.5*muonIt2->pfIsolationR04().sumPUPt,0.0))/muonIt2->pt()<0.3) {
       ++nb_mu;
     }
   }
   bool foundTightMu=false;
   for(auto muonIt = muons->begin(); muonIt!=muons->end(); ++muonIt) {
     if (!matchHlt(trigEvent,&(*muonIt))) continue;
     float muiso=(muonIt->pfIsolationR04().sumChargedHadronPt+max(muonIt->pfIsolationR04().sumNeutralHadronEt+muonIt->pfIsolationR04().sumPhotonEt-0.5*muonIt->pfIsolationR04().sumPUPt,0.0))/muonIt->pt();
 
     if (muiso<0.1 && nb_mu<2 && !foundTightMu && fabs(muonIt->eta())< 2.1 && muonIt->pt()>24 && muon::isLooseMuon((*muonIt))) {
       float mt=sqrt(pow(muonIt->pt() + pfmet->pt(), 2) - pow(muonIt->px() + pfmet->px(),2) - pow(muonIt->py() + pfmet->py(), 2));
       if (mt<30){
          m_TightMuons.push_back(&(*muonIt));
          foundTightMu=true;
       } 
     }
   }
 }

bool L1TTauOffline::matchHlt	(	edm::Handle< trigger::TriggerEvent > const &	triggerEvent,
		const reco::Muon *	muon
	)

protected

Definition at line 460 of file L1TTauOffline.cc.

References deltaR(), trigger::TriggerEvent::filterIds(), trigger::TriggerEvent::filterIndex(), trigger::TriggerEvent::filterKeys(), trigger::TriggerEvent::getObjects(), m_hltConfig, m_MaxHltTauDR, m_trigIndices, HLTConfigProvider::moduleLabels(), HLTConfigProvider::size(), TriggerAnalyzer::trigObjs, and trigProcess_.

Referenced by getTightMuons().

                                                                                                       {
 
 
   double matchDeltaR = 9999;
 
   trigger::TriggerObjectCollection trigObjs = triggerEvent->getObjects();
 
   for(auto trigIndexIt = m_trigIndices.begin(); trigIndexIt!=m_trigIndices.end(); ++trigIndexIt) {
 
     const vector<string> moduleLabels(m_hltConfig.moduleLabels(*trigIndexIt));
     const unsigned moduleIndex = m_hltConfig.size((*trigIndexIt))-2;
 
     const unsigned hltFilterIndex = triggerEvent->filterIndex(InputTag(moduleLabels[moduleIndex],"",trigProcess_));
     
     if (hltFilterIndex < triggerEvent->sizeFilters()) {
       const Keys triggerKeys(triggerEvent->filterKeys(hltFilterIndex));
       const Vids triggerVids(triggerEvent->filterIds(hltFilterIndex));
       
       const unsigned nTriggers = triggerVids.size();
       for (size_t iTrig = 0; iTrig < nTriggers; ++iTrig) {
         const TriggerObject trigObject = trigObjs[triggerKeys[iTrig]];
     
         double dRtmp = deltaR((*muon),trigObject);
         if (dRtmp < matchDeltaR) matchDeltaR = dRtmp;
       }
     }
   }
   
   return (matchDeltaR < m_MaxHltTauDR);
 
 }