#include <InclusiveVertexFinder.h>

Inheritance diagram for TemplatedInclusiveVertexFinder< InputContainer, VTX >:

Public Types
typedef std::vector< VTX >	Product

typedef InputContainer::value_type	TRK

Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
void	produce (edm::Event &event, const edm::EventSetup &es) override

	TemplatedInclusiveVertexFinder (const edm::ParameterSet &params)

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &cdesc)

Private Member Functions
std::pair< std::vector< reco::TransientTrack >, GlobalPoint >	nearTracks (const reco::TransientTrack &seed, const std::vector< reco::TransientTrack > &tracks, const reco::Vertex &primaryVertex) const

bool	trackFilter (const reco::Track &track) const

Private Attributes
std::unique_ptr< TracksClusteringFromDisplacedSeed >	clusterizer

double	fitterRatio

double	fitterSigmacut

double	fitterTini

double	maxLIP

unsigned int	maxNTracks

double	maxTimeSig

unsigned int	minHits

double	minPt

edm::EDGetTokenT< reco::BeamSpot >	token_beamSpot

edm::EDGetTokenT< reco::VertexCollection >	token_primaryVertex

edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	token_trackBuilder

edm::EDGetTokenT< InputContainer >	token_tracks

bool	useVertexFitter

bool	useVertexReco

double	vertexMinAngleCosine

double	vertexMinDLen2DSig

double	vertexMinDLenSig

std::unique_ptr< VertexReconstructor >	vtxReco

Detailed Description

template<class InputContainer, class VTX>
class TemplatedInclusiveVertexFinder< InputContainer, VTX >

Definition at line 42 of file InclusiveVertexFinder.h.

Member Typedef Documentation

◆ Product

template<class InputContainer , class VTX >

typedef std::vector<VTX> TemplatedInclusiveVertexFinder< InputContainer, VTX >::Product

Definition at line 44 of file InclusiveVertexFinder.h.

◆ TRK

template<class InputContainer , class VTX >

typedef InputContainer::value_type TemplatedInclusiveVertexFinder< InputContainer, VTX >::TRK

Definition at line 45 of file InclusiveVertexFinder.h.

Constructor & Destructor Documentation

◆ TemplatedInclusiveVertexFinder()

template<class InputContainer , class VTX >

TemplatedInclusiveVertexFinder< InputContainer, VTX >::TemplatedInclusiveVertexFinder ( const edm::ParameterSet & params )

Definition at line 132 of file InclusiveVertexFinder.h.

     : minHits(params.getParameter<unsigned int>("minHits")),
       maxNTracks(params.getParameter<unsigned int>("maxNTracks")),
       maxLIP(params.getParameter<double>("maximumLongitudinalImpactParameter")),
       maxTimeSig(params.getParameter<double>("maximumTimeSignificance")),
       minPt(params.getParameter<double>("minPt")),                                //0.8
       vertexMinAngleCosine(params.getParameter<double>("vertexMinAngleCosine")),  //0.98
       vertexMinDLen2DSig(params.getParameter<double>("vertexMinDLen2DSig")),      //2.5
       vertexMinDLenSig(params.getParameter<double>("vertexMinDLenSig")),          //0.5
       fitterSigmacut(params.getParameter<double>("fitterSigmacut")),
       fitterTini(params.getParameter<double>("fitterTini")),
       fitterRatio(params.getParameter<double>("fitterRatio")),
       useVertexFitter(params.getParameter<bool>("useDirectVertexFitter")),
       useVertexReco(params.getParameter<bool>("useVertexReco")),
       vtxReco(new ConfigurableVertexReconstructor(params.getParameter<edm::ParameterSet>("vertexReco"))),
       clusterizer(new TracksClusteringFromDisplacedSeed(params.getParameter<edm::ParameterSet>("clusterizer")))
  
 {
   token_beamSpot = consumes<reco::BeamSpot>(params.getParameter<edm::InputTag>("beamSpot"));
   token_primaryVertex = consumes<reco::VertexCollection>(params.getParameter<edm::InputTag>("primaryVertices"));
   token_tracks = consumes<InputContainer>(params.getParameter<edm::InputTag>("tracks"));
   token_trackBuilder =
       esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"));
   produces<Product>();
   //produces<reco::VertexCollection>("multi");
 }

References CalibrationSummaryClient_cfi::params, TemplatedInclusiveVertexFinder< InputContainer, VTX >::token_beamSpot, TemplatedInclusiveVertexFinder< InputContainer, VTX >::token_primaryVertex, TemplatedInclusiveVertexFinder< InputContainer, VTX >::token_trackBuilder, and TemplatedInclusiveVertexFinder< InputContainer, VTX >::token_tracks.

Member Function Documentation

◆ fillDescriptions()

template<class InputContainer , class VTX >

static void TemplatedInclusiveVertexFinder< InputContainer, VTX >::fillDescriptions ( edm::ConfigurationDescriptions & cdesc )

inlinestatic

Definition at line 48 of file InclusiveVertexFinder.h.

                                                                     {
     edm::ParameterSetDescription pdesc;
     pdesc.add<edm::InputTag>("beamSpot", edm::InputTag("offlineBeamSpot"));
     pdesc.add<edm::InputTag>("primaryVertices", edm::InputTag("offlinePrimaryVertices"));
     if (std::is_same<VTX, reco::Vertex>::value) {
       pdesc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
       pdesc.add<unsigned int>("minHits", 8);
     } else if (std::is_same<VTX, reco::VertexCompositePtrCandidate>::value) {
       pdesc.add<edm::InputTag>("tracks", edm::InputTag("particleFlow"));
       pdesc.add<unsigned int>("minHits", 0);
     } else {
       pdesc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
     }
  
     pdesc.add<double>("maximumLongitudinalImpactParameter", 0.3);
     pdesc.add<double>("maximumTimeSignificance", 3.0);
     pdesc.add<double>("minPt", 0.8);
     pdesc.add<unsigned int>("maxNTracks", 30);
     //clusterizer pset
     edm::ParameterSetDescription clusterizer;
     clusterizer.add<double>("seedMax3DIPSignificance", 9999.0);
     clusterizer.add<double>("seedMax3DIPValue", 9999.0);
     clusterizer.add<double>("seedMin3DIPSignificance", 1.2);
     clusterizer.add<double>("seedMin3DIPValue", 0.005);
     clusterizer.add<double>("clusterMaxDistance", 0.05);
     clusterizer.add<double>("clusterMaxSignificance", 4.5);
     clusterizer.add<double>("distanceRatio", 20.0);
     clusterizer.add<double>("clusterMinAngleCosine", 0.5);
     clusterizer.add<double>("maxTimeSignificance", 3.5);
     pdesc.add<edm::ParameterSetDescription>("clusterizer", clusterizer);
     // vertex and fitter config
     pdesc.add<double>("vertexMinAngleCosine", 0.95);
     pdesc.add<double>("vertexMinDLen2DSig", 2.5);
     pdesc.add<double>("vertexMinDLenSig", 0.5);
     pdesc.add<double>("fitterSigmacut", 3.0);
     pdesc.add<double>("fitterTini", 256.0);
     pdesc.add<double>("fitterRatio", 0.25);
     pdesc.add<bool>("useDirectVertexFitter", true);
     pdesc.add<bool>("useVertexReco", true);
     // vertexReco pset
     edm::ParameterSetDescription vertexReco;
     vertexReco.add<std::string>("finder", std::string("avr"));
     vertexReco.add<double>("primcut", 1.0);
     vertexReco.add<double>("seccut", 3.0);
     vertexReco.add<bool>("smoothing", true);
     pdesc.add<edm::ParameterSetDescription>("vertexReco", vertexReco);
     if (std::is_same<VTX, reco::Vertex>::value) {
       cdesc.add("inclusiveVertexFinderDefault", pdesc);
     } else if (std::is_same<VTX, reco::VertexCompositePtrCandidate>::value) {
       cdesc.add("inclusiveCandidateVertexFinderDefault", pdesc);
     } else {
       cdesc.addDefault(pdesc);
     }
   }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), TemplatedInclusiveVertexFinder< InputContainer, VTX >::clusterizer, HLT_FULL_cff::InputTag, AlCaHLTBitMon_QueryRunRegistry::string, relativeConstraints::value, and HLT_FULL_cff::vertexReco.

◆ nearTracks()

template<class InputContainer , class VTX >

std::pair<std::vector<reco::TransientTrack>, GlobalPoint> TemplatedInclusiveVertexFinder< InputContainer, VTX >::nearTracks	(	const reco::TransientTrack &	seed,
		const std::vector< reco::TransientTrack > &	tracks,
		const reco::Vertex &	primaryVertex
	)		const

private

◆ produce()

template<class InputContainer , class VTX >

void TemplatedInclusiveVertexFinder< InputContainer, VTX >::produce	(	edm::Event &	event,
		const edm::EventSetup &	es
	)

override

Definition at line 169 of file InclusiveVertexFinder.h.

                                                                                                           {
   using namespace reco;
  
   VertexDistance3D vdist;
   VertexDistanceXY vdist2d;
   MultiVertexFitter theMultiVertexFitter;
   AdaptiveVertexFitter theAdaptiveFitter(GeometricAnnealing(fitterSigmacut, fitterTini, fitterRatio),
                                          DefaultLinearizationPointFinder(),
                                          KalmanVertexUpdator<5>(),
                                          KalmanVertexTrackCompatibilityEstimator<5>(),
                                          KalmanVertexSmoother());
  
   edm::Handle<BeamSpot> beamSpot;
   event.getByToken(token_beamSpot, beamSpot);
  
   edm::Handle<VertexCollection> primaryVertices;
   event.getByToken(token_primaryVertex, primaryVertices);
  
   edm::Handle<InputContainer> tracks;
   event.getByToken(token_tracks, tracks);
  
   edm::ESHandle<TransientTrackBuilder> trackBuilder = es.getHandle(token_trackBuilder);
  
   auto recoVertices = std::make_unique<Product>();
   if (!primaryVertices->empty()) {
     const reco::Vertex &pv = (*primaryVertices)[0];
     GlobalPoint ppv(pv.position().x(), pv.position().y(), pv.position().z());
  
     std::vector<TransientTrack> tts;
     //Fill transient track vector
     for (typename InputContainer::const_iterator track = tracks->begin(); track != tracks->end(); ++track) {
       //TransientTrack tt = trackBuilder->build(ref);
       //TrackRef ref(tracks, track - tracks->begin());
       TransientTrack tt(tthelpers::buildTT(tracks, trackBuilder, track - tracks->begin()));
       if (!tt.isValid())
         continue;
       if (!trackFilter(tt.track()))
         continue;
       if (std::abs(tt.track().dz(pv.position())) > maxLIP)
         continue;
       if (edm::isFinite(tt.timeExt()) && pv.covariance(3, 3) > 0.) {  // only apply if time available
         auto tError = std::sqrt(std::pow(tt.dtErrorExt(), 2) + pv.covariance(3, 3));
         auto dtSig = std::abs(tt.timeExt() - pv.t()) / tError;
         if (dtSig > maxTimeSig)
           continue;
       }
       tt.setBeamSpot(*beamSpot);
       tts.push_back(tt);
     }
     std::vector<TracksClusteringFromDisplacedSeed::Cluster> clusters = clusterizer->clusters(pv, tts);
  
     //Create BS object from PV to feed in the AVR
     BeamSpot::CovarianceMatrix cov;
     for (unsigned int i = 0; i < 7; i++) {
       for (unsigned int j = 0; j < 7; j++) {
         if (i < 3 && j < 3)
           cov(i, j) = pv.covariance(i, j);
         else
           cov(i, j) = 0.0;
       }
     }
     BeamSpot bs(pv.position(), 0.0, 0.0, 0.0, 0.0, cov, BeamSpot::Unknown);
  
     int i = 0;
 #ifdef VTXDEBUG
  
     std::cout << "CLUSTERS " << clusters.size() << std::endl;
 #endif
  
     for (std::vector<TracksClusteringFromDisplacedSeed::Cluster>::iterator cluster = clusters.begin();
          cluster != clusters.end();
          ++cluster, ++i) {
       if (cluster->tracks.size() < 2 || cluster->tracks.size() > maxNTracks)
         continue;
       std::vector<TransientVertex> vertices;
       if (useVertexReco) {
         vertices = vtxReco->vertices(cluster->tracks, bs);  // attempt with config given reconstructor
       }
       TransientVertex singleFitVertex;
       if (useVertexFitter) {
         singleFitVertex = theAdaptiveFitter.vertex(cluster->tracks, cluster->seedPoint);  //attempt with direct fitting
         if (singleFitVertex.isValid())
           vertices.push_back(singleFitVertex);
       }
  
       // for each transient vertex state determine if a time can be measured and fill covariance
       if (pv.covariance(3, 3) > 0.) {
         for (auto &vtx : vertices) {
           svhelper::updateVertexTime(vtx);
         }
       }
  
       for (std::vector<TransientVertex>::const_iterator v = vertices.begin(); v != vertices.end(); ++v) {
         Measurement1D dlen = vdist.distance(pv, *v);
         Measurement1D dlen2 = vdist2d.distance(pv, *v);
 #ifdef VTXDEBUG
         VTX vv(*v);
         std::cout << "V chi2/n: " << v->normalisedChiSquared() << " ndof: " << v->degreesOfFreedom();
         std::cout << " dlen: " << dlen.value() << " error: " << dlen.error() << " signif: " << dlen.significance();
         std::cout << " dlen2: " << dlen2.value() << " error2: " << dlen2.error()
                   << " signif2: " << dlen2.significance();
         std::cout << " pos: " << vv.position() << " error: " << vv.xError() << " " << vv.yError() << " " << vv.zError()
                   << std::endl;
         std::cout << " time: " << vv.time() << " error: " << vv.tError() << std::endl;
 #endif
         GlobalVector dir;
         std::vector<reco::TransientTrack> ts = v->originalTracks();
         for (std::vector<reco::TransientTrack>::const_iterator i = ts.begin(); i != ts.end(); ++i) {
           float w = v->trackWeight(*i);
           if (w > 0.5)
             dir += i->impactPointState().globalDirection();
 #ifdef VTXDEBUG
           std::cout << "\t[" << (*i).track().pt() << ": " << (*i).track().eta() << ", " << (*i).track().phi() << "], "
                     << w << std::endl;
 #endif
         }
         GlobalPoint sv((*v).position().x(), (*v).position().y(), (*v).position().z());
         float vscal = dir.unit().dot((sv - ppv).unit());
         if (dlen.significance() > vertexMinDLenSig &&
             ((vertexMinAngleCosine > 0) ? (vscal > vertexMinAngleCosine) : (vscal < vertexMinAngleCosine)) &&
             v->normalisedChiSquared() < 10 && dlen2.significance() > vertexMinDLen2DSig) {
           recoVertices->push_back(*v);
  
 #ifdef VTXDEBUG
           std::cout << "ADDED" << std::endl;
 #endif
         }
       }
     }
 #ifdef VTXDEBUG
  
     std::cout << "Final put  " << recoVertices->size() << std::endl;
 #endif
   }
  
   event.put(std::move(recoVertices));
 }

References funct::abs(), pwdgSkimBPark_cfi::beamSpot, cms::cuda::bs, tthelpers::buildTT(), HLT_FULL_cff::clusterizer, bsc_activity_cfg::clusters, gather_cfg::cout, DeadROC_duringRun::dir, VertexDistanceXY::distance(), VertexDistance3D::distance(), Measurement1D::error(), HLT_FULL_cff::fitterRatio, HLT_FULL_cff::fitterSigmacut, HLT_FULL_cff::fitterTini, edm::EventSetup::getHandle(), mps_fire::i, edm::isFinite(), TransientVertex::isValid(), dqmiolumiharvest::j, HLT_FULL_cff::maxNTracks, eostools::move(), funct::pow(), HLT_FULL_cff::primaryVertices, MetAnalyzer::pv(), Measurement1D::significance(), mathSSE::sqrt(), pfDeepBoostedJetPreprocessParams_cfi::sv, HLT_FULL_cff::track, MinBiasPDSkim_cfg::trackFilter, tracks, groupFilesInBlocks::tt, unit(), reco::BeamSpot::Unknown, svhelper::updateVertexTime(), HLT_FULL_cff::useVertexReco, findQualityFiles::v, Measurement1D::value(), AdaptiveVertexFitter::vertex(), HLT_FULL_cff::vertexMinAngleCosine, HLT_FULL_cff::vertexMinDLen2DSig, HLT_FULL_cff::vertexMinDLenSig, AlignmentTracksFromVertexSelector_cfi::vertices, extraflags_cff::vtx, and w.

◆ trackFilter()

template<class InputContainer , class VTX >

bool TemplatedInclusiveVertexFinder< InputContainer, VTX >::trackFilter ( const reco::Track & track ) const

private

Definition at line 159 of file InclusiveVertexFinder.h.

                                                                                                   {
   if (track.hitPattern().numberOfValidHits() < (int)minHits)
     return false;
   if (track.pt() < minPt)
     return false;
  
   return true;
 }

References createfilelist::int, reco_skim_cfg_mod::minHits, beam_dqm_sourceclient-live_cfg::minPt, and HLT_FULL_cff::track.

Member Data Documentation

◆ clusterizer

template<class InputContainer , class VTX >

std::unique_ptr<TracksClusteringFromDisplacedSeed> TemplatedInclusiveVertexFinder< InputContainer, VTX >::clusterizer

private

Definition at line 129 of file InclusiveVertexFinder.h.

Referenced by TemplatedInclusiveVertexFinder< InputContainer, VTX >::fillDescriptions().

◆ fitterRatio

template<class InputContainer , class VTX >

double TemplatedInclusiveVertexFinder< InputContainer, VTX >::fitterRatio

private

Definition at line 125 of file InclusiveVertexFinder.h.

◆ fitterSigmacut

template<class InputContainer , class VTX >

double TemplatedInclusiveVertexFinder< InputContainer, VTX >::fitterSigmacut

private

Definition at line 123 of file InclusiveVertexFinder.h.

◆ fitterTini

template<class InputContainer , class VTX >

double TemplatedInclusiveVertexFinder< InputContainer, VTX >::fitterTini

private

Definition at line 124 of file InclusiveVertexFinder.h.

◆ maxLIP

template<class InputContainer , class VTX >

double TemplatedInclusiveVertexFinder< InputContainer, VTX >::maxLIP

private

Definition at line 117 of file InclusiveVertexFinder.h.

◆ maxNTracks

template<class InputContainer , class VTX >

unsigned int TemplatedInclusiveVertexFinder< InputContainer, VTX >::maxNTracks

private

Definition at line 116 of file InclusiveVertexFinder.h.

◆ maxTimeSig

template<class InputContainer , class VTX >

double TemplatedInclusiveVertexFinder< InputContainer, VTX >::maxTimeSig

private

Definition at line 118 of file InclusiveVertexFinder.h.

◆ minHits

template<class InputContainer , class VTX >

unsigned int TemplatedInclusiveVertexFinder< InputContainer, VTX >::minHits

private

Definition at line 115 of file InclusiveVertexFinder.h.

◆ minPt

template<class InputContainer , class VTX >

double TemplatedInclusiveVertexFinder< InputContainer, VTX >::minPt

private

Definition at line 119 of file InclusiveVertexFinder.h.

◆ token_beamSpot

template<class InputContainer , class VTX >

edm::EDGetTokenT<reco::BeamSpot> TemplatedInclusiveVertexFinder< InputContainer, VTX >::token_beamSpot

private

Definition at line 111 of file InclusiveVertexFinder.h.

Referenced by TemplatedInclusiveVertexFinder< InputContainer, VTX >::TemplatedInclusiveVertexFinder().

◆ token_primaryVertex

template<class InputContainer , class VTX >

edm::EDGetTokenT<reco::VertexCollection> TemplatedInclusiveVertexFinder< InputContainer, VTX >::token_primaryVertex

private

Definition at line 112 of file InclusiveVertexFinder.h.

Referenced by TemplatedInclusiveVertexFinder< InputContainer, VTX >::TemplatedInclusiveVertexFinder().

◆ token_trackBuilder

template<class InputContainer , class VTX >

edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> TemplatedInclusiveVertexFinder< InputContainer, VTX >::token_trackBuilder

private

Definition at line 114 of file InclusiveVertexFinder.h.

Referenced by TemplatedInclusiveVertexFinder< InputContainer, VTX >::TemplatedInclusiveVertexFinder().

◆ token_tracks

template<class InputContainer , class VTX >

edm::EDGetTokenT<InputContainer> TemplatedInclusiveVertexFinder< InputContainer, VTX >::token_tracks

private

Definition at line 113 of file InclusiveVertexFinder.h.

Referenced by TemplatedInclusiveVertexFinder< InputContainer, VTX >::TemplatedInclusiveVertexFinder().

◆ useVertexFitter

template<class InputContainer , class VTX >

bool TemplatedInclusiveVertexFinder< InputContainer, VTX >::useVertexFitter

private

Definition at line 126 of file InclusiveVertexFinder.h.

◆ useVertexReco

template<class InputContainer , class VTX >

bool TemplatedInclusiveVertexFinder< InputContainer, VTX >::useVertexReco

private

Definition at line 127 of file InclusiveVertexFinder.h.

◆ vertexMinAngleCosine

template<class InputContainer , class VTX >

double TemplatedInclusiveVertexFinder< InputContainer, VTX >::vertexMinAngleCosine

private

Definition at line 120 of file InclusiveVertexFinder.h.

◆ vertexMinDLen2DSig

template<class InputContainer , class VTX >

double TemplatedInclusiveVertexFinder< InputContainer, VTX >::vertexMinDLen2DSig

private

Definition at line 121 of file InclusiveVertexFinder.h.

◆ vertexMinDLenSig

template<class InputContainer , class VTX >

double TemplatedInclusiveVertexFinder< InputContainer, VTX >::vertexMinDLenSig

private

Definition at line 122 of file InclusiveVertexFinder.h.

◆ vtxReco

template<class InputContainer , class VTX >

std::unique_ptr<VertexReconstructor> TemplatedInclusiveVertexFinder< InputContainer, VTX >::vtxReco

private

Definition at line 128 of file InclusiveVertexFinder.h.

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

template<class InputContainer, class VTX> class TemplatedInclusiveVertexFinder< InputContainer, VTX >

Member Typedef Documentation

◆ Product

◆ TRK

Constructor & Destructor Documentation

◆ TemplatedInclusiveVertexFinder()

Member Function Documentation

◆ fillDescriptions()

◆ nearTracks()

◆ produce()

◆ trackFilter()

Member Data Documentation

◆ clusterizer

◆ fitterRatio

◆ fitterSigmacut

◆ fitterTini

◆ maxLIP

◆ maxNTracks

◆ maxTimeSig

◆ minHits

◆ minPt

◆ token_beamSpot

◆ token_primaryVertex

◆ token_trackBuilder

◆ token_tracks

◆ useVertexFitter

◆ useVertexReco

◆ vertexMinAngleCosine

◆ vertexMinDLen2DSig

◆ vertexMinDLenSig

◆ vtxReco

template<class InputContainer, class VTX>
class TemplatedInclusiveVertexFinder< InputContainer, VTX >