PrimaryVertexSorter< ParticlesCollection > Class Template Reference

#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

CandToVertex

template<class ParticlesCollection >

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

Definition at line 37 of file PrimaryVertexSorter.h.

CandToVertexQuality

template<class ParticlesCollection >

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

Definition at line 38 of file PrimaryVertexSorter.h.

PFCollection

template<class ParticlesCollection >

typedef ParticlesCollection PrimaryVertexSorter< ParticlesCollection >::PFCollection

Definition at line 41 of file PrimaryVertexSorter.h.

VertexScore

template<class ParticlesCollection >

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

Definition at line 39 of file PrimaryVertexSorter.h.

Constructor & Destructor Documentation

PrimaryVertexSorter()

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_, 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);
}

~PrimaryVertexSorter()

template<class ParticlesCollection >

PrimaryVertexSorter< ParticlesCollection >::~PrimaryVertexSorter ( )

inlineoverride

Definition at line 45 of file PrimaryVertexSorter.h.

{}

Member Function Documentation

doConsumesForTiming() [1/4]

template<class ParticlesCollection >

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

private

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

doConsumesForTiming() [2/4]

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

doConsumesForTiming() [3/4]

template<>

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

inlineprivate

Definition at line 399 of file PrimaryVertexSorter.h.

                                                                                                               {
}

doConsumesForTiming() [4/4]

template<>

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

inlineprivate

Definition at line 403 of file PrimaryVertexSorter.h.

                                    {}

fillDescriptions() [1/4]

template<class ParticlesCollection >

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

static

fillDescriptions() [2/4]

template<>

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

inline

Definition at line 312 of file PrimaryVertexSorter.h.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, PrimaryVertexSorter< ParticlesCollection >::fillDescriptionsCommon(), and ProducerED_cfi::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);
}

fillDescriptions() [3/4]

template<>

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

inline

Definition at line 329 of file PrimaryVertexSorter.h.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, PrimaryVertexSorter< ParticlesCollection >::fillDescriptionsCommon(), and ProducerED_cfi::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);
}

fillDescriptions() [4/4]

template<>

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

inline

Definition at line 344 of file PrimaryVertexSorter.h.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, PrimaryVertexSorter< ParticlesCollection >::fillDescriptionsCommon(), and ProducerED_cfi::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);
}

fillDescriptionsCommon()

template<class ParticlesCollection >

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

inlinestaticprivate

Definition at line 359 of file PrimaryVertexSorter.h.

References edm::ParameterSetDescription::add(), and submitPVResolutionJobs::desc.

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

needsProductsForTiming() [1/4]

template<class ParticlesCollection >

bool PrimaryVertexSorter< ParticlesCollection >::needsProductsForTiming ( )

private

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

needsProductsForTiming() [2/4]

template<>

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

inlineprivate

Definition at line 407 of file PrimaryVertexSorter.h.

                                                                                                {
  return true;
}

needsProductsForTiming() [3/4]

template<>

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

inlineprivate

Definition at line 412 of file PrimaryVertexSorter.h.

                                                                                    {
  return false;
}

needsProductsForTiming() [4/4]

template<>

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

inlineprivate

Definition at line 417 of file PrimaryVertexSorter.h.

                                                                                       {
  return false;
}

produce()

template<class ParticlesCollection >

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

override

Definition at line 143 of file PrimaryVertexSorter.h.

References edm::helper::Filler< Map >::fill(), edm::EventSetup::getData(), mps_fire::i, heavyIonCSV_trainingSettings::idx, iEvent, edm::helper::Filler< Map >::insert(), PDWG_EXODelayedJetMET_cff::jets, eostools::move(), PrimaryVertexSorter< ParticlesCollection >::needsProductsForTiming(), ecalTrigSettings_cff::particles, packedPFCandidateRefMixer_cfi::pf, PrimaryVertexSorter< ParticlesCollection >::produceOriginalMapping_, PrimaryVertexSorter< ParticlesCollection >::producePFNoPileUp_, PrimaryVertexSorter< ParticlesCollection >::producePFPileUp_, PrimaryVertexSorter< ParticlesCollection >::produceSortedVertices_, edm::Handle< T >::product(), MetAnalyzer::pv(), PrimaryVertexSorter< ParticlesCollection >::qualityCut_, PrimaryVertexSorter< ParticlesCollection >::runAlgo(), alignCSCRings::s, PrimaryVertexSorting::score(), PrimaryVertexSorter< ParticlesCollection >::sortingAlgo_, PrimaryVertexSorter< ParticlesCollection >::tokenBuilder_, PrimaryVertexSorter< ParticlesCollection >::tokenCandidates_, PrimaryVertexSorter< ParticlesCollection >::tokenJets_, PrimaryVertexSorter< ParticlesCollection >::tokenTrackTimeResoTag_, PrimaryVertexSorter< ParticlesCollection >::tokenTrackTimeTag_, PrimaryVertexSorter< ParticlesCollection >::tokenVertices_, offlinePrimaryVertices_cfi::trackTimeResoTag, offlinePrimaryVertices_cfi::trackTimeTag, PrimaryVertexSorter< ParticlesCollection >::useMET_, PrimaryVertexSorter< ParticlesCollection >::useTiming_, and AlignmentTracksFromVertexSelector_cfi::vertices.

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

runAlgo() [1/4]

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().

runAlgo() [2/4]

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_, PrimaryVertexAssignment::chargedHadronVertex(), PDWG_EXODelayedJetMET_cff::jets, packedPFCandidateRefMixer_cfi::pf, offlinePrimaryVertices_cfi::trackTimeResoTag, offlinePrimaryVertices_cfi::trackTimeTag, and AlignmentTracksFromVertexSelector_cfi::vertices.

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

runAlgo() [3/4]

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_, PrimaryVertexAssignment::chargedHadronVertex(), PDWG_EXODelayedJetMET_cff::jets, packedPFCandidateRefMixer_cfi::pf, and AlignmentTracksFromVertexSelector_cfi::vertices.

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

runAlgo() [4/4]

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_, PrimaryVertexAssignment::chargedHadronVertex(), PDWG_EXODelayedJetMET_cff::jets, packedPFCandidateRefMixer_cfi::pf, and AlignmentTracksFromVertexSelector_cfi::vertices.

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

sortedList()

template<class ParticlesCollection >

VertexCollection PrimaryVertexSorter< ParticlesCollection >::sortedList

(

const reco::VertexCollection &

primaryVertex

)

const

Definition at line 7 of file PrimaryVertexSorter.cc.

References FSQDQM_cfi::pvs, and jetUpdater_cfi::sort.

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

Member Data Documentation

assignmentAlgo_

template<class ParticlesCollection >

PrimaryVertexAssignment PrimaryVertexSorter< ParticlesCollection >::assignmentAlgo_

private

Definition at line 52 of file PrimaryVertexSorter.h.

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

produceOriginalMapping_

template<class ParticlesCollection >

bool PrimaryVertexSorter< ParticlesCollection >::produceOriginalMapping_

private

Definition at line 66 of file PrimaryVertexSorter.h.

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

producePFNoPileUp_

template<class ParticlesCollection >

bool PrimaryVertexSorter< ParticlesCollection >::producePFNoPileUp_

private

Definition at line 69 of file PrimaryVertexSorter.h.

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

producePFPileUp_

template<class ParticlesCollection >

bool PrimaryVertexSorter< ParticlesCollection >::producePFPileUp_

private

Definition at line 68 of file PrimaryVertexSorter.h.

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

produceSortedVertices_

template<class ParticlesCollection >

bool PrimaryVertexSorter< ParticlesCollection >::produceSortedVertices_

private

Definition at line 67 of file PrimaryVertexSorter.h.

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

qualityCut_

template<class ParticlesCollection >

int PrimaryVertexSorter< ParticlesCollection >::qualityCut_

private

Definition at line 70 of file PrimaryVertexSorter.h.

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

sortingAlgo_

template<class ParticlesCollection >

PrimaryVertexSorting PrimaryVertexSorter< ParticlesCollection >::sortingAlgo_

private

Definition at line 53 of file PrimaryVertexSorter.h.

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

tokenBuilder_

template<class ParticlesCollection >

edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> PrimaryVertexSorter< ParticlesCollection >::tokenBuilder_

private

Definition at line 64 of file PrimaryVertexSorter.h.

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

tokenCandidates_

template<class ParticlesCollection >

edm::EDGetTokenT<PFCollection> PrimaryVertexSorter< ParticlesCollection >::tokenCandidates_

private

Candidates to be analyzed.

Definition at line 56 of file PrimaryVertexSorter.h.

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

tokenJets_

template<class ParticlesCollection >

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

private

Definition at line 60 of file PrimaryVertexSorter.h.

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

tokenTrackTimeResoTag_

template<class ParticlesCollection >

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

private

Definition at line 62 of file PrimaryVertexSorter.h.

Referenced by PrimaryVertexSorter< ParticlesCollection >::doConsumesForTiming(), and PrimaryVertexSorter< ParticlesCollection >::produce().

tokenTrackTimeTag_

template<class ParticlesCollection >

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

private

Definition at line 61 of file PrimaryVertexSorter.h.

Referenced by PrimaryVertexSorter< ParticlesCollection >::doConsumesForTiming(), and PrimaryVertexSorter< ParticlesCollection >::produce().

tokenVertices_

template<class ParticlesCollection >

edm::EDGetTokenT<reco::VertexCollection> PrimaryVertexSorter< ParticlesCollection >::tokenVertices_

private

vertices

Definition at line 59 of file PrimaryVertexSorter.h.

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

useMET_

template<class ParticlesCollection >

bool PrimaryVertexSorter< ParticlesCollection >::useMET_

private

Definition at line 71 of file PrimaryVertexSorter.h.

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

useTiming_

template<class ParticlesCollection >

bool PrimaryVertexSorter< ParticlesCollection >::useTiming_

private

Definition at line 72 of file PrimaryVertexSorter.h.

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