reco::tau::RecoTauVertexAssociator Class Reference

#include <RecoTauVertexAssociator.h>

Public Types
enum	Algorithm { kHighestPtInEvent, kClosestDeltaZ, kHighestWeigtForLeadTrack, kCombined }

Public Member Functions
reco::VertexRef	associatedVertex (const PFJet &jet) const
reco::VertexRef	associatedVertex (const PFTau &tau) const
reco::TrackBaseRef	getLeadTrack (const PFJet &jet) const
	RecoTauVertexAssociator (const edm::ParameterSet &pset, edm::ConsumesCollector &&iC)
void	setEvent (const edm::Event &evt)
	Load the vertices from the event. More...
virtual	~RecoTauVertexAssociator ()

Private Types
enum	{ kLeadTrack, kLeadPFCand, kMinLeadTrackOrPFCand, kFirstTrack }

Private Attributes
Algorithm	algo_
std::string	algorithm_
std::map< const reco::PFJet *, reco::VertexRef > *	jetToVertexAssociation_
edm::EventNumber_t	lastEvent_
int	leadingTrkOrPFCandOption_
RecoTauQualityCuts *	qcuts_
bool	recoverLeadingTrk_
std::vector< reco::VertexRef >	selectedVertices_
int	verbosity_
StringCutObjectSelector < reco::Vertex > *	vertexSelector_
edm::InputTag	vertexTag_
edm::EDGetTokenT < reco::VertexCollection >	vxToken_
bool	vxTrkFiltering_

Detailed Description

Definition at line 49 of file RecoTauVertexAssociator.h.

Member Enumeration Documentation

anonymous enum

private

Enumerator
kLeadTrack
kLeadPFCand
kMinLeadTrackOrPFCand
kFirstTrack

Definition at line 80 of file RecoTauVertexAssociator.h.

{ kLeadTrack, kLeadPFCand, kMinLeadTrackOrPFCand, kFirstTrack };

enum reco::tau::RecoTauVertexAssociator::Algorithm

Enumerator
kHighestPtInEvent
kClosestDeltaZ
kHighestWeigtForLeadTrack
kCombined

Definition at line 51 of file RecoTauVertexAssociator.h.

                   {
      kHighestPtInEvent,
      kClosestDeltaZ,
      kHighestWeigtForLeadTrack,
      kCombined
    };

Constructor & Destructor Documentation

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

Definition at line 129 of file RecoTauVertexAssociator.cc.

References algo_, algorithm_, assert(), Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), HLT_25ns14e33_v1_cff::InputTag, kClosestDeltaZ, kCombined, kFirstTrack, kHighestPtInEvent, kHighestWeigtForLeadTrack, kLeadPFCand, kLeadTrack, kMinLeadTrackOrPFCand, leadingTrkOrPFCandOption_, qcuts_, recoverLeadingTrk_, AlCaHLTBitMon_QueryRunRegistry::string, verbosity_, HLT_25ns14e33_v1_cff::vertexSelection, vertexSelector_, vertexTag_, vxToken_, and vxTrkFiltering_.

  : vertexSelector_(0),
    qcuts_(0),
    jetToVertexAssociation_(0),
    lastEvent_(0)
{
  //std::cout << "<RecoTauVertexAssociator::RecoTauVertexAssociator>:" << std::endl;

  vertexTag_ = edm::InputTag("offlinePrimaryVertices", "");
  algorithm_ = "highestPtInEvent";
  // Sanity check, will remove once HLT module configs are updated.
  if ( !pset.exists("primaryVertexSrc") || !pset.exists("pvFindingAlgo") ) {
    edm::LogWarning("NoVertexFindingMethodSpecified")
      << "The PSet passed to the RecoTauVertexAssociator was incorrectly configured."
      << " The vertex will be taken as the highest Pt vertex from the 'offlinePrimaryVertices' collection."
      << std::endl;
  } else {
    vertexTag_ = pset.getParameter<edm::InputTag>("primaryVertexSrc");
    algorithm_ = pset.getParameter<std::string>("pvFindingAlgo");
  }
    
  if ( pset.exists("vxAssocQualityCuts") ) {
    //std::cout << " reading 'vxAssocQualityCuts'" << std::endl;
    qcuts_ = new RecoTauQualityCuts(pset.getParameterSet("vxAssocQualityCuts"));
  } else {
    //std::cout << " reading 'signalQualityCuts'" << std::endl;
    qcuts_ = new RecoTauQualityCuts(pset.getParameterSet("signalQualityCuts"));
  }
  assert(qcuts_);

  vxTrkFiltering_ = false;
  if ( !pset.exists("vertexTrackFiltering") && pset.exists("vxAssocQualityCuts") ) {
    edm::LogWarning("NoVertexTrackFilteringSpecified")
      << "The PSet passed to the RecoTauVertexAssociator was incorrectly configured." 
      << " Please define vertexTrackFiltering in config file." 
      << " No filtering of tracks to vertices will be applied."
      << std::endl;
  } else {
    vxTrkFiltering_ = pset.exists("vertexTrackFiltering") ? 
      pset.getParameter<bool>("vertexTrackFiltering") : false;
  }
  if ( pset.exists("vertexSelection") ) {
    std::string vertexSelection = pset.getParameter<std::string>("vertexSelection");
    if ( vertexSelection != "" ) {
      vertexSelector_ = new StringCutObjectSelector<reco::Vertex>(vertexSelection);
    }
  }
  
  if ( algorithm_ == "highestPtInEvent" ) {
    algo_ = kHighestPtInEvent;
  } else if ( algorithm_ == "closestInDeltaZ" ) {
    algo_ = kClosestDeltaZ;
  } else if ( algorithm_ == "highestWeightForLeadTrack" ) {
    algo_ = kHighestWeigtForLeadTrack;
  } else if ( algorithm_ == "combined" ) {
    algo_ = kCombined;
  } else {
    throw cms::Exception("BadVertexAssociatorConfig")
      << "Invalid Configuration parameter 'algorithm' " << algorithm_ << "." 
      << " Valid options are: 'highestPtInEvent', 'closestInDeltaZ', 'highestWeightForLeadTrack' and 'combined'.\n";
  }

  vxToken_ = iC.consumes<reco::VertexCollection>(vertexTag_);

  recoverLeadingTrk_ = pset.exists("recoverLeadingTrk") ? 
    pset.getParameter<bool>("recoverLeadingTrk") : false;

  std::string leadingTrkOrPFCandOption_string = pset.exists("leadingTrkOrPFCandOption") ? pset.getParameter<std::string>("leadingTrkOrPFCandOption") : "firstTrack" ;
  if      ( leadingTrkOrPFCandOption_string == "leadTrack"  ) leadingTrkOrPFCandOption_ = kLeadTrack;
  else if ( leadingTrkOrPFCandOption_string == "leadPFCand" ) leadingTrkOrPFCandOption_ = kLeadPFCand;
  else if ( leadingTrkOrPFCandOption_string == "minLeadTrackOrPFCand" ) leadingTrkOrPFCandOption_ = kMinLeadTrackOrPFCand;
  else if ( leadingTrkOrPFCandOption_string == "firstTrack" ) leadingTrkOrPFCandOption_ = kFirstTrack;
  else throw cms::Exception("BadVertexAssociatorConfig")
    << "Invalid Configuration parameter 'leadingTrkOrPFCandOption' " << leadingTrkOrPFCandOption_string << "." 
    << " Valid options are: 'leadTrack', 'leadPFCand', 'firstTrack'.\n";
  
  verbosity_ = ( pset.exists("verbosity") ) ?
    pset.getParameter<int>("verbosity") : 0;
}

reco::tau::RecoTauVertexAssociator::~RecoTauVertexAssociator ( )

virtual

Definition at line 209 of file RecoTauVertexAssociator.cc.

References jetToVertexAssociation_, qcuts_, and vertexSelector_.

{ 
  delete vertexSelector_; 
  delete qcuts_;
  delete jetToVertexAssociation_;
}

Member Function Documentation

reco::VertexRef reco::tau::RecoTauVertexAssociator::associatedVertex

(

const PFJet &

jet

)

const

Get the primary vertex associated to a given jet. Returns a null Ref if no vertex is found.

Definition at line 248 of file RecoTauVertexAssociator.cc.

References algo_, algorithm_, gather_cfg::cout, alignCSCRings::e, reco::LeafCandidate::eta(), reco::TrackBase::eta(), getLeadTrack(), edm::RefToBase< T >::isNonnull(), metsig::jet, jetToVertexAssociation_, kClosestDeltaZ, kCombined, kHighestPtInEvent, kHighestWeigtForLeadTrack, singlePfTauSkim_cff::leadTrack, reco::LeafCandidate::phi(), reco::TrackBase::phi(), reco::LeafCandidate::pt(), reco::TrackBase::pt(), recoverLeadingTrk_, selectedVertices_, verbosity_, vertexTag_, and puppiForMET_cff::weight.

Referenced by associatedVertex(), Tau.Tau::dxy(), Muon.Muon::dxy(), Tau.Tau::dxy_approx(), Tau.Tau::dz(), Muon.Muon::dz(), reco::tau::RecoTauImpactParameterSignificancePlugin::operator()(), reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin::operator()(), reco::tau::PFRecoTauChargedHadronFromTrackPlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin2::operator()(), reco::tau::RecoTauPiZeroStripPlugin3::operator()(), reco::tau::RecoTauBuilderPlugin::primaryVertex(), and Tau.Tau::zImpact().

{
  if ( verbosity_ >= 1 ) {
    std::cout << "<RecoTauVertexAssociator::associatedVertex>:" << std::endl;
    std::cout << " jet: Pt = " << jet.pt() << ", eta = " << jet.eta() << ", phi = " << jet.phi() << std::endl;
    std::cout << " num. Vertices = " << selectedVertices_.size() << std::endl;
    std::cout << " size(jetToVertexAssociation) = " << jetToVertexAssociation_->size() << std::endl;
    std::cout << " vertexTag = " << vertexTag_ << std::endl;
    std::cout << " algorithm = " << algorithm_ << std::endl;
    std::cout << " recoverLeadingTrk = " << recoverLeadingTrk_ << std::endl;
  }

  reco::VertexRef jetVertex = ( selectedVertices_.size() > 0 ) ? selectedVertices_[0] : reco::VertexRef();
  const PFJet* jetPtr = &jet;

  // check if jet-vertex association has been determined for this jet before
  std::map<const reco::PFJet*, reco::VertexRef>::iterator vertexPtr = jetToVertexAssociation_->find(jetPtr);
  if ( vertexPtr != jetToVertexAssociation_->end() ) {
    jetVertex = vertexPtr->second;
  } else {
    // no jet-vertex association exists for this jet yet, compute it!
    if ( algo_ == kHighestPtInEvent ) {
      if ( selectedVertices_.size() > 0 ) jetVertex = selectedVertices_[0];
    } else if ( algo_ == kClosestDeltaZ ) {
      // find "leading" (highest Pt) track in jet
      reco::TrackBaseRef leadTrack = getLeadTrack(jet);
      if ( verbosity_ ) {
    if ( leadTrack.isNonnull() ) std::cout << "leadTrack: Pt = " << leadTrack->pt() << ", eta = " << leadTrack->eta() << ", phi = " << leadTrack->phi() << std::endl;
    else std::cout << "leadTrack: N/A" << std::endl;
      }
      if ( leadTrack.isNonnull() ) {
    double closestDistance = 1.e+6;
    DZtoTrack dzComputer(leadTrack);
    // Find the vertex that has the lowest dZ to the leading track
    int idxVertex = 0;
    for ( std::vector<reco::VertexRef>::const_iterator selectedVertex = selectedVertices_.begin();
          selectedVertex != selectedVertices_.end(); ++selectedVertex ) {
      double dZ = dzComputer(*selectedVertex);
      if ( verbosity_ ) {
        std::cout << "vertex #" << idxVertex << ": x = " << (*selectedVertex)->position().x() << ", y = " << (*selectedVertex)->position().y() << ", z = " << (*selectedVertex)->position().z() 
              << " --> dZ = " << dZ << std::endl;
      }
      if ( dZ < closestDistance ) {
        jetVertex = (*selectedVertex);
        closestDistance = dZ;
      }
      ++idxVertex;
    }
      }
    } else if ( algo_ == kHighestWeigtForLeadTrack || algo_ == kCombined ) {
      reco::TrackBaseRef leadTrack = getLeadTrack(jet);
      if ( verbosity_ ) {
    if ( leadTrack.isNonnull() ) std::cout << "leadTrack: Pt = " << leadTrack->pt() << ", eta = " << leadTrack->eta() << ", phi = " << leadTrack->phi() << std::endl;
    else std::cout << "leadTrack: N/A" << std::endl;
      }
      if ( leadTrack.isNonnull() ) {
    double largestWeight = -1.;
    // Find the vertex that has the highest association probability to the leading track
    TrackWeightInVertex weightComputer(leadTrack);
    int idxVertex = 0;
    for ( std::vector<reco::VertexRef>::const_iterator selectedVertex = selectedVertices_.begin();
          selectedVertex != selectedVertices_.end(); ++selectedVertex ) {
      double weight = weightComputer(*selectedVertex);
      if ( verbosity_ ) {
        std::cout << "vertex #" << idxVertex << ": x = " << (*selectedVertex)->position().x() << ", y = " << (*selectedVertex)->position().y() << ", z = " << (*selectedVertex)->position().z() 
              << " --> weight = " << weight << std::endl;
      }
      if ( weight > largestWeight ) {
        jetVertex = (*selectedVertex);
        largestWeight = weight;
      }
      ++idxVertex;
    }
    // the weight was never larger than zero
    if ( algo_ == kCombined && largestWeight < 1.e-7 ) {
      if ( verbosity_ ) {
        std::cout << "No vertex had positive weight! Trying dZ instead... " << std::endl;
      }
      double closestDistance = 1.e+6;
      DZtoTrack dzComputer(leadTrack);
      // Find the vertex that has the lowest dZ to the leading track
      int idxVertex = 0;
      for ( std::vector<reco::VertexRef>::const_iterator selectedVertex = selectedVertices_.begin();
        selectedVertex != selectedVertices_.end(); ++selectedVertex ) {
        double dZ = dzComputer(*selectedVertex);
        if ( verbosity_ ) {
          std::cout << "vertex #" << idxVertex << ": x = " << (*selectedVertex)->position().x() << ", y = " << (*selectedVertex)->position().y() << ", z = " << (*selectedVertex)->position().z() 
            << " --> dZ = " << dZ << std::endl;
        }
        if ( dZ < closestDistance ) {
          jetVertex = (*selectedVertex);
          closestDistance = dZ;
        }
        ++idxVertex;
      }
    }
      }
    }
    
    jetToVertexAssociation_->insert(std::pair<const PFJet*, reco::VertexRef>(jetPtr, jetVertex));
  }

  if ( verbosity_ >= 1 ) {
    std::cout << "--> returning vertex: x = " << jetVertex->position().x() << ", y = " << jetVertex->position().y() << ", z = " << jetVertex->position().z() << std::endl;
  }
  
  return jetVertex;
}

reco::VertexRef reco::tau::RecoTauVertexAssociator::associatedVertex

(

const PFTau &

tau

)

const

Convenience function to get the PV associated to the jet that seeded this tau.

Definition at line 239 of file RecoTauVertexAssociator.cc.

References associatedVertex(), edm::Ref< C, T, F >::isNull(), reco::PFTau::jetRef(), and reco::PFTau::pfTauTagInfoRef().

Referenced by Tau.Tau::dxy(), Muon.Muon::dxy(), Tau.Tau::dxy_approx(), Tau.Tau::dz(), Muon.Muon::dz(), and Tau.Tau::zImpact().

{
  reco::PFJetRef jetRef = tau.jetRef();
  // FIXME workaround for HLT which does not use updated data format
  if ( jetRef.isNull() ) jetRef = tau.pfTauTagInfoRef()->pfjetRef();
  return associatedVertex(*jetRef);
}

reco::TrackBaseRef reco::tau::RecoTauVertexAssociator::getLeadTrack

(

const PFJet &

jet

)

const

Definition at line 20 of file RecoTauVertexAssociator.cc.

References assert(), gather_cfg::cout, reco::LeafCandidate::eta(), reco::tau::RecoTauQualityCuts::filterCandRefs(), edm::Ptr< T >::isNonnull(), edm::Ptr< T >::isNull(), kFirstTrack, kLeadPFCand, kLeadTrack, kMinLeadTrackOrPFCand, leadingTrkOrPFCandOption_, reco::tau::leadPFCand(), Min(), reco::tau::pfChargedCands(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::TrackBase::pt(), reco::TrackBase::ptError(), qcuts_, recoverLeadingTrk_, listHistos::trackPt, verbosity_, and vxTrkFiltering_.

Referenced by associatedVertex().

{
  std::vector<PFCandidatePtr> chargedPFCands = pfChargedCands(jet, true);
  if ( verbosity_ >= 1 ) {
    std::cout << "<RecoTauVertexAssociator::getLeadTrack>:" << std::endl;
    std::cout << " jet: Pt = " << jet.pt() << ", eta = " << jet.eta() << ", phi = " << jet.phi() << std::endl;
    std::cout << " num. chargedPFCands = " << chargedPFCands.size() << std::endl;
    std::cout << " vxTrkFiltering = " << vxTrkFiltering_ << std::endl;
  }

  if ( chargedPFCands.size() == 0 ) {
    return reco::TrackBaseRef();
  }

  std::vector<PFCandidatePtr> selectedPFCands;
  if ( vxTrkFiltering_ ) {
    selectedPFCands = qcuts_->filterCandRefs(chargedPFCands);
  } else { 
    selectedPFCands = chargedPFCands;
  }
  if ( verbosity_ >= 1 ) {
    std::cout << " num. selectedPFCands = " << selectedPFCands.size() << std::endl;
  }

  PFCandidatePtr leadPFCand;
  if ( selectedPFCands.size() >= 1 ) {
    double leadTrackPt = 0.;
    if ( leadingTrkOrPFCandOption_ == kFirstTrack){ leadPFCand=selectedPFCands[0];}
    else
    {
      for ( std::vector<PFCandidatePtr>::const_iterator pfCand = selectedPFCands.begin();
      pfCand != selectedPFCands.end(); ++pfCand ) {
        const reco::Track* track = 0;
        if ( (*pfCand)->trackRef().isNonnull() ) track = (*pfCand)->trackRef().get();
        else if ( (*pfCand)->gsfTrackRef().isNonnull() ) track = (*pfCand)->gsfTrackRef().get();
        if ( !track ) continue;
        double trackPt = 0.;
        if ( leadingTrkOrPFCandOption_ == kLeadTrack ) {
      //double trackPt = track->pt();
      trackPt = track->pt() - 2.*track->ptError();
        } else if ( leadingTrkOrPFCandOption_ == kLeadPFCand ) {
      trackPt = (*pfCand)->pt();
        } else if ( leadingTrkOrPFCandOption_ == kMinLeadTrackOrPFCand ) {
      trackPt = TMath::Min(track->pt(), (double)(*pfCand)->pt());
    } else assert(0);
        if ( trackPt > leadTrackPt ) {
          leadPFCand = (*pfCand);
      leadTrackPt = trackPt;
        }
      }
    }
  }
  if ( leadPFCand.isNull() ) {
    if ( recoverLeadingTrk_ ) {
      leadPFCand = chargedPFCands[0];
    } else {
      return reco::TrackBaseRef();
    } 
  }
  if ( verbosity_ >= 1 ) {
    std::cout << "leadPFCand: Pt = " << leadPFCand->pt() << ", eta = " << leadPFCand->eta() << ", phi = " << leadPFCand->phi() << std::endl;
  }
  
  if ( leadPFCand->trackRef().isNonnull() ) {
    return reco::TrackBaseRef(leadPFCand->trackRef());
  } else if ( leadPFCand->gsfTrackRef().isNonnull() ) {
    return reco::TrackBaseRef(leadPFCand->gsfTrackRef());
  } 
  return reco::TrackBaseRef();
}

void reco::tau::RecoTauVertexAssociator::setEvent

(

const edm::Event &

evt

)

Load the vertices from the event.

Definition at line 216 of file RecoTauVertexAssociator.cc.

References edm::EventID::event(), edm::Event::getByToken(), edm::EventBase::id(), jetToVertexAssociation_, lastEvent_, qcuts_, selectedVertices_, reco::tau::RecoTauQualityCuts::setPV(), vertexSelector_, HLT_25ns14e33_v1_cff::vertices, and vxToken_.

Referenced by reco::tau::RecoTauImpactParameterSignificancePlugin::beginEvent(), reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::beginEvent(), reco::tau::RecoTauPiZeroStripPlugin::beginEvent(), reco::tau::PFRecoTauChargedHadronFromTrackPlugin::beginEvent(), reco::tau::RecoTauPiZeroStripPlugin2::beginEvent(), reco::tau::RecoTauPiZeroStripPlugin3::beginEvent(), and reco::tau::RecoTauBuilderPlugin::beginEvent().

{
  edm::Handle<reco::VertexCollection> vertices;
  evt.getByToken(vxToken_, vertices);
  selectedVertices_.clear();
  selectedVertices_.reserve(vertices->size());
  for ( size_t idxVertex = 0; idxVertex < vertices->size(); ++idxVertex ) {
    reco::VertexRef vertex(vertices, idxVertex);
    if ( vertexSelector_ && !(*vertexSelector_)(*vertex) ) continue;
    selectedVertices_.push_back(vertex);
  }
  if ( selectedVertices_.size() > 0 ) {
    qcuts_->setPV(selectedVertices_[0]);
  }
  edm::EventNumber_t currentEvent = evt.id().event();
  if ( currentEvent != lastEvent_ || !jetToVertexAssociation_ ) {
    if ( !jetToVertexAssociation_ ) jetToVertexAssociation_ = new std::map<const reco::PFJet*, reco::VertexRef>;
    else jetToVertexAssociation_->clear();
    lastEvent_ = currentEvent;
  }
}

Member Data Documentation

Algorithm reco::tau::RecoTauVertexAssociator::algo_

private

Definition at line 76 of file RecoTauVertexAssociator.h.

Referenced by associatedVertex(), and RecoTauVertexAssociator().

std::string reco::tau::RecoTauVertexAssociator::algorithm_

private

Definition at line 75 of file RecoTauVertexAssociator.h.

Referenced by associatedVertex(), and RecoTauVertexAssociator().

std::map<const reco::PFJet*, reco::VertexRef>* reco::tau::RecoTauVertexAssociator::jetToVertexAssociation_

private

Definition at line 84 of file RecoTauVertexAssociator.h.

Referenced by associatedVertex(), setEvent(), and ~RecoTauVertexAssociator().

edm::EventNumber_t reco::tau::RecoTauVertexAssociator::lastEvent_

private

Definition at line 85 of file RecoTauVertexAssociator.h.

Referenced by setEvent().

int reco::tau::RecoTauVertexAssociator::leadingTrkOrPFCandOption_

private

Definition at line 81 of file RecoTauVertexAssociator.h.

Referenced by getLeadTrack(), and RecoTauVertexAssociator().

RecoTauQualityCuts* reco::tau::RecoTauVertexAssociator::qcuts_

private

Definition at line 78 of file RecoTauVertexAssociator.h.

Referenced by getLeadTrack(), RecoTauVertexAssociator(), setEvent(), and ~RecoTauVertexAssociator().

bool reco::tau::RecoTauVertexAssociator::recoverLeadingTrk_

private

Definition at line 79 of file RecoTauVertexAssociator.h.

Referenced by associatedVertex(), getLeadTrack(), and RecoTauVertexAssociator().

std::vector<reco::VertexRef> reco::tau::RecoTauVertexAssociator::selectedVertices_

private

Definition at line 74 of file RecoTauVertexAssociator.h.

Referenced by associatedVertex(), and setEvent().

int reco::tau::RecoTauVertexAssociator::verbosity_

private

Definition at line 86 of file RecoTauVertexAssociator.h.

Referenced by associatedVertex(), getLeadTrack(), and RecoTauVertexAssociator().

StringCutObjectSelector<reco::Vertex>* reco::tau::RecoTauVertexAssociator::vertexSelector_

private

Definition at line 73 of file RecoTauVertexAssociator.h.

Referenced by RecoTauVertexAssociator(), setEvent(), and ~RecoTauVertexAssociator().

edm::InputTag reco::tau::RecoTauVertexAssociator::vertexTag_

private

Definition at line 71 of file RecoTauVertexAssociator.h.

Referenced by associatedVertex(), and RecoTauVertexAssociator().

edm::EDGetTokenT<reco::VertexCollection> reco::tau::RecoTauVertexAssociator::vxToken_

private

Definition at line 82 of file RecoTauVertexAssociator.h.

Referenced by RecoTauVertexAssociator(), and setEvent().

bool reco::tau::RecoTauVertexAssociator::vxTrkFiltering_

private

Definition at line 72 of file RecoTauVertexAssociator.h.

Referenced by getLeadTrack(), and RecoTauVertexAssociator().