HLTTauDQMPath Class Reference

#include <HLTTauDQMPath.h>

Classes
struct	Object

Public Types
typedef std::tuple < std::string, size_t >	FilterIndex
typedef math::XYZTLorentzVectorD	LV
typedef std::vector< LV >	LVColl

Public Member Functions
size_t	filtersSize () const
bool	fired (const edm::TriggerResults &triggerResults) const
size_t	getFilterIndex (size_t i) const
const std::string &	getFilterName (size_t i) const
int	getFilterNElectrons (size_t i) const
int	getFilterNMuons (size_t i) const
int	getFilterNTaus (size_t i) const
void	getFilterObjects (const trigger::TriggerEvent &triggerEvent, size_t i, std::vector< Object > &retval) const
size_t	getLastFilterBeforeL2TauIndex () const
size_t	getLastFilterBeforeL3TauIndex () const
const std::string &	getLastFilterName () const
size_t	getLastL2TauFilterIndex () const
size_t	getLastL3TauFilterIndex () const
const unsigned int	getPathIndex () const
const std::string &	getPathName () const
bool	goodOfflineEvent (size_t i, const HLTTauDQMOfflineObjects &offlineObjects) const
bool	hasL2Taus () const
bool	hasL3Taus () const
	HLTTauDQMPath (const std::string &pathName, const std::string &hltProcess, bool doRefAnalysis, const HLTConfigProvider &HLTCP)
bool	isFirstFilterL1Seed () const
bool	isValid () const
int	lastPassedFilter (const edm::TriggerResults &triggerResults) const
bool	offlineMatching (size_t i, const std::vector< Object > &triggerObjects, const HLTTauDQMOfflineObjects &offlineObjects, double dR, std::vector< Object > &matchedTriggerObjects, HLTTauDQMOfflineObjects &matchedOfflineObjects) const
	~HLTTauDQMPath ()

Static Public Attributes
static constexpr size_t	kInvalidIndex = std::numeric_limits<size_t>::max()
static constexpr size_t	kModuleIndex = 1
static constexpr size_t	kName = 0

Private Attributes
const bool	doRefAnalysis_
std::vector< int >	filterElectronN_
std::vector< FilterIndex >	filterIndices_
std::vector< int >	filterMuonN_
std::vector< int >	filterTauN_
const std::string	hltProcess_
bool	isFirstL1Seed_
bool	isValid_
size_t	lastFilterBeforeL2TauIndex_
size_t	lastFilterBeforeL3TauIndex_
size_t	lastL2TauFilterIndex_
size_t	lastL3TauFilterIndex_
const unsigned int	pathIndex_
const std::string	pathName_

Detailed Description

Definition at line 22 of file HLTTauDQMPath.h.

Member Typedef Documentation

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

Definition at line 26 of file HLTTauDQMPath.h.

typedef math::XYZTLorentzVectorD HLTTauDQMPath::LV

Definition at line 24 of file HLTTauDQMPath.h.

typedef std::vector<LV> HLTTauDQMPath::LVColl

Definition at line 25 of file HLTTauDQMPath.h.

Constructor & Destructor Documentation

HLTTauDQMPath::HLTTauDQMPath	(	const std::string &	pathName,
		const std::string &	hltProcess,
		bool	doRefAnalysis,
		const HLTConfigProvider &	HLTCP
	)

Definition at line 233 of file HLTTauDQMPath.cc.

References doRefAnalysis_, filterElectronN_, filterIndices_, filterMuonN_, filtersSize(), filterTauN_, getFilterIndex(), getFilterNElectrons(), getFilterNMuons(), getFilterNTaus(), EcalActivitySkim_cff::HLTPath, i, isFirstL1Seed_, isValid_, kInvalidIndex, lastFilterBeforeL2TauIndex_, lastFilterBeforeL3TauIndex_, lastL2TauFilterIndex_, lastL3TauFilterIndex_, LogDebug, HLTConfigProvider::moduleType(), pathName_, contentValuesCheck::ss, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                                                      :
  hltProcess_(hltProcess),
  doRefAnalysis_(doRefAnalysis),
  pathName_(pathName),
  pathIndex_(HLTCP.triggerIndex(pathName_)),
  lastFilterBeforeL2TauIndex_(0), lastL2TauFilterIndex_(0),
  lastFilterBeforeL3TauIndex_(0), lastL3TauFilterIndex_(0),
  isFirstL1Seed_(false),
  isValid_(false)
{
#ifdef EDM_ML_DEBUG
  std::stringstream ss;
  ss << "HLTTauDQMPath: " << pathName_ << "\n";
#endif

  // Get the filters
  HLTPath thePath(pathName_);
  filterIndices_ = thePath.interestingFilters(HLTCP, doRefAnalysis_);
  if(filterIndices_.empty()) {
    edm::LogInfo("HLTTauDQMOffline") << "HLTTauDQMPath: " << pathName_ << " no interesting filters found";
    return;
  }
  isFirstL1Seed_ = HLTCP.moduleType(std::get<kName>(filterIndices_[0])) == "HLTLevel1GTSeed";
#ifdef EDM_ML_DEBUG
  ss << "  Interesting filters (preceded by the module index in the path)";
#endif
  // Set the filter multiplicity counts
  filterTauN_.clear();
  filterElectronN_.clear();
  filterMuonN_.clear();
  filterTauN_.reserve(filterIndices_.size());
  filterElectronN_.reserve(filterIndices_.size());
  filterMuonN_.reserve(filterIndices_.size());
  for(size_t i=0; i<filterIndices_.size(); ++i) {
    const std::string& filterName = std::get<kName>(filterIndices_[i]);
    const std::string& moduleType = HLTCP.moduleType(filterName);

    TauLeptonMultiplicity n = inferTauLeptonMultiplicity(HLTCP, filterName, moduleType, pathName_);
    filterTauN_.push_back(n.tau);
    filterElectronN_.push_back(n.electron);
    filterMuonN_.push_back(n.muon);

#ifdef EDM_ML_DEBUG
    ss << "\n    " << std::get<kModuleIndex>(filterIndices_[i])
       << " " << filterName
       << " " << moduleType
       << " ntau " << n.tau
       << " nele " << n.electron
       << " nmu " << n.muon;
#endif

  }
#ifdef EDM_ML_DEBUG
  LogDebug("HLTTauDQMOffline") << ss.str();
#endif


  // Find the position of tau producer, use filters with taus before
  // it for L2 tau efficiency, and filters with taus after it for L3
  // tau efficiency. Here we have to take into account that for
  // reference-matched case filterIndices_ contains only those filters
  // that have saveTags=True, while for searching the first L3 tau
  // filter we have to consider all filters
  const size_t firstL3TauFilterIndex = thePath.firstL3TauFilterIndex(HLTCP);
  if(firstL3TauFilterIndex == kInvalidIndex) {
    edm::LogInfo("HLTTauDQMOffline") << "Did not find a filter with L3 tau producer as input in path " << pathName_;
  }

  lastFilterBeforeL2TauIndex_ = 0;
  lastL2TauFilterIndex_ = kInvalidIndex;
  lastFilterBeforeL3TauIndex_ = 0;
  lastL3TauFilterIndex_ = kInvalidIndex;
  size_t i = 0;
  for(; i<filtersSize() && getFilterIndex(i) < firstL3TauFilterIndex; ++i) {
    if(lastL2TauFilterIndex_ == kInvalidIndex && getFilterNTaus(i) == 0)
      lastFilterBeforeL2TauIndex_ = i;
    if(getFilterNTaus(i) > 0 && getFilterNElectrons(i) == 0 && getFilterNMuons(i) == 0)
      lastL2TauFilterIndex_ = i;
  }
  lastFilterBeforeL3TauIndex_ = i-1;
  for(; i<filtersSize(); ++i) {
    if(lastL3TauFilterIndex_ == kInvalidIndex && getFilterNTaus(i) == 0)
      lastFilterBeforeL3TauIndex_ = i;
    if(getFilterNTaus(i) > 0 && getFilterNElectrons(i) == 0 && getFilterNMuons(i) == 0)
      lastL3TauFilterIndex_ = i;
  }
  LogDebug("HLTTauDQMOffline") << "lastFilterBeforeL2 " << lastFilterBeforeL2TauIndex_
                                   << " lastL2TauFilter " << lastL2TauFilterIndex_
                                   << " lastFilterBeforeL3 " << lastFilterBeforeL3TauIndex_
                                   << " lastL3TauFilter " << lastL3TauFilterIndex_;
  isValid_ = true;
}

HLTTauDQMPath::~HLTTauDQMPath

(

)

Definition at line 326 of file HLTTauDQMPath.cc.

{}

Member Function Documentation

size_t HLTTauDQMPath::filtersSize ( ) const

inline

Definition at line 51 of file HLTTauDQMPath.h.

References filterIndices_.

Referenced by HLTTauDQMPathSummaryPlotter::analyze(), HLTTauDQMPathPlotter::bookHistograms(), and HLTTauDQMPath().

{ return filterIndices_.size(); }

bool HLTTauDQMPath::fired

(

const edm::TriggerResults &

triggerResults

)

const

Definition at line 329 of file HLTTauDQMPath.cc.

References edm::HLTGlobalStatus::accept(), and pathIndex_.

Referenced by HLTTauDQMPathSummaryPlotter::analyze(), HLTTauDQMPathPlotter::analyze(), and lastPassedFilter().

                                                                       {
  return triggerResults.accept(pathIndex_);
}

size_t HLTTauDQMPath::getFilterIndex ( size_t  i ) const

inline

Definition at line 68 of file HLTTauDQMPath.h.

References filterIndices_, and i.

Referenced by HLTTauDQMPath().

{ return std::get<kModuleIndex>(filterIndices_[i]); }

const std::string& HLTTauDQMPath::getFilterName ( size_t  i ) const

inline

Definition at line 52 of file HLTTauDQMPath.h.

References filterIndices_, and i.

Referenced by HLTTauDQMPathPlotter::bookHistograms(), and getFilterObjects().

{ return std::get<kName>(filterIndices_[i]); }

int HLTTauDQMPath::getFilterNElectrons ( size_t  i ) const

inline

Definition at line 54 of file HLTTauDQMPath.h.

References filterElectronN_, and i.

Referenced by HLTTauDQMPathPlotter::analyze(), HLTTauDQMPathPlotter::bookHistograms(), goodOfflineEvent(), and HLTTauDQMPath().

{return filterElectronN_[i]; }

int HLTTauDQMPath::getFilterNMuons ( size_t  i ) const

inline

Definition at line 55 of file HLTTauDQMPath.h.

References filterMuonN_, and i.

Referenced by HLTTauDQMPathPlotter::analyze(), HLTTauDQMPathPlotter::bookHistograms(), goodOfflineEvent(), and HLTTauDQMPath().

{return filterMuonN_[i]; }

int HLTTauDQMPath::getFilterNTaus ( size_t  i ) const

inline

Definition at line 53 of file HLTTauDQMPath.h.

References filterTauN_, and i.

Referenced by HLTTauDQMPathPlotter::analyze(), HLTTauDQMPathPlotter::bookHistograms(), goodOfflineEvent(), and HLTTauDQMPath().

{ return filterTauN_[i]; }

void HLTTauDQMPath::getFilterObjects	(	const trigger::TriggerEvent &	triggerEvent,
		size_t	i,
		std::vector< Object > &	retval
	)		const

Definition at line 353 of file HLTTauDQMPath.cc.

References trigger::TriggerEvent::filterIds(), trigger::TriggerEvent::filterIndex(), trigger::TriggerEvent::filterKeys(), getFilterName(), trigger::TriggerEvent::getObjects(), hltProcess_, i, relativeConstraints::keys, dbtoconf::object, and trigger::TriggerEvent::sizeFilters().

Referenced by HLTTauDQMPathSummaryPlotter::analyze(), and HLTTauDQMPathPlotter::analyze().

                                                                                                                       {
  trigger::size_type filterIndex = triggerEvent.filterIndex(edm::InputTag(getFilterName(i), "", hltProcess_));
  if(filterIndex != triggerEvent.sizeFilters()) {
    const trigger::Keys& keys = triggerEvent.filterKeys(filterIndex);
    const trigger::Vids& ids = triggerEvent.filterIds(filterIndex);
    const trigger::TriggerObjectCollection& triggerObjects = triggerEvent.getObjects();
    //std::cout << "Filter name " << getFilterName(i) << std::endl;
    for(size_t i=0; i<keys.size(); ++i) {
      const trigger::TriggerObject& object = triggerObjects[keys[i]];
      retval.emplace_back(Object{object, ids[i]});
      //std::cout << "  object id " <<  object.id() << std::endl;
    }
  }
}

size_t HLTTauDQMPath::getLastFilterBeforeL2TauIndex ( ) const

inline

Definition at line 62 of file HLTTauDQMPath.h.

References lastFilterBeforeL2TauIndex_.

Referenced by HLTTauDQMPathPlotter::analyze().

{ return lastFilterBeforeL2TauIndex_; }

size_t HLTTauDQMPath::getLastFilterBeforeL3TauIndex ( ) const

inline

Definition at line 64 of file HLTTauDQMPath.h.

References lastFilterBeforeL3TauIndex_.

Referenced by HLTTauDQMPathPlotter::analyze().

{ return lastFilterBeforeL3TauIndex_; }

const std::string& HLTTauDQMPath::getLastFilterName ( ) const

inline

Definition at line 58 of file HLTTauDQMPath.h.

References filterIndices_.

{ return std::get<kName>(filterIndices_.back()); }

size_t HLTTauDQMPath::getLastL2TauFilterIndex ( ) const

inline

Definition at line 63 of file HLTTauDQMPath.h.

References lastL2TauFilterIndex_.

Referenced by HLTTauDQMPathPlotter::analyze().

{ return lastL2TauFilterIndex_; }

size_t HLTTauDQMPath::getLastL3TauFilterIndex ( ) const

inline

Definition at line 65 of file HLTTauDQMPath.h.

References lastL3TauFilterIndex_.

Referenced by HLTTauDQMPathPlotter::analyze().

{ return lastL3TauFilterIndex_; }

const unsigned int HLTTauDQMPath::getPathIndex ( ) const

inline

Definition at line 49 of file HLTTauDQMPath.h.

References pathIndex_.

{ return pathIndex_; }

const std::string& HLTTauDQMPath::getPathName ( ) const

inline

Definition at line 48 of file HLTTauDQMPath.h.

References pathName_.

Referenced by HLTTauDQMPathPlotter::bookHistograms().

{ return pathName_; }

bool HLTTauDQMPath::goodOfflineEvent	(	size_t	i,
		const HLTTauDQMOfflineObjects &	offlineObjects
	)		const

Definition at line 430 of file HLTTauDQMPath.cc.

References HLTTauDQMOfflineObjects::electrons, getFilterNElectrons(), getFilterNMuons(), getFilterNTaus(), HLTTauDQMOfflineObjects::muons, and HLTTauDQMOfflineObjects::taus.

Referenced by HLTTauDQMPathSummaryPlotter::analyze().

                                                                                                  {
  return (static_cast<size_t>(getFilterNTaus(i)) <= offlineObjects.taus.size() &&
          static_cast<size_t>(getFilterNElectrons(i)) <= offlineObjects.electrons.size() &&
          static_cast<size_t>(getFilterNMuons(i)) <= offlineObjects.muons.size());
}

bool HLTTauDQMPath::hasL2Taus ( ) const

inline

Definition at line 60 of file HLTTauDQMPath.h.

References kInvalidIndex, and lastL2TauFilterIndex_.

Referenced by HLTTauDQMPathPlotter::analyze(), and HLTTauDQMPathPlotter::bookHistograms().

{ return lastL2TauFilterIndex_ != kInvalidIndex; }

bool HLTTauDQMPath::hasL3Taus ( ) const

inline

Definition at line 61 of file HLTTauDQMPath.h.

References kInvalidIndex, and lastL3TauFilterIndex_.

Referenced by HLTTauDQMPathPlotter::analyze(), and HLTTauDQMPathPlotter::bookHistograms().

{ return lastL3TauFilterIndex_ != kInvalidIndex; }

bool HLTTauDQMPath::isFirstFilterL1Seed ( ) const

inline

Definition at line 57 of file HLTTauDQMPath.h.

References isFirstL1Seed_.

Referenced by HLTTauDQMPathPlotter::analyze().

{ return isFirstL1Seed_; }

bool HLTTauDQMPath::isValid ( void  ) const

inline

Definition at line 40 of file HLTTauDQMPath.h.

References isValid_.

Referenced by HLTTauDQMPathPlotter::HLTTauDQMPathPlotter().

{ return isValid_; }

int HLTTauDQMPath::lastPassedFilter

(

const edm::TriggerResults &

triggerResults

)

const

Definition at line 333 of file HLTTauDQMPath.cc.

References filterIndices_, fired(), i, edm::HLTGlobalStatus::index(), and pathIndex_.

Referenced by HLTTauDQMPathPlotter::analyze().

                                                                                 {
  if(fired(triggerResults)) {
    //std::cout << "Event passed" << std::endl;
    return filterIndices_.size()-1;
  }

  unsigned int firstFailedFilter = triggerResults.index(pathIndex_);
  int lastPassedFilter = -1;
  for(size_t i=0; i<filterIndices_.size(); ++i) {
    if(std::get<kModuleIndex>(filterIndices_[i]) < firstFailedFilter) {
      lastPassedFilter = i;
    }
    else {
      //std::cout << "Decision-making filter " << firstFailedFilter << " this " << std::get<kModuleIndex>(filterIndices_[i]) << std::endl;
      break;
    }
  }
  return lastPassedFilter;
}

bool HLTTauDQMPath::offlineMatching	(	size_t	i,
		const std::vector< Object > &	triggerObjects,
		const HLTTauDQMOfflineObjects &	offlineObjects,
		double	dR,
		std::vector< Object > &	matchedTriggerObjects,
		HLTTauDQMOfflineObjects &	matchedOfflineObjects
	)		const

Definition at line 368 of file HLTTauDQMPath.cc.

References a, b, HLTTauDQMOfflineObjects::electrons, lumiContext::fill, filterElectronN_, filterMuonN_, filterTauN_, isFirstL1Seed_, HLTTauDQMOfflineObjects::muons, python.multivaluedict::sort(), HLTTauDQMOfflineObjects::taus, trigger::TriggerElectron, trigger::TriggerL1CenJet, trigger::TriggerL1IsoEG, trigger::TriggerL1Mu, trigger::TriggerL1NoIsoEG, trigger::TriggerL1TauJet, trigger::TriggerMuon, and trigger::TriggerTau.

Referenced by HLTTauDQMPathSummaryPlotter::analyze(), and HLTTauDQMPathPlotter::analyze().

                                                                                                                                                                                                                                               {
  bool isL1 = (i==0 && isFirstL1Seed_);
  std::vector<bool> offlineMask;
  if(filterTauN_[i] > 0) {
    int matchedObjects = 0;
    offlineMask.resize(offlineObjects.taus.size());
    std::fill(offlineMask.begin(), offlineMask.end(), true);
    for(const Object& trgObj: triggerObjects) {
      //std::cout << "trigger object id " << trgObj.id << std::endl;
      if(! ((isL1 && (trgObj.id == trigger::TriggerL1TauJet || trgObj.id == trigger::TriggerL1CenJet))
            || trgObj.id == trigger::TriggerTau) )
        continue;
      if(deltaRmatch(trgObj.object, offlineObjects.taus, dR, offlineMask, matchedOfflineObjects.taus)) {
        ++matchedObjects;
        matchedTriggerObjects.emplace_back(trgObj);
      }
    }
    if(matchedObjects < filterTauN_[i])
      return false;
  }
  if(filterElectronN_[i] > 0) {
    int matchedObjects = 0;
    offlineMask.resize(offlineObjects.electrons.size());
    std::fill(offlineMask.begin(), offlineMask.end(), true);
    for(const Object& trgObj: triggerObjects) {
      //std::cout << "trigger object id " << trgObj.id << std::endl;
      if(! ((isL1 && (trgObj.id == trigger::TriggerL1NoIsoEG || trgObj.id == trigger::TriggerL1IsoEG))
            || trgObj.id == trigger::TriggerElectron) )
        continue;
      if(deltaRmatch(trgObj.object, offlineObjects.electrons, dR, offlineMask, matchedOfflineObjects.electrons)) {
        ++matchedObjects;
        matchedTriggerObjects.emplace_back(trgObj);
      }
    }
    if(matchedObjects < filterElectronN_[i])
      return false;
  }
  if(filterMuonN_[i] > 0) {
    int matchedObjects = 0;
    offlineMask.resize(offlineObjects.muons.size());
    std::fill(offlineMask.begin(), offlineMask.end(), true);
    for(const Object& trgObj: triggerObjects) {
      //std::cout << "trigger object id " << trgObj.id << std::endl;
      if(! ((isL1 && trgObj.id == trigger::TriggerL1Mu)
            || trgObj.id == trigger::TriggerMuon) )
        continue;
      if(deltaRmatch(trgObj.object, offlineObjects.muons, dR, offlineMask, matchedOfflineObjects.muons)) {
        ++matchedObjects;
        matchedTriggerObjects.emplace_back(trgObj);
      }
    }
    if(matchedObjects < filterMuonN_[i])
      return false;
  }
  // Sort offline objects by pt
  std::sort(matchedOfflineObjects.taus.begin(), matchedOfflineObjects.taus.end(), [](const LV& a, const LV&b) { return a.pt() > b.pt();});
  std::sort(matchedOfflineObjects.electrons.begin(), matchedOfflineObjects.electrons.end(), [](const LV& a, const LV&b) { return a.pt() > b.pt();});
  std::sort(matchedOfflineObjects.muons.begin(), matchedOfflineObjects.muons.end(), [](const LV& a, const LV&b) { return a.pt() > b.pt();});

  return true;
}

Member Data Documentation

const bool HLTTauDQMPath::doRefAnalysis_

private

Definition at line 80 of file HLTTauDQMPath.h.

Referenced by HLTTauDQMPath().

std::vector<int> HLTTauDQMPath::filterElectronN_

private

Definition at line 84 of file HLTTauDQMPath.h.

Referenced by getFilterNElectrons(), HLTTauDQMPath(), and offlineMatching().

std::vector<FilterIndex> HLTTauDQMPath::filterIndices_

private

Definition at line 82 of file HLTTauDQMPath.h.

Referenced by filtersSize(), getFilterIndex(), getFilterName(), getLastFilterName(), HLTTauDQMPath(), and lastPassedFilter().

std::vector<int> HLTTauDQMPath::filterMuonN_

private

Definition at line 85 of file HLTTauDQMPath.h.

Referenced by getFilterNMuons(), HLTTauDQMPath(), and offlineMatching().

std::vector<int> HLTTauDQMPath::filterTauN_

private

Definition at line 83 of file HLTTauDQMPath.h.

Referenced by getFilterNTaus(), HLTTauDQMPath(), and offlineMatching().

const std::string HLTTauDQMPath::hltProcess_

private

Definition at line 79 of file HLTTauDQMPath.h.

Referenced by getFilterObjects().

bool HLTTauDQMPath::isFirstL1Seed_

private

Definition at line 92 of file HLTTauDQMPath.h.

Referenced by HLTTauDQMPath(), isFirstFilterL1Seed(), and offlineMatching().

bool HLTTauDQMPath::isValid_

private

Definition at line 93 of file HLTTauDQMPath.h.

Referenced by HLTTauDQMPath(), and isValid().

constexpr size_t HLTTauDQMPath::kInvalidIndex = std::numeric_limits<size_t>::max()

static

Definition at line 30 of file HLTTauDQMPath.h.

Referenced by hasL2Taus(), hasL3Taus(), and HLTTauDQMPath().

constexpr size_t HLTTauDQMPath::kModuleIndex = 1

static

Definition at line 29 of file HLTTauDQMPath.h.

constexpr size_t HLTTauDQMPath::kName = 0

static

Definition at line 28 of file HLTTauDQMPath.h.

size_t HLTTauDQMPath::lastFilterBeforeL2TauIndex_

private

Definition at line 88 of file HLTTauDQMPath.h.

Referenced by getLastFilterBeforeL2TauIndex(), and HLTTauDQMPath().

size_t HLTTauDQMPath::lastFilterBeforeL3TauIndex_

private

Definition at line 90 of file HLTTauDQMPath.h.

Referenced by getLastFilterBeforeL3TauIndex(), and HLTTauDQMPath().

size_t HLTTauDQMPath::lastL2TauFilterIndex_

private

Definition at line 89 of file HLTTauDQMPath.h.

Referenced by getLastL2TauFilterIndex(), hasL2Taus(), and HLTTauDQMPath().

size_t HLTTauDQMPath::lastL3TauFilterIndex_

private

Definition at line 91 of file HLTTauDQMPath.h.

Referenced by getLastL3TauFilterIndex(), hasL3Taus(), and HLTTauDQMPath().

const unsigned int HLTTauDQMPath::pathIndex_

private

Definition at line 87 of file HLTTauDQMPath.h.

Referenced by fired(), getPathIndex(), and lastPassedFilter().

const std::string HLTTauDQMPath::pathName_

private

Definition at line 86 of file HLTTauDQMPath.h.

Referenced by getPathName(), and HLTTauDQMPath().