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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
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 ()

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)

Private Attributes
PrimaryVertexAssignment	assignmentAlgo_

bool	produceOriginalMapping_

bool	producePFNoPileUp_

bool	producePFPileUp_

bool	produceSortedVertices_

int	qualityCut_

PrimaryVertexSorting	sortingAlgo_

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

Member Typedef Documentation

template<class ParticlesCollection >

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

Definition at line 33 of file PrimaryVertexSorter.h.

template<class ParticlesCollection >

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

Definition at line 34 of file PrimaryVertexSorter.h.

template<class ParticlesCollection >

typedef ParticlesCollection PrimaryVertexSorter< ParticlesCollection >::PFCollection

Definition at line 37 of file PrimaryVertexSorter.h.

template<class ParticlesCollection >

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

Definition at line 35 of file PrimaryVertexSorter.h.

Constructor & Destructor Documentation

template<class ParticlesCollection >

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

explicit

Definition at line 86 of file PrimaryVertexSorter.h.

References PrimaryVertexSorter< ParticlesCollection >::doConsumesForTiming(), PrimaryVertexSorter< ParticlesCollection >::produceOriginalMapping_, PrimaryVertexSorter< ParticlesCollection >::producePFNoPileUp_, PrimaryVertexSorter< ParticlesCollection >::producePFPileUp_, PrimaryVertexSorter< ParticlesCollection >::produceSortedVertices_, 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"))),
       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 41 of file PrimaryVertexSorter.h.

References PrimaryVertexSorter< ParticlesCollection >::produce().

41 {}

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 )

private

Definition at line 304 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 )

private

Definition at line 311 of file PrimaryVertexSorter.h.

311 {}

template<class ParticlesCollection >

bool PrimaryVertexSorter< ParticlesCollection >::needsProductsForTiming ( )

private

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

template<>

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

private

Definition at line 314 of file PrimaryVertexSorter.h.

                                                                                          {
   return true;
 }

template<>

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

private

Definition at line 319 of file PrimaryVertexSorter.h.

                                                                              {
   return false;
 }

template<class ParticlesCollection >

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

override

Definition at line 134 of file PrimaryVertexSorter.h.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), HTMLExport.HTMLExportStatic::export(), and PrimaryVertexSorter< ParticlesCollection >::~PrimaryVertexSorter().

                                                                                                     {
   using namespace std;
   using namespace edm;
   using namespace reco;
 
   Handle<edm::View<reco::Candidate>> jets;
   iEvent.getByToken(tokenJets_, jets);
 
   edm::ESHandle<TransientTrackBuilder> builder;
   iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", builder);
 
   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
	)

private

Definition at line 325 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
	)

private

Definition at line 335 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.

References FSQDQM_cfi::pvs.

Referenced by QualityCutsAnalyzer::LoopOverJetTracksAssociation().

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