reco::tau::RecoTauPiZeroStripPlugin3 Class Reference

Inheritance diagram for reco::tau::RecoTauPiZeroStripPlugin3:

Public Member Functions
void	beginEvent () override
	Hook called at the beginning of the event. More...
return_type	operator() (const reco::Jet &) const override
	Build a collection of piZeros from objects in the input jet. More...
	RecoTauPiZeroStripPlugin3 (const edm::ParameterSet &, edm::ConsumesCollector &&iC)
	~RecoTauPiZeroStripPlugin3 () override
Public Member Functions inherited from reco::tau::RecoTauPiZeroBuilderPlugin
	RecoTauPiZeroBuilderPlugin (const edm::ParameterSet &pset, edm::ConsumesCollector &&iC)
	~RecoTauPiZeroBuilderPlugin () override
Public Member Functions inherited from reco::tau::RecoTauEventHolderPlugin
const edm::Event *	evt () const
edm::Event *	evt ()
const edm::EventSetup *	evtSetup () const
	RecoTauEventHolderPlugin (const edm::ParameterSet &pset)
void	setup (edm::Event &, const edm::EventSetup &)
	~RecoTauEventHolderPlugin () override
Public Member Functions inherited from reco::tau::RecoTauNamedPlugin
const std::string &	name () const
	RecoTauNamedPlugin (const edm::ParameterSet &pset)
virtual	~RecoTauNamedPlugin ()

Private Types
typedef std::vector< reco::CandidatePtr >	CandPtrs

Private Member Functions
void	addCandsToStrip (RecoTauPiZero &, CandPtrs &, const std::vector< bool > &, std::set< size_t > &, bool &) const

Private Attributes
bool	applyElecTrackQcuts_
double	combinatoricStripMassHypo_
bool	combineStrips_
std::unique_ptr< const TFormula >	etaAssociationDistance_
std::vector< int >	inputParticleIds_
int	maxStripBuildIterations_
int	maxStrips_
double	minGammaEtStripAdd_
double	minGammaEtStripSeed_
double	minStripEt_
AddFourMomenta	p4Builder_
std::unique_ptr< const TFormula >	phiAssociationDistance_
std::unique_ptr< RecoTauQualityCuts >	qcuts_
bool	updateStripAfterEachDaughter_
int	verbosity_
RecoTauVertexAssociator	vertexAssociator_

Additional Inherited Members
Public Types inherited from reco::tau::RecoTauPiZeroBuilderPlugin
typedef std::vector< std::unique_ptr< RecoTauPiZero > >	PiZeroVector
typedef PiZeroVector	return_type

Detailed Description

Definition at line 55 of file RecoTauPiZeroStripPlugin3.cc.

Member Typedef Documentation

CandPtrs

typedef std::vector<reco::CandidatePtr> reco::tau::RecoTauPiZeroStripPlugin3::CandPtrs

private

Definition at line 65 of file RecoTauPiZeroStripPlugin3.cc.

Constructor & Destructor Documentation

RecoTauPiZeroStripPlugin3()

reco::tau::RecoTauPiZeroStripPlugin3::RecoTauPiZeroStripPlugin3 ( const edm::ParameterSet &  pset, edm::ConsumesCollector &&  iC  )

explicit

Definition at line 109 of file RecoTauPiZeroStripPlugin3.cc.

References applyElecTrackQcuts_, combinatoricStripMassHypo_, combineStrips_, etaAssociationDistance_, inputParticleIds_, maxStripBuildIterations_, maxStrips_, SiStripPI::min, minGammaEtStripAdd_, minGammaEtStripSeed_, minStripEt_, phiAssociationDistance_, muonDTDigis_cfi::pset, qcuts_, updateStripAfterEachDaughter_, and verbosity_.

        : RecoTauPiZeroBuilderPlugin(pset, std::move(iC)),
          vertexAssociator_(pset.getParameter<edm::ParameterSet>("qualityCuts"), std::move(iC)),
          qcuts_(nullptr),
          etaAssociationDistance_(nullptr),
          phiAssociationDistance_(nullptr) {
      minGammaEtStripSeed_ = pset.getParameter<double>("minGammaEtStripSeed");
      minGammaEtStripAdd_ = pset.getParameter<double>("minGammaEtStripAdd");

      minStripEt_ = pset.getParameter<double>("minStripEt");

      edm::ParameterSet qcuts_pset = pset.getParameterSet("qualityCuts").getParameterSet("signalQualityCuts");
      //-------------------------------------------------------------------------------
      // CV: disable track quality cuts for PFElectronsPFElectron
      //       (treat PFElectrons like PFGammas for the purpose of building eta-phi strips)
      applyElecTrackQcuts_ = pset.getParameter<bool>("applyElecTrackQcuts");
      if (!applyElecTrackQcuts_) {
        qcuts_pset.addParameter<double>("minTrackPt", std::min(minGammaEtStripSeed_, minGammaEtStripAdd_));
        qcuts_pset.addParameter<double>("maxTrackChi2", 1.e+9);
        qcuts_pset.addParameter<double>("maxTransverseImpactParameter", 1.e+9);
        qcuts_pset.addParameter<double>("maxDeltaZ", 1.e+9);
        qcuts_pset.addParameter<double>("minTrackVertexWeight", -1.);
        qcuts_pset.addParameter<unsigned>("minTrackPixelHits", 0);
        qcuts_pset.addParameter<unsigned>("minTrackHits", 0);
      }
      //-------------------------------------------------------------------------------
      qcuts_pset.addParameter<double>("minGammaEt", std::min(minGammaEtStripSeed_, minGammaEtStripAdd_));
      //qcuts_ = new RecoTauQualityCuts(qcuts_pset);
      //std::unique_ptr<RecoTauQualityCuts> qcuts_(new RecoTauQualityCuts(qcuts_pset));

      qcuts_ = std::make_unique<RecoTauQualityCuts>(qcuts_pset);

      inputParticleIds_ = pset.getParameter<std::vector<int> >("stripCandidatesParticleIds");
      const edm::ParameterSet& stripSize_eta_pset = pset.getParameterSet("stripEtaAssociationDistanceFunc");
      etaAssociationDistance_ = makeFunction("etaAssociationDistance", stripSize_eta_pset);
      const edm::ParameterSet& stripSize_phi_pset = pset.getParameterSet("stripPhiAssociationDistanceFunc");
      phiAssociationDistance_ = makeFunction("phiAssociationDistance", stripSize_phi_pset);

      updateStripAfterEachDaughter_ = pset.getParameter<bool>("updateStripAfterEachDaughter");
      maxStripBuildIterations_ = pset.getParameter<int>("maxStripBuildIterations");

      combineStrips_ = pset.getParameter<bool>("makeCombinatoricStrips");
      if (combineStrips_) {
        maxStrips_ = pset.getParameter<int>("maxInputStrips");
        combinatoricStripMassHypo_ = pset.getParameter<double>("stripMassWhenCombining");
      }

      verbosity_ = pset.getParameter<int>("verbosity");
    }

~RecoTauPiZeroStripPlugin3()

reco::tau::RecoTauPiZeroStripPlugin3::~RecoTauPiZeroStripPlugin3 ( )

override

Definition at line 158 of file RecoTauPiZeroStripPlugin3.cc.

{}

Member Function Documentation

addCandsToStrip()

void reco::tau::RecoTauPiZeroStripPlugin3::addCandsToStrip ( RecoTauPiZero &  strip, CandPtrs &  cands, const std::vector< bool > &  candFlags, std::set< size_t > &  candIdsCurrentStrip, bool &  isCandAdded  ) const

private

Definition at line 163 of file RecoTauPiZeroStripPlugin3.cc.

References HLT_2022v15_cff::cands, reco::deltaPhi(), etaAssociationDistance_, p4Builder_, phiAssociationDistance_, AddFourMomenta::set(), digitizers_cfi::strip, updateStripAfterEachDaughter_, and verbosity_.

Referenced by operator()().

                                                                             {
      if (verbosity_ >= 1) {
        edm::LogPrint("RecoTauPiZeroStripPlugin3") << "<RecoTauPiZeroStripPlugin3::addCandsToStrip>:";
      }
      size_t numCands = cands.size();
      for (size_t candId = 0; candId < numCands; ++candId) {
        if ((!candFlags[candId]) &&
            candIdsCurrentStrip.find(candId) == candIdsCurrentStrip.end()) {  // do not include same cand twice
          reco::CandidatePtr cand = cands[candId];
          double etaAssociationDistance_value =
              etaAssociationDistance_->Eval(strip.pt()) + etaAssociationDistance_->Eval(cand->pt());
          double phiAssociationDistance_value =
              phiAssociationDistance_->Eval(strip.pt()) + phiAssociationDistance_->Eval(cand->pt());
          if (fabs(strip.eta() - cand->eta()) <
                  etaAssociationDistance_value &&  // check if cand is within eta-phi window centered on strip
              reco::deltaPhi(strip.phi(), cand->phi()) < phiAssociationDistance_value) {
            if (verbosity_ >= 2) {
              edm::LogPrint("RecoTauPiZeroStripPlugin3")
                  << "--> adding PFCand #" << candId << " (" << cand.id() << ":" << cand.key()
                  << "): Et = " << cand->et() << ", eta = " << cand->eta() << ", phi = " << cand->phi();
            }
            strip.addDaughter(cand);
            if (updateStripAfterEachDaughter_)
              p4Builder_.set(strip);
            isCandAdded = true;
            candIdsCurrentStrip.insert(candId);
          }
        }
      }
    }

beginEvent()

void reco::tau::RecoTauPiZeroStripPlugin3::beginEvent ( )

overridevirtual

Hook called at the beginning of the event.

Reimplemented from reco::tau::RecoTauPiZeroBuilderPlugin.

Definition at line 161 of file RecoTauPiZeroStripPlugin3.cc.

References reco::tau::RecoTauEventHolderPlugin::evt(), reco::tau::RecoTauVertexAssociator::setEvent(), and vertexAssociator_.

{ vertexAssociator_.setEvent(*evt()); }

operator()()

RecoTauPiZeroStripPlugin3::return_type reco::tau::RecoTauPiZeroStripPlugin3::operator() ( const reco::Jet &  ) const

overridevirtual

Build a collection of piZeros from objects in the input jet.

Implements reco::tau::RecoTauPiZeroBuilderPlugin.

Definition at line 223 of file RecoTauPiZeroStripPlugin3.cc.

References addCandsToStrip(), reco::tau::RecoTauVertexAssociator::associatedVertex(), reco::TrackBase::charge(), combinatoricStripMassHypo_, combineStrips_, reco::TrackBase::dxy(), reco::TrackBase::dz(), MillePedeFileConverter_cfg::e, CastorDataFrameFilter_impl::energySum(), reco::TrackBase::eta(), etaAssociationDistance_, dqmdumpme::first, CustomPhysics_cfi::gamma, getTrack(), reco::TrackBase::hitPattern(), heavyIonCSV_trainingSettings::idx, inputParticleIds_, edm::RefToBase< T >::isNonnull(), metsig::jet, reco::RecoTauPiZero::kStrips, reco::RecoTauPiZero::kUndefined, maxStripBuildIterations_, maxStrips_, minGammaEtStripAdd_, minGammaEtStripSeed_, minStripEt_, eostools::move(), reco::TrackBase::normalizedChi2(), reco::HitPattern::numberOfValidPixelHits(), reco::HitPattern::numberOfValidTrackerHits(), convertSQLitetoXML_cfg::output, p4Builder_, reco::tau::pfCandidates(), reco::TrackBase::phi(), phiAssociationDistance_, reco::TrackBase::pt(), reco::TrackBase::ptError(), qcuts_, edm::second(), AddFourMomenta::set(), jetUpdater_cfi::sort, digitizers_cfi::strip, reco::tau::takeNElements(), updateStripAfterEachDaughter_, verbosity_, and vertexAssociator_.

                                                                                                       {
      if (verbosity_ >= 1) {
        edm::LogPrint("RecoTauPiZeroStripPlugin3") << "<RecoTauPiZeroStripPlugin3::operator()>:";
        edm::LogPrint("RecoTauPiZeroStripPlugin3") << " minGammaEtStripSeed = " << minGammaEtStripSeed_;
        edm::LogPrint("RecoTauPiZeroStripPlugin3") << " minGammaEtStripAdd = " << minGammaEtStripAdd_;
        edm::LogPrint("RecoTauPiZeroStripPlugin3") << " minStripEt = " << minStripEt_;
      }

      PiZeroVector output;

      // Get the candidates passing our quality cuts
      qcuts_->setPV(vertexAssociator_.associatedVertex(jet));
      CandPtrs candsVector = qcuts_->filterCandRefs(pfCandidates(jet, inputParticleIds_));

      // Convert to stl::list to allow fast deletions
      CandPtrs seedCands;
      CandPtrs addCands;
      int idx = 0;
      for (CandPtrs::iterator cand = candsVector.begin(); cand != candsVector.end(); ++cand) {
        if (verbosity_ >= 1) {
          edm::LogPrint("RecoTauPiZeroStripPlugin3")
              << "PFGamma #" << idx << " (" << cand->id() << ":" << cand->key() << "): Et = " << (*cand)->et()
              << ", eta = " << (*cand)->eta() << ", phi = " << (*cand)->phi();
        }
        if ((*cand)->et() > minGammaEtStripSeed_) {
          if (verbosity_ >= 2) {
            edm::LogPrint("RecoTauPiZeroStripPlugin3") << "--> assigning seedCandId = " << seedCands.size();
            const reco::TrackBaseRef candTrack = getTrack(**cand);
            if (candTrack.isNonnull()) {
              edm::LogPrint("RecoTauPiZeroStripPlugin3")
                  << "track: Pt = " << candTrack->pt() << " eta = " << candTrack->eta()
                  << ", phi = " << candTrack->phi() << ", charge = " << candTrack->charge();
              edm::LogPrint("RecoTauPiZeroStripPlugin3")
                  << " (dZ = " << candTrack->dz(vertexAssociator_.associatedVertex(jet)->position())
                  << ", dXY = " << candTrack->dxy(vertexAssociator_.associatedVertex(jet)->position()) << ","
                  << " numHits = " << candTrack->hitPattern().numberOfValidTrackerHits()
                  << ", numPxlHits = " << candTrack->hitPattern().numberOfValidPixelHits() << ","
                  << " chi2 = " << candTrack->normalizedChi2()
                  << ", dPt/Pt = " << (candTrack->ptError() / candTrack->pt()) << ")";
            }
          }
          seedCands.push_back(*cand);
        } else if ((*cand)->et() > minGammaEtStripAdd_) {
          if (verbosity_ >= 2) {
            edm::LogPrint("RecoTauPiZeroStripPlugin3") << "--> assigning addCandId = " << addCands.size();
          }
          addCands.push_back(*cand);
        }
        ++idx;
      }

      std::vector<bool> seedCandFlags(seedCands.size());  // true/false: seedCand is already/not yet included in strip
      std::vector<bool> addCandFlags(addCands.size());    // true/false: addCand  is already/not yet included in strip

      std::set<size_t> seedCandIdsCurrentStrip;
      std::set<size_t> addCandIdsCurrentStrip;

      size_t idxSeed = 0;
      while (idxSeed < seedCands.size()) {
        if (verbosity_ >= 2)
          edm::LogPrint("RecoTauPiZeroStripPlugin3") << "processing seed #" << idxSeed;

        seedCandIdsCurrentStrip.clear();
        addCandIdsCurrentStrip.clear();

        std::unique_ptr<RecoTauPiZero> strip(new RecoTauPiZero(*seedCands[idxSeed], RecoTauPiZero::kStrips));
        strip->addDaughter(seedCands[idxSeed]);
        seedCandIdsCurrentStrip.insert(idxSeed);

        bool isCandAdded;
        int stripBuildIteration = 0;
        do {
          isCandAdded = false;

          //if ( verbosity_ >= 2 ) edm::LogPrint("RecoTauPiZeroStripPlugin3") << " adding seedCands to strip..." ;
          addCandsToStrip(*strip, seedCands, seedCandFlags, seedCandIdsCurrentStrip, isCandAdded);
          //if ( verbosity_ >= 2 ) edm::LogPrint("RecoTauPiZeroStripPlugin3") << " adding addCands to strip..." ;
          addCandsToStrip(*strip, addCands, addCandFlags, addCandIdsCurrentStrip, isCandAdded);

          if (!updateStripAfterEachDaughter_)
            p4Builder_.set(*strip);

          ++stripBuildIteration;
        } while (isCandAdded && (stripBuildIteration < maxStripBuildIterations_ || maxStripBuildIterations_ == -1));

        if (strip->et() > minStripEt_) {  // strip passed Et cuts, add it to the event
          if (verbosity_ >= 2)
            edm::LogPrint("RecoTauPiZeroStripPlugin3")
                << "Building strip: Et = " << strip->et() << ", eta = " << strip->eta() << ", phi = " << strip->phi();

          // Update the vertex
          if (strip->daughterPtr(0).isNonnull())
            strip->setVertex(strip->daughterPtr(0)->vertex());
          output.push_back(std::move(strip));

          // Mark daughters as being part of this strip
          markCandsInStrip(seedCandFlags, seedCandIdsCurrentStrip);
          markCandsInStrip(addCandFlags, addCandIdsCurrentStrip);
        } else {  // strip failed Et cuts, just skip it
          if (verbosity_ >= 2)
            edm::LogPrint("RecoTauPiZeroStripPlugin3")
                << "Discarding strip: Et = " << strip->et() << ", eta = " << strip->eta() << ", phi = " << strip->phi();
        }

        ++idxSeed;
        while (idxSeed < seedCands.size() && seedCandFlags[idxSeed]) {
          ++idxSeed;  // fast-forward to next seed cand not yet included in any strip
        }
      }

      // Check if we want to combine our strips
      if (combineStrips_ && output.size() > 1) {
        PiZeroVector stripCombinations;
        // Sort the output by descending pt
        std::sort(output.begin(), output.end(), [&](auto& arg1, auto& arg2) { return arg1->pt() > arg2->pt(); });
        // Get the end of interesting set of strips to try and combine
        PiZeroVector::const_iterator end_iter = takeNElements(output.begin(), output.end(), maxStrips_);

        // Look at all the combinations
        for (PiZeroVector::const_iterator firstIter = output.begin(); firstIter != end_iter - 1; ++firstIter) {
          for (PiZeroVector::const_iterator secondIter = firstIter + 1; secondIter != end_iter; ++secondIter) {
            auto const& first = *firstIter;
            auto const& second = *secondIter;
            Candidate::LorentzVector firstP4 = first->p4();
            Candidate::LorentzVector secondP4 = second->p4();
            // If we assume a certain mass for each strip apply it here.
            firstP4 = applyMassConstraint(firstP4, combinatoricStripMassHypo_);
            secondP4 = applyMassConstraint(secondP4, combinatoricStripMassHypo_);
            Candidate::LorentzVector totalP4 = firstP4 + secondP4;
            // Make our new combined strip
            auto combinedStrips =
                std::make_unique<RecoTauPiZero>(0,
                                                totalP4,
                                                Candidate::Point(0, 0, 0),
                                                //111, 10001, true, RecoTauPiZero::kCombinatoricStrips));
                                                111,
                                                10001,
                                                true,
                                                RecoTauPiZero::kUndefined);

            // Now loop over the strip members
            for (auto const& gamma : first->daughterPtrVector()) {
              combinedStrips->addDaughter(gamma);
            }
            for (auto const& gamma : second->daughterPtrVector()) {
              combinedStrips->addDaughter(gamma);
            }
            // Update the vertex
            if (combinedStrips->daughterPtr(0).isNonnull()) {
              combinedStrips->setVertex(combinedStrips->daughterPtr(0)->vertex());
            }

            // Add to our collection of combined strips
            stripCombinations.push_back(std::move(combinedStrips));
          }
        }
        // When done doing all the combinations, add the combined strips to the
        // output.
        std::move(stripCombinations.begin(), stripCombinations.end(), std::back_inserter(output));
      }

      // Compute correction to account for spread of photon energy in eta and phi
      // in case charged pions make nuclear interactions or photons convert within the tracking detector
      for (auto const& strip : output) {
        double bendCorrEta = 0.;
        double bendCorrPhi = 0.;
        double energySum = 0.;
        for (auto const& gamma : strip->daughterPtrVector()) {
          bendCorrEta += (gamma->energy() * etaAssociationDistance_->Eval(gamma->pt()));
          bendCorrPhi += (gamma->energy() * phiAssociationDistance_->Eval(gamma->pt()));
          energySum += gamma->energy();
        }
        if (energySum > 1.e-2) {
          bendCorrEta /= energySum;
          bendCorrPhi /= energySum;
        }
        //std::cout << "stripPt = " << strip->pt() << ": bendCorrEta = " << bendCorrEta << ", bendCorrPhi = " << bendCorrPhi << std::endl;
        strip->setBendCorrEta(bendCorrEta);
        strip->setBendCorrPhi(bendCorrPhi);
      }

      return output;
    }

Member Data Documentation

applyElecTrackQcuts_

bool reco::tau::RecoTauPiZeroStripPlugin3::applyElecTrackQcuts_

private

Definition at line 71 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by RecoTauPiZeroStripPlugin3().

combinatoricStripMassHypo_

double reco::tau::RecoTauPiZeroStripPlugin3::combinatoricStripMassHypo_

private

Definition at line 87 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by operator()(), and RecoTauPiZeroStripPlugin3().

combineStrips_

bool reco::tau::RecoTauPiZeroStripPlugin3::combineStrips_

private

Definition at line 85 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by operator()(), and RecoTauPiZeroStripPlugin3().

etaAssociationDistance_

std::unique_ptr<const TFormula> reco::tau::RecoTauPiZeroStripPlugin3::etaAssociationDistance_

private

Definition at line 78 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by addCandsToStrip(), operator()(), and RecoTauPiZeroStripPlugin3().

inputParticleIds_

std::vector<int> reco::tau::RecoTauPiZeroStripPlugin3::inputParticleIds_

private

Definition at line 77 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by operator()(), and RecoTauPiZeroStripPlugin3().

maxStripBuildIterations_

int reco::tau::RecoTauPiZeroStripPlugin3::maxStripBuildIterations_

private

Definition at line 82 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by operator()(), and RecoTauPiZeroStripPlugin3().

maxStrips_

int reco::tau::RecoTauPiZeroStripPlugin3::maxStrips_

private

Definition at line 86 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by operator()(), and RecoTauPiZeroStripPlugin3().

minGammaEtStripAdd_

double reco::tau::RecoTauPiZeroStripPlugin3::minGammaEtStripAdd_

private

Definition at line 73 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by operator()(), and RecoTauPiZeroStripPlugin3().

minGammaEtStripSeed_

double reco::tau::RecoTauPiZeroStripPlugin3::minGammaEtStripSeed_

private

Definition at line 72 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by operator()(), and RecoTauPiZeroStripPlugin3().

minStripEt_

double reco::tau::RecoTauPiZeroStripPlugin3::minStripEt_

private

Definition at line 75 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by operator()(), and RecoTauPiZeroStripPlugin3().

p4Builder_

AddFourMomenta reco::tau::RecoTauPiZeroStripPlugin3::p4Builder_

private

Definition at line 89 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by addCandsToStrip(), and operator()().

phiAssociationDistance_

std::unique_ptr<const TFormula> reco::tau::RecoTauPiZeroStripPlugin3::phiAssociationDistance_

private

Definition at line 79 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by addCandsToStrip(), operator()(), and RecoTauPiZeroStripPlugin3().

qcuts_

std::unique_ptr<RecoTauQualityCuts> reco::tau::RecoTauPiZeroStripPlugin3::qcuts_

private

Definition at line 70 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by operator()(), and RecoTauPiZeroStripPlugin3().

updateStripAfterEachDaughter_

bool reco::tau::RecoTauPiZeroStripPlugin3::updateStripAfterEachDaughter_

private

Definition at line 81 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by addCandsToStrip(), operator()(), and RecoTauPiZeroStripPlugin3().

verbosity_

int reco::tau::RecoTauPiZeroStripPlugin3::verbosity_

private

Definition at line 91 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by addCandsToStrip(), operator()(), and RecoTauPiZeroStripPlugin3().

vertexAssociator_

RecoTauVertexAssociator reco::tau::RecoTauPiZeroStripPlugin3::vertexAssociator_

private

Definition at line 68 of file RecoTauPiZeroStripPlugin3.cc.

Referenced by beginEvent(), and operator()().