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

 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 ecalSeedingParametersChecked_
 
edm::EDGetTokenT< reco::PFCandidateCollection > egmPFCandidateCollection_
 
const edm::EDPutTokenT< reco::GsfElectronCollection > electronPutToken_
 
const edm::EDGetTokenT< reco::GsfPFRecTrackCollection > gsfPfRecTracksTag_
 
ElectronHcalHelper::Configuration hcalCfg_
 
ElectronHcalHelper::Configuration hcalCfgBc_
 
bool hcalRun2EffDepth_
 
GsfElectronAlgo::Tokens inputCfg_
 
const bool resetMvaValuesUsingPFCandidates_
 
GsfElectronAlgo::StrategyConfiguration strategyCfg_
 
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 77 of file GsfElectronProducer.cc.

Constructor & Destructor Documentation

◆ GsfElectronProducer()

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

Definition at line 291 of file GsfElectronProducer.cc.

292  : cutsCfg_{makeCutsConfiguration(cfg.getParameter<edm::ParameterSet>("preselection"))},
293  ecalSeedingParametersChecked_(false),
294  electronPutToken_(produces<GsfElectronCollection>()),
295  gsfPfRecTracksTag_(consumes(cfg.getParameter<edm::InputTag>("gsfPfRecTracksTag"))),
296  useGsfPfRecTracks_(cfg.getParameter<bool>("useGsfPfRecTracks")),
297  resetMvaValuesUsingPFCandidates_(cfg.getParameter<bool>("resetMvaValuesUsingPFCandidates")) {
298  if (resetMvaValuesUsingPFCandidates_) {
299  egmPFCandidateCollection_ = consumes(cfg.getParameter<edm::InputTag>("egmPFCandidatesTag"));
300  }
301 
302  inputCfg_.gsfElectronCores = consumes(cfg.getParameter<edm::InputTag>("gsfElectronCoresTag"));
303  inputCfg_.hbheRecHitsTag = consumes(cfg.getParameter<edm::InputTag>("hbheRecHits"));
304  inputCfg_.barrelRecHitCollection = consumes(cfg.getParameter<edm::InputTag>("barrelRecHitCollectionTag"));
305  inputCfg_.endcapRecHitCollection = consumes(cfg.getParameter<edm::InputTag>("endcapRecHitCollectionTag"));
306  inputCfg_.ctfTracks = consumes(cfg.getParameter<edm::InputTag>("ctfTracksTag"));
307  // used to check config consistency with seeding
308  inputCfg_.seedsTag = consumes(cfg.getParameter<edm::InputTag>("seedsTag"));
309  inputCfg_.beamSpotTag = consumes(cfg.getParameter<edm::InputTag>("beamSpotTag"));
310  inputCfg_.vtxCollectionTag = consumes(cfg.getParameter<edm::InputTag>("vtxTag"));
311  if (cfg.getParameter<bool>("fillConvVtxFitProb"))
312  inputCfg_.conversions = consumes(cfg.getParameter<edm::InputTag>("conversionsTag"));
313 
314  strategyCfg_.useDefaultEnergyCorrection = cfg.getParameter<bool>("useDefaultEnergyCorrection");
315 
316  strategyCfg_.applyPreselection = cfg.getParameter<bool>("applyPreselection");
317  strategyCfg_.ecalDrivenEcalEnergyFromClassBasedParameterization =
318  cfg.getParameter<bool>("ecalDrivenEcalEnergyFromClassBasedParameterization");
319  strategyCfg_.ecalDrivenEcalErrorFromClassBasedParameterization =
320  cfg.getParameter<bool>("ecalDrivenEcalErrorFromClassBasedParameterization");
321  strategyCfg_.pureTrackerDrivenEcalErrorFromSimpleParameterization =
322  cfg.getParameter<bool>("pureTrackerDrivenEcalErrorFromSimpleParameterization");
323  strategyCfg_.applyAmbResolution = cfg.getParameter<bool>("applyAmbResolution");
324  strategyCfg_.ignoreNotPreselected = cfg.getParameter<bool>("ignoreNotPreselected");
325  strategyCfg_.ambSortingStrategy = cfg.getParameter<unsigned>("ambSortingStrategy");
326  strategyCfg_.ambClustersOverlapStrategy = cfg.getParameter<unsigned>("ambClustersOverlapStrategy");
327  strategyCfg_.ctfTracksCheck = cfg.getParameter<bool>("ctfTracksCheck");
328  strategyCfg_.PreSelectMVA = cfg.getParameter<double>("PreSelectMVA");
329  strategyCfg_.MaxElePtForOnlyMVA = cfg.getParameter<double>("MaxElePtForOnlyMVA");
330  strategyCfg_.useEcalRegression = cfg.getParameter<bool>("useEcalRegression");
331  strategyCfg_.useCombinationRegression = cfg.getParameter<bool>("useCombinationRegression");
332  strategyCfg_.fillConvVtxFitProb = cfg.getParameter<bool>("fillConvVtxFitProb");
333 
334  // hcal helpers
335  auto const& psetPreselection = cfg.getParameter<edm::ParameterSet>("preselection");
336  hcalCfg_.hOverEConeSize = psetPreselection.getParameter<double>("hOverEConeSize");
337  if (hcalCfg_.hOverEConeSize > 0) {
338  hcalCfg_.onlyBehindCluster = false;
339  hcalCfg_.checkHcalStatus = cfg.getParameter<bool>("checkHcalStatus");
340 
341  //hcalCfg_.hbheRecHits = consumes<HBHERecHitCollection>(cfg.getParameter<edm::InputTag>("hbheRecHits"));
342  hcalCfg_.hbheRecHits = consumes<HBHERecHitCollection>(cfg.getParameter<edm::InputTag>("hbheRecHits"));
343 
344  hcalCfg_.eThresHB = cfg.getParameter<EgammaHcalIsolation::arrayHB>("recHitEThresholdHB");
345  hcalCfg_.maxSeverityHB = cfg.getParameter<int>("maxHcalRecHitSeverity");
346  hcalCfg_.eThresHE = cfg.getParameter<EgammaHcalIsolation::arrayHE>("recHitEThresholdHE");
347  hcalCfg_.maxSeverityHE = hcalCfg_.maxSeverityHB;
348  }
349 
350  hcalCfgBc_.hOverEConeSize = 0.;
351  hcalCfgBc_.onlyBehindCluster = true;
352  hcalCfgBc_.checkHcalStatus = cfg.getParameter<bool>("checkHcalStatus");
353 
354  //hcalCfgBc_.hbheRecHits = consumes<HBHERecHitCollection>(cfg.getParameter<edm::InputTag>("hbheRecHits"));
355  hcalCfgBc_.hbheRecHits = consumes<HBHERecHitCollection>(cfg.getParameter<edm::InputTag>("hbheRecHits"));
356 
357  hcalCfgBc_.eThresHB = cfg.getParameter<EgammaHcalIsolation::arrayHB>("recHitEThresholdHB");
358  hcalCfgBc_.maxSeverityHB = cfg.getParameter<int>("maxHcalRecHitSeverity");
359  hcalCfgBc_.eThresHE = cfg.getParameter<EgammaHcalIsolation::arrayHE>("recHitEThresholdHE");
360  hcalCfgBc_.maxSeverityHE = hcalCfgBc_.maxSeverityHB;
361 
362  hcalRun2EffDepth_ = cfg.getParameter<bool>("hcalRun2EffDepth");
363 
364  // Ecal rec hits configuration
365  GsfElectronAlgo::EcalRecHitsConfiguration recHitsCfg;
366  auto const& flagnamesbarrel = cfg.getParameter<std::vector<std::string>>("recHitFlagsToBeExcludedBarrel");
367  recHitsCfg.recHitFlagsToBeExcludedBarrel = StringToEnumValue<EcalRecHit::Flags>(flagnamesbarrel);
368  auto const& flagnamesendcaps = cfg.getParameter<std::vector<std::string>>("recHitFlagsToBeExcludedEndcaps");
369  recHitsCfg.recHitFlagsToBeExcludedEndcaps = StringToEnumValue<EcalRecHit::Flags>(flagnamesendcaps);
370  auto const& severitynamesbarrel = cfg.getParameter<std::vector<std::string>>("recHitSeverityToBeExcludedBarrel");
371  recHitsCfg.recHitSeverityToBeExcludedBarrel =
372  StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesbarrel);
373  auto const& severitynamesendcaps = cfg.getParameter<std::vector<std::string>>("recHitSeverityToBeExcludedEndcaps");
374  recHitsCfg.recHitSeverityToBeExcludedEndcaps =
375  StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesendcaps);
376 
377  // isolation
378  const GsfElectronAlgo::IsolationConfiguration isoCfg{
379  .intRadiusHcal = cfg.getParameter<double>("intRadiusHcal"),
380  .etMinHcal = cfg.getParameter<double>("etMinHcal"),
381  .intRadiusEcalBarrel = cfg.getParameter<double>("intRadiusEcalBarrel"),
382  .intRadiusEcalEndcaps = cfg.getParameter<double>("intRadiusEcalEndcaps"),
383  .jurassicWidth = cfg.getParameter<double>("jurassicWidth"),
384  .etMinBarrel = cfg.getParameter<double>("etMinBarrel"),
385  .eMinBarrel = cfg.getParameter<double>("eMinBarrel"),
386  .etMinEndcaps = cfg.getParameter<double>("etMinEndcaps"),
387  .eMinEndcaps = cfg.getParameter<double>("eMinEndcaps"),
388  .vetoClustered = cfg.getParameter<bool>("vetoClustered"),
389  .useNumCrystals = cfg.getParameter<bool>("useNumCrystals")};
390 
391  const RegressionHelper::Configuration regressionCfg{
392  .ecalRegressionWeightLabels = cfg.getParameter<std::vector<std::string>>("ecalRefinedRegressionWeightLabels"),
393  .ecalWeightsFromDB = cfg.getParameter<bool>("ecalWeightsFromDB"),
394  .ecalRegressionWeightFiles = cfg.getParameter<std::vector<std::string>>("ecalRefinedRegressionWeightFiles"),
395  .combinationRegressionWeightLabels =
396  cfg.getParameter<std::vector<std::string>>("combinationRegressionWeightLabels"),
397  .combinationWeightsFromDB = cfg.getParameter<bool>("combinationWeightsFromDB"),
398  .combinationRegressionWeightFiles =
399  cfg.getParameter<std::vector<std::string>>("combinationRegressionWeightFile")};
400 
401  // create algo
402  algo_ = std::make_unique<GsfElectronAlgo>(
403  inputCfg_,
404  strategyCfg_,
405  cutsCfg_,
406  hcalCfg_,
407  hcalCfgBc_,
408  isoCfg,
409  recHitsCfg,
410  EcalClusterFunctionFactory::get()->create(cfg.getParameter<std::string>("crackCorrectionFunction"), cfg),
411  regressionCfg,
412  cfg.getParameter<edm::ParameterSet>("trkIsol03Cfg"),
413  cfg.getParameter<edm::ParameterSet>("trkIsol04Cfg"),
414  cfg.getParameter<edm::ParameterSet>("trkIsolHEEP03Cfg"),
415  cfg.getParameter<edm::ParameterSet>("trkIsolHEEP04Cfg"),
416  consumesCollector());
417 }

References looper::cfg.

Member Function Documentation

◆ checkEcalSeedingParameters()

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

Definition at line 419 of file GsfElectronProducer.cc.

419  {
420  if (!pset.exists("SeedConfiguration")) {
421  return;
422  }
423  edm::ParameterSet seedConfiguration = pset.getParameter<edm::ParameterSet>("SeedConfiguration");
424 
425  if (seedConfiguration.getParameter<bool>("applyHOverECut")) {
426  if ((hcalCfg_.hOverEConeSize != 0) &&
427  (hcalCfg_.hOverEConeSize != seedConfiguration.getParameter<double>("hOverEConeSize"))) {
428  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
429  << "The H/E cone size (" << hcalCfg_.hOverEConeSize << ") is different from ecal seeding ("
430  << seedConfiguration.getParameter<double>("hOverEConeSize") << ").";
431  }
432  if (cutsCfg_.maxHOverEBarrelCone < seedConfiguration.getParameter<double>("maxHOverEBarrel")) {
433  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
434  << "The max barrel cone H/E is lower than during ecal seeding.";
435  }
436  if (cutsCfg_.maxHOverEEndcapsCone < seedConfiguration.getParameter<double>("maxHOverEEndcaps")) {
437  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
438  << "The max endcaps cone H/E is lower than during ecal seeding.";
439  }
440  }
441 
442  if (cutsCfg_.minSCEtBarrel < seedConfiguration.getParameter<double>("SCEtCut")) {
443  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
444  << "The minimum super-cluster Et in barrel is lower than during ecal seeding.";
445  }
446  if (cutsCfg_.minSCEtEndcaps < seedConfiguration.getParameter<double>("SCEtCut")) {
447  edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
448  << "The minimum super-cluster Et in endcaps is lower than during ecal seeding.";
449  }
450 }

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

◆ fillDescriptions()

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

Definition at line 121 of file GsfElectronProducer.cc.

121  {
122  edm::ParameterSetDescription desc;
123  // input collections
124  desc.add<edm::InputTag>("gsfElectronCoresTag", {"ecalDrivenGsfElectronCores"});
125  desc.add<edm::InputTag>("vtxTag", {"offlinePrimaryVertices"});
126  desc.add<edm::InputTag>("conversionsTag", {"allConversions"});
127  desc.add<edm::InputTag>("gsfPfRecTracksTag", {"pfTrackElec"});
128  desc.add<edm::InputTag>("barrelRecHitCollectionTag", {"ecalRecHit", "EcalRecHitsEB"});
129  desc.add<edm::InputTag>("endcapRecHitCollectionTag", {"ecalRecHit", "EcalRecHitsEE"});
130  desc.add<edm::InputTag>("seedsTag", {"ecalDrivenElectronSeeds"});
131  desc.add<edm::InputTag>("beamSpotTag", {"offlineBeamSpot"});
132  desc.add<edm::InputTag>("egmPFCandidatesTag", {"particleFlowEGamma"});
133 
134  // steering
135  desc.add<bool>("useDefaultEnergyCorrection", true);
136  desc.add<bool>("useCombinationRegression", false);
137  desc.add<bool>("ecalDrivenEcalEnergyFromClassBasedParameterization", true);
138  desc.add<bool>("ecalDrivenEcalErrorFromClassBasedParameterization", true);
139  desc.add<bool>("applyPreselection", false);
140  desc.add<bool>("useEcalRegression", false);
141  desc.add<bool>("applyAmbResolution", false);
142  desc.add<bool>("ignoreNotPreselected", true);
143  desc.add<bool>("useGsfPfRecTracks", true);
144  desc.add<bool>("pureTrackerDrivenEcalErrorFromSimpleParameterization", true);
145  desc.add<unsigned int>("ambSortingStrategy", 1);
146  desc.add<unsigned int>("ambClustersOverlapStrategy", 1);
147  desc.add<bool>("fillConvVtxFitProb", true);
148  desc.add<bool>("resetMvaValuesUsingPFCandidates", false);
149 
150  // Ecal rec hits configuration
151  desc.add<std::vector<std::string>>("recHitFlagsToBeExcludedBarrel");
152  desc.add<std::vector<std::string>>("recHitFlagsToBeExcludedEndcaps");
153  desc.add<std::vector<std::string>>("recHitSeverityToBeExcludedBarrel");
154  desc.add<std::vector<std::string>>("recHitSeverityToBeExcludedEndcaps");
155 
156  // Hcal rec hits configuration
157  desc.add<bool>("checkHcalStatus", true);
158  desc.add<edm::InputTag>("hbheRecHits", edm::InputTag("hbhereco"));
159  desc.add<std::vector<double>>("recHitEThresholdHB", {0., 0., 0., 0.});
160  desc.add<std::vector<double>>("recHitEThresholdHE", {0., 0., 0., 0., 0., 0., 0.});
161  desc.add<int>("maxHcalRecHitSeverity", 999999);
162  desc.add<bool>("hcalRun2EffDepth", false);
163 
164  // Isolation algos configuration
165  desc.add("trkIsol03Cfg", EleTkIsolFromCands::pSetDescript());
166  desc.add("trkIsol04Cfg", EleTkIsolFromCands::pSetDescript());
167  desc.add("trkIsolHEEP03Cfg", EleTkIsolFromCands::pSetDescript());
168  desc.add("trkIsolHEEP04Cfg", EleTkIsolFromCands::pSetDescript());
169  desc.add<bool>("useNumCrystals", true);
170  desc.add<double>("etMinBarrel", 0.0);
171  desc.add<double>("etMinEndcaps", 0.11);
172  desc.add<double>("etMinHcal", 0.0);
173  desc.add<double>("eMinBarrel", 0.095);
174  desc.add<double>("eMinEndcaps", 0.0);
175  desc.add<double>("intRadiusEcalBarrel", 3.0);
176  desc.add<double>("intRadiusEcalEndcaps", 3.0);
177  desc.add<double>("intRadiusHcal", 0.15);
178  desc.add<double>("jurassicWidth", 1.5);
179  desc.add<bool>("vetoClustered", false);
180 
181  // backward compatibility mechanism for ctf tracks
182  desc.add<bool>("ctfTracksCheck", true);
183  desc.add<edm::InputTag>("ctfTracksTag", {"generalTracks"});
184 
185  desc.add<double>("MaxElePtForOnlyMVA", 50.0);
186  desc.add<double>("PreSelectMVA", -0.1);
187 
188  {
189  edm::ParameterSetDescription psd0;
190  psd0.add<double>("minSCEtBarrel", 4.0);
191  psd0.add<double>("minSCEtEndcaps", 4.0);
192  psd0.add<double>("minEOverPBarrel", 0.0);
193  psd0.add<double>("minEOverPEndcaps", 0.0);
194  psd0.add<double>("maxEOverPBarrel", 999999999.0);
195  psd0.add<double>("maxEOverPEndcaps", 999999999.0);
196  psd0.add<double>("maxDeltaEtaBarrel", 0.02);
197  psd0.add<double>("maxDeltaEtaEndcaps", 0.02);
198  psd0.add<double>("maxDeltaPhiBarrel", 0.15);
199  psd0.add<double>("maxDeltaPhiEndcaps", 0.15);
200  psd0.add<double>("hOverEConeSize", 0.15);
201  psd0.add<double>("maxHOverEBarrelCone", 0.15);
202  psd0.add<double>("maxHOverEEndcapsCone", 0.15);
203  psd0.add<double>("maxHBarrelCone", 0.0);
204  psd0.add<double>("maxHEndcapsCone", 0.0);
205  psd0.add<double>("maxHOverEBarrelBc", 0.15);
206  psd0.add<double>("maxHOverEEndcapsBc", 0.15);
207  psd0.add<double>("maxHBarrelBc", 0.0);
208  psd0.add<double>("maxHEndcapsBc", 0.0);
209  psd0.add<double>("maxSigmaIetaIetaBarrel", 999999999.0);
210  psd0.add<double>("maxSigmaIetaIetaEndcaps", 999999999.0);
211  psd0.add<double>("maxFbremBarrel", 999999999.0);
212  psd0.add<double>("maxFbremEndcaps", 999999999.0);
213  psd0.add<bool>("isBarrel", false);
214  psd0.add<bool>("isEndcaps", false);
215  psd0.add<bool>("isFiducial", false);
216  psd0.add<bool>("seedFromTEC", true);
217  psd0.add<double>("maxTIP", 999999999.0);
218  psd0.add<double>("multThresEB", EgammaLocalCovParamDefaults::kMultThresEB);
219  psd0.add<double>("multThresEE", EgammaLocalCovParamDefaults::kMultThresEE);
220  // preselection parameters
221  desc.add<edm::ParameterSetDescription>("preselection", psd0);
222  }
223 
224  // Corrections
225  desc.add<std::string>("crackCorrectionFunction", "EcalClusterCrackCorrection");
226 
227  desc.add<bool>("ecalWeightsFromDB", true);
228  desc.add<std::vector<std::string>>("ecalRefinedRegressionWeightFiles", {})
229  ->setComment("if not from DB. Otherwise, keep empty");
230  desc.add<bool>("combinationWeightsFromDB", true);
231  desc.add<std::vector<std::string>>("combinationRegressionWeightFile", {})
232  ->setComment("if not from DB. Otherwise, keep empty");
233 
234  // regression. The labels are needed in all cases.
235  desc.add<std::vector<std::string>>("ecalRefinedRegressionWeightLabels", {});
236  desc.add<std::vector<std::string>>("combinationRegressionWeightLabels", {});
237 
238  desc.add<std::vector<std::string>>(
239  "ElecMVAFilesString",
240  {
241  "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_10_17Feb2011.weights.xml",
242  "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_12_17Feb2011.weights.xml",
243  "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_20_17Feb2011.weights.xml",
244  "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_22_17Feb2011.weights.xml",
245  });
246  desc.add<std::vector<std::string>>(
247  "SoftElecMVAFilesString",
248  {
249  "RecoEgamma/ElectronIdentification/data/TMVA_BDTSoftElectrons_7Feb2014.weights.xml",
250  });
251 
252  descriptions.add("gsfElectronProducerDefault", desc);
253 }

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

◆ globalEndJob()

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

Definition at line 87 of file GsfElectronProducer.cc.

87 {}

◆ initializeGlobalCache()

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

Definition at line 83 of file GsfElectronProducer.cc.

83  {
84  return std::make_unique<GsfElectronAlgo::HeavyObjectCache>(conf);
85  }

◆ isPreselected()

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

Definition at line 554 of file GsfElectronProducer.cc.

554  {
555  bool passCutBased = ele.passingCutBasedPreselection();
556  bool passPF = ele.passingPflowPreselection();
557  // it is worth nothing for gedGsfElectrons, this does nothing as its not set
558  // till GedGsfElectron finaliser, this is always false
559  bool passmva = ele.passingMvaPreselection();
560  if (!ele.ecalDrivenSeed()) {
561  if (ele.pt() > strategyCfg_.MaxElePtForOnlyMVA)
562  return passmva && passCutBased;
563  else
564  return passmva;
565  } else {
566  return passCutBased || passPF || passmva;
567  }
568 }

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

◆ produce()

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

Definition at line 571 of file GsfElectronProducer.cc.

571  {
572  // check configuration
573  if (!ecalSeedingParametersChecked_) {
574  ecalSeedingParametersChecked_ = true;
575  auto seeds = event.getHandle(inputCfg_.seedsTag);
576  if (!seeds.isValid()) {
577  edm::LogWarning("GsfElectronAlgo|UnreachableSeedsProvenance")
578  << "Cannot check consistency of parameters with ecal seeding ones,"
579  << " because the original collection of seeds is not any more available.";
580  } else {
581  checkEcalSeedingParameters(edm::parameterSet(seeds.provenance()->stable(), event.processHistory()));
582  }
583  }
584 
585  auto electrons = algo_->completeElectrons(event, setup, globalCache());
586  if (resetMvaValuesUsingPFCandidates_) {
587  const auto gsfMVAInputMap = matchWithPFCandidates(event.get(egmPFCandidateCollection_));
588  setMVAOutputs(electrons, globalCache(), event.get(inputCfg_.vtxCollectionTag));
589  for (auto& el : electrons)
590  el.setMvaInput(gsfMVAInputMap.find(el.gsfTrack())->second); // set MVA inputs
591  }
592 
593  // all electrons
594  logElectrons(electrons, event, "GsfElectronAlgo Info (before preselection)");
595  // preselection
596  if (strategyCfg_.applyPreselection) {
597  electrons.erase(
598  std::remove_if(electrons.begin(), electrons.end(), [this](auto const& ele) { return !isPreselected(ele); }),
599  electrons.end());
600  logElectrons(electrons, event, "GsfElectronAlgo Info (after preselection)");
601  }
602  // ambiguity
603  setAmbiguityData(electrons, event, strategyCfg_.ignoreNotPreselected);
604  if (strategyCfg_.applyAmbResolution) {
605  electrons.erase(std::remove_if(electrons.begin(), electrons.end(), std::mem_fn(&reco::GsfElectron::ambiguous)),
606  electrons.end());
607  logElectrons(electrons, event, "GsfElectronAlgo Info (after amb. solving)");
608  }
609  // 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
610  if (hcalRun2EffDepth_) {
611  for (auto& ele : electrons)
612  ele.hcalToRun2EffDepth();
613  }
614  // final filling
615  event.emplace(electronPutToken_, std::move(electrons));
616 }

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

◆ setAmbiguityData()

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

Definition at line 456 of file GsfElectronProducer.cc.

458  {
459  // Getting required event data
460  auto const& beamspot = event.get(inputCfg_.beamSpotTag);
461  auto gsfPfRecTracks =
462  useGsfPfRecTracks_ ? event.getHandle(gsfPfRecTracksTag_) : edm::Handle<reco::GsfPFRecTrackCollection>{};
463  auto const& barrelRecHits = event.get(inputCfg_.barrelRecHitCollection);
464  auto const& endcapRecHits = event.get(inputCfg_.endcapRecHitCollection);
465 
466  if (strategyCfg_.ambSortingStrategy == 0) {
467  std::sort(electrons.begin(), electrons.end(), egamma::isBetterElectron);
468  } else if (strategyCfg_.ambSortingStrategy == 1) {
469  std::sort(electrons.begin(), electrons.end(), egamma::isInnermostElectron);
470  } else {
471  throw cms::Exception("GsfElectronAlgo|UnknownAmbiguitySortingStrategy")
472  << "value of strategyCfg_.ambSortingStrategy is : " << strategyCfg_.ambSortingStrategy;
473  }
474 
475  // init
476  for (auto& electron : electrons) {
477  electron.clearAmbiguousGsfTracks();
478  electron.setAmbiguous(false);
479  }
480 
481  // get ambiguous from GsfPfRecTracks
482  if (useGsfPfRecTracks_) {
483  for (auto& e1 : electrons) {
484  bool found = false;
485  for (auto const& gsfPfRecTrack : *gsfPfRecTracks) {
486  if (gsfPfRecTrack.gsfTrackRef() == e1.gsfTrack()) {
487  if (found) {
488  edm::LogWarning("GsfElectronAlgo") << "associated gsfPfRecTrack already found";
489  } else {
490  found = true;
491  for (auto const& duplicate : gsfPfRecTrack.convBremGsfPFRecTrackRef()) {
492  e1.addAmbiguousGsfTrack(duplicate->gsfTrackRef());
493  }
494  }
495  }
496  }
497  }
498  }
499  // or search overlapping clusters
500  else {
501  for (auto e1 = electrons.begin(); e1 != electrons.end(); ++e1) {
502  if (e1->ambiguous())
503  continue;
504  if (ignoreNotPreselected && !isPreselected(*e1))
505  continue;
506 
507  SuperClusterRef scRef1 = e1->superCluster();
508  CaloClusterPtr eleClu1 = e1->electronCluster();
509  LogDebug("GsfElectronAlgo") << "Blessing electron with E/P " << e1->eSuperClusterOverP() << ", cluster "
510  << scRef1.get() << " & track " << e1->gsfTrack().get();
511 
512  for (auto e2 = e1 + 1; e2 != electrons.end(); ++e2) {
513  if (e2->ambiguous())
514  continue;
515  if (ignoreNotPreselected && !isPreselected(*e2))
516  continue;
517 
518  SuperClusterRef scRef2 = e2->superCluster();
519  CaloClusterPtr eleClu2 = e2->electronCluster();
520 
521  // search if same cluster
522  bool sameCluster = false;
523  if (strategyCfg_.ambClustersOverlapStrategy == 0) {
524  sameCluster = (scRef1 == scRef2);
525  } else if (strategyCfg_.ambClustersOverlapStrategy == 1) {
526  float eMin = 1.;
527  float threshold = eMin * cosh(EleRelPoint(scRef1->position(), beamspot.position()).eta());
528  using egamma::sharedEnergy;
529  sameCluster = ((sharedEnergy(*eleClu1, *eleClu2, barrelRecHits, endcapRecHits) >= threshold) ||
530  (sharedEnergy(*scRef1->seed(), *eleClu2, barrelRecHits, endcapRecHits) >= threshold) ||
531  (sharedEnergy(*eleClu1, *scRef2->seed(), barrelRecHits, endcapRecHits) >= threshold) ||
532  (sharedEnergy(*scRef1->seed(), *scRef2->seed(), barrelRecHits, endcapRecHits) >= threshold));
533  } else {
534  throw cms::Exception("GsfElectronAlgo|UnknownAmbiguityClustersOverlapStrategy")
535  << "value of strategyCfg_.ambClustersOverlapStrategy is : " << strategyCfg_.ambClustersOverlapStrategy;
536  }
537 
538  // main instructions
539  if (sameCluster) {
540  LogDebug("GsfElectronAlgo") << "Discarding electron with E/P " << e2->eSuperClusterOverP() << ", cluster "
541  << scRef2.get() << " and track " << e2->gsfTrack().get();
542  e1->addAmbiguousGsfTrack(e2->gsfTrack());
543  e2->setAmbiguous(true);
544  } else if (e1->gsfTrack() == e2->gsfTrack()) {
545  edm::LogWarning("GsfElectronAlgo") << "Forgetting electron with E/P " << e2->eSuperClusterOverP()
546  << ", cluster " << scRef2.get() << " and track " << e2->gsfTrack().get();
547  e2->setAmbiguous(true);
548  }
549  }
550  }
551  }
552 }

References GsfElectronAlgo::StrategyConfiguration::ambClustersOverlapStrategy, GsfElectronAlgo::StrategyConfiguration::ambSortingStrategy, GsfElectronAlgo::Tokens::barrelRecHitCollection, HLT_FULL_cff::barrelRecHits, GsfElectronAlgo::Tokens::beamSpotTag, StorageManager_cfg::e1, HPSPFTauProducerPuppi_cfi::electron, pwdgSkimBPark_cfi::electrons, photonAnalyzer_cfi::eMin, GsfElectronAlgo::Tokens::endcapRecHitCollection, HLT_FULL_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_LED_IterMethod_cfg::threshold, and useGsfPfRecTracks_.

Referenced by produce().

Member Data Documentation

◆ algo_

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

Definition at line 93 of file GsfElectronProducer.cc.

Referenced by produce().

◆ cutsCfg_

const GsfElectronAlgo::CutsConfiguration GsfElectronProducer::cutsCfg_
private

Definition at line 98 of file GsfElectronProducer.cc.

Referenced by checkEcalSeedingParameters().

◆ ecalSeedingParametersChecked_

bool GsfElectronProducer::ecalSeedingParametersChecked_
private

Definition at line 109 of file GsfElectronProducer.cc.

Referenced by produce().

◆ egmPFCandidateCollection_

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

Definition at line 114 of file GsfElectronProducer.cc.

Referenced by produce().

◆ electronPutToken_

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

Definition at line 112 of file GsfElectronProducer.cc.

Referenced by produce().

◆ gsfPfRecTracksTag_

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

Definition at line 113 of file GsfElectronProducer.cc.

Referenced by setAmbiguityData().

◆ hcalCfg_

ElectronHcalHelper::Configuration GsfElectronProducer::hcalCfg_
private

Definition at line 99 of file GsfElectronProducer.cc.

Referenced by checkEcalSeedingParameters().

◆ hcalCfgBc_

ElectronHcalHelper::Configuration GsfElectronProducer::hcalCfgBc_
private

Definition at line 99 of file GsfElectronProducer.cc.

◆ hcalRun2EffDepth_

bool GsfElectronProducer::hcalRun2EffDepth_
private

Definition at line 101 of file GsfElectronProducer.cc.

Referenced by produce().

◆ inputCfg_

GsfElectronAlgo::Tokens GsfElectronProducer::inputCfg_
private

Definition at line 96 of file GsfElectronProducer.cc.

Referenced by produce(), and setAmbiguityData().

◆ resetMvaValuesUsingPFCandidates_

const bool GsfElectronProducer::resetMvaValuesUsingPFCandidates_
private

Definition at line 118 of file GsfElectronProducer.cc.

Referenced by produce().

◆ strategyCfg_

GsfElectronAlgo::StrategyConfiguration GsfElectronProducer::strategyCfg_
private

Definition at line 97 of file GsfElectronProducer.cc.

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

◆ useGsfPfRecTracks_

const bool GsfElectronProducer::useGsfPfRecTracks_
private

Definition at line 116 of file GsfElectronProducer.cc.

Referenced by setAmbiguityData().

ElectronHcalHelper::Configuration::hbheRecHits
edm::EDGetTokenT< HBHERecHitCollection > hbheRecHits
Definition: ElectronHcalHelper.h:33
GsfElectronAlgo::CutsConfiguration::maxHOverEBarrelCone
double maxHOverEBarrelCone
Definition: GsfElectronAlgo.h:112
GsfElectronAlgo::StrategyConfiguration::applyAmbResolution
bool applyAmbResolution
Definition: GsfElectronAlgo.h:83
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
RegressionHelper::Configuration::ecalRegressionWeightLabels
std::vector< std::string > ecalRegressionWeightLabels
Definition: RegressionHelper.h:29
EgammaHcalIsolation::arrayHB
std::array< double, 4 > arrayHB
Definition: EgammaHcalIsolation.h:41
HLT_FULL_cff.endcapRecHits
endcapRecHits
Definition: HLT_FULL_cff.py:14947
GsfElectronAlgo::Tokens::gsfElectronCores
edm::EDGetTokenT< reco::GsfElectronCoreCollection > gsfElectronCores
Definition: GsfElectronAlgo.h:61
GsfElectronAlgo::StrategyConfiguration::useCombinationRegression
bool useCombinationRegression
Definition: GsfElectronAlgo.h:94
GsfElectronProducer::hcalCfgBc_
ElectronHcalHelper::Configuration hcalCfgBc_
Definition: GsfElectronProducer.cc:99
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89301
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
HLT_FULL_cff.barrelRecHits
barrelRecHits
Definition: HLT_FULL_cff.py:14946
edm::Ref::get
T const * get() const
Returns C++ pointer to the item.
Definition: Ref.h:232
GsfElectronAlgo::StrategyConfiguration::ignoreNotPreselected
bool ignoreNotPreselected
Definition: GsfElectronAlgo.h:84
GsfElectronProducer::inputCfg_
GsfElectronAlgo::Tokens inputCfg_
Definition: GsfElectronProducer.cc:96
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
GsfElectronAlgo::StrategyConfiguration::ambClustersOverlapStrategy
unsigned ambClustersOverlapStrategy
Definition: GsfElectronAlgo.h:86
GsfElectronProducer::cutsCfg_
const GsfElectronAlgo::CutsConfiguration cutsCfg_
Definition: GsfElectronProducer.cc:98
beamerCreator.create
def create(alignables, pedeDump, additionalData, outputFile, config)
Definition: beamerCreator.py:44
GsfElectronAlgo::Tokens::seedsTag
edm::EDGetTokenT< reco::ElectronSeedCollection > seedsTag
Definition: GsfElectronAlgo.h:67
EgammaLocalCovParamDefaults::kMultThresEB
static constexpr float kMultThresEB
Definition: EgammaLocalCovParamDefaults.h:6
newFWLiteAna.found
found
Definition: newFWLiteAna.py:118
edm::Handle
Definition: AssociativeIterator.h:50
GsfElectronAlgo::CutsConfiguration::minSCEtEndcaps
double minSCEtEndcaps
Definition: GsfElectronAlgo.h:103
GsfElectronAlgo::Tokens::beamSpotTag
edm::EDGetTokenT< reco::BeamSpot > beamSpotTag
Definition: GsfElectronAlgo.h:69
GsfElectronAlgo::Tokens::barrelRecHitCollection
edm::EDGetTokenT< EcalRecHitCollection > barrelRecHitCollection
Definition: GsfElectronAlgo.h:65
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
GsfElectronProducer::isPreselected
bool isPreselected(reco::GsfElectron const &ele) const
Definition: GsfElectronProducer.cc:554
GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalErrorFromClassBasedParameterization
bool ecalDrivenEcalErrorFromClassBasedParameterization
Definition: GsfElectronAlgo.h:80
singleTopDQM_cfi.setup
setup
Definition: singleTopDQM_cfi.py:37
GsfElectronAlgo::CutsConfiguration::maxHOverEEndcapsCone
double maxHOverEEndcapsCone
Definition: GsfElectronAlgo.h:113
edm::Ref< SuperClusterCollection >
GsfElectronProducer::resetMvaValuesUsingPFCandidates_
const bool resetMvaValuesUsingPFCandidates_
Definition: GsfElectronProducer.cc:118
GsfElectronAlgo::StrategyConfiguration::ambSortingStrategy
unsigned ambSortingStrategy
Definition: GsfElectronAlgo.h:85
edm::parameterSet
ParameterSet const & parameterSet(StableProvenance const &provenance, ProcessHistory const &history)
Definition: Provenance.cc:11
gsfElectrons_cfi.ignoreNotPreselected
ignoreNotPreselected
Definition: gsfElectrons_cfi.py:37
uncleanedOnlyElectronSequence_cff.gsfPfRecTracks
gsfPfRecTracks
Definition: uncleanedOnlyElectronSequence_cff.py:141
GsfElectronProducer::hcalRun2EffDepth_
bool hcalRun2EffDepth_
Definition: GsfElectronProducer.cc:101
ElectronHcalHelper::Configuration::maxSeverityHB
int maxSeverityHB
Definition: ElectronHcalHelper.h:36
EleRelPoint
Definition: ElectronUtilities.h:25
GsfElectronAlgo::StrategyConfiguration::pureTrackerDrivenEcalErrorFromSimpleParameterization
bool pureTrackerDrivenEcalErrorFromSimpleParameterization
Definition: GsfElectronAlgo.h:81
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
ElectronHcalHelper::Configuration::onlyBehindCluster
bool onlyBehindCluster
Definition: ElectronHcalHelper.h:30
PVValHelper::eta
Definition: PVValidationHelpers.h:70
photonAnalyzer_cfi.eMin
eMin
Definition: photonAnalyzer_cfi.py:50
GsfElectronAlgo::CutsConfiguration::minSCEtBarrel
double minSCEtBarrel
Definition: GsfElectronAlgo.h:102
beamspot
Definition: BeamSpotWrite2Txt.h:8
ElectronHcalHelper::Configuration::hOverEConeSize
double hOverEConeSize
Definition: ElectronHcalHelper.h:27
GsfElectronAlgo::StrategyConfiguration::ctfTracksCheck
bool ctfTracksCheck
Definition: GsfElectronAlgo.h:88
GsfElectronAlgo::Tokens::endcapRecHitCollection
edm::EDGetTokenT< EcalRecHitCollection > endcapRecHitCollection
Definition: GsfElectronAlgo.h:66
GsfElectronAlgo::StrategyConfiguration::MaxElePtForOnlyMVA
float MaxElePtForOnlyMVA
Definition: GsfElectronAlgo.h:90
EgammaLocalCovParamDefaults::kMultThresEE
static constexpr float kMultThresEE
Definition: EgammaLocalCovParamDefaults.h:7
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
edm::ParameterSet
Definition: ParameterSet.h:47
GsfElectronProducer::algo_
std::unique_ptr< GsfElectronAlgo > algo_
Definition: GsfElectronProducer.cc:93
GsfElectronProducer::useGsfPfRecTracks_
const bool useGsfPfRecTracks_
Definition: GsfElectronProducer.cc:116
GsfElectronAlgo::Tokens::conversions
edm::EDGetTokenT< reco::ConversionCollection > conversions
Definition: GsfElectronAlgo.h:71
jetUpdater_cfi.sort
sort
Definition: jetUpdater_cfi.py:29
StorageManager_cfg.e1
e1
Definition: StorageManager_cfg.py:16
GsfElectronProducer::egmPFCandidateCollection_
edm::EDGetTokenT< reco::PFCandidateCollection > egmPFCandidateCollection_
Definition: GsfElectronProducer.cc:114
ElectronHcalHelper::Configuration::maxSeverityHE
int maxSeverityHE
Definition: ElectronHcalHelper.h:38
EleTkIsolFromCands::pSetDescript
static edm::ParameterSetDescription pSetDescript()
Definition: EleTkIsolFromCands.cc:43
get
#define get
electronEcalRecHitIsolationLcone_cfi.etMinBarrel
etMinBarrel
Definition: electronEcalRecHitIsolationLcone_cfi.py:17
HPSPFTauProducerPuppi_cfi.electron
electron
Definition: HPSPFTauProducerPuppi_cfi.py:13
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
GsfElectronAlgo::StrategyConfiguration::fillConvVtxFitProb
bool fillConvVtxFitProb
Definition: GsfElectronAlgo.h:97
egamma::sharedEnergy
float sharedEnergy(reco::CaloCluster const &clu1, reco::CaloCluster const &clu2, EcalRecHitCollection const &barrelRecHits, EcalRecHitCollection const &endcapRecHits)
Definition: EgAmbiguityTools.cc:140
edm::Ptr< CaloCluster >
looper.cfg
cfg
Definition: looper.py:296
GsfElectronProducer::checkEcalSeedingParameters
void checkEcalSeedingParameters(edm::ParameterSet const &)
Definition: GsfElectronProducer.cc:419
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
GsfElectronAlgo::StrategyConfiguration::applyPreselection
bool applyPreselection
Definition: GsfElectronAlgo.h:76
eostools.move
def move(src, dest)
Definition: eostools.py:511
DetachedQuadStep_cff.seeds
seeds
Definition: DetachedQuadStep_cff.py:195
GsfElectronAlgo::StrategyConfiguration::PreSelectMVA
float PreSelectMVA
Definition: GsfElectronAlgo.h:89
GsfElectronProducer::electronPutToken_
const edm::EDPutTokenT< reco::GsfElectronCollection > electronPutToken_
Definition: GsfElectronProducer.cc:112
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
ElectronHcalHelper::Configuration::eThresHB
EgammaHcalIsolation::arrayHB eThresHB
Definition: ElectronHcalHelper.h:35
ElectronHcalHelper::Configuration::checkHcalStatus
bool checkHcalStatus
Definition: ElectronHcalHelper.h:30
Exception
Definition: hltDiff.cc:245
GsfElectronProducer::ecalSeedingParametersChecked_
bool ecalSeedingParametersChecked_
Definition: GsfElectronProducer.cc:109
GsfElectronAlgo::Tokens::vtxCollectionTag
edm::EDGetTokenT< reco::VertexCollection > vtxCollectionTag
Definition: GsfElectronAlgo.h:70
GsfElectronProducer::hcalCfg_
ElectronHcalHelper::Configuration hcalCfg_
Definition: GsfElectronProducer.cc:99
GsfElectronAlgo::StrategyConfiguration::useDefaultEnergyCorrection
bool useDefaultEnergyCorrection
Definition: GsfElectronAlgo.h:91
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
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
GsfElectronProducer::strategyCfg_
GsfElectronAlgo::StrategyConfiguration strategyCfg_
Definition: GsfElectronProducer.cc:97
GsfElectronAlgo::Tokens::ctfTracks
edm::EDGetTokenT< reco::TrackCollection > ctfTracks
Definition: GsfElectronAlgo.h:68
GsfElectronAlgo::Tokens::hbheRecHitsTag
edm::EDGetTokenT< HBHERecHitCollection > hbheRecHitsTag
Definition: GsfElectronAlgo.h:62
GsfElectronAlgo::StrategyConfiguration::useEcalRegression
bool useEcalRegression
Definition: GsfElectronAlgo.h:93
GsfElectronAlgo::IsolationConfiguration::intRadiusHcal
double intRadiusHcal
Definition: GsfElectronAlgo.h:165
GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalEnergyFromClassBasedParameterization
bool ecalDrivenEcalEnergyFromClassBasedParameterization
Definition: GsfElectronAlgo.h:79
event
Definition: event.py:1
remoteMonitoring_LED_IterMethod_cfg.threshold
threshold
Definition: remoteMonitoring_LED_IterMethod_cfg.py:430
GsfElectronAlgo::IsolationConfiguration
Definition: GsfElectronAlgo.h:164
gedGsfElectrons_cfi.combinationRegressionWeightLabels
combinationRegressionWeightLabels
Definition: gedGsfElectrons_cfi.py:21
reco::GsfElectron::ambiguous
bool ambiguous() const
Definition: GsfElectron.h:752
GsfElectronProducer::setAmbiguityData
void setAmbiguityData(reco::GsfElectronCollection &electrons, edm::Event const &event, bool ignoreNotPreselected=true) const
Definition: GsfElectronProducer.cc:456
ElectronHcalHelper::Configuration::eThresHE
EgammaHcalIsolation::arrayHE eThresHE
Definition: ElectronHcalHelper.h:37
edm::InputTag
Definition: InputTag.h:15
EgammaHcalIsolation::arrayHE
std::array< double, 7 > arrayHE
Definition: EgammaHcalIsolation.h:42
GsfElectronProducer::gsfPfRecTracksTag_
const edm::EDGetTokenT< reco::GsfPFRecTrackCollection > gsfPfRecTracksTag_
Definition: GsfElectronProducer.cc:113
RegressionHelper::Configuration
Definition: RegressionHelper.h:27
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
GsfElectronAlgo::EcalRecHitsConfiguration
Definition: GsfElectronAlgo.h:155
electronEcalRecHitIsolationLcone_cfi.vetoClustered
vetoClustered
Definition: electronEcalRecHitIsolationLcone_cfi.py:25
Generated for CMSSW Reference Manual by doxygen 1.8.16