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
bool	beginRun (const HLTConfigProvider &HLTCP)
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 &hltProcess, const std::string &dqmFolder, bool doRefAnalysis)
void	initialize (const edm::ParameterSet &pset)
bool	isFirstFilterL1Seed () 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 ()

Private Attributes
const bool	doRefAnalysis_
const std::string	dqmFolder_
std::vector< int >	filterElectronN_
std::vector< FilterIndex >	filterIndices_
std::vector< int >	filterMuonN_
std::vector< int >	filterTauN_
const std::string	hltProcess_
std::vector< boost::regex >	ignoreFilterNames_
std::vector< boost::regex >	ignoreFilterTypes_
bool	isFirstL1Seed_
size_t	lastFilterBeforeL2TauIndex_
size_t	lastFilterBeforeL3TauIndex_
size_t	lastL2TauFilterIndex_
size_t	lastL3TauFilterIndex_
unsigned int	pathIndex_
std::string	pathName_
std::vector< boost::regex >	pathRegexs_

Detailed Description

Definition at line 24 of file HLTTauDQMPath.h.

Member Typedef Documentation

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

Definition at line 77 of file HLTTauDQMPath.h.

typedef math::XYZTLorentzVectorD HLTTauDQMPath::LV

Definition at line 26 of file HLTTauDQMPath.h.

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

Definition at line 27 of file HLTTauDQMPath.h.

Constructor & Destructor Documentation

HLTTauDQMPath::HLTTauDQMPath	(	const std::string &	hltProcess,
		const std::string &	dqmFolder,
		bool	doRefAnalysis
	)

Definition at line 274 of file HLTTauDQMPath.cc.

                                                                                                       :
  hltProcess_(hltProcess),
  dqmFolder_(dqmFolder),
  doRefAnalysis_(doRefAnalysis),
  pathIndex_(0),
  lastFilterBeforeL2TauIndex_(0), lastL2TauFilterIndex_(0),
  lastFilterBeforeL3TauIndex_(0), lastL3TauFilterIndex_(0),
  isFirstL1Seed_(false)
{}

HLTTauDQMPath::~HLTTauDQMPath

(

)

Definition at line 283 of file HLTTauDQMPath.cc.

{}

Member Function Documentation

bool HLTTauDQMPath::beginRun

(

const HLTConfigProvider &

HLTCP

)

Definition at line 306 of file HLTTauDQMPath.cc.

References doRefAnalysis_, dqmFolder_, filterElectronN_, filterIndices_, filterMuonN_, filtersSize(), filterTauN_, getFilterIndex(), getFilterNElectrons(), getFilterNMuons(), getFilterNTaus(), i, ignoreFilterNames_, ignoreFilterTypes_, isFirstL1Seed_, lastFilterBeforeL2TauIndex_, lastFilterBeforeL3TauIndex_, lastL2TauFilterIndex_, lastL3TauFilterIndex_, LogDebug, max(), HLTConfigProvider::moduleType(), getHLTPrescaleColumns::path, pathIndex_, pathName_, pathRegexs_, AlCaHLTBitMon_QueryRunRegistry::string, HLTConfigProvider::triggerIndex(), HLTConfigProvider::triggerNames(), and cms::Exception::what().

Referenced by HLTTauDQMPathPlotter::beginRun().

                                                           {
  // Search path candidates

  std::vector<HLTPath> foundPaths;
  const std::vector<std::string>& triggerNames = HLTCP.triggerNames();
  for(const boost::regex& re: pathRegexs_) {
    //std::cout << regexStr << std::endl;
    boost::smatch what;

    for(const std::string& path: triggerNames) {
      if(boost::regex_match(path, what, re)) {
        foundPaths.emplace_back(path, what);
      }
    }
    if(!foundPaths.empty())
      break;
  }
  if(foundPaths.empty()) {
    std::stringstream ss;
    for(std::vector<boost::regex>::const_iterator iRegex = pathRegexs_.begin(); iRegex != pathRegexs_.end(); ++iRegex) {
      if(iRegex != pathRegexs_.begin())
        ss << ",";
      ss << iRegex->str();
    }
    edm::LogWarning("HLTTauDQMOffline") << "HLTTauDQMPath::beginRun(): did not find any paths matching to regexes " << ss.str();
    return false;
  }

  // If more than one, find the best match
  std::vector<HLTPath>::const_iterator thePath = foundPaths.begin();
  try {
    std::vector<HLTPath>::const_iterator iPath = thePath;
    ++iPath;
    for(; iPath != foundPaths.end(); ++iPath) {
      if(!thePath->isBetterThan(*iPath, HLTCP))
        thePath = iPath;
    }
  } catch(cms::Exception& e) {
    edm::LogError("HLTTauDQMOffline") << "HLTTauDQMPath::beginRun(): " << e.what();
    return false;
  }
  std::stringstream ss;
  ss << "HLTTauDQMPath::beginRun(): " << dqmFolder_ << ": chose path " << thePath->name() << "\n";

  // Get the filters
  filterIndices_ = thePath->interestingFilters(HLTCP, doRefAnalysis_, ignoreFilterTypes_, ignoreFilterNames_);
  isFirstL1Seed_ = HLTCP.moduleType(std::get<0>(filterIndices_[0])) == "HLTLevel1GTSeed";
  ss << "  Filters";
  // 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<0>(filterIndices_[i]);
    const std::string& moduleType = HLTCP.moduleType(filterName);

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

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

  }
  edm::LogInfo("HLTTauDQMOffline") << ss.str();


  // Find the position of PFRecoTauProducer, use filters with taus
  // before it for L2 tau efficiency, and filters with taus after it
  // for L3 tau efficiency
  const size_t tauProducerIndex = thePath->tauProducerIndex(HLTCP);
  if(tauProducerIndex == std::numeric_limits<size_t>::max()) {
    edm::LogWarning("HLTTauDQMOffline") << "HLTTauDQMPath::beginRun(): Did not find PFRecoTauProducer from HLT path " << thePath->name();
    return false;
  }
  //lastFilterBeforeL2TauIndex_ = std::numeric_limits<size_t>::max();
  lastL2TauFilterIndex_ = std::numeric_limits<size_t>::max();
  //lastFilterBeforeL3TauIndex_ = std::numeric_limits<size_t>::max();
  lastL3TauFilterIndex_ = std::numeric_limits<size_t>::max();
  size_t i = 0;
  lastFilterBeforeL2TauIndex_ = 0;
  for(; i<filtersSize() && getFilterIndex(i) < tauProducerIndex; ++i) {
    if(lastL2TauFilterIndex_ == std::numeric_limits<size_t>::max() && 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_ == std::numeric_limits<size_t>::max() && 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_;

  // Set path index
  pathName_ = thePath->name();
  pathIndex_ = HLTCP.triggerIndex(thePath->name());


  return true;
}

size_t HLTTauDQMPath::filtersSize ( ) const

inline

Definition at line 50 of file HLTTauDQMPath.h.

References filterIndices_.

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

{ return filterIndices_.size(); }

bool HLTTauDQMPath::fired

(

const edm::TriggerResults &

triggerResults

)

const

Definition at line 421 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 67 of file HLTTauDQMPath.h.

References filterIndices_, and i.

Referenced by beginRun().

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

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

inline

Definition at line 51 of file HLTTauDQMPath.h.

References filterIndices_, and i.

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

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

int HLTTauDQMPath::getFilterNElectrons ( size_t  i ) const

inline

Definition at line 53 of file HLTTauDQMPath.h.

References filterElectronN_, and i.

Referenced by HLTTauDQMPathPlotter::analyze(), HLTTauDQMPathPlotter::beginRun(), beginRun(), and goodOfflineEvent().

{return filterElectronN_[i]; }

int HLTTauDQMPath::getFilterNMuons ( size_t  i ) const

inline

Definition at line 54 of file HLTTauDQMPath.h.

References filterMuonN_, and i.

Referenced by HLTTauDQMPathPlotter::analyze(), HLTTauDQMPathPlotter::beginRun(), beginRun(), and goodOfflineEvent().

{return filterMuonN_[i]; }

int HLTTauDQMPath::getFilterNTaus ( size_t  i ) const

inline

Definition at line 52 of file HLTTauDQMPath.h.

References filterTauN_, and i.

Referenced by HLTTauDQMPathPlotter::analyze(), HLTTauDQMPathPlotter::beginRun(), beginRun(), and goodOfflineEvent().

{ return filterTauN_[i]; }

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

Definition at line 445 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 61 of file HLTTauDQMPath.h.

References lastFilterBeforeL2TauIndex_.

Referenced by HLTTauDQMPathPlotter::analyze().

{ return lastFilterBeforeL2TauIndex_; }

size_t HLTTauDQMPath::getLastFilterBeforeL3TauIndex ( ) const

inline

Definition at line 63 of file HLTTauDQMPath.h.

References lastFilterBeforeL3TauIndex_.

Referenced by HLTTauDQMPathPlotter::analyze().

{ return lastFilterBeforeL3TauIndex_; }

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

inline

Definition at line 57 of file HLTTauDQMPath.h.

References filterIndices_.

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

size_t HLTTauDQMPath::getLastL2TauFilterIndex ( ) const

inline

Definition at line 62 of file HLTTauDQMPath.h.

References lastL2TauFilterIndex_.

Referenced by HLTTauDQMPathPlotter::analyze().

{ return lastL2TauFilterIndex_; }

size_t HLTTauDQMPath::getLastL3TauFilterIndex ( ) const

inline

Definition at line 64 of file HLTTauDQMPath.h.

References lastL3TauFilterIndex_.

Referenced by HLTTauDQMPathPlotter::analyze().

{ return lastL3TauFilterIndex_; }

const unsigned int HLTTauDQMPath::getPathIndex ( ) const

inline

Definition at line 48 of file HLTTauDQMPath.h.

References pathIndex_.

{ return pathIndex_; }

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

inline

Definition at line 47 of file HLTTauDQMPath.h.

References pathName_.

{ return pathName_; }

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

Definition at line 522 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 59 of file HLTTauDQMPath.h.

References lastL2TauFilterIndex_, and max().

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

{ return lastL2TauFilterIndex_ != std::numeric_limits<size_t>::max(); }

bool HLTTauDQMPath::hasL3Taus ( ) const

inline

Definition at line 60 of file HLTTauDQMPath.h.

References lastL3TauFilterIndex_, and max().

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

{ return lastL3TauFilterIndex_ != std::numeric_limits<size_t>::max(); }

void HLTTauDQMPath::initialize

(

const edm::ParameterSet &

pset

)

Definition at line 285 of file HLTTauDQMPath.cc.

References edm::ParameterSet::getUntrackedParameter(), pathRegexs_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by HLTTauDQMPathPlotter::HLTTauDQMPathPlotter().

                                                          {
  std::vector<std::string> regexs;
  std::vector<boost::regex> ignoreFilterTypes;
  std::vector<boost::regex> ignoreFilterNames;
  std::vector<std::string> regexsTmp = pset.getUntrackedParameter<std::vector<std::string> >("Path");
  pathRegexs_.reserve(regexsTmp.size());
  for(const std::string& str: regexsTmp)
    pathRegexs_.emplace_back(str);

  std::vector<std::string> ignoreFilterTypesTmp;
  std::vector<std::string> ignoreFilterNamesTmp;
  ignoreFilterTypesTmp   = pset.getUntrackedParameter<std::vector<std::string> >("IgnoreFilterTypes");
  ignoreFilterNamesTmp   = pset.getUntrackedParameter<std::vector<std::string> >("IgnoreFilterNames");
  ignoreFilterTypes.reserve(ignoreFilterTypesTmp.size());
  ignoreFilterNames.reserve(ignoreFilterNamesTmp.size());
  for(const std::string& str: ignoreFilterTypesTmp)
    ignoreFilterTypes.emplace_back(str);
  for(const std::string& str: ignoreFilterNamesTmp)
    ignoreFilterNames.emplace_back(str);
}

bool HLTTauDQMPath::isFirstFilterL1Seed ( ) const

inline

Definition at line 56 of file HLTTauDQMPath.h.

References isFirstL1Seed_.

Referenced by HLTTauDQMPathPlotter::analyze().

{ return isFirstL1Seed_; }

int HLTTauDQMPath::lastPassedFilter

(

const edm::TriggerResults &

triggerResults

)

const

Definition at line 425 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<1>(filterIndices_[i]) < firstFailedFilter) {
      lastPassedFilter = i;
    }
    else {
      //std::cout << "Decision-making filter " << firstFailedFilter << " this " << std::get<1>(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 460 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 81 of file HLTTauDQMPath.h.

Referenced by beginRun().

const std::string HLTTauDQMPath::dqmFolder_

private

Definition at line 80 of file HLTTauDQMPath.h.

Referenced by beginRun().

std::vector<int> HLTTauDQMPath::filterElectronN_

private

Definition at line 89 of file HLTTauDQMPath.h.

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

std::vector<FilterIndex> HLTTauDQMPath::filterIndices_

private

Definition at line 87 of file HLTTauDQMPath.h.

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

std::vector<int> HLTTauDQMPath::filterMuonN_

private

Definition at line 90 of file HLTTauDQMPath.h.

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

std::vector<int> HLTTauDQMPath::filterTauN_

private

Definition at line 88 of file HLTTauDQMPath.h.

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

const std::string HLTTauDQMPath::hltProcess_

private

Definition at line 79 of file HLTTauDQMPath.h.

Referenced by getFilterObjects().

std::vector<boost::regex> HLTTauDQMPath::ignoreFilterNames_

private

Definition at line 85 of file HLTTauDQMPath.h.

Referenced by beginRun().

std::vector<boost::regex> HLTTauDQMPath::ignoreFilterTypes_

private

Definition at line 84 of file HLTTauDQMPath.h.

Referenced by beginRun().

bool HLTTauDQMPath::isFirstL1Seed_

private

Definition at line 97 of file HLTTauDQMPath.h.

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

size_t HLTTauDQMPath::lastFilterBeforeL2TauIndex_

private

Definition at line 93 of file HLTTauDQMPath.h.

Referenced by beginRun(), and getLastFilterBeforeL2TauIndex().

size_t HLTTauDQMPath::lastFilterBeforeL3TauIndex_

private

Definition at line 95 of file HLTTauDQMPath.h.

Referenced by beginRun(), and getLastFilterBeforeL3TauIndex().

size_t HLTTauDQMPath::lastL2TauFilterIndex_

private

Definition at line 94 of file HLTTauDQMPath.h.

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

size_t HLTTauDQMPath::lastL3TauFilterIndex_

private

Definition at line 96 of file HLTTauDQMPath.h.

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

unsigned int HLTTauDQMPath::pathIndex_

private

Definition at line 92 of file HLTTauDQMPath.h.

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

std::string HLTTauDQMPath::pathName_

private

Definition at line 91 of file HLTTauDQMPath.h.

Referenced by beginRun(), and getPathName().

std::vector<boost::regex> HLTTauDQMPath::pathRegexs_

private

Definition at line 83 of file HLTTauDQMPath.h.

Referenced by beginRun(), and initialize().