CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
EGammaMvaEleEstimatorCSA14.cc
Go to the documentation of this file.
1 #include <TFile.h>
2 #include "EgammaAnalysis/ElectronTools/interface/EGammaMvaEleEstimatorCSA14.h"
3 #include <cmath>
4 #include <vector>
5 #include <cstdio>
6 #include <zlib.h>
7 #include "TMVA/MethodBase.h"
8 #include "FWCore/Utilities/interface/isFinite.h"
9 
10 //--------------------------------------------------------------------------------------------------
11 EGammaMvaEleEstimatorCSA14::EGammaMvaEleEstimatorCSA14()
12  : fMethodname("BDTG method"), fisInitialized(kFALSE), fMVAType(kTrig), fUseBinnedVersion(kTRUE), fNMVABins(0) {
13  // Constructor.
14 }
15 
16 //--------------------------------------------------------------------------------------------------
17 EGammaMvaEleEstimatorCSA14::~EGammaMvaEleEstimatorCSA14() {
18  for (unsigned int i = 0; i < fTMVAReader.size(); ++i) {
19  if (fTMVAReader[i])
20  delete fTMVAReader[i];
21  }
22 }
23 
24 //--------------------------------------------------------------------------------------------------
25 void EGammaMvaEleEstimatorCSA14::initialize(std::string methodName,
26  std::string weightsfile,
27  EGammaMvaEleEstimatorCSA14::MVAType type) {
28  std::vector<std::string> tempWeightFileVector;
29  tempWeightFileVector.push_back(weightsfile);
30  initialize(methodName, type, kFALSE, tempWeightFileVector);
31 }
32 
33 //--------------------------------------------------------------------------------------------------
34 void EGammaMvaEleEstimatorCSA14::initialize(std::string methodName,
35  EGammaMvaEleEstimatorCSA14::MVAType type,
36  Bool_t useBinnedVersion,
37  std::vector<std::string> weightsfiles) {
38  //clean up first
39  for (unsigned int i = 0; i < fTMVAReader.size(); ++i) {
40  if (fTMVAReader[i])
41  delete fTMVAReader[i];
42  }
43  fTMVAReader.clear();
44  fTMVAMethod.clear();
45  //initialize
46  fisInitialized = kTRUE;
47  fMVAType = type;
48  fMethodname = methodName;
49  fUseBinnedVersion = useBinnedVersion;
50 
51  //Define expected number of bins
52  UInt_t ExpectedNBins = 0;
53  if (type == kTrig) {
54  ExpectedNBins = 2;
55  } else if (type == kNonTrig) {
56  ExpectedNBins = 4;
57  } else if (type == kNonTrigPhys14) {
58  ExpectedNBins = 6;
59  }
60 
61  fNMVABins = ExpectedNBins;
62 
63  //Check number of weight files given
64  if (fNMVABins != weightsfiles.size()) {
65  std::cout << "Error: Expected Number of bins = " << fNMVABins
66  << " does not equal to weightsfiles.size() = " << weightsfiles.size() << std::endl;
67 
68 #ifndef STANDALONE
69  assert(fNMVABins == weightsfiles.size());
70 #endif
71  }
72 
73  //Loop over all bins
74  for (unsigned int i = 0; i < fNMVABins; ++i) {
75  TMVA::Reader *tmpTMVAReader = new TMVA::Reader("!Color:!Silent:Error");
76  tmpTMVAReader->SetVerbose(kTRUE);
77 
78  if (type == kTrig) {
79  // Pure tracking variables
80  // Pure tracking variables
81  tmpTMVAReader->AddVariable("fBrem", &fMVAVar_fbrem);
82  tmpTMVAReader->AddVariable("kfchi2", &fMVAVar_kfchi2);
83  tmpTMVAReader->AddVariable("kfhits", &fMVAVar_kfhits);
84  tmpTMVAReader->AddVariable("gsfChi2", &fMVAVar_gsfchi2);
85 
86  // Geometrical matchings
87  tmpTMVAReader->AddVariable("eledeta", &fMVAVar_deta);
88  tmpTMVAReader->AddVariable("eledphi", &fMVAVar_dphi);
89  tmpTMVAReader->AddVariable("detacalo", &fMVAVar_detacalo);
90 
91  // Pure ECAL -> shower shapes
92  tmpTMVAReader->AddVariable("noZSsee", &fMVAVar_see);
93  tmpTMVAReader->AddVariable("noZSspp", &fMVAVar_spp);
94  tmpTMVAReader->AddVariable("etawidth", &fMVAVar_etawidth);
95  tmpTMVAReader->AddVariable("phiwidth", &fMVAVar_phiwidth);
96  tmpTMVAReader->AddVariable("noZSe1x5e5x5", &fMVAVar_OneMinusE1x5E5x5);
97  tmpTMVAReader->AddVariable("noZSr9", &fMVAVar_R9);
98 
99  // Energy matching
100  tmpTMVAReader->AddVariable("HtoE", &fMVAVar_HoE);
101  tmpTMVAReader->AddVariable("EoP", &fMVAVar_EoP);
102  tmpTMVAReader->AddVariable("IoEmIoP", &fMVAVar_IoEmIoP);
103  tmpTMVAReader->AddVariable("EEleoPout", &fMVAVar_eleEoPout);
104  if (i == 1)
105  tmpTMVAReader->AddVariable("PreShowerOverRaw", &fMVAVar_PreShowerOverRaw);
106 
107  tmpTMVAReader->AddSpectator("pt", &fMVAVar_pt);
108  tmpTMVAReader->AddSpectator("absEta", &fMVAVar_abseta);
109  }
110 
111  if ((type == kNonTrig) || (type == kNonTrigPhys14)) {
112  tmpTMVAReader->AddVariable("ele_kfhits", &fMVAVar_kfhits);
113  // Pure ECAL -> shower shapes
114  tmpTMVAReader->AddVariable("ele_oldsigmaietaieta", &fMVAVar_see);
115  tmpTMVAReader->AddVariable("ele_oldsigmaiphiiphi", &fMVAVar_spp);
116  tmpTMVAReader->AddVariable("ele_oldcircularity", &fMVAVar_OneMinusE1x5E5x5);
117  tmpTMVAReader->AddVariable("ele_oldr9", &fMVAVar_R9);
118  tmpTMVAReader->AddVariable("ele_scletawidth", &fMVAVar_etawidth);
119  tmpTMVAReader->AddVariable("ele_sclphiwidth", &fMVAVar_phiwidth);
120  tmpTMVAReader->AddVariable("ele_he", &fMVAVar_HoE);
121  if ((type == kNonTrig) && (i == 1 || i == 3))
122  tmpTMVAReader->AddVariable("ele_psEoverEraw", &fMVAVar_PreShowerOverRaw);
123  if ((type == kNonTrigPhys14) && (i == 2 || i == 5))
124  tmpTMVAReader->AddVariable("ele_psEoverEraw", &fMVAVar_PreShowerOverRaw);
125 
126  //Pure tracking variables
127  tmpTMVAReader->AddVariable("ele_kfchi2", &fMVAVar_kfchi2);
128  tmpTMVAReader->AddVariable("ele_chi2_hits", &fMVAVar_gsfchi2);
129  // Energy matching
130  tmpTMVAReader->AddVariable("ele_fbrem", &fMVAVar_fbrem);
131  tmpTMVAReader->AddVariable("ele_ep", &fMVAVar_EoP);
132  tmpTMVAReader->AddVariable("ele_eelepout", &fMVAVar_eleEoPout);
133  tmpTMVAReader->AddVariable("ele_IoEmIop", &fMVAVar_IoEmIoP);
134 
135  // Geometrical matchings
136  tmpTMVAReader->AddVariable("ele_deltaetain", &fMVAVar_deta);
137  tmpTMVAReader->AddVariable("ele_deltaphiin", &fMVAVar_dphi);
138  tmpTMVAReader->AddVariable("ele_deltaetaseed", &fMVAVar_detacalo);
139 
140  tmpTMVAReader->AddSpectator("ele_pT", &fMVAVar_pt);
141  tmpTMVAReader->AddSpectator("ele_isbarrel", &fMVAVar_isBarrel);
142  tmpTMVAReader->AddSpectator("ele_isendcap", &fMVAVar_isEndcap);
143  if (type == kNonTrigPhys14)
144  tmpTMVAReader->AddSpectator("scl_eta", &fMVAVar_SCeta);
145  }
146 
147 #ifndef STANDALONE
148  if ((fMethodname.find("BDT") == 0) &&
149  (weightsfiles[i].rfind(".xml.gz") == weightsfiles[i].length() - strlen(".xml.gz"))) {
150  gzFile file = gzopen(weightsfiles[i].c_str(), "rb");
151  if (file == nullptr) {
152  std::cout << "Error opening gzip file associated to " << weightsfiles[i] << std::endl;
153  throw cms::Exception("Configuration", "Error reading zipped XML file");
154  }
155  std::vector<char> data;
156  data.reserve(1024 * 1024 * 10);
157  unsigned int bufflen = 32 * 1024;
158  char *buff = reinterpret_cast<char *>(malloc(bufflen));
159  if (buff == nullptr) {
160  std::cout << "Error creating buffer for " << weightsfiles[i] << std::endl;
161  gzclose(file);
162  throw cms::Exception("Configuration", "Error reading zipped XML file");
163  }
164  int read;
165  while ((read = gzread(file, buff, bufflen)) != 0) {
166  if (read == -1) {
167  std::cout << "Error reading gzip file associated to " << weightsfiles[i] << ": " << gzerror(file, &read)
168  << std::endl;
169  gzclose(file);
170  free(buff);
171  throw cms::Exception("Configuration", "Error reading zipped XML file");
172  }
173  data.insert(data.end(), buff, buff + read);
174  }
175  if (gzclose(file) != Z_OK) {
176  std::cout << "Error closing gzip file associated to " << weightsfiles[i] << std::endl;
177  }
178  free(buff);
179  data.push_back('\0'); // IMPORTANT
180  fTMVAMethod.push_back(dynamic_cast<TMVA::MethodBase *>(tmpTMVAReader->BookMVA(TMVA::Types::kBDT, &data[0])));
181  } else {
182  if (weightsfiles[i].rfind(".xml.gz") == weightsfiles[i].length() - strlen(".xml.gz")) {
183  std::cout << "Error: xml.gz unsupported for method " << fMethodname << ", weight file " << weightsfiles[i]
184  << std::endl;
185  throw cms::Exception("Configuration", "Error reading zipped XML file");
186  }
187  fTMVAMethod.push_back(dynamic_cast<TMVA::MethodBase *>(tmpTMVAReader->BookMVA(fMethodname, weightsfiles[i])));
188  }
189 #else
190  if (weightsfiles[i].rfind(".xml.gz") == weightsfiles[i].length() - strlen(".xml.gz")) {
191  std::cout << "Error: xml.gz unsupported for method " << fMethodname << ", weight file " << weightsfiles[i]
192  << std::endl;
193  abort();
194  }
195  fTMVAMethod.push_back(dynamic_cast<TMVA::MethodBase *>(tmpTMVAReader->BookMVA(fMethodname, weightsfiles[i])));
196 #endif
197  std::cout << "MVABin " << i << " : MethodName = " << fMethodname << " , type == " << type << " , "
198  << "Load weights file : " << weightsfiles[i] << std::endl;
199  fTMVAReader.push_back(tmpTMVAReader);
200  }
201  std::cout << "Electron ID MVA Completed\n";
202 }
203 
204 //--------------------------------------------------------------------------------------------------
205 UInt_t EGammaMvaEleEstimatorCSA14::GetMVABin(double eta, double pt) const {
206  //Default is to return the first bin
207  unsigned int bin = 0;
208 
209  if (fMVAType == EGammaMvaEleEstimatorCSA14::kNonTrig) {
210  bin = 0;
211  if (pt < 10 && fabs(eta) < 1.479)
212  bin = 0;
213  if (pt < 10 && fabs(eta) >= 1.479)
214  bin = 1;
215  if (pt >= 10 && fabs(eta) < 1.479)
216  bin = 2;
217  if (pt >= 10 && fabs(eta) >= 1.479)
218  bin = 3;
219  }
220 
221  if (fMVAType == EGammaMvaEleEstimatorCSA14::kTrig) {
222  bin = 0;
223  if (pt >= 10 && fabs(eta) < 1.479)
224  bin = 0;
225  if (pt >= 10 && fabs(eta) >= 1.479)
226  bin = 1;
227  }
228 
229  if (fMVAType == EGammaMvaEleEstimatorCSA14::kNonTrigPhys14) {
230  bin = 0;
231  if (pt < 10 && fabs(eta) < 0.8)
232  bin = 0;
233  if (pt < 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479)
234  bin = 1;
235  if (pt < 10 && fabs(eta) >= 1.479)
236  bin = 2;
237  if (pt >= 10 && fabs(eta) < 0.8)
238  bin = 3;
239  if (pt >= 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479)
240  bin = 4;
241  if (pt >= 10 && fabs(eta) >= 1.479)
242  bin = 5;
243  }
244 
245  return bin;
246 }
247 
248 //--------------------------------------------------------------------------------------------------
249 
250 // for kTrig and kNonTrig algorithm
251 Double_t EGammaMvaEleEstimatorCSA14::mvaValue(const reco::GsfElectron &ele,
252  const reco::Vertex &vertex,
253  const TransientTrackBuilder &transientTrackBuilder,
254  noZS::EcalClusterLazyTools myEcalCluster,
255  bool printDebug) {
256  if (!fisInitialized) {
257  std::cout << "Error: EGammaMvaEleEstimatorCSA14 not properly initialized.\n";
258  return -9999;
259  }
260 
261  if ((fMVAType != EGammaMvaEleEstimatorCSA14::kTrig) && (fMVAType != EGammaMvaEleEstimatorCSA14::kNonTrig) &&
262  (fMVAType != EGammaMvaEleEstimatorCSA14::kNonTrigPhys14)) {
263  std::cout << "Error: This method should be called for kTrig or kNonTrig or kNonTrigPhys14 MVA only" << std::endl;
264  return -9999;
265  }
266 
267  bool validKF = false;
268  reco::TrackRef myTrackRef = ele.closestCtfTrackRef();
269  validKF = (myTrackRef.isAvailable());
270  validKF &= (myTrackRef.isNonnull());
271 
272  // Pure tracking variables
273  fMVAVar_fbrem = ele.fbrem();
274  fMVAVar_kfchi2 = (validKF) ? myTrackRef->normalizedChi2() : 0;
275  fMVAVar_kfhits = (validKF) ? myTrackRef->hitPattern().trackerLayersWithMeasurement() : -1.;
276  fMVAVar_kfhitsall =
277  (validKF) ? myTrackRef->numberOfValidHits() : -1.; // save also this in your ntuple as possible alternative
278  fMVAVar_gsfchi2 = ele.gsfTrack()->normalizedChi2();
279 
280  // Geometrical matchings
281  fMVAVar_deta = ele.deltaEtaSuperClusterTrackAtVtx();
282  fMVAVar_dphi = ele.deltaPhiSuperClusterTrackAtVtx();
283  fMVAVar_detacalo = ele.deltaEtaSeedClusterTrackAtCalo();
284 
285  // Pure ECAL -> shower shapes
286  const auto &vCov = myEcalCluster.localCovariances(*(ele.superCluster()->seed()));
287  if (edm::isFinite(vCov[0]))
288  fMVAVar_see = sqrt(vCov[0]); //EleSigmaIEtaIEta
289  else
290  fMVAVar_see = 0.;
291  if (edm::isFinite(vCov[2]))
292  fMVAVar_spp = sqrt(vCov[2]); //EleSigmaIPhiIPhi
293  else
294  fMVAVar_spp = 0.;
295 
296  fMVAVar_etawidth = ele.superCluster()->etaWidth();
297  fMVAVar_phiwidth = ele.superCluster()->phiWidth();
298  fMVAVar_OneMinusE1x5E5x5 =
299  (ele.e5x5()) != 0.
300  ? 1. - (myEcalCluster.e1x5(*(ele.superCluster()->seed())) / myEcalCluster.e5x5(*(ele.superCluster()->seed())))
301  : -1.;
302  fMVAVar_R9 = myEcalCluster.e3x3(*(ele.superCluster()->seed())) / ele.superCluster()->rawEnergy();
303 
304  // Energy matching
305  fMVAVar_HoE = ele.hadronicOverEm();
306  fMVAVar_EoP = ele.eSuperClusterOverP();
307  fMVAVar_IoEmIoP = (1.0 / ele.ecalEnergy()) - (1.0 / ele.p()); // in the future to be changed with ele.gsfTrack()->p()
308  fMVAVar_eleEoPout = ele.eEleClusterOverPout();
309  fMVAVar_PreShowerOverRaw = ele.superCluster()->preshowerEnergy() / ele.superCluster()->rawEnergy();
310 
311  // Spectators
312  fMVAVar_eta = ele.superCluster()->eta();
313  fMVAVar_abseta = fabs(ele.superCluster()->eta());
314  fMVAVar_pt = ele.pt();
315  fMVAVar_isBarrel = (ele.superCluster()->eta() < 1.479);
316  fMVAVar_isEndcap = (ele.superCluster()->eta() > 1.479);
317  fMVAVar_SCeta = ele.superCluster()->eta();
318 
319  // for triggering electrons get the impact parameteres
320  if (fMVAType == kTrig) {
321  //d0
322  if (ele.gsfTrack().isNonnull()) {
323  fMVAVar_d0 = (-1.0) * ele.gsfTrack()->dxy(vertex.position());
324  } else if (ele.closestCtfTrackRef().isNonnull()) {
325  fMVAVar_d0 = (-1.0) * ele.closestCtfTrackRef()->dxy(vertex.position());
326  } else {
327  fMVAVar_d0 = -9999.0;
328  }
329 
330  //default values for IP3D
331  fMVAVar_ip3d = -999.0;
332  fMVAVar_ip3dSig = 0.0;
333  if (ele.gsfTrack().isNonnull()) {
334  const double gsfsign = ((-ele.gsfTrack()->dxy(vertex.position())) >= 0) ? 1. : -1.;
335 
336  const reco::TransientTrack &tt = transientTrackBuilder.build(ele.gsfTrack());
337  const std::pair<bool, Measurement1D> &ip3dpv = IPTools::absoluteImpactParameter3D(tt, vertex);
338  if (ip3dpv.first) {
339  double ip3d = gsfsign * ip3dpv.second.value();
340  double ip3derr = ip3dpv.second.error();
341  fMVAVar_ip3d = ip3d;
342  fMVAVar_ip3dSig = ip3d / ip3derr;
343  }
344  }
345  }
346 
347  // evaluate
348  bindVariables();
349  Double_t mva = -9999;
350  if (fUseBinnedVersion) {
351  int bin = GetMVABin(fMVAVar_eta, fMVAVar_pt);
352  mva = fTMVAReader[bin]->EvaluateMVA(fTMVAMethod[bin]);
353  } else {
354  mva = fTMVAReader[0]->EvaluateMVA(fTMVAMethod[0]);
355  }
356 
357  if (printDebug) {
358  std::cout << " *** Inside the class fMethodname " << fMethodname << " fMVAType " << fMVAType << std::endl;
359  std::cout << " fbrem " << fMVAVar_fbrem << " kfchi2 " << fMVAVar_kfchi2 << " mykfhits " << fMVAVar_kfhits
360  << " gsfchi2 " << fMVAVar_gsfchi2 << " deta " << fMVAVar_deta << " dphi " << fMVAVar_dphi << " detacalo "
361  << fMVAVar_detacalo << " see " << fMVAVar_see << " spp " << fMVAVar_spp << " etawidth "
362  << fMVAVar_etawidth << " phiwidth " << fMVAVar_phiwidth << " OneMinusE1x5E5x5 "
363  << fMVAVar_OneMinusE1x5E5x5 << " R9 " << fMVAVar_R9 << " HoE " << fMVAVar_HoE << " EoP " << fMVAVar_EoP
364  << " IoEmIoP " << fMVAVar_IoEmIoP << " eleEoPout " << fMVAVar_eleEoPout << " d0 " << fMVAVar_d0
365  << " ip3d " << fMVAVar_ip3d << " eta " << fMVAVar_eta << " pt " << fMVAVar_pt << std::endl;
366  std::cout << " ### MVA " << mva << std::endl;
367  }
368 
369  return mva;
370 }
371 
372 Double_t EGammaMvaEleEstimatorCSA14::mvaValue(const pat::Electron &ele, bool printDebug) {
373  if (!fisInitialized) {
374  std::cout << "Error: EGammaMvaEleEstimatorCSA14 not properly initialized.\n";
375  return -9999;
376  }
377 
378  if ((fMVAType != EGammaMvaEleEstimatorCSA14::kTrig) && (fMVAType != EGammaMvaEleEstimatorCSA14::kNonTrig) &&
379  (fMVAType != EGammaMvaEleEstimatorCSA14::kNonTrigPhys14)) {
380  std::cout << "Error: This method should be called for kTrig or kNonTrig or kNonTrigPhys14 MVA only" << std::endl;
381  return -9999;
382  }
383 
384  bool validKF = false;
385  reco::TrackRef myTrackRef = ele.closestCtfTrackRef();
386  validKF = (myTrackRef.isAvailable());
387  validKF &= (myTrackRef.isNonnull());
388 
389  // Pure tracking variables
390  fMVAVar_fbrem = ele.fbrem();
391  fMVAVar_kfchi2 = (validKF) ? myTrackRef->normalizedChi2() : 0;
392  fMVAVar_kfhits = (validKF) ? myTrackRef->hitPattern().trackerLayersWithMeasurement() : -1.;
393  fMVAVar_kfhitsall =
394  (validKF) ? myTrackRef->numberOfValidHits() : -1.; // save also this in your ntuple as possible alternative
395  fMVAVar_gsfchi2 = ele.gsfTrack()->normalizedChi2();
396 
397  // Geometrical matchings
398  fMVAVar_deta = ele.deltaEtaSuperClusterTrackAtVtx();
399  fMVAVar_dphi = ele.deltaPhiSuperClusterTrackAtVtx();
400  fMVAVar_detacalo = ele.deltaEtaSeedClusterTrackAtCalo();
401 
402  // Pure ECAL -> shower shapes
403  fMVAVar_see = ele.full5x5_sigmaIetaIeta(); //EleSigmaIEtaIEta
404  fMVAVar_spp = ele.full5x5_sigmaIphiIphi(); //EleSigmaIPhiIPhi
405 
406  fMVAVar_etawidth = ele.superCluster()->etaWidth();
407  fMVAVar_phiwidth = ele.superCluster()->phiWidth();
408  fMVAVar_OneMinusE1x5E5x5 = (ele.full5x5_e5x5()) != 0. ? 1. - (ele.full5x5_e1x5() / ele.full5x5_e5x5()) : -1.;
409  fMVAVar_R9 = ele.full5x5_r9();
410 
411  // Energy matching
412  fMVAVar_HoE = ele.hadronicOverEm();
413  fMVAVar_EoP = ele.eSuperClusterOverP();
414  fMVAVar_IoEmIoP = (1.0 / ele.ecalEnergy()) - (1.0 / ele.p()); // in the future to be changed with ele.gsfTrack()->p()
415  fMVAVar_eleEoPout = ele.eEleClusterOverPout();
416  fMVAVar_PreShowerOverRaw = ele.superCluster()->preshowerEnergy() / ele.superCluster()->rawEnergy();
417 
418  // Spectators
419  fMVAVar_eta = ele.superCluster()->eta();
420  fMVAVar_abseta = fabs(ele.superCluster()->eta());
421  fMVAVar_pt = ele.pt();
422  fMVAVar_isBarrel = (ele.superCluster()->eta() < 1.479);
423  fMVAVar_isEndcap = (ele.superCluster()->eta() > 1.479);
424  fMVAVar_SCeta = ele.superCluster()->eta();
425 
426  // evaluate
427  bindVariables();
428  Double_t mva = -9999;
429  if (fUseBinnedVersion) {
430  int bin = GetMVABin(fMVAVar_eta, fMVAVar_pt);
431  mva = fTMVAReader[bin]->EvaluateMVA(fTMVAMethod[bin]);
432  } else {
433  mva = fTMVAReader[0]->EvaluateMVA(fTMVAMethod[0]);
434  }
435 
436  if (printDebug) {
437  std::cout << " *** Inside the class fMethodname " << fMethodname << " fMVAType " << fMVAType << std::endl;
438  std::cout << " fbrem " << fMVAVar_fbrem << " kfchi2 " << fMVAVar_kfchi2 << " mykfhits " << fMVAVar_kfhits
439  << " gsfchi2 " << fMVAVar_gsfchi2 << " deta " << fMVAVar_deta << " dphi " << fMVAVar_dphi << " detacalo "
440  << fMVAVar_detacalo << " see " << fMVAVar_see << " spp " << fMVAVar_spp << " etawidth "
441  << fMVAVar_etawidth << " phiwidth " << fMVAVar_phiwidth << " OneMinusE1x5E5x5 "
442  << fMVAVar_OneMinusE1x5E5x5 << " R9 " << fMVAVar_R9 << " HoE " << fMVAVar_HoE << " EoP " << fMVAVar_EoP
443  << " IoEmIoP " << fMVAVar_IoEmIoP << " eleEoPout " << fMVAVar_eleEoPout << " eta " << fMVAVar_eta
444  << " pt " << fMVAVar_pt << std::endl;
445  std::cout << " ### MVA " << mva << std::endl;
446  }
447 
448  return mva;
449 }
450 
451 void EGammaMvaEleEstimatorCSA14::bindVariables() {
452  // this binding is needed for variables that sometime diverge.
453 
454  if (fMVAVar_fbrem < -1.)
455  fMVAVar_fbrem = -1.;
456 
457  fMVAVar_deta = fabs(fMVAVar_deta);
458  if (fMVAVar_deta > 0.06)
459  fMVAVar_deta = 0.06;
460 
461  fMVAVar_dphi = fabs(fMVAVar_dphi);
462  if (fMVAVar_dphi > 0.6)
463  fMVAVar_dphi = 0.6;
464 
465  if (fMVAVar_EoP > 20.)
466  fMVAVar_EoP = 20.;
467 
468  if (fMVAVar_eleEoPout > 20.)
469  fMVAVar_eleEoPout = 20.;
470 
471  fMVAVar_detacalo = fabs(fMVAVar_detacalo);
472  if (fMVAVar_detacalo > 0.2)
473  fMVAVar_detacalo = 0.2;
474 
475  if (fMVAVar_OneMinusE1x5E5x5 < -1.)
476  fMVAVar_OneMinusE1x5E5x5 = -1;
477 
478  if (fMVAVar_OneMinusE1x5E5x5 > 2.)
479  fMVAVar_OneMinusE1x5E5x5 = 2.;
480 
481  if (fMVAVar_R9 > 5)
482  fMVAVar_R9 = 5;
483 
484  if (fMVAVar_gsfchi2 > 200.)
485  fMVAVar_gsfchi2 = 200;
486 
487  if (fMVAVar_kfchi2 > 10.)
488  fMVAVar_kfchi2 = 10.;
489 
490  // Needed for a bug in CMSSW_420, fixed in more recent CMSSW versions
491 #ifndef STANDALONE
492  if (edm::isNotFinite(fMVAVar_spp))
493 #else
494  if (std::isnan(fMVAVar_spp))
495 #endif
496  fMVAVar_spp = 0.;
497 
498  return;
499 }
EcalClusterLazyToolsT::e3x3
float e3x3(const reco::BasicCluster &cluster) const
Definition: EcalClusterLazyTools.h:195
edm::Ref::isAvailable
bool isAvailable() const
Definition: Ref.h:537
EGammaMvaEleEstimatorCSA14::initialize
void initialize(std::string methodName, std::string weightsfile, EGammaMvaEleEstimatorCSA14::MVAType type)
Definition: EGammaMvaEleEstimatorCSA14.cc:25
reco::GsfElectron::closestCtfTrackRef
virtual TrackRef closestCtfTrackRef() const
Definition: GsfElectron.h:180
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
mps_fire.i
i
Definition: mps_fire.py:428
EGammaMvaEleEstimatorCSA14::fTMVAMethod
std::vector< TMVA::MethodBase * > fTMVAMethod
Definition: EGammaMvaEleEstimatorCSA14.h:71
DiDispStaMuonMonitor_cfi.pt
tuple pt
Definition: DiDispStaMuonMonitor_cfi.py:39
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
reco::GsfElectron::eSuperClusterOverP
float eSuperClusterOverP() const
Definition: GsfElectron.h:221
beam_dqm_sourceclient-live_cfg.mva
tuple mva
Definition: beam_dqm_sourceclient-live_cfg.py:132
reco::GsfElectron::full5x5_e5x5
float full5x5_e5x5() const
Definition: GsfElectron.h:475
edm::isNotFinite
constexpr bool isNotFinite(T x)
Definition: isFinite.h:9
reco::GsfElectron::full5x5_e1x5
float full5x5_e1x5() const
Definition: GsfElectron.h:473
pat::Electron::closestCtfTrackRef
reco::TrackRef closestCtfTrackRef() const override
override the reco::GsfElectron::closestCtfTrackRef method, to access the internal storage of the trac...
TransientTrackBuilder::build
reco::TransientTrack build(const reco::Track *p) const
Definition: TransientTrackBuilder.cc:20
IPTools::absoluteImpactParameter3D
std::pair< bool, Measurement1D > absoluteImpactParameter3D(const reco::TransientTrack &transientTrack, const reco::Vertex &vertex)
Definition: IPTools.cc:38
reco::GsfElectron::full5x5_sigmaIphiIphi
float full5x5_sigmaIphiIphi() const
Definition: GsfElectron.h:472
pat::Electron::gsfTrack
reco::GsfTrackRef gsfTrack() const override
override the reco::GsfElectron::gsfTrack method, to access the internal storage of the supercluster ...
pat::Electron::superCluster
reco::SuperClusterRef superCluster() const override
override the reco::GsfElectron::superCluster method, to access the internal storage of the superclust...
reco::GsfElectron::fbrem
float fbrem() const
Definition: GsfElectron.h:809
EGammaMvaEleEstimatorCSA14::mvaValue
Double_t mvaValue(const reco::GsfElectron &ele, const reco::Vertex &vertex, const TransientTrackBuilder &transientTrackBuilder, noZS::EcalClusterLazyTools myEcalCluster, bool printDebug=kFALSE)
Definition: EGammaMvaEleEstimatorCSA14.cc:251
type
type
Definition: SiPixelVCal_PayloadInspector.cc:39
cms::cuda::assert
assert(be >=bs)
edm::isFinite
constexpr bool isFinite(T x)
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:127
EGammaMvaEleEstimatorCSA14::fTMVAReader
std::vector< TMVA::Reader * > fTMVAReader
Definition: EGammaMvaEleEstimatorCSA14.h:70
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
reco::GsfElectron::full5x5_sigmaIetaIeta
float full5x5_sigmaIetaIeta() const
Definition: GsfElectron.h:471
reco::GsfElectron::gsfTrack
GsfTrackRef gsfTrack() const override
reference to a GsfTrack
Definition: GsfElectron.h:156
reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx
float deltaEtaSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:225
reco::LeafCandidate::p
double p() const final
magnitude of momentum vector
Definition: LeafCandidate.h:123
reco::GsfElectron::hadronicOverEm
float hadronicOverEm() const
Definition: GsfElectron.h:500
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx
float deltaPhiSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:228
EcalClusterLazyToolsT::e1x5
float e1x5(const reco::BasicCluster &cluster) const
Definition: EcalClusterLazyTools.h:183
reco::GsfElectron::eEleClusterOverPout
float eEleClusterOverPout() const
Definition: GsfElectron.h:224
SiPixelLorentzAngle_cfi.read
tuple read
Definition: SiPixelLorentzAngle_cfi.py:7
EcalClusterLazyToolsT::localCovariances
std::array< float, 3 > localCovariances(const reco::BasicCluster &cluster, float w0=EgammaLocalCovParamDefaults::kRelEnCut, const EcalPFRecHitThresholds *rhthresholds=nullptr, float multEB=0.0, float multEE=0.0) const
Definition: EcalClusterLazyTools.h:284
pat::Electron
Analysis-level electron class.
Definition: Electron.h:51
reco::GsfElectron::ecalEnergy
float ecalEnergy() const
Definition: GsfElectron.h:896
reco::GsfElectron::e5x5
float e5x5() const
Definition: GsfElectron.h:423
reco::GsfElectron::full5x5_r9
float full5x5_r9() const
Definition: GsfElectron.h:476
EGammaMvaEleEstimatorCSA14::GetMVABin
UInt_t GetMVABin(double eta, double pt) const
Definition: EGammaMvaEleEstimatorCSA14.cc:205
reco::GsfElectron::deltaEtaSeedClusterTrackAtCalo
float deltaEtaSeedClusterTrackAtCalo() const
Definition: GsfElectron.h:226
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:79
EcalClusterLazyToolsT::e5x5
float e5x5(const reco::BasicCluster &cluster) const
Definition: EcalClusterLazyTools.h:201
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:144
reco::GsfElectron::superCluster
SuperClusterRef superCluster() const override
reference to a SuperCluster
Definition: GsfElectron.h:155
SQLiteCheck_cfg.printDebug
tuple printDebug
Definition: SQLiteCheck_cfg.py:43
Generated for CMSSW Reference Manual by doxygen 1.8.5