CMS 3D CMS Logo
List of all members | Classes | Public Member Functions | Private Member Functions | Private Attributes
GsfElectronAlgo Class Reference

#include <GsfElectronAlgo.h>

Classes

struct  Configuration
 
struct  CutsConfiguration
 
struct  EcalRecHitsConfiguration
 
struct  ElectronData
 
struct  EventData
 
class  HeavyObjectCache
 
struct  IsolationConfiguration
 
struct  StrategyConfiguration
 
struct  Tokens
 

Public Member Functions

reco::GsfElectronCollection completeElectrons (edm::Event const &event, edm::EventSetup const &eventSetup, const HeavyObjectCache *hoc)
 
 GsfElectronAlgo (const Tokens &, const StrategyConfiguration &, const CutsConfiguration &cutsCfg, const ElectronHcalHelper::Configuration &hcalCfg, const IsolationConfiguration &, const EcalRecHitsConfiguration &, std::unique_ptr< EcalClusterFunctionBaseClass > &&superClusterErrorFunction, std::unique_ptr< EcalClusterFunctionBaseClass > &&crackCorrectionFunction, const RegressionHelper::Configuration &regCfg, const edm::ParameterSet &tkIsol03Cfg, const edm::ParameterSet &tkIsol04Cfg, const edm::ParameterSet &tkIsolHEEP03Cfg, const edm::ParameterSet &tkIsolHEEP04Cfg, edm::ConsumesCollector &&cc)
 

Private Member Functions

EventData beginEvent (edm::Event const &event, CaloGeometry const &caloGeometry, EcalSeverityLevelAlgo const &ecalSeveretyLevelAlgo)
 
reco::GsfElectron::SaturationInfo calculateSaturationInfo (const reco::SuperClusterRef &, EventData const &eventData) const
 
template<bool full5x5>
reco::GsfElectron::ShowerShape calculateShowerShape (const reco::SuperClusterRef &, ElectronHcalHelper const &hcalHelper, EventData const &eventData, CaloTopology const &topology, CaloGeometry const &geometry) const
 
void checkSetup (edm::EventSetup const &eventSetup)
 
void createElectron (reco::GsfElectronCollection &electrons, ElectronData &electronData, EventData &eventData, CaloTopology const &topology, CaloGeometry const &geometry, MultiTrajectoryStateTransform const &mtsTransform, double magneticFieldInTesla, const HeavyObjectCache *)
 
void setCutBasedPreselectionFlag (reco::GsfElectron &ele, const reco::BeamSpot &) const
 
void setPixelMatchInfomation (reco::GsfElectron &) const
 

Private Attributes

const edm::ESGetToken< CaloGeometry, CaloGeometryRecord > caloGeometryToken_
 
const edm::ESGetToken< CaloTopology, CaloTopologyRecord > caloTopologyToken_
 
const Configuration cfg_
 
std::unique_ptr< EcalClusterFunctionBaseClass > crackCorrectionFunction_
 
const edm::ESGetToken< EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd > ecalSeveretyLevelAlgoToken_
 
ElectronHcalHelper hcalHelper_
 
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magneticFieldToken_
 
RegressionHelper regHelper_
 
std::unique_ptr< EcalClusterFunctionBaseClass > superClusterErrorFunction_
 
const EleTkIsolFromCands tkIsol03Calc_
 
const EleTkIsolFromCands tkIsol04Calc_
 
const EleTkIsolFromCands tkIsolHEEP03Calc_
 
const EleTkIsolFromCands tkIsolHEEP04Calc_
 
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > trackerGeometryToken_
 

Detailed Description

Definition at line 49 of file GsfElectronAlgo.h.

Constructor & Destructor Documentation

◆ GsfElectronAlgo()

GsfElectronAlgo::GsfElectronAlgo ( const Tokens &  input,
const StrategyConfiguration &  strategy,
const CutsConfiguration &  cutsCfg,
const ElectronHcalHelper::Configuration &  hcalCfg,
const IsolationConfiguration &  iso,
const EcalRecHitsConfiguration &  recHits,
std::unique_ptr< EcalClusterFunctionBaseClass > &&  superClusterErrorFunction,
std::unique_ptr< EcalClusterFunctionBaseClass > &&  crackCorrectionFunction,
const RegressionHelper::Configuration &  regCfg,
const edm::ParameterSet &  tkIsol03Cfg,
const edm::ParameterSet &  tkIsol04Cfg,
const edm::ParameterSet &  tkIsolHEEP03Cfg,
const edm::ParameterSet &  tkIsolHEEP04Cfg,
edm::ConsumesCollector &&  cc 
)

Definition at line 362 of file GsfElectronAlgo.cc.

376  : cfg_{input, strategy, cuts, iso, recHits},
377  tkIsol03Calc_(tkIsol03),
378  tkIsol04Calc_(tkIsol04),
379  tkIsolHEEP03Calc_(tkIsolHEEP03),
380  tkIsolHEEP04Calc_(tkIsolHEEP04),
381  magneticFieldToken_{cc.esConsumes<MagneticField, IdealMagneticFieldRecord>()},
382  caloGeometryToken_{cc.esConsumes<CaloGeometry, CaloGeometryRecord>()},
383  caloTopologyToken_{cc.esConsumes<CaloTopology, CaloTopologyRecord>()},
384  trackerGeometryToken_{cc.esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>()},
385  ecalSeveretyLevelAlgoToken_{cc.esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd>()},
386  hcalHelper_{hcal},
387  superClusterErrorFunction_{
388  std::forward<std::unique_ptr<EcalClusterFunctionBaseClass>>(superClusterErrorFunction)},
389  crackCorrectionFunction_{std::forward<std::unique_ptr<EcalClusterFunctionBaseClass>>(crackCorrectionFunction)},
390  regHelper_{reg}
391 
392 {}

References L1TMuonDQMOffline_cfi::cuts, input, and FastTrackerRecHitMaskProducer_cfi::recHits.

Member Function Documentation

◆ beginEvent()

GsfElectronAlgo::EventData GsfElectronAlgo::beginEvent ( edm::Event const &  event,
CaloGeometry const &  caloGeometry,
EcalSeverityLevelAlgo const &  ecalSeveretyLevelAlgo 
)
private

Definition at line 407 of file GsfElectronAlgo.cc.

409  {
410  // prepare access to hcal data
411  hcalHelper_.readEvent(event);
412 
413  auto const& towers = event.get(cfg_.tokens.hcalTowersTag);
414 
415  // Isolation algos
416  float egHcalIsoConeSizeOutSmall = 0.3, egHcalIsoConeSizeOutLarge = 0.4;
417  float egHcalIsoConeSizeIn = cfg_.iso.intRadiusHcal, egHcalIsoPtMin = cfg_.iso.etMinHcal;
418  int egHcalDepth1 = 1, egHcalDepth2 = 2;
419 
420  float egIsoConeSizeOutSmall = 0.3, egIsoConeSizeOutLarge = 0.4, egIsoJurassicWidth = cfg_.iso.jurassicWidth;
421  float egIsoPtMinBarrel = cfg_.iso.etMinBarrel, egIsoEMinBarrel = cfg_.iso.eMinBarrel,
422  egIsoConeSizeInBarrel = cfg_.iso.intRadiusEcalBarrel;
423  float egIsoPtMinEndcap = cfg_.iso.etMinEndcaps, egIsoEMinEndcap = cfg_.iso.eMinEndcaps,
424  egIsoConeSizeInEndcap = cfg_.iso.intRadiusEcalEndcaps;
425 
426  auto barrelRecHits = event.getHandle(cfg_.tokens.barrelRecHitCollection);
427  auto endcapRecHits = event.getHandle(cfg_.tokens.endcapRecHitCollection);
428 
429  EventData eventData{
430  .event = &event,
431  .beamspot = &event.get(cfg_.tokens.beamSpotTag),
432  .coreElectrons = event.getHandle(cfg_.tokens.gsfElectronCores),
433  .barrelRecHits = barrelRecHits,
434  .endcapRecHits = endcapRecHits,
435  .currentCtfTracks = event.getHandle(cfg_.tokens.ctfTracks),
436  .seeds = event.getHandle(cfg_.tokens.seedsTag),
437  .vertices = event.getHandle(cfg_.tokens.vtxCollectionTag),
438  .conversions = cfg_.strategy.fillConvVtxFitProb ? event.getHandle(cfg_.tokens.conversions)
439  : edm::Handle<reco::ConversionCollection>(),
440  .hadDepth1Isolation03 =
441  EgammaTowerIsolation(egHcalIsoConeSizeOutSmall, egHcalIsoConeSizeIn, egHcalIsoPtMin, egHcalDepth1, &towers),
442  .hadDepth1Isolation04 =
443  EgammaTowerIsolation(egHcalIsoConeSizeOutLarge, egHcalIsoConeSizeIn, egHcalIsoPtMin, egHcalDepth1, &towers),
444  .hadDepth2Isolation03 =
445  EgammaTowerIsolation(egHcalIsoConeSizeOutSmall, egHcalIsoConeSizeIn, egHcalIsoPtMin, egHcalDepth2, &towers),
446  .hadDepth2Isolation04 =
447  EgammaTowerIsolation(egHcalIsoConeSizeOutLarge, egHcalIsoConeSizeIn, egHcalIsoPtMin, egHcalDepth2, &towers),
448  .hadDepth1Isolation03Bc =
449  EgammaTowerIsolation(egHcalIsoConeSizeOutSmall, 0., egHcalIsoPtMin, egHcalDepth1, &towers),
450  .hadDepth1Isolation04Bc =
451  EgammaTowerIsolation(egHcalIsoConeSizeOutLarge, 0., egHcalIsoPtMin, egHcalDepth1, &towers),
452  .hadDepth2Isolation03Bc =
453  EgammaTowerIsolation(egHcalIsoConeSizeOutSmall, 0., egHcalIsoPtMin, egHcalDepth2, &towers),
454  .hadDepth2Isolation04Bc =
455  EgammaTowerIsolation(egHcalIsoConeSizeOutLarge, 0., egHcalIsoPtMin, egHcalDepth2, &towers),
456  .ecalBarrelIsol03 = EgammaRecHitIsolation(egIsoConeSizeOutSmall,
457  egIsoConeSizeInBarrel,
458  egIsoJurassicWidth,
459  egIsoPtMinBarrel,
460  egIsoEMinBarrel,
461  &caloGeometry,
462  *barrelRecHits,
463  &ecalSeveretyLevelAlgo,
464  DetId::Ecal),
465  .ecalBarrelIsol04 = EgammaRecHitIsolation(egIsoConeSizeOutLarge,
466  egIsoConeSizeInBarrel,
467  egIsoJurassicWidth,
468  egIsoPtMinBarrel,
469  egIsoEMinBarrel,
470  &caloGeometry,
471  *barrelRecHits,
472  &ecalSeveretyLevelAlgo,
473  DetId::Ecal),
474  .ecalEndcapIsol03 = EgammaRecHitIsolation(egIsoConeSizeOutSmall,
475  egIsoConeSizeInEndcap,
476  egIsoJurassicWidth,
477  egIsoPtMinEndcap,
478  egIsoEMinEndcap,
479  &caloGeometry,
480  *endcapRecHits,
481  &ecalSeveretyLevelAlgo,
482  DetId::Ecal),
483  .ecalEndcapIsol04 = EgammaRecHitIsolation(egIsoConeSizeOutLarge,
484  egIsoConeSizeInEndcap,
485  egIsoJurassicWidth,
486  egIsoPtMinEndcap,
487  egIsoEMinEndcap,
488  &caloGeometry,
489  *endcapRecHits,
490  &ecalSeveretyLevelAlgo,
491  DetId::Ecal),
492  .originalCtfTracks = {},
493  .originalGsfTracks = {}};
494 
495  eventData.ecalBarrelIsol03.setUseNumCrystals(cfg_.iso.useNumCrystals);
496  eventData.ecalBarrelIsol03.setVetoClustered(cfg_.iso.vetoClustered);
497  eventData.ecalBarrelIsol03.doSeverityChecks(eventData.barrelRecHits.product(),
498  cfg_.recHits.recHitSeverityToBeExcludedBarrel);
499  eventData.ecalBarrelIsol03.doFlagChecks(cfg_.recHits.recHitFlagsToBeExcludedBarrel);
500  eventData.ecalBarrelIsol04.setUseNumCrystals(cfg_.iso.useNumCrystals);
501  eventData.ecalBarrelIsol04.setVetoClustered(cfg_.iso.vetoClustered);
502  eventData.ecalBarrelIsol04.doSeverityChecks(eventData.barrelRecHits.product(),
503  cfg_.recHits.recHitSeverityToBeExcludedBarrel);
504  eventData.ecalBarrelIsol04.doFlagChecks(cfg_.recHits.recHitFlagsToBeExcludedBarrel);
505  eventData.ecalEndcapIsol03.setUseNumCrystals(cfg_.iso.useNumCrystals);
506  eventData.ecalEndcapIsol03.setVetoClustered(cfg_.iso.vetoClustered);
507  eventData.ecalEndcapIsol03.doSeverityChecks(eventData.endcapRecHits.product(),
508  cfg_.recHits.recHitSeverityToBeExcludedEndcaps);
509  eventData.ecalEndcapIsol03.doFlagChecks(cfg_.recHits.recHitFlagsToBeExcludedEndcaps);
510  eventData.ecalEndcapIsol04.setUseNumCrystals(cfg_.iso.useNumCrystals);
511  eventData.ecalEndcapIsol04.setVetoClustered(cfg_.iso.vetoClustered);
512  eventData.ecalEndcapIsol04.doSeverityChecks(eventData.endcapRecHits.product(),
513  cfg_.recHits.recHitSeverityToBeExcludedEndcaps);
514  eventData.ecalEndcapIsol04.doFlagChecks(cfg_.recHits.recHitFlagsToBeExcludedEndcaps);
515 
516  return eventData;
517 }

References GsfElectronAlgo::Tokens::barrelRecHitCollection, HLT_2018_cff::barrelRecHits, GsfElectronAlgo::Tokens::beamSpotTag, cfg_, GsfElectronAlgo::Tokens::conversions, GsfElectronAlgo::Tokens::ctfTracks, DetId::Ecal, GsfElectronAlgo::IsolationConfiguration::eMinBarrel, GsfElectronAlgo::IsolationConfiguration::eMinEndcaps, GsfElectronAlgo::Tokens::endcapRecHitCollection, HLT_2018_cff::endcapRecHits, GsfElectronAlgo::IsolationConfiguration::etMinBarrel, GsfElectronAlgo::IsolationConfiguration::etMinEndcaps, GsfElectronAlgo::IsolationConfiguration::etMinHcal, event(), GsfElectronAlgo::EventData::event, GsfElectronAlgo::StrategyConfiguration::fillConvVtxFitProb, GsfElectronAlgo::Tokens::gsfElectronCores, hcalHelper_, GsfElectronAlgo::Tokens::hcalTowersTag, GsfElectronAlgo::IsolationConfiguration::intRadiusEcalBarrel, GsfElectronAlgo::IsolationConfiguration::intRadiusEcalEndcaps, GsfElectronAlgo::IsolationConfiguration::intRadiusHcal, GsfElectronAlgo::Configuration::iso, GsfElectronAlgo::IsolationConfiguration::jurassicWidth, ElectronHcalHelper::readEvent(), GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedEndcaps, GsfElectronAlgo::Configuration::recHits, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedEndcaps, GsfElectronAlgo::Tokens::seedsTag, EgammaRecHitIsolation::setUseNumCrystals(), GsfElectronAlgo::Configuration::strategy, GsfElectronAlgo::Configuration::tokens, HLT_2018_cff::towers, GsfElectronAlgo::IsolationConfiguration::useNumCrystals, GsfElectronAlgo::IsolationConfiguration::vetoClustered, and GsfElectronAlgo::Tokens::vtxCollectionTag.

Referenced by completeElectrons().

◆ calculateSaturationInfo()

reco::GsfElectron::SaturationInfo GsfElectronAlgo::calculateSaturationInfo ( const reco::SuperClusterRef &  theClus,
EventData const &  eventData 
) const
private

Definition at line 253 of file GsfElectronAlgo.cc.

254  {
255  reco::GsfElectron::SaturationInfo si;
256 
257  const reco::CaloCluster& seedCluster = *(theClus->seed());
258  DetId seedXtalId = seedCluster.seed();
259  int detector = seedXtalId.subdetId();
260  const EcalRecHitCollection* ecalRecHits = nullptr;
261  if (detector == EcalBarrel)
262  ecalRecHits = eventData.barrelRecHits.product();
263  else
264  ecalRecHits = eventData.endcapRecHits.product();
265 
266  int nSaturatedXtals = 0;
267  bool isSeedSaturated = false;
268  for (auto&& hitFractionPair : theClus->hitsAndFractions()) {
269  auto&& ecalRecHit = ecalRecHits->find(hitFractionPair.first);
270  if (ecalRecHit == ecalRecHits->end())
271  continue;
272  if (ecalRecHit->checkFlag(EcalRecHit::Flags::kSaturated)) {
273  nSaturatedXtals++;
274  if (seedXtalId == ecalRecHit->detid())
275  isSeedSaturated = true;
276  }
277  }
278  si.nSaturatedXtals = nSaturatedXtals;
279  si.isSeedSaturated = isSeedSaturated;
280 
281  return si;
282 }

References GsfElectronAlgo::EventData::barrelRecHits, hgcalTestNeighbor_cfi::detector, EcalBarrel, IOMC_cff::ecalRecHit, edm::SortedCollection< T, SORT >::end(), GsfElectronAlgo::EventData::endcapRecHits, edm::SortedCollection< T, SORT >::find(), reco::GsfElectron::SaturationInfo::isSeedSaturated, reco::GsfElectron::SaturationInfo::nSaturatedXtals, reco::CaloCluster::seed(), and DetId::subdetId().

Referenced by createElectron().

◆ calculateShowerShape()

template<bool full5x5>
reco::GsfElectron::ShowerShape GsfElectronAlgo::calculateShowerShape ( const reco::SuperClusterRef &  theClus,
ElectronHcalHelper const &  hcalHelper,
EventData const &  eventData,
CaloTopology const &  topology,
CaloGeometry const &  geometry 
) const
private

Definition at line 285 of file GsfElectronAlgo.cc.

289  {
290  using ClusterTools = EcalClusterToolsT<full5x5>;
291  reco::GsfElectron::ShowerShape showerShape;
292 
293  const reco::CaloCluster& seedCluster = *(theClus->seed());
294  // temporary, till CaloCluster->seed() is made available
295  DetId seedXtalId = seedCluster.hitsAndFractions()[0].first;
296  int detector = seedXtalId.subdetId();
297 
298  const EcalRecHitCollection* recHits = nullptr;
299  std::vector<int> recHitFlagsToBeExcluded;
300  std::vector<int> recHitSeverityToBeExcluded;
301  if (detector == EcalBarrel) {
302  recHits = eventData.barrelRecHits.product();
303  recHitFlagsToBeExcluded = cfg_.recHits.recHitFlagsToBeExcludedBarrel;
304  recHitSeverityToBeExcluded = cfg_.recHits.recHitSeverityToBeExcludedBarrel;
305  } else {
306  recHits = eventData.endcapRecHits.product();
307  recHitFlagsToBeExcluded = cfg_.recHits.recHitFlagsToBeExcludedEndcaps;
308  recHitSeverityToBeExcluded = cfg_.recHits.recHitSeverityToBeExcludedEndcaps;
309  }
310 
311  std::vector<float> covariances = ClusterTools::covariances(seedCluster, recHits, &topology, &geometry);
312  std::vector<float> localCovariances = ClusterTools::localCovariances(seedCluster, recHits, &topology);
313  showerShape.sigmaEtaEta = sqrt(covariances[0]);
314  showerShape.sigmaIetaIeta = sqrt(localCovariances[0]);
315  if (!edm::isNotFinite(localCovariances[2]))
316  showerShape.sigmaIphiIphi = sqrt(localCovariances[2]);
317  showerShape.e1x5 = ClusterTools::e1x5(seedCluster, recHits, &topology);
318  showerShape.e2x5Max = ClusterTools::e2x5Max(seedCluster, recHits, &topology);
319  showerShape.e5x5 = ClusterTools::e5x5(seedCluster, recHits, &topology);
320  showerShape.r9 = ClusterTools::e3x3(seedCluster, recHits, &topology) / theClus->rawEnergy();
321 
322  const float scale = full5x5 ? showerShape.e5x5 : theClus->energy();
323 
324  showerShape.hcalDepth1OverEcal = hcalHelper.hcalESumDepth1(*theClus) / theClus->energy();
325  showerShape.hcalDepth2OverEcal = hcalHelper.hcalESumDepth2(*theClus) / theClus->energy();
326  showerShape.hcalTowersBehindClusters = hcalHelper.hcalTowersBehindClusters(*theClus);
327  showerShape.hcalDepth1OverEcalBc =
328  hcalHelper.hcalESumDepth1BehindClusters(showerShape.hcalTowersBehindClusters) / scale;
329  showerShape.hcalDepth2OverEcalBc =
330  hcalHelper.hcalESumDepth2BehindClusters(showerShape.hcalTowersBehindClusters) / scale;
331  showerShape.invalidHcal = (showerShape.hcalDepth1OverEcalBc == 0 && showerShape.hcalDepth2OverEcalBc == 0 &&
332  !hcalHelper.hasActiveHcal(*theClus));
333 
334  // extra shower shapes
335  const float see_by_spp = showerShape.sigmaIetaIeta * showerShape.sigmaIphiIphi;
336  if (see_by_spp > 0) {
337  showerShape.sigmaIetaIphi = localCovariances[1] / see_by_spp;
338  } else if (localCovariances[1] > 0) {
339  showerShape.sigmaIetaIphi = 1.f;
340  } else {
341  showerShape.sigmaIetaIphi = -1.f;
342  }
343  showerShape.eMax = ClusterTools::eMax(seedCluster, recHits);
344  showerShape.e2nd = ClusterTools::e2nd(seedCluster, recHits);
345  showerShape.eTop = ClusterTools::eTop(seedCluster, recHits, &topology);
346  showerShape.eLeft = ClusterTools::eLeft(seedCluster, recHits, &topology);
347  showerShape.eRight = ClusterTools::eRight(seedCluster, recHits, &topology);
348  showerShape.eBottom = ClusterTools::eBottom(seedCluster, recHits, &topology);
349 
350  showerShape.e2x5Left = ClusterTools::e2x5Left(seedCluster, recHits, &topology);
351  showerShape.e2x5Right = ClusterTools::e2x5Right(seedCluster, recHits, &topology);
352  showerShape.e2x5Top = ClusterTools::e2x5Top(seedCluster, recHits, &topology);
353  showerShape.e2x5Bottom = ClusterTools::e2x5Bottom(seedCluster, recHits, &topology);
354 
355  return showerShape;
356 }

References GsfElectronAlgo::EventData::barrelRecHits, cfg_, hgcalTestNeighbor_cfi::detector, EgHLTOffHistBins_cfi::e1x5, reco::GsfElectron::ShowerShape::e1x5, reco::GsfElectron::ShowerShape::e2nd, reco::GsfElectron::ShowerShape::e2x5Bottom, reco::GsfElectron::ShowerShape::e2x5Left, reco::GsfElectron::ShowerShape::e2x5Max, reco::GsfElectron::ShowerShape::e2x5Right, reco::GsfElectron::ShowerShape::e2x5Top, reco::GsfElectron::ShowerShape::e5x5, reco::GsfElectron::ShowerShape::eBottom, EcalBarrel, reco::GsfElectron::ShowerShape::eLeft, cosmicPhotonAnalyzer_cfi::eMax, reco::GsfElectron::ShowerShape::eMax, GsfElectronAlgo::EventData::endcapRecHits, reco::GsfElectron::ShowerShape::eRight, reco::GsfElectron::ShowerShape::eTop, ElectronHcalHelper::hasActiveHcal(), reco::GsfElectron::ShowerShape::hcalDepth1OverEcal, reco::GsfElectron::ShowerShape::hcalDepth1OverEcalBc, reco::GsfElectron::ShowerShape::hcalDepth2OverEcal, reco::GsfElectron::ShowerShape::hcalDepth2OverEcalBc, ElectronHcalHelper::hcalESumDepth1(), ElectronHcalHelper::hcalESumDepth1BehindClusters(), ElectronHcalHelper::hcalESumDepth2(), ElectronHcalHelper::hcalESumDepth2BehindClusters(), ElectronHcalHelper::hcalTowersBehindClusters(), reco::GsfElectron::ShowerShape::hcalTowersBehindClusters, reco::CaloCluster::hitsAndFractions(), reco::GsfElectron::ShowerShape::invalidHcal, edm::isNotFinite(), reco::GsfElectron::ShowerShape::r9, GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedEndcaps, FastTrackerRecHitMaskProducer_cfi::recHits, GsfElectronAlgo::Configuration::recHits, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedEndcaps, Scenarios_cff::scale, reco::GsfElectron::ShowerShape::sigmaEtaEta, reco::GsfElectron::ShowerShape::sigmaIetaIeta, reco::GsfElectron::ShowerShape::sigmaIetaIphi, reco::GsfElectron::ShowerShape::sigmaIphiIphi, mathSSE::sqrt(), DetId::subdetId(), and ecaldqm::topology().

◆ checkSetup()

void GsfElectronAlgo::checkSetup ( edm::EventSetup const &  eventSetup)
private

Definition at line 394 of file GsfElectronAlgo.cc.

394  {
395  hcalHelper_.checkSetup(es);
396  if (cfg_.strategy.useEcalRegression || cfg_.strategy.useCombinationRegression)
397  regHelper_.checkSetup(es);
398 
399  if (superClusterErrorFunction_) {
400  superClusterErrorFunction_->init(es);
401  }
402  if (crackCorrectionFunction_) {
403  crackCorrectionFunction_->init(es);
404  }
405 }

References cfg_, RegressionHelper::checkSetup(), ElectronHcalHelper::checkSetup(), crackCorrectionFunction_, hcalHelper_, regHelper_, GsfElectronAlgo::Configuration::strategy, superClusterErrorFunction_, GsfElectronAlgo::StrategyConfiguration::useCombinationRegression, and GsfElectronAlgo::StrategyConfiguration::useEcalRegression.

Referenced by completeElectrons().

◆ completeElectrons()

reco::GsfElectronCollection GsfElectronAlgo::completeElectrons ( edm::Event const &  event,
edm::EventSetup const &  eventSetup,
const HeavyObjectCache *  hoc 
)

Definition at line 519 of file GsfElectronAlgo.cc.

521  {
522  reco::GsfElectronCollection electrons;
523 
524  auto const& magneticField = eventSetup.getData(magneticFieldToken_);
525  auto const& caloGeometry = eventSetup.getData(caloGeometryToken_);
526  auto const& caloTopology = eventSetup.getData(caloTopologyToken_);
527  auto const& trackerGeometry = eventSetup.getData(trackerGeometryToken_);
528  auto const& ecalSeveretyLevelAlgo = eventSetup.getData(ecalSeveretyLevelAlgoToken_);
529 
530  checkSetup(eventSetup);
531  auto eventData = beginEvent(event, caloGeometry, ecalSeveretyLevelAlgo);
532  double magneticFieldInTesla = magneticField.inTesla(GlobalPoint(0., 0., 0.)).z();
533 
534  MultiTrajectoryStateTransform mtsTransform(&trackerGeometry, &magneticField);
535  GsfConstraintAtVertex constraintAtVtx(eventSetup);
536 
537  const GsfElectronCoreCollection* coreCollection = eventData.coreElectrons.product();
538  for (unsigned int i = 0; i < coreCollection->size(); ++i) {
539  // check there is no existing electron with this core
540  const GsfElectronCoreRef coreRef = edm::Ref<GsfElectronCoreCollection>(eventData.coreElectrons, i);
541  bool coreFound = false;
542  for (auto const& ele : electrons) {
543  if (ele.core() == coreRef) {
544  coreFound = true;
545  break;
546  }
547  }
548  if (coreFound)
549  continue;
550 
551  // check there is a super-cluster
552  if (coreRef->superCluster().isNull())
553  continue;
554 
555  // prepare internal structure for electron specific data
556  ElectronData electronData(coreRef, *eventData.beamspot);
557 
558  // calculate and check Trajectory StatesOnSurface....
559  if (!electronData.calculateTSOS(mtsTransform, constraintAtVtx))
560  continue;
561 
562  createElectron(
563  electrons, electronData, eventData, caloTopology, caloGeometry, mtsTransform, magneticFieldInTesla, hoc);
564 
565  } // loop over tracks
566  return electrons;
567 }

References beginEvent(), GsfElectronAlgo::ElectronData::calculateTSOS(), caloGeometryToken_, caloTopologyToken_, checkSetup(), createElectron(), ecalSeveretyLevelAlgoToken_, pwdgSkimBPark_cfi::electrons, edm::EventSetup::getData(), mps_fire::i, edm::Ref< C, T, F >::isNull(), HLT_2018_cff::magneticField, magneticFieldToken_, and trackerGeometryToken_.

◆ createElectron()

void GsfElectronAlgo::createElectron ( reco::GsfElectronCollection &  electrons,
ElectronData &  electronData,
EventData &  eventData,
CaloTopology const &  topology,
CaloGeometry const &  geometry,
MultiTrajectoryStateTransform const &  mtsTransform,
double  magneticFieldInTesla,
const HeavyObjectCache *  hoc 
)
private

Definition at line 687 of file GsfElectronAlgo.cc.

694  {
695  // eventually check ctf track
696  if (cfg_.strategy.ctfTracksCheck && electronData.ctfTrackRef.isNull()) {
697  electronData.ctfTrackRef = egamma::getClosestCtfToGsf(electronData.gsfTrackRef, eventData.currentCtfTracks).first;
698  }
699 
700  // charge ID
701  int eleCharge;
702  GsfElectron::ChargeInfo eleChargeInfo;
703  electronData.computeCharge(eleCharge, eleChargeInfo);
704 
705  // electron basic cluster
706  CaloClusterPtr elbcRef = electronData.getEleBasicCluster(mtsTransform);
707 
708  // Seed cluster
709  const reco::CaloCluster& seedCluster = *(electronData.superClusterRef->seed());
710 
711  // seed Xtal
712  // temporary, till CaloCluster->seed() is made available
713  DetId seedXtalId = seedCluster.hitsAndFractions()[0].first;
714 
715  electronData.calculateMode();
716 
717  //====================================================
718  // Candidate attributes
719  //====================================================
720 
721  Candidate::LorentzVector momentum = electronData.calculateMomentum();
722 
723  //====================================================
724  // Track-Cluster Matching
725  //====================================================
726 
727  reco::GsfElectron::TrackClusterMatching tcMatching;
728  tcMatching.electronCluster = elbcRef;
729  tcMatching.eSuperClusterOverP =
730  (electronData.vtxMom.mag() > 0) ? (electronData.superClusterRef->energy() / electronData.vtxMom.mag()) : (-1.);
731  tcMatching.eSeedClusterOverP =
732  (electronData.vtxMom.mag() > 0.) ? (seedCluster.energy() / electronData.vtxMom.mag()) : (-1);
733  tcMatching.eSeedClusterOverPout =
734  (electronData.seedMom.mag() > 0.) ? (seedCluster.energy() / electronData.seedMom.mag()) : (-1.);
735  tcMatching.eEleClusterOverPout =
736  (electronData.eleMom.mag() > 0.) ? (elbcRef->energy() / electronData.eleMom.mag()) : (-1.);
737 
738  EleRelPointPair scAtVtx(
739  electronData.superClusterRef->position(), electronData.sclPos, eventData.beamspot->position());
740  tcMatching.deltaEtaSuperClusterAtVtx = scAtVtx.dEta();
741  tcMatching.deltaPhiSuperClusterAtVtx = scAtVtx.dPhi();
742 
743  EleRelPointPair seedAtCalo(seedCluster.position(), electronData.seedPos, eventData.beamspot->position());
744  tcMatching.deltaEtaSeedClusterAtCalo = seedAtCalo.dEta();
745  tcMatching.deltaPhiSeedClusterAtCalo = seedAtCalo.dPhi();
746 
747  EleRelPointPair ecAtCalo(elbcRef->position(), electronData.elePos, eventData.beamspot->position());
748  tcMatching.deltaEtaEleClusterAtCalo = ecAtCalo.dEta();
749  tcMatching.deltaPhiEleClusterAtCalo = ecAtCalo.dPhi();
750 
751  //=======================================================
752  // Track extrapolations
753  //=======================================================
754 
755  reco::GsfElectron::TrackExtrapolations tkExtra;
756  ele_convert(electronData.vtxPos, tkExtra.positionAtVtx);
757  ele_convert(electronData.sclPos, tkExtra.positionAtCalo);
758  ele_convert(electronData.vtxMom, tkExtra.momentumAtVtx);
759  ele_convert(electronData.sclMom, tkExtra.momentumAtCalo);
760  ele_convert(electronData.seedMom, tkExtra.momentumOut);
761  ele_convert(electronData.eleMom, tkExtra.momentumAtEleClus);
762  ele_convert(electronData.vtxMomWithConstraint, tkExtra.momentumAtVtxWithConstraint);
763 
764  //=======================================================
765  // Closest Ctf Track
766  //=======================================================
767 
768  reco::GsfElectron::ClosestCtfTrack ctfInfo;
769  ctfInfo.ctfTrack = electronData.ctfTrackRef;
770  ctfInfo.shFracInnerHits = electronData.shFracInnerHits;
771 
772  //====================================================
773  // FiducialFlags, using nextToBoundary definition of gaps
774  //====================================================
775 
776  reco::GsfElectron::FiducialFlags fiducialFlags;
777  int region = seedXtalId.det();
778  int detector = seedXtalId.subdetId();
779  double feta = std::abs(electronData.superClusterRef->position().eta());
780  if (detector == EcalBarrel) {
781  fiducialFlags.isEB = true;
782  EBDetId ebdetid(seedXtalId);
783  if (EBDetId::isNextToEtaBoundary(ebdetid)) {
784  if (ebdetid.ietaAbs() == 85) {
785  fiducialFlags.isEBEEGap = true;
786  } else {
787  fiducialFlags.isEBEtaGap = true;
788  }
789  }
790  if (EBDetId::isNextToPhiBoundary(ebdetid)) {
791  fiducialFlags.isEBPhiGap = true;
792  }
793  } else if (detector == EcalEndcap) {
794  fiducialFlags.isEE = true;
795  EEDetId eedetid(seedXtalId);
796  if (EEDetId::isNextToRingBoundary(eedetid)) {
797  if (std::abs(feta) < 2.) {
798  fiducialFlags.isEBEEGap = true;
799  } else {
800  fiducialFlags.isEERingGap = true;
801  }
802  }
803  if (EEDetId::isNextToDBoundary(eedetid)) {
804  fiducialFlags.isEEDeeGap = true;
805  }
806  } else if (EcalTools::isHGCalDet((DetId::Detector)region)) {
807  fiducialFlags.isEE = true;
808  //HGCalDetId eeDetid(seedXtalId);
809  // fill in fiducial information when we know how to use it...
810  } else {
811  throw cms::Exception("GsfElectronAlgo|UnknownXtalRegion")
812  << "createElectron(): do not know if it is a barrel or endcap seed cluster !!!!";
813  }
814 
815  //====================================================
816  // SaturationInfo
817  //====================================================
818 
819  auto saturationInfo = calculateSaturationInfo(electronData.superClusterRef, eventData);
820 
821  //====================================================
822  // ShowerShape
823  //====================================================
824 
825  reco::GsfElectron::ShowerShape showerShape;
826  reco::GsfElectron::ShowerShape full5x5_showerShape;
827  if (!EcalTools::isHGCalDet((DetId::Detector)region)) {
828  showerShape = calculateShowerShape<false>(electronData.superClusterRef, hcalHelper_, eventData, topology, geometry);
829  full5x5_showerShape =
830  calculateShowerShape<true>(electronData.superClusterRef, hcalHelper_, eventData, topology, geometry);
831  }
832 
833  //====================================================
834  // ConversionRejection
835  //====================================================
836 
837  eventData.retreiveOriginalTrackCollections(electronData.ctfTrackRef, electronData.coreRef->gsfTrack());
838 
839  edm::Handle<reco::TrackCollection> ctfTracks = eventData.originalCtfTracks;
840  if (!ctfTracks.isValid()) {
841  ctfTracks = eventData.currentCtfTracks;
842  }
843 
844  // values of conversionInfo.flag
845  // -9999 : Partner track was not found
846  // 0 : Partner track found in the CTF collection using
847  // 1 : Partner track found in the CTF collection using
848  // 2 : Partner track found in the GSF collection using
849  // 3 : Partner track found in the GSF collection using the electron's GSF track
850  ConversionInfo conversionInfo = egammaTools::getConversionInfo(
851  *electronData.coreRef, ctfTracks, eventData.originalGsfTracks, magneticFieldInTesla);
852 
853  reco::GsfElectron::ConversionRejection conversionVars;
854  conversionVars.flags = conversionInfo.flag;
855  conversionVars.dist = conversionInfo.dist;
856  conversionVars.dcot = conversionInfo.dcot;
857  conversionVars.radius = conversionInfo.radiusOfConversion;
858  if (cfg_.strategy.fillConvVtxFitProb) {
859  //this is an intentionally bugged version which ignores the GsfTrack
860  //this is a bug which was introduced in reduced e/gamma where the GsfTrack gets
861  //relinked to a new collection which means it can no longer match the conversion
862  //as it matches based on product/id
863  //we keep this defination for the MVAs
864  const auto matchedConv = ConversionTools::matchedConversion(
865  electronData.coreRef->ctfTrack(), *eventData.conversions, eventData.beamspot->position(), 2.0, 1e-6, 0);
866  conversionVars.vtxFitProb = ConversionTools::getVtxFitProb(matchedConv);
867  }
868  if ((conversionVars.flags == 0) or (conversionVars.flags == 1))
869  conversionVars.partner = TrackBaseRef(conversionInfo.conversionPartnerCtfTk);
870  else if ((conversionVars.flags == 2) or (conversionVars.flags == 3))
871  conversionVars.partner = TrackBaseRef(conversionInfo.conversionPartnerGsfTk);
872 
873  //====================================================
874  // Go !
875  //====================================================
876 
877  electrons.emplace_back(eleCharge,
878  eleChargeInfo,
879  electronData.coreRef,
880  tcMatching,
881  tkExtra,
882  ctfInfo,
883  fiducialFlags,
884  showerShape,
885  full5x5_showerShape,
886  conversionVars,
887  saturationInfo);
888  auto& ele = electrons.back();
889  // Will be overwritten later in the case of the regression
890  ele.setCorrectedEcalEnergyError(superClusterErrorFunction_->getValue(*(ele.superCluster()), 0));
891  ele.setP4(GsfElectron::P4_FROM_SUPER_CLUSTER, momentum, 0, true);
892 
893  //====================================================
894  // brems fractions
895  //====================================================
896 
897  if (electronData.innMom.mag() > 0.) {
898  ele.setTrackFbrem((electronData.innMom.mag() - electronData.outMom.mag()) / electronData.innMom.mag());
899  }
900 
901  // the supercluster is the refined one The seed is not necessarily the first cluster
902  // hence the use of the electronCluster
903  SuperClusterRef sc = ele.superCluster();
904  if (!(sc.isNull())) {
905  CaloClusterPtr cl = ele.electronCluster();
906  if (sc->clustersSize() > 1) {
907  float pf_fbrem = (sc->energy() - cl->energy()) / sc->energy();
908  ele.setSuperClusterFbrem(pf_fbrem);
909  } else {
910  ele.setSuperClusterFbrem(0);
911  }
912  }
913 
914  //====================================================
915  // classification and corrections
916  //====================================================
917  // classification
918  const auto elClass = egamma::classifyElectron(ele);
919  ele.setClassification(elClass);
920 
921  bool unexpectedClassification = elClass == GsfElectron::UNKNOWN || elClass > GsfElectron::GAP;
922  if (unexpectedClassification) {
923  edm::LogWarning("GsfElectronAlgo") << "unexpected classification";
924  }
925 
926  // ecal energy
927  if (cfg_.strategy.useEcalRegression) // new
928  {
929  regHelper_.applyEcalRegression(ele, eventData.vertices, eventData.barrelRecHits, eventData.endcapRecHits);
930  } else // original implementation
931  {
932  if (!EcalTools::isHGCalDet((DetId::Detector)region)) {
933  if (ele.core()->ecalDrivenSeed()) {
934  if (cfg_.strategy.ecalDrivenEcalEnergyFromClassBasedParameterization && !unexpectedClassification) {
935  if (ele.isEcalEnergyCorrected()) {
936  edm::LogWarning("ElectronEnergyCorrector::classBasedElectronEnergy") << "already done";
937  } else {
938  ele.setCorrectedEcalEnergy(
939  egamma::classBasedElectronEnergy(ele, *eventData.beamspot, *crackCorrectionFunction_));
940  }
941  }
942  if (cfg_.strategy.ecalDrivenEcalErrorFromClassBasedParameterization) {
943  ele.setCorrectedEcalEnergyError(egamma::classBasedElectronEnergyUncertainty(ele));
944  }
945  } else {
946  if (cfg_.strategy.pureTrackerDrivenEcalErrorFromSimpleParameterization) {
947  ele.setCorrectedEcalEnergyError(egamma::simpleElectronEnergyUncertainty(ele));
948  }
949  }
950  }
951  }
952 
953  // momentum
954  // Keep the default correction running first. The track momentum error is computed in there
955  if (ele.core()->ecalDrivenSeed() && !unexpectedClassification) {
956  if (ele.p4Error(reco::GsfElectron::P4_COMBINATION) != 999.) {
957  edm::LogWarning("ElectronMomentumCorrector::correct") << "already done";
958  } else {
959  auto p = egamma::correctElectronMomentum(ele, electronData.vtxTSOS);
960  ele.correctMomentum(p.momentum, p.trackError, p.finalError);
961  }
962  }
963  if (cfg_.strategy.useCombinationRegression) // new
964  {
965  regHelper_.applyCombinationRegression(ele);
966  }
967 
968  //====================================================
969  // now isolation variables
970  //====================================================
971 
972  reco::GsfElectron::IsolationVariables dr03, dr04;
973  dr03.tkSumPt = tkIsol03Calc_.calIsolPt(*ele.gsfTrack(), *eventData.currentCtfTracks);
974  dr04.tkSumPt = tkIsol04Calc_.calIsolPt(*ele.gsfTrack(), *eventData.currentCtfTracks);
975  dr03.tkSumPtHEEP = tkIsolHEEP03Calc_.calIsolPt(*ele.gsfTrack(), *eventData.currentCtfTracks);
976  dr04.tkSumPtHEEP = tkIsolHEEP04Calc_.calIsolPt(*ele.gsfTrack(), *eventData.currentCtfTracks);
977 
978  if (!EcalTools::isHGCalDet((DetId::Detector)region)) {
979  dr03.hcalDepth1TowerSumEt = eventData.hadDepth1Isolation03.getTowerEtSum(&ele);
980  dr03.hcalDepth2TowerSumEt = eventData.hadDepth2Isolation03.getTowerEtSum(&ele);
981  dr03.hcalDepth1TowerSumEtBc =
982  eventData.hadDepth1Isolation03Bc.getTowerEtSum(&ele, &(showerShape.hcalTowersBehindClusters));
983  dr03.hcalDepth2TowerSumEtBc =
984  eventData.hadDepth2Isolation03Bc.getTowerEtSum(&ele, &(showerShape.hcalTowersBehindClusters));
985  dr03.ecalRecHitSumEt = eventData.ecalBarrelIsol03.getEtSum(&ele);
986  dr03.ecalRecHitSumEt += eventData.ecalEndcapIsol03.getEtSum(&ele);
987  dr04.hcalDepth1TowerSumEt = eventData.hadDepth1Isolation04.getTowerEtSum(&ele);
988  dr04.hcalDepth2TowerSumEt = eventData.hadDepth2Isolation04.getTowerEtSum(&ele);
989  dr04.hcalDepth1TowerSumEtBc =
990  eventData.hadDepth1Isolation04Bc.getTowerEtSum(&ele, &(showerShape.hcalTowersBehindClusters));
991  dr04.hcalDepth2TowerSumEtBc =
992  eventData.hadDepth2Isolation04Bc.getTowerEtSum(&ele, &(showerShape.hcalTowersBehindClusters));
993  dr04.ecalRecHitSumEt = eventData.ecalBarrelIsol04.getEtSum(&ele);
994  dr04.ecalRecHitSumEt += eventData.ecalEndcapIsol04.getEtSum(&ele);
995  }
996  ele.setIsolation03(dr03);
997  ele.setIsolation04(dr04);
998 
999  //====================================================
1000  // preselection flag
1001  //====================================================
1002 
1003  setCutBasedPreselectionFlag(ele, *eventData.beamspot);
1004  //setting mva flag, currently GedGsfElectron and GsfElectron pre-selection flags have desynced
1005  //this is for GedGsfElectrons, GsfElectrons (ie old pre 7X std reco) resets this later on
1006  //in the function "addPfInfo"
1007  //yes this is awful, we'll fix it once we work out how to...
1008  float mvaValue = hoc->sElectronMVAEstimator->mva(ele, *(eventData.vertices));
1009  ele.setPassMvaPreselection(mvaValue > cfg_.strategy.PreSelectMVA);
1010 
1011  //====================================================
1012  // Pixel match variables
1013  //====================================================
1014  setPixelMatchInfomation(ele);
1015 
1016  LogTrace("GsfElectronAlgo") << "Constructed new electron with energy " << ele.p4().e();
1017 }

References funct::abs(), RegressionHelper::applyCombinationRegression(), RegressionHelper::applyEcalRegression(), GsfElectronAlgo::EventData::barrelRecHits, GsfElectronAlgo::EventData::beamspot, GsfElectronAlgo::ElectronData::calculateMode(), GsfElectronAlgo::ElectronData::calculateMomentum(), calculateSaturationInfo(), EleTkIsolFromCands::calIsolPt(), cfg_, GetRecoTauVFromDQM_MC_cff::cl, egamma::classBasedElectronEnergy(), egamma::classBasedElectronEnergyUncertainty(), egamma::classifyElectron(), GsfElectronAlgo::ElectronData::computeCharge(), ConversionInfo::conversionPartnerCtfTk, ConversionInfo::conversionPartnerGsfTk, GsfElectronAlgo::EventData::conversions, GsfElectronAlgo::ElectronData::coreRef, egamma::correctElectronMomentum(), crackCorrectionFunction_, reco::GsfElectron::ClosestCtfTrack::ctfTrack, GsfElectronAlgo::ElectronData::ctfTrackRef, lowPtGsfElectronCores_cff::ctfTracks, GsfElectronAlgo::StrategyConfiguration::ctfTracksCheck, GsfElectronAlgo::EventData::currentCtfTracks, ConversionInfo::dcot, reco::GsfElectron::ConversionRejection::dcot, reco::GsfElectron::TrackClusterMatching::deltaEtaEleClusterAtCalo, reco::GsfElectron::TrackClusterMatching::deltaEtaSeedClusterAtCalo, reco::GsfElectron::TrackClusterMatching::deltaEtaSuperClusterAtVtx, reco::GsfElectron::TrackClusterMatching::deltaPhiEleClusterAtCalo, reco::GsfElectron::TrackClusterMatching::deltaPhiSeedClusterAtCalo, reco::GsfElectron::TrackClusterMatching::deltaPhiSuperClusterAtVtx, DetId::det(), hgcalTestNeighbor_cfi::detector, ConversionInfo::dist, reco::GsfElectron::ConversionRejection::dist, MillePedeFileConverter_cfg::e, EcalBarrel, GsfElectronAlgo::EventData::ecalBarrelIsol03, GsfElectronAlgo::EventData::ecalBarrelIsol04, GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalEnergyFromClassBasedParameterization, GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalErrorFromClassBasedParameterization, EcalEndcap, GsfElectronAlgo::EventData::ecalEndcapIsol03, GsfElectronAlgo::EventData::ecalEndcapIsol04, reco::GsfElectron::IsolationVariables::ecalRecHitSumEt, reco::GsfElectron::TrackClusterMatching::eEleClusterOverPout, ele_convert(), reco::GsfElectron::TrackClusterMatching::electronCluster, pwdgSkimBPark_cfi::electrons, GsfElectronAlgo::ElectronData::eleMom, GsfElectronAlgo::ElectronData::elePos, GsfElectronAlgo::EventData::endcapRecHits, reco::CaloCluster::energy(), reco::GsfElectron::TrackClusterMatching::eSeedClusterOverP, reco::GsfElectron::TrackClusterMatching::eSeedClusterOverPout, reco::GsfElectron::TrackClusterMatching::eSuperClusterOverP, Exception, JetMETHLTOfflineSource_cfi::feta, GsfElectronAlgo::StrategyConfiguration::fillConvVtxFitProb, ConversionInfo::flag, reco::GsfElectron::ConversionRejection::flags, egamma::getClosestCtfToGsf(), egammaTools::getConversionInfo(), GsfElectronAlgo::ElectronData::getEleBasicCluster(), EgammaRecHitIsolation::getEtSum(), EgammaTowerIsolation::getTowerEtSum(), ConversionTools::getVtxFitProb(), GsfElectronAlgo::ElectronData::gsfTrackRef, GsfElectronAlgo::EventData::hadDepth1Isolation03, GsfElectronAlgo::EventData::hadDepth1Isolation03Bc, GsfElectronAlgo::EventData::hadDepth1Isolation04, GsfElectronAlgo::EventData::hadDepth1Isolation04Bc, GsfElectronAlgo::EventData::hadDepth2Isolation03, GsfElectronAlgo::EventData::hadDepth2Isolation03Bc, GsfElectronAlgo::EventData::hadDepth2Isolation04, GsfElectronAlgo::EventData::hadDepth2Isolation04Bc, reco::GsfElectron::IsolationVariables::hcalDepth1TowerSumEt, reco::GsfElectron::IsolationVariables::hcalDepth1TowerSumEtBc, reco::GsfElectron::IsolationVariables::hcalDepth2TowerSumEt, reco::GsfElectron::IsolationVariables::hcalDepth2TowerSumEtBc, hcalHelper_, reco::GsfElectron::ShowerShape::hcalTowersBehindClusters, reco::CaloCluster::hitsAndFractions(), EBDetId::ietaAbs(), GsfElectronAlgo::ElectronData::innMom, reco::GsfElectron::FiducialFlags::isEB, reco::GsfElectron::FiducialFlags::isEBEEGap, reco::GsfElectron::FiducialFlags::isEBEtaGap, reco::GsfElectron::FiducialFlags::isEBPhiGap, reco::GsfElectron::FiducialFlags::isEE, reco::GsfElectron::FiducialFlags::isEEDeeGap, reco::GsfElectron::FiducialFlags::isEERingGap, EcalTools::isHGCalDet(), EEDetId::isNextToDBoundary(), EBDetId::isNextToEtaBoundary(), EBDetId::isNextToPhiBoundary(), EEDetId::isNextToRingBoundary(), edm::Ref< C, T, F >::isNull(), LogTrace, PV3DBase< T, PVType, FrameType >::mag(), ConversionTools::matchedConversion(), reco::GsfElectron::TrackExtrapolations::momentumAtCalo, reco::GsfElectron::TrackExtrapolations::momentumAtEleClus, reco::GsfElectron::TrackExtrapolations::momentumAtVtx, reco::GsfElectron::TrackExtrapolations::momentumAtVtxWithConstraint, reco::GsfElectron::TrackExtrapolations::momentumOut, or, GsfElectronAlgo::EventData::originalCtfTracks, GsfElectronAlgo::EventData::originalGsfTracks, GsfElectronAlgo::ElectronData::outMom, AlCaHLTBitMon_ParallelJobs::p, reco::GsfElectron::P4_COMBINATION, reco::GsfElectron::ConversionRejection::partner, reco::BeamSpot::position(), reco::CaloCluster::position(), reco::GsfElectron::TrackExtrapolations::positionAtCalo, reco::GsfElectron::TrackExtrapolations::positionAtVtx, GsfElectronAlgo::StrategyConfiguration::PreSelectMVA, GsfElectronAlgo::StrategyConfiguration::pureTrackerDrivenEcalErrorFromSimpleParameterization, reco::GsfElectron::ConversionRejection::radius, ConversionInfo::radiusOfConversion, regHelper_, HLT_2018_cff::region, GsfElectronAlgo::EventData::retreiveOriginalTrackCollections(), GsfElectronAlgo::ElectronData::sclMom, GsfElectronAlgo::ElectronData::sclPos, GsfElectronAlgo::ElectronData::seedMom, GsfElectronAlgo::ElectronData::seedPos, GsfElectronAlgo::HeavyObjectCache::sElectronMVAEstimator, setCutBasedPreselectionFlag(), setPixelMatchInfomation(), GsfElectronAlgo::ElectronData::shFracInnerHits, reco::GsfElectron::ClosestCtfTrack::shFracInnerHits, egamma::simpleElectronEnergyUncertainty(), GsfElectronAlgo::Configuration::strategy, DetId::subdetId(), superClusterErrorFunction_, GsfElectronAlgo::ElectronData::superClusterRef, tkIsol03Calc_, tkIsol04Calc_, tkIsolHEEP03Calc_, tkIsolHEEP04Calc_, reco::GsfElectron::IsolationVariables::tkSumPt, reco::GsfElectron::IsolationVariables::tkSumPtHEEP, ecaldqm::topology(), SiStripSubdetector::UNKNOWN, GsfElectronAlgo::StrategyConfiguration::useCombinationRegression, GsfElectronAlgo::StrategyConfiguration::useEcalRegression, GsfElectronAlgo::EventData::vertices, reco::GsfElectron::ConversionRejection::vtxFitProb, GsfElectronAlgo::ElectronData::vtxMom, GsfElectronAlgo::ElectronData::vtxMomWithConstraint, GsfElectronAlgo::ElectronData::vtxPos, and GsfElectronAlgo::ElectronData::vtxTSOS.

Referenced by completeElectrons().

◆ setCutBasedPreselectionFlag()

void GsfElectronAlgo::setCutBasedPreselectionFlag ( reco::GsfElectron &  ele,
const reco::BeamSpot &  bs 
) const
private

Definition at line 569 of file GsfElectronAlgo.cc.

569  {
570  // default value
571  ele.setPassCutBasedPreselection(false);
572 
573  // kind of seeding
574  bool eg = ele.core()->ecalDrivenSeed();
575  bool pf = ele.core()->trackerDrivenSeed() && !ele.core()->ecalDrivenSeed();
576  if (eg && pf) {
577  throw cms::Exception("GsfElectronAlgo|BothEcalAndPureTrackerDriven")
578  << "An electron cannot be both egamma and purely pflow";
579  }
580  if ((!eg) && (!pf)) {
581  throw cms::Exception("GsfElectronAlgo|NeitherEcalNorPureTrackerDriven")
582  << "An electron cannot be neither egamma nor purely pflow";
583  }
584 
585  CutsConfiguration const& cfg = cfg_.cuts;
586 
587  // Et cut
588  double etaValue = EleRelPoint(ele.superCluster()->position(), bs.position()).eta();
589  double etValue = ele.superCluster()->energy() / cosh(etaValue);
590  LogTrace("GsfElectronAlgo") << "Et : " << etValue;
591  if (ele.isEB() && (etValue < cfg.minSCEtBarrel))
592  return;
593  if (ele.isEE() && (etValue < cfg.minSCEtEndcaps))
594  return;
595  LogTrace("GsfElectronAlgo") << "Et criteria are satisfied";
596 
597  // E/p cut
598  double eopValue = ele.eSuperClusterOverP();
599  LogTrace("GsfElectronAlgo") << "E/p : " << eopValue;
600  if (ele.isEB() && (eopValue > cfg.maxEOverPBarrel))
601  return;
602  if (ele.isEE() && (eopValue > cfg.maxEOverPEndcaps))
603  return;
604  if (ele.isEB() && (eopValue < cfg.minEOverPBarrel))
605  return;
606  if (ele.isEE() && (eopValue < cfg.minEOverPEndcaps))
607  return;
608  LogTrace("GsfElectronAlgo") << "E/p criteria are satisfied";
609 
610  // HoE cuts
611  LogTrace("GsfElectronAlgo") << "HoE1 : " << ele.hcalDepth1OverEcal() << ", HoE2 : " << ele.hcalDepth2OverEcal();
612  double hoeCone = ele.hcalOverEcal();
613  double hoeTower = ele.hcalOverEcalBc();
614  const reco::CaloCluster& seedCluster = *(ele.superCluster()->seed());
615  int detector = seedCluster.hitsAndFractions()[0].first.subdetId();
616  bool HoEveto = false;
617  double scle = ele.superCluster()->energy();
618 
619  if (detector == EcalBarrel)
620  HoEveto = hoeCone * scle < cfg.maxHBarrelCone || hoeTower * scle < cfg.maxHBarrelTower ||
621  hoeCone < cfg.maxHOverEBarrelCone || hoeTower < cfg.maxHOverEBarrelTower;
622  else if (detector == EcalEndcap)
623  HoEveto = hoeCone * scle < cfg.maxHEndcapsCone || hoeTower * scle < cfg.maxHEndcapsTower ||
624  hoeCone < cfg.maxHOverEEndcapsCone || hoeTower < cfg.maxHOverEEndcapsTower;
625 
626  if (!HoEveto)
627  return;
628  LogTrace("GsfElectronAlgo") << "H/E criteria are satisfied";
629 
630  // delta eta criteria
631  double deta = ele.deltaEtaSuperClusterTrackAtVtx();
632  LogTrace("GsfElectronAlgo") << "delta eta : " << deta;
633  if (ele.isEB() && (std::abs(deta) > cfg.maxDeltaEtaBarrel))
634  return;
635  if (ele.isEE() && (std::abs(deta) > cfg.maxDeltaEtaEndcaps))
636  return;
637  LogTrace("GsfElectronAlgo") << "Delta eta criteria are satisfied";
638 
639  // delta phi criteria
640  double dphi = ele.deltaPhiSuperClusterTrackAtVtx();
641  LogTrace("GsfElectronAlgo") << "delta phi : " << dphi;
642  if (ele.isEB() && (std::abs(dphi) > cfg.maxDeltaPhiBarrel))
643  return;
644  if (ele.isEE() && (std::abs(dphi) > cfg.maxDeltaPhiEndcaps))
645  return;
646  LogTrace("GsfElectronAlgo") << "Delta phi criteria are satisfied";
647 
648  // sigma ieta ieta
649  LogTrace("GsfElectronAlgo") << "sigma ieta ieta : " << ele.sigmaIetaIeta();
650  if (ele.isEB() && (ele.sigmaIetaIeta() > cfg.maxSigmaIetaIetaBarrel))
651  return;
652  if (ele.isEE() && (ele.sigmaIetaIeta() > cfg.maxSigmaIetaIetaEndcaps))
653  return;
654  LogTrace("GsfElectronAlgo") << "Sigma ieta ieta criteria are satisfied";
655 
656  // fiducial
657  if (!ele.isEB() && cfg.isBarrel)
658  return;
659  if (!ele.isEE() && cfg.isEndcaps)
660  return;
661  if (cfg.isFiducial &&
662  (ele.isEBEEGap() || ele.isEBEtaGap() || ele.isEBPhiGap() || ele.isEERingGap() || ele.isEEDeeGap()))
663  return;
664  LogTrace("GsfElectronAlgo") << "Fiducial flags criteria are satisfied";
665 
666  // seed in TEC
667  edm::RefToBase<TrajectorySeed> seed = ele.gsfTrack()->extra()->seedRef();
668  ElectronSeedRef elseed = seed.castTo<ElectronSeedRef>();
669  if (eg && !cfg_.cuts.seedFromTEC) {
670  if (elseed.isNull()) {
671  throw cms::Exception("GsfElectronAlgo|NotElectronSeed") << "The GsfTrack seed is not an ElectronSeed ?!";
672  } else {
673  if (elseed->subDet(1) == 6)
674  return;
675  }
676  }
677 
678  // transverse impact parameter
679  if (std::abs(ele.gsfTrack()->dxy(bs.position())) > cfg.maxTIP)
680  return;
681  LogTrace("GsfElectronAlgo") << "TIP criterion is satisfied";
682 
683  LogTrace("GsfElectronAlgo") << "All cut based criteria are satisfied";
684  ele.setPassCutBasedPreselection(true);
685 }

References funct::abs(), cms::cuda::bs, looper::cfg, cfg_, reco::GsfElectron::core(), GsfElectronAlgo::Configuration::cuts, reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx(), reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx(), hgcalTestNeighbor_cfi::detector, EcalBarrel, EcalEndcap, reco::GsfElectron::eSuperClusterOverP(), PVValHelper::eta, Exception, reco::GsfElectron::gsfTrack(), reco::GsfElectron::hcalDepth1OverEcal(), reco::GsfElectron::hcalDepth2OverEcal(), reco::GsfElectron::hcalOverEcal(), reco::GsfElectron::hcalOverEcalBc(), reco::CaloCluster::hitsAndFractions(), reco::GsfElectron::isEB(), reco::GsfElectron::isEBEEGap(), reco::GsfElectron::isEBEtaGap(), reco::GsfElectron::isEBPhiGap(), reco::GsfElectron::isEE(), reco::GsfElectron::isEEDeeGap(), reco::GsfElectron::isEERingGap(), edm::Ref< C, T, F >::isNull(), LogTrace, packedPFCandidateRefMixer_cfi::pf, SurveyInfoScenario_cff::seed, GsfElectronAlgo::CutsConfiguration::seedFromTEC, reco::GsfElectron::setPassCutBasedPreselection(), reco::GsfElectron::sigmaIetaIeta(), and reco::GsfElectron::superCluster().

Referenced by createElectron().

◆ setPixelMatchInfomation()

void GsfElectronAlgo::setPixelMatchInfomation ( reco::GsfElectron &  ele) const
private

Definition at line 1020 of file GsfElectronAlgo.cc.

1020  {
1021  int sd1 = 0;
1022  int sd2 = 0;
1023  float dPhi1 = 0;
1024  float dPhi2 = 0;
1025  float dRz1 = 0;
1026  float dRz2 = 0;
1027  edm::RefToBase<TrajectorySeed> seed = ele.gsfTrack()->extra()->seedRef();
1028  ElectronSeedRef elseed = seed.castTo<ElectronSeedRef>();
1029  if (seed.isNull()) {
1030  } else {
1031  if (elseed.isNull()) {
1032  } else {
1033  sd1 = elseed->subDet(0);
1034  sd2 = elseed->subDet(1);
1035  dPhi1 = (ele.charge() > 0) ? elseed->dPhiPos(0) : elseed->dPhiNeg(0);
1036  dPhi2 = (ele.charge() > 0) ? elseed->dPhiPos(1) : elseed->dPhiNeg(1);
1037  dRz1 = (ele.charge() > 0) ? elseed->dRZPos(0) : elseed->dRZNeg(0);
1038  dRz2 = (ele.charge() > 0) ? elseed->dRZPos(1) : elseed->dRZNeg(1);
1039  }
1040  }
1041  ele.setPixelMatchSubdetectors(sd1, sd2);
1042  ele.setPixelMatchDPhi1(dPhi1);
1043  ele.setPixelMatchDPhi2(dPhi2);
1044  ele.setPixelMatchDRz1(dRz1);
1045  ele.setPixelMatchDRz2(dRz2);
1046 }

References reco::LeafCandidate::charge(), reco::GsfElectron::gsfTrack(), edm::Ref< C, T, F >::isNull(), SurveyInfoScenario_cff::seed, reco::GsfElectron::setPixelMatchDPhi1(), reco::GsfElectron::setPixelMatchDPhi2(), reco::GsfElectron::setPixelMatchDRz1(), reco::GsfElectron::setPixelMatchDRz2(), and reco::GsfElectron::setPixelMatchSubdetectors().

Referenced by createElectron().

Member Data Documentation

◆ caloGeometryToken_

const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> GsfElectronAlgo::caloGeometryToken_
private

Definition at line 246 of file GsfElectronAlgo.h.

Referenced by completeElectrons().

◆ caloTopologyToken_

const edm::ESGetToken<CaloTopology, CaloTopologyRecord> GsfElectronAlgo::caloTopologyToken_
private

Definition at line 247 of file GsfElectronAlgo.h.

Referenced by completeElectrons().

◆ cfg_

const Configuration GsfElectronAlgo::cfg_
private

Definition at line 238 of file GsfElectronAlgo.h.

Referenced by beginEvent(), calculateShowerShape(), checkSetup(), createElectron(), and setCutBasedPreselectionFlag().

◆ crackCorrectionFunction_

std::unique_ptr<EcalClusterFunctionBaseClass> GsfElectronAlgo::crackCorrectionFunction_
private

Definition at line 254 of file GsfElectronAlgo.h.

Referenced by checkSetup(), and createElectron().

◆ ecalSeveretyLevelAlgoToken_

const edm::ESGetToken<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd> GsfElectronAlgo::ecalSeveretyLevelAlgoToken_
private

Definition at line 249 of file GsfElectronAlgo.h.

Referenced by completeElectrons().

◆ hcalHelper_

ElectronHcalHelper GsfElectronAlgo::hcalHelper_
private

Definition at line 252 of file GsfElectronAlgo.h.

Referenced by beginEvent(), checkSetup(), and createElectron().

◆ magneticFieldToken_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> GsfElectronAlgo::magneticFieldToken_
private

Definition at line 245 of file GsfElectronAlgo.h.

Referenced by completeElectrons().

◆ regHelper_

RegressionHelper GsfElectronAlgo::regHelper_
private

Definition at line 255 of file GsfElectronAlgo.h.

Referenced by checkSetup(), and createElectron().

◆ superClusterErrorFunction_

std::unique_ptr<EcalClusterFunctionBaseClass> GsfElectronAlgo::superClusterErrorFunction_
private

Definition at line 253 of file GsfElectronAlgo.h.

Referenced by checkSetup(), and createElectron().

◆ tkIsol03Calc_

const EleTkIsolFromCands GsfElectronAlgo::tkIsol03Calc_
private

Definition at line 240 of file GsfElectronAlgo.h.

Referenced by createElectron().

◆ tkIsol04Calc_

const EleTkIsolFromCands GsfElectronAlgo::tkIsol04Calc_
private

Definition at line 241 of file GsfElectronAlgo.h.

Referenced by createElectron().

◆ tkIsolHEEP03Calc_

const EleTkIsolFromCands GsfElectronAlgo::tkIsolHEEP03Calc_
private

Definition at line 242 of file GsfElectronAlgo.h.

Referenced by createElectron().

◆ tkIsolHEEP04Calc_

const EleTkIsolFromCands GsfElectronAlgo::tkIsolHEEP04Calc_
private

Definition at line 243 of file GsfElectronAlgo.h.

Referenced by createElectron().

◆ trackerGeometryToken_

const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> GsfElectronAlgo::trackerGeometryToken_
private

Definition at line 248 of file GsfElectronAlgo.h.

Referenced by completeElectrons().

reco::GsfElectron::ClosestCtfTrack::shFracInnerHits
float shFracInnerHits
Definition: GsfElectron.h:183
EgHLTOffHistBins_cfi.e1x5
e1x5
Definition: EgHLTOffHistBins_cfi.py:22
ConversionInfo::conversionPartnerGsfTk
const reco::GsfTrackRef conversionPartnerGsfTk
Definition: ConversionInfo.h:18
GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedEndcaps
std::vector< int > recHitFlagsToBeExcludedEndcaps
Definition: GsfElectronAlgo.h:153
EcalSeverityLevelAlgo
Definition: EcalSeverityLevelAlgo.h:33
reco::GsfElectron::ShowerShape::e2x5Right
float e2x5Right
Definition: GsfElectron.h:389
reco::GsfElectron::isEE
bool isEE() const
Definition: GsfElectron.h:337
ConversionInfo
Definition: ConversionInfo.h:8
EBDetId::isNextToEtaBoundary
static bool isNextToEtaBoundary(EBDetId id)
Definition: EBDetId.cc:108
reco::GsfElectron::ShowerShape::r9
float r9
Definition: GsfElectron.h:373
GsfElectronAlgo::magneticFieldToken_
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magneticFieldToken_
Definition: GsfElectronAlgo.h:245
reco::GsfElectron::ShowerShape::sigmaIetaIeta
float sigmaIetaIeta
Definition: GsfElectron.h:368
reco::GsfElectron::ClosestCtfTrack
Definition: GsfElectron.h:181
reco::GsfElectron::TrackClusterMatching::electronCluster
CaloClusterPtr electronCluster
Definition: GsfElectron.h:203
mps_fire.i
i
Definition: mps_fire.py:355
reco::GsfElectron::isEB
bool isEB() const
Definition: GsfElectron.h:336
input
static const std::string input
Definition: EdmProvDump.cc:48
reco::GsfElectron::gsfTrack
GsfTrackRef gsfTrack() const override
reference to a GsfTrack
Definition: GsfElectron.h:164
ele_convert
void ele_convert(const Type1 &obj1, Type2 &obj2)
Definition: ElectronUtilities.h:16
GsfElectronAlgo::tkIsol03Calc_
const EleTkIsolFromCands tkIsol03Calc_
Definition: GsfElectronAlgo.h:240
GsfElectronAlgo::IsolationConfiguration::eMinEndcaps
double eMinEndcaps
Definition: GsfElectronAlgo.h:169
GsfElectronAlgo::Configuration::iso
const IsolationConfiguration iso
Definition: GsfElectronAlgo.h:202
reco::GsfElectron::FiducialFlags::isEBEEGap
bool isEBEEGap
Definition: GsfElectron.h:320
reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx
float deltaPhiSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:236
EcalTools::isHGCalDet
static bool isHGCalDet(DetId::Detector thedet)
identify HGCal cells
Definition: EcalTools.h:48
reco::GsfElectron::ShowerShape::hcalDepth1OverEcal
float hcalDepth1OverEcal
Definition: GsfElectron.h:374
reco::GsfElectron::ChargeInfo
Definition: GsfElectron.h:123
edm::isNotFinite
constexpr bool isNotFinite(T x)
Definition: isFinite.h:9
GsfElectronAlgo::IsolationConfiguration::intRadiusEcalBarrel
double intRadiusEcalBarrel
Definition: GsfElectronAlgo.h:163
GsfElectronAlgo::IsolationConfiguration::etMinHcal
double etMinHcal
Definition: GsfElectronAlgo.h:162
HLT_2018_cff.magneticField
magneticField
Definition: HLT_2018_cff.py:348
reco::GsfElectron::FiducialFlags::isEE
bool isEE
Definition: GsfElectron.h:319
reco::GsfElectron::setPixelMatchDPhi2
void setPixelMatchDPhi2(float dPhi2)
Definition: GsfElectron.h:855
reco::GsfElectron::isEERingGap
bool isEERingGap() const
Definition: GsfElectron.h:345
ConversionInfo::radiusOfConversion
const double radiusOfConversion
Definition: ConversionInfo.h:11
CaloGeometryRecord
Definition: CaloGeometryRecord.h:30
hcal
Definition: ConfigurationDatabase.cc:13
edm::Ref::isNull
bool isNull() const
Checks for null.
Definition: Ref.h:235
EBDetId
Definition: EBDetId.h:17
GsfElectronAlgo::trackerGeometryToken_
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > trackerGeometryToken_
Definition: GsfElectronAlgo.h:248
reco::GsfElectron::FiducialFlags::isEEDeeGap
bool isEEDeeGap
Definition: GsfElectron.h:323
GsfElectronAlgo::Tokens::gsfElectronCores
edm::EDGetTokenT< reco::GsfElectronCoreCollection > gsfElectronCores
Definition: GsfElectronAlgo.h:59
reco::GsfElectron::ClosestCtfTrack::ctfTrack
TrackRef ctfTrack
Definition: GsfElectron.h:182
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
GsfElectronAlgo::StrategyConfiguration::useCombinationRegression
bool useCombinationRegression
Definition: GsfElectronAlgo.h:90
DetId::det
constexpr Detector det() const
get the detector field from this detid
Definition: DetId.h:46
GsfElectronAlgo::IsolationConfiguration::vetoClustered
bool vetoClustered
Definition: GsfElectronAlgo.h:170
geometry
Definition: geometry.py:1
ConversionTools::getVtxFitProb
static float getVtxFitProb(const reco::Conversion *conv)
Definition: ConversionTools.cc:441
EgammaRecHitIsolation::setUseNumCrystals
void setUseNumCrystals(bool b=true)
Definition: EgammaRecHitIsolation.h:45
reco::GsfElectron::P4_COMBINATION
Definition: GsfElectron.h:769
reco::GsfElectron::TrackClusterMatching::eSeedClusterOverP
float eSeedClusterOverP
Definition: GsfElectron.h:205
GsfElectronAlgo::hcalHelper_
ElectronHcalHelper hcalHelper_
Definition: GsfElectronAlgo.h:252
lowPtGsfElectronCores_cff.ctfTracks
ctfTracks
Definition: lowPtGsfElectronCores_cff.py:6
reco::GsfElectron::ShowerShape::eMax
float eMax
Definition: GsfElectron.h:381
reco::GsfElectron::setPixelMatchSubdetectors
void setPixelMatchSubdetectors(int sd1, int sd2)
Definition: GsfElectron.h:853
reco::GsfElectron::ConversionRejection::dcot
float dcot
Definition: GsfElectron.h:576
edm::SortedCollection< EcalRecHit >
reco::GsfElectron::ShowerShape::sigmaIetaIphi
float sigmaIetaIphi
Definition: GsfElectron.h:380
HLT_2018_cff.endcapRecHits
endcapRecHits
Definition: HLT_2018_cff.py:13538
GsfElectronAlgo::setCutBasedPreselectionFlag
void setCutBasedPreselectionFlag(reco::GsfElectron &ele, const reco::BeamSpot &) const
Definition: GsfElectronAlgo.cc:569
reco::TrackBaseRef
edm::RefToBase< reco::Track > TrackBaseRef
persistent reference to a Track, using views
Definition: TrackFwd.h:35
GsfElectronAlgo::IsolationConfiguration::useNumCrystals
bool useNumCrystals
Definition: GsfElectronAlgo.h:171
GsfElectronAlgo::IsolationConfiguration::eMinBarrel
double eMinBarrel
Definition: GsfElectronAlgo.h:167
reco::GsfElectronCollection
std::vector< GsfElectron > GsfElectronCollection
collection of GsfElectron objects
Definition: GsfElectronFwd.h:14
CaloTopologyRecord
Definition: CaloTopologyRecord.h:10
reco::GsfElectron::SaturationInfo::nSaturatedXtals
int nSaturatedXtals
Definition: GsfElectron.h:491
EgammaRecHitIsolation
Definition: EgammaRecHitIsolation.h:26
reco::GsfElectron::TrackClusterMatching::eEleClusterOverPout
float eEleClusterOverPout
Definition: GsfElectron.h:207
GsfElectronAlgo::tkIsolHEEP03Calc_
const EleTkIsolFromCands tkIsolHEEP03Calc_
Definition: GsfElectronAlgo.h:242
reco::GsfElectron::TrackExtrapolations::momentumAtCalo
math::XYZVectorF momentumAtCalo
Definition: GsfElectron.h:265
GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedBarrel
std::vector< int > recHitFlagsToBeExcludedBarrel
Definition: GsfElectronAlgo.h:152
reco::GsfElectron::TrackExtrapolations::momentumOut
math::XYZVectorF momentumOut
Definition: GsfElectron.h:267
GsfElectronAlgo::Tokens::seedsTag
edm::EDGetTokenT< reco::ElectronSeedCollection > seedsTag
Definition: GsfElectronAlgo.h:65
reco::GsfElectron::ShowerShape::e2x5Max
float e2x5Max
Definition: GsfElectron.h:371
reco::GsfElectron::TrackClusterMatching::deltaEtaEleClusterAtCalo
float deltaEtaEleClusterAtCalo
Definition: GsfElectron.h:210
edm::Handle< reco::ConversionCollection >
GsfElectronAlgo::Tokens::beamSpotTag
edm::EDGetTokenT< reco::BeamSpot > beamSpotTag
Definition: GsfElectronAlgo.h:67
GsfElectronAlgo::Tokens::barrelRecHitCollection
edm::EDGetTokenT< EcalRecHitCollection > barrelRecHitCollection
Definition: GsfElectronAlgo.h:63
CaloTopology
Definition: CaloTopology.h:19
GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalErrorFromClassBasedParameterization
bool ecalDrivenEcalErrorFromClassBasedParameterization
Definition: GsfElectronAlgo.h:78
reco::GsfElectron::hcalDepth2OverEcal
float hcalDepth2OverEcal() const
Definition: GsfElectron.h:426
EcalBarrel
Definition: EcalSubdetector.h:10
reco::GsfElectron::ShowerShape::eBottom
float eBottom
Definition: GsfElectron.h:386
edm::Ref< GsfElectronCoreCollection >
reco::GsfElectron::FiducialFlags::isEBPhiGap
bool isEBPhiGap
Definition: GsfElectron.h:322
RegressionHelper::applyCombinationRegression
void applyCombinationRegression(reco::GsfElectron &ele) const
Definition: RegressionHelper.cc:152
cc
reco::GsfElectron::hcalDepth1OverEcal
float hcalDepth1OverEcal() const
Definition: GsfElectron.h:425
reco::GsfElectron::ShowerShape::sigmaEtaEta
float sigmaEtaEta
Definition: GsfElectron.h:367
RegressionHelper::applyEcalRegression
void applyEcalRegression(reco::GsfElectron &electron, const edm::Handle< reco::VertexCollection > &vertices, const edm::Handle< EcalRecHitCollection > &rechitsEB, const edm::Handle< EcalRecHitCollection > &rechitsEE) const
Definition: RegressionHelper.cc:23
reco::GsfElectron::core
virtual GsfElectronCoreRef core() const
Definition: GsfElectron.cc:8
reco::GsfElectron::TrackClusterMatching::deltaPhiSuperClusterAtVtx
float deltaPhiSuperClusterAtVtx
Definition: GsfElectron.h:212
reco::GsfElectron::IsolationVariables::tkSumPtHEEP
float tkSumPtHEEP
Definition: GsfElectron.h:512
GetRecoTauVFromDQM_MC_cff.cl
cl
Definition: GetRecoTauVFromDQM_MC_cff.py:38
IdealMagneticFieldRecord
Definition: IdealMagneticFieldRecord.h:11
DetId
Definition: DetId.h:17
GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedBarrel
std::vector< int > recHitSeverityToBeExcludedBarrel
Definition: GsfElectronAlgo.h:154
EleRelPoint
Definition: ElectronUtilities.h:25
CaloGeometry
Definition: CaloGeometry.h:21
cms::cuda::bs
bs
Definition: HistoContainer.h:127
reco::GsfElectron::IsolationVariables::tkSumPt
float tkSumPt
Definition: GsfElectron.h:511
reco::GsfElectron::FiducialFlags::isEERingGap
bool isEERingGap
Definition: GsfElectron.h:324
GsfElectronAlgo::caloTopologyToken_
const edm::ESGetToken< CaloTopology, CaloTopologyRecord > caloTopologyToken_
Definition: GsfElectronAlgo.h:247
GsfElectronAlgo::StrategyConfiguration::pureTrackerDrivenEcalErrorFromSimpleParameterization
bool pureTrackerDrivenEcalErrorFromSimpleParameterization
Definition: GsfElectronAlgo.h:79
GsfElectronAlgo::regHelper_
RegressionHelper regHelper_
Definition: GsfElectronAlgo.h:255
reco::GsfElectron::setPixelMatchDRz2
void setPixelMatchDRz2(float dRz2)
Definition: GsfElectron.h:857
ecaldqm::topology
const CaloTopology * topology(nullptr)
reco::GsfElectron::ConversionRejection
Definition: GsfElectron.h:572
GsfConstraintAtVertex
Definition: GsfConstraintAtVertex.h:21
reco::GsfElectron::ShowerShape
Definition: GsfElectron.h:366
PVValHelper::eta
Definition: PVValidationHelpers.h:69
reco::GsfElectronCoreCollection
std::vector< GsfElectronCore > GsfElectronCoreCollection
Definition: GsfElectronCoreFwd.h:12
reco::CaloCluster
Definition: CaloCluster.h:31
TrackerDigiGeometryRecord
Definition: TrackerDigiGeometryRecord.h:15
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
GsfElectronAlgo::setPixelMatchInfomation
void setPixelMatchInfomation(reco::GsfElectron &) const
Definition: GsfElectronAlgo.cc:1020
EcalSeverityLevelAlgoRcd
Definition: EcalSeverityLevelAlgoRcd.h:12
reco::GsfElectron::isEEDeeGap
bool isEEDeeGap() const
Definition: GsfElectron.h:344
reco::GsfElectron::IsolationVariables::hcalDepth1TowerSumEt
float hcalDepth1TowerSumEt
Definition: GsfElectron.h:514
reco::GsfElectron::ShowerShape::eTop
float eTop
Definition: GsfElectron.h:383
reco::GsfElectron::FiducialFlags
Definition: GsfElectron.h:317
GsfElectronAlgo::createElectron
void createElectron(reco::GsfElectronCollection &electrons, ElectronData &electronData, EventData &eventData, CaloTopology const &topology, CaloGeometry const &geometry, MultiTrajectoryStateTransform const &mtsTransform, double magneticFieldInTesla, const HeavyObjectCache *)
Definition: GsfElectronAlgo.cc:687
reco::GsfElectron::setPixelMatchDRz1
void setPixelMatchDRz1(float dRz1)
Definition: GsfElectron.h:856
egammaTools::getConversionInfo
ConversionInfo getConversionInfo(const reco::GsfElectronCore &, const edm::Handle< reco::TrackCollection > &ctftracks_h, const edm::Handle< reco::GsfTrackCollection > &gsftracks_h, const double bFieldAtOrigin, const double minFracSharedHits=0.45)
Definition: ConversionFinder.cc:35
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
reco::GsfElectron::IsolationVariables
Definition: GsfElectron.h:510
reco::GsfElectron::ShowerShape::hcalTowersBehindClusters
std::vector< CaloTowerDetId > hcalTowersBehindClusters
Definition: GsfElectron.h:376
reco::GsfElectron::ShowerShape::sigmaIphiIphi
float sigmaIphiIphi
Definition: GsfElectron.h:369
GsfElectronAlgo::StrategyConfiguration::ctfTracksCheck
bool ctfTracksCheck
Definition: GsfElectronAlgo.h:85
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector's numbering enum)
Definition: DetId.h:48
EEDetId
Definition: EEDetId.h:14
GsfElectronAlgo::beginEvent
EventData beginEvent(edm::Event const &event, CaloGeometry const &caloGeometry, EcalSeverityLevelAlgo const &ecalSeveretyLevelAlgo)
Definition: GsfElectronAlgo.cc:407
GsfElectronAlgo::Tokens::endcapRecHitCollection
edm::EDGetTokenT< EcalRecHitCollection > endcapRecHitCollection
Definition: GsfElectronAlgo.h:64
egamma::classBasedElectronEnergy
float classBasedElectronEnergy(reco::GsfElectron const &, reco::BeamSpot const &, EcalClusterFunctionBaseClass const &crackCorrectionFunction)
Definition: ElectronEnergyCorrector.cc:295
EcalEndcap
Definition: EcalSubdetector.h:10
reco::GsfElectron::IsolationVariables::hcalDepth1TowerSumEtBc
float hcalDepth1TowerSumEtBc
Definition: GsfElectron.h:516
FastTrackerRecHitMaskProducer_cfi.recHits
recHits
Definition: FastTrackerRecHitMaskProducer_cfi.py:8
edm::LogWarning
Definition: MessageLogger.h:141
reco::GsfElectron::TrackClusterMatching::eSeedClusterOverPout
float eSeedClusterOverPout
Definition: GsfElectron.h:206
EleTkIsolFromCands::calIsolPt
double calIsolPt(Args &&... args) const
Definition: EleTkIsolFromCands.h:95
reco::GsfElectron::IsolationVariables::hcalDepth2TowerSumEtBc
float hcalDepth2TowerSumEtBc
Definition: GsfElectron.h:517
Scenarios_cff.scale
scale
Definition: Scenarios_cff.py:2186
IOMC_cff.ecalRecHit
ecalRecHit
Definition: IOMC_cff.py:103
JetMETHLTOfflineSource_cfi.feta
feta
Definition: JetMETHLTOfflineSource_cfi.py:30
reco::GsfElectron::TrackClusterMatching
Definition: GsfElectron.h:202
reco::GsfElectron::TrackClusterMatching::eSuperClusterOverP
float eSuperClusterOverP
Definition: GsfElectron.h:204
reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx
float deltaEtaSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:233
reco::CaloCluster::hitsAndFractions
const std::vector< std::pair< DetId, float > > & hitsAndFractions() const
Definition: CaloCluster.h:210
GsfElectronAlgo::ecalSeveretyLevelAlgoToken_
const edm::ESGetToken< EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd > ecalSeveretyLevelAlgoToken_
Definition: GsfElectronAlgo.h:249
GsfElectronAlgo::checkSetup
void checkSetup(edm::EventSetup const &eventSetup)
Definition: GsfElectronAlgo.cc:394
EEDetId::isNextToRingBoundary
static bool isNextToRingBoundary(EEDetId id)
Definition: EEDetId.cc:284
cosmicPhotonAnalyzer_cfi.eMax
eMax
Definition: cosmicPhotonAnalyzer_cfi.py:10
GsfElectronAlgo::Tokens::conversions
edm::EDGetTokenT< reco::ConversionCollection > conversions
Definition: GsfElectronAlgo.h:69
reco::GsfElectron::TrackExtrapolations::momentumAtVtxWithConstraint
math::XYZVectorF momentumAtVtxWithConstraint
Definition: GsfElectron.h:270
edm::SortedCollection::end
const_iterator end() const
Definition: SortedCollection.h:267
reco::GsfElectron::TrackExtrapolations
Definition: GsfElectron.h:260
egamma::correctElectronMomentum
ElectronMomentum correctElectronMomentum(reco::GsfElectron const &, TrajectoryStateOnSurface const &)
Definition: ElectronMomentumCorrector.cc:22
reco::GsfElectron::ShowerShape::e2x5Left
float e2x5Left
Definition: GsfElectron.h:388
EgammaTowerIsolation
Definition: EgammaTowerIsolation.h:196
GsfElectronAlgo::Configuration::strategy
const StrategyConfiguration strategy
Definition: GsfElectronAlgo.h:200
ConversionInfo::dist
const double dist
Definition: ConversionInfo.h:9
reco::GsfElectron::hcalOverEcalBc
float hcalOverEcalBc() const
Definition: GsfElectron.h:433
reco::GsfElectron::TrackClusterMatching::deltaPhiEleClusterAtCalo
float deltaPhiEleClusterAtCalo
Definition: GsfElectron.h:211
reco::GsfElectron::ShowerShape::e2x5Top
float e2x5Top
Definition: GsfElectron.h:387
GsfElectronAlgo::IsolationConfiguration::etMinEndcaps
double etMinEndcaps
Definition: GsfElectronAlgo.h:168
reco::GsfElectron::setPixelMatchDPhi1
void setPixelMatchDPhi1(float dPhi1)
Definition: GsfElectron.h:854
reco::LeafCandidate::charge
int charge() const final
electric charge
Definition: LeafCandidate.h:106
GsfElectronAlgo::CutsConfiguration::seedFromTEC
bool seedFromTEC
Definition: GsfElectronAlgo.h:147
reco::GsfElectron::isEBEtaGap
bool isEBEtaGap() const
Definition: GsfElectron.h:341
DetId::Detector
Detector
Definition: DetId.h:24
ElectronHcalHelper::checkSetup
void checkSetup(const edm::EventSetup &)
Definition: ElectronHcalHelper.cc:14
EleRelPointPair
Definition: ElectronUtilities.h:43
DetId::Ecal
Definition: DetId.h:27
reco::GsfElectron::TrackExtrapolations::momentumAtEleClus
math::XYZVectorF momentumAtEleClus
Definition: GsfElectron.h:269
reco::GsfElectron::SaturationInfo::isSeedSaturated
bool isSeedSaturated
Definition: GsfElectron.h:492
egamma::classifyElectron
reco::GsfElectron::Classification classifyElectron(reco::GsfElectron const &)
GsfElectronAlgo::tkIsol04Calc_
const EleTkIsolFromCands tkIsol04Calc_
Definition: GsfElectronAlgo.h:241
reco::CaloCluster::seed
DetId seed() const
return DetId of seed
Definition: CaloCluster.h:219
GsfElectronAlgo::StrategyConfiguration::fillConvVtxFitProb
bool fillConvVtxFitProb
Definition: GsfElectronAlgo.h:93
reco::GsfElectron::hcalOverEcal
float hcalOverEcal() const
Definition: GsfElectron.h:427
RegressionHelper::checkSetup
void checkSetup(const edm::EventSetup &)
Definition: RegressionHelper.cc:33
reco::GsfElectron::TrackClusterMatching::deltaPhiSeedClusterAtCalo
float deltaPhiSeedClusterAtCalo
Definition: GsfElectron.h:213
EcalClusterToolsT
Definition: EcalClusterTools.h:73
reco::CaloCluster::position
const math::XYZPoint & position() const
cluster centroid position
Definition: CaloCluster.h:154
edm::Ptr< CaloCluster >
looper.cfg
cfg
Definition: looper.py:297
MultiTrajectoryStateTransform
Definition: MultiTrajectoryStateTransform.h:18
reco::GsfElectron::sigmaIetaIeta
float sigmaIetaIeta() const
Definition: GsfElectron.h:419
HLT_2018_cff.barrelRecHits
barrelRecHits
Definition: HLT_2018_cff.py:13541
EBDetId::isNextToPhiBoundary
static bool isNextToPhiBoundary(EBDetId id)
Definition: EBDetId.cc:113
SiStripSubdetector::UNKNOWN
Definition: SiStripEnums.h:5
reco::GsfElectron::ConversionRejection::partner
TrackBaseRef partner
Definition: GsfElectron.h:574
HLT_2018_cff.towers
towers
Definition: HLT_2018_cff.py:35030
edm::SortedCollection::find
iterator find(key_type k)
Definition: SortedCollection.h:240
GsfElectronAlgo::calculateSaturationInfo
reco::GsfElectron::SaturationInfo calculateSaturationInfo(const reco::SuperClusterRef &, EventData const &eventData) const
Definition: GsfElectronAlgo.cc:253
reco::GsfElectron::ShowerShape::eRight
float eRight
Definition: GsfElectron.h:385
reco::GsfElectron::ShowerShape::e2nd
float e2nd
Definition: GsfElectron.h:382
GsfElectronAlgo::Configuration::tokens
const Tokens tokens
Definition: GsfElectronAlgo.h:199
reco::GsfElectron::ShowerShape::invalidHcal
bool invalidHcal
Definition: GsfElectron.h:379
GsfElectronAlgo::cfg_
const Configuration cfg_
Definition: GsfElectronAlgo.h:238
reco::GsfElectron::ShowerShape::e1x5
float e1x5
Definition: GsfElectron.h:370
GsfElectronAlgo::StrategyConfiguration::PreSelectMVA
float PreSelectMVA
Definition: GsfElectronAlgo.h:86
reco::GsfElectron::setPassCutBasedPreselection
void setPassCutBasedPreselection(bool flag)
Definition: GsfElectron.h:695
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
reco::GsfElectron::ConversionRejection::dist
float dist
Definition: GsfElectron.h:575
reco::GsfElectron::TrackClusterMatching::deltaEtaSuperClusterAtVtx
float deltaEtaSuperClusterAtVtx
Definition: GsfElectron.h:208
GsfElectronAlgo::superClusterErrorFunction_
std::unique_ptr< EcalClusterFunctionBaseClass > superClusterErrorFunction_
Definition: GsfElectronAlgo.h:253
reco::GsfElectron::isEBEEGap
bool isEBEEGap() const
Definition: GsfElectron.h:339
packedPFCandidateRefMixer_cfi.pf
pf
Definition: packedPFCandidateRefMixer_cfi.py:4
reco::GsfElectron::ShowerShape::hcalDepth2OverEcalBc
float hcalDepth2OverEcalBc
Definition: GsfElectron.h:378
GsfElectronAlgo::IsolationConfiguration::jurassicWidth
double jurassicWidth
Definition: GsfElectronAlgo.h:165
EEDetId::isNextToDBoundary
static bool isNextToDBoundary(EEDetId id)
Definition: EEDetId.cc:279
GsfElectronAlgo::IsolationConfiguration::etMinBarrel
double etMinBarrel
Definition: GsfElectronAlgo.h:166
GsfElectronAlgo::IsolationConfiguration::intRadiusEcalEndcaps
double intRadiusEcalEndcaps
Definition: GsfElectronAlgo.h:164
GsfElectronAlgo::tkIsolHEEP04Calc_
const EleTkIsolFromCands tkIsolHEEP04Calc_
Definition: GsfElectronAlgo.h:243
Exception
Definition: hltDiff.cc:246
ConversionTools::matchedConversion
static const reco::Conversion * matchedConversion(const reco::GsfElectron &ele, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, bool allowCkfMatch=true, float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=0)
Definition: ConversionTools.cc:258
reco::GsfElectron::TrackExtrapolations::positionAtCalo
math::XYZPointF positionAtCalo
Definition: GsfElectron.h:262
ConversionInfo::flag
const int flag
Definition: ConversionInfo.h:20
reco::GsfElectron::ShowerShape::hcalDepth1OverEcalBc
float hcalDepth1OverEcalBc
Definition: GsfElectron.h:377
reco::GsfElectron::eSuperClusterOverP
float eSuperClusterOverP() const
Definition: GsfElectron.h:229
HLT_2018_cff.region
region
Definition: HLT_2018_cff.py:81479
GsfElectronAlgo::Tokens::vtxCollectionTag
edm::EDGetTokenT< reco::VertexCollection > vtxCollectionTag
Definition: GsfElectronAlgo.h:68
reco::GsfElectron::ConversionRejection::radius
float radius
Definition: GsfElectron.h:577
reco::GsfElectron::ConversionRejection::flags
int flags
Definition: GsfElectron.h:573
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
reco::GsfElectron::IsolationVariables::hcalDepth2TowerSumEt
float hcalDepth2TowerSumEt
Definition: GsfElectron.h:515
edm::RefToBase< TrajectorySeed >
reco::GsfElectron::isEBPhiGap
bool isEBPhiGap() const
Definition: GsfElectron.h:342
reco::GsfElectron::ShowerShape::eLeft
float eLeft
Definition: GsfElectron.h:384
reco::GsfElectron::superCluster
SuperClusterRef superCluster() const override
reference to a SuperCluster
Definition: GsfElectron.h:163
ConversionInfo::conversionPartnerCtfTk
const reco::TrackRef conversionPartnerCtfTk
Definition: ConversionInfo.h:15
egamma::classBasedElectronEnergyUncertainty
double classBasedElectronEnergyUncertainty(reco::GsfElectron const &)
Definition: ElectronEnergyCorrector.cc:270
hgcalTestNeighbor_cfi.detector
detector
Definition: hgcalTestNeighbor_cfi.py:6
GsfElectronAlgo::Tokens::ctfTracks
edm::EDGetTokenT< reco::TrackCollection > ctfTracks
Definition: GsfElectronAlgo.h:66
GsfElectronAlgo::StrategyConfiguration::useEcalRegression
bool useEcalRegression
Definition: GsfElectronAlgo.h:89
reco::GsfElectron::IsolationVariables::ecalRecHitSumEt
float ecalRecHitSumEt
Definition: GsfElectron.h:513
GsfElectronAlgo::Tokens::hcalTowersTag
edm::EDGetTokenT< CaloTowerCollection > hcalTowersTag
Definition: GsfElectronAlgo.h:60
GsfElectronAlgo::IsolationConfiguration::intRadiusHcal
double intRadiusHcal
Definition: GsfElectronAlgo.h:161
GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalEnergyFromClassBasedParameterization
bool ecalDrivenEcalEnergyFromClassBasedParameterization
Definition: GsfElectronAlgo.h:77
reco::GsfElectron::FiducialFlags::isEBEtaGap
bool isEBEtaGap
Definition: GsfElectron.h:321
reco::GsfElectron::FiducialFlags::isEB
bool isEB
Definition: GsfElectron.h:318
L1TMuonDQMOffline_cfi.cuts
cuts
Definition: L1TMuonDQMOffline_cfi.py:41
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
reco::GsfElectron::TrackExtrapolations::momentumAtVtx
math::XYZVectorF momentumAtVtx
Definition: GsfElectron.h:263
reco::Candidate::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Candidate.h:36
SiStripFineDelayHit_cfi.MagneticField
MagneticField
Definition: SiStripFineDelayHit_cfi.py:7
event
Definition: event.py:1
reco::GsfElectron::SaturationInfo
Definition: GsfElectron.h:490
GsfElectronAlgo::crackCorrectionFunction_
std::unique_ptr< EcalClusterFunctionBaseClass > crackCorrectionFunction_
Definition: GsfElectronAlgo.h:254
GsfElectronAlgo::Configuration::cuts
const CutsConfiguration cuts
Definition: GsfElectronAlgo.h:201
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of "!*" before the partial wildcard feature was incorporated). The per-event "cost" of each negative criterion with multiple relevant triggers is about the same as ! *was in the past
egamma::simpleElectronEnergyUncertainty
double simpleElectronEnergyUncertainty(reco::GsfElectron const &)
Definition: ElectronEnergyCorrector.cc:277
reco::CaloCluster::energy
double energy() const
cluster energy
Definition: CaloCluster.h:149
reco::GsfElectron::ShowerShape::e5x5
float e5x5
Definition: GsfElectron.h:372
GsfElectronAlgo::Configuration::recHits
const EcalRecHitsConfiguration recHits
Definition: GsfElectronAlgo.h:203
ElectronHcalHelper::readEvent
void readEvent(const edm::Event &)
Definition: ElectronHcalHelper.cc:31
reco::GsfElectron::ShowerShape::e2x5Bottom
float e2x5Bottom
Definition: GsfElectron.h:390
GsfElectronAlgo::caloGeometryToken_
const edm::ESGetToken< CaloGeometry, CaloGeometryRecord > caloGeometryToken_
Definition: GsfElectronAlgo.h:246
reco::GsfElectron::ConversionRejection::vtxFitProb
float vtxFitProb
Definition: GsfElectron.h:578
SurveyInfoScenario_cff.seed
seed
Definition: SurveyInfoScenario_cff.py:295
reco::GsfElectron::TrackClusterMatching::deltaEtaSeedClusterAtCalo
float deltaEtaSeedClusterAtCalo
Definition: GsfElectron.h:209
ConversionInfo::dcot
const double dcot
Definition: ConversionInfo.h:10
reco::GsfElectron::TrackExtrapolations::positionAtVtx
math::XYZPointF positionAtVtx
Definition: GsfElectron.h:261
egamma::getClosestCtfToGsf
std::pair< reco::TrackRef, float > getClosestCtfToGsf(reco::GsfTrackRef const &, edm::Handle< reco::TrackCollection > const &ctfTracksH)
Definition: GsfElectronTools.cc:17
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
TrackerGeometry
Definition: TrackerGeometry.h:14
GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedEndcaps
std::vector< int > recHitSeverityToBeExcludedEndcaps
Definition: GsfElectronAlgo.h:155
reco::GsfElectron::ShowerShape::hcalDepth2OverEcal
float hcalDepth2OverEcal
Definition: GsfElectron.h:375
Generated for CMSSW Reference Manual by doxygen 1.8.16