CMS 3D CMS Logo
List of all members | Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes
LowPtGsfElectronSeedProducer Class Referencefinal

#include <RecoEgamma/EgammaElectronProducers/plugins/LowPtGsfElectronSeedProducer.cc>

Inheritance diagram for LowPtGsfElectronSeedProducer:
edm::stream::EDProducer< edm::GlobalCache< lowptgsfeleseed::HeavyObjectCache > >

Public Types

using TrackIndxMap = std::unordered_map< reco::TrackRef::key_type, size_t >
 
- Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< lowptgsfeleseed::HeavyObjectCache > >
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

void beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
 
 LowPtGsfElectronSeedProducer (const edm::ParameterSet &, const lowptgsfeleseed::HeavyObjectCache *)
 
void produce (edm::Event &, const edm::EventSetup &) override
 
- Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< lowptgsfeleseed::HeavyObjectCache > >
 EDProducer ()=default
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &)
 
static void globalEndJob (lowptgsfeleseed::HeavyObjectCache const *)
 
static std::unique_ptr< lowptgsfeleseed::HeavyObjectCache > initializeGlobalCache (const edm::ParameterSet &conf)
 

Private Member Functions

bool decision (const reco::PFRecTrackRef &pfTrackRef, reco::PreId &ecal, reco::PreId &hcal, double rho, const reco::BeamSpot &spot, noZS::EcalClusterLazyTools &ecalTools)
 
bool decision (const reco::TrackRef &kfTrackRef, reco::PreId &ecal, reco::PreId &hcal, double rho, const reco::BeamSpot &spot, noZS::EcalClusterLazyTools &ecalTools)
 
template<typename CollType >
void fillPreIdRefValueMap (edm::Handle< CollType > tracksHandle, const TrackIndxMap &trksToPreIdIndx, const edm::OrphanHandle< reco::PreIdCollection > &preIdHandle, edm::ValueMap< reco::PreIdRef >::Filler &filler)
 
reco::TrackRef getBaseRef (edm::Handle< std::vector< reco::PFRecTrack > > handle, int idx) const
 
reco::TrackRef getBaseRef (edm::Handle< std::vector< reco::Track > > handle, int idx) const
 
bool lightGsfTracking (reco::PreId &, const reco::TrackRef &, const reco::ElectronSeed &, const edm::EventSetup &)
 
template<typename T >
void loop (const edm::Handle< std::vector< T > > &handle, edm::Handle< reco::PFClusterCollection > &hcalClusters, reco::ElectronSeedCollection &seeds, reco::PreIdCollection &ecalPreIds, reco::PreIdCollection &hcalPreIds, TrackIndxMap &trksToPreIdIndx, edm::Event &, const edm::EventSetup &)
 
void propagateTrackToCalo (const reco::PFRecTrackRef &pfTrackRef, const edm::Handle< reco::PFClusterCollection > &clusters, std::vector< int > &matchedClusters, reco::PreId &preId, bool ecal)
 
void propagateTrackToCalo (const reco::PFRecTrackRef &pfTrackRef, const edm::Handle< reco::PFClusterCollection > &ecalClusters, const edm::Handle< reco::PFClusterCollection > &hcalClusters, std::vector< int > &matchedEcalClusters, std::vector< int > &matchedHcalClusters, reco::PreId &ecalPreId, reco::PreId &hcalPreId)
 
void propagateTrackToCalo (const reco::TrackRef &pfTrack, const edm::Handle< reco::PFClusterCollection > &ecalClusters, const edm::Handle< reco::PFClusterCollection > &hcalClusters, std::vector< int > &matchedEcalClusters, std::vector< int > &matchedHcalClusters, reco::PreId &ecalPreId, reco::PreId &hcalPreId)
 

Private Attributes

const edm::EDGetTokenT< reco::BeamSpot > beamSpot_
 
const std::string builder_
 
const edm::EDGetTokenT< EcalRecHitCollection > ebRecHits_
 
const edm::EDGetTokenT< reco::PFClusterCollection > ecalClusters_
 
const edm::EDGetTokenT< EcalRecHitCollection > eeRecHits_
 
edm::ESHandle< MagneticField > field_
 
const std::string fitter_
 
std::unique_ptr< TrajectoryFitter > fitterPtr_
 
edm::EDGetTokenT< reco::PFClusterCollection > hcalClusters_
 
edm::EDGetTokenT< reco::TrackCollection > kfTracks_
 
const double maxPtThreshold_
 
const double minPtThreshold_
 
const bool passThrough_
 
edm::EDGetTokenT< reco::PFRecTrackCollection > pfTracks_
 
const edm::EDGetTokenT< double > rho_
 
const std::string smoother_
 
std::unique_ptr< TrajectorySmoother > smootherPtr_
 
const bool usePfTracks_
 

Static Private Attributes

static constexpr double boundary_ = 2.50746495928 * 2.50746495928
 
static constexpr double mass_ = 0.000511 * 0.000511
 

Detailed Description

Description: EDProducer of ElectronSeed objects Implementation: <Notes on="" implementation>="">

Definition at line 59 of file LowPtGsfElectronSeedProducer.cc.

Member Typedef Documentation

◆ TrackIndxMap

using LowPtGsfElectronSeedProducer::TrackIndxMap = std::unordered_map<reco::TrackRef::key_type, size_t>

Definition at line 62 of file LowPtGsfElectronSeedProducer.cc.

Constructor & Destructor Documentation

◆ LowPtGsfElectronSeedProducer()

LowPtGsfElectronSeedProducer::LowPtGsfElectronSeedProducer ( const edm::ParameterSet &  conf,
const lowptgsfeleseed::HeavyObjectCache *   
)
explicit

Definition at line 169 of file LowPtGsfElectronSeedProducer.cc.

171  : field_(),
172  fitterPtr_(),
173  smootherPtr_(),
174  kfTracks_(),
175  pfTracks_(),
176  ecalClusters_{consumes<reco::PFClusterCollection>(conf.getParameter<edm::InputTag>("ecalClusters"))},
177  hcalClusters_(),
178  ebRecHits_{consumes<EcalRecHitCollection>(conf.getParameter<edm::InputTag>("EBRecHits"))},
179  eeRecHits_{consumes<EcalRecHitCollection>(conf.getParameter<edm::InputTag>("EERecHits"))},
180  rho_(consumes<double>(conf.getParameter<edm::InputTag>("rho"))),
181  beamSpot_(consumes<reco::BeamSpot>(conf.getParameter<edm::InputTag>("BeamSpot"))),
182  fitter_(conf.getParameter<std::string>("Fitter")),
183  smoother_(conf.getParameter<std::string>("Smoother")),
184  builder_(conf.getParameter<std::string>("TTRHBuilder")),
185  passThrough_(conf.getParameter<bool>("PassThrough")),
186  usePfTracks_(conf.getParameter<bool>("UsePfTracks")),
187  minPtThreshold_(conf.getParameter<double>("MinPtThreshold")),
188  maxPtThreshold_(conf.getParameter<double>("MaxPtThreshold")) {
189  if (usePfTracks_) {
190  pfTracks_ = consumes<reco::PFRecTrackCollection>(conf.getParameter<edm::InputTag>("pfTracks"));
191  hcalClusters_ = consumes<reco::PFClusterCollection>(conf.getParameter<edm::InputTag>("hcalClusters"));
192  }
193  kfTracks_ = consumes<reco::TrackCollection>(conf.getParameter<edm::InputTag>("tracks"));
194 
195  produces<reco::ElectronSeedCollection>();
196  produces<reco::PreIdCollection>();
197  produces<reco::PreIdCollection>("HCAL");
198  produces<edm::ValueMap<reco::PreIdRef> >(); // indexed by edm::Ref<ElectronSeed>.index()
199 }

References edm::ParameterSet::getParameter().

Member Function Documentation

◆ beginLuminosityBlock()

void LowPtGsfElectronSeedProducer::beginLuminosityBlock ( edm::LuminosityBlock const &  ,
edm::EventSetup const &  setup 
)
override

Definition at line 203 of file LowPtGsfElectronSeedProducer.cc.

203  {
204  setup.get<IdealMagneticFieldRecord>().get(field_);
205 }

References field_, get, and singleTopDQM_cfi::setup.

◆ decision() [1/2]

bool LowPtGsfElectronSeedProducer::decision ( const reco::PFRecTrackRef &  pfTrackRef,
reco::PreId &  ecal,
reco::PreId &  hcal,
double  rho,
const reco::BeamSpot &  spot,
noZS::EcalClusterLazyTools &  ecalTools 
)
private

Definition at line 603 of file LowPtGsfElectronSeedProducer.cc.

608  {
609  bool result = false;
610  for (auto& name : globalCache()->modelNames()) {
611  result |= globalCache()->eval(name, ecalPreId, hcalPreId, rho, spot, ecalTools);
612  }
613  return passThrough_ || (pfTrackRef->trackRef()->pt() > maxPtThreshold_) || result;
614 }

References maxPtThreshold_, Skims_PA_cff::name, passThrough_, mps_fire::result, and rho.

Referenced by loop().

◆ decision() [2/2]

bool LowPtGsfElectronSeedProducer::decision ( const reco::TrackRef &  kfTrackRef,
reco::PreId &  ecal,
reco::PreId &  hcal,
double  rho,
const reco::BeamSpot &  spot,
noZS::EcalClusterLazyTools &  ecalTools 
)
private

Definition at line 618 of file LowPtGsfElectronSeedProducer.cc.

623  {
624  // No implementation currently
625  return passThrough_;
626 }

References passThrough_.

◆ fillDescriptions()

void LowPtGsfElectronSeedProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions)
static

Definition at line 651 of file LowPtGsfElectronSeedProducer.cc.

651  {
652  edm::ParameterSetDescription desc;
653  desc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
654  desc.add<edm::InputTag>("pfTracks", edm::InputTag("lowPtGsfElePfTracks"));
655  desc.add<edm::InputTag>("ecalClusters", edm::InputTag("particleFlowClusterECAL"));
656  desc.add<edm::InputTag>("hcalClusters", edm::InputTag("particleFlowClusterHCAL"));
657  desc.add<edm::InputTag>("EBRecHits", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
658  desc.add<edm::InputTag>("EERecHits", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
659  desc.add<edm::InputTag>("rho", edm::InputTag("fixedGridRhoFastjetAllTmp"));
660  desc.add<edm::InputTag>("BeamSpot", edm::InputTag("offlineBeamSpot"));
661  desc.add<std::string>("Fitter", "GsfTrajectoryFitter_forPreId");
662  desc.add<std::string>("Smoother", "GsfTrajectorySmoother_forPreId");
663  desc.add<std::string>("TTRHBuilder", "WithAngleAndTemplate");
664  desc.add<std::vector<std::string> >("ModelNames", std::vector<std::string>());
665  desc.add<std::vector<std::string> >("ModelWeights", std::vector<std::string>());
666  desc.add<std::vector<double> >("ModelThresholds", std::vector<double>());
667  desc.add<bool>("PassThrough", false);
668  desc.add<bool>("UsePfTracks", true);
669  desc.add<double>("MinPtThreshold", 1.0);
670  desc.add<double>("MaxPtThreshold", 15.);
671  descriptions.add("lowPtGsfElectronSeeds", desc);
672 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ fillPreIdRefValueMap()

template<typename CollType >
void LowPtGsfElectronSeedProducer::fillPreIdRefValueMap ( edm::Handle< CollType >  tracksHandle,
const TrackIndxMap &  trksToPreIdIndx,
const edm::OrphanHandle< reco::PreIdCollection > &  preIdHandle,
edm::ValueMap< reco::PreIdRef >::Filler &  filler 
)
private

Definition at line 629 of file LowPtGsfElectronSeedProducer.cc.

632  {
633  std::vector<reco::PreIdRef> values;
634 
635  unsigned ntracks = tracksHandle->size();
636  for (unsigned itrack = 0; itrack < ntracks; ++itrack) {
637  edm::Ref<CollType> trackRef(tracksHandle, itrack);
638  auto preIdRefIt = trksToPreIdIndx.find(trackRef.index());
639  if (preIdRefIt == trksToPreIdIndx.end()) {
640  values.push_back(reco::PreIdRef());
641  } else {
642  edm::Ref<reco::PreIdCollection> preIdRef(preIdHandle, preIdRefIt->second);
643  values.push_back(preIdRef);
644  }
645  }
646  filler.insert(tracksHandle, values.begin(), values.end());
647 }

References trigObjTnPSource_cfi::filler, edm::Ref< C, T, F >::index(), and contentValuesCheck::values.

Referenced by produce().

◆ getBaseRef() [1/2]

reco::TrackRef LowPtGsfElectronSeedProducer::getBaseRef ( edm::Handle< std::vector< reco::PFRecTrack > >  handle,
int  idx 
) const
private

Definition at line 279 of file LowPtGsfElectronSeedProducer.cc.

280  {
281  return reco::PFRecTrackRef(handle, idx)->trackRef();
282 }

References patZpeak::handle, and training_settings::idx.

◆ getBaseRef() [2/2]

reco::TrackRef LowPtGsfElectronSeedProducer::getBaseRef ( edm::Handle< std::vector< reco::Track > >  handle,
int  idx 
) const
private

Definition at line 275 of file LowPtGsfElectronSeedProducer.cc.

275  {
276  return reco::TrackRef(handle, idx);
277 }

References patZpeak::handle, and training_settings::idx.

Referenced by loop().

◆ globalEndJob()

static void LowPtGsfElectronSeedProducer::globalEndJob ( lowptgsfeleseed::HeavyObjectCache const *  )
inlinestatic

Definition at line 69 of file LowPtGsfElectronSeedProducer.cc.

69 {}

◆ initializeGlobalCache()

static std::unique_ptr<lowptgsfeleseed::HeavyObjectCache> LowPtGsfElectronSeedProducer::initializeGlobalCache ( const edm::ParameterSet &  conf)
inlinestatic

Definition at line 65 of file LowPtGsfElectronSeedProducer.cc.

65  {
66  return std::make_unique<lowptgsfeleseed::HeavyObjectCache>(lowptgsfeleseed::HeavyObjectCache(conf));
67  }

◆ lightGsfTracking()

bool LowPtGsfElectronSeedProducer::lightGsfTracking ( reco::PreId &  preId,
const reco::TrackRef &  trackRef,
const reco::ElectronSeed &  seed,
const edm::EventSetup &  setup 
)
private

Definition at line 564 of file LowPtGsfElectronSeedProducer.cc.

567  {
568  Trajectory::ConstRecHitContainer hits;
569  for (unsigned int ihit = 0; ihit < trackRef->recHitsSize(); ++ihit) {
570  hits.push_back(trackRef->recHit(ihit)->cloneSH());
571  }
572 
573  GlobalVector gv(trackRef->innerMomentum().x(), trackRef->innerMomentum().y(), trackRef->innerMomentum().z());
574  GlobalPoint gp(trackRef->innerPosition().x(), trackRef->innerPosition().y(), trackRef->innerPosition().z());
575 
576  GlobalTrajectoryParameters gtps(gp, gv, trackRef->charge(), &*field_);
577 
578  TrajectoryStateOnSurface tsos(gtps, trackRef->innerStateCovariance(), *hits[0]->surface());
579 
580  // Track fitted and smoothed under electron hypothesis
581  Trajectory traj1 = fitterPtr_->fitOne(seed, hits, tsos);
582  if (!traj1.isValid()) {
583  return false;
584  }
585  Trajectory traj2 = smootherPtr_->trajectory(traj1);
586  if (!traj2.isValid()) {
587  return false;
588  }
589 
590  // Set PreId content
591  float chi2Ratio = trackRef->chi2() > 0. ? traj2.chiSquared() / trackRef->chi2() : -1.;
592  float gsfReducedChi2 = chi2Ratio > -1. ? chi2Ratio * trackRef->normalizedChi2() : -1.;
593  float ptOut = traj2.firstMeasurement().updatedState().globalMomentum().perp();
594  float ptIn = traj2.lastMeasurement().updatedState().globalMomentum().perp();
595  float gsfDpt = (ptIn > 0) ? fabs(ptOut - ptIn) / ptIn : 0.;
596  preId.setTrackProperties(gsfReducedChi2, chi2Ratio, gsfDpt);
597 
598  return true;
599 }

References Trajectory::chiSquared(), field_, Trajectory::firstMeasurement(), fitterPtr_, TrajectoryStateOnSurface::globalMomentum(), runTauDisplay::gp, hfClusterShapes_cfi::hits, Trajectory::isValid(), Trajectory::lastMeasurement(), PV3DBase< T, PVType, FrameType >::perp(), SurveyInfoScenario_cff::seed, reco::PreId::setTrackProperties(), smootherPtr_, and TrajectoryMeasurement::updatedState().

Referenced by loop().

◆ loop()

template<typename T >
void LowPtGsfElectronSeedProducer::loop ( const edm::Handle< std::vector< T > > &  handle,
edm::Handle< reco::PFClusterCollection > &  hcalClusters,
reco::ElectronSeedCollection &  seeds,
reco::PreIdCollection &  ecalPreIds,
reco::PreIdCollection &  hcalPreIds,
TrackIndxMap &  trksToPreIdIndx,
edm::Event &  event,
const edm::EventSetup &  setup 
)
private

Definition at line 287 of file LowPtGsfElectronSeedProducer.cc.

294  {
295  // Pileup
296  edm::Handle<double> rho;
297  event.getByToken(rho_, rho);
298 
299  // Beam spot
300  edm::Handle<reco::BeamSpot> spot;
301  event.getByToken(beamSpot_, spot);
302 
303  // Track fitter
304  edm::ESHandle<TrajectoryFitter> fitter;
305  setup.get<TrajectoryFitter::Record>().get(fitter_, fitter);
306  fitterPtr_ = fitter->clone();
307 
308  // Track smoother
309  edm::ESHandle<TrajectorySmoother> smoother;
310  setup.get<TrajectoryFitter::Record>().get(smoother_, smoother);
311  smootherPtr_.reset(smoother->clone());
312 
313  // RecHit cloner
314  edm::ESHandle<TransientTrackingRecHitBuilder> builder;
315  setup.get<TransientRecHitRecord>().get(builder_, builder);
316  TkClonerImpl hitCloner = static_cast<TkTransientTrackingRecHitBuilder const*>(builder.product())->cloner();
317  fitterPtr_->setHitCloner(&hitCloner);
318  smootherPtr_->setHitCloner(&hitCloner);
319 
320  // ECAL clusters
321  edm::Handle<reco::PFClusterCollection> ecalClusters;
322  event.getByToken(ecalClusters_, ecalClusters);
323 
324  // Utility to access to shower shape vars
325  noZS::EcalClusterLazyTools ecalTools(event, setup, ebRecHits_, eeRecHits_);
326 
327  // Ensure each cluster is only matched once to a track
328  std::vector<int> matchedEcalClusters;
329  std::vector<int> matchedHcalClusters;
330 
331  // Reserve
332  seeds.reserve(handle->size());
333  ecalPreIds.reserve(handle->size());
334  hcalPreIds.reserve(handle->size());
335 
336  // Iterate through (PF or KF) tracks
337  for (unsigned int itrk = 0; itrk < handle.product()->size(); itrk++) {
338  edm::Ref<std::vector<T> > templatedRef(handle, itrk); // TrackRef or PFRecTrackRef
339  reco::TrackRef trackRef = getBaseRef(handle, itrk);
340 
341  if (!(trackRef->quality(reco::TrackBase::qualityByName("highPurity")))) {
342  continue;
343  }
344  if (!passThrough_ && (trackRef->pt() < minPtThreshold_)) {
345  continue;
346  }
347 
348  // Create ElectronSeed
349  reco::ElectronSeed seed(*(trackRef->seedRef()));
350  seed.setCtfTrack(trackRef);
351 
352  // Create PreIds
353  unsigned int nModels = globalCache()->modelNames().size();
354  reco::PreId ecalPreId(nModels);
355  reco::PreId hcalPreId(nModels);
356 
357  // Add track ref to PreId
358  ecalPreId.setTrack(trackRef);
359  hcalPreId.setTrack(trackRef);
360 
361  // Add Track-Calo matching variables to PreIds
362  propagateTrackToCalo(
363  templatedRef, ecalClusters, hcalClusters, matchedEcalClusters, matchedHcalClusters, ecalPreId, hcalPreId);
364 
365  // Add variables related to GSF tracks to PreId
366  lightGsfTracking(ecalPreId, trackRef, seed, setup);
367 
368  // Decision based on BDT
369  bool result = decision(templatedRef, ecalPreId, hcalPreId, *rho, *spot, ecalTools);
370 
371  // If fails BDT, do not store seed
372  if (!result) {
373  continue;
374  }
375 
376  // Store PreId
377  ecalPreIds.push_back(ecalPreId);
378  hcalPreIds.push_back(hcalPreId);
379  trksToPreIdIndx[trackRef.index()] = ecalPreIds.size() - 1;
380 
381  // Store ElectronSeed and corresponding edm::Ref<PreId>.index()
382  seeds.push_back(seed);
383  }
384 }

References beamSpot_, builder_, TrajectorySmoother::clone(), TrajectoryFitter::clone(), decision(), ebRecHits_, RecoEcal_cff::ecalClusters, ecalClusters_, eeRecHits_, fitter_, fitterPtr_, get, getBaseRef(), patZpeak::handle, lowPtGsfElectronSeeds_cfi::hcalClusters, edm::Ref< C, T, F >::index(), lightGsfTracking(), minPtThreshold_, passThrough_, edm::ESHandle< T >::product(), propagateTrackToCalo(), reco::TrackBase::qualityByName(), mps_fire::result, rho, rho_, SurveyInfoScenario_cff::seed, InitialStep_cff::seeds, reco::PreId::setTrack(), singleTopDQM_cfi::setup, smoother_, and smootherPtr_.

Referenced by produce().

◆ produce()

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

Definition at line 209 of file LowPtGsfElectronSeedProducer.cc.

209  {
210  // Products
211  auto seeds = std::make_unique<reco::ElectronSeedCollection>();
212  auto ecalPreIds = std::make_unique<reco::PreIdCollection>();
213  auto hcalPreIds = std::make_unique<reco::PreIdCollection>();
214 
215  const edm::RefProd<reco::PreIdCollection> preIdsRefProd = event.getRefBeforePut<reco::PreIdCollection>();
216 
217  // HCAL clusters (only used with PF tracks)
218  edm::Handle<reco::PFClusterCollection> hcalClusters;
219 
220  //we always need kftracks as we link the preids to them
221  edm::Handle<reco::TrackCollection> kfTracks;
222  event.getByToken(kfTracks_, kfTracks);
223 
224  TrackIndxMap trksToPreIdIndx;
225  if (usePfTracks_) {
226  edm::Handle<reco::PFRecTrackCollection> pfTracks;
227  event.getByToken(pfTracks_, pfTracks);
228  event.getByToken(hcalClusters_, hcalClusters);
229 
230  //check consistency between kfTracks and pfTracks collection
231  for (auto& trk : *pfTracks) {
232  if (trk.trackRef().isNonnull()) {
233  if (trk.trackRef().id() != kfTracks.id()) {
234  throw cms::Exception("ConfigError")
235  << "kfTracks is not the collection that pfTracks was built from, please fix this";
236  }
237  break; //we only need one valid track ref to check this so end the loop
238  }
239  }
240 
241  loop(pfTracks, // PF tracks
242  hcalClusters,
243  *seeds,
244  *ecalPreIds,
245  *hcalPreIds,
246  trksToPreIdIndx,
247  event,
248  setup);
249 
250  } else {
251  loop(kfTracks, // KF tracks
252  hcalClusters,
253  *seeds,
254  *ecalPreIds,
255  *hcalPreIds,
256  trksToPreIdIndx,
257  event,
258  setup);
259  }
260 
261  auto ecalPreIdsHandle = event.put(std::move(ecalPreIds));
262  event.put(std::move(hcalPreIds), "HCAL");
263  event.put(std::move(seeds));
264 
265  auto preIdVMOut = std::make_unique<edm::ValueMap<reco::PreIdRef> >();
266  edm::ValueMap<reco::PreIdRef>::Filler mapFiller(*preIdVMOut);
267  fillPreIdRefValueMap(kfTracks, trksToPreIdIndx, ecalPreIdsHandle, mapFiller);
268  mapFiller.fill();
269  event.put(std::move(preIdVMOut));
270 }

References Exception, fillPreIdRefValueMap(), lowPtGsfElectronSeeds_cfi::hcalClusters, hcalClusters_, edm::HandleBase::id(), kfTracks_, loop(), eostools::move(), lowPtGsfElectronSeeds_cfi::pfTracks, pfTracks_, InitialStep_cff::seeds, singleTopDQM_cfi::setup, and usePfTracks_.

◆ propagateTrackToCalo() [1/3]

void LowPtGsfElectronSeedProducer::propagateTrackToCalo ( const reco::PFRecTrackRef &  pfTrackRef,
const edm::Handle< reco::PFClusterCollection > &  clusters,
std::vector< int > &  matchedClusters,
reco::PreId &  preId,
bool  ecal 
)
private

Definition at line 423 of file LowPtGsfElectronSeedProducer.cc.

427  {
428  // Store info for PreId
429  struct Info {
430  reco::PFClusterRef cluRef = reco::PFClusterRef();
431  float dr2min = 1.e6;
432  float deta = 1.e6;
433  float dphi = 1.e6;
434  math::XYZPoint showerPos = math::XYZPoint(0., 0., 0.);
435  } info;
436 
437  // Find closest "seed cluster" to KF track extrapolated to ECAL (or HCAL)
438  reco::PFTrajectoryPoint point;
439  if (ecal) {
440  point = pfTrackRef->extrapolatedPoint(reco::PFTrajectoryPoint::LayerType::ECALShowerMax);
441  } else {
442  point = pfTrackRef->extrapolatedPoint(reco::PFTrajectoryPoint::LayerType::HCALEntrance);
443  }
444 
445  if (point.isValid()) {
446  Info info;
447  for (unsigned int iclu = 0; iclu < clusters.product()->size(); iclu++) {
448  if (std::find(matched.begin(), matched.end(), iclu) == matched.end()) {
449  reco::PFClusterRef cluRef(clusters, iclu);
450 
451  // Determine dR squared
452  float dr2 = reco::deltaR2(cluRef->positionREP(), point.positionREP());
453 
454  if (dr2 < info.dr2min) {
455  info.dr2min = dr2;
456  info.cluRef = cluRef;
457  info.deta = cluRef->positionREP().eta() - point.positionREP().eta();
458  info.dphi =
459  reco::deltaPhi(cluRef->positionREP().phi(), point.positionREP().phi()) * pfTrackRef->trackRef()->charge();
460  info.showerPos = point.position();
461  }
462  }
463  }
464 
465  // Set PreId content if match found
466  if (info.dr2min < 1.e5) {
467  float ep = info.cluRef->correctedEnergy() / std::sqrt(pfTrackRef->trackRef()->innerMomentum().mag2());
468  preId.setECALMatchingProperties(info.cluRef,
469  point.position(), // ECAL or HCAL surface
470  info.showerPos, //
471  info.deta,
472  info.dphi,
473  0.f, // chieta
474  0.f, // chiphi
475  pfTrackRef->trackRef()->normalizedChi2(), // chi2
476  ep);
477  }
478 
479  } // clusters
480 }

References bsc_activity_cfg::clusters, reco::deltaPhi(), reco::deltaR2(), bsc_activity_cfg::ecal, SiStripBadComponentsDQMServiceTemplate_cfg::ep, spr::find(), info(), muonTagProbeFilters_cff::matched, point, reco::PreId::setECALMatchingProperties(), and mathSSE::sqrt().

◆ propagateTrackToCalo() [2/3]

void LowPtGsfElectronSeedProducer::propagateTrackToCalo ( const reco::PFRecTrackRef &  pfTrackRef,
const edm::Handle< reco::PFClusterCollection > &  ecalClusters,
const edm::Handle< reco::PFClusterCollection > &  hcalClusters,
std::vector< int > &  matchedEcalClusters,
std::vector< int > &  matchedHcalClusters,
reco::PreId &  ecalPreId,
reco::PreId &  hcalPreId 
)
private

Definition at line 410 of file LowPtGsfElectronSeedProducer.cc.

416  {
417  propagateTrackToCalo(pfTrackRef, ecalClusters, matchedEcalClusters, ecalPreId, true);
418  propagateTrackToCalo(pfTrackRef, hcalClusters, matchedHcalClusters, hcalPreId, false);
419 }

References RecoEcal_cff::ecalClusters, and lowPtGsfElectronSeeds_cfi::hcalClusters.

Referenced by loop().

◆ propagateTrackToCalo() [3/3]

void LowPtGsfElectronSeedProducer::propagateTrackToCalo ( const reco::TrackRef &  pfTrack,
const edm::Handle< reco::PFClusterCollection > &  ecalClusters,
const edm::Handle< reco::PFClusterCollection > &  hcalClusters,
std::vector< int > &  matchedEcalClusters,
std::vector< int > &  matchedHcalClusters,
reco::PreId &  ecalPreId,
reco::PreId &  hcalPreId 
)
private

Definition at line 484 of file LowPtGsfElectronSeedProducer.cc.

491  {
492  // Store info for PreId
493  struct Info {
494  reco::PFClusterRef cluRef = reco::PFClusterRef();
495  float dr2min = 1.e6;
496  float deta = 1.e6;
497  float dphi = 1.e6;
498  math::XYZPoint showerPos = math::XYZPoint(0., 0., 0.);
499  } info;
500 
501  // Propagate 'electron' to ECAL surface
502  float energy = sqrt(mass_ + kfTrackRef->outerMomentum().Mag2());
503  XYZTLorentzVector mom = XYZTLorentzVector(
504  kfTrackRef->outerMomentum().x(), kfTrackRef->outerMomentum().y(), kfTrackRef->outerMomentum().z(), energy);
505  XYZTLorentzVector pos = XYZTLorentzVector(
506  kfTrackRef->outerPosition().x(), kfTrackRef->outerPosition().y(), kfTrackRef->outerPosition().z(), 0.);
507  math::XYZVector field(field_->inTesla(GlobalPoint(0, 0, 0)));
508  BaseParticlePropagator particle(RawParticle(mom, pos, kfTrackRef->charge()), 0, 0, field.z());
509  particle.propagateToEcalEntrance(false);
510  if (particle.getSuccess() == 0) {
511  return;
512  }
513 
514  // ECAL entry point for track
515  GlobalPoint ecal_pos(
516  particle.particle().vertex().x(), particle.particle().vertex().y(), particle.particle().vertex().z());
517 
518  // Preshower limit
519  bool below_ps = pow(ecal_pos.z(), 2.) > boundary_ * ecal_pos.perp2();
520 
521  // Iterate through ECAL clusters
522  for (unsigned int iclu = 0; iclu < ecalClusters.product()->size(); iclu++) {
523  reco::PFClusterRef cluRef(ecalClusters, iclu);
524 
525  // Correct ecal_pos for shower depth
526  double shower_depth = reco::PFCluster::getDepthCorrection(cluRef->correctedEnergy(), below_ps, false);
527  GlobalPoint showerPos = ecal_pos + GlobalVector(particle.particle().momentum().x(),
528  particle.particle().momentum().y(),
529  particle.particle().momentum().z())
530  .unit() *
531  shower_depth;
532 
533  // Determine dR squared
534  float dr2 = reco::deltaR2(cluRef->positionREP(), showerPos);
535 
536  // Find nearest ECAL cluster
537  if (dr2 < info.dr2min) {
538  info.dr2min = dr2;
539  info.cluRef = cluRef;
540  info.deta = std::abs(cluRef->positionREP().eta() - showerPos.eta());
541  info.dphi = std::abs(reco::deltaPhi(cluRef->positionREP().phi(), showerPos.phi())) * kfTrackRef->charge();
542  info.showerPos = showerPos;
543  }
544  }
545 
546  // Populate PreId object
547  math::XYZPoint point(ecal_pos.x(), ecal_pos.y(), ecal_pos.z());
548 
549  // Set PreId content
550  ecalPreId.setECALMatchingProperties(
551  info.cluRef,
552  point,
553  info.showerPos,
554  info.deta,
555  info.dphi,
556  0.f, // chieta
557  0.f, // chiphi
558  kfTrackRef->normalizedChi2(), // chi2
559  info.cluRef->correctedEnergy() / std::sqrt(kfTrackRef->innerMomentum().mag2())); // E/p
560 }

References funct::abs(), boundary_, reco::deltaPhi(), reco::deltaR2(), RecoEcal_cff::ecalClusters, HCALHighEnergyHPDFilter_cfi::energy, field_, reco::PFCluster::getDepthCorrection(), info(), MagneticField::inTesla(), mass_, point, funct::pow(), BaseParticlePropagator::propagateToEcalEntrance(), reco::PreId::setECALMatchingProperties(), mathSSE::sqrt(), unit(), and RawParticle::z().

Member Data Documentation

◆ beamSpot_

const edm::EDGetTokenT<reco::BeamSpot> LowPtGsfElectronSeedProducer::beamSpot_
private

Definition at line 152 of file LowPtGsfElectronSeedProducer.cc.

Referenced by loop().

◆ boundary_

constexpr double LowPtGsfElectronSeedProducer::boundary_ = 2.50746495928 * 2.50746495928
staticconstexprprivate

Definition at line 162 of file LowPtGsfElectronSeedProducer.cc.

Referenced by propagateTrackToCalo().

◆ builder_

const std::string LowPtGsfElectronSeedProducer::builder_
private

Definition at line 155 of file LowPtGsfElectronSeedProducer.cc.

Referenced by loop().

◆ ebRecHits_

const edm::EDGetTokenT<EcalRecHitCollection> LowPtGsfElectronSeedProducer::ebRecHits_
private

Definition at line 149 of file LowPtGsfElectronSeedProducer.cc.

Referenced by loop().

◆ ecalClusters_

const edm::EDGetTokenT<reco::PFClusterCollection> LowPtGsfElectronSeedProducer::ecalClusters_
private

Definition at line 147 of file LowPtGsfElectronSeedProducer.cc.

Referenced by loop().

◆ eeRecHits_

const edm::EDGetTokenT<EcalRecHitCollection> LowPtGsfElectronSeedProducer::eeRecHits_
private

Definition at line 150 of file LowPtGsfElectronSeedProducer.cc.

Referenced by loop().

◆ field_

edm::ESHandle<MagneticField> LowPtGsfElectronSeedProducer::field_
private

Definition at line 142 of file LowPtGsfElectronSeedProducer.cc.

Referenced by beginLuminosityBlock(), lightGsfTracking(), and propagateTrackToCalo().

◆ fitter_

const std::string LowPtGsfElectronSeedProducer::fitter_
private

Definition at line 153 of file LowPtGsfElectronSeedProducer.cc.

Referenced by loop().

◆ fitterPtr_

std::unique_ptr<TrajectoryFitter> LowPtGsfElectronSeedProducer::fitterPtr_
private

Definition at line 143 of file LowPtGsfElectronSeedProducer.cc.

Referenced by lightGsfTracking(), and loop().

◆ hcalClusters_

edm::EDGetTokenT<reco::PFClusterCollection> LowPtGsfElectronSeedProducer::hcalClusters_
private

Definition at line 148 of file LowPtGsfElectronSeedProducer.cc.

Referenced by produce().

◆ kfTracks_

edm::EDGetTokenT<reco::TrackCollection> LowPtGsfElectronSeedProducer::kfTracks_
private

Definition at line 145 of file LowPtGsfElectronSeedProducer.cc.

Referenced by produce().

◆ mass_

constexpr double LowPtGsfElectronSeedProducer::mass_ = 0.000511 * 0.000511
staticconstexprprivate

Definition at line 164 of file LowPtGsfElectronSeedProducer.cc.

Referenced by propagateTrackToCalo().

◆ maxPtThreshold_

const double LowPtGsfElectronSeedProducer::maxPtThreshold_
private

Definition at line 159 of file LowPtGsfElectronSeedProducer.cc.

Referenced by decision().

◆ minPtThreshold_

const double LowPtGsfElectronSeedProducer::minPtThreshold_
private

Definition at line 158 of file LowPtGsfElectronSeedProducer.cc.

Referenced by loop().

◆ passThrough_

const bool LowPtGsfElectronSeedProducer::passThrough_
private

Definition at line 156 of file LowPtGsfElectronSeedProducer.cc.

Referenced by decision(), and loop().

◆ pfTracks_

edm::EDGetTokenT<reco::PFRecTrackCollection> LowPtGsfElectronSeedProducer::pfTracks_
private

Definition at line 146 of file LowPtGsfElectronSeedProducer.cc.

Referenced by produce().

◆ rho_

const edm::EDGetTokenT<double> LowPtGsfElectronSeedProducer::rho_
private

Definition at line 151 of file LowPtGsfElectronSeedProducer.cc.

Referenced by loop().

◆ smoother_

const std::string LowPtGsfElectronSeedProducer::smoother_
private

Definition at line 154 of file LowPtGsfElectronSeedProducer.cc.

Referenced by loop().

◆ smootherPtr_

std::unique_ptr<TrajectorySmoother> LowPtGsfElectronSeedProducer::smootherPtr_
private

Definition at line 144 of file LowPtGsfElectronSeedProducer.cc.

Referenced by lightGsfTracking(), and loop().

◆ usePfTracks_

const bool LowPtGsfElectronSeedProducer::usePfTracks_
private

Definition at line 157 of file LowPtGsfElectronSeedProducer.cc.

Referenced by produce().

Vector3DBase
Definition: Vector3DBase.h:8
muonTagProbeFilters_cff.matched
matched
Definition: muonTagProbeFilters_cff.py:62
edm::RefProd
Definition: EDProductfwd.h:25
LowPtGsfElectronSeedProducer::pfTracks_
edm::EDGetTokenT< reco::PFRecTrackCollection > pfTracks_
Definition: LowPtGsfElectronSeedProducer.cc:146
lowPtGsfElectronSeeds_cfi.pfTracks
pfTracks
Definition: lowPtGsfElectronSeeds_cfi.py:10
TrajectorySmoother::clone
virtual TrajectorySmoother * clone() const =0
LowPtGsfElectronSeedProducer::rho_
const edm::EDGetTokenT< double > rho_
Definition: LowPtGsfElectronSeedProducer.cc:151
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
LowPtGsfElectronSeedProducer::usePfTracks_
const bool usePfTracks_
Definition: LowPtGsfElectronSeedProducer.cc:157
LowPtGsfElectronSeedProducer::lightGsfTracking
bool lightGsfTracking(reco::PreId &, const reco::TrackRef &, const reco::ElectronSeed &, const edm::EventSetup &)
Definition: LowPtGsfElectronSeedProducer.cc:564
MagneticField::inTesla
virtual GlobalVector inTesla(const GlobalPoint &gp) const =0
Field value ad specified global point, in Tesla.
RawParticle
Definition: RawParticle.h:37
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
BaseParticlePropagator::propagateToEcalEntrance
bool propagateToEcalEntrance(bool first=true)
Definition: BaseParticlePropagator.cc:450
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
lowPtGsfElectronSeeds_cfi.hcalClusters
hcalClusters
Definition: lowPtGsfElectronSeeds_cfi.py:12
Trajectory::chiSquared
float chiSquared() const
Definition: Trajectory.h:241
patZpeak.handle
handle
Definition: patZpeak.py:23
LowPtGsfElectronSeedProducer::eeRecHits_
const edm::EDGetTokenT< EcalRecHitCollection > eeRecHits_
Definition: LowPtGsfElectronSeedProducer.cc:150
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
pos
Definition: PixelAliasList.h:18
LowPtGsfElectronSeedProducer::fitter_
const std::string fitter_
Definition: LowPtGsfElectronSeedProducer.cc:153
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
TransientRecHitRecord
Definition: TransientRecHitRecord.h:14
info
static const TGPicture * info(bool iBackgroundIsBlack)
Definition: FWCollectionSummaryWidget.cc:152
TrajectoryMeasurement::updatedState
TrajectoryStateOnSurface const & updatedState() const
Definition: TrajectoryMeasurement.h:184
XYZTLorentzVector
math::XYZTLorentzVector XYZTLorentzVector
Definition: RawParticle.h:25
LowPtGsfElectronSeedProducer::boundary_
static constexpr double boundary_
Definition: LowPtGsfElectronSeedProducer.cc:162
GlobalVector
Global3DVector GlobalVector
Definition: GlobalVector.h:10
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
reco::PreId
Definition: PreId.h:13
edm::Ref::index
key_type index() const
Definition: Ref.h:253
edm::Handle< double >
training_settings.idx
idx
Definition: training_settings.py:16
singleTopDQM_cfi.setup
setup
Definition: singleTopDQM_cfi.py:37
BaseParticlePropagator
Definition: BaseParticlePropagator.h:82
edm::Ref
Definition: AssociativeIterator.h:58
reco::PFClusterRef
edm::Ref< PFClusterCollection > PFClusterRef
persistent reference to PFCluster objects
Definition: PFClusterFwd.h:15
IdealMagneticFieldRecord
Definition: IdealMagneticFieldRecord.h:11
TrajectoryFitter::clone
virtual std::unique_ptr< TrajectoryFitter > clone() const =0
TrajectoryStateOnSurface
Definition: TrajectoryStateOnSurface.h:16
reco::ElectronSeed
Definition: ElectronSeed.h:51
LowPtGsfElectronSeedProducer::maxPtThreshold_
const double maxPtThreshold_
Definition: LowPtGsfElectronSeedProducer.cc:159
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
contentValuesCheck.values
values
Definition: contentValuesCheck.py:38
LowPtGsfElectronSeedProducer::getBaseRef
reco::TrackRef getBaseRef(edm::Handle< std::vector< reco::Track > > handle, int idx) const
Definition: LowPtGsfElectronSeedProducer.cc:275
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
edm::ESHandle< TrajectoryFitter >
TrajectoryFitterRecord
Definition: TrajectoryFitterRecord.h:12
reco::PFRecTrackRef
edm::Ref< PFRecTrackCollection > PFRecTrackRef
persistent reference to PFRecTrack objects
Definition: PFRecTrackFwd.h:15
HCALHighEnergyHPDFilter_cfi.energy
energy
Definition: HCALHighEnergyHPDFilter_cfi.py:5
GlobalTrajectoryParameters
Definition: GlobalTrajectoryParameters.h:15
Point3DBase< float, GlobalTag >
RawParticle::z
double z() const
z of vertex
Definition: RawParticle.h:284
LowPtGsfElectronSeedProducer::smoother_
const std::string smoother_
Definition: LowPtGsfElectronSeedProducer.cc:154
LowPtGsfElectronSeedProducer::fitterPtr_
std::unique_ptr< TrajectoryFitter > fitterPtr_
Definition: LowPtGsfElectronSeedProducer.cc:143
reco::TrackRef
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:20
DDAxes::rho
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
Trajectory::ConstRecHitContainer
TrackingRecHit::ConstRecHitContainer ConstRecHitContainer
Definition: Trajectory.h:41
bsc_activity_cfg.clusters
clusters
Definition: bsc_activity_cfg.py:36
InitialStep_cff.seeds
seeds
Definition: InitialStep_cff.py:232
runTauDisplay.gp
gp
Definition: runTauDisplay.py:431
EcalClusterLazyToolsT
Definition: EcalClusterLazyTools.h:105
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
RecoEcal_cff.ecalClusters
ecalClusters
Definition: RecoEcal_cff.py:26
Trajectory::lastMeasurement
TrajectoryMeasurement const & lastMeasurement() const
Definition: Trajectory.h:150
trigObjTnPSource_cfi.filler
filler
Definition: trigObjTnPSource_cfi.py:21
reco::deltaR2
constexpr auto deltaR2(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:16
LowPtGsfElectronSeedProducer::field_
edm::ESHandle< MagneticField > field_
Definition: LowPtGsfElectronSeedProducer.cc:142
math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:31
reco::PFCluster::getDepthCorrection
static double getDepthCorrection(double energy, bool isBelowPS=false, bool isHadron=false)
Definition: PFCluster.cc:83
LowPtGsfElectronSeedProducer::ecalClusters_
const edm::EDGetTokenT< reco::PFClusterCollection > ecalClusters_
Definition: LowPtGsfElectronSeedProducer.cc:147
LowPtGsfElectronSeedProducer::smootherPtr_
std::unique_ptr< TrajectorySmoother > smootherPtr_
Definition: LowPtGsfElectronSeedProducer.cc:144
LowPtGsfElectronSeedProducer::hcalClusters_
edm::EDGetTokenT< reco::PFClusterCollection > hcalClusters_
Definition: LowPtGsfElectronSeedProducer.cc:148
LowPtGsfElectronSeedProducer::decision
bool decision(const reco::PFRecTrackRef &pfTrackRef, reco::PreId &ecal, reco::PreId &hcal, double rho, const reco::BeamSpot &spot, noZS::EcalClusterLazyTools &ecalTools)
Definition: LowPtGsfElectronSeedProducer.cc:603
LowPtGsfElectronSeedProducer::propagateTrackToCalo
void propagateTrackToCalo(const reco::PFRecTrackRef &pfTrackRef, const edm::Handle< reco::PFClusterCollection > &ecalClusters, const edm::Handle< reco::PFClusterCollection > &hcalClusters, std::vector< int > &matchedEcalClusters, std::vector< int > &matchedHcalClusters, reco::PreId &ecalPreId, reco::PreId &hcalPreId)
Definition: LowPtGsfElectronSeedProducer.cc:410
get
#define get
unit
Basic3DVector unit() const
Definition: Basic3DVectorLD.h:162
reco::TrackBase::qualityByName
static TrackQuality qualityByName(const std::string &name)
Definition: TrackBase.cc:126
LowPtGsfElectronSeedProducer::beamSpot_
const edm::EDGetTokenT< reco::BeamSpot > beamSpot_
Definition: LowPtGsfElectronSeedProducer.cc:152
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
LowPtGsfElectronSeedProducer::passThrough_
const bool passThrough_
Definition: LowPtGsfElectronSeedProducer.cc:156
TrajectoryStateOnSurface::globalMomentum
GlobalVector globalMomentum() const
Definition: TrajectoryStateOnSurface.h:66
eostools.move
def move(src, dest)
Definition: eostools.py:511
TkClonerImpl
Definition: TkClonerImpl.h:12
Trajectory::firstMeasurement
TrajectoryMeasurement const & firstMeasurement() const
Definition: Trajectory.h:166
LowPtGsfElectronSeedProducer::TrackIndxMap
std::unordered_map< reco::TrackRef::key_type, size_t > TrackIndxMap
Definition: LowPtGsfElectronSeedProducer.cc:62
Trajectory
Definition: Trajectory.h:38
lowptgsfeleseed::HeavyObjectCache
Definition: LowPtGsfElectronSeedHeavyObjectCache.h:52
reco::PFTrajectoryPoint
A PFTrack holds several trajectory points, which basically contain the position and momentum of a tra...
Definition: PFTrajectoryPoint.h:26
Exception
Definition: hltDiff.cc:246
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
bsc_activity_cfg.ecal
ecal
Definition: bsc_activity_cfg.py:25
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:30
LowPtGsfElectronSeedProducer::builder_
const std::string builder_
Definition: LowPtGsfElectronSeedProducer.cc:155
mps_fire.result
result
Definition: mps_fire.py:303
edm::helper::Filler
Definition: ValueMap.h:22
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
LowPtGsfElectronSeedProducer::fillPreIdRefValueMap
void fillPreIdRefValueMap(edm::Handle< CollType > tracksHandle, const TrackIndxMap &trksToPreIdIndx, const edm::OrphanHandle< reco::PreIdCollection > &preIdHandle, edm::ValueMap< reco::PreIdRef >::Filler &filler)
Definition: LowPtGsfElectronSeedProducer.cc:629
reco::PreId::setTrackProperties
void setTrackProperties(float newchi2, float chi2ratio, float dpt)
Definition: PreId.h:53
point
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
Definition: invegas.h:5
LowPtGsfElectronSeedProducer::loop
void loop(const edm::Handle< std::vector< T > > &handle, edm::Handle< reco::PFClusterCollection > &hcalClusters, reco::ElectronSeedCollection &seeds, reco::PreIdCollection &ecalPreIds, reco::PreIdCollection &hcalPreIds, TrackIndxMap &trksToPreIdIndx, edm::Event &, const edm::EventSetup &)
Definition: LowPtGsfElectronSeedProducer.cc:287
event
Definition: event.py:1
LowPtGsfElectronSeedProducer::mass_
static constexpr double mass_
Definition: LowPtGsfElectronSeedProducer.cc:164
edm::HandleBase::id
ProductID id() const
Definition: HandleBase.cc:13
reco::PreId::setECALMatchingProperties
void setECALMatchingProperties(PFClusterRef clusterRef, const math::XYZPoint &ecalpos, const math::XYZPoint &meanShower, float deta, float dphi, float chieta, float chiphi, float chi2, float eop)
Definition: PreId.h:33
LowPtGsfElectronSeedProducer::kfTracks_
edm::EDGetTokenT< reco::TrackCollection > kfTracks_
Definition: LowPtGsfElectronSeedProducer.cc:145
PV3DBase::perp
T perp() const
Definition: PV3DBase.h:69
SiStripBadComponentsDQMServiceTemplate_cfg.ep
ep
Definition: SiStripBadComponentsDQMServiceTemplate_cfg.py:86
LowPtGsfElectronSeedProducer::minPtThreshold_
const double minPtThreshold_
Definition: LowPtGsfElectronSeedProducer.cc:158
edm::InputTag
Definition: InputTag.h:15
reco::PreIdCollection
std::vector< reco::PreId > PreIdCollection
Definition: PreIdFwd.h:6
Trajectory::isValid
bool isValid() const
Definition: Trajectory.h:257
SurveyInfoScenario_cff.seed
seed
Definition: SurveyInfoScenario_cff.py:295
LowPtGsfElectronSeedProducer::ebRecHits_
const edm::EDGetTokenT< EcalRecHitCollection > ebRecHits_
Definition: LowPtGsfElectronSeedProducer.cc:149
Generated for CMSSW Reference Manual by doxygen 1.8.16