CMS 3D CMS Logo
AntiElectronIDMVA6.cc
Go to the documentation of this file.
1 #include "RecoTauTag/RecoTau/interface/AntiElectronIDMVA6.h"
2 
3 #include "FWCore/Utilities/interface/Exception.h"
4 
5 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
6 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
7 #include "DataFormats/TrackReco/interface/Track.h"
8 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
9 #include "DataFormats/MuonReco/interface/Muon.h"
10 
11 #include "CondFormats/DataRecord/interface/GBRWrapperRcd.h"
12 #include "FWCore/Framework/interface/ESHandle.h"
13 
14 #include <TFile.h>
15 #include <array>
16 
17 using namespace antiElecIDMVA6_blocks;
18 
19 namespace {
20  const reco::Track* getTrackFromPFCand(const reco::PFCandidate* pfCandidate) {
21  const reco::Track* track = nullptr;
22  if (pfCandidate->trackRef().isNonnull())
23  track = pfCandidate->trackRef().get();
24  else if (pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->innerTrack().isNonnull())
25  track = pfCandidate->muonRef()->innerTrack().get();
26  else if (pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->globalTrack().isNonnull())
27  track = pfCandidate->muonRef()->globalTrack().get();
28  else if (pfCandidate->muonRef().isNonnull() && pfCandidate->muonRef()->outerTrack().isNonnull())
29  track = pfCandidate->muonRef()->outerTrack().get();
30  else if (pfCandidate->gsfTrackRef().isNonnull())
31  track = pfCandidate->gsfTrackRef().get();
32  return track;
33  }
34 } // namespace
35 
36 template <class TauType, class ElectronType>
37 AntiElectronIDMVA6<TauType, ElectronType>::AntiElectronIDMVA6(const edm::ParameterSet& cfg, edm::ConsumesCollector&& cc)
38  : isInitialized_(false),
39  mva_NoEleMatch_woGwoGSF_BL_(nullptr),
40  mva_NoEleMatch_wGwoGSF_BL_(nullptr),
41  mva_woGwGSF_BL_(nullptr),
42  mva_wGwGSF_BL_(nullptr),
43  mva_NoEleMatch_woGwoGSF_EC_(nullptr),
44  mva_NoEleMatch_wGwoGSF_EC_(nullptr),
45  mva_woGwGSF_EC_(nullptr),
46  mva_wGwGSF_EC_(nullptr),
47  mva_NoEleMatch_woGwoGSF_VFEC_(nullptr),
48  mva_NoEleMatch_wGwoGSF_VFEC_(nullptr),
49  mva_woGwGSF_VFEC_(nullptr),
50  mva_wGwGSF_VFEC_(nullptr),
51  isPhase2_(cfg.getParameter<bool>("isPhase2")),
52  positionAtECalEntrance_(PositionAtECalEntranceComputer(cc, isPhase2_)),
53  verbosity_(cfg.getParameter<int>("verbosity")) {
54  loadMVAfromDB_ = cfg.exists("loadMVAfromDB") ? cfg.getParameter<bool>("loadMVAfromDB") : false;
55  if (!loadMVAfromDB_) {
56  if (cfg.exists("inputFileName")) {
57  inputFileName_ = cfg.getParameter<edm::FileInPath>("inputFileName");
58  } else
59  throw cms::Exception("MVA input not defined")
60  << "Requested to load tau MVA input from ROOT file but no file provided in cfg file";
61  }
62 
63  mvaName_NoEleMatch_woGwoGSF_BL_ = cfg.getParameter<std::string>("mvaName_NoEleMatch_woGwoGSF_BL");
64  mvaName_NoEleMatch_wGwoGSF_BL_ = cfg.getParameter<std::string>("mvaName_NoEleMatch_wGwoGSF_BL");
65  mvaName_woGwGSF_BL_ = cfg.getParameter<std::string>("mvaName_woGwGSF_BL");
66  mvaName_wGwGSF_BL_ = cfg.getParameter<std::string>("mvaName_wGwGSF_BL");
67  mvaName_NoEleMatch_woGwoGSF_EC_ = cfg.getParameter<std::string>("mvaName_NoEleMatch_woGwoGSF_EC");
68  mvaName_NoEleMatch_wGwoGSF_EC_ = cfg.getParameter<std::string>("mvaName_NoEleMatch_wGwoGSF_EC");
69  mvaName_woGwGSF_EC_ = cfg.getParameter<std::string>("mvaName_woGwGSF_EC");
70  mvaName_wGwGSF_EC_ = cfg.getParameter<std::string>("mvaName_wGwGSF_EC");
71  if (isPhase2_) {
72  mvaName_NoEleMatch_woGwoGSF_VFEC_ = cfg.getParameter<std::string>("mvaName_NoEleMatch_woGwoGSF_VFEC");
73  mvaName_NoEleMatch_wGwoGSF_VFEC_ = cfg.getParameter<std::string>("mvaName_NoEleMatch_wGwoGSF_VFEC");
74  mvaName_woGwGSF_VFEC_ = cfg.getParameter<std::string>("mvaName_woGwGSF_VFEC");
75  mvaName_wGwGSF_VFEC_ = cfg.getParameter<std::string>("mvaName_wGwGSF_VFEC");
76  }
77  usePhiAtEcalEntranceExtrapolation_ = cfg.getParameter<bool>("usePhiAtEcalEntranceExtrapolation");
78 
79  if (!isPhase2_) {
80  var_NoEleMatch_woGwoGSF_Barrel_ = std::vector<float>(10);
81  var_NoEleMatch_wGwoGSF_Barrel_ = std::vector<float>(18);
82  var_woGwGSF_Barrel_ = std::vector<float>(24);
83  var_wGwGSF_Barrel_ = std::vector<float>(32);
84  var_NoEleMatch_woGwoGSF_Endcap_ = std::vector<float>(9);
85  var_NoEleMatch_wGwoGSF_Endcap_ = std::vector<float>(17);
86  var_woGwGSF_Endcap_ = std::vector<float>(23);
87  var_wGwGSF_Endcap_ = std::vector<float>(31);
88  } else {
89  var_NoEleMatch_woGwoGSF_Barrel_ = std::vector<float>(9);
90  var_NoEleMatch_wGwoGSF_Barrel_ = std::vector<float>(17);
91  var_woGwGSF_Barrel_ = std::vector<float>(27);
92  var_wGwGSF_Barrel_ = std::vector<float>(36);
93  var_NoEleMatch_woGwoGSF_Endcap_ = std::vector<float>(6);
94  var_NoEleMatch_wGwoGSF_Endcap_ = std::vector<float>(14);
95  var_woGwGSF_Endcap_ = std::vector<float>(31);
96  var_wGwGSF_Endcap_ = std::vector<float>(38);
97  var_NoEleMatch_woGwoGSF_VFEndcap_ = std::vector<float>(6);
98  var_NoEleMatch_wGwoGSF_VFEndcap_ = std::vector<float>(14);
99  var_woGwGSF_VFEndcap_ = std::vector<float>(32);
100  var_wGwGSF_VFEndcap_ = std::vector<float>(40);
101 
102  //MB: Tokens for additional inputs (HGCal EleID variables) only for Phase2 and reco::GsfElectrons
103  if (std::is_same<ElectronType, reco::GsfElectron>::value) {
104  for (const auto& inputTag : cfg.getParameter<std::vector<edm::InputTag>>("hgcalElectronIDs")) {
105  std::string elecIdLabel = "hgcElectronID:" + inputTag.instance();
106  electronIds_tokens_[elecIdLabel] = cc.consumes<edm::ValueMap<float>>(
107  inputTag); //MB: It assumes that instances are not empty and meaningful (as for userData in patElectrons)
108  electronIds_[elecIdLabel] = edm::Handle<edm::ValueMap<float>>();
109  }
110  }
111  }
112 }
113 
114 template <class TauType, class ElectronType>
115 AntiElectronIDMVA6<TauType, ElectronType>::~AntiElectronIDMVA6() {
116  if (!loadMVAfromDB_) {
117  delete mva_NoEleMatch_woGwoGSF_BL_;
118  delete mva_NoEleMatch_wGwoGSF_BL_;
119  delete mva_woGwGSF_BL_;
120  delete mva_wGwGSF_BL_;
121  delete mva_NoEleMatch_woGwoGSF_EC_;
122  delete mva_NoEleMatch_wGwoGSF_EC_;
123  delete mva_woGwGSF_EC_;
124  delete mva_wGwGSF_EC_;
125  if (isPhase2_) {
126  delete mva_NoEleMatch_woGwoGSF_VFEC_;
127  delete mva_NoEleMatch_wGwoGSF_VFEC_;
128  delete mva_woGwGSF_VFEC_;
129  delete mva_wGwGSF_VFEC_;
130  }
131  }
132 
133  for (std::vector<TFile*>::iterator it = inputFilesToDelete_.begin(); it != inputFilesToDelete_.end(); ++it) {
134  delete (*it);
135  }
136 }
137 
138 namespace {
139  const GBRForest* loadMVAfromFile(TFile* inputFile, const std::string& mvaName) {
140  const GBRForest* mva = (GBRForest*)inputFile->Get(mvaName.data());
141  if (mva == nullptr)
142  throw cms::Exception("PFRecoTauDiscriminationAgainstElectronMVA6::loadMVA")
143  << " Failed to load MVA = " << mvaName.data() << " from file "
144  << " !!\n";
145 
146  return mva;
147  }
148 
149  const GBRForest* loadMVAfromDB(const edm::EventSetup& es, const std::string& mvaName) {
150  edm::ESHandle<GBRForest> mva;
151  es.get<GBRWrapperRcd>().get(mvaName, mva);
152  return mva.product();
153  }
154 } // namespace
155 
156 template <class TauType, class ElectronType>
157 void AntiElectronIDMVA6<TauType, ElectronType>::beginEvent(const edm::Event& evt, const edm::EventSetup& es) {
158  if (!isInitialized_) {
159  if (loadMVAfromDB_) {
160  mva_NoEleMatch_woGwoGSF_BL_ = loadMVAfromDB(es, mvaName_NoEleMatch_woGwoGSF_BL_);
161  mva_NoEleMatch_wGwoGSF_BL_ = loadMVAfromDB(es, mvaName_NoEleMatch_wGwoGSF_BL_);
162  mva_woGwGSF_BL_ = loadMVAfromDB(es, mvaName_woGwGSF_BL_);
163  mva_wGwGSF_BL_ = loadMVAfromDB(es, mvaName_wGwGSF_BL_);
164  mva_NoEleMatch_woGwoGSF_EC_ = loadMVAfromDB(es, mvaName_NoEleMatch_woGwoGSF_EC_);
165  mva_NoEleMatch_wGwoGSF_EC_ = loadMVAfromDB(es, mvaName_NoEleMatch_wGwoGSF_EC_);
166  mva_woGwGSF_EC_ = loadMVAfromDB(es, mvaName_woGwGSF_EC_);
167  mva_wGwGSF_EC_ = loadMVAfromDB(es, mvaName_wGwGSF_EC_);
168  if (isPhase2_) {
169  mva_NoEleMatch_woGwoGSF_VFEC_ = loadMVAfromDB(es, mvaName_NoEleMatch_woGwoGSF_VFEC_);
170  mva_NoEleMatch_wGwoGSF_VFEC_ = loadMVAfromDB(es, mvaName_NoEleMatch_wGwoGSF_VFEC_);
171  mva_woGwGSF_VFEC_ = loadMVAfromDB(es, mvaName_woGwGSF_VFEC_);
172  mva_wGwGSF_VFEC_ = loadMVAfromDB(es, mvaName_wGwGSF_VFEC_);
173  }
174  } else {
175  if (inputFileName_.location() == edm::FileInPath::Unknown)
176  throw cms::Exception("PFRecoTauDiscriminationAgainstElectronMVA6::loadMVA")
177  << " Failed to find File = " << inputFileName_ << " !!\n";
178  TFile* inputFile = new TFile(inputFileName_.fullPath().data());
179 
180  mva_NoEleMatch_woGwoGSF_BL_ = loadMVAfromFile(inputFile, mvaName_NoEleMatch_woGwoGSF_BL_);
181  mva_NoEleMatch_wGwoGSF_BL_ = loadMVAfromFile(inputFile, mvaName_NoEleMatch_wGwoGSF_BL_);
182  mva_woGwGSF_BL_ = loadMVAfromFile(inputFile, mvaName_woGwGSF_BL_);
183  mva_wGwGSF_BL_ = loadMVAfromFile(inputFile, mvaName_wGwGSF_BL_);
184  mva_NoEleMatch_woGwoGSF_EC_ = loadMVAfromFile(inputFile, mvaName_NoEleMatch_woGwoGSF_EC_);
185  mva_NoEleMatch_wGwoGSF_EC_ = loadMVAfromFile(inputFile, mvaName_NoEleMatch_wGwoGSF_EC_);
186  mva_woGwGSF_EC_ = loadMVAfromFile(inputFile, mvaName_woGwGSF_EC_);
187  mva_wGwGSF_EC_ = loadMVAfromFile(inputFile, mvaName_wGwGSF_EC_);
188  if (isPhase2_) {
189  mva_NoEleMatch_woGwoGSF_VFEC_ = loadMVAfromFile(inputFile, mvaName_NoEleMatch_woGwoGSF_VFEC_);
190  mva_NoEleMatch_wGwoGSF_VFEC_ = loadMVAfromFile(inputFile, mvaName_NoEleMatch_wGwoGSF_VFEC_);
191  mva_woGwGSF_VFEC_ = loadMVAfromFile(inputFile, mvaName_woGwGSF_VFEC_);
192  mva_wGwGSF_VFEC_ = loadMVAfromFile(inputFile, mvaName_wGwGSF_VFEC_);
193  }
194  inputFilesToDelete_.push_back(inputFile);
195  }
196  isInitialized_ = true;
197  }
198  positionAtECalEntrance_.beginEvent(es);
199  //MB: Handle additional inputs (HGCal EleID variables) only for Phase2 and reco::GsfElectrons
200  if (isPhase2_ && std::is_same<ElectronType, reco::GsfElectron>::value) {
201  for (const auto& eId_token : electronIds_tokens_) {
202  electronIds_[eId_token.first] = evt.getHandle(eId_token.second);
203  }
204  }
205 }
206 
207 template <class TauType, class ElectronType>
208 double AntiElectronIDMVA6<TauType, ElectronType>::mvaValue(const TauVars& tauVars,
209  const TauGammaVecs& tauGammaVecs,
210  const ElecVars& elecVars) {
211  TauGammaMoms tauGammaMoms;
212  double sumPt = 0.;
213  double dEta2 = 0.;
214  double dPhi2 = 0.;
215  tauGammaMoms.signalPFGammaCandsIn = tauGammaVecs.gammasPtInSigCone.size();
216  for (size_t i = 0; i < tauGammaVecs.gammasPtInSigCone.size(); ++i) {
217  double pt_i = tauGammaVecs.gammasPtInSigCone[i];
218  double phi_i = tauGammaVecs.gammasdPhiInSigCone[i];
219  if (tauGammaVecs.gammasdPhiInSigCone[i] > M_PI)
220  phi_i = tauGammaVecs.gammasdPhiInSigCone[i] - 2 * M_PI;
221  else if (tauGammaVecs.gammasdPhiInSigCone[i] < -M_PI)
222  phi_i = tauGammaVecs.gammasdPhiInSigCone[i] + 2 * M_PI;
223  double eta_i = tauGammaVecs.gammasdEtaInSigCone[i];
224  sumPt += pt_i;
225  dEta2 += (pt_i * eta_i * eta_i);
226  dPhi2 += (pt_i * phi_i * phi_i);
227  }
228 
229  tauGammaMoms.gammaEnFracIn = -99.;
230  if (tauVars.pt > 0.) {
231  tauGammaMoms.gammaEnFracIn = sumPt / tauVars.pt;
232  }
233  if (sumPt > 0.) {
234  dEta2 /= sumPt;
235  dPhi2 /= sumPt;
236  }
237  tauGammaMoms.gammaEtaMomIn = std::sqrt(dEta2 * tauGammaMoms.gammaEnFracIn) * tauVars.pt;
238  tauGammaMoms.gammaPhiMomIn = std::sqrt(dPhi2 * tauGammaMoms.gammaEnFracIn) * tauVars.pt;
239 
240  sumPt = 0.;
241  dEta2 = 0.;
242  dPhi2 = 0.;
243  tauGammaMoms.signalPFGammaCandsOut = tauGammaVecs.gammasPtOutSigCone.size();
244  for (size_t i = 0; i < tauGammaVecs.gammasPtOutSigCone.size(); ++i) {
245  double pt_i = tauGammaVecs.gammasPtOutSigCone[i];
246  double phi_i = tauGammaVecs.gammasdPhiOutSigCone[i];
247  if (tauGammaVecs.gammasdPhiOutSigCone[i] > M_PI)
248  phi_i = tauGammaVecs.gammasdPhiOutSigCone[i] - 2 * M_PI;
249  else if (tauGammaVecs.gammasdPhiOutSigCone[i] < -M_PI)
250  phi_i = tauGammaVecs.gammasdPhiOutSigCone[i] + 2 * M_PI;
251  double eta_i = tauGammaVecs.gammasdEtaOutSigCone[i];
252  sumPt += pt_i;
253  dEta2 += (pt_i * eta_i * eta_i);
254  dPhi2 += (pt_i * phi_i * phi_i);
255  }
256 
257  tauGammaMoms.gammaEnFracOut = -99.;
258  if (tauVars.pt > 0.) {
259  tauGammaMoms.gammaEnFracOut = sumPt / tauVars.pt;
260  }
261  if (sumPt > 0.) {
262  dEta2 /= sumPt;
263  dPhi2 /= sumPt;
264  }
265  tauGammaMoms.gammaEtaMomOut = std::sqrt(dEta2 * tauGammaMoms.gammaEnFracOut) * tauVars.pt;
266  tauGammaMoms.gammaPhiMomOut = std::sqrt(dPhi2 * tauGammaMoms.gammaEnFracOut) * tauVars.pt;
267 
268  if (!isPhase2_) {
269  return mvaValue(tauVars, tauGammaMoms, elecVars);
270  } else {
271  return mvaValuePhase2(tauVars, tauGammaMoms, elecVars);
272  }
273 }
274 
275 template <class TauType, class ElectronType>
276 double AntiElectronIDMVA6<TauType, ElectronType>::mvaValue(const TauVars& tauVars,
277  const TauGammaMoms& tauGammaMoms,
278  const ElecVars& elecVars) {
279  if (!isInitialized_) {
280  throw cms::Exception("ClassNotInitialized") << " AntiElectronMVA6 not properly initialized !!\n";
281  }
282 
283  double mvaValue = -99.;
284 
285  float elecDeltaPinPoutOverPin = (elecVars.pIn > 0.0) ? (std::abs(elecVars.pIn - elecVars.pOut) / elecVars.pIn) : 1.0;
286  float elecEecalOverPout = (elecVars.pOut > 0.0) ? (elecVars.eEcal / elecVars.pOut) : 20.0;
287  float elecNumHitsDiffOverSum =
288  ((elecVars.gsfNumHits + elecVars.kfNumHits) > 0.0)
289  ? ((elecVars.gsfNumHits - elecVars.kfNumHits) / (elecVars.gsfNumHits + elecVars.kfNumHits))
290  : 1.0;
291 
292  if (deltaR(tauVars.etaAtEcalEntrance, tauVars.phi, elecVars.eta, elecVars.phi) > 0.3 &&
293  tauGammaMoms.signalPFGammaCandsIn == 0 && tauVars.hasGsf < 0.5) {
294  if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) {
295  var_NoEleMatch_woGwoGSF_Barrel_[0] = tauVars.etaAtEcalEntrance;
296  var_NoEleMatch_woGwoGSF_Barrel_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
297  var_NoEleMatch_woGwoGSF_Barrel_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
298  var_NoEleMatch_woGwoGSF_Barrel_[3] = std::log(std::max(1.f, tauVars.pt));
299  var_NoEleMatch_woGwoGSF_Barrel_[4] = tauVars.emFraction;
300  var_NoEleMatch_woGwoGSF_Barrel_[5] = tauVars.leadPFChargedHadrHoP;
301  var_NoEleMatch_woGwoGSF_Barrel_[6] = tauVars.leadPFChargedHadrEoP;
302  var_NoEleMatch_woGwoGSF_Barrel_[7] = tauVars.visMassIn;
303  var_NoEleMatch_woGwoGSF_Barrel_[8] = tauVars.dCrackEta;
304  var_NoEleMatch_woGwoGSF_Barrel_[9] = tauVars.dCrackPhi;
305  mvaValue = mva_NoEleMatch_woGwoGSF_BL_->GetClassifier(var_NoEleMatch_woGwoGSF_Barrel_.data());
306  } else {
307  var_NoEleMatch_woGwoGSF_Endcap_[0] = tauVars.etaAtEcalEntrance;
308  var_NoEleMatch_woGwoGSF_Endcap_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
309  var_NoEleMatch_woGwoGSF_Endcap_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
310  var_NoEleMatch_woGwoGSF_Endcap_[3] = std::log(std::max(1.f, tauVars.pt));
311  var_NoEleMatch_woGwoGSF_Endcap_[4] = tauVars.emFraction;
312  var_NoEleMatch_woGwoGSF_Endcap_[5] = tauVars.leadPFChargedHadrHoP;
313  var_NoEleMatch_woGwoGSF_Endcap_[6] = tauVars.leadPFChargedHadrEoP;
314  var_NoEleMatch_woGwoGSF_Endcap_[7] = tauVars.visMassIn;
315  var_NoEleMatch_woGwoGSF_Endcap_[8] = tauVars.dCrackEta;
316  mvaValue = mva_NoEleMatch_woGwoGSF_EC_->GetClassifier(var_NoEleMatch_woGwoGSF_Endcap_.data());
317  }
318  } else if (deltaR(tauVars.etaAtEcalEntrance, tauVars.phi, elecVars.eta, elecVars.phi) > 0.3 &&
319  tauGammaMoms.signalPFGammaCandsIn > 0 && tauVars.hasGsf < 0.5) {
320  if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) {
321  var_NoEleMatch_wGwoGSF_Barrel_[0] = tauVars.etaAtEcalEntrance;
322  var_NoEleMatch_wGwoGSF_Barrel_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
323  var_NoEleMatch_wGwoGSF_Barrel_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
324  var_NoEleMatch_wGwoGSF_Barrel_[3] = std::log(std::max(1.f, tauVars.pt));
325  var_NoEleMatch_wGwoGSF_Barrel_[4] = tauVars.emFraction;
326  var_NoEleMatch_wGwoGSF_Barrel_[5] = tauGammaMoms.signalPFGammaCandsIn;
327  var_NoEleMatch_wGwoGSF_Barrel_[6] = tauGammaMoms.signalPFGammaCandsOut;
328  var_NoEleMatch_wGwoGSF_Barrel_[7] = tauVars.leadPFChargedHadrHoP;
329  var_NoEleMatch_wGwoGSF_Barrel_[8] = tauVars.leadPFChargedHadrEoP;
330  var_NoEleMatch_wGwoGSF_Barrel_[9] = tauVars.visMassIn;
331  var_NoEleMatch_wGwoGSF_Barrel_[10] = tauGammaMoms.gammaEtaMomIn;
332  var_NoEleMatch_wGwoGSF_Barrel_[11] = tauGammaMoms.gammaEtaMomOut;
333  var_NoEleMatch_wGwoGSF_Barrel_[12] = tauGammaMoms.gammaPhiMomIn;
334  var_NoEleMatch_wGwoGSF_Barrel_[13] = tauGammaMoms.gammaPhiMomOut;
335  var_NoEleMatch_wGwoGSF_Barrel_[14] = tauGammaMoms.gammaEnFracIn;
336  var_NoEleMatch_wGwoGSF_Barrel_[15] = tauGammaMoms.gammaEnFracOut;
337  var_NoEleMatch_wGwoGSF_Barrel_[16] = tauVars.dCrackEta;
338  var_NoEleMatch_wGwoGSF_Barrel_[17] = tauVars.dCrackPhi;
339  mvaValue = mva_NoEleMatch_wGwoGSF_BL_->GetClassifier(var_NoEleMatch_wGwoGSF_Barrel_.data());
340  } else {
341  var_NoEleMatch_wGwoGSF_Endcap_[0] = tauVars.etaAtEcalEntrance;
342  var_NoEleMatch_wGwoGSF_Endcap_[1] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
343  var_NoEleMatch_wGwoGSF_Endcap_[2] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
344  var_NoEleMatch_wGwoGSF_Endcap_[3] = std::log(std::max(1.f, tauVars.pt));
345  var_NoEleMatch_wGwoGSF_Endcap_[4] = tauVars.emFraction;
346  var_NoEleMatch_wGwoGSF_Endcap_[5] = tauGammaMoms.signalPFGammaCandsIn;
347  var_NoEleMatch_wGwoGSF_Endcap_[6] = tauGammaMoms.signalPFGammaCandsOut;
348  var_NoEleMatch_wGwoGSF_Endcap_[7] = tauVars.leadPFChargedHadrHoP;
349  var_NoEleMatch_wGwoGSF_Endcap_[8] = tauVars.leadPFChargedHadrEoP;
350  var_NoEleMatch_wGwoGSF_Endcap_[9] = tauVars.visMassIn;
351  var_NoEleMatch_wGwoGSF_Endcap_[10] = tauGammaMoms.gammaEtaMomIn;
352  var_NoEleMatch_wGwoGSF_Endcap_[11] = tauGammaMoms.gammaEtaMomOut;
353  var_NoEleMatch_wGwoGSF_Endcap_[12] = tauGammaMoms.gammaPhiMomIn;
354  var_NoEleMatch_wGwoGSF_Endcap_[13] = tauGammaMoms.gammaPhiMomOut;
355  var_NoEleMatch_wGwoGSF_Endcap_[14] = tauGammaMoms.gammaEnFracIn;
356  var_NoEleMatch_wGwoGSF_Endcap_[15] = tauGammaMoms.gammaEnFracOut;
357  var_NoEleMatch_wGwoGSF_Endcap_[16] = tauVars.dCrackEta;
358  mvaValue = mva_NoEleMatch_wGwoGSF_EC_->GetClassifier(var_NoEleMatch_wGwoGSF_Endcap_.data());
359  }
360  } else if (tauGammaMoms.signalPFGammaCandsIn == 0 && tauVars.hasGsf > 0.5) {
361  if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) {
362  var_woGwGSF_Barrel_[0] = std::max(-0.1f, elecVars.eTotOverPin);
363  var_woGwGSF_Barrel_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF));
364  var_woGwGSF_Barrel_[2] = elecVars.gsfNumHits;
365  var_woGwGSF_Barrel_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol));
366  var_woGwGSF_Barrel_[4] = elecVars.gsfTracklnPt;
367  var_woGwGSF_Barrel_[5] = elecNumHitsDiffOverSum;
368  var_woGwGSF_Barrel_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF));
369  var_woGwGSF_Barrel_[7] = std::min(elecDeltaPinPoutOverPin, 1.f);
370  var_woGwGSF_Barrel_[8] = std::min(elecEecalOverPout, 20.f);
371  var_woGwGSF_Barrel_[9] = elecVars.deltaEta;
372  var_woGwGSF_Barrel_[10] = elecVars.deltaPhi;
373  var_woGwGSF_Barrel_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f);
374  var_woGwGSF_Barrel_[12] = std::min(elecVars.mvaInHadEnergy, 20.f);
375  var_woGwGSF_Barrel_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f);
376  var_woGwGSF_Barrel_[14] = tauVars.etaAtEcalEntrance;
377  var_woGwGSF_Barrel_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
378  var_woGwGSF_Barrel_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
379  var_woGwGSF_Barrel_[17] = std::log(std::max(1.f, tauVars.pt));
380  var_woGwGSF_Barrel_[18] = tauVars.emFraction;
381  var_woGwGSF_Barrel_[19] = tauVars.leadPFChargedHadrHoP;
382  var_woGwGSF_Barrel_[20] = tauVars.leadPFChargedHadrEoP;
383  var_woGwGSF_Barrel_[21] = tauVars.visMassIn;
384  var_woGwGSF_Barrel_[22] = tauVars.dCrackEta;
385  var_woGwGSF_Barrel_[23] = tauVars.dCrackPhi;
386  mvaValue = mva_woGwGSF_BL_->GetClassifier(var_woGwGSF_Barrel_.data());
387  } else {
388  var_woGwGSF_Endcap_[0] = std::max(-0.1f, elecVars.eTotOverPin);
389  var_woGwGSF_Endcap_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF));
390  var_woGwGSF_Endcap_[2] = elecVars.gsfNumHits;
391  var_woGwGSF_Endcap_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol));
392  var_woGwGSF_Endcap_[4] = elecVars.gsfTracklnPt;
393  var_woGwGSF_Endcap_[5] = elecNumHitsDiffOverSum;
394  var_woGwGSF_Endcap_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF));
395  var_woGwGSF_Endcap_[7] = std::min(elecDeltaPinPoutOverPin, 1.f);
396  var_woGwGSF_Endcap_[8] = std::min(elecEecalOverPout, 20.f);
397  var_woGwGSF_Endcap_[9] = elecVars.deltaEta;
398  var_woGwGSF_Endcap_[10] = elecVars.deltaPhi;
399  var_woGwGSF_Endcap_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f);
400  var_woGwGSF_Endcap_[12] = std::min(elecVars.mvaInHadEnergy, 20.f);
401  var_woGwGSF_Endcap_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f);
402  var_woGwGSF_Endcap_[14] = tauVars.etaAtEcalEntrance;
403  var_woGwGSF_Endcap_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
404  var_woGwGSF_Endcap_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
405  var_woGwGSF_Endcap_[17] = std::log(std::max(1.f, tauVars.pt));
406  var_woGwGSF_Endcap_[18] = tauVars.emFraction;
407  var_woGwGSF_Endcap_[19] = tauVars.leadPFChargedHadrHoP;
408  var_woGwGSF_Endcap_[20] = tauVars.leadPFChargedHadrEoP;
409  var_woGwGSF_Endcap_[21] = tauVars.visMassIn;
410  var_woGwGSF_Endcap_[22] = tauVars.dCrackEta;
411  mvaValue = mva_woGwGSF_EC_->GetClassifier(var_woGwGSF_Endcap_.data());
412  }
413  } else if (tauGammaMoms.signalPFGammaCandsIn > 0 && tauVars.hasGsf > 0.5) {
414  if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) {
415  var_wGwGSF_Barrel_[0] = std::max(-0.1f, elecVars.eTotOverPin);
416  var_wGwGSF_Barrel_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF));
417  var_wGwGSF_Barrel_[2] = elecVars.gsfNumHits;
418  var_wGwGSF_Barrel_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol));
419  var_wGwGSF_Barrel_[4] = elecVars.gsfTracklnPt;
420  var_wGwGSF_Barrel_[5] = elecNumHitsDiffOverSum;
421  var_wGwGSF_Barrel_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF));
422  var_wGwGSF_Barrel_[7] = std::min(elecDeltaPinPoutOverPin, 1.f);
423  var_wGwGSF_Barrel_[8] = std::min(elecEecalOverPout, 20.f);
424  var_wGwGSF_Barrel_[9] = elecVars.deltaEta;
425  var_wGwGSF_Barrel_[10] = elecVars.deltaPhi;
426  var_wGwGSF_Barrel_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f);
427  var_wGwGSF_Barrel_[12] = std::min(elecVars.mvaInHadEnergy, 20.f);
428  var_wGwGSF_Barrel_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f);
429  var_wGwGSF_Barrel_[14] = tauVars.etaAtEcalEntrance;
430  var_wGwGSF_Barrel_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
431  var_wGwGSF_Barrel_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
432  var_wGwGSF_Barrel_[17] = std::log(std::max(1.f, tauVars.pt));
433  var_wGwGSF_Barrel_[18] = tauVars.emFraction;
434  var_wGwGSF_Barrel_[19] = tauGammaMoms.signalPFGammaCandsIn;
435  var_wGwGSF_Barrel_[20] = tauGammaMoms.signalPFGammaCandsOut;
436  var_wGwGSF_Barrel_[21] = tauVars.leadPFChargedHadrHoP;
437  var_wGwGSF_Barrel_[22] = tauVars.leadPFChargedHadrEoP;
438  var_wGwGSF_Barrel_[23] = tauVars.visMassIn;
439  var_wGwGSF_Barrel_[24] = tauGammaMoms.gammaEtaMomIn;
440  var_wGwGSF_Barrel_[25] = tauGammaMoms.gammaEtaMomOut;
441  var_wGwGSF_Barrel_[26] = tauGammaMoms.gammaPhiMomIn;
442  var_wGwGSF_Barrel_[27] = tauGammaMoms.gammaPhiMomOut;
443  var_wGwGSF_Barrel_[28] = tauGammaMoms.gammaEnFracIn;
444  var_wGwGSF_Barrel_[29] = tauGammaMoms.gammaEnFracOut;
445  var_wGwGSF_Barrel_[30] = tauVars.dCrackEta;
446  var_wGwGSF_Barrel_[31] = tauVars.dCrackPhi;
447  mvaValue = mva_wGwGSF_BL_->GetClassifier(var_wGwGSF_Barrel_.data());
448  } else {
449  var_wGwGSF_Endcap_[0] = std::max(-0.1f, elecVars.eTotOverPin);
450  var_wGwGSF_Endcap_[1] = std::log(std::max(0.01f, elecVars.chi2NormGSF));
451  var_wGwGSF_Endcap_[2] = elecVars.gsfNumHits;
452  var_wGwGSF_Endcap_[3] = std::log(std::max(0.01f, elecVars.gsfTrackResol));
453  var_wGwGSF_Endcap_[4] = elecVars.gsfTracklnPt;
454  var_wGwGSF_Endcap_[5] = elecNumHitsDiffOverSum;
455  var_wGwGSF_Endcap_[6] = std::log(std::max(0.01f, elecVars.chi2NormKF));
456  var_wGwGSF_Endcap_[7] = std::min(elecDeltaPinPoutOverPin, 1.f);
457  var_wGwGSF_Endcap_[8] = std::min(elecEecalOverPout, 20.f);
458  var_wGwGSF_Endcap_[9] = elecVars.deltaEta;
459  var_wGwGSF_Endcap_[10] = elecVars.deltaPhi;
460  var_wGwGSF_Endcap_[11] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f);
461  var_wGwGSF_Endcap_[12] = std::min(elecVars.mvaInHadEnergy, 20.f);
462  var_wGwGSF_Endcap_[13] = std::min(elecVars.mvaInDeltaEta, 0.1f);
463  var_wGwGSF_Endcap_[14] = tauVars.etaAtEcalEntrance;
464  var_wGwGSF_Endcap_[15] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
465  var_wGwGSF_Endcap_[16] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
466  var_wGwGSF_Endcap_[17] = std::log(std::max(1.f, tauVars.pt));
467  var_wGwGSF_Endcap_[18] = tauVars.emFraction;
468  var_wGwGSF_Endcap_[19] = tauGammaMoms.signalPFGammaCandsIn;
469  var_wGwGSF_Endcap_[20] = tauGammaMoms.signalPFGammaCandsOut;
470  var_wGwGSF_Endcap_[21] = tauVars.leadPFChargedHadrHoP;
471  var_wGwGSF_Endcap_[22] = tauVars.leadPFChargedHadrEoP;
472  var_wGwGSF_Endcap_[23] = tauVars.visMassIn;
473  var_wGwGSF_Endcap_[24] = tauGammaMoms.gammaEtaMomIn;
474  var_wGwGSF_Endcap_[25] = tauGammaMoms.gammaEtaMomOut;
475  var_wGwGSF_Endcap_[26] = tauGammaMoms.gammaPhiMomIn;
476  var_wGwGSF_Endcap_[27] = tauGammaMoms.gammaPhiMomOut;
477  var_wGwGSF_Endcap_[28] = tauGammaMoms.gammaEnFracIn;
478  var_wGwGSF_Endcap_[29] = tauGammaMoms.gammaEnFracOut;
479  var_wGwGSF_Endcap_[30] = tauVars.dCrackEta;
480  mvaValue = mva_wGwGSF_EC_->GetClassifier(var_wGwGSF_Endcap_.data());
481  }
482  }
483  return mvaValue;
484 }
486 template <class TauType, class ElectronType>
487 double AntiElectronIDMVA6<TauType, ElectronType>::mvaValuePhase2(const TauVars& tauVars,
488  const TauGammaMoms& tauGammaMoms,
489  const ElecVars& elecVars) {
490  if (!isInitialized_) {
491  throw cms::Exception("ClassNotInitialized") << " AntiElectronMVA6 not properly initialized !!\n";
492  }
493 
494  double mvaValue = -99.;
495 
496  //do not consider tau candidates outside the HGCal border at |eta|=3
497  if (std::abs(tauVars.etaAtEcalEntrance) > 3.0) {
498  return mvaValue;
499  }
500 
501  float elecDeltaPinPoutOverPin = (elecVars.pIn > 0.0) ? (std::abs(elecVars.pIn - elecVars.pOut) / elecVars.pIn) : 1.0;
502  float elecEecalOverPout = (elecVars.pOut > 0.0) ? (elecVars.eEcal / elecVars.pOut) : 20.0;
503  float elecNumHitsDiffOverSum =
504  ((elecVars.gsfNumHits + elecVars.kfNumHits) > 0.0)
505  ? ((elecVars.gsfNumHits - elecVars.kfNumHits) / (elecVars.gsfNumHits + elecVars.kfNumHits))
506  : 1.0;
507 
508  if (tauGammaMoms.signalPFGammaCandsIn == 0 && tauVars.hasGsf < 0.5) {
509  if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) {
510  var_NoEleMatch_woGwoGSF_Barrel_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
511  var_NoEleMatch_woGwoGSF_Barrel_[1] = std::log(std::max(1.f, tauVars.pt));
512  var_NoEleMatch_woGwoGSF_Barrel_[2] = tauVars.emFraction;
513  var_NoEleMatch_woGwoGSF_Barrel_[3] = tauVars.leadPFChargedHadrHoP;
514  var_NoEleMatch_woGwoGSF_Barrel_[4] = tauVars.leadPFChargedHadrEoP;
515  var_NoEleMatch_woGwoGSF_Barrel_[5] = tauVars.visMassIn;
516  var_NoEleMatch_woGwoGSF_Barrel_[6] = tauVars.dCrackEta;
517  var_NoEleMatch_woGwoGSF_Barrel_[7] = tauVars.etaAtEcalEntrance;
518  var_NoEleMatch_woGwoGSF_Barrel_[8] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
519  mvaValue = mva_NoEleMatch_woGwoGSF_BL_->GetClassifier(var_NoEleMatch_woGwoGSF_Barrel_.data());
520  } else if (std::abs(tauVars.etaAtEcalEntrance) < ecalEndcapVFEndcapEtaBorder_) {
521  var_NoEleMatch_woGwoGSF_Endcap_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
522  var_NoEleMatch_woGwoGSF_Endcap_[1] = std::log(std::max(1.f, tauVars.pt));
523  var_NoEleMatch_woGwoGSF_Endcap_[2] = tauVars.visMassIn;
524  var_NoEleMatch_woGwoGSF_Endcap_[3] = tauVars.dCrackEta;
525  var_NoEleMatch_woGwoGSF_Endcap_[4] = tauVars.etaAtEcalEntrance;
526  var_NoEleMatch_woGwoGSF_Endcap_[5] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
527  mvaValue = mva_NoEleMatch_woGwoGSF_EC_->GetClassifier(var_NoEleMatch_woGwoGSF_Endcap_.data());
528  } else {
529  var_NoEleMatch_woGwoGSF_VFEndcap_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
530  var_NoEleMatch_woGwoGSF_VFEndcap_[1] = std::log(std::max(1.f, tauVars.pt));
531  var_NoEleMatch_woGwoGSF_VFEndcap_[2] = tauVars.visMassIn;
532  var_NoEleMatch_woGwoGSF_VFEndcap_[3] = tauVars.dCrackEta;
533  var_NoEleMatch_woGwoGSF_VFEndcap_[4] = tauVars.etaAtEcalEntrance;
534  var_NoEleMatch_woGwoGSF_VFEndcap_[5] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
535  mvaValue = mva_NoEleMatch_woGwoGSF_VFEC_->GetClassifier(var_NoEleMatch_woGwoGSF_VFEndcap_.data());
536  }
537  } else if (tauGammaMoms.signalPFGammaCandsIn > 0 && tauVars.hasGsf < 0.5) {
538  if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) {
539  var_NoEleMatch_wGwoGSF_Barrel_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
540  var_NoEleMatch_wGwoGSF_Barrel_[1] = std::log(std::max(1.f, tauVars.pt));
541  var_NoEleMatch_wGwoGSF_Barrel_[2] = tauVars.emFraction;
542  var_NoEleMatch_wGwoGSF_Barrel_[3] = tauGammaMoms.signalPFGammaCandsIn;
543  var_NoEleMatch_wGwoGSF_Barrel_[4] = tauGammaMoms.signalPFGammaCandsOut;
544  var_NoEleMatch_wGwoGSF_Barrel_[5] = tauVars.leadPFChargedHadrHoP;
545  var_NoEleMatch_wGwoGSF_Barrel_[6] = tauVars.leadPFChargedHadrEoP;
546  var_NoEleMatch_wGwoGSF_Barrel_[7] = tauVars.visMassIn;
547  var_NoEleMatch_wGwoGSF_Barrel_[7] = tauGammaMoms.gammaEtaMomIn;
548  var_NoEleMatch_wGwoGSF_Barrel_[9] = tauGammaMoms.gammaEtaMomOut;
549  var_NoEleMatch_wGwoGSF_Barrel_[10] = tauGammaMoms.gammaPhiMomIn;
550  var_NoEleMatch_wGwoGSF_Barrel_[11] = tauGammaMoms.gammaPhiMomOut;
551  var_NoEleMatch_wGwoGSF_Barrel_[12] = tauGammaMoms.gammaEnFracIn;
552  var_NoEleMatch_wGwoGSF_Barrel_[13] = tauGammaMoms.gammaEnFracOut;
553  var_NoEleMatch_wGwoGSF_Barrel_[14] = tauVars.dCrackEta;
554  var_NoEleMatch_wGwoGSF_Barrel_[15] = tauVars.etaAtEcalEntrance;
555  var_NoEleMatch_wGwoGSF_Barrel_[16] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
556  mvaValue = mva_NoEleMatch_wGwoGSF_BL_->GetClassifier(var_NoEleMatch_wGwoGSF_Barrel_.data());
557  } else if (std::abs(tauVars.etaAtEcalEntrance) < ecalEndcapVFEndcapEtaBorder_) {
558  var_NoEleMatch_wGwoGSF_Endcap_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
559  var_NoEleMatch_wGwoGSF_Endcap_[1] = std::log(std::max(1.f, tauVars.pt));
560  var_NoEleMatch_wGwoGSF_Endcap_[2] = tauGammaMoms.signalPFGammaCandsIn;
561  var_NoEleMatch_wGwoGSF_Endcap_[3] = tauGammaMoms.signalPFGammaCandsOut;
562  var_NoEleMatch_wGwoGSF_Endcap_[4] = tauVars.visMassIn;
563  var_NoEleMatch_wGwoGSF_Endcap_[5] = tauGammaMoms.gammaEtaMomIn;
564  var_NoEleMatch_wGwoGSF_Endcap_[6] = tauGammaMoms.gammaEtaMomOut;
565  var_NoEleMatch_wGwoGSF_Endcap_[7] = tauGammaMoms.gammaPhiMomIn;
566  var_NoEleMatch_wGwoGSF_Endcap_[8] = tauGammaMoms.gammaPhiMomOut;
567  var_NoEleMatch_wGwoGSF_Endcap_[9] = tauGammaMoms.gammaEnFracIn;
568  var_NoEleMatch_wGwoGSF_Endcap_[10] = tauGammaMoms.gammaEnFracOut;
569  var_NoEleMatch_wGwoGSF_Endcap_[11] = tauVars.dCrackEta;
570  var_NoEleMatch_wGwoGSF_Endcap_[12] = tauVars.etaAtEcalEntrance;
571  var_NoEleMatch_wGwoGSF_Endcap_[13] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
572  mvaValue = mva_NoEleMatch_wGwoGSF_EC_->GetClassifier(var_NoEleMatch_wGwoGSF_Endcap_.data());
573  } else {
574  var_NoEleMatch_wGwoGSF_VFEndcap_[0] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
575  var_NoEleMatch_wGwoGSF_VFEndcap_[1] = std::log(std::max(1.f, tauVars.pt));
576  var_NoEleMatch_wGwoGSF_VFEndcap_[2] = tauGammaMoms.signalPFGammaCandsIn;
577  var_NoEleMatch_wGwoGSF_VFEndcap_[3] = tauGammaMoms.signalPFGammaCandsOut;
578  var_NoEleMatch_wGwoGSF_VFEndcap_[4] = tauVars.visMassIn;
579  var_NoEleMatch_wGwoGSF_VFEndcap_[5] = tauGammaMoms.gammaEtaMomIn;
580  var_NoEleMatch_wGwoGSF_VFEndcap_[6] = tauGammaMoms.gammaEtaMomOut;
581  var_NoEleMatch_wGwoGSF_VFEndcap_[7] = tauGammaMoms.gammaPhiMomIn;
582  var_NoEleMatch_wGwoGSF_VFEndcap_[8] = tauGammaMoms.gammaPhiMomOut;
583  var_NoEleMatch_wGwoGSF_VFEndcap_[9] = tauGammaMoms.gammaEnFracIn;
584  var_NoEleMatch_wGwoGSF_VFEndcap_[10] = tauGammaMoms.gammaEnFracOut;
585  var_NoEleMatch_wGwoGSF_VFEndcap_[11] = tauVars.dCrackEta;
586  var_NoEleMatch_wGwoGSF_VFEndcap_[12] = tauVars.etaAtEcalEntrance;
587  var_NoEleMatch_wGwoGSF_VFEndcap_[13] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
588  mvaValue = mva_NoEleMatch_wGwoGSF_VFEC_->GetClassifier(var_NoEleMatch_wGwoGSF_VFEndcap_.data());
589  }
590  } else if (tauGammaMoms.signalPFGammaCandsIn == 0 && tauVars.hasGsf > 0.5) {
591  if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) {
592  var_woGwGSF_Barrel_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF));
593  var_woGwGSF_Barrel_[1] = elecVars.gsfNumHits;
594  var_woGwGSF_Barrel_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol));
595  var_woGwGSF_Barrel_[3] = elecVars.gsfTracklnPt;
596  var_woGwGSF_Barrel_[4] = elecNumHitsDiffOverSum;
597  var_woGwGSF_Barrel_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF));
598  var_woGwGSF_Barrel_[6] = std::min(elecDeltaPinPoutOverPin, 1.f);
599  var_woGwGSF_Barrel_[7] = std::min(elecEecalOverPout, 20.f);
600  var_woGwGSF_Barrel_[8] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f);
601  var_woGwGSF_Barrel_[9] = std::min(elecVars.mvaInHadEnergy, 20.f);
602  var_woGwGSF_Barrel_[10] = std::min(elecVars.mvaInDeltaEta, 0.1f);
603  var_woGwGSF_Barrel_[11] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
604  var_woGwGSF_Barrel_[12] = std::log(std::max(1.f, tauVars.pt));
605  var_woGwGSF_Barrel_[13] = tauVars.emFraction;
606  var_woGwGSF_Barrel_[14] = tauVars.leadPFChargedHadrHoP;
607  var_woGwGSF_Barrel_[15] = tauVars.leadPFChargedHadrEoP;
608  var_woGwGSF_Barrel_[16] = tauVars.visMassIn;
609  var_woGwGSF_Barrel_[17] = tauVars.dCrackEta;
610  var_woGwGSF_Barrel_[18] = tauVars.etaAtEcalEntrance;
611  var_woGwGSF_Barrel_[19] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
612  var_woGwGSF_Barrel_[20] = elecVars.deltaEta;
613  var_woGwGSF_Barrel_[21] = elecVars.deltaPhi;
614  var_woGwGSF_Barrel_[22] = elecVars.sigmaIEtaIEta5x5;
615  var_woGwGSF_Barrel_[23] = elecVars.showerCircularity;
616  var_woGwGSF_Barrel_[24] = elecVars.r9;
617  var_woGwGSF_Barrel_[25] = elecVars.superClusterEtaWidth;
618  var_woGwGSF_Barrel_[26] = elecVars.superClusterPhiWidth;
619  mvaValue = mva_woGwGSF_BL_->GetClassifier(var_woGwGSF_Barrel_.data());
620  } else if (std::abs(tauVars.etaAtEcalEntrance) < ecalEndcapVFEndcapEtaBorder_) {
621  var_woGwGSF_Endcap_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF));
622  var_woGwGSF_Endcap_[1] = elecVars.gsfNumHits;
623  var_woGwGSF_Endcap_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol));
624  var_woGwGSF_Endcap_[3] = elecVars.gsfTracklnPt;
625  var_woGwGSF_Endcap_[4] = elecNumHitsDiffOverSum;
626  var_woGwGSF_Endcap_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF));
627  var_woGwGSF_Endcap_[6] = elecVars.eEcal;
628  var_woGwGSF_Endcap_[7] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
629  var_woGwGSF_Endcap_[8] = std::log(std::max(1.f, tauVars.pt));
630  var_woGwGSF_Endcap_[9] = tauVars.visMassIn;
631  var_woGwGSF_Endcap_[10] = tauVars.dCrackEta;
632  var_woGwGSF_Endcap_[11] = tauVars.etaAtEcalEntrance;
633  var_woGwGSF_Endcap_[12] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
634  var_woGwGSF_Endcap_[13] = elecVars.hgcalSigmaUU;
635  var_woGwGSF_Endcap_[14] = elecVars.hgcalSigmaVV;
636  var_woGwGSF_Endcap_[15] = elecVars.hgcalSigmaEE;
637  var_woGwGSF_Endcap_[16] = elecVars.hgcalSigmaPP;
638  var_woGwGSF_Endcap_[17] = elecVars.hgcalNLayers;
639  var_woGwGSF_Endcap_[18] = elecVars.hgcalLastLayer;
640  var_woGwGSF_Endcap_[19] = elecVars.hgcalLayerEfrac10;
641  var_woGwGSF_Endcap_[20] = elecVars.hgcalLayerEfrac90;
642  var_woGwGSF_Endcap_[21] = elecVars.hgcalEcEnergyEE;
643  var_woGwGSF_Endcap_[22] = elecVars.hgcalEcEnergyFH;
644  var_woGwGSF_Endcap_[23] = elecVars.hgcalMeasuredDepth;
645  var_woGwGSF_Endcap_[24] = elecVars.hgcalExpectedDepth;
646  var_woGwGSF_Endcap_[25] = elecVars.hgcalDepthCompatibility;
647  var_woGwGSF_Endcap_[26] = elecVars.deltaEta;
648  var_woGwGSF_Endcap_[27] = elecVars.deltaPhi;
649  var_woGwGSF_Endcap_[28] = elecVars.eSeedClusterOverPout;
650  var_woGwGSF_Endcap_[29] = elecVars.superClusterEtaWidth;
651  var_woGwGSF_Endcap_[30] = elecVars.superClusterPhiWidth;
652  mvaValue = mva_woGwGSF_EC_->GetClassifier(var_woGwGSF_Endcap_.data());
653  } else {
654  var_woGwGSF_VFEndcap_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF));
655  var_woGwGSF_VFEndcap_[1] = elecVars.gsfNumHits;
656  var_woGwGSF_VFEndcap_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol));
657  var_woGwGSF_VFEndcap_[3] = elecVars.gsfTracklnPt;
658  var_woGwGSF_VFEndcap_[4] = elecNumHitsDiffOverSum;
659  var_woGwGSF_VFEndcap_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF));
660  var_woGwGSF_VFEndcap_[6] = elecVars.eEcal;
661  var_woGwGSF_VFEndcap_[7] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
662  var_woGwGSF_VFEndcap_[8] = std::log(std::max(1.f, tauVars.pt));
663  var_woGwGSF_VFEndcap_[9] = tauVars.visMassIn;
664  var_woGwGSF_VFEndcap_[10] = tauVars.dCrackEta;
665  var_woGwGSF_VFEndcap_[11] = tauVars.etaAtEcalEntrance;
666  var_woGwGSF_VFEndcap_[12] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
667  var_woGwGSF_VFEndcap_[13] = elecVars.hgcalSigmaUU;
668  var_woGwGSF_VFEndcap_[14] = elecVars.hgcalSigmaVV;
669  var_woGwGSF_VFEndcap_[15] = elecVars.hgcalSigmaEE;
670  var_woGwGSF_VFEndcap_[16] = elecVars.hgcalSigmaPP;
671  var_woGwGSF_VFEndcap_[17] = elecVars.hgcalNLayers;
672  var_woGwGSF_VFEndcap_[18] = elecVars.hgcalLastLayer;
673  var_woGwGSF_VFEndcap_[19] = elecVars.hgcalLayerEfrac10;
674  var_woGwGSF_VFEndcap_[20] = elecVars.hgcalLayerEfrac90;
675  var_woGwGSF_VFEndcap_[21] = elecVars.hgcalEcEnergyEE;
676  var_woGwGSF_VFEndcap_[22] = elecVars.hgcalEcEnergyFH;
677  var_woGwGSF_VFEndcap_[23] = elecVars.hgcalMeasuredDepth;
678  var_woGwGSF_VFEndcap_[24] = elecVars.hgcalExpectedDepth;
679  var_woGwGSF_VFEndcap_[25] = elecVars.hgcalExpectedSigma;
680  var_woGwGSF_VFEndcap_[26] = elecVars.hgcalDepthCompatibility;
681  var_woGwGSF_VFEndcap_[27] = elecVars.deltaEta;
682  var_woGwGSF_VFEndcap_[28] = elecVars.deltaPhi;
683  var_woGwGSF_VFEndcap_[29] = elecVars.eSeedClusterOverPout;
684  var_woGwGSF_VFEndcap_[30] = elecVars.superClusterEtaWidth;
685  var_woGwGSF_VFEndcap_[31] = elecVars.superClusterPhiWidth;
686  mvaValue = mva_woGwGSF_VFEC_->GetClassifier(var_woGwGSF_VFEndcap_.data());
687  }
688  } else if (tauGammaMoms.signalPFGammaCandsIn > 0 && tauVars.hasGsf > 0.5) {
689  if (std::abs(tauVars.etaAtEcalEntrance) < ecalBarrelEndcapEtaBorder_) {
690  var_wGwGSF_Barrel_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF));
691  var_wGwGSF_Barrel_[1] = elecVars.gsfNumHits;
692  var_wGwGSF_Barrel_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol));
693  var_wGwGSF_Barrel_[3] = elecVars.gsfTracklnPt;
694  var_wGwGSF_Barrel_[4] = elecNumHitsDiffOverSum;
695  var_wGwGSF_Barrel_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF));
696  var_wGwGSF_Barrel_[6] = std::min(elecDeltaPinPoutOverPin, 1.f);
697  var_wGwGSF_Barrel_[7] = std::min(elecEecalOverPout, 20.f);
698  var_wGwGSF_Barrel_[8] = std::min(elecVars.mvaInSigmaEtaEta, 0.01f);
699  var_wGwGSF_Barrel_[9] = std::min(elecVars.mvaInHadEnergy, 20.f);
700  var_wGwGSF_Barrel_[10] = std::min(elecVars.mvaInDeltaEta, 0.1f);
701  var_wGwGSF_Barrel_[11] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
702  var_wGwGSF_Barrel_[12] = std::log(std::max(1.f, tauVars.pt));
703  var_wGwGSF_Barrel_[13] = tauVars.emFraction;
704  var_wGwGSF_Barrel_[14] = tauGammaMoms.signalPFGammaCandsIn;
705  var_wGwGSF_Barrel_[15] = tauGammaMoms.signalPFGammaCandsOut;
706  var_wGwGSF_Barrel_[16] = tauVars.leadPFChargedHadrHoP;
707  var_wGwGSF_Barrel_[17] = tauVars.leadPFChargedHadrEoP;
708  var_wGwGSF_Barrel_[18] = tauVars.visMassIn;
709  var_wGwGSF_Barrel_[19] = tauGammaMoms.gammaEtaMomIn;
710  var_wGwGSF_Barrel_[20] = tauGammaMoms.gammaEtaMomOut;
711  var_wGwGSF_Barrel_[21] = tauGammaMoms.gammaPhiMomIn;
712  var_wGwGSF_Barrel_[22] = tauGammaMoms.gammaPhiMomOut;
713  var_wGwGSF_Barrel_[23] = tauGammaMoms.gammaEnFracIn;
714  var_wGwGSF_Barrel_[24] = tauGammaMoms.gammaEnFracOut;
715  var_wGwGSF_Barrel_[25] = tauVars.dCrackEta;
716  var_wGwGSF_Barrel_[26] = tauVars.etaAtEcalEntrance;
717  var_wGwGSF_Barrel_[27] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
718  var_wGwGSF_Barrel_[28] = elecVars.deltaEta;
719  var_wGwGSF_Barrel_[29] = elecVars.deltaPhi;
720  var_wGwGSF_Barrel_[30] = elecVars.sigmaIPhiIPhi5x5;
721  var_wGwGSF_Barrel_[31] = elecVars.sigmaIEtaIEta5x5;
722  var_wGwGSF_Barrel_[32] = elecVars.showerCircularity;
723  var_wGwGSF_Barrel_[33] = elecVars.eSeedClusterOverPout;
724  var_wGwGSF_Barrel_[34] = elecVars.superClusterEtaWidth;
725  var_wGwGSF_Barrel_[35] = elecVars.superClusterPhiWidth;
726  mvaValue = mva_wGwGSF_BL_->GetClassifier(var_wGwGSF_Barrel_.data());
727  } else if (std::abs(tauVars.etaAtEcalEntrance) < ecalEndcapVFEndcapEtaBorder_) {
728  var_wGwGSF_Endcap_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF));
729  var_wGwGSF_Endcap_[1] = elecVars.gsfNumHits;
730  var_wGwGSF_Endcap_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol));
731  var_wGwGSF_Endcap_[3] = elecVars.gsfTracklnPt;
732  var_wGwGSF_Endcap_[4] = elecNumHitsDiffOverSum;
733  var_wGwGSF_Endcap_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF));
734  var_wGwGSF_Endcap_[6] = elecVars.eEcal;
735  var_wGwGSF_Endcap_[7] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
736  var_wGwGSF_Endcap_[8] = std::log(std::max(1.f, tauVars.pt));
737  var_wGwGSF_Endcap_[9] = tauGammaMoms.signalPFGammaCandsIn;
738  var_wGwGSF_Endcap_[10] = tauGammaMoms.signalPFGammaCandsOut;
739  var_wGwGSF_Endcap_[11] = tauVars.visMassIn;
740  var_wGwGSF_Endcap_[12] = tauGammaMoms.gammaEtaMomIn;
741  var_wGwGSF_Endcap_[13] = tauGammaMoms.gammaEtaMomOut;
742  var_wGwGSF_Endcap_[14] = tauGammaMoms.gammaPhiMomIn;
743  var_wGwGSF_Endcap_[15] = tauGammaMoms.gammaPhiMomOut;
744  var_wGwGSF_Endcap_[16] = tauGammaMoms.gammaEnFracIn;
745  var_wGwGSF_Endcap_[17] = tauGammaMoms.gammaEnFracOut;
746  var_wGwGSF_Endcap_[18] = tauVars.dCrackEta;
747  var_wGwGSF_Endcap_[19] = tauVars.etaAtEcalEntrance;
748  var_wGwGSF_Endcap_[20] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
749  var_wGwGSF_Endcap_[21] = elecVars.hgcalSigmaVV;
750  var_wGwGSF_Endcap_[22] = elecVars.hgcalSigmaEE;
751  var_wGwGSF_Endcap_[23] = elecVars.hgcalSigmaPP;
752  var_wGwGSF_Endcap_[24] = elecVars.hgcalNLayers;
753  var_wGwGSF_Endcap_[25] = elecVars.hgcalFirstLayer;
754  var_wGwGSF_Endcap_[26] = elecVars.hgcalLastLayer;
755  var_wGwGSF_Endcap_[27] = elecVars.hgcalLayerEfrac10;
756  var_wGwGSF_Endcap_[28] = elecVars.hgcalLayerEfrac90;
757  var_wGwGSF_Endcap_[29] = elecVars.hgcalEcEnergyEE;
758  var_wGwGSF_Endcap_[30] = elecVars.hgcalEcEnergyFH;
759  var_wGwGSF_Endcap_[31] = elecVars.hgcalMeasuredDepth;
760  var_wGwGSF_Endcap_[32] = elecVars.hgcalExpectedDepth;
761  var_wGwGSF_Endcap_[33] = elecVars.deltaEta;
762  var_wGwGSF_Endcap_[34] = elecVars.deltaPhi;
763  var_wGwGSF_Endcap_[35] = elecVars.eSeedClusterOverPout;
764  var_wGwGSF_Endcap_[36] = elecVars.superClusterEtaWidth;
765  var_wGwGSF_Endcap_[37] = elecVars.superClusterPhiWidth;
766  mvaValue = mva_wGwGSF_EC_->GetClassifier(var_wGwGSF_Endcap_.data());
767  } else {
768  var_wGwGSF_VFEndcap_[0] = std::log(std::max(0.1f, elecVars.chi2NormGSF));
769  var_wGwGSF_VFEndcap_[1] = elecVars.gsfNumHits;
770  var_wGwGSF_VFEndcap_[2] = std::log(std::max(0.1f, elecVars.gsfTrackResol));
771  var_wGwGSF_VFEndcap_[3] = elecVars.gsfTracklnPt;
772  var_wGwGSF_VFEndcap_[4] = elecNumHitsDiffOverSum;
773  var_wGwGSF_VFEndcap_[5] = std::log(std::max(0.1f, elecVars.chi2NormKF));
774  var_wGwGSF_VFEndcap_[6] = elecVars.eEcal;
775  var_wGwGSF_VFEndcap_[7] = std::min(2.f, tauVars.leadChargedPFCandPt / std::max(1.f, tauVars.pt));
776  var_wGwGSF_VFEndcap_[8] = std::log(std::max(1.f, tauVars.pt));
777  var_wGwGSF_VFEndcap_[9] = tauGammaMoms.signalPFGammaCandsIn;
778  var_wGwGSF_VFEndcap_[10] = tauGammaMoms.signalPFGammaCandsOut;
779  var_wGwGSF_VFEndcap_[11] = tauVars.visMassIn;
780  var_wGwGSF_VFEndcap_[12] = tauGammaMoms.gammaEtaMomIn;
781  var_wGwGSF_VFEndcap_[13] = tauGammaMoms.gammaEtaMomOut;
782  var_wGwGSF_VFEndcap_[14] = tauGammaMoms.gammaPhiMomIn;
783  var_wGwGSF_VFEndcap_[15] = tauGammaMoms.gammaPhiMomOut;
784  var_wGwGSF_VFEndcap_[16] = tauGammaMoms.gammaEnFracIn;
785  var_wGwGSF_VFEndcap_[17] = tauGammaMoms.gammaEnFracOut;
786  var_wGwGSF_VFEndcap_[18] = tauVars.dCrackEta;
787  var_wGwGSF_VFEndcap_[19] = tauVars.etaAtEcalEntrance;
788  var_wGwGSF_VFEndcap_[20] = tauVars.leadChargedPFCandEtaAtEcalEntrance;
789  var_wGwGSF_VFEndcap_[21] = elecVars.hgcalSigmaUU;
790  var_wGwGSF_VFEndcap_[22] = elecVars.hgcalSigmaVV;
791  var_wGwGSF_VFEndcap_[23] = elecVars.hgcalSigmaEE;
792  var_wGwGSF_VFEndcap_[24] = elecVars.hgcalSigmaPP;
793  var_wGwGSF_VFEndcap_[25] = elecVars.hgcalNLayers;
794  var_wGwGSF_VFEndcap_[26] = elecVars.hgcalLastLayer;
795  var_wGwGSF_VFEndcap_[27] = elecVars.hgcalLayerEfrac10;
796  var_wGwGSF_VFEndcap_[28] = elecVars.hgcalLayerEfrac90;
797  var_wGwGSF_VFEndcap_[29] = elecVars.hgcalEcEnergyEE;
798  var_wGwGSF_VFEndcap_[30] = elecVars.hgcalEcEnergyFH;
799  var_wGwGSF_VFEndcap_[31] = elecVars.hgcalMeasuredDepth;
800  var_wGwGSF_VFEndcap_[32] = elecVars.hgcalExpectedDepth;
801  var_wGwGSF_VFEndcap_[33] = elecVars.hgcalExpectedSigma;
802  var_wGwGSF_VFEndcap_[34] = elecVars.hgcalDepthCompatibility;
803  var_wGwGSF_VFEndcap_[35] = elecVars.deltaEta;
804  var_wGwGSF_VFEndcap_[36] = elecVars.deltaPhi;
805  var_wGwGSF_VFEndcap_[37] = elecVars.eSeedClusterOverPout;
806  var_wGwGSF_VFEndcap_[38] = elecVars.superClusterEtaWidth;
807  var_wGwGSF_VFEndcap_[39] = elecVars.superClusterPhiWidth;
808  mvaValue = mva_wGwGSF_VFEC_->GetClassifier(var_wGwGSF_VFEndcap_.data());
809  }
810  }
811  return mvaValue;
812 }
814 template <class TauType, class ElectronType>
815 double AntiElectronIDMVA6<TauType, ElectronType>::mvaValue(const TauType& theTau, const ElectronRef& theEleRef)
816 
817 {
818  // === tau variables ===
819  TauVars tauVars = AntiElectronIDMVA6<TauType, ElectronType>::getTauVars(theTau);
820  TauGammaVecs tauGammaVecs = AntiElectronIDMVA6<TauType, ElectronType>::getTauGammaVecs(theTau);
821 
822  // === electron variables ===
823  ElecVars elecVars = AntiElectronIDMVA6<TauType, ElectronType>::getElecVars(theEleRef);
824 
825  return mvaValue(tauVars, tauGammaVecs, elecVars);
826 }
827 
828 template <class TauType, class ElectronType>
829 double AntiElectronIDMVA6<TauType, ElectronType>::mvaValue(const TauType& theTau) {
830  // === tau variables ===
831  TauVars tauVars = AntiElectronIDMVA6<TauType, ElectronType>::getTauVars(theTau);
832  TauGammaVecs tauGammaVecs = AntiElectronIDMVA6<TauType, ElectronType>::getTauGammaVecs(theTau);
833 
834  // === electron variables ===
835  ElecVars elecVars;
836  elecVars.eta = 9.9; // Dummy value used in MVA training
837 
838  return mvaValue(tauVars, tauGammaVecs, elecVars);
839 }
840 
841 template <class TauType, class ElectronType>
842 TauVars AntiElectronIDMVA6<TauType, ElectronType>::getTauVars(const TauType& theTau) {
843  TauVars tauVars;
844  if (std::is_same<TauType, reco::PFTau>::value || std::is_same<TauType, pat::Tau>::value)
845  tauVars = getTauVarsTypeSpecific(theTau);
846  else
847  throw cms::Exception("AntiElectronIDMVA6")
848  << "Unsupported TauType used. You must use either reco::PFTau or pat::Tau.";
849 
850  tauVars.pt = theTau.pt();
851 
852  reco::Candidate::LorentzVector pfGammaSum(0, 0, 0, 0);
853  reco::Candidate::LorentzVector pfChargedSum(0, 0, 0, 0);
854  float signalrad = std::clamp(3.0 / std::max(1.0, theTau.pt()), 0.05, 0.10);
855  for (const auto& gamma : theTau.signalGammaCands()) {
856  float dR = deltaR(gamma->p4(), theTau.leadChargedHadrCand()->p4());
857  // pfGammas inside the tau signal cone
858  if (dR < signalrad) {
859  pfGammaSum += gamma->p4();
860  }
861  }
862  for (const auto& charged : theTau.signalChargedHadrCands()) {
863  float dR = deltaR(charged->p4(), theTau.leadChargedHadrCand()->p4());
864  // charged particles inside the tau signal cone
865  if (dR < signalrad) {
866  pfChargedSum += charged->p4();
867  }
868  }
869  tauVars.visMassIn = (pfGammaSum + pfChargedSum).mass();
870 
871  tauVars.hasGsf = 0;
872  if (theTau.leadChargedHadrCand().isNonnull()) {
873  const pat::PackedCandidate* packedLeadChCand =
874  dynamic_cast<const pat::PackedCandidate*>(theTau.leadChargedHadrCand().get());
875  if (packedLeadChCand != nullptr) {
876  if (std::abs(packedLeadChCand->pdgId()) == 11)
877  tauVars.hasGsf = 1;
878  } else {
879  const reco::PFCandidate* pfLeadChCand =
880  dynamic_cast<const reco::PFCandidate*>(theTau.leadChargedHadrCand().get());
881  if (pfLeadChCand != nullptr && pfLeadChCand->gsfTrackRef().isNonnull())
882  tauVars.hasGsf = 1;
883  }
884  }
885  tauVars.dCrackPhi = dCrackPhi(tauVars.phi, tauVars.etaAtEcalEntrance);
886  tauVars.dCrackEta = dCrackEta(tauVars.etaAtEcalEntrance);
887 
888  return tauVars;
889 }
890 
891 template <class TauType, class ElectronType>
892 TauGammaVecs AntiElectronIDMVA6<TauType, ElectronType>::getTauGammaVecs(const TauType& theTau) {
893  TauGammaVecs tauGammaVecs;
894 
895  float signalrad = std::clamp(3.0 / std::max(1.0, theTau.pt()), 0.05, 0.10);
896  for (const auto& gamma : theTau.signalGammaCands()) {
897  float dR = deltaR(gamma->p4(), theTau.leadChargedHadrCand()->p4());
898  // pfGammas inside the tau signal cone
899  if (dR < signalrad) {
900  tauGammaVecs.gammasdEtaInSigCone.push_back(gamma->eta() - theTau.leadChargedHadrCand()->eta());
901  tauGammaVecs.gammasdPhiInSigCone.push_back(gamma->phi() - theTau.leadChargedHadrCand()->phi());
902  tauGammaVecs.gammasPtInSigCone.push_back(gamma->pt());
903  }
904  // pfGammas outside the tau signal cone
905  else {
906  tauGammaVecs.gammasdEtaOutSigCone.push_back(gamma->eta() - theTau.leadChargedHadrCand()->eta());
907  tauGammaVecs.gammasdPhiOutSigCone.push_back(gamma->phi() - theTau.leadChargedHadrCand()->phi());
908  tauGammaVecs.gammasPtOutSigCone.push_back(gamma->pt());
909  }
910  }
911  return tauGammaVecs;
912 }
913 
914 template <class TauType, class ElectronType>
915 ElecVars AntiElectronIDMVA6<TauType, ElectronType>::getElecVars(const ElectronRef& theEleRef) {
916  ElecVars elecVars;
917 
918  elecVars.eta = theEleRef->eta();
919  elecVars.phi = theEleRef->phi();
920 
921  // Variables related to the electron Cluster
922  float elecEe = 0.;
923  float elecEgamma = 0.;
924  reco::SuperClusterRef pfSuperCluster = theEleRef->superCluster();
925  if (pfSuperCluster.isNonnull() && pfSuperCluster.isAvailable()) {
926  if (!isPhase2_) {
927  for (reco::CaloCluster_iterator pfCluster = pfSuperCluster->clustersBegin();
928  pfCluster != pfSuperCluster->clustersEnd();
929  ++pfCluster) {
930  double pfClusterEn = (*pfCluster)->energy();
931  if (pfCluster == pfSuperCluster->clustersBegin())
932  elecEe += pfClusterEn;
933  else
934  elecEgamma += pfClusterEn;
935  }
936  }
937  elecVars.superClusterEtaWidth = pfSuperCluster->etaWidth();
938  elecVars.superClusterPhiWidth = pfSuperCluster->phiWidth();
939  }
940  elecVars.eSeedClusterOverPout = theEleRef->eSeedClusterOverPout();
941  elecVars.showerCircularity = 1. - theEleRef->e1x5() / theEleRef->e5x5();
942  elecVars.r9 = theEleRef->r9();
943  elecVars.sigmaIEtaIEta5x5 = theEleRef->full5x5_sigmaIetaIeta();
944  elecVars.sigmaIPhiIPhi5x5 = theEleRef->full5x5_sigmaIphiIphi();
945 
946  elecVars.pIn = std::sqrt(theEleRef->trackMomentumAtVtx().Mag2());
947  elecVars.pOut = std::sqrt(theEleRef->trackMomentumOut().Mag2());
948  elecVars.eTotOverPin = (elecVars.pIn > 0.0) ? ((elecEe + elecEgamma) / elecVars.pIn) : -0.1;
949  elecVars.eEcal = theEleRef->ecalEnergy();
950  if (!isPhase2_) {
951  elecVars.deltaEta = theEleRef->deltaEtaSeedClusterTrackAtCalo();
952  elecVars.deltaPhi = theEleRef->deltaPhiSeedClusterTrackAtCalo();
953  } else {
954  elecVars.deltaEta = theEleRef->deltaEtaEleClusterTrackAtCalo();
955  elecVars.deltaPhi = theEleRef->deltaPhiEleClusterTrackAtCalo();
956  }
957  elecVars.mvaInSigmaEtaEta = theEleRef->mvaInput().sigmaEtaEta;
958  elecVars.mvaInHadEnergy = theEleRef->mvaInput().hadEnergy;
959  elecVars.mvaInDeltaEta = theEleRef->mvaInput().deltaEta;
960 
961  // Variables related to the GsfTrack
962  elecVars.chi2NormGSF = -99.;
963  elecVars.gsfNumHits = -99.;
964  elecVars.gsfTrackResol = -99.;
965  elecVars.gsfTracklnPt = -99.;
966  if (theEleRef->gsfTrack().isNonnull()) {
967  elecVars.chi2NormGSF = theEleRef->gsfTrack()->normalizedChi2();
968  elecVars.gsfNumHits = theEleRef->gsfTrack()->numberOfValidHits();
969  if (theEleRef->gsfTrack()->pt() > 0.) {
970  elecVars.gsfTrackResol = theEleRef->gsfTrack()->ptError() / theEleRef->gsfTrack()->pt();
971  elecVars.gsfTracklnPt = log(theEleRef->gsfTrack()->pt()) * M_LN10;
972  }
973  }
974 
975  // Variables related to the CtfTrack
976  elecVars.chi2NormKF = -99.;
977  elecVars.kfNumHits = -99.;
978  if (theEleRef->closestCtfTrackRef().isNonnull()) {
979  elecVars.chi2NormKF = theEleRef->closestCtfTrackRef()->normalizedChi2();
980  elecVars.kfNumHits = theEleRef->closestCtfTrackRef()->numberOfValidHits();
981  }
982 
983  // Variables related to HGCal
984  if (isPhase2_ && !theEleRef->isEB()) {
985  if (std::is_same<ElectronType, reco::GsfElectron>::value || std::is_same<ElectronType, pat::Electron>::value)
986  getElecVarsHGCalTypeSpecific(theEleRef, elecVars);
987  else
988  throw cms::Exception("AntiElectronIDMVA6")
989  << "Unsupported ElectronType used. You must use either reco::GsfElectron or pat::Electron.";
990  }
991 
992  return elecVars;
993 }
994 
995 template <class TauType, class ElectronType>
996 double AntiElectronIDMVA6<TauType, ElectronType>::minimum(double a, double b) {
997  if (std::abs(b) < std::abs(a))
998  return b;
999  else
1000  return a;
1001 }
1002 
1003 namespace {
1004 
1005  // IN: define locations of the 18 phi-cracks
1006  std::array<double, 18> fill_cPhi() {
1007  constexpr double pi = M_PI; // 3.14159265358979323846;
1008  std::array<double, 18> cPhi;
1009  // IN: define locations of the 18 phi-cracks
1010  cPhi[0] = 2.97025;
1011  for (unsigned iCrack = 1; iCrack <= 17; ++iCrack) {
1012  cPhi[iCrack] = cPhi[0] - 2. * iCrack * pi / 18;
1013  }
1014  return cPhi;
1015  }
1016 
1017  const std::array<double, 18> cPhi = fill_cPhi();
1018 
1019 } // namespace
1020 
1021 template <class TauType, class ElectronType>
1022 double AntiElectronIDMVA6<TauType, ElectronType>::dCrackPhi(double phi, double eta) {
1023  //--- compute the (unsigned) distance to the closest phi-crack in the ECAL barrel
1024 
1025  constexpr double pi = M_PI; // 3.14159265358979323846;
1026 
1027  // IN: shift of this location if eta < 0
1028  constexpr double delta_cPhi = 0.00638;
1029 
1030  double retVal = 99.;
1031 
1032  if (eta >= -1.47464 && eta <= 1.47464) {
1033  // the location is shifted
1034  if (eta < 0.)
1035  phi += delta_cPhi;
1036 
1037  // CV: need to bring-back phi into interval [-pi,+pi]
1038  if (phi > pi)
1039  phi -= 2. * pi;
1040  if (phi < -pi)
1041  phi += 2. * pi;
1042 
1043  if (phi >= -pi && phi <= pi) {
1044  // the problem of the extrema:
1045  if (phi < cPhi[17] || phi >= cPhi[0]) {
1046  if (phi < 0.)
1047  phi += 2. * pi;
1048  retVal = minimum(phi - cPhi[0], phi - cPhi[17] - 2. * pi);
1049  } else {
1050  // between these extrema...
1051  bool OK = false;
1052  unsigned iCrack = 16;
1053  while (!OK) {
1054  if (phi < cPhi[iCrack]) {
1055  retVal = minimum(phi - cPhi[iCrack + 1], phi - cPhi[iCrack]);
1056  OK = true;
1057  } else {
1058  iCrack -= 1;
1059  }
1060  }
1061  }
1062  } else {
1063  retVal = 0.; // IN: if there is a problem, we assume that we are in a crack
1064  }
1065  } else {
1066  return -99.;
1067  }
1068 
1069  return std::abs(retVal);
1070 }
1071 
1072 template <class TauType, class ElectronType>
1073 double AntiElectronIDMVA6<TauType, ElectronType>::dCrackEta(double eta) {
1074  //--- compute the (unsigned) distance to the closest eta-crack in the ECAL barrel
1075 
1076  // IN: define locations of the eta-cracks
1077  double cracks[5] = {0., 4.44747e-01, 7.92824e-01, 1.14090e+00, 1.47464e+00};
1078 
1079  double retVal = 99.;
1080 
1081  for (int iCrack = 0; iCrack < 5; ++iCrack) {
1082  double d = minimum(eta - cracks[iCrack], eta + cracks[iCrack]);
1083  if (std::abs(d) < std::abs(retVal)) {
1084  retVal = d;
1085  }
1086  }
1087 
1088  return std::abs(retVal);
1089 }
1090 
1091 // pat::Tau
1092 template <class TauType, class ElectronType>
1093 TauVars AntiElectronIDMVA6<TauType, ElectronType>::getTauVarsTypeSpecific(const pat::Tau& theTau) {
1094  TauVars tauVars;
1095  tauVars.etaAtEcalEntrance = theTau.etaAtEcalEntrance();
1096  tauVars.leadChargedPFCandEtaAtEcalEntrance = theTau.etaAtEcalEntranceLeadChargedCand();
1097  tauVars.leadChargedPFCandPt = theTau.ptLeadChargedCand();
1098  tauVars.phi = theTau.phi();
1099  if (!isPhase2_) {
1100  if (!usePhiAtEcalEntranceExtrapolation_) {
1101  tauVars.phi = theTau.phiAtEcalEntrance();
1102  } else {
1103  float etaAtECal = 0.;
1104  float phiAtECal = 0.;
1105  bool success = energyWeightedEtaAndPhiAtECal(theTau, etaAtECal, phiAtECal);
1106  if (success) {
1107  tauVars.phi = phiAtECal;
1108  }
1109  }
1110  tauVars.emFraction = std::max(theTau.emFraction_MVA(), 0.f);
1111  } else {
1112  if (std::abs(theTau.eta()) >= ecalBarrelEndcapEtaBorder_) { //HGCal
1113  tauVars.etaAtEcalEntrance = -99.;
1114  tauVars.leadChargedPFCandEtaAtEcalEntrance = -99.;
1115  bool success = false;
1116  reco::Candidate::Point posAtECal = positionAtECalEntrance_(theTau.leadChargedHadrCand().get(), success);
1117  if (success) {
1118  tauVars.leadChargedPFCandEtaAtEcalEntrance = posAtECal.eta();
1119  }
1120  float phiAtECal = 0.;
1121  float etaAtECal = 0.;
1122  success = energyWeightedEtaAndPhiAtECal(theTau, etaAtECal, phiAtECal);
1123  if (success) {
1124  tauVars.etaAtEcalEntrance = etaAtECal;
1125  }
1126  }
1127  tauVars.emFraction = std::max(theTau.ecalEnergyLeadChargedHadrCand() /
1128  (theTau.ecalEnergyLeadChargedHadrCand() + theTau.hcalEnergyLeadChargedHadrCand()),
1129  0.f);
1130  }
1131  tauVars.leadPFChargedHadrHoP = 0.;
1132  tauVars.leadPFChargedHadrEoP = 0.;
1133  if (theTau.leadChargedHadrCand()->p() > 0.) {
1134  tauVars.leadPFChargedHadrHoP = theTau.hcalEnergyLeadChargedHadrCand() / theTau.leadChargedHadrCand()->p();
1135  tauVars.leadPFChargedHadrEoP = theTau.ecalEnergyLeadChargedHadrCand() / theTau.leadChargedHadrCand()->p();
1136  }
1137 
1138  return tauVars;
1139 }
1140 
1141 // reco::PFTau
1142 template <class TauType, class ElectronType>
1143 TauVars AntiElectronIDMVA6<TauType, ElectronType>::getTauVarsTypeSpecific(const reco::PFTau& theTau) {
1144  TauVars tauVars;
1145  tauVars.etaAtEcalEntrance = -99.;
1146  tauVars.leadChargedPFCandEtaAtEcalEntrance = -99.;
1147  tauVars.leadChargedPFCandPt = -99.;
1148  float sumEtaTimesEnergy = 0.;
1149  float sumPhiTimesEnergy = 0.;
1150  float sumEnergy = 0.;
1151  tauVars.phi = theTau.phi();
1152  // Check type of candidates building tau to avoid dynamic casts further
1153  bool isFromPFCands =
1154  (theTau.leadCand().isNonnull() && dynamic_cast<const reco::PFCandidate*>(theTau.leadCand().get()) != nullptr);
1155  if (!isPhase2_) {
1156  for (const auto& candidate : theTau.signalCands()) {
1157  float etaAtECalEntrance = candidate->eta();
1158  float phiAtECalEntrance = candidate->phi();
1159  const reco::Track* track = nullptr;
1160  if (isFromPFCands) {
1161  const reco::PFCandidate* pfCandidate = static_cast<const reco::PFCandidate*>(candidate.get());
1162  etaAtECalEntrance = pfCandidate->positionAtECALEntrance().eta();
1163  if (!usePhiAtEcalEntranceExtrapolation_) {
1164  phiAtECalEntrance = pfCandidate->positionAtECALEntrance().phi();
1165  } else {
1166  bool success = false;
1167  reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success);
1168  if (success) {
1169  phiAtECalEntrance = posAtECal.phi();
1170  }
1171  }
1172  track = getTrackFromPFCand(pfCandidate);
1173  } else {
1174  bool success = false;
1175  reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success);
1176  if (success) {
1177  etaAtECalEntrance = posAtECal.eta();
1178  phiAtECalEntrance = posAtECal.phi();
1179  }
1180  track = candidate->bestTrack();
1181  }
1182  if (track != nullptr) {
1183  if (track->pt() > tauVars.leadChargedPFCandPt) {
1184  tauVars.leadChargedPFCandEtaAtEcalEntrance = etaAtECalEntrance;
1185  tauVars.leadChargedPFCandPt = track->pt();
1186  }
1187  }
1188  sumEtaTimesEnergy += etaAtECalEntrance * candidate->energy();
1189  sumPhiTimesEnergy += phiAtECalEntrance * candidate->energy();
1190  sumEnergy += candidate->energy();
1191  }
1192  if (sumEnergy > 0.) {
1193  tauVars.etaAtEcalEntrance = sumEtaTimesEnergy / sumEnergy;
1194  tauVars.phi = sumPhiTimesEnergy / sumEnergy;
1195  }
1196  tauVars.emFraction = std::max(theTau.emFraction(), 0.f);
1197  } else { // Phase2
1198  for (const auto& candidate : theTau.signalCands()) {
1199  float etaAtECalEntrance = candidate->eta();
1200  const reco::Track* track = nullptr;
1201  if (isFromPFCands) {
1202  const reco::PFCandidate* pfCandidate = static_cast<const reco::PFCandidate*>(candidate.get());
1203  etaAtECalEntrance = pfCandidate->positionAtECALEntrance().eta();
1204  if (std::abs(theTau.eta()) >= ecalBarrelEndcapEtaBorder_) { //HGCal
1205  bool success = false;
1206  reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success);
1207  if (success) {
1208  etaAtECalEntrance = posAtECal.eta();
1209  }
1210  }
1211  track = getTrackFromPFCand(pfCandidate);
1212  } else {
1213  bool success = false;
1214  reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success);
1215  if (success) {
1216  etaAtECalEntrance = posAtECal.eta();
1217  }
1218  track = candidate->bestTrack();
1219  }
1220  if (track != nullptr) {
1221  if (track->pt() > tauVars.leadChargedPFCandPt) {
1222  tauVars.leadChargedPFCandEtaAtEcalEntrance = etaAtECalEntrance;
1223  tauVars.leadChargedPFCandPt = track->pt();
1224  }
1225  }
1226  sumEtaTimesEnergy += etaAtECalEntrance * candidate->energy();
1227  sumEnergy += candidate->energy();
1228  }
1229  if (sumEnergy > 0.) {
1230  tauVars.etaAtEcalEntrance = sumEtaTimesEnergy / sumEnergy;
1231  }
1232  if (isFromPFCands) {
1233  const reco::PFCandidate* pfLeadCandidte =
1234  static_cast<const reco::PFCandidate*>(theTau.leadChargedHadrCand().get());
1235  tauVars.emFraction =
1236  std::max(pfLeadCandidte->ecalEnergy() / (pfLeadCandidte->ecalEnergy() + pfLeadCandidte->hcalEnergy()), 0.);
1237  } else {
1238  const pat::PackedCandidate* patLeadCandiate =
1239  dynamic_cast<const pat::PackedCandidate*>(theTau.leadChargedHadrCand().get());
1240  if (patLeadCandiate != nullptr) {
1241  tauVars.emFraction = std::max(1. - patLeadCandiate->hcalFraction(), 0.);
1242  }
1243  }
1244  }
1245  tauVars.leadPFChargedHadrHoP = 0.;
1246  tauVars.leadPFChargedHadrEoP = 0.;
1247  if (theTau.leadChargedHadrCand()->p() > 0.) {
1248  if (isFromPFCands) {
1249  const reco::PFCandidate* pfLeadCandiate =
1250  static_cast<const reco::PFCandidate*>(theTau.leadChargedHadrCand().get());
1251  tauVars.leadPFChargedHadrHoP = pfLeadCandiate->hcalEnergy() / pfLeadCandiate->p();
1252  tauVars.leadPFChargedHadrEoP = pfLeadCandiate->ecalEnergy() / pfLeadCandiate->p();
1253  } else {
1254  const pat::PackedCandidate* patLeadCandiate =
1255  dynamic_cast<const pat::PackedCandidate*>(theTau.leadChargedHadrCand().get());
1256  if (patLeadCandiate != nullptr) {
1257  tauVars.leadPFChargedHadrHoP = patLeadCandiate->caloFraction() * patLeadCandiate->energy() *
1258  patLeadCandiate->hcalFraction() / patLeadCandiate->p();
1259  tauVars.leadPFChargedHadrEoP = patLeadCandiate->caloFraction() * patLeadCandiate->energy() *
1260  (1. - patLeadCandiate->hcalFraction()) / patLeadCandiate->p();
1261  }
1262  }
1263  }
1264 
1265  return tauVars;
1266 }
1267 
1268 // reco::GsfElectron
1269 template <class TauType, class ElectronType>
1270 void AntiElectronIDMVA6<TauType, ElectronType>::getElecVarsHGCalTypeSpecific(
1271  const reco::GsfElectronRef& theEleRef, antiElecIDMVA6_blocks::ElecVars& elecVars) {
1272  //MB: Assumed that presence of one of the HGCal EleID variables guarantee presence of all
1273  if (!(electronIds_.find("hgcElectronID:sigmaUU") != electronIds_.end() &&
1274  electronIds_.at("hgcElectronID:sigmaUU").isValid()))
1275  return;
1276 
1277  elecVars.hgcalSigmaUU = (*electronIds_.at("hgcElectronID:sigmaUU"))[theEleRef];
1278  elecVars.hgcalSigmaVV = (*electronIds_.at("hgcElectronID:sigmaVV"))[theEleRef];
1279  elecVars.hgcalSigmaEE = (*electronIds_.at("hgcElectronID:sigmaEE"))[theEleRef];
1280  elecVars.hgcalSigmaPP = (*electronIds_.at("hgcElectronID:sigmaPP"))[theEleRef];
1281  elecVars.hgcalNLayers = (*electronIds_.at("hgcElectronID:nLayers"))[theEleRef];
1282  elecVars.hgcalFirstLayer = (*electronIds_.at("hgcElectronID:firstLayer"))[theEleRef];
1283  elecVars.hgcalLastLayer = (*electronIds_.at("hgcElectronID:lastLayer"))[theEleRef];
1284  elecVars.hgcalLayerEfrac10 = (*electronIds_.at("hgcElectronID:layerEfrac10"))[theEleRef];
1285  elecVars.hgcalLayerEfrac90 = (*electronIds_.at("hgcElectronID:layerEfrac90"))[theEleRef];
1286  elecVars.hgcalEcEnergyEE = (*electronIds_.at("hgcElectronID:ecEnergyEE"))[theEleRef];
1287  elecVars.hgcalEcEnergyFH = (*electronIds_.at("hgcElectronID:ecEnergyFH"))[theEleRef];
1288  elecVars.hgcalMeasuredDepth = (*electronIds_.at("hgcElectronID:measuredDepth"))[theEleRef];
1289  elecVars.hgcalExpectedDepth = (*electronIds_.at("hgcElectronID:expectedDepth"))[theEleRef];
1290  elecVars.hgcalExpectedSigma = (*electronIds_.at("hgcElectronID:expectedSigma"))[theEleRef];
1291  elecVars.hgcalDepthCompatibility = (*electronIds_.at("hgcElectronID:depthCompatibility"))[theEleRef];
1292 }
1293 
1294 // pat::Electron
1295 template <class TauType, class ElectronType>
1296 void AntiElectronIDMVA6<TauType, ElectronType>::getElecVarsHGCalTypeSpecific(
1297  const pat::ElectronRef& theEleRef, antiElecIDMVA6_blocks::ElecVars& elecVars) {
1298  //MB: Assumed that presence of one of the HGCal EleID variables guarantee presence of all
1299  if (!theEleRef->hasUserFloat("hgcElectronID:sigmaUU"))
1300  return;
1301 
1302  elecVars.hgcalSigmaUU = theEleRef->userFloat("hgcElectronID:sigmaUU");
1303  elecVars.hgcalSigmaVV = theEleRef->userFloat("hgcElectronID:sigmaVV");
1304  elecVars.hgcalSigmaEE = theEleRef->userFloat("hgcElectronID:sigmaEE");
1305  elecVars.hgcalSigmaPP = theEleRef->userFloat("hgcElectronID:sigmaPP");
1306  elecVars.hgcalNLayers = theEleRef->userFloat("hgcElectronID:nLayers");
1307  elecVars.hgcalFirstLayer = theEleRef->userFloat("hgcElectronID:firstLayer");
1308  elecVars.hgcalLastLayer = theEleRef->userFloat("hgcElectronID:lastLayer");
1309  elecVars.hgcalLayerEfrac10 = theEleRef->userFloat("hgcElectronID:layerEfrac10");
1310  elecVars.hgcalLayerEfrac90 = theEleRef->userFloat("hgcElectronID:layerEfrac90");
1311  elecVars.hgcalEcEnergyEE = theEleRef->userFloat("hgcElectronID:ecEnergyEE");
1312  elecVars.hgcalEcEnergyFH = theEleRef->userFloat("hgcElectronID:ecEnergyFH");
1313  elecVars.hgcalMeasuredDepth = theEleRef->userFloat("hgcElectronID:measuredDepth");
1314  elecVars.hgcalExpectedDepth = theEleRef->userFloat("hgcElectronID:expectedDepth");
1315  elecVars.hgcalExpectedSigma = theEleRef->userFloat("hgcElectronID:expectedSigma");
1316  elecVars.hgcalDepthCompatibility = theEleRef->userFloat("hgcElectronID:depthCompatibility");
1317 }
1318 
1319 template <class TauType, class ElectronType>
1320 bool AntiElectronIDMVA6<TauType, ElectronType>::energyWeightedEtaAndPhiAtECal(const pat::Tau& theTau,
1321  float& eta,
1322  float& phi) {
1323  eta = 0.;
1324  phi = 0.;
1325  float sumEnergy = 0.;
1326  for (const auto& candidate : theTau.signalCands()) {
1327  float etaAtECalEntrance = candidate->eta();
1328  float phiAtECalEntrance = candidate->phi();
1329  bool success = false;
1330  reco::Candidate::Point posAtECal = positionAtECalEntrance_(candidate.get(), success);
1331  if (success) {
1332  etaAtECalEntrance = posAtECal.eta();
1333  phiAtECalEntrance = posAtECal.phi();
1334  }
1335  eta += etaAtECalEntrance * candidate->energy();
1336  phi += phiAtECalEntrance * candidate->energy();
1337  sumEnergy += candidate->energy();
1338  }
1339  if (sumEnergy > 0.) {
1340  eta = eta / sumEnergy;
1341  phi = phi / sumEnergy;
1342  } else {
1343  eta = -99.;
1344  phi = -99.;
1345  }
1346  return (sumEnergy > 0.);
1347 }
1348 
1349 // compile desired types and make available to linker
1350 template class AntiElectronIDMVA6<reco::PFTau, reco::GsfElectron>;
1351 template class AntiElectronIDMVA6<pat::Tau, pat::Electron>;
pat::Tau::leadChargedHadrCand
const reco::CandidatePtr leadChargedHadrCand() const
reco::PFCandidate::trackRef
reco::TrackRef trackRef() const
Definition: PFCandidate.cc:408
AntiElectronIDMVA6::getTauGammaVecs
antiElecIDMVA6_blocks::TauGammaVecs getTauGammaVecs(const TauType &theTau)
Definition: AntiElectronIDMVA6.cc:892
AntiElectronIDMVA6::mvaName_NoEleMatch_wGwoGSF_VFEC_
std::string mvaName_NoEleMatch_wGwoGSF_VFEC_
Definition: AntiElectronIDMVA6.h:176
antiElecIDMVA6_blocks::TauGammaMoms::gammaEnFracIn
float gammaEnFracIn
Definition: AntiElectronIDMVA6.h:67
AntiElectronIDMVA6::electronIds_tokens_
std::map< std::string, edm::EDGetTokenT< edm::ValueMap< float > > > electronIds_tokens_
Definition: AntiElectronIDMVA6.h:214
taus_updatedMVAIds_cff.loadMVAfromDB
loadMVAfromDB
Definition: taus_updatedMVAIds_cff.py:17
AntiElectronIDMVA6::getElecVarsHGCalTypeSpecific
void getElecVarsHGCalTypeSpecific(const reco::GsfElectronRef &theEleRef, antiElecIDMVA6_blocks::ElecVars &elecVars)
Definition: AntiElectronIDMVA6.cc:1270
AntiElectronIDMVA6
Definition: AntiElectronIDMVA6.h:114
antiElecIDMVA6_blocks::TauGammaVecs::gammasdEtaInSigCone
std::vector< float > gammasdEtaInSigCone
Definition: AntiElectronIDMVA6.h:53
AntiElectronIDMVA6.h
antiElecIDMVA6_blocks::TauGammaMoms::gammaEtaMomIn
float gammaEtaMomIn
Definition: AntiElectronIDMVA6.h:63
antiElecIDMVA6_blocks::ElecVars::hgcalSigmaVV
float hgcalSigmaVV
Definition: AntiElectronIDMVA6.h:96
reco::PFTau::leadCand
const CandidatePtr & leadCand() const
Definition: PFTau.cc:65
antiElecIDMVA6_blocks::TauVars::leadPFChargedHadrEoP
float leadPFChargedHadrEoP
Definition: AntiElectronIDMVA6.h:46
electrons_cff.bool
bool
Definition: electrons_cff.py:366
antiElecIDMVA6_blocks::ElecVars::hgcalEcEnergyEE
float hgcalEcEnergyEE
Definition: AntiElectronIDMVA6.h:104
mps_fire.i
i
Definition: mps_fire.py:428
antiElecIDMVA6_blocks::ElecVars::eEcal
float eEcal
Definition: AntiElectronIDMVA6.h:82
AntiElectronIDMVA6::mvaName_wGwGSF_EC_
std::string mvaName_wGwGSF_EC_
Definition: AntiElectronIDMVA6.h:174
reco::PFTau::signalCands
const std::vector< reco::CandidatePtr > & signalCands() const
Candidates in signal region.
Definition: PFTau.cc:74
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11713
Muon.h
antiElecIDMVA6_blocks::ElecVars::sigmaIPhiIPhi5x5
float sigmaIPhiIPhi5x5
Definition: AntiElectronIDMVA6.h:92
antiElecIDMVA6_blocks::ElecVars::hgcalMeasuredDepth
float hgcalMeasuredDepth
Definition: AntiElectronIDMVA6.h:106
antiElecIDMVA6_blocks::ElecVars::hgcalFirstLayer
float hgcalFirstLayer
Definition: AntiElectronIDMVA6.h:100
antiElecIDMVA6_blocks::ElecVars::mvaInDeltaEta
float mvaInDeltaEta
Definition: AntiElectronIDMVA6.h:87
funct::false
false
Definition: Factorize.h:29
antiElecIDMVA6_blocks::TauGammaVecs::gammasdPhiOutSigCone
std::vector< float > gammasdPhiOutSigCone
Definition: AntiElectronIDMVA6.h:57
AntiElectronIDMVA6::mvaName_NoEleMatch_woGwoGSF_EC_
std::string mvaName_NoEleMatch_woGwoGSF_EC_
Definition: AntiElectronIDMVA6.h:171
ESHandle.h
AntiElectronIDMVA6::var_woGwGSF_VFEndcap_
std::vector< float > var_woGwGSF_VFEndcap_
Definition: AntiElectronIDMVA6.h:192
antiElecIDMVA6_blocks::TauVars::dCrackEta
float dCrackEta
Definition: AntiElectronIDMVA6.h:48
antiElecIDMVA6_blocks::TauVars::hasGsf
float hasGsf
Definition: AntiElectronIDMVA6.h:50
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
antiElecIDMVA6_blocks::ElecVars::chi2NormGSF
float chi2NormGSF
Definition: AntiElectronIDMVA6.h:74
AntiElectronIDMVA6::var_NoEleMatch_woGwoGSF_Endcap_
std::vector< float > var_NoEleMatch_woGwoGSF_Endcap_
Definition: AntiElectronIDMVA6.h:186
PFCandidate.h
pat::PackedCandidate::p
double p() const override
magnitude of momentum vector
Definition: PackedCandidate.h:463
pat::Tau::ecalEnergyLeadChargedHadrCand
float ecalEnergyLeadChargedHadrCand() const
Definition: Tau.h:306
pat::PackedCandidate::pdgId
int pdgId() const override
PDG identifier.
Definition: PackedCandidate.h:833
edm::Ref::isAvailable
bool isAvailable() const
Definition: Ref.h:537
min
T min(T a, T b)
Definition: MathUtil.h:58
antiElecIDMVA6_blocks::ElecVars::pIn
float pIn
Definition: AntiElectronIDMVA6.h:80
GBRWrapperRcd.h
pat::PackedCandidate::caloFraction
float caloFraction() const
Set the fraction of ECAL+HCAL energy over candidate energy.
Definition: PackedCandidate.h:929
GBRForest
Definition: GBRForest.h:25
pat::Tau
Analysis-level tau class.
Definition: Tau.h:53
AntiElectronIDMVA6::mvaName_NoEleMatch_woGwoGSF_BL_
std::string mvaName_NoEleMatch_woGwoGSF_BL_
Definition: AntiElectronIDMVA6.h:167
AntiElectronIDMVA6::var_NoEleMatch_wGwoGSF_VFEndcap_
std::vector< float > var_NoEleMatch_wGwoGSF_VFEndcap_
Definition: AntiElectronIDMVA6.h:191
pat::Tau::emFraction_MVA
float emFraction_MVA() const
return emFraction_MVA
Definition: Tau.h:318
reco::PFCandidate::positionAtECALEntrance
const math::XYZPointF & positionAtECALEntrance() const
Definition: PFCandidate.h:363
antiElecIDMVA6_blocks::ElecVars::eSeedClusterOverPout
float eSeedClusterOverPout
Definition: AntiElectronIDMVA6.h:88
edm::Ref::get
T const * get() const
Returns C++ pointer to the item.
Definition: Ref.h:232
antiElecIDMVA6_blocks::ElecVars::deltaEta
float deltaEta
Definition: AntiElectronIDMVA6.h:83
AntiElectronIDMVA6::var_wGwGSF_Endcap_
std::vector< float > var_wGwGSF_Endcap_
Definition: AntiElectronIDMVA6.h:189
CustomPhysics_cfi.gamma
gamma
Definition: CustomPhysics_cfi.py:17
edm::PtrVectorItr
Definition: PtrVector.h:51
antiElecIDMVA6_blocks::ElecVars::kfNumHits
float kfNumHits
Definition: AntiElectronIDMVA6.h:77
reco::PFTau
Definition: PFTau.h:36
antiElecIDMVA6_blocks::TauVars::pt
float pt
Definition: AntiElectronIDMVA6.h:39
edm::Ptr::get
T const * get() const
Returns C++ pointer to the item.
Definition: Ptr.h:139
antiElecIDMVA6_blocks::ElecVars::phi
float phi
Definition: AntiElectronIDMVA6.h:72
AntiElectronIDMVA6::electronIds_
std::map< std::string, edm::Handle< edm::ValueMap< float > > > electronIds_
Definition: AntiElectronIDMVA6.h:215
antiElecIDMVA6_blocks::ElecVars::mvaInSigmaEtaEta
float mvaInSigmaEtaEta
Definition: AntiElectronIDMVA6.h:85
antiElecIDMVA6_blocks::ElecVars::hgcalSigmaUU
float hgcalSigmaUU
Definition: AntiElectronIDMVA6.h:95
beam_dqm_sourceclient-live_cfg.mva
mva
Definition: beam_dqm_sourceclient-live_cfg.py:126
AntiElectronIDMVA6::energyWeightedEtaAndPhiAtECal
bool energyWeightedEtaAndPhiAtECal(const pat::Tau &theTau, float &eta, float &phi)
Definition: AntiElectronIDMVA6.cc:1320
antiElecIDMVA6_blocks::TauGammaMoms::signalPFGammaCandsOut
int signalPFGammaCandsOut
Definition: AntiElectronIDMVA6.h:62
edm::Handle
Definition: AssociativeIterator.h:50
antiElecIDMVA6_blocks::ElecVars::hgcalNLayers
float hgcalNLayers
Definition: AntiElectronIDMVA6.h:99
reco::PFTau::emFraction
float emFraction() const
Definition: PFTau.cc:340
reco::OK
std::pair< int, edm::FunctionWithDict > OK
Definition: findMethod.cc:126
PositionAtECalEntranceComputer
Definition: PositionAtECalEntranceComputer.h:25
antiElecIDMVA6_blocks::TauVars::emFraction
float emFraction
Definition: AntiElectronIDMVA6.h:44
antiElecIDMVA6_blocks::ElecVars::sigmaIEtaIEta5x5
float sigmaIEtaIEta5x5
Definition: AntiElectronIDMVA6.h:91
antiElecIDMVA6_blocks::ElecVars::eta
float eta
Definition: AntiElectronIDMVA6.h:71
edm::Ref
Definition: AssociativeIterator.h:58
TtFullHadEvtBuilder_cfi.sumPt
sumPt
Definition: TtFullHadEvtBuilder_cfi.py:38
cc
AntiElectronIDMVA6::mvaValuePhase2
double mvaValuePhase2(const antiElecIDMVA6_blocks::TauVars &tauVars, const antiElecIDMVA6_blocks::TauGammaMoms &tauGammaMoms, const antiElecIDMVA6_blocks::ElecVars &elecVars)
Definition: AntiElectronIDMVA6.cc:487
antiElecIDMVA6_blocks::TauVars::phi
float phi
Definition: AntiElectronIDMVA6.h:41
antiElecIDMVA6_blocks
Definition: AntiElectronIDMVA6.h:37
AntiElectronIDMVA6::var_woGwGSF_Barrel_
std::vector< float > var_woGwGSF_Barrel_
Definition: AntiElectronIDMVA6.h:184
pat::Tau::hcalEnergyLeadChargedHadrCand
float hcalEnergyLeadChargedHadrCand() const
return hcal energy from LeadChargedHadrCand
Definition: Tau.h:308
antiElecIDMVA6_blocks::ElecVars::chi2NormKF
float chi2NormKF
Definition: AntiElectronIDMVA6.h:75
pat::Tau::signalCands
reco::CandidatePtrVector signalCands() const
edm::FileInPath
Definition: FileInPath.h:64
antiElecIDMVA6_blocks::ElecVars::showerCircularity
float showerCircularity
Definition: AntiElectronIDMVA6.h:93
antiElecIDMVA6_blocks::ElecVars::mvaInHadEnergy
float mvaInHadEnergy
Definition: AntiElectronIDMVA6.h:86
antiElecIDMVA6_blocks::ElecVars::superClusterEtaWidth
float superClusterEtaWidth
Definition: AntiElectronIDMVA6.h:89
reco::PFCandidate::muonRef
reco::MuonRef muonRef() const
Definition: PFCandidate.cc:421
pat::PackedCandidate::energy
double energy() const override
energy
Definition: PackedCandidate.h:469
antiElecIDMVA6_blocks::TauVars
Definition: AntiElectronIDMVA6.h:38
antiElecIDMVA6_blocks::ElecVars::hgcalExpectedDepth
float hgcalExpectedDepth
Definition: AntiElectronIDMVA6.h:107
Track.h
edm::EventSetup::get
T get() const
Definition: EventSetup.h:87
PVValHelper::eta
Definition: PVValidationHelpers.h:70
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
AntiElectronIDMVA6::dCrackPhi
double dCrackPhi(double phi, double eta)
Definition: AntiElectronIDMVA6.cc:1022
AntiElectronIDMVA6::var_NoEleMatch_wGwoGSF_Endcap_
std::vector< float > var_NoEleMatch_wGwoGSF_Endcap_
Definition: AntiElectronIDMVA6.h:187
AntiElectronIDMVA6::var_NoEleMatch_woGwoGSF_VFEndcap_
std::vector< float > var_NoEleMatch_woGwoGSF_VFEndcap_
Definition: AntiElectronIDMVA6.h:190
reco::Track
Definition: Track.h:27
antiElecIDMVA6_blocks::TauGammaMoms
Definition: AntiElectronIDMVA6.h:60
edm::ESHandle< GBRForest >
summarizeEdmComparisonLogfiles.success
success
Definition: summarizeEdmComparisonLogfiles.py:115
AntiElectronIDMVA6::var_woGwGSF_Endcap_
std::vector< float > var_woGwGSF_Endcap_
Definition: AntiElectronIDMVA6.h:188
antiElecIDMVA6_blocks::ElecVars::gsfTrackResol
float gsfTrackResol
Definition: AntiElectronIDMVA6.h:78
taus_updatedMVAIds_cff.mvaName
mvaName
Definition: taus_updatedMVAIds_cff.py:18
antiElecIDMVA6_blocks::TauVars::leadPFChargedHadrHoP
float leadPFChargedHadrHoP
Definition: AntiElectronIDMVA6.h:45
antiElecIDMVA6_blocks::TauGammaVecs::gammasdPhiInSigCone
std::vector< float > gammasdPhiInSigCone
Definition: AntiElectronIDMVA6.h:54
b
double b
Definition: hdecay.h:118
antiElecIDMVA6_blocks::ElecVars::hgcalDepthCompatibility
float hgcalDepthCompatibility
Definition: AntiElectronIDMVA6.h:109
antiElecIDMVA6_blocks::ElecVars::hgcalEcEnergyFH
float hgcalEcEnergyFH
Definition: AntiElectronIDMVA6.h:105
antiElecIDMVA6_blocks::TauGammaVecs::gammasdEtaOutSigCone
std::vector< float > gammasdEtaOutSigCone
Definition: AntiElectronIDMVA6.h:56
AntiElectronIDMVA6::mvaName_NoEleMatch_wGwoGSF_BL_
std::string mvaName_NoEleMatch_wGwoGSF_BL_
Definition: AntiElectronIDMVA6.h:168
PbPb_ZMuSkimMuonDPG_cff.deltaR
deltaR
Definition: PbPb_ZMuSkimMuonDPG_cff.py:63
reco::PFTau::leadChargedHadrCand
const CandidatePtr & leadChargedHadrCand() const
Definition: PFTau.cc:63
AntiElectronIDMVA6::mvaName_woGwGSF_VFEC_
std::string mvaName_woGwGSF_VFEC_
Definition: AntiElectronIDMVA6.h:177
antiElecIDMVA6_blocks::ElecVars::hgcalLayerEfrac10
float hgcalLayerEfrac10
Definition: AntiElectronIDMVA6.h:102
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
AntiElectronIDMVA6::AntiElectronIDMVA6
AntiElectronIDMVA6(const edm::ParameterSet &, edm::ConsumesCollector &&)
Definition: AntiElectronIDMVA6.cc:37
AntiElectronIDMVA6::usePhiAtEcalEntranceExtrapolation_
bool usePhiAtEcalEntranceExtrapolation_
Definition: AntiElectronIDMVA6.h:180
antiElecIDMVA6_blocks::TauVars::leadChargedPFCandEtaAtEcalEntrance
float leadChargedPFCandEtaAtEcalEntrance
Definition: AntiElectronIDMVA6.h:43
antiElecIDMVA6_blocks::ElecVars::hgcalExpectedSigma
float hgcalExpectedSigma
Definition: AntiElectronIDMVA6.h:108
AntiElectronIDMVA6::var_NoEleMatch_wGwoGSF_Barrel_
std::vector< float > var_NoEleMatch_wGwoGSF_Barrel_
Definition: AntiElectronIDMVA6.h:183
edm::ParameterSet
Definition: ParameterSet.h:47
reco::PFCandidate::gsfTrackRef
reco::GsfTrackRef gsfTrackRef() const
Definition: PFCandidate.cc:440
antiElecIDMVA6_blocks::TauGammaMoms::gammaEnFracOut
float gammaEnFracOut
Definition: AntiElectronIDMVA6.h:68
a
double a
Definition: hdecay.h:119
AntiElectronIDMVA6::inputFileName_
edm::FileInPath inputFileName_
Definition: AntiElectronIDMVA6.h:165
reco::LeafCandidate::eta
double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:152
PVValHelper::phi
Definition: PVValidationHelpers.h:69
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
antiElecIDMVA6_blocks::TauVars::visMassIn
float visMassIn
Definition: AntiElectronIDMVA6.h:47
antiElecIDMVA6_blocks::TauGammaVecs::gammasPtOutSigCone
std::vector< float > gammasPtOutSigCone
Definition: AntiElectronIDMVA6.h:58
antiElecIDMVA6_blocks::TauGammaMoms::gammaEtaMomOut
float gammaEtaMomOut
Definition: AntiElectronIDMVA6.h:64
pat::PackedCandidate
Definition: PackedCandidate.h:22
antiElecIDMVA6_blocks::ElecVars::gsfNumHits
float gsfNumHits
Definition: AntiElectronIDMVA6.h:76
pat::Tau::etaAtEcalEntrance
float etaAtEcalEntrance() const
return etaAtEcalEntrance
Definition: Tau.h:312
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
AntiElectronIDMVA6::var_wGwGSF_Barrel_
std::vector< float > var_wGwGSF_Barrel_
Definition: AntiElectronIDMVA6.h:185
antiElecIDMVA6_blocks::TauGammaVecs
Definition: AntiElectronIDMVA6.h:52
createfilelist.int
int
Definition: createfilelist.py:10
dtResolutionTest_cfi.inputFile
inputFile
Definition: dtResolutionTest_cfi.py:14
GsfTrack.h
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:49
antiElecIDMVA6_blocks::ElecVars::superClusterPhiWidth
float superClusterPhiWidth
Definition: AntiElectronIDMVA6.h:90
AntiElectronIDMVA6::getTauVars
antiElecIDMVA6_blocks::TauVars getTauVars(const TauType &theTau)
Definition: AntiElectronIDMVA6.cc:842
antiElecIDMVA6_blocks::ElecVars::hgcalLayerEfrac90
float hgcalLayerEfrac90
Definition: AntiElectronIDMVA6.h:103
edm::EventSetup
Definition: EventSetup.h:58
AntiElectronIDMVA6::var_wGwGSF_VFEndcap_
std::vector< float > var_wGwGSF_VFEndcap_
Definition: AntiElectronIDMVA6.h:193
get
#define get
AntiElectronIDMVA6::getElecVars
antiElecIDMVA6_blocks::ElecVars getElecVars(const ElectronRef &theEleRef)
Definition: AntiElectronIDMVA6.cc:915
pat::Tau::phiAtEcalEntrance
float phiAtEcalEntrance() const
return phiAtEcalEntrance
Definition: Tau.h:310
reco::PFCandidate::ecalEnergy
double ecalEnergy() const
return corrected Ecal energy
Definition: PFCandidate.h:221
looper.cfg
cfg
Definition: looper.py:297
AntiElectronIDMVA6::mvaName_woGwGSF_BL_
std::string mvaName_woGwGSF_BL_
Definition: AntiElectronIDMVA6.h:169
AntiElectronIDMVA6::mvaName_NoEleMatch_woGwoGSF_VFEC_
std::string mvaName_NoEleMatch_woGwoGSF_VFEC_
Definition: AntiElectronIDMVA6.h:175
antiElecIDMVA6_blocks::TauGammaMoms::gammaPhiMomIn
float gammaPhiMomIn
Definition: AntiElectronIDMVA6.h:65
antiElecIDMVA6_blocks::ElecVars::r9
float r9
Definition: AntiElectronIDMVA6.h:94
AntiElectronIDMVA6::loadMVAfromDB_
bool loadMVAfromDB_
Definition: AntiElectronIDMVA6.h:164
AntiElectronIDMVA6::mvaName_woGwGSF_EC_
std::string mvaName_woGwGSF_EC_
Definition: AntiElectronIDMVA6.h:173
AntiElectronIDMVA6::isPhase2_
const bool isPhase2_
Definition: AntiElectronIDMVA6.h:210
pat::PackedCandidate::hcalFraction
float hcalFraction() const
Definition: PackedCandidate.h:934
AntiElectronIDMVA6::mvaName_wGwGSF_VFEC_
std::string mvaName_wGwGSF_VFEC_
Definition: AntiElectronIDMVA6.h:178
reco::LeafCandidate::phi
double phi() const final
momentum azimuthal angle
Definition: LeafCandidate.h:148
edm::FileInPath::Unknown
Definition: FileInPath.h:66
antiElecIDMVA6_blocks::ElecVars::pOut
float pOut
Definition: AntiElectronIDMVA6.h:81
reco::PFCandidate::hcalEnergy
double hcalEnergy() const
return corrected Hcal energy
Definition: PFCandidate.h:233
pat::Tau::etaAtEcalEntranceLeadChargedCand
float etaAtEcalEntranceLeadChargedCand() const
return etaAtEcalEntrance from LeadChargedCand
Definition: Tau.h:314
edm::ValueMap< float >
relativeConstraints.value
value
Definition: relativeConstraints.py:53
Exception
Definition: hltDiff.cc:245
reco::LeafCandidate::p
double p() const final
magnitude of momentum vector
Definition: LeafCandidate.h:123
antiElecIDMVA6_blocks::ElecVars
Definition: AntiElectronIDMVA6.h:70
EgHLTOffHistBins_cfi.mass
mass
Definition: EgHLTOffHistBins_cfi.py:34
GBRWrapperRcd
Definition: GBRWrapperRcd.h:24
antiElecIDMVA6_blocks::TauVars::etaAtEcalEntrance
float etaAtEcalEntrance
Definition: AntiElectronIDMVA6.h:40
edm::Ptr::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ptr.h:146
AntiElectronIDMVA6::minimum
double minimum(double a, double b)
Definition: AntiElectronIDMVA6.cc:996
antiElecIDMVA6_blocks::TauGammaVecs::gammasPtInSigCone
std::vector< float > gammasPtInSigCone
Definition: AntiElectronIDMVA6.h:55
Exception.h
antiElecIDMVA6_blocks::TauVars::dCrackPhi
float dCrackPhi
Definition: AntiElectronIDMVA6.h:49
dqm-mbProfile.log
log
Definition: dqm-mbProfile.py:17
antiElecIDMVA6_blocks::ElecVars::hgcalSigmaEE
float hgcalSigmaEE
Definition: AntiElectronIDMVA6.h:97
pat::Tau::ptLeadChargedCand
float ptLeadChargedCand() const
return pt from LeadChargedCand
Definition: Tau.h:316
AntiElectronIDMVA6::beginEvent
void beginEvent(const edm::Event &, const edm::EventSetup &)
Definition: AntiElectronIDMVA6.cc:157
reco::PFCandidate
Particle reconstructed by the particle flow algorithm.
Definition: PFCandidate.h:41
ztail.d
d
Definition: ztail.py:151
AntiElectronIDMVA6::mvaName_NoEleMatch_wGwoGSF_EC_
std::string mvaName_NoEleMatch_wGwoGSF_EC_
Definition: AntiElectronIDMVA6.h:172
antiElecIDMVA6_blocks::ElecVars::hgcalSigmaPP
float hgcalSigmaPP
Definition: AntiElectronIDMVA6.h:98
antiElecIDMVA6_blocks::ElecVars::gsfTracklnPt
float gsfTracklnPt
Definition: AntiElectronIDMVA6.h:79
pi
const Double_t pi
Definition: trackSplitPlot.h:36
AntiElectronIDMVA6::mvaValue
double mvaValue(const antiElecIDMVA6_blocks::TauVars &tauVars, const antiElecIDMVA6_blocks::TauGammaVecs &tauGammaVecs, const antiElecIDMVA6_blocks::ElecVars &elecVars)
Definition: AntiElectronIDMVA6.cc:208
cms::Exception
Definition: Exception.h:70
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
HGC3DClusterGenMatchSelector_cfi.dR
dR
Definition: HGC3DClusterGenMatchSelector_cfi.py:7
antiElecIDMVA6_blocks::ElecVars::eTotOverPin
float eTotOverPin
Definition: AntiElectronIDMVA6.h:73
reco::Candidate::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Candidate.h:36
reco::Candidate::Point
math::XYZPoint Point
point in the space
Definition: Candidate.h:40
AntiElectronIDMVA6::~AntiElectronIDMVA6
~AntiElectronIDMVA6()
Definition: AntiElectronIDMVA6.cc:115
SimL1EmulatorRepack_Full_cff.inputTag
inputTag
Definition: SimL1EmulatorRepack_Full_cff.py:56
antiElecIDMVA6_blocks::TauGammaMoms::signalPFGammaCandsIn
int signalPFGammaCandsIn
Definition: AntiElectronIDMVA6.h:61
edm::Event
Definition: Event.h:73
antiElecIDMVA6_blocks::TauVars::leadChargedPFCandPt
float leadChargedPFCandPt
Definition: AntiElectronIDMVA6.h:42
antiElecIDMVA6_blocks::ElecVars::deltaPhi
float deltaPhi
Definition: AntiElectronIDMVA6.h:84
AntiElectronIDMVA6::getTauVarsTypeSpecific
antiElecIDMVA6_blocks::TauVars getTauVarsTypeSpecific(const reco::PFTau &theTau)
Definition: AntiElectronIDMVA6.cc:1143
AntiElectronIDMVA6::mvaName_wGwGSF_BL_
std::string mvaName_wGwGSF_BL_
Definition: AntiElectronIDMVA6.h:170
edm::Event::getHandle
Handle< PROD > getHandle(EDGetTokenT< PROD > token) const
Definition: Event.h:559
AntiElectronIDMVA6::dCrackEta
double dCrackEta(double eta)
Definition: AntiElectronIDMVA6.cc:1073
AntiElectronIDMVA6::var_NoEleMatch_woGwoGSF_Barrel_
std::vector< float > var_NoEleMatch_woGwoGSF_Barrel_
Definition: AntiElectronIDMVA6.h:182
edm::ConsumesCollector
Definition: ConsumesCollector.h:45
antiElecIDMVA6_blocks::TauGammaMoms::gammaPhiMomOut
float gammaPhiMomOut
Definition: AntiElectronIDMVA6.h:66
PFCandidateFwd.h
antiElecIDMVA6_blocks::ElecVars::hgcalLastLayer
float hgcalLastLayer
Definition: AntiElectronIDMVA6.h:101
Generated for CMSSW Reference Manual by doxygen 1.8.16