CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes
GsfElectronProducer Class Reference
Inheritance diagram for GsfElectronProducer:
edm::stream::EDProducer< edm::GlobalCache< GsfElectronAlgo::HeavyObjectCache > >

Public Member Functions

void beginRun (const edm::Run &, const edm::EventSetup &) override
 
void endStream () override
 
 GsfElectronProducer (const edm::ParameterSet &, const GsfElectronAlgo::HeavyObjectCache *)
 
void produce (edm::Event &event, const edm::EventSetup &setup) override
 
- Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< GsfElectronAlgo::HeavyObjectCache > >
 EDProducer ()=default
 
 EDProducer (const EDProducer &)=delete
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () const final
 
bool hasAbilityToProduceInEndRuns () const final
 
const EDProducer & operator= (const EDProducer &)=delete
 

Static Public Member Functions

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

Private Member Functions

void checkEcalSeedingParameters (edm::ParameterSet const &)
 
bool isPreselected (reco::GsfElectron const &ele) const
 
void setAmbiguityData (reco::GsfElectronCollection &electrons, edm::Event const &event, bool ignoreNotPreselected=true) const
 

Private Attributes

std::unique_ptr< GsfElectronAlgo > algo_
 
const GsfElectronAlgo::CutsConfiguration cutsCfg_
 
bool cutsFromDB
 
bool dnnPFidEnabled_
 
bool ecalSeedingParametersChecked_
 
edm::EDGetTokenT< reco::PFCandidateCollection > egmPFCandidateCollection_
 
const edm::EDPutTokenT< reco::GsfElectronCollection > electronPutToken_
 
float extetaboundary_
 
const edm::EDGetTokenT< reco::GsfPFRecTrackCollection > gsfPfRecTracksTag_
 
ElectronHcalHelper::Configuration hcalCfg_
 
ElectronHcalHelper::Configuration hcalCfgBc_
 
HcalPFCuts const * hcalCuts = nullptr
 
edm::ESGetToken< HcalPFCuts, HcalPFCutsRcd > hcalCutsToken_
 
bool hcalRun2EffDepth_
 
GsfElectronAlgo::Tokens inputCfg_
 
const bool resetMvaValuesUsingPFCandidates_
 
GsfElectronAlgo::StrategyConfiguration strategyCfg_
 
std::vector< tensorflow::Session * > tfSessions_
 
const bool useGsfPfRecTracks_
 

Additional Inherited Members

- Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< GsfElectronAlgo::HeavyObjectCache > >
using CacheTypes = CacheContexts< T... >
 
using GlobalCache = typename CacheTypes::GlobalCache
 
using HasAbility = AbilityChecker< T... >
 
using InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
 
using LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
 
using LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
 
using LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
 
using RunCache = typename CacheTypes::RunCache
 
using RunContext = RunContextT< RunCache, GlobalCache >
 
using RunSummaryCache = typename CacheTypes::RunSummaryCache
 

Detailed Description

Definition at line 120 of file GsfElectronProducer.cc.

Constructor & Destructor Documentation

◆ GsfElectronProducer()

GsfElectronProducer::GsfElectronProducer ( const edm::ParameterSet &  cfg,
const GsfElectronAlgo::HeavyObjectCache *  gcache 
)
explicit

Definition at line 415 of file GsfElectronProducer.cc.

References looper::cfg.

416  : cutsCfg_{makeCutsConfiguration(cfg.getParameter<edm::ParameterSet>("preselection"))},
417  ecalSeedingParametersChecked_(false),
418  electronPutToken_(produces<GsfElectronCollection>()),
419  gsfPfRecTracksTag_(consumes(cfg.getParameter<edm::InputTag>("gsfPfRecTracksTag"))),
420  useGsfPfRecTracks_(cfg.getParameter<bool>("useGsfPfRecTracks")),
421  resetMvaValuesUsingPFCandidates_(cfg.getParameter<bool>("resetMvaValuesUsingPFCandidates")) {
422  if (resetMvaValuesUsingPFCandidates_) {
423  egmPFCandidateCollection_ = consumes(cfg.getParameter<edm::InputTag>("egmPFCandidatesTag"));
424  }
425 
426  //Retrieve HCAL PF thresholds - from config or from DB
427  cutsFromDB = cfg.getParameter<bool>("usePFThresholdsFromDB");
428  if (cutsFromDB) {
429  hcalCutsToken_ = esConsumes<HcalPFCuts, HcalPFCutsRcd, edm::Transition::BeginRun>(edm::ESInputTag("", "withTopo"));
430  }
431 
432  inputCfg_.gsfElectronCores = consumes(cfg.getParameter<edm::InputTag>("gsfElectronCoresTag"));
433  inputCfg_.hbheRecHitsTag = consumes(cfg.getParameter<edm::InputTag>("hbheRecHits"));
434  inputCfg_.barrelRecHitCollection = consumes(cfg.getParameter<edm::InputTag>("barrelRecHitCollectionTag"));
435  inputCfg_.endcapRecHitCollection = consumes(cfg.getParameter<edm::InputTag>("endcapRecHitCollectionTag"));
436  inputCfg_.ctfTracks = consumes(cfg.getParameter<edm::InputTag>("ctfTracksTag"));
437  // used to check config consistency with seeding
438  inputCfg_.seedsTag = consumes(cfg.getParameter<edm::InputTag>("seedsTag"));
439  inputCfg_.beamSpotTag = consumes(cfg.getParameter<edm::InputTag>("beamSpotTag"));
440  inputCfg_.vtxCollectionTag = consumes(cfg.getParameter<edm::InputTag>("vtxTag"));
441  if (cfg.getParameter<bool>("fillConvVtxFitProb"))
442  inputCfg_.conversions = consumes(cfg.getParameter<edm::InputTag>("conversionsTag"));
443 
444  // inputs for PFCluster isolation
445  const edm::ParameterSet& pfECALClusIsolCfg = cfg.getParameter<edm::ParameterSet>("pfECALClusIsolCfg");
446  const edm::ParameterSet& pfHCALClusIsolCfg = cfg.getParameter<edm::ParameterSet>("pfHCALClusIsolCfg");
447  inputCfg_.pfClusterProducer =
448  consumes<reco::PFClusterCollection>(pfECALClusIsolCfg.getParameter<edm::InputTag>("pfClusterProducer"));
449  inputCfg_.pfClusterProducerHCAL = consumes(pfHCALClusIsolCfg.getParameter<edm::InputTag>("pfClusterProducerHCAL"));
450  inputCfg_.pfClusterProducerHFEM = consumes(pfHCALClusIsolCfg.getParameter<edm::InputTag>("pfClusterProducerHFEM"));
451  inputCfg_.pfClusterProducerHFHAD = consumes(pfHCALClusIsolCfg.getParameter<edm::InputTag>("pfClusterProducerHFHAD"));
452 
453  // Config for PFID dnn
454  const auto& pset_dnn = cfg.getParameter<edm::ParameterSet>("EleDNNPFid");
455  dnnPFidEnabled_ = pset_dnn.getParameter<bool>("enabled");
456  extetaboundary_ = pset_dnn.getParameter<double>("extetaboundary");
457 
458  strategyCfg_.useDefaultEnergyCorrection = cfg.getParameter<bool>("useDefaultEnergyCorrection");
459 
460  strategyCfg_.applyPreselection = cfg.getParameter<bool>("applyPreselection");
461  strategyCfg_.ecalDrivenEcalEnergyFromClassBasedParameterization =
462  cfg.getParameter<bool>("ecalDrivenEcalEnergyFromClassBasedParameterization");
463  strategyCfg_.ecalDrivenEcalErrorFromClassBasedParameterization =
464  cfg.getParameter<bool>("ecalDrivenEcalErrorFromClassBasedParameterization");
465  strategyCfg_.pureTrackerDrivenEcalErrorFromSimpleParameterization =
466  cfg.getParameter<bool>("pureTrackerDrivenEcalErrorFromSimpleParameterization");
467  strategyCfg_.applyAmbResolution = cfg.getParameter<bool>("applyAmbResolution");
468  strategyCfg_.ignoreNotPreselected = cfg.getParameter<bool>("ignoreNotPreselected");
469  strategyCfg_.ambSortingStrategy = cfg.getParameter<unsigned>("ambSortingStrategy");
470  strategyCfg_.ambClustersOverlapStrategy = cfg.getParameter<unsigned>("ambClustersOverlapStrategy");
471  strategyCfg_.ctfTracksCheck = cfg.getParameter<bool>("ctfTracksCheck");
472  strategyCfg_.PreSelectMVA = cfg.getParameter<double>("PreSelectMVA");
473  strategyCfg_.MaxElePtForOnlyMVA = cfg.getParameter<double>("MaxElePtForOnlyMVA");
474  strategyCfg_.useEcalRegression = cfg.getParameter<bool>("useEcalRegression");
475  strategyCfg_.useCombinationRegression = cfg.getParameter<bool>("useCombinationRegression");
476  strategyCfg_.fillConvVtxFitProb = cfg.getParameter<bool>("fillConvVtxFitProb");
477  strategyCfg_.computePfClusterIso = dnnPFidEnabled_;
478 
479  // hcal helpers
480  auto const& psetPreselection = cfg.getParameter<edm::ParameterSet>("preselection");
481  hcalCfg_.hOverEConeSize = psetPreselection.getParameter<double>("hOverEConeSize");
482  if (hcalCfg_.hOverEConeSize > 0) {
483  hcalCfg_.onlyBehindCluster = false;
484  hcalCfg_.checkHcalStatus = cfg.getParameter<bool>("checkHcalStatus");
485 
486  //hcalCfg_.hbheRecHits = consumes<HBHERecHitCollection>(cfg.getParameter<edm::InputTag>("hbheRecHits"));
487  hcalCfg_.hbheRecHits = consumes<HBHERecHitCollection>(cfg.getParameter<edm::InputTag>("hbheRecHits"));
488 
489  hcalCfg_.eThresHB = cfg.getParameter<EgammaHcalIsolation::arrayHB>("recHitEThresholdHB");
490  hcalCfg_.maxSeverityHB = cfg.getParameter<int>("maxHcalRecHitSeverity");
491  hcalCfg_.eThresHE = cfg.getParameter<EgammaHcalIsolation::arrayHE>("recHitEThresholdHE");
492  hcalCfg_.maxSeverityHE = hcalCfg_.maxSeverityHB;
493  }
494 
495  hcalCfgBc_.hOverEConeSize = 0.;
496  hcalCfgBc_.onlyBehindCluster = true;
497  hcalCfgBc_.checkHcalStatus = cfg.getParameter<bool>("checkHcalStatus");
498 
499  //hcalCfgBc_.hbheRecHits = consumes<HBHERecHitCollection>(cfg.getParameter<edm::InputTag>("hbheRecHits"));
500  hcalCfgBc_.hbheRecHits = consumes<HBHERecHitCollection>(cfg.getParameter<edm::InputTag>("hbheRecHits"));
501 
502  hcalCfgBc_.eThresHB = cfg.getParameter<EgammaHcalIsolation::arrayHB>("recHitEThresholdHB");
503  hcalCfgBc_.maxSeverityHB = cfg.getParameter<int>("maxHcalRecHitSeverity");
504  hcalCfgBc_.eThresHE = cfg.getParameter<EgammaHcalIsolation::arrayHE>("recHitEThresholdHE");
505  hcalCfgBc_.maxSeverityHE = hcalCfgBc_.maxSeverityHB;
506 
507  hcalRun2EffDepth_ = cfg.getParameter<bool>("hcalRun2EffDepth");
508 
509  // Ecal rec hits configuration
510  GsfElectronAlgo::EcalRecHitsConfiguration recHitsCfg;
511  auto const& flagnamesbarrel = cfg.getParameter<std::vector<std::string>>("recHitFlagsToBeExcludedBarrel");
512  recHitsCfg.recHitFlagsToBeExcludedBarrel = StringToEnumValue<EcalRecHit::Flags>(flagnamesbarrel);
513  auto const& flagnamesendcaps = cfg.getParameter<std::vector<std::string>>("recHitFlagsToBeExcludedEndcaps");
514  recHitsCfg.recHitFlagsToBeExcludedEndcaps = StringToEnumValue<EcalRecHit::Flags>(flagnamesendcaps);
515  auto const& severitynamesbarrel = cfg.getParameter<std::vector<std::string>>("recHitSeverityToBeExcludedBarrel");
516  recHitsCfg.recHitSeverityToBeExcludedBarrel =
517  StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesbarrel);
518  auto const& severitynamesendcaps = cfg.getParameter<std::vector<std::string>>("recHitSeverityToBeExcludedEndcaps");
519  recHitsCfg.recHitSeverityToBeExcludedEndcaps =
520  StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesendcaps);
521 
522  // isolation
523  const GsfElectronAlgo::IsolationConfiguration isoCfg{
524  .intRadiusHcal = cfg.getParameter<double>("intRadiusHcal"),
525  .etMinHcal = cfg.getParameter<double>("etMinHcal"),
526  .intRadiusEcalBarrel = cfg.getParameter<double>("intRadiusEcalBarrel"),
527  .intRadiusEcalEndcaps = cfg.getParameter<double>("intRadiusEcalEndcaps"),
528  .jurassicWidth = cfg.getParameter<double>("jurassicWidth"),
529  .etMinBarrel = cfg.getParameter<double>("etMinBarrel"),
530  .eMinBarrel = cfg.getParameter<double>("eMinBarrel"),
531  .etMinEndcaps = cfg.getParameter<double>("etMinEndcaps"),
532  .eMinEndcaps = cfg.getParameter<double>("eMinEndcaps"),
533  .vetoClustered = cfg.getParameter<bool>("vetoClustered"),
534  .useNumCrystals = cfg.getParameter<bool>("useNumCrystals")};
535 
536  // isolation
537  const GsfElectronAlgo::PFClusterIsolationConfiguration pfisoCfg{
538  .ecaldrMax = pfECALClusIsolCfg.getParameter<double>("drMax"),
539  .ecaldrVetoBarrel = pfECALClusIsolCfg.getParameter<double>("drVetoBarrel"),
540  .ecaldrVetoEndcap = pfECALClusIsolCfg.getParameter<double>("drVetoEndcap"),
541  .ecaletaStripBarrel = pfECALClusIsolCfg.getParameter<double>("etaStripBarrel"),
542  .ecaletaStripEndcap = pfECALClusIsolCfg.getParameter<double>("etaStripEndcap"),
543  .ecalenergyBarrel = pfECALClusIsolCfg.getParameter<double>("energyBarrel"),
544  .ecalenergyEndcap = pfECALClusIsolCfg.getParameter<double>("energyEndcap"),
545  .useHF = pfHCALClusIsolCfg.getParameter<bool>("useHF"),
546  .hcaldrMax = pfHCALClusIsolCfg.getParameter<double>("drMax"),
547  .hcaldrVetoBarrel = pfHCALClusIsolCfg.getParameter<double>("drVetoBarrel"),
548  .hcaldrVetoEndcap = pfHCALClusIsolCfg.getParameter<double>("drVetoEndcap"),
549  .hcaletaStripBarrel = pfHCALClusIsolCfg.getParameter<double>("etaStripBarrel"),
550  .hcaletaStripEndcap = pfHCALClusIsolCfg.getParameter<double>("etaStripEndcap"),
551  .hcalenergyBarrel = pfHCALClusIsolCfg.getParameter<double>("energyBarrel"),
552  .hcalenergyEndcap = pfHCALClusIsolCfg.getParameter<double>("energyEndcap"),
553  .hcaluseEt = pfHCALClusIsolCfg.getParameter<bool>("useEt")};
554 
555  const RegressionHelper::Configuration regressionCfg{
556  .ecalRegressionWeightLabels = cfg.getParameter<std::vector<std::string>>("ecalRefinedRegressionWeightLabels"),
557  .ecalWeightsFromDB = cfg.getParameter<bool>("ecalWeightsFromDB"),
558  .ecalRegressionWeightFiles = cfg.getParameter<std::vector<std::string>>("ecalRefinedRegressionWeightFiles"),
559  .combinationRegressionWeightLabels =
560  cfg.getParameter<std::vector<std::string>>("combinationRegressionWeightLabels"),
561  .combinationWeightsFromDB = cfg.getParameter<bool>("combinationWeightsFromDB"),
562  .combinationRegressionWeightFiles =
563  cfg.getParameter<std::vector<std::string>>("combinationRegressionWeightFile")};
564 
565  // create algo
566  algo_ = std::make_unique<GsfElectronAlgo>(
567  inputCfg_,
568  strategyCfg_,
569  cutsCfg_,
570  hcalCfg_,
571  hcalCfgBc_,
572  isoCfg,
573  pfisoCfg,
574  recHitsCfg,
575  EcalClusterFunctionFactory::get()->create(
576  cfg.getParameter<std::string>("crackCorrectionFunction"), cfg, consumesCollector()),
577  regressionCfg,
578  cfg.getParameter<edm::ParameterSet>("trkIsol03Cfg"),
579  cfg.getParameter<edm::ParameterSet>("trkIsol04Cfg"),
580  cfg.getParameter<edm::ParameterSet>("trkIsolHEEP03Cfg"),
581  cfg.getParameter<edm::ParameterSet>("trkIsolHEEP04Cfg"),
582  consumesCollector());
583 
584  if (dnnPFidEnabled_) {
585  tfSessions_ = gcache->iElectronDNNEstimator->getSessions();
586  }
587 }
GsfElectronAlgo::Tokens::hbheRecHitsTag
edm::EDGetTokenT< HBHERecHitCollection > hbheRecHitsTag
Definition: GsfElectronAlgo.h:66
GsfElectronProducer::gsfPfRecTracksTag_
const edm::EDGetTokenT< reco::GsfPFRecTrackCollection > gsfPfRecTracksTag_
Definition: GsfElectronProducer.cc:159
GsfElectronProducer::inputCfg_
GsfElectronAlgo::Tokens inputCfg_
Definition: GsfElectronProducer.cc:142
GsfElectronAlgo::Tokens::conversions
edm::EDGetTokenT< reco::ConversionCollection > conversions
Definition: GsfElectronAlgo.h:75
GsfElectronProducer::egmPFCandidateCollection_
edm::EDGetTokenT< reco::PFCandidateCollection > egmPFCandidateCollection_
Definition: GsfElectronProducer.cc:160
RegressionHelper::Configuration::ecalRegressionWeightLabels
std::vector< std::string > ecalRegressionWeightLabels
Definition: RegressionHelper.h:29
gsfElectronProducer_cfi.pfHCALClusIsolCfg
pfHCALClusIsolCfg
Definition: gsfElectronProducer_cfi.py:27
GsfElectronAlgo::Tokens::pfClusterProducerHFEM
edm::EDGetTokenT< reco::PFClusterCollection > pfClusterProducerHFEM
Definition: GsfElectronAlgo.h:79
GsfElectronProducer::resetMvaValuesUsingPFCandidates_
const bool resetMvaValuesUsingPFCandidates_
Definition: GsfElectronProducer.cc:164
GsfElectronAlgo::Tokens::pfClusterProducerHCAL
edm::EDGetTokenT< reco::PFClusterCollection > pfClusterProducerHCAL
Definition: GsfElectronAlgo.h:78
GsfElectronAlgo::Tokens::vtxCollectionTag
edm::EDGetTokenT< reco::VertexCollection > vtxCollectionTag
Definition: GsfElectronAlgo.h:74
GsfElectronAlgo::Tokens::endcapRecHitCollection
edm::EDGetTokenT< EcalRecHitCollection > endcapRecHitCollection
Definition: GsfElectronAlgo.h:70
GsfElectronAlgo::Tokens::pfClusterProducerHFHAD
edm::EDGetTokenT< reco::PFClusterCollection > pfClusterProducerHFHAD
Definition: GsfElectronAlgo.h:80
ElectronHcalHelper::Configuration::hbheRecHits
edm::EDGetTokenT< HBHERecHitCollection > hbheRecHits
Definition: ElectronHcalHelper.h:35
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
GsfElectronProducer::hcalCutsToken_
edm::ESGetToken< HcalPFCuts, HcalPFCutsRcd > hcalCutsToken_
Definition: GsfElectronProducer.cc:171
GsfElectronProducer::hcalCfg_
ElectronHcalHelper::Configuration hcalCfg_
Definition: GsfElectronProducer.cc:145
GsfElectronAlgo::Tokens::gsfElectronCores
edm::EDGetTokenT< reco::GsfElectronCoreCollection > gsfElectronCores
Definition: GsfElectronAlgo.h:65
electronEcalRecHitIsolationLcone_cfi.etMinBarrel
etMinBarrel
Definition: electronEcalRecHitIsolationLcone_cfi.py:17
electronEcalRecHitIsolationLcone_cfi.vetoClustered
vetoClustered
Definition: electronEcalRecHitIsolationLcone_cfi.py:25
GsfElectronProducer::electronPutToken_
const edm::EDPutTokenT< reco::GsfElectronCollection > electronPutToken_
Definition: GsfElectronProducer.cc:158
gedGsfElectrons_cfi.combinationRegressionWeightLabels
combinationRegressionWeightLabels
Definition: gedGsfElectrons_cfi.py:21
gsfElectronProducer_cfi.pfECALClusIsolCfg
pfECALClusIsolCfg
Definition: gsfElectronProducer_cfi.py:16
GsfElectronAlgo::Tokens::beamSpotTag
edm::EDGetTokenT< reco::BeamSpot > beamSpotTag
Definition: GsfElectronAlgo.h:73
GsfElectronProducer::tfSessions_
std::vector< tensorflow::Session * > tfSessions_
Definition: GsfElectronProducer.cc:169
GsfElectronAlgo::Tokens::ctfTracks
edm::EDGetTokenT< reco::TrackCollection > ctfTracks
Definition: GsfElectronAlgo.h:72
GsfElectronAlgo::Tokens::seedsTag
edm::EDGetTokenT< reco::ElectronSeedCollection > seedsTag
Definition: GsfElectronAlgo.h:71
GsfElectronAlgo::HeavyObjectCache::iElectronDNNEstimator
std::unique_ptr< const ElectronDNNEstimator > iElectronDNNEstimator
Definition: GsfElectronAlgo.h:61
GsfElectronAlgo::Tokens::pfClusterProducer
edm::EDGetTokenT< reco::PFClusterCollection > pfClusterProducer
Definition: GsfElectronAlgo.h:77
GsfElectronProducer::cutsCfg_
const GsfElectronAlgo::CutsConfiguration cutsCfg_
Definition: GsfElectronProducer.cc:144
GsfElectronAlgo::Tokens::barrelRecHitCollection
edm::EDGetTokenT< EcalRecHitCollection > barrelRecHitCollection
Definition: GsfElectronAlgo.h:69
ElectronHcalHelper::Configuration::eThresHB
EgammaHcalIsolation::arrayHB eThresHB
Definition: ElectronHcalHelper.h:37
GsfElectronProducer::algo_
std::unique_ptr< GsfElectronAlgo > algo_
Definition: GsfElectronProducer.cc:139
GsfElectronProducer::hcalCfgBc_
ElectronHcalHelper::Configuration hcalCfgBc_
Definition: GsfElectronProducer.cc:145
ElectronHcalHelper::Configuration::eThresHE
EgammaHcalIsolation::arrayHE eThresHE
Definition: ElectronHcalHelper.h:39
get
#define get
EgammaHcalIsolation::arrayHB
std::array< double, 4 > arrayHB
Definition: EgammaHcalIsolation.h:43
GsfElectronProducer::strategyCfg_
GsfElectronAlgo::StrategyConfiguration strategyCfg_
Definition: GsfElectronProducer.cc:143
HLT_2023v12_cff.useHF
useHF
Definition: HLT_2023v12_cff.py:16231
EgammaHcalIsolation::arrayHE
std::array< double, 7 > arrayHE
Definition: EgammaHcalIsolation.h:44

Member Function Documentation

◆ beginRun()

void GsfElectronProducer::beginRun ( const edm::Run &  run,
const edm::EventSetup &  setup 
)
override

Definition at line 409 of file GsfElectronProducer.cc.

References singleTopDQM_cfi::setup.

409  {
410  if (cutsFromDB) {
411  hcalCuts = &setup.getData(hcalCutsToken_);
412  }
413 }
GsfElectronProducer::hcalCuts
HcalPFCuts const * hcalCuts
Definition: GsfElectronProducer.cc:173
GsfElectronProducer::hcalCutsToken_
edm::ESGetToken< HcalPFCuts, HcalPFCutsRcd > hcalCutsToken_
Definition: GsfElectronProducer.cc:171
singleTopDQM_cfi.setup
setup
SETUP
Definition: singleTopDQM_cfi.py:37

◆ checkEcalSeedingParameters()

void GsfElectronProducer::checkEcalSeedingParameters ( edm::ParameterSet const &  pset)
private

Definition at line 595 of file GsfElectronProducer.cc.

References cutsCfg_, edm::ParameterSet::getParameter(), hcalCfg_, ElectronHcalHelper::Configuration::hOverEConeSize, GsfElectronAlgo::CutsConfiguration::maxHOverEBarrelCone, GsfElectronAlgo::CutsConfiguration::maxHOverEEndcapsCone, GsfElectronAlgo::CutsConfiguration::minSCEtBarrel, GsfElectronAlgo::CutsConfiguration::minSCEtEndcaps, and muonDTDigis_cfi::pset.

Referenced by produce().

595  {
596  if (!pset.exists("SeedConfiguration")) {
597  return;
598  }
599  edm::ParameterSet seedConfiguration = pset.getParameter<edm::ParameterSet>("SeedConfiguration");
600 
601  if (seedConfiguration.getParameter<bool>("applyHOverECut")) {
602  if ((hcalCfg_.hOverEConeSize != 0) &&
603  (hcalCfg_.hOverEConeSize != seedConfiguration.getParameter<double>("hOverEConeSize"))) {
604  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
605  << "The H/E cone size (" << hcalCfg_.hOverEConeSize << ") is different from ecal seeding ("
606  << seedConfiguration.getParameter<double>("hOverEConeSize") << ").";
607  }
608  if (cutsCfg_.maxHOverEBarrelCone < seedConfiguration.getParameter<double>("maxHOverEBarrel")) {
609  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
610  << "The max barrel cone H/E is lower than during ecal seeding.";
611  }
612  if (cutsCfg_.maxHOverEEndcapsCone < seedConfiguration.getParameter<double>("maxHOverEEndcaps")) {
613  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
614  << "The max endcaps cone H/E is lower than during ecal seeding.";
615  }
616  }
617 
618  if (cutsCfg_.minSCEtBarrel < seedConfiguration.getParameter<double>("SCEtCut")) {
619  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
620  << "The minimum super-cluster Et in barrel is lower than during ecal seeding.";
621  }
622  if (cutsCfg_.minSCEtEndcaps < seedConfiguration.getParameter<double>("SCEtCut")) {
623  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
624  << "The minimum super-cluster Et in endcaps is lower than during ecal seeding.";
625  }
626 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:307
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
GsfElectronProducer::hcalCfg_
ElectronHcalHelper::Configuration hcalCfg_
Definition: GsfElectronProducer.cc:145
GsfElectronProducer::cutsCfg_
const GsfElectronAlgo::CutsConfiguration cutsCfg_
Definition: GsfElectronProducer.cc:144
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:128

◆ endStream()

void GsfElectronProducer::endStream ( )
override

Definition at line 589 of file GsfElectronProducer.cc.

References tensorflow::closeSession(), and tfSessions_.

589  {
590  for (auto session : tfSessions_) {
591  tensorflow::closeSession(session);
592  }
593 }
tensorflow::closeSession
bool closeSession(Session *&session)
Definition: TensorFlow.cc:234
GsfElectronProducer::tfSessions_
std::vector< tensorflow::Session * > tfSessions_
Definition: GsfElectronProducer.cc:169

◆ fillDescriptions()

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

For PF cluster isolations ECAL
HCAL

Definition at line 176 of file GsfElectronProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, EgammaLocalCovParamDefaults::kMultThresEB, EgammaLocalCovParamDefaults::kMultThresEE, EleTkIsolFromCands::pSetDescript(), and AlCaHLTBitMon_QueryRunRegistry::string.

176  {
177  edm::ParameterSetDescription desc;
178  // input collections
179  desc.add<edm::InputTag>("gsfElectronCoresTag", {"ecalDrivenGsfElectronCores"});
180  desc.add<edm::InputTag>("vtxTag", {"offlinePrimaryVertices"});
181  desc.add<edm::InputTag>("conversionsTag", {"allConversions"});
182  desc.add<edm::InputTag>("gsfPfRecTracksTag", {"pfTrackElec"});
183  desc.add<edm::InputTag>("barrelRecHitCollectionTag", {"ecalRecHit", "EcalRecHitsEB"});
184  desc.add<edm::InputTag>("endcapRecHitCollectionTag", {"ecalRecHit", "EcalRecHitsEE"});
185  desc.add<edm::InputTag>("seedsTag", {"ecalDrivenElectronSeeds"});
186  desc.add<edm::InputTag>("beamSpotTag", {"offlineBeamSpot"});
187  desc.add<edm::InputTag>("egmPFCandidatesTag", {"particleFlowEGamma"});
188 
189  // steering
190  desc.add<bool>("useDefaultEnergyCorrection", true);
191  desc.add<bool>("useCombinationRegression", false);
192  desc.add<bool>("ecalDrivenEcalEnergyFromClassBasedParameterization", true);
193  desc.add<bool>("ecalDrivenEcalErrorFromClassBasedParameterization", true);
194  desc.add<bool>("applyPreselection", false);
195  desc.add<bool>("useEcalRegression", false);
196  desc.add<bool>("applyAmbResolution", false);
197  desc.add<bool>("ignoreNotPreselected", true);
198  desc.add<bool>("useGsfPfRecTracks", true);
199  desc.add<bool>("pureTrackerDrivenEcalErrorFromSimpleParameterization", true);
200  desc.add<unsigned int>("ambSortingStrategy", 1);
201  desc.add<unsigned int>("ambClustersOverlapStrategy", 1);
202  desc.add<bool>("fillConvVtxFitProb", true);
203  desc.add<bool>("resetMvaValuesUsingPFCandidates", false);
204 
205  // Ecal rec hits configuration
206  desc.add<std::vector<std::string>>("recHitFlagsToBeExcludedBarrel");
207  desc.add<std::vector<std::string>>("recHitFlagsToBeExcludedEndcaps");
208  desc.add<std::vector<std::string>>("recHitSeverityToBeExcludedBarrel");
209  desc.add<std::vector<std::string>>("recHitSeverityToBeExcludedEndcaps");
210 
211  // Hcal rec hits configuration
212  desc.add<bool>("checkHcalStatus", true);
213  desc.add<edm::InputTag>("hbheRecHits", edm::InputTag("hbhereco"));
214  desc.add<std::vector<double>>("recHitEThresholdHB", {0., 0., 0., 0.});
215  desc.add<std::vector<double>>("recHitEThresholdHE", {0., 0., 0., 0., 0., 0., 0.});
216  desc.add<int>("maxHcalRecHitSeverity", 999999);
217  desc.add<bool>("hcalRun2EffDepth", false);
218  desc.add<bool>("usePFThresholdsFromDB", false);
219 
220  // Isolation algos configuration
221  desc.add("trkIsol03Cfg", EleTkIsolFromCands::pSetDescript());
222  desc.add("trkIsol04Cfg", EleTkIsolFromCands::pSetDescript());
223  desc.add("trkIsolHEEP03Cfg", EleTkIsolFromCands::pSetDescript());
224  desc.add("trkIsolHEEP04Cfg", EleTkIsolFromCands::pSetDescript());
225  desc.add<bool>("useNumCrystals", true);
226  desc.add<double>("etMinBarrel", 0.0);
227  desc.add<double>("etMinEndcaps", 0.11);
228  desc.add<double>("etMinHcal", 0.0);
229  desc.add<double>("eMinBarrel", 0.095);
230  desc.add<double>("eMinEndcaps", 0.0);
231  desc.add<double>("intRadiusEcalBarrel", 3.0);
232  desc.add<double>("intRadiusEcalEndcaps", 3.0);
233  desc.add<double>("intRadiusHcal", 0.15);
234  desc.add<double>("jurassicWidth", 1.5);
235  desc.add<bool>("vetoClustered", false);
236 
237  // backward compatibility mechanism for ctf tracks
238  desc.add<bool>("ctfTracksCheck", true);
239  desc.add<edm::InputTag>("ctfTracksTag", {"generalTracks"});
240 
241  desc.add<double>("MaxElePtForOnlyMVA", 50.0);
242  desc.add<double>("PreSelectMVA", -0.1);
243 
244  {
245  edm::ParameterSetDescription psd0;
246  psd0.add<double>("minSCEtBarrel", 4.0);
247  psd0.add<double>("minSCEtEndcaps", 4.0);
248  psd0.add<double>("minEOverPBarrel", 0.0);
249  psd0.add<double>("minEOverPEndcaps", 0.0);
250  psd0.add<double>("maxEOverPBarrel", 999999999.0);
251  psd0.add<double>("maxEOverPEndcaps", 999999999.0);
252  psd0.add<double>("maxDeltaEtaBarrel", 0.02);
253  psd0.add<double>("maxDeltaEtaEndcaps", 0.02);
254  psd0.add<double>("maxDeltaPhiBarrel", 0.15);
255  psd0.add<double>("maxDeltaPhiEndcaps", 0.15);
256  psd0.add<double>("hOverEConeSize", 0.15);
257  psd0.add<double>("maxHOverEBarrelCone", 0.15);
258  psd0.add<double>("maxHOverEEndcapsCone", 0.15);
259  psd0.add<double>("maxHBarrelCone", 0.0);
260  psd0.add<double>("maxHEndcapsCone", 0.0);
261  psd0.add<double>("maxHOverEBarrelBc", 0.15);
262  psd0.add<double>("maxHOverEEndcapsBc", 0.15);
263  psd0.add<double>("maxHBarrelBc", 0.0);
264  psd0.add<double>("maxHEndcapsBc", 0.0);
265  psd0.add<double>("maxSigmaIetaIetaBarrel", 999999999.0);
266  psd0.add<double>("maxSigmaIetaIetaEndcaps", 999999999.0);
267  psd0.add<double>("maxFbremBarrel", 999999999.0);
268  psd0.add<double>("maxFbremEndcaps", 999999999.0);
269  psd0.add<bool>("isBarrel", false);
270  psd0.add<bool>("isEndcaps", false);
271  psd0.add<bool>("isFiducial", false);
272  psd0.add<bool>("seedFromTEC", true);
273  psd0.add<double>("maxTIP", 999999999.0);
274  psd0.add<double>("multThresEB", EgammaLocalCovParamDefaults::kMultThresEB);
275  psd0.add<double>("multThresEE", EgammaLocalCovParamDefaults::kMultThresEE);
276  // preselection parameters
277  desc.add<edm::ParameterSetDescription>("preselection", psd0);
278  }
279 
280  // Corrections
281  desc.add<std::string>("crackCorrectionFunction", "EcalClusterCrackCorrection");
282 
283  desc.add<bool>("ecalWeightsFromDB", true);
284  desc.add<std::vector<std::string>>("ecalRefinedRegressionWeightFiles", {})
285  ->setComment("if not from DB. Otherwise, keep empty");
286  desc.add<bool>("combinationWeightsFromDB", true);
287  desc.add<std::vector<std::string>>("combinationRegressionWeightFile", {})
288  ->setComment("if not from DB. Otherwise, keep empty");
289 
290  // regression. The labels are needed in all cases.
291  desc.add<std::vector<std::string>>("ecalRefinedRegressionWeightLabels", {});
292  desc.add<std::vector<std::string>>("combinationRegressionWeightLabels", {});
293 
294  desc.add<std::vector<std::string>>(
295  "ElecMVAFilesString",
296  {
297  "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_10_17Feb2011.weights.xml",
298  "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_12_17Feb2011.weights.xml",
299  "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_20_17Feb2011.weights.xml",
300  "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_22_17Feb2011.weights.xml",
301  });
302  desc.add<std::vector<std::string>>(
303  "SoftElecMVAFilesString",
304  {
305  "RecoEgamma/ElectronIdentification/data/TMVA_BDTSoftElectrons_7Feb2014.weights.xml",
306  });
307 
308  {
309  edm::ParameterSetDescription psd1;
310  psd1.add<bool>("enabled", false);
311  psd1.add<double>("extetaboundary", 2.65);
312  psd1.add<std::string>("inputTensorName", "FirstLayer_input");
313  psd1.add<std::string>("outputTensorName", "sequential/FinalLayer/Softmax");
314 
315  psd1.add<std::vector<std::string>>(
316  "modelsFiles",
317  {"RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/lowpT/lowpT_modelDNN.pb",
318  "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/highpTEB/highpTEB_modelDNN.pb",
319  "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/highpTEE/highpTEE_modelDNN.pb",
320  "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta1/modelDNN.pb",
321  "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta2/modelDNN.pb"});
322  psd1.add<std::vector<std::string>>(
323  "scalersFiles",
324  {"RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/lowpT/lowpT_scaler.txt",
325  "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/highpTEB/highpTEB_scaler.txt",
326  "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Summer21_120X/highpTEE/highpTEE_scaler.txt",
327  "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta1/scaler.txt",
328  "RecoEgamma/ElectronIdentification/data/Ele_PFID_dnn/Run3Winter22_122X/exteta2/scaler.txt"});
329  psd1.add<std::vector<unsigned int>>("outputDim", //Number of output nodes for the above models
330  {5, 5, 5, 5, 3});
331 
332  psd1.add<bool>("useEBModelInGap", true);
333  // preselection parameters
334  desc.add<edm::ParameterSetDescription>("EleDNNPFid", psd1);
335  }
336 
339  {
340  edm::ParameterSetDescription psd0;
341  psd0.add<edm::InputTag>("pfClusterProducer", edm::InputTag("particleFlowClusterECAL"));
342  psd0.add<double>("drMax", 0.3);
343  psd0.add<double>("drVetoBarrel", 0.0);
344  psd0.add<double>("drVetoEndcap", 0.0);
345  psd0.add<double>("etaStripBarrel", 0.0);
346  psd0.add<double>("etaStripEndcap", 0.0);
347  psd0.add<double>("energyBarrel", 0.0);
348  psd0.add<double>("energyEndcap", 0.0);
349  desc.add<edm::ParameterSetDescription>("pfECALClusIsolCfg", psd0);
350  }
351 
353  {
354  edm::ParameterSetDescription psd0;
355  psd0.add<edm::InputTag>("pfClusterProducerHCAL", edm::InputTag("particleFlowClusterHCAL"));
356  psd0.add<edm::InputTag>("pfClusterProducerHFEM", edm::InputTag(""));
357  psd0.add<edm::InputTag>("pfClusterProducerHFHAD", edm::InputTag(""));
358  psd0.add<bool>("useHF", false);
359  psd0.add<double>("drMax", 0.3);
360  psd0.add<double>("drVetoBarrel", 0.0);
361  psd0.add<double>("drVetoEndcap", 0.0);
362  psd0.add<double>("etaStripBarrel", 0.0);
363  psd0.add<double>("etaStripEndcap", 0.0);
364  psd0.add<double>("energyBarrel", 0.0);
365  psd0.add<double>("energyEndcap", 0.0);
366  psd0.add<bool>("useEt", true);
367  desc.add<edm::ParameterSetDescription>("pfHCALClusIsolCfg", psd0);
368  }
369 
370  descriptions.add("gsfElectronProducerDefault", desc);
371 }
ProducerED_cfi.InputTag
InputTag
Definition: ProducerED_cfi.py:5
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
EleTkIsolFromCands::pSetDescript
static edm::ParameterSetDescription pSetDescript()
Definition: EleTkIsolFromCands.cc:43
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57

◆ globalEndJob()

static void GsfElectronProducer::globalEndJob ( GsfElectronAlgo::HeavyObjectCache const *  )
inlinestatic

Definition at line 132 of file GsfElectronProducer.cc.

132 {};

◆ initializeGlobalCache()

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

Definition at line 126 of file GsfElectronProducer.cc.

126  {
127  return std::make_unique<GsfElectronAlgo::HeavyObjectCache>(conf);
128  }

◆ isPreselected()

bool GsfElectronProducer::isPreselected ( reco::GsfElectron const &  ele) const
private

Definition at line 730 of file GsfElectronProducer.cc.

References reco::GsfElectron::ecalDrivenSeed(), GsfElectronAlgo::StrategyConfiguration::MaxElePtForOnlyMVA, reco::GsfElectron::passingCutBasedPreselection(), reco::GsfElectron::passingMvaPreselection(), reco::GsfElectron::passingPflowPreselection(), reco::LeafCandidate::pt(), and strategyCfg_.

Referenced by produce(), and setAmbiguityData().

730  {
731  bool passCutBased = ele.passingCutBasedPreselection();
732  bool passPF = ele.passingPflowPreselection();
733  // it is worth nothing for gedGsfElectrons, this does nothing as its not set
734  // till GedGsfElectron finaliser, this is always false
735  bool passmva = ele.passingMvaPreselection();
736  if (!ele.ecalDrivenSeed()) {
737  if (ele.pt() > strategyCfg_.MaxElePtForOnlyMVA)
738  return passmva && passCutBased;
739  else
740  return passmva;
741  } else {
742  return passCutBased || passPF || passmva;
743  }
744 }
GsfElectronProducer::strategyCfg_
GsfElectronAlgo::StrategyConfiguration strategyCfg_
Definition: GsfElectronProducer.cc:143

◆ produce()

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

Definition at line 747 of file GsfElectronProducer.cc.

References algo_, reco::GsfElectron::ambiguous(), GsfElectronAlgo::StrategyConfiguration::applyAmbResolution, GsfElectronAlgo::StrategyConfiguration::applyPreselection, checkEcalSeedingParameters(), dnnPFidEnabled_, ecalSeedingParametersChecked_, egmPFCandidateCollection_, electronPutToken_, pwdgSkimBPark_cfi::electrons, extetaboundary_, hcalCuts, hcalRun2EffDepth_, GsfElectronAlgo::StrategyConfiguration::ignoreNotPreselected, inputCfg_, isPreselected(), eostools::move(), edm::parameterSet(), resetMvaValuesUsingPFCandidates_, edm::second(), DetachedQuadStep_cff::seeds, GsfElectronAlgo::Tokens::seedsTag, setAmbiguityData(), singleTopDQM_cfi::setup, strategyCfg_, tfSessions_, and GsfElectronAlgo::Tokens::vtxCollectionTag.

747  {
748  // check configuration
749  if (!ecalSeedingParametersChecked_) {
750  ecalSeedingParametersChecked_ = true;
751  auto seeds = event.getHandle(inputCfg_.seedsTag);
752  if (!seeds.isValid()) {
753  edm::LogWarning("GsfElectronAlgo|UnreachableSeedsProvenance")
754  << "Cannot check consistency of parameters with ecal seeding ones,"
755  << " because the original collection of seeds is not any more available.";
756  } else {
757  checkEcalSeedingParameters(edm::parameterSet(seeds.provenance()->stable(), event.processHistory()));
758  }
759  }
760 
761  auto electrons = algo_->completeElectrons(event, setup, globalCache(), hcalCuts);
762  if (resetMvaValuesUsingPFCandidates_) {
763  const auto gsfMVAInputMap = matchWithPFCandidates(event.get(egmPFCandidateCollection_));
764  for (auto& el : electrons) {
765  el.setMvaInput(gsfMVAInputMap.find(el.gsfTrack())->second); // set Run2 MVA inputs
766  }
767  setMVAOutputs(
768  electrons, globalCache(), event.get(inputCfg_.vtxCollectionTag), dnnPFidEnabled_, extetaboundary_, tfSessions_);
769  }
770 
771  // all electrons
772  logElectrons(electrons, event, "GsfElectronAlgo Info (before preselection)");
773  // preselection
774  if (strategyCfg_.applyPreselection) {
775  electrons.erase(
776  std::remove_if(electrons.begin(), electrons.end(), [this](auto const& ele) { return !isPreselected(ele); }),
777  electrons.end());
778  logElectrons(electrons, event, "GsfElectronAlgo Info (after preselection)");
779  }
780  // ambiguity
781  setAmbiguityData(electrons, event, strategyCfg_.ignoreNotPreselected);
782  if (strategyCfg_.applyAmbResolution) {
783  electrons.erase(std::remove_if(electrons.begin(), electrons.end(), std::mem_fn(&reco::GsfElectron::ambiguous)),
784  electrons.end());
785  logElectrons(electrons, event, "GsfElectronAlgo Info (after amb. solving)");
786  }
787  // go back to run2-like 2 effective depths if desired - depth 1 is the normal depth 1, depth 2 is the sum over the rest
788  if (hcalRun2EffDepth_) {
789  for (auto& ele : electrons)
790  ele.hcalToRun2EffDepth();
791  }
792  // final filling
793  event.emplace(electronPutToken_, std::move(electrons));
794 }
GsfElectronProducer::checkEcalSeedingParameters
void checkEcalSeedingParameters(edm::ParameterSet const &)
Definition: GsfElectronProducer.cc:595
GsfElectronProducer::inputCfg_
GsfElectronAlgo::Tokens inputCfg_
Definition: GsfElectronProducer.cc:142
GsfElectronProducer::egmPFCandidateCollection_
edm::EDGetTokenT< reco::PFCandidateCollection > egmPFCandidateCollection_
Definition: GsfElectronProducer.cc:160
GsfElectronProducer::resetMvaValuesUsingPFCandidates_
const bool resetMvaValuesUsingPFCandidates_
Definition: GsfElectronProducer.cc:164
reco::GsfElectron::ambiguous
bool ambiguous() const
Definition: GsfElectron.h:765
GsfElectronAlgo::Tokens::vtxCollectionTag
edm::EDGetTokenT< reco::VertexCollection > vtxCollectionTag
Definition: GsfElectronAlgo.h:74
GsfElectronProducer::hcalCuts
HcalPFCuts const * hcalCuts
Definition: GsfElectronProducer.cc:173
edm::parameterSet
ParameterSet const & parameterSet(StableProvenance const &provenance, ProcessHistory const &history)
Definition: Provenance.cc:11
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
DetachedQuadStep_cff.seeds
seeds
Definition: DetachedQuadStep_cff.py:199
GsfElectronProducer::electronPutToken_
const edm::EDPutTokenT< reco::GsfElectronCollection > electronPutToken_
Definition: GsfElectronProducer.cc:158
GsfElectronProducer::tfSessions_
std::vector< tensorflow::Session * > tfSessions_
Definition: GsfElectronProducer.cc:169
GsfElectronAlgo::Tokens::seedsTag
edm::EDGetTokenT< reco::ElectronSeedCollection > seedsTag
Definition: GsfElectronAlgo.h:71
singleTopDQM_cfi.setup
setup
SETUP
Definition: singleTopDQM_cfi.py:37
GsfElectronProducer::isPreselected
bool isPreselected(reco::GsfElectron const &ele) const
Definition: GsfElectronProducer.cc:730
GsfElectronProducer::setAmbiguityData
void setAmbiguityData(reco::GsfElectronCollection &electrons, edm::Event const &event, bool ignoreNotPreselected=true) const
Definition: GsfElectronProducer.cc:632
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
GsfElectronProducer::algo_
std::unique_ptr< GsfElectronAlgo > algo_
Definition: GsfElectronProducer.cc:139
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:128
eostools.move
def move(src, dest)
Definition: eostools.py:511
GsfElectronProducer::strategyCfg_
GsfElectronAlgo::StrategyConfiguration strategyCfg_
Definition: GsfElectronProducer.cc:143
event
Definition: event.py:1

◆ setAmbiguityData()

void GsfElectronProducer::setAmbiguityData ( reco::GsfElectronCollection &  electrons,
edm::Event const &  event,
bool  ignoreNotPreselected = true 
) const
private

Definition at line 632 of file GsfElectronProducer.cc.

References GsfElectronAlgo::StrategyConfiguration::ambClustersOverlapStrategy, GsfElectronAlgo::StrategyConfiguration::ambSortingStrategy, GsfElectronAlgo::Tokens::barrelRecHitCollection, HLT_2023v12_cff::barrelRecHits, GsfElectronAlgo::Tokens::beamSpotTag, StorageManager_cfg::e1, HPSPFTauProducerPuppi_cfi::electron, pwdgSkimBPark_cfi::electrons, photonAnalyzer_cfi::eMin, GsfElectronAlgo::Tokens::endcapRecHitCollection, HLT_2023v12_cff::endcapRecHits, PVValHelper::eta, Exception, newFWLiteAna::found, edm::Ref< C, T, F >::get(), uncleanedOnlyElectronSequence_cff::gsfPfRecTracks, gsfPfRecTracksTag_, gsfElectrons_cfi::ignoreNotPreselected, inputCfg_, egamma::isBetterElectron(), egamma::isInnermostElectron(), isPreselected(), LogDebug, egamma::sharedEnergy(), jetUpdater_cfi::sort, strategyCfg_, DiMuonV_cfg::threshold, and useGsfPfRecTracks_.

Referenced by produce().

634  {
635  // Getting required event data
636  auto const& beamspot = event.get(inputCfg_.beamSpotTag);
637  auto gsfPfRecTracks =
638  useGsfPfRecTracks_ ? event.getHandle(gsfPfRecTracksTag_) : edm::Handle<reco::GsfPFRecTrackCollection>{};
639  auto const& barrelRecHits = event.get(inputCfg_.barrelRecHitCollection);
640  auto const& endcapRecHits = event.get(inputCfg_.endcapRecHitCollection);
641 
642  if (strategyCfg_.ambSortingStrategy == 0) {
643  std::sort(electrons.begin(), electrons.end(), egamma::isBetterElectron);
644  } else if (strategyCfg_.ambSortingStrategy == 1) {
645  std::sort(electrons.begin(), electrons.end(), egamma::isInnermostElectron);
646  } else {
647  throw cms::Exception("GsfElectronAlgo|UnknownAmbiguitySortingStrategy")
648  << "value of strategyCfg_.ambSortingStrategy is : " << strategyCfg_.ambSortingStrategy;
649  }
650 
651  // init
652  for (auto& electron : electrons) {
653  electron.clearAmbiguousGsfTracks();
654  electron.setAmbiguous(false);
655  }
656 
657  // get ambiguous from GsfPfRecTracks
658  if (useGsfPfRecTracks_) {
659  for (auto& e1 : electrons) {
660  bool found = false;
661  for (auto const& gsfPfRecTrack : *gsfPfRecTracks) {
662  if (gsfPfRecTrack.gsfTrackRef() == e1.gsfTrack()) {
663  if (found) {
664  edm::LogWarning("GsfElectronAlgo") << "associated gsfPfRecTrack already found";
665  } else {
666  found = true;
667  for (auto const& duplicate : gsfPfRecTrack.convBremGsfPFRecTrackRef()) {
668  e1.addAmbiguousGsfTrack(duplicate->gsfTrackRef());
669  }
670  }
671  }
672  }
673  }
674  }
675  // or search overlapping clusters
676  else {
677  for (auto e1 = electrons.begin(); e1 != electrons.end(); ++e1) {
678  if (e1->ambiguous())
679  continue;
680  if (ignoreNotPreselected && !isPreselected(*e1))
681  continue;
682 
683  SuperClusterRef scRef1 = e1->superCluster();
684  CaloClusterPtr eleClu1 = e1->electronCluster();
685  LogDebug("GsfElectronAlgo") << "Blessing electron with E/P " << e1->eSuperClusterOverP() << ", cluster "
686  << scRef1.get() << " & track " << e1->gsfTrack().get();
687 
688  for (auto e2 = e1 + 1; e2 != electrons.end(); ++e2) {
689  if (e2->ambiguous())
690  continue;
691  if (ignoreNotPreselected && !isPreselected(*e2))
692  continue;
693 
694  SuperClusterRef scRef2 = e2->superCluster();
695  CaloClusterPtr eleClu2 = e2->electronCluster();
696 
697  // search if same cluster
698  bool sameCluster = false;
699  if (strategyCfg_.ambClustersOverlapStrategy == 0) {
700  sameCluster = (scRef1 == scRef2);
701  } else if (strategyCfg_.ambClustersOverlapStrategy == 1) {
702  float eMin = 1.;
703  float threshold = eMin * cosh(EleRelPoint(scRef1->position(), beamspot.position()).eta());
704  using egamma::sharedEnergy;
705  sameCluster = ((sharedEnergy(*eleClu1, *eleClu2, barrelRecHits, endcapRecHits) >= threshold) ||
706  (sharedEnergy(*scRef1->seed(), *eleClu2, barrelRecHits, endcapRecHits) >= threshold) ||
707  (sharedEnergy(*eleClu1, *scRef2->seed(), barrelRecHits, endcapRecHits) >= threshold) ||
708  (sharedEnergy(*scRef1->seed(), *scRef2->seed(), barrelRecHits, endcapRecHits) >= threshold));
709  } else {
710  throw cms::Exception("GsfElectronAlgo|UnknownAmbiguityClustersOverlapStrategy")
711  << "value of strategyCfg_.ambClustersOverlapStrategy is : " << strategyCfg_.ambClustersOverlapStrategy;
712  }
713 
714  // main instructions
715  if (sameCluster) {
716  LogDebug("GsfElectronAlgo") << "Discarding electron with E/P " << e2->eSuperClusterOverP() << ", cluster "
717  << scRef2.get() << " and track " << e2->gsfTrack().get();
718  e1->addAmbiguousGsfTrack(e2->gsfTrack());
719  e2->setAmbiguous(true);
720  } else if (e1->gsfTrack() == e2->gsfTrack()) {
721  edm::LogWarning("GsfElectronAlgo") << "Forgetting electron with E/P " << e2->eSuperClusterOverP()
722  << ", cluster " << scRef2.get() << " and track " << e2->gsfTrack().get();
723  e2->setAmbiguous(true);
724  }
725  }
726  }
727  }
728 }
HLT_2023v12_cff.barrelRecHits
barrelRecHits
Definition: HLT_2023v12_cff.py:16461
jetUpdater_cfi.sort
sort
Definition: jetUpdater_cfi.py:30
GsfElectronProducer::gsfPfRecTracksTag_
const edm::EDGetTokenT< reco::GsfPFRecTrackCollection > gsfPfRecTracksTag_
Definition: GsfElectronProducer.cc:159
GsfElectronProducer::inputCfg_
GsfElectronAlgo::Tokens inputCfg_
Definition: GsfElectronProducer.cc:142
GsfElectronAlgo::Tokens::endcapRecHitCollection
edm::EDGetTokenT< EcalRecHitCollection > endcapRecHitCollection
Definition: GsfElectronAlgo.h:70
gsfElectrons_cfi.ignoreNotPreselected
ignoreNotPreselected
Definition: gsfElectrons_cfi.py:37
uncleanedOnlyElectronSequence_cff.gsfPfRecTracks
gsfPfRecTracks
Definition: uncleanedOnlyElectronSequence_cff.py:141
egamma::isBetterElectron
bool isBetterElectron(reco::GsfElectron const &, reco::GsfElectron const &)
Definition: EgAmbiguityTools.cc:16
egamma::isInnermostElectron
bool isInnermostElectron(reco::GsfElectron const &, reco::GsfElectron const &)
Definition: EgAmbiguityTools.cc:20
GsfElectronAlgo::Tokens::beamSpotTag
edm::EDGetTokenT< reco::BeamSpot > beamSpotTag
Definition: GsfElectronAlgo.h:73
photonAnalyzer_cfi.eMin
eMin
Definition: photonAnalyzer_cfi.py:50
GsfElectronProducer::isPreselected
bool isPreselected(reco::GsfElectron const &ele) const
Definition: GsfElectronProducer.cc:730
DiMuonV_cfg.threshold
threshold
Definition: DiMuonV_cfg.py:100
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
StorageManager_cfg.e1
e1
Definition: StorageManager_cfg.py:16
egamma::sharedEnergy
float sharedEnergy(reco::CaloCluster const &clu1, reco::CaloCluster const &clu2, EcalRecHitCollection const &barrelRecHits, EcalRecHitCollection const &endcapRecHits)
Definition: EgAmbiguityTools.cc:140
edm::Ref::get
T const * get() const
Returns C++ pointer to the item.
Definition: Ref.h:232
GsfElectronAlgo::Tokens::barrelRecHitCollection
edm::EDGetTokenT< EcalRecHitCollection > barrelRecHitCollection
Definition: GsfElectronAlgo.h:69
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:128
HLT_2023v12_cff.endcapRecHits
endcapRecHits
Definition: HLT_2023v12_cff.py:16462
HPSPFTauProducerPuppi_cfi.electron
electron
Definition: HPSPFTauProducerPuppi_cfi.py:13
GsfElectronProducer::strategyCfg_
GsfElectronAlgo::StrategyConfiguration strategyCfg_
Definition: GsfElectronProducer.cc:143
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:241

Member Data Documentation

◆ algo_

std::unique_ptr<GsfElectronAlgo> GsfElectronProducer::algo_
private

Definition at line 139 of file GsfElectronProducer.cc.

Referenced by produce().

◆ cutsCfg_

const GsfElectronAlgo::CutsConfiguration GsfElectronProducer::cutsCfg_
private

Definition at line 144 of file GsfElectronProducer.cc.

Referenced by checkEcalSeedingParameters().

◆ cutsFromDB

bool GsfElectronProducer::cutsFromDB
private

Definition at line 172 of file GsfElectronProducer.cc.

◆ dnnPFidEnabled_

bool GsfElectronProducer::dnnPFidEnabled_
private

Definition at line 166 of file GsfElectronProducer.cc.

Referenced by produce().

◆ ecalSeedingParametersChecked_

bool GsfElectronProducer::ecalSeedingParametersChecked_
private

Definition at line 155 of file GsfElectronProducer.cc.

Referenced by produce().

◆ egmPFCandidateCollection_

edm::EDGetTokenT<reco::PFCandidateCollection> GsfElectronProducer::egmPFCandidateCollection_
private

Definition at line 160 of file GsfElectronProducer.cc.

Referenced by produce().

◆ electronPutToken_

const edm::EDPutTokenT<reco::GsfElectronCollection> GsfElectronProducer::electronPutToken_
private

Definition at line 158 of file GsfElectronProducer.cc.

Referenced by produce().

◆ extetaboundary_

float GsfElectronProducer::extetaboundary_
private

Definition at line 167 of file GsfElectronProducer.cc.

Referenced by produce().

◆ gsfPfRecTracksTag_

const edm::EDGetTokenT<reco::GsfPFRecTrackCollection> GsfElectronProducer::gsfPfRecTracksTag_
private

Definition at line 159 of file GsfElectronProducer.cc.

Referenced by setAmbiguityData().

◆ hcalCfg_

ElectronHcalHelper::Configuration GsfElectronProducer::hcalCfg_
private

Definition at line 145 of file GsfElectronProducer.cc.

Referenced by checkEcalSeedingParameters().

◆ hcalCfgBc_

ElectronHcalHelper::Configuration GsfElectronProducer::hcalCfgBc_
private

Definition at line 145 of file GsfElectronProducer.cc.

◆ hcalCuts

HcalPFCuts const* GsfElectronProducer::hcalCuts = nullptr
private

Definition at line 173 of file GsfElectronProducer.cc.

Referenced by produce().

◆ hcalCutsToken_

edm::ESGetToken<HcalPFCuts, HcalPFCutsRcd> GsfElectronProducer::hcalCutsToken_
private

Definition at line 171 of file GsfElectronProducer.cc.

◆ hcalRun2EffDepth_

bool GsfElectronProducer::hcalRun2EffDepth_
private

Definition at line 147 of file GsfElectronProducer.cc.

Referenced by produce().

◆ inputCfg_

GsfElectronAlgo::Tokens GsfElectronProducer::inputCfg_
private

Definition at line 142 of file GsfElectronProducer.cc.

Referenced by produce(), and setAmbiguityData().

◆ resetMvaValuesUsingPFCandidates_

const bool GsfElectronProducer::resetMvaValuesUsingPFCandidates_
private

Definition at line 164 of file GsfElectronProducer.cc.

Referenced by produce().

◆ strategyCfg_

GsfElectronAlgo::StrategyConfiguration GsfElectronProducer::strategyCfg_
private

Definition at line 143 of file GsfElectronProducer.cc.

Referenced by isPreselected(), produce(), and setAmbiguityData().

◆ tfSessions_

std::vector<tensorflow::Session*> GsfElectronProducer::tfSessions_
private

Definition at line 169 of file GsfElectronProducer.cc.

Referenced by endStream(), and produce().

◆ useGsfPfRecTracks_

const bool GsfElectronProducer::useGsfPfRecTracks_
private

Definition at line 162 of file GsfElectronProducer.cc.

Referenced by setAmbiguityData().

Generated for CMSSW Reference Manual by doxygen 1.8.14