CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
GsfElectronProducer.cc
Go to the documentation of this file.
25 
26 using namespace reco;
27 
28 namespace {
29 
30  void setMVAOutputs(reco::GsfElectronCollection& electrons,
33  for (auto& el : electrons) {
34  GsfElectron::MvaOutput mvaOutput;
35  mvaOutput.mva_e_pi = hoc->sElectronMVAEstimator->mva(el, vertices);
36  mvaOutput.mva_Isolated = hoc->iElectronMVAEstimator->mva(el, vertices.size());
37  el.setMvaOutput(mvaOutput);
38  }
39  }
40 
41  // Something more clever has to be found. The collections are small, so the timing is not
42  // an issue here; but it is clearly suboptimal
43 
44  auto matchWithPFCandidates(std::vector<reco::PFCandidate> const& pfCandidates) {
45  std::map<reco::GsfTrackRef, reco::GsfElectron::MvaInput> gsfMVAInputs{};
46 
47  //Loop over the collection of PFFCandidates
48  for (auto const& pfCand : pfCandidates) {
50  // First check that the GsfTrack is non null
51  if (pfCand.gsfTrackRef().isNonnull()) {
53  input.earlyBrem = pfCand.egammaExtraRef()->mvaVariable(reco::PFCandidateEGammaExtra::MVA_FirstBrem);
54  input.lateBrem = pfCand.egammaExtraRef()->mvaVariable(reco::PFCandidateEGammaExtra::MVA_LateBrem);
55  input.deltaEta = pfCand.egammaExtraRef()->mvaVariable(reco::PFCandidateEGammaExtra::MVA_DeltaEtaTrackCluster);
56  input.sigmaEtaEta = pfCand.egammaExtraRef()->sigmaEtaEta();
57  input.hadEnergy = pfCand.egammaExtraRef()->hadEnergy();
58  gsfMVAInputs[pfCand.gsfTrackRef()] = input;
59  }
60  }
61  return gsfMVAInputs;
62  }
63 
64  void logElectrons(reco::GsfElectronCollection const& electrons, edm::Event const& event, const std::string& title) {
65  LogTrace("GsfElectronAlgo") << "========== " << title << " ==========";
66  LogTrace("GsfElectronAlgo") << "Event: " << event.id();
67  LogTrace("GsfElectronAlgo") << "Number of electrons: " << electrons.size();
68  for (auto const& ele : electrons) {
69  LogTrace("GsfElectronAlgo") << "Electron with charge, pt, eta, phi: " << ele.charge() << " , " << ele.pt()
70  << " , " << ele.eta() << " , " << ele.phi();
71  }
72  LogTrace("GsfElectronAlgo") << "=================================================";
73  }
74 
75 } // namespace
76 
77 class GsfElectronProducer : public edm::stream::EDProducer<edm::GlobalCache<GsfElectronAlgo::HeavyObjectCache>> {
78 public:
80 
82 
83  static std::unique_ptr<GsfElectronAlgo::HeavyObjectCache> initializeGlobalCache(const edm::ParameterSet& conf) {
84  return std::make_unique<GsfElectronAlgo::HeavyObjectCache>(conf);
85  }
86 
88 
89  // ------------ method called to produce the data ------------
90  void produce(edm::Event& event, const edm::EventSetup& setup) override;
91 
92 private:
93  std::unique_ptr<GsfElectronAlgo> algo_;
94 
95  // configurables
100 
102 
103  bool isPreselected(reco::GsfElectron const& ele) const;
104  void setAmbiguityData(reco::GsfElectronCollection& electrons,
105  edm::Event const& event,
106  bool ignoreNotPreselected = true) const;
107 
108  // check expected configuration of previous modules
110  void checkEcalSeedingParameters(edm::ParameterSet const&);
111 
115 
116  const bool useGsfPfRecTracks_;
117 
119 };
120 
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  {
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 }
254 
255 namespace {
256  GsfElectronAlgo::CutsConfiguration makeCutsConfiguration(edm::ParameterSet const& pset) {
258  .minSCEtBarrel = pset.getParameter<double>("minSCEtBarrel"),
259  .minSCEtEndcaps = pset.getParameter<double>("minSCEtEndcaps"),
260  .maxEOverPBarrel = pset.getParameter<double>("maxEOverPBarrel"),
261  .maxEOverPEndcaps = pset.getParameter<double>("maxEOverPEndcaps"),
262  .minEOverPBarrel = pset.getParameter<double>("minEOverPBarrel"),
263  .minEOverPEndcaps = pset.getParameter<double>("minEOverPEndcaps"),
264  .maxHOverEBarrelCone = pset.getParameter<double>("maxHOverEBarrelCone"),
265  .maxHOverEEndcapsCone = pset.getParameter<double>("maxHOverEEndcapsCone"),
266  .maxHBarrelCone = pset.getParameter<double>("maxHBarrelCone"),
267  .maxHEndcapsCone = pset.getParameter<double>("maxHEndcapsCone"),
268  .maxHOverEBarrelBc = pset.getParameter<double>("maxHOverEBarrelBc"),
269  .maxHOverEEndcapsBc = pset.getParameter<double>("maxHOverEEndcapsBc"),
270  .maxHBarrelBc = pset.getParameter<double>("maxHBarrelBc"),
271  .maxHEndcapsBc = pset.getParameter<double>("maxHEndcapsBc"),
272  .maxDeltaEtaBarrel = pset.getParameter<double>("maxDeltaEtaBarrel"),
273  .maxDeltaEtaEndcaps = pset.getParameter<double>("maxDeltaEtaEndcaps"),
274  .maxDeltaPhiBarrel = pset.getParameter<double>("maxDeltaPhiBarrel"),
275  .maxDeltaPhiEndcaps = pset.getParameter<double>("maxDeltaPhiEndcaps"),
276  .maxSigmaIetaIetaBarrel = pset.getParameter<double>("maxSigmaIetaIetaBarrel"),
277  .maxSigmaIetaIetaEndcaps = pset.getParameter<double>("maxSigmaIetaIetaEndcaps"),
278  .maxFbremBarrel = pset.getParameter<double>("maxFbremBarrel"),
279  .maxFbremEndcaps = pset.getParameter<double>("maxFbremEndcaps"),
280  .isBarrel = pset.getParameter<bool>("isBarrel"),
281  .isEndcaps = pset.getParameter<bool>("isEndcaps"),
282  .isFiducial = pset.getParameter<bool>("isFiducial"),
283  .maxTIP = pset.getParameter<double>("maxTIP"),
284  .seedFromTEC = pset.getParameter<bool>("seedFromTEC"),
285  .multThresEB = pset.getParameter<double>("multThresEB"),
286  .multThresEE = pset.getParameter<double>("multThresEE"),
287  };
288  }
289 }; // namespace
290 
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
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
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"),
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 }
418 
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 }
451 
452 //=======================================================================================
453 // Ambiguity solving
454 //=======================================================================================
455 
457  edm::Event const& event,
458  bool ignoreNotPreselected) const {
459  // Getting required event data
460  auto const& beamspot = event.get(inputCfg_.beamSpotTag);
461  auto gsfPfRecTracks =
463  auto const& barrelRecHits = event.get(inputCfg_.barrelRecHitCollection);
464  auto const& endcapRecHits = event.get(inputCfg_.endcapRecHitCollection);
465 
466  if (strategyCfg_.ambSortingStrategy == 0) {
468  } else if (strategyCfg_.ambSortingStrategy == 1) {
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;
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;
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 }
553 
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 }
569 
570 // ------------ method called to produce the data ------------
572  // check configuration
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());
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
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
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 }
617 
ConfigurationDescriptions.h
Handle.h
zmumugammaAnalyzer_cfi.pfCandidates
pfCandidates
Definition: zmumugammaAnalyzer_cfi.py:11
GsfElectronAlgo::CutsConfiguration::maxHOverEBarrelCone
double maxHOverEBarrelCone
Definition: GsfElectronAlgo.h:112
GsfElectronAlgo::StrategyConfiguration::applyAmbResolution
bool applyAmbResolution
Definition: GsfElectronAlgo.h:83
runGCPTkAlMap.title
string title
Definition: runGCPTkAlMap.py:94
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
input
static const std::string input
Definition: EdmProvDump.cc:48
RegressionHelper::Configuration::ecalRegressionWeightLabels
std::vector< std::string > ecalRegressionWeightLabels
Definition: RegressionHelper.h:29
MessageLogger.h
TrackCandidateCollection.h
GsfElectronProducer::initializeGlobalCache
static std::unique_ptr< GsfElectronAlgo::HeavyObjectCache > initializeGlobalCache(const edm::ParameterSet &conf)
Definition: GsfElectronProducer.cc:83
reco::GsfElectron::passingMvaPreselection
bool passingMvaPreselection() const
Definition: GsfElectron.h:765
GsfElectronAlgo::StrategyConfiguration
Definition: GsfElectronAlgo.h:74
PFCandidate.h
EgammaHcalIsolation::arrayHB
std::array< double, 4 > arrayHB
Definition: EgammaHcalIsolation.h:41
HLT_FULL_cff.endcapRecHits
endcapRecHits
Definition: HLT_FULL_cff.py:14947
edm::EDGetTokenT< reco::GsfPFRecTrackCollection >
reco::GsfElectron::MvaOutput::mva_e_pi
float mva_e_pi
Definition: GsfElectron.h:715
edm::EDPutTokenT< reco::GsfElectronCollection >
GsfElectronProducer::hcalCfgBc_
ElectronHcalHelper::Configuration hcalCfgBc_
Definition: GsfElectronProducer.cc:99
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
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
EDProducer.h
GsfElectronAlgo::HeavyObjectCache::iElectronMVAEstimator
std::unique_ptr< const ElectronMVAEstimator > iElectronMVAEstimator
Definition: GsfElectronAlgo.h:57
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
reco::GsfElectronCollection
std::vector< GsfElectron > GsfElectronCollection
collection of GsfElectron objects
Definition: GsfElectronFwd.h:14
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
GsfElectronProducer::produce
void produce(edm::Event &event, const edm::EventSetup &setup) override
Definition: GsfElectronProducer.cc:571
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:46
ElectronUtilities.h
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
gedGsfElectrons_cfi.minSCEtEndcaps
minSCEtEndcaps
Definition: gedGsfElectrons_cfi.py:27
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
singleTopDQM_cfi.setup
setup
Definition: singleTopDQM_cfi.py:37
GsfElectronAlgo::CutsConfiguration::maxHOverEEndcapsCone
double maxHOverEEndcapsCone
Definition: GsfElectronAlgo.h:113
AlignmentTracksFromVertexSelector_cfi.vertices
vertices
Definition: AlignmentTracksFromVertexSelector_cfi.py:5
edm::Ref
Definition: AssociativeIterator.h:58
GsfElectronProducer::resetMvaValuesUsingPFCandidates_
const bool resetMvaValuesUsingPFCandidates_
Definition: GsfElectronProducer.cc:118
GsfElectronAlgo::StrategyConfiguration::ambSortingStrategy
unsigned ambSortingStrategy
Definition: GsfElectronAlgo.h:85
EcalSeverityLevel.h
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
MakerMacros.h
reco::GsfElectron::passingPflowPreselection
bool passingPflowPreselection() const
Definition: GsfElectron.h:751
EleRelPoint
Definition: ElectronUtilities.h:25
GsfElectronAlgo::HeavyObjectCache
Definition: GsfElectronAlgo.h:53
EgAmbiguityTools.h
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
PVValHelper::eta
Definition: PVValidationHelpers.h:70
photonAnalyzer_cfi.eMin
eMin
Definition: photonAnalyzer_cfi.py:50
fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
reco::GsfElectron::MvaOutput::mva_Isolated
float mva_Isolated
Definition: GsfElectron.h:714
reco::GsfElectron::ecalDrivenSeed
bool ecalDrivenSeed() const
Definition: GsfElectron.h:166
GsfElectronAlgo::CutsConfiguration::minSCEtBarrel
double minSCEtBarrel
Definition: GsfElectronAlgo.h:102
GsfElectronProducer::globalEndJob
static void globalEndJob(GsfElectronAlgo::HeavyObjectCache const *)
Definition: GsfElectronProducer.cc:87
beamspot
Definition: BeamSpotWrite2Txt.h:8
ElectronHcalHelper::Configuration::hOverEConeSize
double hOverEConeSize
Definition: ElectronHcalHelper.h:27
StringToEnumValue.h
reco::GsfElectron
Definition: GsfElectron.h:35
EcalClusterFunctionFactory.h
ParameterSetDescription.h
GsfElectron.h
GsfElectronProducer::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &)
Definition: GsfElectronProducer.cc:121
ElectronHcalHelper::Configuration
Definition: ElectronHcalHelper.h:25
reco::GsfElectron::MvaInput
Definition: GsfElectron.h:694
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
GsfElectronAlgo::Tokens::endcapRecHitCollection
edm::EDGetTokenT< EcalRecHitCollection > endcapRecHitCollection
Definition: GsfElectronAlgo.h:66
GsfElectronProducer
Definition: GsfElectronProducer.cc:77
GsfElectronAlgo::StrategyConfiguration::MaxElePtForOnlyMVA
float MaxElePtForOnlyMVA
Definition: GsfElectronAlgo.h:90
GsfElectronAlgo::Tokens
Definition: GsfElectronAlgo.h:60
EgammaLocalCovParamDefaults::kMultThresEE
static constexpr float kMultThresEE
Definition: EgammaLocalCovParamDefaults.h:7
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
edm::ParameterSet
Definition: ParameterSet.h:47
EleTkIsolFromCands.h
Event.h
GsfElectronProducer::algo_
std::unique_ptr< GsfElectronAlgo > algo_
Definition: GsfElectronProducer.cc:93
GsfElectronProducer::useGsfPfRecTracks_
const bool useGsfPfRecTracks_
Definition: GsfElectronProducer.cc:116
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
Reconstruction_hiPF_cff.maxEOverPEndcaps
maxEOverPEndcaps
Definition: Reconstruction_hiPF_cff.py:32
GsfTrack.h
GsfElectronAlgo::CutsConfiguration
Definition: GsfElectronAlgo.h:100
reco::GsfElectron::passingCutBasedPreselection
bool passingCutBasedPreselection() const
Definition: GsfElectron.h:750
edm::stream::EDProducer
Definition: EDProducer.h:36
EleTkIsolFromCands::pSetDescript
static edm::ParameterSetDescription pSetDescript()
Definition: EleTkIsolFromCands.cc:43
edm::EventSetup
Definition: EventSetup.h:58
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
GsfElectronProducer::GsfElectronProducer
GsfElectronProducer(const edm::ParameterSet &, const GsfElectronAlgo::HeavyObjectCache *)
Definition: GsfElectronProducer.cc:291
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
GsfElectronAlgo::HeavyObjectCache::sElectronMVAEstimator
std::unique_ptr< const SoftElectronMVAEstimator > sElectronMVAEstimator
Definition: GsfElectronAlgo.h:56
Reconstruction_hiPF_cff.maxHOverEEndcapsCone
maxHOverEEndcapsCone
Definition: Reconstruction_hiPF_cff.py:28
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
GsfElectronProducer::electronPutToken_
const edm::EDPutTokenT< reco::GsfElectronCollection > electronPutToken_
Definition: GsfElectronProducer.cc:112
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
PFCandidateEGammaExtra.h
Exception
Definition: hltDiff.cc:245
reco::GsfElectron::MvaOutput
Definition: GsfElectron.h:712
GsfElectronProducer::ecalSeedingParametersChecked_
bool ecalSeedingParametersChecked_
Definition: GsfElectronProducer.cc:109
GsfElectronAlgo::Tokens::vtxCollectionTag
edm::EDGetTokenT< reco::VertexCollection > vtxCollectionTag
Definition: GsfElectronAlgo.h:70
Provenance.h
GsfElectronProducer::hcalCfg_
ElectronHcalHelper::Configuration hcalCfg_
Definition: GsfElectronProducer.cc:99
EventSetup.h
reco::PFCandidateEGammaExtra::MVA_DeltaEtaTrackCluster
Definition: PFCandidateEGammaExtra.h:48
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
reco::PFCandidateEGammaExtra::MVA_LateBrem
Definition: PFCandidateEGammaExtra.h:51
EgammaLocalCovParamDefaults.h
GsfElectronAlgo::IsolationConfiguration::intRadiusHcal
double intRadiusHcal
Definition: GsfElectronAlgo.h:165
reco::PFCandidateEGammaExtra::MVA_FirstBrem
Definition: PFCandidateEGammaExtra.h:52
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
ParameterSet.h
HLT_FULL_cff.multThresEB
multThresEB
Definition: HLT_FULL_cff.py:14986
GsfPFRecTrack.h
event
Definition: event.py:1
remoteMonitoring_LED_IterMethod_cfg.threshold
threshold
Definition: remoteMonitoring_LED_IterMethod_cfg.py:430
edm::Event
Definition: Event.h:73
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
Reconstruction_hiPF_cff.maxHOverEEndcapsBc
maxHOverEEndcapsBc
Definition: Reconstruction_hiPF_cff.py:30
GsfElectronProducer::setAmbiguityData
void setAmbiguityData(reco::GsfElectronCollection &electrons, edm::Event const &event, bool ignoreNotPreselected=true) const
Definition: GsfElectronProducer.cc:456
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
ElectronSeed.h
GsfElectronAlgo::EcalRecHitsConfiguration
Definition: GsfElectronAlgo.h:155
GsfElectronAlgo.h
electronEcalRecHitIsolationLcone_cfi.vetoClustered
vetoClustered
Definition: electronEcalRecHitIsolationLcone_cfi.py:25