#include <HLTTauDQMPathPlotter.h>

Inheritance diagram for HLTTauDQMPathPlotter:

Public Types
typedef std::tuple < std::string, size_t >	FilterIndex

Public Member Functions
void	analyze (const edm::TriggerResults &triggerResults, const trigger::TriggerEvent &triggerEvent, const HLTTauDQMOfflineObjects &refCollection)

void	bookHistograms (DQMStore::IBooker &iBooker)

const HLTTauDQMPath *	getPathObject () const

	HLTTauDQMPathPlotter (const std::string &pathName, const HLTConfigProvider &HLTCP, bool doRefAnalysis, const std::string &dqmBaseFolder, const std::string &hltProcess, int ptbins, int etabins, int phibins, double ptmax, double highptmax, double l1MatchDr, double hltMatchDr)

	~HLTTauDQMPathPlotter ()

Private Attributes
const bool	doRefAnalysis_

const int	etabins_

MonitorElement *	hAcceptedEvents_

const double	highptmax_

MonitorElement *	hL2TrigTauEtaEffDenom_

MonitorElement *	hL2TrigTauEtaEffNum_

MonitorElement *	hL2TrigTauEtEffDenom_

MonitorElement *	hL2TrigTauEtEffNum_

MonitorElement *	hL2TrigTauHighEtEffDenom_

MonitorElement *	hL2TrigTauHighEtEffNum_

MonitorElement *	hL2TrigTauPhiEffDenom_

MonitorElement *	hL2TrigTauPhiEffNum_

MonitorElement *	hL3TrigTauEtaEffDenom_

MonitorElement *	hL3TrigTauEtaEffNum_

MonitorElement *	hL3TrigTauEtEffDenom_

MonitorElement *	hL3TrigTauEtEffNum_

MonitorElement *	hL3TrigTauHighEtEffDenom_

MonitorElement *	hL3TrigTauHighEtEffNum_

MonitorElement *	hL3TrigTauPhiEffDenom_

MonitorElement *	hL3TrigTauPhiEffNum_

const double	hltMatchDr_

HLTTauDQMPath	hltPath_

MonitorElement *	hMass_

MonitorElement *	hTrigTauEt_

MonitorElement *	hTrigTauEta_

MonitorElement *	hTrigTauPhi_

const double	l1MatchDr_

const int	phibins_

const int	ptbins_

const double	ptmax_

Private Attributes inherited from HLTTauDQMPlotter
bool	configValid_

std::string	dqmFolder_

std::string	dqmFullFolder_

Additional Inherited Members
Private Member Functions inherited from HLTTauDQMPlotter
	HLTTauDQMPlotter (const edm::ParameterSet &pset, const std::string &dqmBaseFolder)

	HLTTauDQMPlotter (const std::string &dqmFolder, const std::string &dqmBaseFolder)

bool	isValid () const

	~HLTTauDQMPlotter ()

std::pair< bool, LV >	match (const LV &, const LVColl &, double)

const std::string &	triggerTag () const

Detailed Description

Definition at line 21 of file HLTTauDQMPathPlotter.h.

Member Typedef Documentation

typedef std::tuple<std::string, size_t> HLTTauDQMPathPlotter::FilterIndex

Definition at line 38 of file HLTTauDQMPathPlotter.h.

Constructor & Destructor Documentation

HLTTauDQMPathPlotter::HLTTauDQMPathPlotter	(	const std::string &	pathName,
		const HLTConfigProvider &	HLTCP,
		bool	doRefAnalysis,
		const std::string &	dqmBaseFolder,
		const std::string &	hltProcess,
		int	ptbins,
		int	etabins,
		int	phibins,
		double	ptmax,
		double	highptmax,
		double	l1MatchDr,
		double	hltMatchDr
	)

Definition at line 15 of file HLTTauDQMPathPlotter.cc.

References HLTTauDQMPlotter::configValid_, hltPath_, and HLTTauDQMPath::isValid().

                                                                                :
   HLTTauDQMPlotter(stripVersion(pathName), dqmBaseFolder),
   ptbins_(ptbins),
   etabins_(etabins),
   phibins_(phibins),
   ptmax_(ptmax),
   highptmax_(highptmax),
   l1MatchDr_(l1MatchDr),
   hltMatchDr_(hltMatchDr),
   doRefAnalysis_(doRefAnalysis),
   hltPath_(pathName, hltProcess, doRefAnalysis_, HLTCP)
 {
   configValid_ = configValid_ && hltPath_.isValid();
 }

HLTTauDQMPathPlotter::~HLTTauDQMPathPlotter ( )

Definition at line 102 of file HLTTauDQMPathPlotter.cc.

102 {}

Member Function Documentation

void HLTTauDQMPathPlotter::analyze	(	const edm::TriggerResults &	triggerResults,
		const trigger::TriggerEvent &	triggerEvent,
		const HLTTauDQMOfflineObjects &	refCollection
	)

Definition at line 104 of file HLTTauDQMPathPlotter.cc.

                                                                                                                                                                  {
 
   std::vector<HLTTauDQMPath::Object> triggerObjs;
   std::vector<HLTTauDQMPath::Object> matchedTriggerObjs;
   HLTTauDQMOfflineObjects matchedOfflineObjs;
 
   // Events per filter
   const int lastPassedFilter = hltPath_.lastPassedFilter(triggerResults);
   int lastMatchedFilter = -1;
   //std::cout << "Last passed filter " << lastPassedFilter << " " << (lastPassedFilter >= 0 ? hltPath_.getFilterName(lastPassedFilter) : "") << std::endl;
   if(doRefAnalysis_) {
     double matchDr = hltPath_.isFirstFilterL1Seed() ? l1MatchDr_ : hltMatchDr_;
     for(int i=0; i<=lastPassedFilter; ++i) {
       triggerObjs.clear();
       matchedTriggerObjs.clear();
       matchedOfflineObjs.clear();
       hltPath_.getFilterObjects(triggerEvent, i, triggerObjs);
       //std::cout << "Filter name " << hltPath_.getFilterName(i) << " nobjs " << triggerObjs.size() << std::endl;
       bool matched = hltPath_.offlineMatching(i, triggerObjs, refCollection, matchDr, matchedTriggerObjs, matchedOfflineObjs);
       //std::cout << "  offline matching: " << matched << std::endl;
       matchDr = hltMatchDr_;
       if(!matched)
         break;
 
       hAcceptedEvents_->Fill(i+0.5);
       lastMatchedFilter = i;
     }
   }
   else {
     for(int i=0; i<=lastPassedFilter; ++i) {
       hAcceptedEvents_->Fill(i+0.5);
     }
   }
 
   // Efficiency plots
   if(doRefAnalysis_ && lastMatchedFilter >= 0) {
     // L2 taus
     if(hltPath_.hasL2Taus()) {
       // Denominators
       if(static_cast<size_t>(lastMatchedFilter) >= hltPath_.getLastFilterBeforeL2TauIndex()) {
         for(const LV& tau: refCollection.taus) {
           hL2TrigTauEtEffDenom_->Fill(tau.pt());
           hL2TrigTauHighEtEffDenom_->Fill(tau.pt());
           hL2TrigTauEtaEffDenom_->Fill(tau.eta());
           hL2TrigTauPhiEffDenom_->Fill(tau.phi());
         }
       }
 
       // Numerators
       if(static_cast<size_t>(lastMatchedFilter) >= hltPath_.getLastL2TauFilterIndex()) {
         triggerObjs.clear();
         matchedTriggerObjs.clear();
         matchedOfflineObjs.clear();
         hltPath_.getFilterObjects(triggerEvent, hltPath_.getLastL2TauFilterIndex(), triggerObjs);
         bool matched = hltPath_.offlineMatching(hltPath_.getLastL2TauFilterIndex(), triggerObjs, refCollection, hltMatchDr_, matchedTriggerObjs, matchedOfflineObjs);
         if(matched) {
           for(const LV& tau: matchedOfflineObjs.taus) {
             hL2TrigTauEtEffNum_->Fill(tau.pt());
             hL2TrigTauHighEtEffNum_->Fill(tau.pt());
             hL2TrigTauEtaEffNum_->Fill(tau.eta());
             hL2TrigTauPhiEffNum_->Fill(tau.phi());
           }
         }
       }
     }
 
     // L3 taus
     if(hltPath_.hasL3Taus()) {
       // Denominators
       if(static_cast<size_t>(lastMatchedFilter) >= hltPath_.getLastFilterBeforeL3TauIndex()) {
         for(const LV& tau: refCollection.taus) {
           hL3TrigTauEtEffDenom_->Fill(tau.pt());
           hL3TrigTauHighEtEffDenom_->Fill(tau.pt());
           hL3TrigTauEtaEffDenom_->Fill(tau.eta());
           hL3TrigTauPhiEffDenom_->Fill(tau.phi());
         }
       }
 
       // Numerators
       if(static_cast<size_t>(lastMatchedFilter) >= hltPath_.getLastL3TauFilterIndex()) {
         triggerObjs.clear();
         matchedTriggerObjs.clear();
         matchedOfflineObjs.clear();
         hltPath_.getFilterObjects(triggerEvent, hltPath_.getLastL3TauFilterIndex(), triggerObjs);
         bool matched = hltPath_.offlineMatching(hltPath_.getLastL3TauFilterIndex(), triggerObjs, refCollection, hltMatchDr_, matchedTriggerObjs, matchedOfflineObjs);
         if(matched) {
           for(const LV& tau: matchedOfflineObjs.taus) {
             hL3TrigTauEtEffNum_->Fill(tau.pt());
             hL3TrigTauHighEtEffNum_->Fill(tau.pt());
             hL3TrigTauEtaEffNum_->Fill(tau.eta());
             hL3TrigTauPhiEffNum_->Fill(tau.phi());
           }
         }
       }
     }
   }
 
   if(hltPath_.fired(triggerResults)) {
     triggerObjs.clear();
     matchedTriggerObjs.clear();
     matchedOfflineObjs.clear();
     hltPath_.getFilterObjects(triggerEvent, lastPassedFilter, triggerObjs);
     if(doRefAnalysis_) {
       bool matched = hltPath_.offlineMatching(lastPassedFilter, triggerObjs, refCollection, hltMatchDr_, matchedTriggerObjs, matchedOfflineObjs);
       if(matched) {
         // Di-object invariant mass
         if(hMass_) {
           const int ntaus = hltPath_.getFilterNTaus(lastPassedFilter);
           if(ntaus == 2) {
             // Di-tau (matchedOfflineObjs are already sorted)
             hMass_->Fill( (matchedOfflineObjs.taus[0]+matchedOfflineObjs.taus[1]).M() );
           }
           // Electron+tau
           else if(ntaus == 1 && hltPath_.getFilterNElectrons(lastPassedFilter) == 1) {
             hMass_->Fill( (matchedOfflineObjs.taus[0]+matchedOfflineObjs.electrons[0]).M() );
           }
           // Muon+tau
           else if(ntaus == 1 && hltPath_.getFilterNMuons(lastPassedFilter) == 1) {
             hMass_->Fill( (matchedOfflineObjs.taus[0]+matchedOfflineObjs.muons[0]).M() );
           }
         }
       }
 
       if(matched)
         triggerObjs.swap(matchedTriggerObjs);
       else
         triggerObjs.clear();
     }
 
     // Triggered tau kinematics
     for(const HLTTauDQMPath::Object& obj: triggerObjs) {
       if(obj.id != trigger::TriggerTau)
         continue;
       hTrigTauEt_->Fill(obj.object.pt());
       hTrigTauEta_->Fill(obj.object.eta());
       hTrigTauPhi_->Fill(obj.object.phi());
     }
   }
 }

void HLTTauDQMPathPlotter::bookHistograms ( DQMStore::IBooker & iBooker )

Definition at line 34 of file HLTTauDQMPathPlotter.cc.

References DQMStore::IBooker::book1D(), SurfaceDeformationFactory::create(), doRefAnalysis_, etabins_, HLTTauDQMPath::filtersSize(), HLTTauDQMPath::getFilterName(), HLTTauDQMPath::getFilterNElectrons(), HLTTauDQMPath::getFilterNMuons(), HLTTauDQMPath::getFilterNTaus(), HLTTauDQMPath::getPathName(), hAcceptedEvents_, HLTTauDQMPath::hasL2Taus(), HLTTauDQMPath::hasL3Taus(), highptmax_, hL2TrigTauEtaEffDenom_, hL2TrigTauEtaEffNum_, hL2TrigTauEtEffDenom_, hL2TrigTauEtEffNum_, hL2TrigTauHighEtEffDenom_, hL2TrigTauHighEtEffNum_, hL2TrigTauPhiEffDenom_, hL2TrigTauPhiEffNum_, hL3TrigTauEtaEffDenom_, hL3TrigTauEtaEffNum_, hL3TrigTauEtEffDenom_, hL3TrigTauEtEffNum_, hL3TrigTauHighEtEffDenom_, hL3TrigTauHighEtEffNum_, hL3TrigTauPhiEffDenom_, hL3TrigTauPhiEffNum_, hltPath_, hMass_, hTrigTauEt_, hTrigTauEta_, hTrigTauPhi_, i, HLTTauDQMPlotter::isValid(), LogDebug, mergeVDriftHistosByStation::name, phibins_, ptbins_, ptmax_, MonitorElement::setBinLabel(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, and HLTTauDQMPlotter::triggerTag().

                                                                   {
   if(!isValid())
     return;
 
   // Book histograms
   iBooker.setCurrentFolder(triggerTag());
 
   hAcceptedEvents_ = iBooker.book1D("EventsPerFilter", "Accepted Events per filter;;entries", hltPath_.filtersSize(), 0, hltPath_.filtersSize());
   for(size_t i=0; i<hltPath_.filtersSize(); ++i) {
     hAcceptedEvents_->setBinLabel(i+1, hltPath_.getFilterName(i));
   }
 
   hTrigTauEt_ = iBooker.book1D("TrigTauEt",   "Triggered #tau p_{T};#tau p_{T};entries", ptbins_,     0, ptmax_);
   hTrigTauEta_ = iBooker.book1D("TrigTauEta", "Triggered #tau #eta;#tau #eta;entries",  etabins_, -2.5, 2.5);
   hTrigTauPhi_ = iBooker.book1D("TrigTauPhi", "Triggered #tau #phi;#tau #phi;entries",  phibins_, -3.2, 3.2);
 
   // Efficiency helpers
   if(doRefAnalysis_) {
     iBooker.setCurrentFolder(triggerTag()+"/helpers");
     if(hltPath_.hasL2Taus()) {
       hL2TrigTauEtEffNum_    = iBooker.book1D("L2TrigTauEtEffNum",    "L2 #tau p_{T} efficiency;Ref #tau p_{T};entries", ptbins_, 0, ptmax_);
       hL2TrigTauEtEffDenom_  = iBooker.book1D("L2TrigTauEtEffDenom",  "L2 #tau p_{T} denominator;Ref #tau p_{T};Efficiency", ptbins_, 0, ptmax_);
       hL2TrigTauEtaEffNum_   = iBooker.book1D("L2TrigTauEtaEffNum",   "L2 #tau #eta efficiency;Ref #tau #eta;entries", etabins_, -2.5, 2.5);
       hL2TrigTauEtaEffDenom_ = iBooker.book1D("L2TrigTauEtaEffDenom", "L2 #tau #eta denominator;Ref #tau #eta;Efficiency", etabins_, -2.5, 2.5);
       hL2TrigTauPhiEffNum_   = iBooker.book1D("L2TrigTauPhiEffNum",   "L2 #tau #phi efficiency;Ref #tau #phi;entries", phibins_, -3.2, 3.2);
       hL2TrigTauPhiEffDenom_ = iBooker.book1D("L2TrigTauPhiEffDenom", "L2 #tau #phi denominator;Ref #tau #phi;Efficiency", phibins_, -3.2, 3.2);
       hL2TrigTauHighEtEffNum_   = iBooker.book1D("L2TrigTauHighEtEffNum",    "L2 #tau p_{T} efficiency (high p_{T});Ref #tau p_{T};entries", ptbins_, 0, highptmax_);
       hL2TrigTauHighEtEffDenom_ = iBooker.book1D("L2TrigTauHighEtEffDenom",  "L2 #tau p_{T} denominator (high p_{T});Ref #tau p_{T};Efficiency", ptbins_, 0, highptmax_);
     }
 
     if(hltPath_.hasL3Taus()) {
       hL3TrigTauEtEffNum_    = iBooker.book1D("L3TrigTauEtEffNum",    "L3 #tau p_{T} efficiency;Ref #tau p_{T};entries", ptbins_, 0, ptmax_);
       hL3TrigTauEtEffDenom_  = iBooker.book1D("L3TrigTauEtEffDenom",  "L3 #tau p_{T} denominator;Ref #tau p_{T};Efficiency", ptbins_, 0, ptmax_);
       hL3TrigTauEtaEffNum_   = iBooker.book1D("L3TrigTauEtaEffNum",   "L3 #tau #eta efficiency;Ref #tau #eta;entries", etabins_, -2.5, 2.5);
       hL3TrigTauEtaEffDenom_ = iBooker.book1D("L3TrigTauEtaEffDenom", "L3 #tau #eta denominator;Ref #tau #eta;Efficiency", etabins_, -2.5, 2.5);
       hL3TrigTauPhiEffNum_   = iBooker.book1D("L3TrigTauPhiEffNum",   "L3 #tau #phi efficiency;Ref #tau #phi;entries", phibins_, -3.2, 3.2);
       hL3TrigTauPhiEffDenom_ = iBooker.book1D("L3TrigTauPhiEffDenom", "L3 #tau #phi denominator;Ref #tau #phi;Efficiency", phibins_, -3.2, 3.2);
       hL3TrigTauHighEtEffNum_    = iBooker.book1D("L3TrigTauHighEtEffNum",    "L3 #tau p_{T} efficiency (high p_{T});Ref #tau p_{T};entries", ptbins_, 0, highptmax_);
       hL3TrigTauHighEtEffDenom_  = iBooker.book1D("L3TrigTauHighEtEffDenom",  "L3 #tau p_{T} denominator (high p_{T});Ref #tau p_{T};Efficiency", ptbins_, 0, highptmax_);
     }
     iBooker.setCurrentFolder(triggerTag());
   }
 
   // Book di-object invariant mass histogram only for mu+tau, ele+tau, and di-tau paths
   hMass_ = nullptr;
   if(doRefAnalysis_) {
     const int lastFilter = hltPath_.filtersSize()-1;
     const int ntaus = hltPath_.getFilterNTaus(lastFilter);
     const int neles = hltPath_.getFilterNElectrons(lastFilter);
     const int nmus = hltPath_.getFilterNMuons(lastFilter);
     auto create = [&](const std::string& name) {
       this->hMass_ = iBooker.book1D("ReferenceMass", "Invariant mass of reference "+name+";Reference invariant mass;entries", 100, 0, 500);
     };
 
     LogDebug("HLTTauDQMOffline") << "Path " << hltPath_.getPathName() << " number of taus " << ntaus << " electrons " << neles << " muons " << nmus;
 
     if(ntaus == 2)
       create("di-tau");
     else if(ntaus == 1) {
       if(neles == 1)
         create("electron-tau");
       else if(nmus == 1)
         create("muon-tau");
     }
   }
 }