CMS 3D CMS Logo
MVAJetPuId.cc
Go to the documentation of this file.
1 #include "RecoJets/JetProducers/interface/MVAJetPuId.h"
2 #include "DataFormats/JetReco/interface/PFJet.h"
3 #include "FWCore/Framework/interface/Frameworkfwd.h"
4 #include "DataFormats/JetReco/interface/Jet.h"
5 #include "DataFormats/VertexReco/interface/Vertex.h"
6 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
7 #include "DataFormats/Math/interface/deltaR.h"
8 #include "FWCore/ParameterSet/interface/FileInPath.h"
9 #include "CommonTools/MVAUtils/interface/TMVAZipReader.h"
10 #include "TMatrixDSym.h"
11 #include "TMatrixDSymEigen.h"
12 #include "DataFormats/JetReco/interface/PileupJetIdentifier.h"
13 
14 const float large_val = std::numeric_limits<float>::max();
15 
16 MVAJetPuId::MVAJetPuId(const edm::ParameterSet &ps) {
17  impactParTkThreshod_ = 1.;
18 
19  tmvaWeights_ = edm::FileInPath(ps.getParameter<std::string>("tmvaWeights")).fullPath();
20  tmvaMethod_ = ps.getParameter<std::string>("tmvaMethod");
21  tmvaVariables_ = ps.getParameter<std::vector<std::string> >("tmvaVariables");
22  tmvaSpectators_ = ps.getParameter<std::vector<std::string> >("tmvaSpectators");
23  version_ = ps.getParameter<int>("version");
24  reader_ = nullptr;
25  edm::ParameterSet jetConfig = ps.getParameter<edm::ParameterSet>("JetIdParams");
26  for (int i0 = 0; i0 < NWPs; i0++) {
27  std::string lCutType = "Tight";
28  if (i0 == PileupJetIdentifier::kMedium)
29  lCutType = "Medium";
30  if (i0 == PileupJetIdentifier::kLoose)
31  lCutType = "Loose";
32  for (int i1 = 0; i1 < 1; i1++) {
33  std::vector<double> pt010 = jetConfig.getParameter<std::vector<double> >(("Pt010_" + lCutType).c_str());
34  std::vector<double> pt1020 = jetConfig.getParameter<std::vector<double> >(("Pt1020_" + lCutType).c_str());
35  std::vector<double> pt2030 = jetConfig.getParameter<std::vector<double> >(("Pt2030_" + lCutType).c_str());
36  std::vector<double> pt3050 = jetConfig.getParameter<std::vector<double> >(("Pt3050_" + lCutType).c_str());
37  for (int i2 = 0; i2 < NPts; i2++)
38  mvacut_[i0][0][i2] = pt010[i2];
39  for (int i2 = 0; i2 < NPts; i2++)
40  mvacut_[i0][1][i2] = pt1020[i2];
41  for (int i2 = 0; i2 < NPts; i2++)
42  mvacut_[i0][2][i2] = pt2030[i2];
43  for (int i2 = 0; i2 < NPts; i2++)
44  mvacut_[i0][3][i2] = pt3050[i2];
45  }
46  }
47  setup();
48 }
49 
50 MVAJetPuId::MVAJetPuId(int version,
51  const std::string &tmvaWeights,
52  const std::string &tmvaMethod,
53  Float_t impactParTkThreshod,
54  const std::vector<std::string> &tmvaVariables) {
55  impactParTkThreshod_ = impactParTkThreshod;
56  tmvaWeights_ = tmvaWeights;
57  tmvaMethod_ = tmvaMethod;
58  tmvaVariables_ = tmvaVariables;
59  version_ = version;
60 
61  reader_ = nullptr;
62 
63  setup();
64 }
65 
66 void MVAJetPuId::setup() {
67  initVariables();
68 
69  tmvaVariables_.clear();
70  tmvaVariables_.push_back("rho");
71  tmvaVariables_.push_back("nParticles");
72  tmvaVariables_.push_back("nCharged");
73  tmvaVariables_.push_back("majW");
74  tmvaVariables_.push_back("minW");
75  tmvaVariables_.push_back("frac01");
76  tmvaVariables_.push_back("frac02");
77  tmvaVariables_.push_back("frac03");
78  tmvaVariables_.push_back("frac04");
79  tmvaVariables_.push_back("ptD");
80  tmvaVariables_.push_back("beta");
81  tmvaVariables_.push_back("betaStar");
82  tmvaVariables_.push_back("dR2Mean");
83  tmvaVariables_.push_back("pull");
84  tmvaVariables_.push_back("jetR");
85  tmvaVariables_.push_back("jetRchg");
86 
87  tmvaNames_["rho"] = "rho";
88  tmvaNames_["nParticles"] = "nParticles";
89  tmvaNames_["nCharged"] = "nCharged";
90  tmvaNames_["majW"] = "majW";
91  tmvaNames_["minW"] = "minW";
92  tmvaNames_["frac01"] = "frac01";
93  tmvaNames_["frac02"] = "frac02";
94  tmvaNames_["frac03"] = "frac03";
95  tmvaNames_["frac04"] = "frac04";
96  tmvaNames_["ptD"] = "ptD";
97  tmvaNames_["beta"] = "beta";
98  tmvaNames_["betaStar"] = "betaStar";
99  tmvaNames_["dR2Mean"] = "dR2Mean";
100  tmvaNames_["pull"] = "pull";
101  tmvaNames_["jetR"] = "jetR";
102  tmvaNames_["jetRchg"] = "jetRchg";
103 }
104 
105 MVAJetPuId::~MVAJetPuId() {
106  if (reader_) {
107  delete reader_;
108  }
109 }
110 
111 void Assign(const std::vector<float> &vec, float &a, float &b, float &c, float &d) {
112  size_t sz = vec.size();
113  a = (sz > 0 ? vec[0] : 0.);
114  b = (sz > 1 ? vec[1] : 0.);
115  c = (sz > 2 ? vec[2] : 0.);
116  d = (sz > 3 ? vec[3] : 0.);
117 }
118 
119 void SetPtEtaPhi(const reco::Candidate &p, float &pt, float &eta, float &phi) {
120  pt = p.pt();
121  eta = p.eta();
122  phi = p.phi();
123 }
124 
125 void MVAJetPuId::bookReader() {
126  reader_ = new TMVA::Reader("!Color:Silent");
127  assert(!tmvaMethod_.empty() && !tmvaWeights_.empty());
128  for (std::vector<std::string>::iterator it = tmvaVariables_.begin(); it != tmvaVariables_.end(); ++it) {
129  if (tmvaNames_[*it].empty()) {
130  tmvaNames_[*it] = *it;
131  }
132  reader_->AddVariable(*it, variables_[tmvaNames_[*it]].first);
133  }
134  for (std::vector<std::string>::iterator it = tmvaSpectators_.begin(); it != tmvaSpectators_.end(); ++it) {
135  if (tmvaNames_[*it].empty()) {
136  tmvaNames_[*it] = *it;
137  }
138  reader_->AddSpectator(*it, variables_[tmvaNames_[*it]].first);
139  }
140  reco::details::loadTMVAWeights(reader_, tmvaMethod_, tmvaWeights_);
141 }
142 
143 void MVAJetPuId::set(const PileupJetIdentifier &id) { internalId_ = id; }
144 
145 void MVAJetPuId::runMva() {
146  if (!reader_) {
147  bookReader();
148  }
149  if (fabs(internalId_.jetEta_) < 5.0)
150  internalId_.mva_ = reader_->EvaluateMVA(tmvaMethod_.c_str());
151  if (fabs(internalId_.jetEta_) >= 5.0)
152  internalId_.mva_ = -2.;
153  internalId_.idFlag_ = computeIDflag(internalId_.mva_, internalId_.jetPt_, internalId_.jetEta_);
154 }
155 
156 std::pair<int, int> MVAJetPuId::getJetIdKey(float jetPt, float jetEta) {
157  int ptId = 0;
158  if (jetPt > 10 && jetPt < 20)
159  ptId = 1;
160  if (jetPt >= 20 && jetPt < 30)
161  ptId = 2;
162  if (jetPt >= 30)
163  ptId = 3;
164 
165  int etaId = 0;
166  if (fabs(jetEta) > 2.5 && fabs(jetEta) < 2.75)
167  etaId = 1;
168  if (fabs(jetEta) >= 2.75 && fabs(jetEta) < 3.0)
169  etaId = 2;
170  if (fabs(jetEta) >= 3.0 && fabs(jetEta) < 5.0)
171  etaId = 3;
172  return std::pair<int, int>(ptId, etaId);
173 }
174 
175 int MVAJetPuId::computeIDflag(float mva, float jetPt, float jetEta) {
176  std::pair<int, int> jetIdKey = getJetIdKey(jetPt, jetEta);
177  return computeIDflag(mva, jetIdKey.first, jetIdKey.second);
178 }
179 
180 int MVAJetPuId::computeIDflag(float mva, int ptId, int etaId) {
181  int idFlag(0);
182  if (mva > mvacut_[PileupJetIdentifier::kTight][ptId][etaId])
183  idFlag += 1 << PileupJetIdentifier::kTight;
184  if (mva > mvacut_[PileupJetIdentifier::kMedium][ptId][etaId])
185  idFlag += 1 << PileupJetIdentifier::kMedium;
186  if (mva > mvacut_[PileupJetIdentifier::kLoose][ptId][etaId])
187  idFlag += 1 << PileupJetIdentifier::kLoose;
188  return idFlag;
189 }
190 
191 PileupJetIdentifier MVAJetPuId::computeMva() {
192  runMva();
193  return PileupJetIdentifier(internalId_);
194 }
195 
196 PileupJetIdentifier MVAJetPuId::computeIdVariables(const reco::Jet *jet,
197  float jec,
198  const reco::Vertex *vtx,
199  const reco::VertexCollection &allvtx,
200  double rho,
201  bool calculateMva) {
202  typedef std::vector<reco::PFCandidatePtr> constituents_type;
203  typedef std::vector<reco::PFCandidatePtr>::iterator constituents_iterator;
204 
205  resetVariables();
206 
207  const reco::PFJet *pfjet = dynamic_cast<const reco::PFJet *>(jet);
208 
209  if (jec < 0.) {
210  jec = 1.;
211  }
212 
213  constituents_type constituents = pfjet->getPFConstituents();
214 
215  reco::PFCandidatePtr lLead, lSecond, lLeadNeut, lLeadEm, lLeadCh, lTrail;
216  std::vector<float> frac, fracCh, fracEm, fracNeut;
217  constexpr int ncones = 4;
218  std::array<float, ncones> cones{{0.1, 0.2, 0.3, 0.4}};
219  std::array<float *, ncones> coneFracs{
220  {&internalId_.frac01_, &internalId_.frac02_, &internalId_.frac03_, &internalId_.frac04_}};
221  TMatrixDSym covMatrix(2);
222  covMatrix = 0.;
223 
224  reco::TrackRef impactTrack;
225  float jetPt = jet->pt() / jec; // use uncorrected pt for shape variables
226  float sumPt = 0., sumPt2 = 0., sumTkPt = 0., sumPtCh = 0, sumPtNe = 0;
227  float sum_deta = 0;
228  float sum_dphi = 0;
229  float sum_deta2 = 0;
230  float sum_detadphi = 0;
231  float sum_dphi2 = 0;
232  SetPtEtaPhi(
233  *jet, internalId_.jetPt_, internalId_.jetEta_, internalId_.jetPhi_); // use corrected pt for jet kinematics
234  internalId_.jetM_ = jet->mass();
235  internalId_.rho_ = rho; //allvtx.size();
236  for (constituents_iterator it = constituents.begin(); it != constituents.end(); ++it) {
237  reco::PFCandidatePtr &icand = *it;
238  float candPt = icand->pt();
239  float candPtFrac = candPt / jetPt;
240  float candDr = reco::deltaR(**it, *jet);
241  float candDeta = fabs((*it)->eta() - jet->eta());
242  float candDphi = reco::deltaPhi(**it, *jet);
243  float candPtDr = candPt * candDr;
244  size_t icone = std::lower_bound(&cones[0], &cones[ncones], candDr) - &cones[0];
245  float weight2 = candPt * candPt;
246 
247  if (lLead.isNull() || candPt > lLead->pt()) {
248  lSecond = lLead;
249  lLead = icand;
250  } else if ((lSecond.isNull() || candPt > lSecond->pt()) && (candPt < lLead->pt())) {
251  lSecond = icand;
252  }
253 
254  //internalId_.dRMean_ += candPtDr;
255  internalId_.dR2Mean_ += candPtDr * candPtDr;
256 
257  internalId_.ptD_ += candPt * candPt;
258  sumPt += candPt;
259  sumPt2 += candPt * candPt;
260  sum_deta += candDeta * weight2;
261  sum_dphi += candDphi * weight2;
262  sum_deta2 += candDeta * candDeta * weight2;
263  sum_detadphi += candDeta * candDphi * weight2;
264  sum_dphi2 += candDphi * candDphi * weight2;
265  //Teta += candPt * candDR * candDeta;
266  //Tphi += candPt * candDR * candDphi;
267 
268  frac.push_back(candPtFrac);
269  if (icone < ncones) {
270  *coneFracs[icone] += candPt;
271  }
272 
273  if (icand->particleId() == reco::PFCandidate::h0) {
274  if (lLeadNeut.isNull() || candPt > lLeadNeut->pt()) {
275  lLeadNeut = icand;
276  }
277  internalId_.dRMeanNeut_ += candPtDr;
278  fracNeut.push_back(candPtFrac);
279  sumPtNe += candPt;
280  }
281 
282  if (icand->particleId() == reco::PFCandidate::gamma) {
283  if (lLeadEm.isNull() || candPt > lLeadEm->pt()) {
284  lLeadEm = icand;
285  }
286  internalId_.dRMeanEm_ += candPtDr;
287  fracEm.push_back(candPtFrac);
288  sumPtNe += candPt;
289  }
290 
291  if (icand->trackRef().isNonnull() && icand->trackRef().isAvailable()) {
292  if (lLeadCh.isNull() || candPt > lLeadCh->pt()) {
293  lLeadCh = icand;
294  }
295  //internalId_.jetRchg_ += candPtDr;
296  fracCh.push_back(candPtFrac);
297  sumPtCh += candPt;
298  }
299 
300  if (icand->trackRef().isNonnull() && icand->trackRef().isAvailable()) {
301  float tkpt = icand->trackRef()->pt();
302  sumTkPt += tkpt;
303  bool inVtx0 =
304  find(vtx->tracks_begin(), vtx->tracks_end(), reco::TrackBaseRef(icand->trackRef())) != vtx->tracks_end();
305  bool inAnyOther = false;
306 
307  double dZ0 = fabs(icand->trackRef()->dz(vtx->position()));
308  double dZ = dZ0;
309  for (reco::VertexCollection::const_iterator vi = allvtx.begin(); vi != allvtx.end(); ++vi) {
310  const reco::Vertex &iv = *vi;
311  if (iv.isFake() || iv.ndof() < 4) {
312  continue;
313  }
314 
315  bool isVtx0 = (iv.position() - vtx->position()).r() < 0.02;
316 
317  if (!isVtx0 && !inAnyOther) {
318  inAnyOther =
319  find(iv.tracks_begin(), iv.tracks_end(), reco::TrackBaseRef(icand->trackRef())) != iv.tracks_end();
320  }
321 
322  dZ = std::min(dZ, fabs(icand->trackRef()->dz(iv.position())));
323  }
324  if (inVtx0 && !inAnyOther) {
325  internalId_.betaClassic_ += tkpt;
326  } else if (!inVtx0 && inAnyOther) {
327  internalId_.betaStarClassic_ += tkpt;
328  }
329 
330  if (dZ0 < 0.2) {
331  internalId_.beta_ += tkpt;
332  } else if (dZ < 0.2) {
333  internalId_.betaStar_ += tkpt;
334  }
335  }
336 
337  if (lTrail.isNull() || candPt < lTrail->pt()) {
338  lTrail = icand;
339  }
340  }
341 
342  assert(lLead.isNonnull());
343  if (lSecond.isNull()) {
344  lSecond = lTrail;
345  }
346  if (lLeadNeut.isNull()) {
347  lLeadNeut = lTrail;
348  }
349  if (lLeadEm.isNull()) {
350  lLeadEm = lTrail;
351  }
352  if (lLeadCh.isNull()) {
353  lLeadCh = lTrail;
354  }
355  impactTrack = lLeadCh->trackRef();
356 
357  internalId_.nCharged_ = pfjet->chargedMultiplicity();
358  internalId_.nNeutrals_ = pfjet->neutralMultiplicity();
359  internalId_.chgEMfrac_ = pfjet->chargedEmEnergy() / jet->energy();
360  internalId_.neuEMfrac_ = pfjet->neutralEmEnergy() / jet->energy();
361  internalId_.chgHadrfrac_ = pfjet->chargedHadronEnergy() / jet->energy();
362  internalId_.neuHadrfrac_ = pfjet->neutralHadronEnergy() / jet->energy();
363 
364  if (impactTrack.isNonnull() && impactTrack.isAvailable()) {
365  internalId_.d0_ = fabs(impactTrack->dxy(vtx->position()));
366  internalId_.dZ_ = fabs(impactTrack->dz(vtx->position()));
367  } else {
368  internalId_.nParticles_ = constituents.size();
369  SetPtEtaPhi(*lLead, internalId_.leadPt_, internalId_.leadEta_, internalId_.leadPhi_);
370  SetPtEtaPhi(*lSecond, internalId_.secondPt_, internalId_.secondEta_, internalId_.secondPhi_);
371  SetPtEtaPhi(*lLeadNeut, internalId_.leadNeutPt_, internalId_.leadNeutEta_, internalId_.leadNeutPhi_);
372  SetPtEtaPhi(*lLeadEm, internalId_.leadEmPt_, internalId_.leadEmEta_, internalId_.leadEmPhi_);
373  SetPtEtaPhi(*lLeadCh, internalId_.leadChPt_, internalId_.leadChEta_, internalId_.leadChPhi_);
374  std::sort(frac.begin(), frac.end(), std::greater<float>());
375  std::sort(fracCh.begin(), fracCh.end(), std::greater<float>());
376  std::sort(fracEm.begin(), fracEm.end(), std::greater<float>());
377  std::sort(fracNeut.begin(), fracNeut.end(), std::greater<float>());
378  Assign(frac, internalId_.leadFrac_, internalId_.secondFrac_, internalId_.thirdFrac_, internalId_.fourthFrac_);
379 
380  //covMatrix(0,0) /= sumPt2;
381  //covMatrix(0,1) /= sumPt2;
382  //covMatrix(1,1) /= sumPt2;
383  //covMatrix(1,0) = covMatrix(0,1);
384  //internalId_.etaW_ = sqrt(covMatrix(0,0));
385  //internalId_.phiW_ = sqrt(covMatrix(1,1));
386  //internalId_.jetW_ = 0.5*(internalId_.etaW_+internalId_.phiW_);
387  //TVectorD eigVals(2); eigVals = TMatrixDSymEigen(covMatrix).GetEigenValues();
388  //
389  if (internalId_.majW_ < internalId_.minW_) {
390  std::swap(internalId_.majW_, internalId_.minW_);
391  }
392 
393  //internalId_.dRLeadCent_ = reco::deltaR(*jet,*lLead);
394  if (lSecond.isNonnull()) {
395  internalId_.dRLead2nd_ = reco::deltaR(*jet, *lSecond);
396  }
397  internalId_.dRMeanNeut_ /= jetPt;
398  internalId_.dRMeanEm_ /= jetPt;
399  //internalId_.jetRchg_ /= jetPt;
400  internalId_.dR2Mean_ /= sumPt2;
401  for (size_t ic = 0; ic < ncones; ++ic) {
402  *coneFracs[ic] /= jetPt;
403  }
404 
405  double ptMean = sumPt / internalId_.nParticles_;
406  double ptRMS = 0;
407  for (unsigned int i0 = 0; i0 < frac.size(); i0++) {
408  ptRMS += (frac[i0] - ptMean) * (frac[i0] - ptMean);
409  }
410  ptRMS /= internalId_.nParticles_;
411  ptRMS = sqrt(ptRMS);
412  internalId_.jetRchg_ = internalId_.leadChPt_ / sumPt;
413  internalId_.jetR_ = internalId_.leadPt_ / sumPt;
414 
415  internalId_.ptMean_ = ptMean;
416  internalId_.ptRMS_ = ptRMS / jetPt;
417  internalId_.pt2A_ = sqrt(internalId_.ptD_ / internalId_.nParticles_) / jetPt;
418  internalId_.ptD_ = sqrt(internalId_.ptD_) / sumPt;
419  internalId_.sumPt_ = sumPt;
420  internalId_.sumChPt_ = sumPtCh;
421  internalId_.sumNePt_ = sumPtNe;
422  if (sumPt > 0) {
423  internalId_.beta_ /= sumPt;
424  internalId_.betaStar_ /= sumPt;
425  } else {
426  assert(internalId_.beta_ == 0. && internalId_.betaStar_ == 0.);
427  }
428  float ave_deta = sum_deta / sumPt2;
429  float ave_dphi = sum_dphi / sumPt2;
430  float ave_deta2 = sum_deta2 / sumPt2;
431  float ave_dphi2 = sum_dphi2 / sumPt2;
432  float a = ave_deta2 - ave_deta * ave_deta;
433  float b = ave_dphi2 - ave_dphi * ave_dphi;
434  float c = -(sum_detadphi / sumPt2 - ave_deta * ave_dphi);
435  float axis1 = 0;
436  float axis2 = 0;
437  if ((((a - b) * (a - b) + 4 * c * c)) > 0) {
438  float delta = sqrt(((a - b) * (a - b) + 4 * c * c));
439  if (a + b + delta > 0) {
440  axis1 = sqrt(0.5 * (a + b + delta));
441  }
442  if (a + b - delta > 0) {
443  axis2 = sqrt(0.5 * (a + b - delta));
444  }
445  } else {
446  axis1 = -1;
447  axis2 = -1;
448  }
449  internalId_.majW_ = axis1; //sqrt(fabs(eigVals(0)));
450  internalId_.minW_ = axis2; //sqrt(fabs(eigVals(1)));
451  //compute Pull
452 
453  float ddetaR_sum(0.0), ddphiR_sum(0.0);
454  for (int i = 0; i < internalId_.nParticles_; ++i) {
455  reco::PFCandidatePtr part = pfjet->getPFConstituent(i);
456  float weight = part->pt() * part->pt();
457  float deta = part->eta() - jet->eta();
458  float dphi = reco::deltaPhi(*part, *jet);
459  float ddeta, ddphi, ddR;
460  ddeta = deta - ave_deta;
461  ddphi = reco::deltaPhi(dphi, ave_dphi); //2*atan(tan((dphi - ave_dphi)/2.)) ;
462  ddR = sqrt(ddeta * ddeta + ddphi * ddphi);
463  ddetaR_sum += ddR * ddeta * weight;
464  ddphiR_sum += ddR * ddphi * weight;
465  }
466  if (sumPt2 > 0) {
467  float ddetaR_ave = ddetaR_sum / sumPt2;
468  float ddphiR_ave = ddphiR_sum / sumPt2;
469  internalId_.dRMean_ = sqrt(ddetaR_ave * ddetaR_ave + ddphiR_ave * ddphiR_ave);
470  }
471  }
472 
473  if (calculateMva) {
474  runMva();
475  }
476 
477  return PileupJetIdentifier(internalId_);
478 }
479 
480 std::string MVAJetPuId::dumpVariables() const {
481  std::stringstream out;
482  for (variables_list_t::const_iterator it = variables_.begin(); it != variables_.end(); ++it) {
483  out << std::setw(15) << it->first << std::setw(3) << "=" << std::setw(5) << *it->second.first << " ("
484  << std::setw(5) << it->second.second << ")" << std::endl;
485  }
486  return out.str();
487 }
488 
489 void MVAJetPuId::resetVariables() {
490  internalId_.idFlag_ = 0;
491  for (variables_list_t::iterator it = variables_.begin(); it != variables_.end(); ++it) {
492  *it->second.first = it->second.second;
493  }
494 }
495 
496 #define INIT_VARIABLE(NAME, TMVANAME, VAL) \
497  internalId_.NAME##_ = VAL; \
498  variables_[#NAME] = std::make_pair(&internalId_.NAME##_, VAL);
499 
500 void MVAJetPuId::initVariables() {
501  internalId_.idFlag_ = 0;
502  INIT_VARIABLE(mva, "", -100.);
503 
504  INIT_VARIABLE(jetPt, "jetPt", 0.);
505  INIT_VARIABLE(jetEta, "jetEta", large_val);
506  INIT_VARIABLE(jetPhi, "", large_val);
507  INIT_VARIABLE(jetM, "", 0.);
508  INIT_VARIABLE(nCharged, "nCharged", 0.);
509  INIT_VARIABLE(nNeutrals, "", 0.);
510 
511  INIT_VARIABLE(chgEMfrac, "", 0.);
512  INIT_VARIABLE(neuEMfrac, "", 0.);
513  INIT_VARIABLE(chgHadrfrac, "", 0.);
514  INIT_VARIABLE(neuHadrfrac, "", 0.);
515 
516  INIT_VARIABLE(d0, "", -1000.);
517  INIT_VARIABLE(dZ, "", -1000.);
518  INIT_VARIABLE(nParticles, "nParticles", 0.);
519 
520  INIT_VARIABLE(leadPt, "", 0.);
521  INIT_VARIABLE(leadEta, "", large_val);
522  INIT_VARIABLE(leadPhi, "", large_val);
523  INIT_VARIABLE(secondPt, "", 0.);
524  INIT_VARIABLE(secondEta, "", large_val);
525  INIT_VARIABLE(secondPhi, "", large_val);
526  INIT_VARIABLE(leadNeutPt, "", 0.);
527  INIT_VARIABLE(leadNeutEta, "", large_val);
528 
529  INIT_VARIABLE(jetR, "jetR", 0.);
530  INIT_VARIABLE(pull, "pull", 0.);
531  INIT_VARIABLE(jetRchg, "jetRchg", 0.);
532  INIT_VARIABLE(dR2Mean, "dR2Mean", 0.);
533 
534  INIT_VARIABLE(ptD, "ptD", 0.);
535  INIT_VARIABLE(ptMean, "", 0.);
536  INIT_VARIABLE(ptRMS, "", 0.);
537  INIT_VARIABLE(pt2A, "", 0.);
538  INIT_VARIABLE(ptDCh, "", 0.);
539  INIT_VARIABLE(ptDNe, "", 0.);
540  INIT_VARIABLE(sumPt, "", 0.);
541  INIT_VARIABLE(sumChPt, "", 0.);
542  INIT_VARIABLE(sumNePt, "", 0.);
543  INIT_VARIABLE(secondFrac, "", 0.);
544  INIT_VARIABLE(thirdFrac, "", 0.);
545  INIT_VARIABLE(fourthFrac, "", 0.);
546  INIT_VARIABLE(leadChFrac, "", 0.);
547  INIT_VARIABLE(secondChFrac, "", 0.);
548  INIT_VARIABLE(thirdChFrac, "", 0.);
549  INIT_VARIABLE(fourthChFrac, "", 0.);
550  INIT_VARIABLE(leadNeutFrac, "", 0.);
551  INIT_VARIABLE(secondNeutFrac, "", 0.);
552  INIT_VARIABLE(thirdNeutFrac, "", 0.);
553  INIT_VARIABLE(fourthNeutFrac, "", 0.);
554  INIT_VARIABLE(leadEmFrac, "", 0.);
555  INIT_VARIABLE(secondEmFrac, "", 0.);
556  INIT_VARIABLE(thirdEmFrac, "", 0.);
557  INIT_VARIABLE(fourthEmFrac, "", 0.);
558  INIT_VARIABLE(jetW, "", 1.);
559  INIT_VARIABLE(etaW, "", 1.);
560  INIT_VARIABLE(phiW, "", 1.);
561  INIT_VARIABLE(majW, "majW", 1.);
562  INIT_VARIABLE(minW, "minW", 1.);
563  INIT_VARIABLE(frac01, "frac01", 0.);
564  INIT_VARIABLE(frac02, "frac02", 0.);
565  INIT_VARIABLE(frac03, "frac03", 0.);
566  INIT_VARIABLE(frac04, "frac04", 0.);
567 
568  INIT_VARIABLE(beta, "beta", 0.);
569  INIT_VARIABLE(betaStar, "betaStar", 0.);
570  INIT_VARIABLE(betaClassic, "betaClassic", 0.);
571  INIT_VARIABLE(betaStarClassic, "betaStarClassic", 0.);
572  INIT_VARIABLE(rho, "rho", 0.);
573 }
574 #undef INIT_VARIABLE
StoredPileupJetIdentifier::dR2Mean_
float dR2Mean_
Definition: PileupJetIdentifier.h:40
reco::btau::jetPt
Definition: TaggingVariable.h:32
testProducerWithPsetDescEmpty_cfi.i2
i2
Definition: testProducerWithPsetDescEmpty_cfi.py:46
PileupJetIdentifier::dRMeanEm_
float dRMeanEm_
Definition: PileupJetIdentifier.h:124
PileupJetIdentifier::leadNeutPt_
float leadNeutPt_
Definition: PileupJetIdentifier.h:111
mps_fire.i
i
Definition: mps_fire.py:428
MVAJetPuId::initVariables
void initVariables()
Definition: MVAJetPuId.cc:500
reco::Jet
Base class for all types of Jets.
Definition: Jet.h:20
PileupJetIdentifier::secondEta_
float secondEta_
Definition: PileupJetIdentifier.h:109
PileupJetIdentifier::d0_
float d0_
Definition: PileupJetIdentifier.h:104
MVAJetPuId::computeIdVariables
PileupJetIdentifier computeIdVariables(const reco::Jet *jet, float jec, const reco::Vertex *, const reco::VertexCollection &, double rho, bool calculateMva=false)
Definition: MVAJetPuId.cc:196
PileupJetIdentifier::sumChPt_
float sumChPt_
Definition: PileupJetIdentifier.h:133
HLT_FULL_cff.nCharged
nCharged
Definition: HLT_FULL_cff.py:33250
reco::PFJet::getPFConstituents
virtual std::vector< reco::PFCandidatePtr > getPFConstituents() const
get all constituents
Definition: PFJet.cc:41
jets_cff.ptD
ptD
Definition: jets_cff.py:145
StoredPileupJetIdentifier::jetR_
float jetR_
Definition: PileupJetIdentifier.h:64
PileupJetIdentifier::idFlag_
int idFlag_
Definition: PileupJetIdentifier.h:91
hltPUIdAlgo_cff.tmvaMethod
tmvaMethod
Definition: hltPUIdAlgo_cff.py:32
PFCandidate.h
BeamSpotFakeParameters_cfi.betaStar
betaStar
Definition: BeamSpotFakeParameters_cfi.py:19
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
edm::Ref::isAvailable
bool isAvailable() const
Definition: Ref.h:537
min
T min(T a, T b)
Definition: MathUtil.h:58
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
PileupJetIdentifier::kTight
Definition: PileupJetIdentifier.h:87
HLT_FULL_cff.beta
beta
Definition: HLT_FULL_cff.py:8686
PileupJetIdentifier::leadPhi_
float leadPhi_
Definition: PileupJetIdentifier.h:107
mps_merge.weight
weight
Definition: mps_merge.py:88
PileupJetIdentifier::pt2A_
float pt2A_
Definition: PileupJetIdentifier.h:129
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
gpuVertexFinder::iv
int32_t *__restrict__ iv
Definition: gpuClusterTracksDBSCAN.h:42
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
ZElectronSkim_cff.rho
rho
Definition: ZElectronSkim_cff.py:38
PFJet.h
testProducerWithPsetDescEmpty_cfi.i1
i1
Definition: testProducerWithPsetDescEmpty_cfi.py:45
PileupJetIdentifier::leadEmPt_
float leadEmPt_
Definition: PileupJetIdentifier.h:114
PileupJetIdentifier::mva_
float mva_
Definition: PileupJetIdentifier.h:94
StoredPileupJetIdentifier::rho_
float rho_
Definition: PileupJetIdentifier.h:63
PileupJetIdentifier::sumPt_
float sumPt_
Definition: PileupJetIdentifier.h:132
cms::cuda::assert
assert(be >=bs)
PileupJetIdentifier::jetM_
float jetM_
Definition: PileupJetIdentifier.h:97
PileupJetIdentifier::thirdFrac_
float thirdFrac_
Definition: PileupJetIdentifier.h:138
INIT_VARIABLE
#define INIT_VARIABLE(NAME, TMVANAME, VAL)
Definition: MVAJetPuId.cc:496
Jet.h
LHEJetFilter_cfi.jetR
jetR
Definition: LHEJetFilter_cfi.py:5
reco::TrackBaseRef
edm::RefToBase< reco::Track > TrackBaseRef
persistent reference to a Track, using views
Definition: TrackFwd.h:35
MVAJetPuId::tmvaNames_
std::map< std::string, std::string > tmvaNames_
Definition: MVAJetPuId.h:68
StoredPileupJetIdentifier::dRMean_
float dRMean_
Definition: PileupJetIdentifier.h:44
beam_dqm_sourceclient-live_cfg.mva
mva
Definition: beam_dqm_sourceclient-live_cfg.py:124
PileupJetIdentifier::chgHadrfrac_
float chgHadrfrac_
Definition: PileupJetIdentifier.h:101
StoredPileupJetIdentifier::dZ_
float dZ_
Definition: PileupJetIdentifier.h:37
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
StoredPileupJetIdentifier::minW_
float minW_
Definition: PileupJetIdentifier.h:47
PileupJetIdentifier::neuHadrfrac_
float neuHadrfrac_
Definition: PileupJetIdentifier.h:102
PileupJetIdentifier::leadChEta_
float leadChEta_
Definition: PileupJetIdentifier.h:118
Assign
void Assign(const std::vector< float > &vec, float &a, float &b, float &c, float &d)
Definition: MVAJetPuId.cc:111
MVAJetPuId::computeMva
PileupJetIdentifier computeMva()
Definition: MVAJetPuId.cc:191
edm::Ref< TrackCollection >
FileInPath.h
TtFullHadEvtBuilder_cfi.sumPt
sumPt
Definition: TtFullHadEvtBuilder_cfi.py:38
PileupJetIdentifier.h
StoredPileupJetIdentifier::jetPt_
float jetPt_
Definition: PileupJetIdentifier.h:32
MVAJetPuId::tmvaWeights_
std::string tmvaWeights_
Definition: MVAJetPuId.h:65
hltPUIdAlgo_cff.tmvaVariables
tmvaVariables
Definition: hltPUIdAlgo_cff.py:34
reco::PFJet::chargedHadronEnergy
float chargedHadronEnergy() const
chargedHadronEnergy
Definition: PFJet.h:95
MVAJetPuId::reader_
TMVA::Reader * reader_
Definition: MVAJetPuId.h:64
edm::FileInPath
Definition: FileInPath.h:64
MVAJetPuId::set
void set(const PileupJetIdentifier &)
Definition: MVAJetPuId.cc:143
part
part
Definition: HCALResponse.h:20
MVAJetPuId::tmvaMethod_
std::string tmvaMethod_
Definition: MVAJetPuId.h:65
DivergingColor.frac
float frac
Definition: DivergingColor.py:175
MVAJetPuId::internalId_
PileupJetIdentifier internalId_
Definition: MVAJetPuId.h:61
std::swap
void swap(edm::DataFrameContainer &lhs, edm::DataFrameContainer &rhs)
Definition: DataFrameContainer.h:209
PVValHelper::eta
Definition: PVValidationHelpers.h:70
MVAJetPuId.h
StoredPileupJetIdentifier::jetEta_
float jetEta_
Definition: PileupJetIdentifier.h:31
PileupJetIdentifier::leadNeutPhi_
float leadNeutPhi_
Definition: PileupJetIdentifier.h:113
reco::PFJet::chargedMultiplicity
int chargedMultiplicity() const
chargedMultiplicity
Definition: PFJet.h:152
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
PileupJetIdentifier::fourthFrac_
float fourthFrac_
Definition: PileupJetIdentifier.h:139
MVAJetPuId::impactParTkThreshod_
Float_t impactParTkThreshod_
Definition: MVAJetPuId.h:71
MVAJetPuId::resetVariables
void resetVariables()
Definition: MVAJetPuId.cc:489
MVAJetPuId::MVAJetPuId
MVAJetPuId(int version=CATEv0, const std::string &tmvaWeight="", const std::string &tmvaMethod="", Float_t impactParTkThreshod_=1., const std::vector< std::string > &tmvaVariables=std::vector< std::string >())
Definition: MVAJetPuId.cc:50
reco::PFJet::chargedEmEnergy
float chargedEmEnergy() const
chargedEmEnergy
Definition: PFJet.h:139
PileupJetIdentifier::dRMeanNeut_
float dRMeanNeut_
Definition: PileupJetIdentifier.h:123
StoredPileupJetIdentifier::frac02_
float frac02_
Definition: PileupJetIdentifier.h:50
MVAJetPuId::setup
void setup()
Definition: MVAJetPuId.cc:66
MVAJetPuId::dumpVariables
std::string dumpVariables() const
Definition: MVAJetPuId.cc:480
MVAJetPuId::getJetIdKey
std::pair< int, int > getJetIdKey(float jetPt, float jetEta)
Definition: MVAJetPuId.cc:156
SetPtEtaPhi
void SetPtEtaPhi(const reco::Candidate &p, float &pt, float &eta, float &phi)
Definition: MVAJetPuId.cc:119
b
double b
Definition: hdecay.h:118
first
auto first
Definition: CAHitNtupletGeneratorKernelsImpl.h:112
PileupJetIdentifier::dRLead2nd_
float dRLead2nd_
Definition: PileupJetIdentifier.h:122
StoredPileupJetIdentifier::nParticles_
float nParticles_
Definition: PileupJetIdentifier.h:38
DDAxes::rho
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
MVAJetPuId::computeIDflag
int computeIDflag(float mva, float jetPt, float jetEta)
Definition: MVAJetPuId.cc:175
Vertex.h
reco::btau::jetPhi
Definition: TaggingVariable.h:36
MVAJetPuId::tmvaSpectators_
std::vector< std::string > tmvaSpectators_
Definition: MVAJetPuId.h:67
pfDeepBoostedJetPreprocessParams_cfi.lower_bound
lower_bound
Definition: pfDeepBoostedJetPreprocessParams_cfi.py:15
PileupJetIdentifier::secondPt_
float secondPt_
Definition: PileupJetIdentifier.h:108
reco::btau::jetEta
Definition: TaggingVariable.h:34
StoredPileupJetIdentifier::betaStar_
float betaStar_
Definition: PileupJetIdentifier.h:58
StoredPileupJetIdentifier::frac04_
float frac04_
Definition: PileupJetIdentifier.h:52
edm::ParameterSet
Definition: ParameterSet.h:47
a
double a
Definition: hdecay.h:119
PVValHelper::phi
Definition: PVValidationHelpers.h:69
deltaR.h
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
MVAJetPuId::bookReader
void bookReader()
Definition: MVAJetPuId.cc:125
jetUpdater_cfi.sort
sort
Definition: jetUpdater_cfi.py:29
StoredPileupJetIdentifier::nNeutrals_
float nNeutrals_
Definition: PileupJetIdentifier.h:35
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
dumpMFGeometry_cfg.delta
delta
Definition: dumpMFGeometry_cfg.py:25
MVAJetPuId::NWPs
static constexpr int NWPs
Definition: MVAJetPuId.h:17
PileupJetIdentifier::leadEta_
float leadEta_
Definition: PileupJetIdentifier.h:106
PileupJetIdentifier::leadFrac_
float leadFrac_
Definition: PileupJetIdentifier.h:136
PileupJetIdentifier::neuEMfrac_
float neuEMfrac_
Definition: PileupJetIdentifier.h:100
large_val
const float large_val
Definition: MVAJetPuId.cc:14
reco::PFCandidate::gamma
Definition: PFCandidate.h:49
PileupJetIdentifier
Definition: PileupJetIdentifier.h:74
StoredPileupJetIdentifier::frac03_
float frac03_
Definition: PileupJetIdentifier.h:51
PileupJetIdentifier::chgEMfrac_
float chgEMfrac_
Definition: PileupJetIdentifier.h:99
PileupJetIdentifier::secondFrac_
float secondFrac_
Definition: PileupJetIdentifier.h:137
MVAJetPuId::runMva
void runMva()
Definition: MVAJetPuId.cc:145
PileupJetIdentifier::jetPhi_
float jetPhi_
Definition: PileupJetIdentifier.h:96
edm::Ptr< PFCandidate >
reco::Candidate
Definition: Candidate.h:27
alignCSCRings.r
r
Definition: alignCSCRings.py:93
MVAJetPuId::tmvaVariables_
std::vector< std::string > tmvaVariables_
Definition: MVAJetPuId.h:66
PileupJetIdentifier::leadEmEta_
float leadEmEta_
Definition: PileupJetIdentifier.h:115
PileupJetIdentifier::sumNePt_
float sumNePt_
Definition: PileupJetIdentifier.h:134
StoredPileupJetIdentifier::jetRchg_
float jetRchg_
Definition: PileupJetIdentifier.h:65
StoredPileupJetIdentifier::betaClassic_
float betaClassic_
Definition: PileupJetIdentifier.h:59
PileupJetIdentifier::kLoose
Definition: PileupJetIdentifier.h:87
reco::PFJet::getPFConstituent
virtual reco::PFCandidatePtr getPFConstituent(unsigned fIndex) const
get specific constituent
Definition: PFJet.cc:27
extraflags_cff.vtx
vtx
Definition: extraflags_cff.py:18
Frameworkfwd.h
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:29
reco::PFJet::neutralHadronEnergy
float neutralHadronEnergy() const
neutralHadronEnergy
Definition: PFJet.h:99
MVAJetPuId::mvacut_
Float_t mvacut_[NWPs][NEtas][NPts]
Definition: MVAJetPuId.h:73
metsig::jet
Definition: SignAlgoResolutions.h:47
reco::PFCandidate::h0
Definition: PFCandidate.h:50
relativeConstraints.empty
bool empty
Definition: relativeConstraints.py:46
reco::PFJet::neutralMultiplicity
int neutralMultiplicity() const
neutralMultiplicity
Definition: PFJet.h:154
reco::details::loadTMVAWeights
TMVA::IMethod * loadTMVAWeights(TMVA::Reader *reader, const std::string &method, const std::string &weightFile, bool verbose=false)
Definition: TMVAZipReader.cc:52
reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:20
PileupJetIdentifier::secondPhi_
float secondPhi_
Definition: PileupJetIdentifier.h:110
reco::PFJet::neutralEmEnergy
float neutralEmEnergy() const
neutralEmEnergy
Definition: PFJet.h:147
StoredPileupJetIdentifier::beta_
float beta_
Definition: PileupJetIdentifier.h:57
reco::deltaR
constexpr auto deltaR(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:30
edm::Ptr::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ptr.h:146
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
TMVAZipReader.h
PileupJetIdentifier::ptRMS_
float ptRMS_
Definition: PileupJetIdentifier.h:128
PileupJetIdentifier::leadPt_
float leadPt_
Definition: PileupJetIdentifier.h:105
MVAJetPuId::version_
Int_t version_
Definition: MVAJetPuId.h:70
MVAJetPuId::~MVAJetPuId
~MVAJetPuId()
Definition: MVAJetPuId.cc:105
jetMETDQMOfflineSource_cff.jec
jec
Definition: jetMETDQMOfflineSource_cff.py:27
MillePedeFileConverter_cfg.out
out
Definition: MillePedeFileConverter_cfg.py:31
edm::Ptr::isAvailable
bool isAvailable() const
Definition: Ptr.h:230
ztail.d
d
Definition: ztail.py:151
StoredPileupJetIdentifier::betaStarClassic_
float betaStarClassic_
Definition: PileupJetIdentifier.h:60
c
auto & c
Definition: CAHitNtupletGeneratorKernelsImpl.h:46
PileupJetIdentifier::leadNeutEta_
float leadNeutEta_
Definition: PileupJetIdentifier.h:112
MVAJetPuId::NPts
static constexpr int NPts
Definition: MVAJetPuId.h:18
PileupJetIdentifier::leadChPt_
float leadChPt_
Definition: PileupJetIdentifier.h:117
PileupJetIdentifier::leadEmPhi_
float leadEmPhi_
Definition: PileupJetIdentifier.h:116
hltPUIdAlgo_cff.tmvaWeights
tmvaWeights
Definition: hltPUIdAlgo_cff.py:31
PileupJetIdentifier::kMedium
Definition: PileupJetIdentifier.h:87
StoredPileupJetIdentifier::majW_
float majW_
Definition: PileupJetIdentifier.h:46
d0
static constexpr float d0
Definition: L1EGammaCrystalsEmulatorProducer.cc:85
BeamSplash_cfg.version
version
Definition: BeamSplash_cfg.py:45
MVAJetPuId::variables_
variables_list_t variables_
Definition: MVAJetPuId.h:62
PileupJetIdentifier::ptMean_
float ptMean_
Definition: PileupJetIdentifier.h:127
StoredPileupJetIdentifier::frac01_
float frac01_
Definition: PileupJetIdentifier.h:49
edm::Ptr::isNull
bool isNull() const
Checks for null.
Definition: Ptr.h:142
weight
Definition: weight.py:1
reco::Vertex
Definition: Vertex.h:35
edm::FileInPath::fullPath
std::string fullPath() const
Definition: FileInPath.cc:161
StoredPileupJetIdentifier::nCharged_
float nCharged_
Definition: PileupJetIdentifier.h:34
PileupJetIdentifier::leadChPhi_
float leadChPhi_
Definition: PileupJetIdentifier.h:119
StoredPileupJetIdentifier::ptD_
float ptD_
Definition: PileupJetIdentifier.h:62
Generated for CMSSW Reference Manual by doxygen 1.8.16