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