TemplatedVertexArbitrator< InputContainer, VTX > Class Template Reference

Inheritance diagram for TemplatedVertexArbitrator< InputContainer, VTX >:

Public Types
typedef std::vector< VTX >	Product
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
	TemplatedVertexArbitrator (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
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::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	token_trackBuilder
edm::EDGetTokenT< InputContainer >	token_tracks

Detailed Description

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

Definition at line 49 of file VertexArbitrators.cc.

Member Typedef Documentation

Product

template<class InputContainer , class VTX >

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

Definition at line 51 of file VertexArbitrators.cc.

Constructor & Destructor Documentation

TemplatedVertexArbitrator()

template<class InputContainer , class VTX >

TemplatedVertexArbitrator< InputContainer, VTX >::TemplatedVertexArbitrator

(

const edm::ParameterSet &

params

)

Definition at line 102 of file VertexArbitrators.cc.

References submitPVValidationJobs::params.

                                                                                                       {
  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"));
  token_trackBuilder =
      esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"));
  produces<Product>();
  theArbitrator.reset(new TrackVertexArbitration<VTX>(params));
}

Member Function Documentation

fillDescriptions()

template<class InputContainer , class VTX >

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

inlinestatic

Definition at line 54 of file VertexArbitrators.cc.

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

                                                                    {
    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);
    }
  }

produce()

template<class InputContainer , class VTX >

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

override

Definition at line 114 of file VertexArbitrators.cc.

References pwdgSkimBPark_cfi::beamSpot, tthelpers::buildTT(), edm::EventSetup::getHandle(), eostools::move(), nTracks(), HLT_2024v12_cff::primaryVertices, HLT_2024v12_cff::secondaryVertices, TrackCollections2monitor_cff::selectedTracks, HLT_2024v12_cff::track, and DiMuonV_cfg::tracks.

                                                                                                     {
  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.getHandle(token_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));
}

trackFilter()

template<class InputContainer , class VTX >

bool TemplatedVertexArbitrator< InputContainer, VTX >::trackFilter ( const reco::TrackRef &  track ) const

private

Member Data Documentation

theArbitrator

template<class InputContainer , class VTX >

std::unique_ptr<TrackVertexArbitration<VTX> > TemplatedVertexArbitrator< InputContainer, VTX >::theArbitrator

private

Definition at line 98 of file VertexArbitrators.cc.

token_beamSpot

template<class InputContainer , class VTX >

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

private

Definition at line 96 of file VertexArbitrators.cc.

token_primaryVertex

template<class InputContainer , class VTX >

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

private

Definition at line 93 of file VertexArbitrators.cc.

token_secondaryVertex

template<class InputContainer , class VTX >

edm::EDGetTokenT<Product> TemplatedVertexArbitrator< InputContainer, VTX >::token_secondaryVertex

private

Definition at line 94 of file VertexArbitrators.cc.

token_trackBuilder

template<class InputContainer , class VTX >

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

private

Definition at line 97 of file VertexArbitrators.cc.

token_tracks

template<class InputContainer , class VTX >

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

private

Definition at line 95 of file VertexArbitrators.cc.