#include <TemplatedVertexArbitrator.h>

Inheritance diagram for TemplatedVertexArbitrator< InputContainer, VTX >:

Public Types
typedef std::vector< VTX >	Product

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

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

	TemplatedVertexArbitrator (const edm::ParameterSet &params)

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Private Member Functions
bool	trackFilter (const reco::TrackRef &track) const

Private Attributes
std::unique_ptr< TrackVertexArbitration< VTX > >	theArbitrator

edm::EDGetTokenT< reco::BeamSpot >	token_beamSpot

edm::EDGetTokenT< reco::VertexCollection >	token_primaryVertex

edm::EDGetTokenT< Product >	token_secondaryVertex

edm::EDGetTokenT< InputContainer >	token_tracks

Detailed Description

template<class InputContainer, class VTX>
class TemplatedVertexArbitrator< InputContainer, VTX >

Definition at line 48 of file TemplatedVertexArbitrator.h.

Member Typedef Documentation

◆ Product

template<class InputContainer , class VTX >

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

Definition at line 50 of file TemplatedVertexArbitrator.h.

Constructor & Destructor Documentation

◆ TemplatedVertexArbitrator()

template<class InputContainer , class VTX >

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

Definition at line 100 of file TemplatedVertexArbitrator.h.

                                                                                                        {
   token_primaryVertex = consumes<reco::VertexCollection>(params.getParameter<edm::InputTag>("primaryVertices"));
   token_secondaryVertex = consumes<Product>(params.getParameter<edm::InputTag>("secondaryVertices"));
   token_beamSpot = consumes<reco::BeamSpot>(params.getParameter<edm::InputTag>("beamSpot"));
   token_tracks = consumes<InputContainer>(params.getParameter<edm::InputTag>("tracks"));
   produces<Product>();
   theArbitrator.reset(new TrackVertexArbitration<VTX>(params));
 }

References CalibrationSummaryClient_cfi::params.

Member Function Documentation

◆ fillDescriptions()

template<class InputContainer , class VTX >

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

inlinestatic

Definition at line 53 of file TemplatedVertexArbitrator.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<edm::InputTag>("secondaryVertices", edm::InputTag("vertexMerger"));
     } else if (std::is_same<VTX, reco::VertexCompositePtrCandidate>::value) {
       pdesc.add<edm::InputTag>("tracks", edm::InputTag("particleFlow"));
       pdesc.add<edm::InputTag>("secondaryVertices", edm::InputTag("candidateVertexMerger"));
     } else {
       pdesc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
       pdesc.add<edm::InputTag>("secondaryVertices", edm::InputTag("vertexMerger"));
     }
     pdesc.add<double>("dLenFraction", 0.333);
     pdesc.add<double>("dRCut", 0.4);
     pdesc.add<double>("distCut", 0.04);
     pdesc.add<double>("sigCut", 5.0);
     pdesc.add<double>("fitterSigmacut", 3.0);
     pdesc.add<double>("fitterTini", 256);
     pdesc.add<double>("fitterRatio", 0.25);
     pdesc.add<int>("trackMinLayers", 4);
     pdesc.add<double>("trackMinPt", 0.4);
     pdesc.add<int>("trackMinPixels", 1);
     pdesc.add<double>("maxTimeSignificance", 3.5);
     if (std::is_same<VTX, reco::Vertex>::value) {
       cdesc.add("trackVertexArbitratorDefault", pdesc);
     } else if (std::is_same<VTX, reco::VertexCompositePtrCandidate>::value) {
       cdesc.add("candidateVertexArbitratorDefault", pdesc);
     } else {
       cdesc.addDefault(pdesc);
     }
   }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), HLT_2018_cff::InputTag, and relativeConstraints::value.

◆ produce()

template<class InputContainer , class VTX >

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

override

Definition at line 110 of file TemplatedVertexArbitrator.h.

                                                                                                      {
   using namespace reco;
  
   edm::Handle<Product> secondaryVertices;
   event.getByToken(token_secondaryVertex, secondaryVertices);
   Product theSecVertexColl = *(secondaryVertices.product());
  
   edm::Handle<VertexCollection> primaryVertices;
   event.getByToken(token_primaryVertex, primaryVertices);
  
   auto recoVertices = std::make_unique<Product>();
   if (!primaryVertices->empty()) {
     const reco::Vertex &pv = (*primaryVertices)[0];
  
     edm::Handle<InputContainer> tracks;
     event.getByToken(token_tracks, tracks);
  
     edm::ESHandle<TransientTrackBuilder> trackBuilder;
     es.get<TransientTrackRecord>().get("TransientTrackBuilder", trackBuilder);
  
     edm::Handle<BeamSpot> beamSpot;
     event.getByToken(token_beamSpot, beamSpot);
  
     std::vector<TransientTrack> selectedTracks;
     for (typename InputContainer::const_iterator track = tracks->begin(); track != tracks->end(); ++track) {
       selectedTracks.push_back(tthelpers::buildTT(tracks, trackBuilder, track - tracks->begin()));
     }
  
     //        const edm::RefVector< TrackCollection > tracksForArbitration= selectedTracks;
     Product theRecoVertices = theArbitrator->trackVertexArbitrator(beamSpot, pv, selectedTracks, theSecVertexColl);
  
     for (unsigned int ivtx = 0; ivtx < theRecoVertices.size(); ivtx++) {
       if (!(nTracks(theRecoVertices[ivtx]) > 1))
         continue;
       recoVertices->push_back(theRecoVertices[ivtx]);
     }
   }
   event.put(std::move(recoVertices));
 }