CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
List of all members | Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes
FFTJetPFPileupCleaner Class Reference

#include <RecoJets/FFTJetProducers/plugins/FFTJetPFPileupCleaner.cc>

Inheritance diagram for FFTJetPFPileupCleaner:
edm::stream::EDProducer<>

Public Member Functions

 FFTJetPFPileupCleaner (const edm::ParameterSet &)
 
 FFTJetPFPileupCleaner ()=delete
 
 FFTJetPFPileupCleaner (const FFTJetPFPileupCleaner &)=delete
 
FFTJetPFPileupCleaneroperator= (const FFTJetPFPileupCleaner &)=delete
 
 ~FFTJetPFPileupCleaner () 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 EDProduceroperator= (const EDProducer &)=delete
 

Protected Member Functions

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

Private Member Functions

void buildRemovalMask ()
 
reco::VertexRef findSomeVertexWFakes (const edm::Handle< reco::VertexCollection > &vertices, const edm::Handle< reco::VertexCollection > &fakeVertices, const reco::PFCandidate &pfcand, bool *fromFakeSet) const
 
bool isAcceptableVtx (reco::VertexCollection::const_iterator iv) const
 
bool isRemovable (reco::PFCandidate::ParticleType ptype) const
 
void setRemovalBit (reco::PFCandidate::ParticleType ptype, bool onOff)
 

Private Attributes

bool checkClosestZVertex
 
double etaMax
 
double etaMin
 
edm::InputTag FakePrimaryVertices
 
edm::EDGetTokenT< reco::VertexCollectionFakePrimaryVerticesToken
 
bool keepIfPVneighbor
 
edm::InputTag PFCandidates
 
edm::EDGetTokenT< reco::PFCandidateCollectionPFCandidatesToken
 
unsigned removalMask
 
bool remove_e
 
bool remove_egamma_HF
 
bool remove_gamma
 
bool remove_h
 
bool remove_h0
 
bool remove_h_HF
 
bool remove_mu
 
bool remove_X
 
bool removeMainVertex
 
bool removeUnassociated
 
bool reverseRemovalDecision
 
bool useFakePrimaryVertex
 
double vertexNdofCut
 
double vertexRhoCut
 
double vertexZmaxCut
 
edm::InputTag Vertices
 
edm::EDGetTokenT< reco::VertexCollectionVerticesToken
 
std::vector< std::pair< double, unsigned > > zAssoc
 

Additional Inherited Members

- 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
 

Detailed Description

Description: cleans up a collection of partice flow objects

Implementation: [Notes on implementation]

Definition at line 45 of file FFTJetPFPileupCleaner.cc.

Constructor & Destructor Documentation

◆ FFTJetPFPileupCleaner() [1/3]

FFTJetPFPileupCleaner::FFTJetPFPileupCleaner ( const edm::ParameterSet ps)
explicit

Definition at line 136 of file FFTJetPFPileupCleaner.cc.

References buildRemovalMask(), FakePrimaryVertices, FakePrimaryVerticesToken, PFCandidates, PFCandidatesToken, useFakePrimaryVertex, Vertices, and VerticesToken.

146  init_param(bool, remove_X),
147  init_param(bool, remove_h),
148  init_param(bool, remove_e),
149  init_param(bool, remove_mu),
150  init_param(bool, remove_gamma),
151  init_param(bool, remove_h0),
152  init_param(bool, remove_h_HF),
154  removalMask(0),
155  init_param(double, etaMin),
156  init_param(double, etaMax),
157  init_param(double, vertexNdofCut),
158  init_param(double, vertexZmaxCut),
159  init_param(double, vertexRhoCut) {
161 
162  PFCandidatesToken = consumes<reco::PFCandidateCollection>(PFCandidates);
163  VerticesToken = consumes<reco::VertexCollection>(Vertices);
165  FakePrimaryVerticesToken = consumes<reco::VertexCollection>(FakePrimaryVertices);
166 
167  produces<reco::PFCandidateCollection>();
168 }
edm::EDGetTokenT< reco::VertexCollection > FakePrimaryVerticesToken
edm::EDGetTokenT< reco::VertexCollection > VerticesToken
edm::EDGetTokenT< reco::PFCandidateCollection > PFCandidatesToken
#define init_param(type, varname)

◆ FFTJetPFPileupCleaner() [2/3]

FFTJetPFPileupCleaner::FFTJetPFPileupCleaner ( )
delete

◆ FFTJetPFPileupCleaner() [3/3]

FFTJetPFPileupCleaner::FFTJetPFPileupCleaner ( const FFTJetPFPileupCleaner )
delete

◆ ~FFTJetPFPileupCleaner()

FFTJetPFPileupCleaner::~FFTJetPFPileupCleaner ( )
override

Definition at line 170 of file FFTJetPFPileupCleaner.cc.

170 {}

Member Function Documentation

◆ buildRemovalMask()

void FFTJetPFPileupCleaner::buildRemovalMask ( )
private

Definition at line 435 of file FFTJetPFPileupCleaner.cc.

References reco::PFCandidate::e, reco::PFCandidate::egamma_HF, reco::PFCandidate::gamma, reco::PFCandidate::h, reco::PFCandidate::h0, reco::PFCandidate::h_HF, reco::PFCandidate::mu, remove_e, remove_egamma_HF, remove_gamma, remove_h, remove_h0, remove_h_HF, remove_mu, remove_X, setRemovalBit(), and reco::PFCandidate::X.

Referenced by FFTJetPFPileupCleaner().

435  {
444 }
void setRemovalBit(reco::PFCandidate::ParticleType ptype, bool onOff)

◆ findSomeVertexWFakes()

reco::VertexRef FFTJetPFPileupCleaner::findSomeVertexWFakes ( const edm::Handle< reco::VertexCollection > &  vertices,
const edm::Handle< reco::VertexCollection > &  fakeVertices,
const reco::PFCandidate pfcand,
bool *  fromFakeSet 
) const
private

Definition at line 260 of file FFTJetPFPileupCleaner.cc.

References funct::abs(), checkClosestZVertex, PVValHelper::dz, dqmdumpme::first, isAcceptableVtx(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::iv, keepIfPVneighbor, pfDeepBoostedJetPreprocessParams_cfi::pfcand, jetUpdater_cfi::sort, mitigatedMETSequence_cff::U, pfDeepBoostedJetPreprocessParams_cfi::upper_bound, useFakePrimaryVertex, AlignmentTracksFromVertexSelector_cfi::vertices, L1BJetProducer_cff::vtx, w(), z, and zAssoc.

Referenced by produce().

263  {
264  typedef reco::VertexCollection::const_iterator IV;
266 
267  *fromFakeSet = false;
268  reco::TrackBaseRef trackBaseRef(pfcand.trackRef());
269 
270  size_t iVertex = 0;
271  unsigned nFoundVertex = 0;
272  const IV vertend(vertices->end());
273 
274  {
275  unsigned index = 0;
276  double bestweight = 0.0;
277  for (IV iv = vertices->begin(); iv != vertend; ++iv, ++index)
278  if (isAcceptableVtx(iv)) {
279  const reco::Vertex& vtx = *iv;
280 
281  // loop on tracks in vertices
282  IT trackend(vtx.tracks_end());
283  for (IT iTrack = vtx.tracks_begin(); iTrack != trackend; ++iTrack) {
284  const reco::TrackBaseRef& baseRef = *iTrack;
285 
286  // one of the tracks in the vertex is the same as
287  // the track considered in the function
288  if (baseRef == trackBaseRef) {
289  // select the vertex for which the track has the highest weight
290  const double w = vtx.trackWeight(baseRef);
291  if (w > bestweight) {
292  bestweight = w;
293  iVertex = index;
294  nFoundVertex++;
295  }
296  }
297  }
298  }
299  }
300 
301  if (nFoundVertex > 0) {
302  if (nFoundVertex != 1)
303  edm::LogWarning("TrackOnTwoVertex") << "a track is shared by at least two vertices. "
304  << "Used to be an assert";
305 
306  // Check if we can re-associate this track with one
307  // of the fake vertices
308  if (useFakePrimaryVertex) {
309  const double ztrack = pfcand.vertex().z();
310  double dzmin = std::abs(ztrack - ((*vertices)[iVertex]).z());
311 
312  const IV fakeEnd(fakeVertices->end());
313  unsigned index = 0;
314  for (IV iv = fakeVertices->begin(); iv != fakeEnd; ++iv, ++index)
315  if (isAcceptableVtx(iv)) {
316  const double dz = std::abs(ztrack - iv->z());
317  if (dz < dzmin) {
318  dzmin = dz;
319  iVertex = index;
320  *fromFakeSet = true;
321  }
322  }
323  }
324 
325  return reco::VertexRef(*fromFakeSet ? fakeVertices : vertices, iVertex);
326  }
327 
328  // optional: as a secondary solution, associate the closest vertex in z
329  if (checkClosestZVertex) {
330  const double ztrack = pfcand.vertex().z();
331  bool foundVertex = false;
332 
333  if (keepIfPVneighbor) {
334  // Sort all vertices according to their Z coordinate
335  zAssoc.clear();
336  unsigned index = 0;
337  for (IV iv = vertices->begin(); iv != vertend; ++iv, ++index)
338  if (isAcceptableVtx(iv))
339  zAssoc.push_back(std::pair<double, unsigned>(iv->z(), index));
340  const unsigned numRealVertices = index;
341 
342  // Mix the fake vertex collection into zAssoc.
343  // Note that we do not reset "index" before doing this.
344  if (useFakePrimaryVertex) {
345  const IV fakeEnd(fakeVertices->end());
346  for (IV iv = fakeVertices->begin(); iv != fakeEnd; ++iv, ++index)
347  if (isAcceptableVtx(iv))
348  zAssoc.push_back(std::pair<double, unsigned>(iv->z(), index));
349  }
350 
351  // Check where the track z position fits into this sequence
352  if (!zAssoc.empty()) {
353  std::sort(zAssoc.begin(), zAssoc.end());
354  std::pair<double, unsigned> tPair(ztrack, UINT_MAX);
355  const unsigned iAbove = std::upper_bound(zAssoc.begin(), zAssoc.end(), tPair) - zAssoc.begin();
356 
357  // Check whether one of the vertices with indices
358  // iAbove or (iAbove - 1) is a primary vertex.
359  // If so, return it. Otherwise return the one
360  // with closest distance to the track.
361  unsigned ich[2] = {0U, 0U};
362  unsigned nch = 1;
363  if (iAbove) {
364  ich[0] = iAbove - 1U;
365  ich[1] = iAbove;
366  if (iAbove < zAssoc.size())
367  nch = 2;
368  }
369 
370  double dzmin = 1.0e100;
371  unsigned bestVertexNum = UINT_MAX;
372  for (unsigned icheck = 0; icheck < nch; ++icheck) {
373  const unsigned zAssocIndex = ich[icheck];
374  const unsigned vertexNum = zAssoc[zAssocIndex].second;
375 
376  if (vertexNum == numRealVertices || (!useFakePrimaryVertex && vertexNum == 0U)) {
377  bestVertexNum = vertexNum;
378  break;
379  }
380 
381  const double dz = std::abs(ztrack - zAssoc[zAssocIndex].first);
382  if (dz < dzmin) {
383  dzmin = dz;
384  bestVertexNum = vertexNum;
385  }
386  }
387 
388  foundVertex = bestVertexNum < UINT_MAX;
389  if (foundVertex) {
390  iVertex = bestVertexNum;
391  if (iVertex >= numRealVertices) {
392  *fromFakeSet = true;
393  iVertex -= numRealVertices;
394  }
395  }
396  }
397  } else {
398  // This is a simple association algorithm (from PFPileUp)
399  // extended to take fake vertices into account
400  double dzmin = 1.0e100;
401  unsigned index = 0;
402  for (IV iv = vertices->begin(); iv != vertend; ++iv, ++index)
403  if (isAcceptableVtx(iv)) {
404  const double dz = std::abs(ztrack - iv->z());
405  if (dz < dzmin) {
406  dzmin = dz;
407  iVertex = index;
408  foundVertex = true;
409  }
410  }
411 
412  if (useFakePrimaryVertex) {
413  const IV fakeEnd(fakeVertices->end());
414  index = 0;
415  for (IV iv = fakeVertices->begin(); iv != fakeEnd; ++iv, ++index)
416  if (isAcceptableVtx(iv)) {
417  const double dz = std::abs(ztrack - iv->z());
418  if (dz < dzmin) {
419  dzmin = dz;
420  iVertex = index;
421  *fromFakeSet = true;
422  foundVertex = true;
423  }
424  }
425  }
426  }
427 
428  if (foundVertex)
429  return reco::VertexRef(*fromFakeSet ? fakeVertices : vertices, iVertex);
430  }
431 
432  return reco::VertexRef();
433 }
T w() const
bool isAcceptableVtx(reco::VertexCollection::const_iterator iv) const
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
std::vector< LinkConnSpec >::const_iterator IT
edm::Ref< VertexCollection > VertexRef
persistent reference to a Vertex
Definition: VertexFwd.h:13
std::vector< std::pair< double, unsigned > > zAssoc
Log< level::Warning, false > LogWarning
std::vector< TrackBaseRef >::const_iterator trackRef_iterator
The iteratator for the vector<TrackRef>
Definition: Vertex.h:38

◆ isAcceptableVtx()

bool FFTJetPFPileupCleaner::isAcceptableVtx ( reco::VertexCollection::const_iterator  iv) const
private

Definition at line 172 of file FFTJetPFPileupCleaner.cc.

References funct::abs(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::iv, vertexNdofCut, vertexRhoCut, and vertexZmaxCut.

Referenced by findSomeVertexWFakes().

172  {
173  return !iv->isFake() && static_cast<double>(iv->ndof()) > vertexNdofCut && std::abs(iv->z()) < vertexZmaxCut &&
174  iv->position().rho() < vertexRhoCut;
175 }
Abs< T >::type abs(const T &t)
Definition: Abs.h:22

◆ isRemovable()

bool FFTJetPFPileupCleaner::isRemovable ( reco::PFCandidate::ParticleType  ptype) const
private

Definition at line 241 of file FFTJetPFPileupCleaner.cc.

References cms::cuda::assert(), DigiTask_cfi::ptype, removalMask, edm::shift, and mitigatedMETSequence_cff::U.

Referenced by produce().

241  {
242  const unsigned shift = static_cast<unsigned>(ptype);
243  assert(shift < 32U);
244  return removalMask & (1U << shift);
245 }
assert(be >=bs)
static unsigned int const shift

◆ operator=()

FFTJetPFPileupCleaner& FFTJetPFPileupCleaner::operator= ( const FFTJetPFPileupCleaner )
delete

◆ produce()

void FFTJetPFPileupCleaner::produce ( edm::Event iEvent,
const edm::EventSetup iSetup 
)
overrideprotected

Definition at line 178 of file FFTJetPFPileupCleaner.cc.

References PVValHelper::eta, etaMax, FakePrimaryVerticesToken, findSomeVertexWFakes(), mps_fire::i, iEvent, edm::Ref< C, T, F >::isNull(), isRemovable(), edm::HandleBase::isValid(), edm::Ref< C, T, F >::key(), eostools::move(), zmumugammaAnalyzer_cfi::pfCandidates, PFCandidatesToken, removeMainVertex, removeUnassociated, reverseRemovalDecision, useFakePrimaryVertex, AlignmentTracksFromVertexSelector_cfi::vertices, and VerticesToken.

178  {
179  // get PFCandidates
180  auto pOutput = std::make_unique<reco::PFCandidateCollection>();
181 
184 
185  // get vertices
187  iEvent.getByToken(VerticesToken, vertices);
188 
190  if (useFakePrimaryVertex) {
191  iEvent.getByToken(FakePrimaryVerticesToken, fakeVertices);
192  if (!fakeVertices.isValid())
193  throw cms::Exception("FFTJetBadConfig") << "ERROR in FFTJetPFPileupCleaner:"
194  " could not find fake vertices"
195  << std::endl;
196  }
197 
198  const unsigned ncand = pfCandidates->size();
199  for (unsigned i = 0; i < ncand; ++i) {
201  bool remove = false;
202 
203  if (isRemovable(candptr->particleId())) {
204  bool fromFakeSet = false;
205  reco::VertexRef vertexref(findSomeVertexWFakes(vertices, fakeVertices, *candptr, &fromFakeSet));
206  if (vertexref.isNull()) {
207  // Track is not associated with any vertex
208  // in any of the vertex sets
209  remove = removeUnassociated;
210  } else if (vertexref.key() == 0 && (!useFakePrimaryVertex || fromFakeSet)) {
211  // Track is associated with the main primary vertex
212  // However, if we are using fake vertices, this only
213  // matters if the vertex comes from the fake set. If
214  // it comes from the real set, remove the track anyway
215  // because in the combined set the associated vertex
216  // would not be the main primary vertex.
217  remove = removeMainVertex;
218  } else
219  remove = true;
220  }
221 
222  // Check the eta range
223  if (!remove) {
224  const double eta = candptr->p4().Eta();
225  remove = eta < etaMin || eta > etaMax;
226  }
227 
228  // Should we remember this candidate?
230  remove = !remove;
231  if (!remove) {
232  const reco::PFCandidate& cand = (*pfCandidates)[i];
233  pOutput->push_back(cand);
234  pOutput->back().setSourceCandidatePtr(candptr);
235  }
236  }
237 
238  iEvent.put(std::move(pOutput));
239 }
edm::EDGetTokenT< reco::VertexCollection > FakePrimaryVerticesToken
bool isRemovable(reco::PFCandidate::ParticleType ptype) const
int iEvent
Definition: GenABIO.cc:224
edm::EDGetTokenT< reco::VertexCollection > VerticesToken
reco::VertexRef findSomeVertexWFakes(const edm::Handle< reco::VertexCollection > &vertices, const edm::Handle< reco::VertexCollection > &fakeVertices, const reco::PFCandidate &pfcand, bool *fromFakeSet) const
edm::EDGetTokenT< reco::PFCandidateCollection > PFCandidatesToken
bool isValid() const
Definition: HandleBase.h:70
Particle reconstructed by the particle flow algorithm.
Definition: PFCandidate.h:41
def move(src, dest)
Definition: eostools.py:511

◆ setRemovalBit()

void FFTJetPFPileupCleaner::setRemovalBit ( reco::PFCandidate::ParticleType  ptype,
bool  onOff 
)
private

Definition at line 247 of file FFTJetPFPileupCleaner.cc.

References cms::cuda::assert(), ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, DigiTask_cfi::ptype, removalMask, edm::shift, and mitigatedMETSequence_cff::U.

Referenced by buildRemovalMask().

247  {
248  const unsigned shift = static_cast<unsigned>(ptype);
249  assert(shift < 32U);
250  const unsigned mask = (1U << shift);
251  if (value)
252  removalMask |= mask;
253  else
254  removalMask &= ~mask;
255 }
assert(be >=bs)
Definition: value.py:1
static unsigned int const shift

Member Data Documentation

◆ checkClosestZVertex

bool FFTJetPFPileupCleaner::checkClosestZVertex
private

Definition at line 82 of file FFTJetPFPileupCleaner.cc.

Referenced by findSomeVertexWFakes().

◆ etaMax

double FFTJetPFPileupCleaner::etaMax
private

Definition at line 118 of file FFTJetPFPileupCleaner.cc.

Referenced by produce().

◆ etaMin

double FFTJetPFPileupCleaner::etaMin
private

Definition at line 117 of file FFTJetPFPileupCleaner.cc.

◆ FakePrimaryVertices

edm::InputTag FFTJetPFPileupCleaner::FakePrimaryVertices
private

Definition at line 70 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner().

◆ FakePrimaryVerticesToken

edm::EDGetTokenT<reco::VertexCollection> FFTJetPFPileupCleaner::FakePrimaryVerticesToken
private

Definition at line 74 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner(), and produce().

◆ keepIfPVneighbor

bool FFTJetPFPileupCleaner::keepIfPVneighbor
private

Definition at line 89 of file FFTJetPFPileupCleaner.cc.

Referenced by findSomeVertexWFakes().

◆ PFCandidates

edm::InputTag FFTJetPFPileupCleaner::PFCandidates
private

Definition at line 68 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner().

◆ PFCandidatesToken

edm::EDGetTokenT<reco::PFCandidateCollection> FFTJetPFPileupCleaner::PFCandidatesToken
private

Definition at line 72 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner(), and produce().

◆ removalMask

unsigned FFTJetPFPileupCleaner::removalMask
private

Definition at line 114 of file FFTJetPFPileupCleaner.cc.

Referenced by isRemovable(), and setRemovalBit().

◆ remove_e

bool FFTJetPFPileupCleaner::remove_e
private

Definition at line 106 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_egamma_HF

bool FFTJetPFPileupCleaner::remove_egamma_HF
private

Definition at line 111 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_gamma

bool FFTJetPFPileupCleaner::remove_gamma
private

Definition at line 108 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_h

bool FFTJetPFPileupCleaner::remove_h
private

Definition at line 105 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_h0

bool FFTJetPFPileupCleaner::remove_h0
private

Definition at line 109 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_h_HF

bool FFTJetPFPileupCleaner::remove_h_HF
private

Definition at line 110 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_mu

bool FFTJetPFPileupCleaner::remove_mu
private

Definition at line 107 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ remove_X

bool FFTJetPFPileupCleaner::remove_X
private

Definition at line 104 of file FFTJetPFPileupCleaner.cc.

Referenced by buildRemovalMask().

◆ removeMainVertex

bool FFTJetPFPileupCleaner::removeMainVertex
private

Definition at line 93 of file FFTJetPFPileupCleaner.cc.

Referenced by produce().

◆ removeUnassociated

bool FFTJetPFPileupCleaner::removeUnassociated
private

Definition at line 97 of file FFTJetPFPileupCleaner.cc.

Referenced by produce().

◆ reverseRemovalDecision

bool FFTJetPFPileupCleaner::reverseRemovalDecision
private

Definition at line 100 of file FFTJetPFPileupCleaner.cc.

Referenced by produce().

◆ useFakePrimaryVertex

bool FFTJetPFPileupCleaner::useFakePrimaryVertex
private

Definition at line 78 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner(), findSomeVertexWFakes(), and produce().

◆ vertexNdofCut

double FFTJetPFPileupCleaner::vertexNdofCut
private

Definition at line 121 of file FFTJetPFPileupCleaner.cc.

Referenced by isAcceptableVtx().

◆ vertexRhoCut

double FFTJetPFPileupCleaner::vertexRhoCut
private

Definition at line 127 of file FFTJetPFPileupCleaner.cc.

Referenced by isAcceptableVtx().

◆ vertexZmaxCut

double FFTJetPFPileupCleaner::vertexZmaxCut
private

Definition at line 124 of file FFTJetPFPileupCleaner.cc.

Referenced by isAcceptableVtx().

◆ Vertices

edm::InputTag FFTJetPFPileupCleaner::Vertices
private

Definition at line 69 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner().

◆ VerticesToken

edm::EDGetTokenT<reco::VertexCollection> FFTJetPFPileupCleaner::VerticesToken
private

Definition at line 73 of file FFTJetPFPileupCleaner.cc.

Referenced by FFTJetPFPileupCleaner(), and produce().

◆ zAssoc

std::vector<std::pair<double, unsigned> > FFTJetPFPileupCleaner::zAssoc
mutableprivate

Definition at line 130 of file FFTJetPFPileupCleaner.cc.

Referenced by findSomeVertexWFakes().