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

References looper::cfg.

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

Member Function Documentation

◆ checkEcalSeedingParameters()

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

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

587  {
588  if (!pset.exists("SeedConfiguration")) {
589  return;
590  }
591  edm::ParameterSet seedConfiguration = pset.getParameter<edm::ParameterSet>("SeedConfiguration");
592 
593  if (seedConfiguration.getParameter<bool>("applyHOverECut")) {
594  if ((hcalCfg_.hOverEConeSize != 0) &&
595  (hcalCfg_.hOverEConeSize != seedConfiguration.getParameter<double>("hOverEConeSize"))) {
596  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
597  << "The H/E cone size (" << hcalCfg_.hOverEConeSize << ") is different from ecal seeding ("
598  << seedConfiguration.getParameter<double>("hOverEConeSize") << ").";
599  }
600  if (cutsCfg_.maxHOverEBarrelCone < seedConfiguration.getParameter<double>("maxHOverEBarrel")) {
601  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
602  << "The max barrel cone H/E is lower than during ecal seeding.";
603  }
604  if (cutsCfg_.maxHOverEEndcapsCone < seedConfiguration.getParameter<double>("maxHOverEEndcaps")) {
605  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
606  << "The max endcaps cone H/E is lower than during ecal seeding.";
607  }
608  }
609 
610  if (cutsCfg_.minSCEtBarrel < seedConfiguration.getParameter<double>("SCEtCut")) {
611  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
612  << "The minimum super-cluster Et in barrel is lower than during ecal seeding.";
613  }
614  if (cutsCfg_.minSCEtEndcaps < seedConfiguration.getParameter<double>("SCEtCut")) {
615  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
616  << "The minimum super-cluster Et in endcaps is lower than during ecal seeding.";
617  }
618 }
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:144
GsfElectronProducer::cutsCfg_
const GsfElectronAlgo::CutsConfiguration cutsCfg_
Definition: GsfElectronProducer.cc:143
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:128

◆ endStream()

void GsfElectronProducer::endStream ( )
override

Definition at line 581 of file GsfElectronProducer.cc.

References tensorflow::closeSession(), and tfSessions_.

581  {
582  for (auto session : tfSessions_) {
583  tensorflow::closeSession(session);
584  }
585 }
tensorflow::closeSession
bool closeSession(Session *&session)
Definition: TensorFlow.cc:234
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 174 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.

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

722  {
723  bool passCutBased = ele.passingCutBasedPreselection();
724  bool passPF = ele.passingPflowPreselection();
725  // it is worth nothing for gedGsfElectrons, this does nothing as its not set
726  // till GedGsfElectron finaliser, this is always false
727  bool passmva = ele.passingMvaPreselection();
728  if (!ele.ecalDrivenSeed()) {
729  if (ele.pt() > strategyCfg_.MaxElePtForOnlyMVA)
730  return passmva && passCutBased;
731  else
732  return passmva;
733  } else {
734  return passCutBased || passPF || passmva;
735  }
736 }
GsfElectronProducer::strategyCfg_
GsfElectronAlgo::StrategyConfiguration strategyCfg_
Definition: GsfElectronProducer.cc:142

◆ produce()

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

Definition at line 739 of file GsfElectronProducer.cc.

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

739  {
740  HcalPFCuts const* hcalCuts = nullptr;
741  if (cutsFromDB_) {
742  hcalCuts = &setup.getData(hcalCutsToken_);
743  }
744 
745  // check configuration
746  if (!ecalSeedingParametersChecked_) {
747  ecalSeedingParametersChecked_ = true;
748  auto seeds = event.getHandle(inputCfg_.seedsTag);
749  if (!seeds.isValid()) {
750  edm::LogWarning("GsfElectronAlgo|UnreachableSeedsProvenance")
751  << "Cannot check consistency of parameters with ecal seeding ones,"
752  << " because the original collection of seeds is not any more available.";
753  } else {
754  checkEcalSeedingParameters(edm::parameterSet(seeds.provenance()->stable(), event.processHistory()));
755  }
756  }
757 
758  auto electrons = algo_->completeElectrons(event, setup, globalCache(), hcalCuts);
759  if (resetMvaValuesUsingPFCandidates_) {
760  const auto gsfMVAInputMap = matchWithPFCandidates(event.get(egmPFCandidateCollection_));
761  for (auto& el : electrons) {
762  el.setMvaInput(gsfMVAInputMap.find(el.gsfTrack())->second); // set Run2 MVA inputs
763  }
764  setMVAOutputs(
765  electrons, globalCache(), event.get(inputCfg_.vtxCollectionTag), dnnPFidEnabled_, extetaboundary_, tfSessions_);
766  }
767 
768  // all electrons
769  logElectrons(electrons, event, "GsfElectronAlgo Info (before preselection)");
770  // preselection
771  if (strategyCfg_.applyPreselection) {
772  electrons.erase(
773  std::remove_if(electrons.begin(), electrons.end(), [this](auto const& ele) { return !isPreselected(ele); }),
774  electrons.end());
775  logElectrons(electrons, event, "GsfElectronAlgo Info (after preselection)");
776  }
777  // ambiguity
778  setAmbiguityData(electrons, event, strategyCfg_.ignoreNotPreselected);
779  if (strategyCfg_.applyAmbResolution) {
780  electrons.erase(std::remove_if(electrons.begin(), electrons.end(), std::mem_fn(&reco::GsfElectron::ambiguous)),
781  electrons.end());
782  logElectrons(electrons, event, "GsfElectronAlgo Info (after amb. solving)");
783  }
784  // 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
785  if (hcalRun2EffDepth_) {
786  for (auto& ele : electrons)
787  ele.hcalToRun2EffDepth();
788  }
789  // final filling
790  event.emplace(electronPutToken_, std::move(electrons));
791 }
GsfElectronProducer::checkEcalSeedingParameters
void checkEcalSeedingParameters(edm::ParameterSet const &)
Definition: GsfElectronProducer.cc:587
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
GsfElectronProducer::hcalCutsToken_
edm::ESGetToken< HcalPFCuts, HcalPFCutsRcd > hcalCutsToken_
Definition: GsfElectronProducer.cc:170
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
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:722
GsfElectronProducer::setAmbiguityData
void setAmbiguityData(reco::GsfElectronCollection &electrons, edm::Event const &event, bool ignoreNotPreselected=true) const
Definition: GsfElectronProducer.cc:624
HLT_2024v12_cff.seeds
seeds
Definition: HLT_2024v12_cff.py:64205
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:128
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 624 of file GsfElectronProducer.cc.

References GsfElectronAlgo::StrategyConfiguration::ambClustersOverlapStrategy, GsfElectronAlgo::StrategyConfiguration::ambSortingStrategy, GsfElectronAlgo::Tokens::barrelRecHitCollection, HLT_2024v12_cff::barrelRecHits, GsfElectronAlgo::Tokens::beamSpotTag, StorageManager_cfg::e1, HPSPFTauProducerPuppi_cfi::electron, pwdgSkimBPark_cfi::electrons, photonAnalyzer_cfi::eMin, GsfElectronAlgo::Tokens::endcapRecHitCollection, HLT_2024v12_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().

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

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().

◆ cutsFromDB_

bool GsfElectronProducer::cutsFromDB_
private

Definition at line 171 of file GsfElectronProducer.cc.

Referenced by produce().

◆ 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.

◆ hcalCutsToken_

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

Definition at line 170 of file GsfElectronProducer.cc.

Referenced by produce().

◆ 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