CMS 3D CMS Logo
GsfElectronProducer.cc
Go to the documentation of this file.
1 #include "CommonTools/Utils/interface/StringToEnumValue.h"
2 #include "DataFormats/Common/interface/Handle.h"
3 #include "DataFormats/EcalRecHit/interface/EcalSeverityLevel.h"
4 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
5 #include "DataFormats/EgammaReco/interface/ElectronSeed.h"
6 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
7 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
8 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidateEGammaExtra.h"
9 #include "DataFormats/ParticleFlowReco/interface/GsfPFRecTrack.h"
10 #include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h"
11 #include "FWCore/Common/interface/Provenance.h"
12 #include "FWCore/Framework/interface/Event.h"
13 #include "FWCore/Framework/interface/EventSetup.h"
14 #include "FWCore/Framework/interface/stream/EDProducer.h"
15 #include "FWCore/MessageLogger/interface/MessageLogger.h"
16 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
17 #include "FWCore/ParameterSet/interface/ParameterSet.h"
18 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
19 #include "RecoEcal/EgammaCoreTools/interface/EcalClusterFunctionFactory.h"
20 #include "RecoEgamma/EgammaIsolationAlgos/interface/EleTkIsolFromCands.h"
21 #include "RecoEgamma/EgammaElectronAlgos/interface/EgAmbiguityTools.h"
22 #include "RecoEgamma/EgammaElectronAlgos/interface/ElectronUtilities.h"
23 #include "RecoEgamma/EgammaElectronAlgos/interface/GsfElectronAlgo.h"
24 #include "RecoEcal/EgammaCoreTools/interface/EgammaLocalCovParamDefaults.h"
25 
26 using namespace reco;
27 
28 namespace {
29 
30  void setMVAOutputs(reco::GsfElectronCollection& electrons,
31  const GsfElectronAlgo::HeavyObjectCache* hoc,
32  reco::VertexCollection const& vertices) {
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) {
49  reco::GsfElectronRef myRef;
50  // First check that the GsfTrack is non null
51  if (pfCand.gsfTrackRef().isNonnull()) {
52  reco::GsfElectron::MvaInput input;
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:
79  static void fillDescriptions(edm::ConfigurationDescriptions&);
80 
81  explicit GsfElectronProducer(const edm::ParameterSet&, const GsfElectronAlgo::HeavyObjectCache*);
82 
83  static std::unique_ptr<GsfElectronAlgo::HeavyObjectCache> initializeGlobalCache(const edm::ParameterSet& conf) {
84  return std::make_unique<GsfElectronAlgo::HeavyObjectCache>(conf);
85  }
86 
87  static void globalEndJob(GsfElectronAlgo::HeavyObjectCache const*) {}
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
96  GsfElectronAlgo::Tokens inputCfg_;
97  GsfElectronAlgo::StrategyConfiguration strategyCfg_;
98  const GsfElectronAlgo::CutsConfiguration cutsCfg_;
99  ElectronHcalHelper::Configuration hcalCfg_, hcalCfgBc_;
100 
101  bool hcalRun2EffDepth_;
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
109  bool ecalSeedingParametersChecked_;
110  void checkEcalSeedingParameters(edm::ParameterSet const&);
111 
112  const edm::EDPutTokenT<reco::GsfElectronCollection> electronPutToken_;
113  const edm::EDGetTokenT<reco::GsfPFRecTrackCollection> gsfPfRecTracksTag_;
114  edm::EDGetTokenT<reco::PFCandidateCollection> egmPFCandidateCollection_;
115 
116  const bool useGsfPfRecTracks_;
117 
118  const bool resetMvaValuesUsingPFCandidates_;
119 };
120 
121 void GsfElectronProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
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 }
254 
255 namespace {
256  GsfElectronAlgo::CutsConfiguration makeCutsConfiguration(edm::ParameterSet const& pset) {
257  return GsfElectronAlgo::CutsConfiguration{
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 
291 GsfElectronProducer::GsfElectronProducer(const edm::ParameterSet& cfg, const GsfElectronAlgo::HeavyObjectCache*)
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 }
418 
419 void GsfElectronProducer::checkEcalSeedingParameters(edm::ParameterSet const& pset) {
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 
456 void GsfElectronProducer::setAmbiguityData(reco::GsfElectronCollection& electrons,
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 =
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 }
553 
554 bool GsfElectronProducer::isPreselected(GsfElectron const& ele) const {
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 ------------
571 void GsfElectronProducer::produce(edm::Event& event, const edm::EventSetup& setup) {
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 }
617 
618 #include "FWCore/Framework/interface/MakerMacros.h"
619 DEFINE_FWK_MODULE(GsfElectronProducer);
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
Generated for CMSSW Reference Manual by doxygen 1.8.16