#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
	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

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)

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 90 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 308 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 315 of file PrimaryVertexSorter.h.

315 {

316 }

template<>

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

inlineprivate

Definition at line 319 of file PrimaryVertexSorter.h.

320 {}

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 323 of file PrimaryVertexSorter.h.

                                                                                                 {
   return true;
 }

template<>

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

inlineprivate

Definition at line 328 of file PrimaryVertexSorter.h.

                                                                                     {
   return false;
 }

template<>

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

inlineprivate

Definition at line 333 of file PrimaryVertexSorter.h.

                                                                                        {
   return false;
 }

template<class ParticlesCollection >

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

override

Definition at line 139 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 339 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 349 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 360 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;
 }