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 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 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_
 
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 403 of file GsfElectronProducer.cc.

References looper::cfg.

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

Member Function Documentation

◆ checkEcalSeedingParameters()

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

Definition at line 577 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().

577  {
578  if (!pset.exists("SeedConfiguration")) {
579  return;
580  }
581  edm::ParameterSet seedConfiguration = pset.getParameter<edm::ParameterSet>("SeedConfiguration");
582 
583  if (seedConfiguration.getParameter<bool>("applyHOverECut")) {
584  if ((hcalCfg_.hOverEConeSize != 0) &&
585  (hcalCfg_.hOverEConeSize != seedConfiguration.getParameter<double>("hOverEConeSize"))) {
586  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
587  << "The H/E cone size (" << hcalCfg_.hOverEConeSize << ") is different from ecal seeding ("
588  << seedConfiguration.getParameter<double>("hOverEConeSize") << ").";
589  }
590  if (cutsCfg_.maxHOverEBarrelCone < seedConfiguration.getParameter<double>("maxHOverEBarrel")) {
591  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
592  << "The max barrel cone H/E is lower than during ecal seeding.";
593  }
594  if (cutsCfg_.maxHOverEEndcapsCone < seedConfiguration.getParameter<double>("maxHOverEEndcaps")) {
595  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
596  << "The max endcaps cone H/E is lower than during ecal seeding.";
597  }
598  }
599 
600  if (cutsCfg_.minSCEtBarrel < seedConfiguration.getParameter<double>("SCEtCut")) {
601  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
602  << "The minimum super-cluster Et in barrel is lower than during ecal seeding.";
603  }
604  if (cutsCfg_.minSCEtEndcaps < seedConfiguration.getParameter<double>("SCEtCut")) {
605  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
606  << "The minimum super-cluster Et in endcaps is lower than during ecal seeding.";
607  }
608 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
GsfElectronProducer::hcalCfg_
ElectronHcalHelper::Configuration hcalCfg_
Definition: GsfElectronProducer.cc:144
GsfElectronProducer::cutsCfg_
const GsfElectronAlgo::CutsConfiguration cutsCfg_
Definition: GsfElectronProducer.cc:143
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122

◆ endStream()

void GsfElectronProducer::endStream ( )
override

Definition at line 571 of file GsfElectronProducer.cc.

References tensorflow::closeSession(), and tfSessions_.

571  {
572  for (auto session : tfSessions_) {
573  tensorflow::closeSession(session);
574  }
575 }
tensorflow::closeSession
bool closeSession(Session *&session)
Definition: TensorFlow.cc:197
GsfElectronProducer::tfSessions_
std::vector< tensorflow::Session * > tfSessions_
Definition: GsfElectronProducer.cc:168

◆ fillDescriptions()

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

For PF cluster isolations ECAL
HCAL

Definition at line 171 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.

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

712  {
713  bool passCutBased = ele.passingCutBasedPreselection();
714  bool passPF = ele.passingPflowPreselection();
715  // it is worth nothing for gedGsfElectrons, this does nothing as its not set
716  // till GedGsfElectron finaliser, this is always false
717  bool passmva = ele.passingMvaPreselection();
718  if (!ele.ecalDrivenSeed()) {
719  if (ele.pt() > strategyCfg_.MaxElePtForOnlyMVA)
720  return passmva && passCutBased;
721  else
722  return passmva;
723  } else {
724  return passCutBased || passPF || passmva;
725  }
726 }
GsfElectronProducer::strategyCfg_
GsfElectronAlgo::StrategyConfiguration strategyCfg_
Definition: GsfElectronProducer.cc:142

◆ produce()

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

Definition at line 729 of file GsfElectronProducer.cc.

References algo_, reco::GsfElectron::ambiguous(), GsfElectronAlgo::StrategyConfiguration::applyAmbResolution, GsfElectronAlgo::StrategyConfiguration::applyPreselection, checkEcalSeedingParameters(), dnnPFidEnabled_, ecalSeedingParametersChecked_, egmPFCandidateCollection_, electronPutToken_, pwdgSkimBPark_cfi::electrons, extetaboundary_, 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.

729  {
730  // check configuration
731  if (!ecalSeedingParametersChecked_) {
732  ecalSeedingParametersChecked_ = true;
733  auto seeds = event.getHandle(inputCfg_.seedsTag);
734  if (!seeds.isValid()) {
735  edm::LogWarning("GsfElectronAlgo|UnreachableSeedsProvenance")
736  << "Cannot check consistency of parameters with ecal seeding ones,"
737  << " because the original collection of seeds is not any more available.";
738  } else {
739  checkEcalSeedingParameters(edm::parameterSet(seeds.provenance()->stable(), event.processHistory()));
740  }
741  }
742 
743  auto electrons = algo_->completeElectrons(event, setup, globalCache());
744  if (resetMvaValuesUsingPFCandidates_) {
745  const auto gsfMVAInputMap = matchWithPFCandidates(event.get(egmPFCandidateCollection_));
746  for (auto& el : electrons) {
747  el.setMvaInput(gsfMVAInputMap.find(el.gsfTrack())->second); // set Run2 MVA inputs
748  }
749  setMVAOutputs(
750  electrons, globalCache(), event.get(inputCfg_.vtxCollectionTag), dnnPFidEnabled_, extetaboundary_, tfSessions_);
751  }
752 
753  // all electrons
754  logElectrons(electrons, event, "GsfElectronAlgo Info (before preselection)");
755  // preselection
756  if (strategyCfg_.applyPreselection) {
757  electrons.erase(
758  std::remove_if(electrons.begin(), electrons.end(), [this](auto const& ele) { return !isPreselected(ele); }),
759  electrons.end());
760  logElectrons(electrons, event, "GsfElectronAlgo Info (after preselection)");
761  }
762  // ambiguity
763  setAmbiguityData(electrons, event, strategyCfg_.ignoreNotPreselected);
764  if (strategyCfg_.applyAmbResolution) {
765  electrons.erase(std::remove_if(electrons.begin(), electrons.end(), std::mem_fn(&reco::GsfElectron::ambiguous)),
766  electrons.end());
767  logElectrons(electrons, event, "GsfElectronAlgo Info (after amb. solving)");
768  }
769  // 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
770  if (hcalRun2EffDepth_) {
771  for (auto& ele : electrons)
772  ele.hcalToRun2EffDepth();
773  }
774  // final filling
775  event.emplace(electronPutToken_, std::move(electrons));
776 }
GsfElectronProducer::checkEcalSeedingParameters
void checkEcalSeedingParameters(edm::ParameterSet const &)
Definition: GsfElectronProducer.cc:577
GsfElectronProducer::inputCfg_
GsfElectronAlgo::Tokens inputCfg_
Definition: GsfElectronProducer.cc:141
GsfElectronProducer::egmPFCandidateCollection_
edm::EDGetTokenT< reco::PFCandidateCollection > egmPFCandidateCollection_
Definition: GsfElectronProducer.cc:159
GsfElectronProducer::resetMvaValuesUsingPFCandidates_
const bool resetMvaValuesUsingPFCandidates_
Definition: GsfElectronProducer.cc:163
reco::GsfElectron::ambiguous
bool ambiguous() const
Definition: GsfElectron.h:765
GsfElectronAlgo::Tokens::vtxCollectionTag
edm::EDGetTokenT< reco::VertexCollection > vtxCollectionTag
Definition: GsfElectronAlgo.h:74
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:157
GsfElectronProducer::tfSessions_
std::vector< tensorflow::Session * > tfSessions_
Definition: GsfElectronProducer.cc:168
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:712
GsfElectronProducer::setAmbiguityData
void setAmbiguityData(reco::GsfElectronCollection &electrons, edm::Event const &event, bool ignoreNotPreselected=true) const
Definition: GsfElectronProducer.cc:614
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
GsfElectronProducer::algo_
std::unique_ptr< GsfElectronAlgo > algo_
Definition: GsfElectronProducer.cc:138
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
eostools.move
def move(src, dest)
Definition: eostools.py:511
GsfElectronProducer::strategyCfg_
GsfElectronAlgo::StrategyConfiguration strategyCfg_
Definition: GsfElectronProducer.cc:142
event
Definition: event.py:1

◆ setAmbiguityData()

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

Definition at line 614 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_, remoteMonitoring_LASER_era2018_cfg::threshold, and useGsfPfRecTracks_.

Referenced by produce().

616  {
617  // Getting required event data
618  auto const& beamspot = event.get(inputCfg_.beamSpotTag);
619  auto gsfPfRecTracks =
620  useGsfPfRecTracks_ ? event.getHandle(gsfPfRecTracksTag_) : edm::Handle<reco::GsfPFRecTrackCollection>{};
621  auto const& barrelRecHits = event.get(inputCfg_.barrelRecHitCollection);
622  auto const& endcapRecHits = event.get(inputCfg_.endcapRecHitCollection);
623 
624  if (strategyCfg_.ambSortingStrategy == 0) {
625  std::sort(electrons.begin(), electrons.end(), egamma::isBetterElectron);
626  } else if (strategyCfg_.ambSortingStrategy == 1) {
627  std::sort(electrons.begin(), electrons.end(), egamma::isInnermostElectron);
628  } else {
629  throw cms::Exception("GsfElectronAlgo|UnknownAmbiguitySortingStrategy")
630  << "value of strategyCfg_.ambSortingStrategy is : " << strategyCfg_.ambSortingStrategy;
631  }
632 
633  // init
634  for (auto& electron : electrons) {
635  electron.clearAmbiguousGsfTracks();
636  electron.setAmbiguous(false);
637  }
638 
639  // get ambiguous from GsfPfRecTracks
640  if (useGsfPfRecTracks_) {
641  for (auto& e1 : electrons) {
642  bool found = false;
643  for (auto const& gsfPfRecTrack : *gsfPfRecTracks) {
644  if (gsfPfRecTrack.gsfTrackRef() == e1.gsfTrack()) {
645  if (found) {
646  edm::LogWarning("GsfElectronAlgo") << "associated gsfPfRecTrack already found";
647  } else {
648  found = true;
649  for (auto const& duplicate : gsfPfRecTrack.convBremGsfPFRecTrackRef()) {
650  e1.addAmbiguousGsfTrack(duplicate->gsfTrackRef());
651  }
652  }
653  }
654  }
655  }
656  }
657  // or search overlapping clusters
658  else {
659  for (auto e1 = electrons.begin(); e1 != electrons.end(); ++e1) {
660  if (e1->ambiguous())
661  continue;
662  if (ignoreNotPreselected && !isPreselected(*e1))
663  continue;
664 
665  SuperClusterRef scRef1 = e1->superCluster();
666  CaloClusterPtr eleClu1 = e1->electronCluster();
667  LogDebug("GsfElectronAlgo") << "Blessing electron with E/P " << e1->eSuperClusterOverP() << ", cluster "
668  << scRef1.get() << " & track " << e1->gsfTrack().get();
669 
670  for (auto e2 = e1 + 1; e2 != electrons.end(); ++e2) {
671  if (e2->ambiguous())
672  continue;
673  if (ignoreNotPreselected && !isPreselected(*e2))
674  continue;
675 
676  SuperClusterRef scRef2 = e2->superCluster();
677  CaloClusterPtr eleClu2 = e2->electronCluster();
678 
679  // search if same cluster
680  bool sameCluster = false;
681  if (strategyCfg_.ambClustersOverlapStrategy == 0) {
682  sameCluster = (scRef1 == scRef2);
683  } else if (strategyCfg_.ambClustersOverlapStrategy == 1) {
684  float eMin = 1.;
685  float threshold = eMin * cosh(EleRelPoint(scRef1->position(), beamspot.position()).eta());
686  using egamma::sharedEnergy;
687  sameCluster = ((sharedEnergy(*eleClu1, *eleClu2, barrelRecHits, endcapRecHits) >= threshold) ||
688  (sharedEnergy(*scRef1->seed(), *eleClu2, barrelRecHits, endcapRecHits) >= threshold) ||
689  (sharedEnergy(*eleClu1, *scRef2->seed(), barrelRecHits, endcapRecHits) >= threshold) ||
690  (sharedEnergy(*scRef1->seed(), *scRef2->seed(), barrelRecHits, endcapRecHits) >= threshold));
691  } else {
692  throw cms::Exception("GsfElectronAlgo|UnknownAmbiguityClustersOverlapStrategy")
693  << "value of strategyCfg_.ambClustersOverlapStrategy is : " << strategyCfg_.ambClustersOverlapStrategy;
694  }
695 
696  // main instructions
697  if (sameCluster) {
698  LogDebug("GsfElectronAlgo") << "Discarding electron with E/P " << e2->eSuperClusterOverP() << ", cluster "
699  << scRef2.get() << " and track " << e2->gsfTrack().get();
700  e1->addAmbiguousGsfTrack(e2->gsfTrack());
701  e2->setAmbiguous(true);
702  } else if (e1->gsfTrack() == e2->gsfTrack()) {
703  edm::LogWarning("GsfElectronAlgo") << "Forgetting electron with E/P " << e2->eSuperClusterOverP()
704  << ", cluster " << scRef2.get() << " and track " << e2->gsfTrack().get();
705  e2->setAmbiguous(true);
706  }
707  }
708  }
709  }
710 }
HLT_2023v12_cff.barrelRecHits
barrelRecHits
Definition: HLT_2023v12_cff.py:16424
jetUpdater_cfi.sort
sort
Definition: jetUpdater_cfi.py:30
GsfElectronProducer::gsfPfRecTracksTag_
const edm::EDGetTokenT< reco::GsfPFRecTrackCollection > gsfPfRecTracksTag_
Definition: GsfElectronProducer.cc:158
GsfElectronProducer::inputCfg_
GsfElectronAlgo::Tokens inputCfg_
Definition: GsfElectronProducer.cc:141
remoteMonitoring_LASER_era2018_cfg.threshold
threshold
Definition: remoteMonitoring_LASER_era2018_cfg.py:582
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:712
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:122
HLT_2023v12_cff.endcapRecHits
endcapRecHits
Definition: HLT_2023v12_cff.py:16425
HPSPFTauProducerPuppi_cfi.electron
electron
Definition: HPSPFTauProducerPuppi_cfi.py:13
GsfElectronProducer::strategyCfg_
GsfElectronAlgo::StrategyConfiguration strategyCfg_
Definition: GsfElectronProducer.cc:142
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233

Member Data Documentation

◆ algo_

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

Definition at line 138 of file GsfElectronProducer.cc.

Referenced by produce().

◆ cutsCfg_

const GsfElectronAlgo::CutsConfiguration GsfElectronProducer::cutsCfg_
private

Definition at line 143 of file GsfElectronProducer.cc.

Referenced by checkEcalSeedingParameters().

◆ dnnPFidEnabled_

bool GsfElectronProducer::dnnPFidEnabled_
private

Definition at line 165 of file GsfElectronProducer.cc.

Referenced by produce().

◆ ecalSeedingParametersChecked_

bool GsfElectronProducer::ecalSeedingParametersChecked_
private

Definition at line 154 of file GsfElectronProducer.cc.

Referenced by produce().

◆ egmPFCandidateCollection_

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

Definition at line 159 of file GsfElectronProducer.cc.

Referenced by produce().

◆ electronPutToken_

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

Definition at line 157 of file GsfElectronProducer.cc.

Referenced by produce().

◆ extetaboundary_

float GsfElectronProducer::extetaboundary_
private

Definition at line 166 of file GsfElectronProducer.cc.

Referenced by produce().

◆ gsfPfRecTracksTag_

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

Definition at line 158 of file GsfElectronProducer.cc.

Referenced by setAmbiguityData().

◆ hcalCfg_

ElectronHcalHelper::Configuration GsfElectronProducer::hcalCfg_
private

Definition at line 144 of file GsfElectronProducer.cc.

Referenced by checkEcalSeedingParameters().

◆ hcalCfgBc_

ElectronHcalHelper::Configuration GsfElectronProducer::hcalCfgBc_
private

Definition at line 144 of file GsfElectronProducer.cc.

◆ hcalRun2EffDepth_

bool GsfElectronProducer::hcalRun2EffDepth_
private

Definition at line 146 of file GsfElectronProducer.cc.

Referenced by produce().

◆ inputCfg_

GsfElectronAlgo::Tokens GsfElectronProducer::inputCfg_
private

Definition at line 141 of file GsfElectronProducer.cc.

Referenced by produce(), and setAmbiguityData().

◆ resetMvaValuesUsingPFCandidates_

const bool GsfElectronProducer::resetMvaValuesUsingPFCandidates_
private

Definition at line 163 of file GsfElectronProducer.cc.

Referenced by produce().

◆ strategyCfg_

GsfElectronAlgo::StrategyConfiguration GsfElectronProducer::strategyCfg_
private

Definition at line 142 of file GsfElectronProducer.cc.

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

◆ tfSessions_

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

Definition at line 168 of file GsfElectronProducer.cc.

Referenced by endStream(), and produce().

◆ useGsfPfRecTracks_

const bool GsfElectronProducer::useGsfPfRecTracks_
private

Definition at line 161 of file GsfElectronProducer.cc.

Referenced by setAmbiguityData().

Generated for CMSSW Reference Manual by doxygen 1.8.14