#include <PrimaryVertexSorter.h>

Inheritance diagram for PrimaryVertexSorter< ParticlesCollection >:

Public Types
typedef edm::Association < reco::VertexCollection >	CandToVertex

typedef edm::ValueMap< int >	CandToVertexQuality

typedef ParticlesCollection	PFCollection

typedef edm::ValueMap< float >	VertexScore

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
template<>
void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

template<>
void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

template<>
void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

	PrimaryVertexSorter (const edm::ParameterSet &)

void	produce (edm::Event &, const edm::EventSetup &) override

std::vector< reco::Vertex >	sortedList (const reco::VertexCollection &primaryVertex) const

	~PrimaryVertexSorter () override

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 &descriptions)

Private Member Functions
void	doConsumesForTiming (const edm::ParameterSet &iConfig)

template<>
void	doConsumesForTiming (const edm::ParameterSet &iConfig)

template<>
void	doConsumesForTiming (const edm::ParameterSet &iConfig)

template<>
void	doConsumesForTiming (const edm::ParameterSet &iConfig)

bool	needsProductsForTiming ()

template<>
bool	needsProductsForTiming ()

template<>
bool	needsProductsForTiming ()

template<>
bool	needsProductsForTiming ()

std::pair< int, PrimaryVertexAssignment::Quality >	runAlgo (const reco::VertexCollection &vertices, const typename ParticlesCollection::value_type &pf, const edm::ValueMap< float > trackTimeTag, const edm::ValueMap< float > trackTimeResoTag, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder)

template<>
std::pair< int, PrimaryVertexAssignment::Quality >	runAlgo (const reco::VertexCollection &vertices, const reco::RecoChargedRefCandidate &pf, const edm::ValueMap< float > trackTimeTag, const edm::ValueMap< float > trackTimeResoTag, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder)

template<>
std::pair< int, PrimaryVertexAssignment::Quality >	runAlgo (const reco::VertexCollection &vertices, const reco::PFCandidate &pf, const edm::ValueMap< float > trackTimeTag, const edm::ValueMap< float > trackTimeResoTag, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder)

template<>
std::pair< int, PrimaryVertexAssignment::Quality >	runAlgo (const reco::VertexCollection &vertices, const pat::PackedCandidate &pf, const edm::ValueMap< float > trackTimeTag, const edm::ValueMap< float > trackTimeResoTag, const edm::View< reco::Candidate > &jets, const TransientTrackBuilder &builder)

Static Private Member Functions
static void	fillDescriptionsCommon (edm::ParameterSetDescription &descriptions)

Private Attributes
PrimaryVertexAssignment	assignmentAlgo_

bool	produceOriginalMapping_

bool	producePFNoPileUp_

bool	producePFPileUp_

bool	produceSortedVertices_

int	qualityCut_

PrimaryVertexSorting	sortingAlgo_

edm::ESGetToken < TransientTrackBuilder, TransientTrackRecord >	tokenBuilder_

edm::EDGetTokenT< PFCollection >	tokenCandidates_
	Candidates to be analyzed. More...

edm::EDGetTokenT< edm::View < reco::Candidate > >	tokenJets_

edm::EDGetTokenT < edm::ValueMap< float > >	tokenTrackTimeResoTag_

edm::EDGetTokenT < edm::ValueMap< float > >	tokenTrackTimeTag_

edm::EDGetTokenT < reco::VertexCollection >	tokenVertices_
	vertices More...

bool	useMET_

bool	useTiming_

Detailed Description

template<class ParticlesCollection>
class PrimaryVertexSorter< ParticlesCollection >

Author: Andrea Rizzi

class to sort VertexCollection in decreasing order of the sum of the squared track pT's

Definition at line 35 of file PrimaryVertexSorter.h.

Member Typedef Documentation

template<class ParticlesCollection >

typedef edm::Association<reco::VertexCollection> PrimaryVertexSorter< ParticlesCollection >::CandToVertex

Definition at line 37 of file PrimaryVertexSorter.h.

template<class ParticlesCollection >

typedef edm::ValueMap<int> PrimaryVertexSorter< ParticlesCollection >::CandToVertexQuality

Definition at line 38 of file PrimaryVertexSorter.h.

template<class ParticlesCollection >

typedef ParticlesCollection PrimaryVertexSorter< ParticlesCollection >::PFCollection

Definition at line 41 of file PrimaryVertexSorter.h.

template<class ParticlesCollection >

typedef edm::ValueMap<float> PrimaryVertexSorter< ParticlesCollection >::VertexScore

Definition at line 39 of file PrimaryVertexSorter.h.

Constructor & Destructor Documentation

template<class ParticlesCollection >

PrimaryVertexSorter< ParticlesCollection >::PrimaryVertexSorter ( const edm::ParameterSet & iConfig )

explicit

Definition at line 94 of file PrimaryVertexSorter.h.

References PrimaryVertexSorter< ParticlesCollection >::doConsumesForTiming(), PrimaryVertexSorter< ParticlesCollection >::produceOriginalMapping_, PrimaryVertexSorter< ParticlesCollection >::producePFNoPileUp_, PrimaryVertexSorter< ParticlesCollection >::producePFPileUp_, PrimaryVertexSorter< ParticlesCollection >::produceSortedVertices_, dt_dqm_sourceclient_common_cff::reco, and PrimaryVertexSorter< ParticlesCollection >::useTiming_.

     : assignmentAlgo_(iConfig.getParameterSet("assignment")),
       sortingAlgo_(iConfig.getParameterSet("sorting")),
       tokenCandidates_(consumes<ParticlesCollection>(iConfig.getParameter<edm::InputTag>("particles"))),
       tokenVertices_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertices"))),
       tokenJets_(consumes<edm::View<reco::Candidate>>(iConfig.getParameter<edm::InputTag>("jets"))),
       tokenBuilder_(esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))),
       produceOriginalMapping_(iConfig.getParameter<bool>("produceAssociationToOriginalVertices")),
       produceSortedVertices_(iConfig.getParameter<bool>("produceSortedVertices")),
       producePFPileUp_(iConfig.getParameter<bool>("producePileUpCollection")),
       producePFNoPileUp_(iConfig.getParameter<bool>("produceNoPileUpCollection")),
       qualityCut_(iConfig.getParameter<int>("qualityForPrimary")),
       useMET_(iConfig.getParameter<bool>("usePVMET")),
       useTiming_(iConfig.getParameterSet("assignment").getParameter<bool>("useTiming")) {
   using namespace std;
   using namespace edm;
   using namespace reco;
 
   if (produceOriginalMapping_) {
     produces<CandToVertex>("original");
     produces<CandToVertexQuality>("original");
     produces<VertexScore>("original");
   }
   if (produceSortedVertices_) {
     produces<reco::VertexCollection>();
     produces<CandToVertex>();
     produces<CandToVertexQuality>();
     produces<VertexScore>();
   }
 
   if (producePFPileUp_) {
     if (produceOriginalMapping_)
       produces<PFCollection>("originalPileUp");
     if (produceSortedVertices_)
       produces<PFCollection>("PileUp");
   }
 
   if (producePFNoPileUp_) {
     if (produceOriginalMapping_)
       produces<PFCollection>("originalNoPileUp");
     if (produceSortedVertices_)
       produces<PFCollection>("NoPileUp");
   }
 
   if (useTiming_)
     doConsumesForTiming(iConfig);
 }

template<class ParticlesCollection >

PrimaryVertexSorter< ParticlesCollection >::~PrimaryVertexSorter ( )

inlineoverride

Definition at line 45 of file PrimaryVertexSorter.h.

45 {}

Member Function Documentation

template<class ParticlesCollection >

void PrimaryVertexSorter< ParticlesCollection >::doConsumesForTiming ( const edm::ParameterSet & iConfig )

private

Referenced by PrimaryVertexSorter< ParticlesCollection >::PrimaryVertexSorter().

template<>

void PrimaryVertexSorter< std::vector< reco::RecoChargedRefCandidate > >::doConsumesForTiming ( const edm::ParameterSet & iConfig )

inlineprivate

Definition at line 392 of file PrimaryVertexSorter.h.

References edm::ParameterSet::getParameter(), PrimaryVertexSorter< ParticlesCollection >::tokenTrackTimeResoTag_, and PrimaryVertexSorter< ParticlesCollection >::tokenTrackTimeTag_.

                                     {
   tokenTrackTimeTag_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("trackTimeTag"));
   tokenTrackTimeResoTag_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("trackTimeResoTag"));
 }

template<>

void PrimaryVertexSorter< std::vector< reco::PFCandidate > >::doConsumesForTiming ( const edm::ParameterSet & iConfig )

inlineprivate

Definition at line 399 of file PrimaryVertexSorter.h.

399 {

400 }

template<>

void PrimaryVertexSorter< std::vector< pat::PackedCandidate > >::doConsumesForTiming ( const edm::ParameterSet & iConfig )

inlineprivate

Definition at line 403 of file PrimaryVertexSorter.h.

404 {}

template<class ParticlesCollection >

static void PrimaryVertexSorter< ParticlesCollection >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

template<>

void PrimaryVertexSorter< std::vector< reco::RecoChargedRefCandidate > >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inline

Definition at line 312 of file PrimaryVertexSorter.h.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, PrimaryVertexSorter< ParticlesCollection >::fillDescriptionsCommon(), and HLT_FULL_cff::InputTag.

                                                 {
   edm::ParameterSetDescription desc;
   fillDescriptionsCommon(desc);
   desc.add<edm::InputTag>("trackTimeTag", edm::InputTag(""));
   desc.add<edm::InputTag>("trackTimeResoTag", edm::InputTag(""));
   desc.add<edm::InputTag>("particles", edm::InputTag("trackRefsForJets"));
   desc.add<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::InputTag>("jets", edm::InputTag("ak4CaloJetsForTrk"));
   desc.add<bool>("produceAssociationToOriginalVertices", false);
   desc.add<bool>("produceSortedVertices", true);
   desc.add<bool>("producePileUpCollection", false);
   desc.add<bool>("produceNoPileUpCollection", false);
   descriptions.add("sortedPrimaryVertices", desc);
 }

template<>

void PrimaryVertexSorter< std::vector< reco::PFCandidate > >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inline

Definition at line 329 of file PrimaryVertexSorter.h.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, PrimaryVertexSorter< ParticlesCollection >::fillDescriptionsCommon(), and HLT_FULL_cff::InputTag.

                                                 {
   edm::ParameterSetDescription desc;
   fillDescriptionsCommon(desc);
   desc.add<edm::InputTag>("particles", edm::InputTag("particleFlow"));
   desc.add<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::InputTag>("jets", edm::InputTag("ak4PFJets"));
   desc.add<bool>("produceAssociationToOriginalVertices", true);
   desc.add<bool>("produceSortedVertices", true);
   desc.add<bool>("producePileUpCollection", true);
   desc.add<bool>("produceNoPileUpCollection", true);
   descriptions.add("sortedPFPrimaryVertices", desc);
 }

template<>

void PrimaryVertexSorter< std::vector< pat::PackedCandidate > >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inline

Definition at line 344 of file PrimaryVertexSorter.h.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, PrimaryVertexSorter< ParticlesCollection >::fillDescriptionsCommon(), and HLT_FULL_cff::InputTag.

                                                 {
   edm::ParameterSetDescription desc;
   fillDescriptionsCommon(desc);
   desc.add<edm::InputTag>("particles", edm::InputTag("packedPFCandidates"));
   desc.add<edm::InputTag>("vertices", edm::InputTag("offlineSlimmedPrimaryVertices"));
   desc.add<edm::InputTag>("jets", edm::InputTag("slimmedJets"));
   desc.add<bool>("produceAssociationToOriginalVertices", true);
   desc.add<bool>("produceSortedVertices", true);
   desc.add<bool>("producePileUpCollection", true);
   desc.add<bool>("produceNoPileUpCollection", true);
   descriptions.add("sortedPackedPrimaryVertices", desc);
 }

template<class ParticlesCollection >

void PrimaryVertexSorter< ParticlesCollection >::fillDescriptionsCommon ( edm::ParameterSetDescription & descriptions )

inlinestaticprivate

Definition at line 359 of file PrimaryVertexSorter.h.

References edm::ParameterSetDescription::add().

Referenced by PrimaryVertexSorter< ParticlesCollection >::fillDescriptions().

                                                                                                              {
   {
     edm::ParameterSetDescription psd0;
     desc.add<edm::ParameterSetDescription>("sorting", psd0);
   }
   {
     edm::ParameterSetDescription psd0;
     psd0.add<double>("maxDzSigForPrimaryAssignment", 5.0);
     psd0.add<double>("maxDzForPrimaryAssignment", 0.1);
     psd0.add<double>("maxDzErrorForPrimaryAssignment", 0.05);
     psd0.add<double>("maxDtSigForPrimaryAssignment", 3.0);
     psd0.add<double>("maxJetDeltaR", 0.5);
     psd0.add<double>("minJetPt", 25);
     psd0.add<double>("maxDistanceToJetAxis", 0.07);
     psd0.add<double>("maxDzForJetAxisAssigment", 0.1);
     psd0.add<double>("maxDxyForJetAxisAssigment", 0.1);
     psd0.add<double>("maxDxySigForNotReconstructedPrimary", 2);
     psd0.add<double>("maxDxyForNotReconstructedPrimary", 0.01);
     psd0.add<bool>("useTiming", false);
     psd0.add<bool>("useVertexFit", true);
     psd0.add<bool>("preferHighRanked", false);
     psd0.add<unsigned int>("NumOfPUVtxsForCharged", 0);
     psd0.add<double>("DzCutForChargedFromPUVtxs", 0.2);
     psd0.add<double>("PtMaxCharged", -1);
     psd0.add<double>("EtaMinUseDz", -1);
     psd0.add<bool>("OnlyUseFirstDz", false);
     desc.add<edm::ParameterSetDescription>("assignment", psd0);
   }
   desc.add<int>("qualityForPrimary", 3);
   desc.add<bool>("usePVMET", true);
 }

template<class ParticlesCollection >

bool PrimaryVertexSorter< ParticlesCollection >::needsProductsForTiming ( )

private

Referenced by PrimaryVertexSorter< ParticlesCollection >::produce().

template<>

bool PrimaryVertexSorter< std::vector< reco::RecoChargedRefCandidate > >::needsProductsForTiming ( )

inlineprivate

Definition at line 407 of file PrimaryVertexSorter.h.

                                                                                                 {
   return true;
 }

template<>

bool PrimaryVertexSorter< std::vector< reco::PFCandidate > >::needsProductsForTiming ( )

inlineprivate

Definition at line 412 of file PrimaryVertexSorter.h.

                                                                                     {
   return false;
 }

template<>

bool PrimaryVertexSorter< std::vector< pat::PackedCandidate > >::needsProductsForTiming ( )

inlineprivate

Definition at line 417 of file PrimaryVertexSorter.h.

                                                                                        {
   return false;
 }

template<class ParticlesCollection >

void PrimaryVertexSorter< ParticlesCollection >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

Definition at line 143 of file PrimaryVertexSorter.h.

                                                                                                     {
   using namespace std;
   using namespace edm;
   using namespace reco;
 
   Handle<edm::View<reco::Candidate>> jets;
   iEvent.getByToken(tokenJets_, jets);
 
   TransientTrackBuilder const& builder = iSetup.getData(tokenBuilder_);
 
   Handle<VertexCollection> vertices;
   iEvent.getByToken(tokenVertices_, vertices);
 
   Handle<ParticlesCollection> particlesHandle;
   iEvent.getByToken(tokenCandidates_, particlesHandle);
 
   Handle<edm::ValueMap<float>> trackTimeTagHandle;
   Handle<edm::ValueMap<float>> trackTimeResoTagHandle;
 
   const edm::ValueMap<float>* trackTimeTag = nullptr;
   const edm::ValueMap<float>* trackTimeResoTag = nullptr;
   if (useTiming_ && needsProductsForTiming()) {
     iEvent.getByToken(tokenTrackTimeTag_, trackTimeTagHandle);
     iEvent.getByToken(tokenTrackTimeResoTag_, trackTimeResoTagHandle);
 
     trackTimeTag = trackTimeTagHandle.product();
     trackTimeResoTag = trackTimeResoTagHandle.product();
   }
 
   ParticlesCollection particles = *particlesHandle.product();
   std::vector<int> pfToPVVector;
   std::vector<PrimaryVertexAssignment::Quality> pfToPVQualityVector;
   //reverse mapping
   std::vector<std::vector<int>> pvToPFVector(vertices->size());
   std::vector<std::vector<const reco::Candidate*>> pvToCandVector(vertices->size());
   std::vector<std::vector<PrimaryVertexAssignment::Quality>> pvToPFQualityVector(vertices->size());
   std::vector<float> vertexScoreOriginal(vertices->size());
   std::vector<float> vertexScore(vertices->size());
 
   for (auto const& pf : particles) {
     std::pair<int, PrimaryVertexAssignment::Quality> vtxWithQuality =
         runAlgo(*vertices, pf, trackTimeTag, trackTimeResoTag, *jets, builder);
     pfToPVVector.push_back(vtxWithQuality.first);
     pfToPVQualityVector.push_back(vtxWithQuality.second);
   }
 
   //Invert the mapping
   for (size_t i = 0; i < pfToPVVector.size(); i++) {
     auto pv = pfToPVVector[i];
     auto qual = pfToPVQualityVector[i];
     if (pv >= 0 and qual >= qualityCut_) {
       pvToPFVector[pv].push_back(i);
       //    std::cout << i << std::endl;
       //     const typename  ParticlesCollection::value_type & cp = particles[i];
       //     std::cout << "CP " << &cp <<  std::endl;
       pvToCandVector[pv].push_back(&particles[i]);
       pvToPFQualityVector[pv].push_back(qual);
     }
   }
 
   //Use multimap for sorting of indices
   std::multimap<float, int> scores;
   for (unsigned int i = 0; i < vertices->size(); i++) {
     float s = sortingAlgo_.score((*vertices)[i], pvToCandVector[i], useMET_);
     vertexScoreOriginal[i] = s;
     scores.insert(std::pair<float, int>(-s, i));
   }
 
   //create indices
   std::vector<int> oldToNew(vertices->size()), newToOld(vertices->size());
   size_t newIdx = 0;
   for (auto const& idx : scores) {
     //    std::cout << newIdx << " score: " << idx.first << " oldidx: " << idx.second << " "<< producePFPileUp_ << std::endl;
     vertexScore[newIdx] = -idx.first;
     oldToNew[idx.second] = newIdx;
     newToOld[newIdx] = idx.second;
     newIdx++;
   }
 
   if (produceOriginalMapping_) {
     unique_ptr<CandToVertex> pfCandToOriginalVertexOutput(new CandToVertex(vertices));
     unique_ptr<CandToVertexQuality> pfCandToOriginalVertexQualityOutput(new CandToVertexQuality());
     CandToVertex::Filler cand2VertexFiller(*pfCandToOriginalVertexOutput);
     CandToVertexQuality::Filler cand2VertexQualityFiller(*pfCandToOriginalVertexQualityOutput);
 
     cand2VertexFiller.insert(particlesHandle, pfToPVVector.begin(), pfToPVVector.end());
     cand2VertexQualityFiller.insert(particlesHandle, pfToPVQualityVector.begin(), pfToPVQualityVector.end());
 
     cand2VertexFiller.fill();
     cand2VertexQualityFiller.fill();
     iEvent.put(std::move(pfCandToOriginalVertexOutput), "original");
     iEvent.put(std::move(pfCandToOriginalVertexQualityOutput), "original");
 
     unique_ptr<VertexScore> vertexScoreOriginalOutput(new VertexScore);
     VertexScore::Filler vertexScoreOriginalFiller(*vertexScoreOriginalOutput);
     vertexScoreOriginalFiller.insert(vertices, vertexScoreOriginal.begin(), vertexScoreOriginal.end());
     vertexScoreOriginalFiller.fill();
     iEvent.put(std::move(vertexScoreOriginalOutput), "original");
   }
 
   if (produceSortedVertices_) {
     std::vector<int> pfToSortedPVVector;
     //      std::vector<int> pfToSortedPVQualityVector;
     for (size_t i = 0; i < pfToPVVector.size(); i++) {
       pfToSortedPVVector.push_back(oldToNew[pfToPVVector[i]]);
       //        pfToSortedPVQualityVector.push_back(pfToPVQualityVector[i]); //same as old!
     }
 
     unique_ptr<reco::VertexCollection> sortedVerticesOutput(new reco::VertexCollection);
     for (size_t i = 0; i < vertices->size(); i++) {
       sortedVerticesOutput->push_back((*vertices)[newToOld[i]]);
     }
     edm::OrphanHandle<reco::VertexCollection> oh = iEvent.put(std::move(sortedVerticesOutput));
     unique_ptr<CandToVertex> pfCandToVertexOutput(new CandToVertex(oh));
     unique_ptr<CandToVertexQuality> pfCandToVertexQualityOutput(new CandToVertexQuality());
     CandToVertex::Filler cand2VertexFiller(*pfCandToVertexOutput);
     CandToVertexQuality::Filler cand2VertexQualityFiller(*pfCandToVertexQualityOutput);
 
     cand2VertexFiller.insert(particlesHandle, pfToSortedPVVector.begin(), pfToSortedPVVector.end());
     cand2VertexQualityFiller.insert(particlesHandle, pfToPVQualityVector.begin(), pfToPVQualityVector.end());
 
     cand2VertexFiller.fill();
     cand2VertexQualityFiller.fill();
     iEvent.put(std::move(pfCandToVertexOutput));
     iEvent.put(std::move(pfCandToVertexQualityOutput));
 
     unique_ptr<VertexScore> vertexScoreOutput(new VertexScore);
     VertexScore::Filler vertexScoreFiller(*vertexScoreOutput);
     vertexScoreFiller.insert(oh, vertexScore.begin(), vertexScore.end());
     vertexScoreFiller.fill();
     iEvent.put(std::move(vertexScoreOutput));
   }
 
   unique_ptr<PFCollection> pfCollectionNOPUOriginalOutput(new PFCollection);
   unique_ptr<PFCollection> pfCollectionNOPUOutput(new PFCollection);
   unique_ptr<PFCollection> pfCollectionPUOriginalOutput(new PFCollection);
   unique_ptr<PFCollection> pfCollectionPUOutput(new PFCollection);
 
   for (size_t i = 0; i < particles.size(); i++) {
     auto pv = pfToPVVector[i];
     auto qual = pfToPVQualityVector[i];
 
     if (producePFNoPileUp_ && produceSortedVertices_)
       if (pv == newToOld[0] and qual >= qualityCut_)
         pfCollectionNOPUOutput->push_back(particles[i]);
 
     if (producePFPileUp_ && produceSortedVertices_)
       if (pv != newToOld[0] and qual >= qualityCut_)
         pfCollectionPUOutput->push_back(particles[i]);
 
     if (producePFNoPileUp_ && produceOriginalMapping_)
       if (pv == 0 and qual >= qualityCut_)
         pfCollectionNOPUOriginalOutput->push_back(particles[i]);
 
     if (producePFPileUp_ && produceOriginalMapping_)
       if (pv != 0 and qual >= qualityCut_)
         pfCollectionPUOriginalOutput->push_back(particles[i]);
   }
   if (producePFNoPileUp_ && produceSortedVertices_)
     iEvent.put(std::move(pfCollectionNOPUOutput), "NoPileUp");
   if (producePFPileUp_ && produceSortedVertices_)
     iEvent.put(std::move(pfCollectionPUOutput), "PileUp");
   if (producePFNoPileUp_ && produceOriginalMapping_)
     iEvent.put(std::move(pfCollectionNOPUOriginalOutput), "originalNoPileUp");
   if (producePFPileUp_ && produceOriginalMapping_)
     iEvent.put(std::move(pfCollectionPUOriginalOutput), "originalPileUp");
 }

template<class ParticlesCollection >

std::pair<int, PrimaryVertexAssignment::Quality> PrimaryVertexSorter< ParticlesCollection >::runAlgo	(	const reco::VertexCollection &	vertices,
		const typename ParticlesCollection::value_type &	pf,
		const edm::ValueMap< float > *	trackTimeTag,
		const edm::ValueMap< float > *	trackTimeResoTag,
		const edm::View< reco::Candidate > &	jets,
		const TransientTrackBuilder &	builder
	)

private

Referenced by PrimaryVertexSorter< ParticlesCollection >::produce().

template<>

std::pair< int, PrimaryVertexAssignment::Quality > PrimaryVertexSorter< std::vector< reco::RecoChargedRefCandidate > >::runAlgo	(	const reco::VertexCollection &	vertices,
		const reco::RecoChargedRefCandidate &	pf,
		const edm::ValueMap< float > *	trackTimeTag,
		const edm::ValueMap< float > *	trackTimeResoTag,
		const edm::View< reco::Candidate > &	jets,
		const TransientTrackBuilder &	builder
	)

inlineprivate

Definition at line 423 of file PrimaryVertexSorter.h.

References PrimaryVertexSorter< ParticlesCollection >::assignmentAlgo_, and PrimaryVertexAssignment::chargedHadronVertex().

                                                                                                                {
   return assignmentAlgo_.chargedHadronVertex(vertices, pf, trackTimeTag, trackTimeResoTag, jets, builder);
 }

template<>

std::pair< int, PrimaryVertexAssignment::Quality > PrimaryVertexSorter< std::vector< reco::PFCandidate > >::runAlgo	(	const reco::VertexCollection &	vertices,
		const reco::PFCandidate &	pf,
		const edm::ValueMap< float > *	trackTimeTag,
		const edm::ValueMap< float > *	trackTimeResoTag,
		const edm::View< reco::Candidate > &	jets,
		const TransientTrackBuilder &	builder
	)

inlineprivate

Definition at line 433 of file PrimaryVertexSorter.h.

References PrimaryVertexSorter< ParticlesCollection >::assignmentAlgo_, and PrimaryVertexAssignment::chargedHadronVertex().

                                           {
   return assignmentAlgo_.chargedHadronVertex(vertices, pf, jets, builder);
 }

template<>

std::pair< int, PrimaryVertexAssignment::Quality > PrimaryVertexSorter< std::vector< pat::PackedCandidate > >::runAlgo	(	const reco::VertexCollection &	vertices,
		const pat::PackedCandidate &	pf,
		const edm::ValueMap< float > *	trackTimeTag,
		const edm::ValueMap< float > *	trackTimeResoTag,
		const edm::View< reco::Candidate > &	jets,
		const TransientTrackBuilder &	builder
	)

inlineprivate

Definition at line 444 of file PrimaryVertexSorter.h.

References PrimaryVertexSorter< ParticlesCollection >::assignmentAlgo_, and PrimaryVertexAssignment::chargedHadronVertex().

                                           {
   return assignmentAlgo_.chargedHadronVertex(vertices, pf, jets, builder);
 }

template<class ParticlesCollection >

VertexCollection PrimaryVertexSorter< ParticlesCollection >::sortedList ( const reco::VertexCollection & primaryVertex ) const

Definition at line 7 of file PrimaryVertexSorter.cc.

Referenced by QualityCutsAnalyzer::LoopOverJetTracksAssociation().

                                                                                              {
   VertexCollection pvs = unsortedPVColl;
   sort(pvs.begin(), pvs.end(), VertexHigherPtSquared());
   return pvs;
 }