CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
PileupJetIdAlgo.cc
Go to the documentation of this file.
1 #include "RecoJets/JetProducers/interface/PileupJetIdAlgo.h"
2 
3 #include "DataFormats/JetReco/interface/PFJet.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 "FWCore/MessageLogger/interface/MessageLogger.h"
10 #include "CommonTools/MVAUtils/interface/GBRForestTools.h"
11 
12 #include "TMatrixDSym.h"
13 #include "TMatrixDSymEigen.h"
14 
15 #include <utility>
16 
17 // ------------------------------------------------------------------------------------------
18 const float large_val = std::numeric_limits<float>::max();
19 
20 // ------------------------------------------------------------------------------------------
21 
22 PileupJetIdAlgo::AlgoGBRForestsAndConstants::AlgoGBRForestsAndConstants(edm::ParameterSet const& ps, bool runMvas)
23  : cutBased_(ps.getParameter<bool>("cutBased")),
24  etaBinnedWeights_(false),
25  runMvas_(runMvas),
26  nEtaBins_(0),
27  label_(ps.getParameter<std::string>("label")),
28  mvacut_{},
29  rmsCut_{},
30  betaStarCut_{} {
31  std::vector<edm::FileInPath> tmvaEtaWeights;
32  std::vector<std::string> tmvaSpectators;
33  int version;
34 
35  if (!cutBased_) {
36  etaBinnedWeights_ = ps.getParameter<bool>("etaBinnedWeights");
37  if (etaBinnedWeights_) {
38  const std::vector<edm::ParameterSet>& trainings = ps.getParameter<std::vector<edm::ParameterSet> >("trainings");
39  nEtaBins_ = ps.getParameter<int>("nEtaBins");
40  for (int v = 0; v < nEtaBins_; v++) {
41  tmvaEtaWeights.push_back(trainings.at(v).getParameter<edm::FileInPath>("tmvaWeights"));
42  jEtaMin_.push_back(trainings.at(v).getParameter<double>("jEtaMin"));
43  jEtaMax_.push_back(trainings.at(v).getParameter<double>("jEtaMax"));
44  }
45  for (int v = 0; v < nEtaBins_; v++) {
46  tmvaEtaVariables_.push_back(trainings.at(v).getParameter<std::vector<std::string> >("tmvaVariables"));
47  }
48  } else {
49  tmvaVariables_ = ps.getParameter<std::vector<std::string> >("tmvaVariables");
50  }
51  tmvaMethod_ = ps.getParameter<std::string>("tmvaMethod");
52  tmvaSpectators = ps.getParameter<std::vector<std::string> >("tmvaSpectators");
53  version = ps.getParameter<int>("version");
54  } else {
55  version = USER;
56  }
57 
58  edm::ParameterSet jetConfig = ps.getParameter<edm::ParameterSet>("JetIdParams");
59  for (int i0 = 0; i0 < 3; i0++) {
60  std::string lCutType = "Tight";
61  if (i0 == PileupJetIdentifier::kMedium)
62  lCutType = "Medium";
63  if (i0 == PileupJetIdentifier::kLoose)
64  lCutType = "Loose";
65  int nCut = 1;
66  if (cutBased_)
67  nCut++;
68  for (int i1 = 0; i1 < nCut; i1++) {
69  std::string lFullCutType = lCutType;
70  if (cutBased_ && i1 == 0)
71  lFullCutType = "BetaStar" + lCutType;
72  if (cutBased_ && i1 == 1)
73  lFullCutType = "RMS" + lCutType;
74  std::vector<double> pt010 = jetConfig.getParameter<std::vector<double> >(("Pt010_" + lFullCutType).c_str());
75  std::vector<double> pt1020 = jetConfig.getParameter<std::vector<double> >(("Pt1020_" + lFullCutType).c_str());
76  std::vector<double> pt2030 = jetConfig.getParameter<std::vector<double> >(("Pt2030_" + lFullCutType).c_str());
77  std::vector<double> pt3040 = jetConfig.getParameter<std::vector<double> >(("Pt3040_" + lFullCutType).c_str());
78  std::vector<double> pt4050 = jetConfig.getParameter<std::vector<double> >(("Pt4050_" + lFullCutType).c_str());
79  if (!cutBased_) {
80  for (int i2 = 0; i2 < 4; i2++)
81  mvacut_[i0][0][i2] = pt010[i2];
82  for (int i2 = 0; i2 < 4; i2++)
83  mvacut_[i0][1][i2] = pt1020[i2];
84  for (int i2 = 0; i2 < 4; i2++)
85  mvacut_[i0][2][i2] = pt2030[i2];
86  for (int i2 = 0; i2 < 4; i2++)
87  mvacut_[i0][3][i2] = pt3040[i2];
88  for (int i2 = 0; i2 < 4; i2++)
89  mvacut_[i0][4][i2] = pt4050[i2];
90  }
91  if (cutBased_ && i1 == 0) {
92  for (int i2 = 0; i2 < 4; i2++)
93  betaStarCut_[i0][0][i2] = pt010[i2];
94  for (int i2 = 0; i2 < 4; i2++)
95  betaStarCut_[i0][1][i2] = pt1020[i2];
96  for (int i2 = 0; i2 < 4; i2++)
97  betaStarCut_[i0][2][i2] = pt2030[i2];
98  for (int i2 = 0; i2 < 4; i2++)
99  betaStarCut_[i0][3][i2] = pt3040[i2];
100  for (int i2 = 0; i2 < 4; i2++)
101  betaStarCut_[i0][4][i2] = pt4050[i2];
102  }
103  if (cutBased_ && i1 == 1) {
104  for (int i2 = 0; i2 < 4; i2++)
105  rmsCut_[i0][0][i2] = pt010[i2];
106  for (int i2 = 0; i2 < 4; i2++)
107  rmsCut_[i0][1][i2] = pt1020[i2];
108  for (int i2 = 0; i2 < 4; i2++)
109  rmsCut_[i0][2][i2] = pt2030[i2];
110  for (int i2 = 0; i2 < 4; i2++)
111  rmsCut_[i0][3][i2] = pt3040[i2];
112  for (int i2 = 0; i2 < 4; i2++)
113  rmsCut_[i0][4][i2] = pt4050[i2];
114  }
115  }
116  }
117 
118  if (!cutBased_) {
119  assert(tmvaMethod_.empty() || ((!tmvaVariables_.empty() || (!tmvaEtaVariables_.empty())) && version == USER));
120  }
121 
122  if ((!cutBased_) && (runMvas_)) {
123  if (etaBinnedWeights_) {
124  for (int v = 0; v < nEtaBins_; v++) {
125  etaReader_.push_back(createGBRForest(tmvaEtaWeights.at(v)));
126  }
127  } else {
128  reader_ = createGBRForest(ps.getParameter<std::string>("tmvaWeights"));
129  }
130  }
131 }
132 
133 PileupJetIdAlgo::PileupJetIdAlgo(AlgoGBRForestsAndConstants const* cache) : cache_(cache) { initVariables(); }
134 
135 // ------------------------------------------------------------------------------------------
136 PileupJetIdAlgo::~PileupJetIdAlgo() {}
137 
138 // ------------------------------------------------------------------------------------------
139 void assign(const std::vector<float>& vec, float& a, float& b, float& c, float& d) {
140  size_t sz = vec.size();
141  a = (sz > 0 ? vec[0] : 0.);
142  b = (sz > 1 ? vec[1] : 0.);
143  c = (sz > 2 ? vec[2] : 0.);
144  d = (sz > 3 ? vec[3] : 0.);
145 }
146 // ------------------------------------------------------------------------------------------
147 void setPtEtaPhi(const reco::Candidate& p, float& pt, float& eta, float& phi) {
148  pt = p.pt();
149  eta = p.eta();
150  phi = p.phi();
151 }
152 
153 // ------------------------------------------------------------------------------------------
154 void PileupJetIdAlgo::set(const PileupJetIdentifier& id) { internalId_ = id; }
155 
156 // ------------------------------------------------------------------------------------------
157 
158 float PileupJetIdAlgo::getMVAval(const std::vector<std::string>& varList,
159  const std::unique_ptr<const GBRForest>& reader) {
160  std::vector<float> vars;
161  for (std::vector<std::string>::const_iterator it = varList.begin(); it != varList.end(); ++it) {
162  std::pair<float*, float> var = variables_.at(*it);
163  vars.push_back(*var.first);
164  }
165  return reader->GetClassifier(vars.data());
166 }
167 
168 void PileupJetIdAlgo::runMva() {
169  if (cache_->cutBased()) {
170  internalId_.idFlag_ = computeCutIDflag(
171  internalId_.betaStarClassic_, internalId_.dR2Mean_, internalId_.nvtx_, internalId_.jetPt_, internalId_.jetEta_);
172  } else {
173  if (std::abs(internalId_.jetEta_) >= 5.0) {
174  internalId_.mva_ = -2.;
175  } else {
176  if (cache_->etaBinnedWeights()) {
177  if (std::abs(internalId_.jetEta_) > cache_->jEtaMax().at(cache_->nEtaBins() - 1)) {
178  internalId_.mva_ = -2.;
179  } else {
180  for (int v = 0; v < cache_->nEtaBins(); v++) {
181  if (std::abs(internalId_.jetEta_) >= cache_->jEtaMin().at(v) &&
182  std::abs(internalId_.jetEta_) < cache_->jEtaMax().at(v)) {
183  internalId_.mva_ = getMVAval(cache_->tmvaEtaVariables().at(v), cache_->etaReader().at(v));
184  break;
185  }
186  }
187  }
188  } else {
189  internalId_.mva_ = getMVAval(cache_->tmvaVariables(), cache_->reader());
190  }
191  }
192  internalId_.idFlag_ = computeIDflag(internalId_.mva_, internalId_.jetPt_, internalId_.jetEta_);
193  }
194 }
195 
196 // ------------------------------------------------------------------------------------------
197 std::pair<int, int> PileupJetIdAlgo::getJetIdKey(float jetPt, float jetEta) {
198  int ptId = 0;
199  if (jetPt >= 10 && jetPt < 20)
200  ptId = 1;
201  if (jetPt >= 20 && jetPt < 30)
202  ptId = 2;
203  if (jetPt >= 30 && jetPt < 40)
204  ptId = 3;
205  if (jetPt >= 40)
206  ptId = 4;
207 
208  int etaId = 0;
209  if (std::abs(jetEta) >= 2.5 && std::abs(jetEta) < 2.75)
210  etaId = 1;
211  if (std::abs(jetEta) >= 2.75 && std::abs(jetEta) < 3.0)
212  etaId = 2;
213  if (std::abs(jetEta) >= 3.0 && std::abs(jetEta) < 5.0)
214  etaId = 3;
215 
216  return std::pair<int, int>(ptId, etaId);
217 }
218 // ------------------------------------------------------------------------------------------
219 int PileupJetIdAlgo::computeCutIDflag(float betaStarClassic, float dR2Mean, float nvtx, float jetPt, float jetEta) {
220  std::pair<int, int> jetIdKey = getJetIdKey(jetPt, jetEta);
221  float betaStarModified = betaStarClassic / log(nvtx - 0.64);
222  int idFlag(0);
223  if (betaStarModified < cache_->betaStarCut()[PileupJetIdentifier::kTight][jetIdKey.first][jetIdKey.second] &&
224  dR2Mean < cache_->rmsCut()[PileupJetIdentifier::kTight][jetIdKey.first][jetIdKey.second])
225  idFlag += 1 << PileupJetIdentifier::kTight;
226 
227  if (betaStarModified < cache_->betaStarCut()[PileupJetIdentifier::kMedium][jetIdKey.first][jetIdKey.second] &&
228  dR2Mean < cache_->rmsCut()[PileupJetIdentifier::kMedium][jetIdKey.first][jetIdKey.second])
229  idFlag += 1 << PileupJetIdentifier::kMedium;
230 
231  if (betaStarModified < cache_->betaStarCut()[PileupJetIdentifier::kLoose][jetIdKey.first][jetIdKey.second] &&
232  dR2Mean < cache_->rmsCut()[PileupJetIdentifier::kLoose][jetIdKey.first][jetIdKey.second])
233  idFlag += 1 << PileupJetIdentifier::kLoose;
234  return idFlag;
235 }
236 // ------------------------------------------------------------------------------------------
237 int PileupJetIdAlgo::computeIDflag(float mva, float jetPt, float jetEta) {
238  std::pair<int, int> jetIdKey = getJetIdKey(jetPt, jetEta);
239  return computeIDflag(mva, jetIdKey.first, jetIdKey.second);
240 }
241 
242 // ------------------------------------------------------------------------------------------
243 int PileupJetIdAlgo::computeIDflag(float mva, int ptId, int etaId) {
244  int idFlag(0);
245  if (mva > cache_->mvacut()[PileupJetIdentifier::kTight][ptId][etaId])
246  idFlag += 1 << PileupJetIdentifier::kTight;
247  if (mva > cache_->mvacut()[PileupJetIdentifier::kMedium][ptId][etaId])
248  idFlag += 1 << PileupJetIdentifier::kMedium;
249  if (mva > cache_->mvacut()[PileupJetIdentifier::kLoose][ptId][etaId])
250  idFlag += 1 << PileupJetIdentifier::kLoose;
251  return idFlag;
252 }
253 
254 // ------------------------------------------------------------------------------------------
255 PileupJetIdentifier PileupJetIdAlgo::computeMva() {
256  runMva();
257  return PileupJetIdentifier(internalId_);
258 }
259 
260 // ------------------------------------------------------------------------------------------
261 PileupJetIdentifier PileupJetIdAlgo::computeIdVariables(const reco::Jet* jet,
262  float jec,
263  const reco::Vertex* vtx,
264  const reco::VertexCollection& allvtx,
265  double rho,
266  bool usePuppi) {
267  // initialize all variables to 0
268  resetVariables();
269 
270  // loop over constituents, accumulate sums and find leading candidates
271  const pat::Jet* patjet = dynamic_cast<const pat::Jet*>(jet);
272  const reco::PFJet* pfjet = dynamic_cast<const reco::PFJet*>(jet);
273  assert(patjet != nullptr || pfjet != nullptr);
274  if (patjet != nullptr && jec == 0.) { // if this is a pat jet and no jec has been passed take the jec from the object
275  jec = patjet->pt() / patjet->correctedJet(0).pt();
276  }
277  if (jec <= 0.) {
278  jec = 1.;
279  }
280 
281  const reco::Candidate *lLead = nullptr, *lSecond = nullptr, *lLeadNeut = nullptr, *lLeadEm = nullptr,
282  *lLeadCh = nullptr, *lTrail = nullptr;
283  std::vector<float> frac, fracCh, fracEm, fracNeut;
284  float cones[] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7};
285  size_t ncones = sizeof(cones) / sizeof(float);
286  float* coneFracs[] = {&internalId_.frac01_,
287  &internalId_.frac02_,
288  &internalId_.frac03_,
289  &internalId_.frac04_,
290  &internalId_.frac05_,
291  &internalId_.frac06_,
292  &internalId_.frac07_};
293  float* coneEmFracs[] = {&internalId_.emFrac01_,
294  &internalId_.emFrac02_,
295  &internalId_.emFrac03_,
296  &internalId_.emFrac04_,
297  &internalId_.emFrac05_,
298  &internalId_.emFrac06_,
299  &internalId_.emFrac07_};
300  float* coneNeutFracs[] = {&internalId_.neutFrac01_,
301  &internalId_.neutFrac02_,
302  &internalId_.neutFrac03_,
303  &internalId_.neutFrac04_,
304  &internalId_.neutFrac05_,
305  &internalId_.neutFrac06_,
306  &internalId_.neutFrac07_};
307  float* coneChFracs[] = {&internalId_.chFrac01_,
308  &internalId_.chFrac02_,
309  &internalId_.chFrac03_,
310  &internalId_.chFrac04_,
311  &internalId_.chFrac05_,
312  &internalId_.chFrac06_,
313  &internalId_.chFrac07_};
314  TMatrixDSym covMatrix(2);
315  covMatrix = 0.;
316  float jetPt = jet->pt() / jec; // use uncorrected pt for shape variables
317  float sumPt = 0., sumPt2 = 0., sumTkPt = 0., sumPtCh = 0, sumPtNe = 0;
318  float multNeut = 0.0;
319  setPtEtaPhi(
320  *jet, internalId_.jetPt_, internalId_.jetEta_, internalId_.jetPhi_); // use corrected pt for jet kinematics
321  internalId_.jetM_ = jet->mass();
322  internalId_.nvtx_ = allvtx.size();
323  internalId_.rho_ = rho;
324 
325  float dRmin(1000);
326 
327  for (unsigned i = 0; i < jet->numberOfSourceCandidatePtrs(); ++i) {
328  reco::CandidatePtr pfJetConstituent = jet->sourceCandidatePtr(i);
329 
330  const reco::Candidate* icand = pfJetConstituent.get();
331  const pat::PackedCandidate* lPack = dynamic_cast<const pat::PackedCandidate*>(icand);
332  const reco::PFCandidate* lPF = dynamic_cast<const reco::PFCandidate*>(icand);
333  bool isPacked = true;
334  if (lPack == nullptr) {
335  isPacked = false;
336  }
337  float candPuppiWeight = 1.0;
338  if (usePuppi && isPacked)
339  candPuppiWeight = lPack->puppiWeight();
340  float candPt = (icand->pt()) * candPuppiWeight;
341  float candPtFrac = candPt / jetPt;
342  float candDr = reco::deltaR(*icand, *jet);
343  float candDeta = icand->eta() - jet->eta();
344  float candDphi = reco::deltaPhi(*icand, *jet);
345  float candPtDr = candPt * candDr;
346  size_t icone = std::lower_bound(&cones[0], &cones[ncones], candDr) - &cones[0];
347 
348  if (candDr < dRmin)
349  dRmin = candDr;
350 
351  // // all particles
352  if (lLead == nullptr || candPt > lLead->pt()) {
353  lSecond = lLead;
354  lLead = icand;
355  } else if ((lSecond == nullptr || candPt > lSecond->pt()) && (candPt < lLead->pt())) {
356  lSecond = icand;
357  }
358 
359  // // average shapes
360  internalId_.dRMean_ += candPtDr;
361  internalId_.dR2Mean_ += candPtDr * candPtDr;
362  covMatrix(0, 0) += candPt * candPt * candDeta * candDeta;
363  covMatrix(0, 1) += candPt * candPt * candDeta * candDphi;
364  covMatrix(1, 1) += candPt * candPt * candDphi * candDphi;
365  internalId_.ptD_ += candPt * candPt;
366  sumPt += candPt;
367  sumPt2 += candPt * candPt;
368 
369  // single most energetic candiates and jet shape profiles
370  frac.push_back(candPtFrac);
371 
372  if (icone < ncones) {
373  *coneFracs[icone] += candPt;
374  }
375 
376  // neutrals
377  if (abs(icand->pdgId()) == 130) {
378  if (lLeadNeut == nullptr || candPt > lLeadNeut->pt()) {
379  lLeadNeut = icand;
380  }
381  internalId_.dRMeanNeut_ += candPtDr;
382  fracNeut.push_back(candPtFrac);
383  if (icone < ncones) {
384  *coneNeutFracs[icone] += candPt;
385  }
386  internalId_.ptDNe_ += candPt * candPt;
387  sumPtNe += candPt;
388  multNeut += candPuppiWeight;
389  }
390  // EM candidated
391  if (icand->pdgId() == 22) {
392  if (lLeadEm == nullptr || candPt > lLeadEm->pt()) {
393  lLeadEm = icand;
394  }
395  internalId_.dRMeanEm_ += candPtDr;
396  fracEm.push_back(candPtFrac);
397  if (icone < ncones) {
398  *coneEmFracs[icone] += candPt;
399  }
400  internalId_.ptDNe_ += candPt * candPt;
401  sumPtNe += candPt;
402  multNeut += candPuppiWeight;
403  }
404  if ((abs(icand->pdgId()) == 1) || (abs(icand->pdgId()) == 2))
405  multNeut += candPuppiWeight;
406 
407  // Charged particles
408  if (icand->charge() != 0) {
409  if (lLeadCh == nullptr || candPt > lLeadCh->pt()) {
410  lLeadCh = icand;
411 
412  const reco::Track* pfTrk = icand->bestTrack();
413  if (lPF && std::abs(icand->pdgId()) == 13 && pfTrk == nullptr) {
414  reco::MuonRef lmuRef = lPF->muonRef();
415  if (lmuRef.isNonnull()) {
416  const reco::Muon& lmu = *lmuRef.get();
417  pfTrk = lmu.bestTrack();
418  edm::LogWarning("BadMuon")
419  << "Found a PFCandidate muon without a trackRef: falling back to Muon::bestTrack ";
420  }
421  }
422  if (pfTrk == nullptr) { //protection against empty pointers for the miniAOD case
423  //To handle the electron case
424  if (isPacked) {
425  internalId_.d0_ = std::abs(lPack->dxy(vtx->position()));
426  internalId_.dZ_ = std::abs(lPack->dz(vtx->position()));
427  } else if (lPF != nullptr) {
428  pfTrk = (lPF->trackRef().get() == nullptr) ? lPF->gsfTrackRef().get() : lPF->trackRef().get();
429  internalId_.d0_ = std::abs(pfTrk->dxy(vtx->position()));
430  internalId_.dZ_ = std::abs(pfTrk->dz(vtx->position()));
431  }
432  } else {
433  internalId_.d0_ = std::abs(pfTrk->dxy(vtx->position()));
434  internalId_.dZ_ = std::abs(pfTrk->dz(vtx->position()));
435  }
436  }
437  internalId_.dRMeanCh_ += candPtDr;
438  internalId_.ptDCh_ += candPt * candPt;
439  fracCh.push_back(candPtFrac);
440  if (icone < ncones) {
441  *coneChFracs[icone] += candPt;
442  }
443  sumPtCh += candPt;
444  }
445  // // beta and betastar
446  if (icand->charge() != 0) {
447  if (!isPacked) {
448  if (lPF->trackRef().isNonnull()) {
449  float tkpt = candPt;
450  sumTkPt += tkpt;
451  // 'classic' beta definition based on track-vertex association
452  bool inVtx0 = vtx->trackWeight(lPF->trackRef()) > 0;
453 
454  bool inAnyOther = false;
455  // alternative beta definition based on track-vertex distance of closest approach
456  double dZ0 = std::abs(lPF->trackRef()->dz(vtx->position()));
457  double dZ = dZ0;
458  for (reco::VertexCollection::const_iterator vi = allvtx.begin(); vi != allvtx.end(); ++vi) {
459  const reco::Vertex& iv = *vi;
460  if (iv.isFake() || iv.ndof() < 4) {
461  continue;
462  }
463  // the primary vertex may have been copied by the user: check identity by position
464  bool isVtx0 = (iv.position() - vtx->position()).r() < 0.02;
465  // 'classic' beta definition: check if the track is associated with
466  // any vertex other than the primary one
467  if (!isVtx0 && !inAnyOther) {
468  inAnyOther = vtx->trackWeight(lPF->trackRef()) <= 0;
469  }
470  // alternative beta: find closest vertex to the track
471  dZ = std::min(dZ, std::abs(lPF->trackRef()->dz(iv.position())));
472  }
473  // classic beta/betaStar
474  if (inVtx0 && !inAnyOther) {
475  internalId_.betaClassic_ += tkpt;
476  } else if (!inVtx0 && inAnyOther) {
477  internalId_.betaStarClassic_ += tkpt;
478  }
479  // alternative beta/betaStar
480  if (dZ0 < 0.2) {
481  internalId_.beta_ += tkpt;
482  } else if (dZ < 0.2) {
483  internalId_.betaStar_ += tkpt;
484  }
485  }
486  } else {
487  float tkpt = candPt;
488  sumTkPt += tkpt;
489  bool inVtx0 = false;
490  bool inVtxOther = false;
491  double dZ0 = 9999.;
492  double dZ_tmp = 9999.;
493  for (unsigned vtx_i = 0; vtx_i < allvtx.size(); vtx_i++) {
494  auto iv = allvtx[vtx_i];
495 
496  if (iv.isFake())
497  continue;
498 
499  // Match to vertex in case of copy as above
500  bool isVtx0 = (iv.position() - vtx->position()).r() < 0.02;
501 
502  if (isVtx0) {
503  if (lPack->fromPV(vtx_i) == pat::PackedCandidate::PVUsedInFit)
504  inVtx0 = true;
505  if (lPack->fromPV(vtx_i) == 0)
506  inVtxOther = true;
507  dZ0 = lPack->dz(iv.position());
508  }
509 
510  if (fabs(lPack->dz(iv.position())) < fabs(dZ_tmp)) {
511  dZ_tmp = lPack->dz(iv.position());
512  }
513  }
514  if (inVtx0) {
515  internalId_.betaClassic_ += tkpt;
516  } else if (inVtxOther) {
517  internalId_.betaStarClassic_ += tkpt;
518  }
519  if (fabs(dZ0) < 0.2) {
520  internalId_.beta_ += tkpt;
521  } else if (fabs(dZ_tmp) < 0.2) {
522  internalId_.betaStar_ += tkpt;
523  }
524  }
525  }
526 
527  // trailing candidate
528  if (lTrail == nullptr || candPt < lTrail->pt()) {
529  lTrail = icand;
530  }
531  }
532 
533  // // Finalize all variables
534  assert(!(lLead == nullptr));
535 
536  if (lSecond == nullptr) {
537  lSecond = lTrail;
538  }
539  if (lLeadNeut == nullptr) {
540  lLeadNeut = lTrail;
541  }
542  if (lLeadEm == nullptr) {
543  lLeadEm = lTrail;
544  }
545  if (lLeadCh == nullptr) {
546  lLeadCh = lTrail;
547  }
548 
549  if (patjet != nullptr) { // to enable running on MiniAOD slimmedJets
550  internalId_.nCharged_ = patjet->chargedMultiplicity();
551  internalId_.nNeutrals_ = patjet->neutralMultiplicity();
552  internalId_.chgEMfrac_ = patjet->chargedEmEnergy() / jet->energy();
553  internalId_.neuEMfrac_ = patjet->neutralEmEnergy() / jet->energy();
554  internalId_.chgHadrfrac_ = patjet->chargedHadronEnergy() / jet->energy();
555  internalId_.neuHadrfrac_ = patjet->neutralHadronEnergy() / jet->energy();
556  if (usePuppi)
557  internalId_.nNeutrals_ = multNeut;
558  } else {
559  internalId_.nCharged_ = pfjet->chargedMultiplicity();
560  internalId_.nNeutrals_ = pfjet->neutralMultiplicity();
561  internalId_.chgEMfrac_ = pfjet->chargedEmEnergy() / jet->energy();
562  internalId_.neuEMfrac_ = pfjet->neutralEmEnergy() / jet->energy();
563  internalId_.chgHadrfrac_ = pfjet->chargedHadronEnergy() / jet->energy();
564  internalId_.neuHadrfrac_ = pfjet->neutralHadronEnergy() / jet->energy();
565  }
566  internalId_.nParticles_ = jet->nConstituents();
567 
569  float sumW2(0.0);
570  float sum_deta(0.0), sum_dphi(0.0);
571  float ave_deta(0.0), ave_dphi(0.0);
572  for (size_t j = 0; j < jet->numberOfDaughters(); j++) {
573  const auto& part = jet->daughterPtr(j);
574  if (!(part.isAvailable() && part.isNonnull())) {
575  continue;
576  }
577 
578  float partPuppiWeight = 1.0;
579  if (usePuppi) {
580  const pat::PackedCandidate* partpack = dynamic_cast<const pat::PackedCandidate*>(part.get());
581  if (partpack != nullptr)
582  partPuppiWeight = partpack->puppiWeight();
583  }
584 
585  float weight = (part->pt()) * partPuppiWeight;
586  float weight2 = weight * weight;
587  sumW2 += weight2;
588  float deta = part->eta() - jet->eta();
589  float dphi = reco::deltaPhi(*part, *jet);
590  sum_deta += deta * weight2;
591  sum_dphi += dphi * weight2;
592  if (sumW2 > 0) {
593  ave_deta = sum_deta / sumW2;
594  ave_dphi = sum_dphi / sumW2;
595  }
596  }
597 
598  float ddetaR_sum(0.0), ddphiR_sum(0.0), pull_tmp(0.0);
599  for (size_t i = 0; i < jet->numberOfDaughters(); i++) {
600  const auto& part = jet->daughterPtr(i);
601  if (!(part.isAvailable() && part.isNonnull())) {
602  continue;
603  }
604 
605  float partPuppiWeight = 1.0;
606  if (usePuppi) {
607  const pat::PackedCandidate* partpack = dynamic_cast<const pat::PackedCandidate*>(part.get());
608  if (partpack != nullptr)
609  partPuppiWeight = partpack->puppiWeight();
610  }
611 
612  float weight = partPuppiWeight * (part->pt()) * partPuppiWeight * (part->pt());
613  float deta = part->eta() - jet->eta();
614  float dphi = reco::deltaPhi(*part, *jet);
615  float ddeta, ddphi, ddR;
616  ddeta = deta - ave_deta;
617  ddphi = dphi - ave_dphi;
618  ddR = sqrt(ddeta * ddeta + ddphi * ddphi);
619  ddetaR_sum += ddR * ddeta * weight;
620  ddphiR_sum += ddR * ddphi * weight;
621  }
622  if (sumW2 > 0) {
623  float ddetaR_ave = ddetaR_sum / sumW2;
624  float ddphiR_ave = ddphiR_sum / sumW2;
625  pull_tmp = sqrt(ddetaR_ave * ddetaR_ave + ddphiR_ave * ddphiR_ave);
626  }
627  internalId_.pull_ = pull_tmp;
629 
630  setPtEtaPhi(*lLead, internalId_.leadPt_, internalId_.leadEta_, internalId_.leadPhi_);
631  setPtEtaPhi(*lSecond, internalId_.secondPt_, internalId_.secondEta_, internalId_.secondPhi_);
632  setPtEtaPhi(*lLeadNeut, internalId_.leadNeutPt_, internalId_.leadNeutEta_, internalId_.leadNeutPhi_);
633  setPtEtaPhi(*lLeadEm, internalId_.leadEmPt_, internalId_.leadEmEta_, internalId_.leadEmPhi_);
634  setPtEtaPhi(*lLeadCh, internalId_.leadChPt_, internalId_.leadChEta_, internalId_.leadChPhi_);
635 
636  std::sort(frac.begin(), frac.end(), std::greater<float>());
637  std::sort(fracCh.begin(), fracCh.end(), std::greater<float>());
638  std::sort(fracEm.begin(), fracEm.end(), std::greater<float>());
639  std::sort(fracNeut.begin(), fracNeut.end(), std::greater<float>());
640  assign(frac, internalId_.leadFrac_, internalId_.secondFrac_, internalId_.thirdFrac_, internalId_.fourthFrac_);
641  assign(
642  fracCh, internalId_.leadChFrac_, internalId_.secondChFrac_, internalId_.thirdChFrac_, internalId_.fourthChFrac_);
643  assign(
644  fracEm, internalId_.leadEmFrac_, internalId_.secondEmFrac_, internalId_.thirdEmFrac_, internalId_.fourthEmFrac_);
645  assign(fracNeut,
646  internalId_.leadNeutFrac_,
647  internalId_.secondNeutFrac_,
648  internalId_.thirdNeutFrac_,
649  internalId_.fourthNeutFrac_);
650 
651  covMatrix(0, 0) /= sumPt2;
652  covMatrix(0, 1) /= sumPt2;
653  covMatrix(1, 1) /= sumPt2;
654  covMatrix(1, 0) = covMatrix(0, 1);
655  internalId_.etaW_ = sqrt(covMatrix(0, 0));
656  internalId_.phiW_ = sqrt(covMatrix(1, 1));
657  internalId_.jetW_ = 0.5 * (internalId_.etaW_ + internalId_.phiW_);
658  TVectorD eigVals(2);
659  eigVals = TMatrixDSymEigen(covMatrix).GetEigenValues();
660  internalId_.majW_ = sqrt(std::abs(eigVals(0)));
661  internalId_.minW_ = sqrt(std::abs(eigVals(1)));
662  if (internalId_.majW_ < internalId_.minW_) {
663  std::swap(internalId_.majW_, internalId_.minW_);
664  }
665 
666  internalId_.dRLeadCent_ = reco::deltaR(*jet, *lLead);
667  if (lSecond != nullptr) {
668  internalId_.dRLead2nd_ = reco::deltaR(*jet, *lSecond);
669  }
670  internalId_.dRMean_ /= jetPt;
671  internalId_.dRMeanNeut_ /= jetPt;
672  internalId_.dRMeanEm_ /= jetPt;
673  internalId_.dRMeanCh_ /= jetPt;
674  internalId_.dR2Mean_ /= sumPt2;
675 
676  for (size_t ic = 0; ic < ncones; ++ic) {
677  *coneFracs[ic] /= jetPt;
678  *coneEmFracs[ic] /= jetPt;
679  *coneNeutFracs[ic] /= jetPt;
680  *coneChFracs[ic] /= jetPt;
681  }
682  //http://jets.physics.harvard.edu/qvg/
683  double ptMean = sumPt / internalId_.nParticles_;
684  double ptRMS = 0;
685  for (unsigned int i0 = 0; i0 < frac.size(); i0++) {
686  ptRMS += (frac[i0] - ptMean) * (frac[i0] - ptMean);
687  }
688  ptRMS /= internalId_.nParticles_;
689  ptRMS = sqrt(ptRMS);
690 
691  internalId_.ptMean_ = ptMean;
692  internalId_.ptRMS_ = ptRMS / jetPt;
693  internalId_.pt2A_ = sqrt(internalId_.ptD_ / internalId_.nParticles_) / jetPt;
694  internalId_.ptD_ = sqrt(internalId_.ptD_) / sumPt;
695  internalId_.ptDCh_ = sqrt(internalId_.ptDCh_) / sumPtCh;
696  internalId_.ptDNe_ = sqrt(internalId_.ptDNe_) / sumPtNe;
697  internalId_.sumPt_ = sumPt;
698  internalId_.sumChPt_ = sumPtCh;
699  internalId_.sumNePt_ = sumPtNe;
700 
701  internalId_.jetR_ = lLead->pt() / sumPt;
702  internalId_.jetRchg_ = lLeadCh->pt() / sumPt;
703  internalId_.dRMatch_ = dRmin;
704 
705  if (sumTkPt != 0.) {
706  internalId_.beta_ /= sumTkPt;
707  internalId_.betaStar_ /= sumTkPt;
708  internalId_.betaClassic_ /= sumTkPt;
709  internalId_.betaStarClassic_ /= sumTkPt;
710  } else {
711  assert(internalId_.beta_ == 0. && internalId_.betaStar_ == 0. && internalId_.betaClassic_ == 0. &&
712  internalId_.betaStarClassic_ == 0.);
713  }
714 
715  if (cache_->runMvas()) {
716  runMva();
717  }
718 
719  return PileupJetIdentifier(internalId_);
720 }
721 
722 // ------------------------------------------------------------------------------------------
723 std::string PileupJetIdAlgo::dumpVariables() const {
724  std::stringstream out;
725  for (variables_list_t::const_iterator it = variables_.begin(); it != variables_.end(); ++it) {
726  out << std::setw(15) << it->first << std::setw(3) << "=" << std::setw(5) << *it->second.first << " ("
727  << std::setw(5) << it->second.second << ")" << std::endl;
728  }
729  return out.str();
730 }
731 
732 // ------------------------------------------------------------------------------------------
733 void PileupJetIdAlgo::resetVariables() {
734  internalId_.idFlag_ = 0;
735  for (variables_list_t::iterator it = variables_.begin(); it != variables_.end(); ++it) {
736  *it->second.first = it->second.second;
737  }
738 }
739 
740 // ------------------------------------------------------------------------------------------
741 #define INIT_VARIABLE(NAME, TMVANAME, VAL) \
742  internalId_.NAME##_ = VAL; \
743  variables_[#NAME] = std::make_pair(&internalId_.NAME##_, VAL);
744 
745 // ------------------------------------------------------------------------------------------
746 void PileupJetIdAlgo::initVariables() {
747  internalId_.idFlag_ = 0;
748  INIT_VARIABLE(mva, "", -100.);
749  //INIT_VARIABLE(jetPt , "jspt_1", 0.);
750  //INIT_VARIABLE(jetEta , "jseta_1", large_val);
751  INIT_VARIABLE(jetPt, "", 0.);
752  INIT_VARIABLE(jetEta, "", large_val);
753  INIT_VARIABLE(jetPhi, "jsphi_1", large_val);
754  INIT_VARIABLE(jetM, "jm_1", 0.);
755 
756  INIT_VARIABLE(nCharged, "", 0.);
757  INIT_VARIABLE(nNeutrals, "", 0.);
758 
759  INIT_VARIABLE(chgEMfrac, "", 0.);
760  INIT_VARIABLE(neuEMfrac, "", 0.);
761  INIT_VARIABLE(chgHadrfrac, "", 0.);
762  INIT_VARIABLE(neuHadrfrac, "", 0.);
763 
764  INIT_VARIABLE(d0, "jd0_1", -1000.);
765  INIT_VARIABLE(dZ, "jdZ_1", -1000.);
766  //INIT_VARIABLE(nParticles , "npart_1" , 0.);
767  INIT_VARIABLE(nParticles, "", 0.);
768 
769  INIT_VARIABLE(leadPt, "lpt_1", 0.);
770  INIT_VARIABLE(leadEta, "leta_1", large_val);
771  INIT_VARIABLE(leadPhi, "lphi_1", large_val);
772  INIT_VARIABLE(secondPt, "spt_1", 0.);
773  INIT_VARIABLE(secondEta, "seta_1", large_val);
774  INIT_VARIABLE(secondPhi, "sphi_1", large_val);
775  INIT_VARIABLE(leadNeutPt, "lnept_1", 0.);
776  INIT_VARIABLE(leadNeutEta, "lneeta_1", large_val);
777  INIT_VARIABLE(leadNeutPhi, "lnephi_1", large_val);
778  INIT_VARIABLE(leadEmPt, "lempt_1", 0.);
779  INIT_VARIABLE(leadEmEta, "lemeta_1", large_val);
780  INIT_VARIABLE(leadEmPhi, "lemphi_1", large_val);
781  INIT_VARIABLE(leadChPt, "lchpt_1", 0.);
782  INIT_VARIABLE(leadChEta, "lcheta_1", large_val);
783  INIT_VARIABLE(leadChPhi, "lchphi_1", large_val);
784  INIT_VARIABLE(leadFrac, "lLfr_1", 0.);
785 
786  INIT_VARIABLE(dRLeadCent, "drlc_1", 0.);
787  INIT_VARIABLE(dRLead2nd, "drls_1", 0.);
788  INIT_VARIABLE(dRMean, "drm_1", 0.);
789  INIT_VARIABLE(dRMean, "", 0.);
790  INIT_VARIABLE(pull, "", 0.);
791  INIT_VARIABLE(dRMeanNeut, "drmne_1", 0.);
792  INIT_VARIABLE(dRMeanEm, "drem_1", 0.);
793  INIT_VARIABLE(dRMeanCh, "drch_1", 0.);
794  INIT_VARIABLE(dR2Mean, "", 0.);
795 
796  INIT_VARIABLE(ptD, "", 0.);
797  INIT_VARIABLE(ptMean, "", 0.);
798  INIT_VARIABLE(ptRMS, "", 0.);
799  INIT_VARIABLE(pt2A, "", 0.);
800  INIT_VARIABLE(ptDCh, "", 0.);
801  INIT_VARIABLE(ptDNe, "", 0.);
802  INIT_VARIABLE(sumPt, "", 0.);
803  INIT_VARIABLE(sumChPt, "", 0.);
804  INIT_VARIABLE(sumNePt, "", 0.);
805 
806  INIT_VARIABLE(secondFrac, "", 0.);
807  INIT_VARIABLE(thirdFrac, "", 0.);
808  INIT_VARIABLE(fourthFrac, "", 0.);
809 
810  INIT_VARIABLE(leadChFrac, "", 0.);
811  INIT_VARIABLE(secondChFrac, "", 0.);
812  INIT_VARIABLE(thirdChFrac, "", 0.);
813  INIT_VARIABLE(fourthChFrac, "", 0.);
814 
815  INIT_VARIABLE(leadNeutFrac, "", 0.);
816  INIT_VARIABLE(secondNeutFrac, "", 0.);
817  INIT_VARIABLE(thirdNeutFrac, "", 0.);
818  INIT_VARIABLE(fourthNeutFrac, "", 0.);
819 
820  INIT_VARIABLE(leadEmFrac, "", 0.);
821  INIT_VARIABLE(secondEmFrac, "", 0.);
822  INIT_VARIABLE(thirdEmFrac, "", 0.);
823  INIT_VARIABLE(fourthEmFrac, "", 0.);
824 
825  INIT_VARIABLE(jetW, "", 1.);
826  INIT_VARIABLE(etaW, "", 1.);
827  INIT_VARIABLE(phiW, "", 1.);
828 
829  INIT_VARIABLE(majW, "", 1.);
830  INIT_VARIABLE(minW, "", 1.);
831 
832  INIT_VARIABLE(frac01, "", 0.);
833  INIT_VARIABLE(frac02, "", 0.);
834  INIT_VARIABLE(frac03, "", 0.);
835  INIT_VARIABLE(frac04, "", 0.);
836  INIT_VARIABLE(frac05, "", 0.);
837  INIT_VARIABLE(frac06, "", 0.);
838  INIT_VARIABLE(frac07, "", 0.);
839 
840  INIT_VARIABLE(chFrac01, "", 0.);
841  INIT_VARIABLE(chFrac02, "", 0.);
842  INIT_VARIABLE(chFrac03, "", 0.);
843  INIT_VARIABLE(chFrac04, "", 0.);
844  INIT_VARIABLE(chFrac05, "", 0.);
845  INIT_VARIABLE(chFrac06, "", 0.);
846  INIT_VARIABLE(chFrac07, "", 0.);
847 
848  INIT_VARIABLE(neutFrac01, "", 0.);
849  INIT_VARIABLE(neutFrac02, "", 0.);
850  INIT_VARIABLE(neutFrac03, "", 0.);
851  INIT_VARIABLE(neutFrac04, "", 0.);
852  INIT_VARIABLE(neutFrac05, "", 0.);
853  INIT_VARIABLE(neutFrac06, "", 0.);
854  INIT_VARIABLE(neutFrac07, "", 0.);
855 
856  INIT_VARIABLE(emFrac01, "", 0.);
857  INIT_VARIABLE(emFrac02, "", 0.);
858  INIT_VARIABLE(emFrac03, "", 0.);
859  INIT_VARIABLE(emFrac04, "", 0.);
860  INIT_VARIABLE(emFrac05, "", 0.);
861  INIT_VARIABLE(emFrac06, "", 0.);
862  INIT_VARIABLE(emFrac07, "", 0.);
863 
864  INIT_VARIABLE(beta, "", 0.);
865  INIT_VARIABLE(betaStar, "", 0.);
866  INIT_VARIABLE(betaClassic, "", 0.);
867  INIT_VARIABLE(betaStarClassic, "", 0.);
868 
869  INIT_VARIABLE(nvtx, "", 0.);
870  INIT_VARIABLE(rho, "", 0.);
871  INIT_VARIABLE(nTrueInt, "", 0.);
872 
873  INIT_VARIABLE(jetR, "", 0.);
874  INIT_VARIABLE(jetRchg, "", 0.);
875  INIT_VARIABLE(dRMatch, "", 0.);
876 }
877 
878 #undef INIT_VARIABLE
pat::PackedCandidate::puppiWeight
float puppiWeight() const
Definition: PackedCandidate.cc:380
pat::PackedCandidate::dz
virtual float dz(size_t ipv=0) const
dz with respect to the PV[ipv]
Definition: PackedCandidate.h:757
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
HLT_FULL_cff.rho
tuple rho
Definition: HLT_FULL_cff.py:103771
PileupJetIdAlgo::set
void set(const PileupJetIdentifier &)
Definition: PileupJetIdAlgo.cc:154
reco::CompositePtrCandidate::numberOfSourceCandidatePtrs
size_type numberOfSourceCandidatePtrs() const override
Definition: CompositePtrCandidate.cc:22
log
static std::vector< std::string > checklist log
Definition: LHERunInfoProduct.cc:179
c
const edm::EventSetup & c
Definition: SiStripLAProfileBooker.cc:66
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
PileupJetIdAlgo::cache_
AlgoGBRForestsAndConstants const * cache_
Definition: PileupJetIdAlgo.h:106
mps_fire.i
i
Definition: mps_fire.py:428
INIT_VARIABLE
#define INIT_VARIABLE(NAME, TMVANAME, VAL)
Definition: PileupJetIdAlgo.cc:741
PileupJetIdAlgo::AlgoGBRForestsAndConstants::AlgoGBRForestsAndConstants
AlgoGBRForestsAndConstants(edm::ParameterSet const &, bool runMvas)
Definition: PileupJetIdAlgo.cc:22
pat::Jet::chargedHadronEnergy
float chargedHadronEnergy() const
chargedHadronEnergy
Definition: Jet.h:696
DiDispStaMuonMonitor_cfi.pt
tuple pt
Definition: DiDispStaMuonMonitor_cfi.py:39
gpuVertexFinder::iv
int32_t *__restrict__ iv
Definition: gpuClusterTracksDBSCAN.h:42
reco::PFJet::chargedEmEnergy
float chargedEmEnergy() const
chargedEmEnergy
Definition: PFJet.h:139
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
PileupJetIdAlgo::AlgoGBRForestsAndConstants::jEtaMin
std::vector< double > const & jEtaMin() const
Definition: PileupJetIdAlgo.h:66
pat::Jet::neutralEmEnergy
float neutralEmEnergy() const
neutralEmEnergy
Definition: Jet.h:726
gpuClustering::id
uint16_t *__restrict__ id
Definition: gpuClusterChargeCut.h:20
beam_dqm_sourceclient-live_cfg.mva
tuple mva
Definition: beam_dqm_sourceclient-live_cfg.py:132
reco::Candidate::bestTrack
virtual const Track * bestTrack() const
Definition: Candidate.h:268
reco::CompositePtrCandidate::sourceCandidatePtr
CandidatePtr sourceCandidatePtr(size_type i) const override
Definition: CompositePtrCandidate.cc:24
reco::Candidate::pt
virtual double pt() const =0
transverse momentum
edm::Ptr::get
T const * get() const
Returns C++ pointer to the item.
Definition: Ptr.h:139
reco::Jet
Base class for all types of Jets.
Definition: Jet.h:20
relval_steps.version
string version
Definition: relval_steps.py:3479
pat::Jet::neutralHadronEnergy
float neutralHadronEnergy() const
neutralHadronEnergy
Definition: Jet.h:706
PileupJetIdAlgo::getJetIdKey
std::pair< int, int > getJetIdKey(float jetPt, float jetEta)
Definition: PileupJetIdAlgo.cc:197
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
mvaPFMET_Data_cff.tmvaSpectators
tuple tmvaSpectators
Definition: mvaPFMET_Data_cff.py:58
pat::Jet::neutralMultiplicity
int neutralMultiplicity() const
neutralMultiplicity
Definition: Jet.h:466
PileupJetIdAlgo::computeCutIDflag
int computeCutIDflag(float betaStarClassic, float dR2Mean, float nvtx, float jetPt, float jetEta)
Definition: PileupJetIdAlgo.cc:219
reco::Muon::bestTrack
const Track * bestTrack() const override
Definition: Muon.h:58
patTestJEC_cfi.jec
tuple jec
Definition: patTestJEC_cfi.py:5
cms::cuda::assert
assert(be >=bs)
PileupJetIdAlgo::AlgoGBRForestsAndConstants::jEtaMax
std::vector< double > const & jEtaMax() const
Definition: PileupJetIdAlgo.h:67
reco::PFJet::chargedMultiplicity
int chargedMultiplicity() const
chargedMultiplicity
Definition: PFJet.h:152
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:127
reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:20
reco::PFJet::neutralEmEnergy
float neutralEmEnergy() const
neutralEmEnergy
Definition: PFJet.h:147
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HLT_FULL_cff.beta
tuple beta
Definition: HLT_FULL_cff.py:8870
pat::Jet::chargedEmEnergy
float chargedEmEnergy() const
chargedEmEnergy
Definition: Jet.h:716
reco::PFCandidate::trackRef
reco::TrackRef trackRef() const
Definition: PFCandidate.cc:430
ztail.d
tuple d
Definition: ztail.py:151
PileupJetIdAlgo::computeIdVariables
PileupJetIdentifier computeIdVariables(const reco::Jet *jet, float jec, const reco::Vertex *, const reco::VertexCollection &, double rho, bool usePuppi)
Definition: PileupJetIdAlgo.cc:261
PileupJetIdAlgo::internalId_
PileupJetIdentifier internalId_
Definition: PileupJetIdAlgo.h:104
std::swap
void swap(edm::DataFrameContainer &lhs, edm::DataFrameContainer &rhs)
Definition: DataFrameContainer.h:209
pat::PackedCandidate::fromPV
const PVAssoc fromPV(size_t ipv=0) const
Definition: PackedCandidate.h:715
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
PileupJetIdAlgo::dumpVariables
std::string dumpVariables() const
Definition: PileupJetIdAlgo.cc:723
isotrackApplyRegressor.var
list var
if using global norm cols_to_minmax = [&#39;t_delta&#39;, &#39;t_hmaxNearP&#39;,&#39;t_emaxNearP&#39;, &#39;t_hAnnular&#39;, &#39;t_eAnnular&#39;,&#39;t_pt&#39;,&#39;t_nVtx&#39;,&#39;t_ieta&#39;,&#39;t_eHcal10&#39;, &#39;t_eHcal30&#39;,&#39;t_rhoh&#39;,&#39;t_eHcal&#39;] df[cols_to_minmax] = df[cols_to_minmax].apply(lambda x: (x - x.min()) / (x.max() - x.min()) if (x.max() - x.min() &gt; 0) else 1.0/200.0)
Definition: isotrackApplyRegressor.py:79
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
DQM.reader
tuple reader
Definition: DQM.py:105
assign
void assign(const std::vector< float > &vec, float &a, float &b, float &c, float &d)
Definition: PileupJetIdAlgo.cc:139
reco::Vertex::trackWeight
float trackWeight(const TREF &r) const
returns the weight with which a Track has contributed to the vertex-fit.
Definition: Vertex.h:96
reco::Candidate::charge
virtual int charge() const =0
electric charge
edm::Ref::get
T const * get() const
Returns C++ pointer to the item.
Definition: Ref.h:232
min
T min(T a, T b)
Definition: MathUtil.h:58
PileupJetIdAlgo::AlgoGBRForestsAndConstants::reader
std::unique_ptr< const GBRForest > const & reader() const
Definition: PileupJetIdAlgo.h:60
PileupJetIdAlgo::computeIDflag
int computeIDflag(float mva, float jetPt, float jetEta)
Definition: PileupJetIdAlgo.cc:237
reco::Vertex::ndof
double ndof() const
Definition: Vertex.h:123
reco::PFJet::neutralMultiplicity
int neutralMultiplicity() const
neutralMultiplicity
Definition: PFJet.h:154
reco::PFCandidate::muonRef
reco::MuonRef muonRef() const
Definition: PFCandidate.cc:443
reco::deltaR
constexpr auto deltaR(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:30
reco::TrackBase::dz
double dz() const
dz parameter (= dsz/cos(lambda)). This is the track z0 w.r.t (0,0,0) only if the refPoint is close to...
Definition: TrackBase.h:622
reco::Candidate::pdgId
virtual int pdgId() const =0
PDG identifier.
setPtEtaPhi
void setPtEtaPhi(const reco::Candidate &p, float &pt, float &eta, float &phi)
Definition: PileupJetIdAlgo.cc:147
reco::CompositePtrCandidate::numberOfDaughters
size_t numberOfDaughters() const override
number of daughters
Definition: CompositePtrCandidate.cc:18
d0
static constexpr float d0
Definition: L1EGammaCrystalsEmulatorProducer.cc:85
reco::Vertex::isFake
bool isFake() const
Definition: Vertex.h:76
part
part
Definition: HCALResponse.h:20
reco::CompositePtrCandidate::daughterPtr
virtual CandidatePtr daughterPtr(size_type i) const
reference to daughter at given position
Definition: CompositePtrCandidate.h:61
large_val
const float large_val
Definition: MVAJetPuId.cc:14
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
PileupJetIdAlgo::computeMva
PileupJetIdentifier computeMva()
Definition: PileupJetIdAlgo.cc:255
b
double b
Definition: hdecay.h:118
pat::Jet
Analysis-level calorimeter jet class.
Definition: Jet.h:77
PileupJetIdAlgo::AlgoGBRForestsAndConstants::etaReader
std::vector< std::unique_ptr< const GBRForest > > const & etaReader() const
Definition: PileupJetIdAlgo.h:61
AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
reco::PFCandidate
Particle reconstructed by the particle flow algorithm.
Definition: PFCandidate.h:41
reco::LeafCandidate::mass
double mass() const final
mass
Definition: LeafCandidate.h:131
reco::Jet::nConstituents
virtual int nConstituents() const
of constituents
Definition: Jet.h:65
cuda_std::lower_bound
__host__ __device__ constexpr RandomIt lower_bound(RandomIt first, RandomIt last, const T &value, Compare comp={})
Definition: cudastdAlgorithm.h:27
a
double a
Definition: hdecay.h:119
reco::PFCandidate::gsfTrackRef
reco::GsfTrackRef gsfTrackRef() const
Definition: PFCandidate.cc:462
PileupJetIdAlgo::AlgoGBRForestsAndConstants::tmvaEtaVariables
std::vector< std::vector< std::string > > const & tmvaEtaVariables() const
Definition: PileupJetIdAlgo.h:71
PileupJetIdAlgo::variables_
variables_list_t variables_
Definition: PileupJetIdAlgo.h:105
reco::PFJet::neutralHadronEnergy
float neutralHadronEnergy() const
neutralHadronEnergy
Definition: PFJet.h:99
vars
vars
Definition: DeepTauId.cc:164
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
histoStyle.weight
int weight
Definition: histoStyle.py:51
pat::PackedCandidate::dxy
virtual float dxy() const
dxy with respect to the PV ref
Definition: PackedCandidate.h:751
reco::TrackBase::dxy
double dxy() const
dxy parameter. (This is the transverse impact parameter w.r.t. to (0,0,0) ONLY if refPoint is close t...
Definition: TrackBase.h:608
pat::Jet::correctedJet
Jet correctedJet(const std::string &level, const std::string &flavor="none", const std::string &set="") const
PileupJetIdAlgo::AlgoGBRForestsAndConstants::tmvaVariables
std::vector< std::string > const & tmvaVariables() const
Definition: PileupJetIdAlgo.h:70
PileupJetIdAlgo::getMVAval
float getMVAval(const std::vector< std::string > &, const std::unique_ptr< const GBRForest > &)
Definition: PileupJetIdAlgo.cc:158
pat::Jet::chargedMultiplicity
int chargedMultiplicity() const
chargedMultiplicity
Definition: Jet.h:746
reco::PFJet::chargedHadronEnergy
float chargedHadronEnergy() const
chargedHadronEnergy
Definition: PFJet.h:95
PileupJetIdAlgo::PileupJetIdAlgo
PileupJetIdAlgo(AlgoGBRForestsAndConstants const *cache)
Definition: PileupJetIdAlgo.cc:133
createGBRForest
std::unique_ptr< const GBRForest > createGBRForest(const std::string &weightsFile)
Definition: GBRForestTools.cc:266
reco::Candidate::phi
virtual double phi() const =0
momentum azimuthal angle
utilities.cache
def cache
Definition: utilities.py:3
reco::Candidate::eta
virtual double eta() const =0
momentum pseudorapidity
reco::LeafCandidate::energy
double energy() const final
energy
Definition: LeafCandidate.h:125
reco::LeafCandidate::eta
double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:152
Generated for CMSSW Reference Manual by doxygen 1.8.5