ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitPhysics/Utils/src/JetIDMVA.cc
(Generate patch)

Comparing UserCode/MitPhysics/Utils/src/JetIDMVA.cc (file contents):
Revision 1.11 by pharris, Mon May 14 09:42:27 2012 UTC vs.
Revision 1.21 by pharris, Tue Jul 16 22:29:52 2013 UTC

# Line 31 | Line 31 | JetIDMVA::JetIDMVA() :
31    fNCharged (0),
32    fNNeutrals(0),
33    fDRMean   (0),
34 +  fPtD      (0),
35    fFrac01   (0),
36    fFrac02   (0),
37    fFrac03   (0),
# Line 52 | Line 53 | void JetIDMVA::Initialize( JetIDMVA::Cut
53                             TString iLowPtWeights,
54                             TString iHighPtWeights,
55                             JetIDMVA::MVAType iType,
56 <                           TString iCutFileName)
56 >                           TString iCutFileName,bool i42)
57   {
58    
59    fIsInitialized = kTRUE;
60    fType          = iType;
61    fCutType       = iCutType;
62 +  f42            = i42;
63 +
64 +  std::string lCutId = "JetIdParams";
65 +  if(fType == k42)     lCutId = "PuJetIdOptMVA_wp";
66 +  if(fType == k52)     lCutId = "full_5x_wp";
67 +  if(fType == kCut)    lCutId = "PuJetIdCutBased_wp";
68 +  if(fType == k53)     lCutId = "full_53x_wp";
69 +  if(fType == k53MET)  lCutId = "met_53x_wp";
70 +
71 + //Load Cut Matrix
72 +  edm::ParameterSet lDefConfig = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>("JetIdParams");
73 +  edm::ParameterSet lConfig    = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>(lCutId);
74 +  std::string lCutType = "Tight";
75 +  if(fCutType == kMedium) lCutType = "Medium";
76 +  if(fCutType == kLoose ) lCutType = "Loose";
77 +  if(fCutType == kMET   ) lCutType = "MET";
78 +  if(fType != kCut) {
79 +    std::string lLowPtCut = "MET";
80 +    std::vector<double> lPt010  = lDefConfig.getParameter<std::vector<double> >(("Pt010_" +lLowPtCut).c_str());
81 +    std::vector<double> lPt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lCutType).c_str());
82 +    std::vector<double> lPt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lCutType).c_str());
83 +    std::vector<double> lPt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lCutType).c_str());
84 +    for(int i0 = 0; i0 < 4; i0++) fMVACut[0][i0] = lPt010 [i0];
85 +    for(int i0 = 0; i0 < 4; i0++) fMVACut[1][i0] = lPt1020[i0];
86 +    for(int i0 = 0; i0 < 4; i0++) fMVACut[2][i0] = lPt2030[i0];
87 +    for(int i0 = 0; i0 < 4; i0++) fMVACut[3][i0] = lPt3050[i0];
88 +  }
89 +  if(fType == kCut) {
90 +    for(int i0 = 0; i0 < 2; i0++) {
91 +      std::string lFullCutType = lCutType;
92 +      if(i0 == 0) lFullCutType = "BetaStar"+ lCutType;
93 +      if(i0 == 1) lFullCutType = "RMS"     + lCutType;
94 +      std::vector<double> pt010  = lConfig.getParameter<std::vector<double> >(("Pt010_" +lFullCutType).c_str());
95 +      std::vector<double> pt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lFullCutType).c_str());
96 +      std::vector<double> pt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lFullCutType).c_str());
97 +      std::vector<double> pt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lFullCutType).c_str());
98 +      if(i0 == 0) {
99 +        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[0][i2] = pt010 [i2];
100 +        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[1][i2] = pt1020[i2];
101 +        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[2][i2] = pt2030[i2];
102 +        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[3][i2] = pt3050[i2];
103 +      }
104 +      if(i0 == 1) {
105 +        for(int i2 = 0; i2 < 4; i2++) fRMSCut[0][i2] = pt010 [i2];
106 +        for(int i2 = 0; i2 < 4; i2++) fRMSCut[1][i2] = pt1020[i2];
107 +        for(int i2 = 0; i2 < 4; i2++) fRMSCut[2][i2] = pt2030[i2];
108 +        for(int i2 = 0; i2 < 4; i2++) fRMSCut[3][i2] = pt3050[i2];
109 +      }
110 +    }
111 +    return;
112 +  }
113 +  
114 +  
115    fLowPtReader   = 0;
116    fLowPtReader   = new TMVA::Reader( "!Color:!Silent:Error" );  
117    fLowPtReader->AddVariable( "nvtx"     , &fNVtx      );
118 <  fLowPtReader->AddVariable( "jetPt"    , &fJPt1      );  
119 <  fLowPtReader->AddVariable( "jetEta"   , &fJEta1     );
120 <  fLowPtReader->AddVariable( "jetPhi"   , &fJPhi1     );            
118 >  if(fType != k53) fLowPtReader->AddVariable( "jetPt"    , &fJPt1      );  
119 >  if(fType != k53) fLowPtReader->AddVariable( "jetEta"   , &fJEta1     );
120 >  if(fType != k53) fLowPtReader->AddVariable( "jetPhi"   , &fJPhi1     );            
121    fLowPtReader->AddVariable( "dZ"       , &fJDZ1      );
122 <  fLowPtReader->AddVariable( "d0"       , &fJD01      );
122 >  if(fType != k53 && fType != k53MET) fLowPtReader->AddVariable( "d0"       , &fJD01      );
123    fLowPtReader->AddVariable( "beta"     , &fBeta      );
124    fLowPtReader->AddVariable( "betaStar" , &fBetaStar  );
125    fLowPtReader->AddVariable( "nCharged" , &fNCharged  );
126    fLowPtReader->AddVariable( "nNeutrals", &fNNeutrals );
127 <  fLowPtReader->AddVariable( "dRMean"   , &fDRMean    );
127 >  if(fType != k53 && fType != k53MET) fLowPtReader->AddVariable( "dRMean"   , &fDRMean    );
128 >  if(fType == k53 || fType == k53MET) fLowPtReader->AddVariable( "dR2Mean"  , &fDR2Mean   );
129 >  if(fType == k53 || fType == k53MET) fLowPtReader->AddVariable( "ptD"      , &fPtD       );
130    fLowPtReader->AddVariable( "frac01"   , &fFrac01    );
131    fLowPtReader->AddVariable( "frac02"   , &fFrac02    );
132    fLowPtReader->AddVariable( "frac03"   , &fFrac03    );
133    fLowPtReader->AddVariable( "frac04"   , &fFrac04    );
134    fLowPtReader->AddVariable( "frac05"   , &fFrac05    );
135 +  if(fType == k53) fLowPtReader->AddSpectator( "jetPt"   , &fJPt1      );  
136 +  if(fType == k53) fLowPtReader->AddSpectator( "jetEta"  , &fJEta1     );
137 +  if(fType == k53) fLowPtReader->AddSpectator( "jetPhi"  , &fJPhi1     );  
138    
139    fReader        = 0;
140    fReader        = new TMVA::Reader( "!Color:!Silent:Error" );  
# Line 128 | Line 187 | void JetIDMVA::Initialize( JetIDMVA::Cut
187      fReader->AddSpectator( "jetPt"    , &fJPt1      );  
188      fReader->AddSpectator( "jetEta"   , &fJEta1     );
189    }
190 +  if (fType == k53) {
191 +    fReader->AddVariable( "nvtx"     , &fNVtx      );
192 +    fReader->AddVariable( "dZ"       , &fJDZ1      );
193 +    fReader->AddVariable( "beta"     , &fBeta      );
194 +    fReader->AddVariable( "betaStar" , &fBetaStar  );
195 +    fReader->AddVariable( "nCharged" , &fNCharged  );
196 +    fReader->AddVariable( "nNeutrals", &fNNeutrals );
197 +    fReader->AddVariable( "dR2Mean"  , &fDR2Mean   );
198 +    fReader->AddVariable( "ptD"      , &fPtD       );
199 +    fReader->AddVariable( "frac01"   , &fFrac01    );
200 +    fReader->AddVariable( "frac02"   , &fFrac02    );
201 +    fReader->AddVariable( "frac03"   , &fFrac03    );
202 +    fReader->AddVariable( "frac04"   , &fFrac04    );
203 +    fReader->AddVariable( "frac05"   , &fFrac05    );
204 +    fReader->AddSpectator( "jetPt"   , &fJPt1      );  
205 +    fReader->AddSpectator( "jetEta"  , &fJEta1     );
206 +    fReader->AddSpectator( "jetPhi"  , &fJPhi1     );  
207 +  }
208 +  if (fType == k53MET) {
209 +    fReader->AddVariable( "nvtx"     , &fNVtx      );
210 +    fReader->AddVariable( "jetPt"    , &fJPt1      );  
211 +    fReader->AddVariable( "jetEta"   , &fJEta1     );
212 +    fReader->AddVariable( "jetPhi"   , &fJPhi1     );  
213 +    fReader->AddVariable( "dZ"       , &fJDZ1      );
214 +    fReader->AddVariable( "beta"     , &fBeta      );
215 +    fReader->AddVariable( "betaStar" , &fBetaStar  );
216 +    fReader->AddVariable( "nCharged" , &fNCharged  );
217 +    fReader->AddVariable( "nNeutrals", &fNNeutrals );
218 +    fReader->AddVariable( "dR2Mean"  , &fDR2Mean   );
219 +    fReader->AddVariable( "ptD"      , &fPtD       );
220 +    fReader->AddVariable( "frac01"   , &fFrac01    );
221 +    fReader->AddVariable( "frac02"   , &fFrac02    );
222 +    fReader->AddVariable( "frac03"   , &fFrac03    );
223 +    fReader->AddVariable( "frac04"   , &fFrac04    );
224 +    fReader->AddVariable( "frac05"   , &fFrac05    );
225 +  }
226 +  if (fType == kQGP) {
227 +    fReader->AddVariable( "nvtx"      , &fNVtx       );
228 +    fReader->AddVariable( "jetPt"     , &fJPt1       );  
229 +    fReader->AddVariable( "jetEta"    , &fJEta1      );
230 +    fReader->AddVariable( "jetPhi"    , &fJPhi1      );            
231 +    fReader->AddVariable( "beta"      , &fBeta      );
232 +    fReader->AddVariable( "betaStar"  , &fBetaStar  );
233 +    fReader->AddVariable( "nParticles", &fNNeutrals );
234 +    fReader->AddVariable( "nCharged"  , &fNCharged  );
235 +    fReader->AddVariable( "dRMean"    , &fDRMean    );
236 +    fReader->AddVariable( "ptD"       , &fPtD       );
237 +    fReader->AddVariable( "frac01"    , &fFrac01    );
238 +    fReader->AddVariable( "frac02"    , &fFrac02    );
239 +    fReader->AddVariable( "frac03"    , &fFrac03    );
240 +    fReader->AddVariable( "frac04"    , &fFrac04    );
241 +    fReader->AddVariable( "frac05"    , &fFrac05    );
242 +  }
243  
244    fLowPtReader->BookMVA(fLowPtMethodName  , iLowPtWeights );
245    fReader->BookMVA(fHighPtMethodName , iHighPtWeights );
246    std::cout << "Jet ID MVA Initialization\n";
247    std::cout << "MethodName : " << fLowPtMethodName << " , type == " << fType << std::endl;
248  
137 –  std::string lCutId = "JetIdParams";
138 –  if(fType == k42) lCutId = "PuJetIdOptMVA_wp";
139 –  if(fType == k52) lCutId = "full_5x_wp";
140 –  //Load Cut Matrix
141 –  edm::ParameterSet lDefConfig = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>("JetIdParams");
142 –  edm::ParameterSet lConfig    = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>(lCutId);
143 –  std::string lCutType = "Tight";
144 –  if(fCutType == kMedium) lCutType = "Medium";
145 –  if(fCutType == kLoose ) lCutType = "Loose";
146 –  if(fCutType == kMET   ) lCutType = "MET";
147 –  std::string lLowPtCut = "MET";
148 –  std::vector<double> lPt010  = lDefConfig.getParameter<std::vector<double> >(("Pt010_" +lLowPtCut).c_str());
149 –  std::vector<double> lPt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lCutType).c_str());
150 –  std::vector<double> lPt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lCutType).c_str());
151 –  std::vector<double> lPt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lCutType).c_str());
152 –  for(int i0 = 0; i0 < 4; i0++) fMVACut[0][i0] = lPt010 [i0];
153 –  for(int i0 = 0; i0 < 4; i0++) fMVACut[1][i0] = lPt1020[i0];
154 –  for(int i0 = 0; i0 < 4; i0++) fMVACut[2][i0] = lPt2030[i0];
155 –  for(int i0 = 0; i0 < 4; i0++) fMVACut[3][i0] = lPt3050[i0];
156 –  //std::cout << " Working Points : << " << std::endl;
157 –  //for(int i0 = 0; i0 < 4; i0++) for(int i1 = 0; i1 < 4; i1++)
158 –  //  std::cout << " ==> " << i0 << " -- " << i1 << " -- " << fMVACut[i0][i1] << std::endl;
249   }
250  
251   //--------------------------------------------------------------------------------------------------
# Line 176 | Line 266 | Double_t JetIDMVA::MVAValue(
266                              Float_t iFrac03  ,
267                              Float_t iFrac04  ,
268                              Float_t iFrac05  ,
269 <                            Float_t iDR2Mean  
269 >                            Float_t iDR2Mean ,
270 >                            Float_t iPtD
271                              ){
272    
273    if(!fIsInitialized) {
# Line 195 | Line 286 | Double_t JetIDMVA::MVAValue(
286    fNCharged  = iNCharged;
287    fNNeutrals = iNNeutrals;
288    fDRMean    = iDRMean;
289 +  fPtD       = iPtD;
290    fFrac01    = iFrac01;
291    fFrac02    = iFrac02;
292    fFrac03    = iFrac03;
# Line 205 | Line 297 | Double_t JetIDMVA::MVAValue(
297    Double_t lMVA = -9999;  
298    if(iJPt1 < 10) lMVA = fLowPtReader->EvaluateMVA( fLowPtMethodName  );
299    if(iJPt1 > 10) lMVA = fReader->EvaluateMVA( fHighPtMethodName );
208 –
300    return lMVA;
301   }
302   //--------------------------------------------------------------------------------------------------
303 + Bool_t JetIDMVA::passPt(const PFJet *iJet, FactorizedJetCorrector *iJetCorrector,
304 +                        const PileupEnergyDensityCol *iPileupEnergyDensity,
305 +                        RhoUtilities::RhoType type) {
306 +  if(iJetCorrector == 0) return (iJet->Pt() > fJetPtMin);
307 +  double lPt  = correctedPt(iJet,                  iJetCorrector,iPileupEnergyDensity,type);
308 +  if(lPt < fJetPtMin)                         return false;
309 +  return true;
310 + }
311 + //--------------------------------------------------------------------------------------------------
312   Bool_t JetIDMVA::pass(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices,
313                        FactorizedJetCorrector *iJetCorrector,
314                        const PileupEnergyDensityCol *iPileupEnergyDensity,
# Line 236 | Line 336 | Bool_t JetIDMVA::pass(const PFJet *iJet,
336    return true;
337   }
338   //--------------------------------------------------------------------------------------------------
339 + Bool_t JetIDMVA::passCut(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices) {
340 +  if(!JetTools::passPFLooseId(iJet))                 return false;
341 +  if(iJet->Pt()        < fJetPtMin) return false;
342 +  if(fabs(iJet->Eta()) > 4.99)      return false;
343 +  //if(fType == kCut) passCut(iJet,iVertex,iVertices);
344 +
345 +  double lPt = iJet->Pt();
346 +  int lPtId = 0;
347 +  if(lPt > 10 && lPt < 20) lPtId = 1;
348 +  if(lPt > 20 && lPt < 30) lPtId = 2;
349 +  if(lPt > 30                   ) lPtId = 3;
350 +  
351 +  int lEtaId = 0;
352 +  if(fabs(iJet->Eta()) > 2.5  && fabs(iJet->Eta()) < 2.75) lEtaId = 1;
353 +  if(fabs(iJet->Eta()) > 2.75 && fabs(iJet->Eta()) < 3.0 ) lEtaId = 2;
354 +  if(fabs(iJet->Eta()) > 3.0  && fabs(iJet->Eta()) < 5.0 ) lEtaId = 3;
355 +  float betaStarModified = JetTools::betaStarClassic(iJet,iVertex,iVertices)/log(iVertices ->GetEntries()-0.64);
356 +  float dR2Mean          = JetTools::dR2Mean(iJet,-1);
357 +  
358 +  if(betaStarModified < fBetaStarCut[lPtId][lEtaId] &&
359 +     dR2Mean          < fRMSCut     [lPtId][lEtaId]
360 +     ) return true;
361 +  
362 +  return false;
363 + }
364 + //--------------------------------------------------------------------------------------------------
365   Bool_t JetIDMVA::pass(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices) {
366    if(!JetTools::passPFLooseId(iJet))                 return false;
367    if(iJet->Pt()        < fJetPtMin) return false;
368    if(fabs(iJet->Eta()) > 4.99)      return false;
369 +  if(fType == kCut) return passCut(iJet,iVertex,iVertices);
370    double lMVA = MVAValue(iJet,iVertex,iVertices);
371    
372    int lPtId = 0;
# Line 286 | Line 413 | Double_t JetIDMVA::MVAValue(const PFJet
413  
414    fDRMean    = JetTools::dRMean(iJet,-1);
415    fDR2Mean   = JetTools::dR2Mean(iJet,-1);
416 +  fPtD       = JetTools::W(iJet,-1,0);  
417    fFrac01    = JetTools::frac  (iJet,0.1,0. ,-1);
418    fFrac02    = JetTools::frac  (iJet,0.2,0.1,-1);
419    fFrac03    = JetTools::frac  (iJet,0.3,0.2,-1);
# Line 308 | Line 436 | Double_t JetIDMVA::MVAValue(const PFJet
436                << fNCharged  << " "
437                << fNNeutrals << " "
438                << fDRMean    << " "
439 +              << fPtD       << " "
440                << fFrac01    << " "
441                << fFrac02    << " "
442                << fFrac03    << " "
443                << fFrac04    << " "
444                << fFrac05    << " "
445 <              << fDRMean    
445 >              << fDR2Mean    
446                << " === : === "
447                << lMVA << " "    
448 <              << std::endl;
448 >              << " -----> raw pt " << iJet->Pt() << std::endl;
449    }
450 <
450 >  //std::cout << " === " << iJet->Pt() << " -- " << iJet->Eta() << " -- "  << fPtD << " -- " << lMVA << std::endl;
451    return lMVA;
452   }
453   Double_t JetIDMVA::MVAValue(const PFJet *iJet,const Vertex *iVertex, const VertexCol *iVertices,//Vertex here is the PV
# Line 341 | Line 470 | Double_t JetIDMVA::MVAValue(const PFJet
470    fBetaStar  = JetTools::betaStar(iJet,iVertex,iVertices,fDZCut);
471    fNCharged  = iJet->ChargedMultiplicity();
472    fNNeutrals = iJet->NeutralMultiplicity();
473 <
473 >  fPtD       = JetTools::W(iJet,-1,0);  
474    fDRMean    = JetTools::dRMean (iJet,-1);
475    fDR2Mean   = JetTools::dR2Mean(iJet,-1);
476    fFrac01    = JetTools::frac   (iJet,0.1,0. ,-1);
# Line 367 | Line 496 | Double_t JetIDMVA::MVAValue(const PFJet
496                << fNCharged  << " "
497                << fNNeutrals << " "
498                << fDRMean    << " "
499 +              << fPtD       << " "
500                << fFrac01    << " "
501                << fFrac02    << " "
502                << fFrac03    << " "
503                << fFrac04    << " "
504                << fFrac05    << " "
505 <              << fDRMean    
505 >              << fDR2Mean    
506                << " === : === "
507                << lMVA << " "    
508                << std::endl;
# Line 380 | Line 510 | Double_t JetIDMVA::MVAValue(const PFJet
510  
511    return lMVA;
512   }
513 + //--------------------------------------------------------------------------------------------------
514 + Double_t* JetIDMVA::QGValue(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices, //Vertex here is the PV
515 +                            FactorizedJetCorrector *iJetCorrector,
516 +                            const PileupEnergyDensityCol *iPileupEnergyDensity,
517 +                            Bool_t printDebug) {
518 +
519 +  Double_t *lId = new double[3];
520 +  lId[0] = -2;
521 +  lId[1] = -2;
522 +  lId[2] = -2;
523 +  if (!fIsInitialized) {
524 +    std::cout << "Error: JetIDMVA not properly initialized.\n";
525 +    return lId;
526 +  }
527 +  if(!JetTools::passPFLooseId(iJet)) return lId;
528 +
529 +  fJPt1       = correctedPt(iJet,iJetCorrector,iPileupEnergyDensity);
530 +  if(fJPt1 < 20) return lId;
531 +
532 +  //set all input variables
533 +  fNVtx       = iVertices->GetEntries();
534 +  fJEta1      = iJet->RawMom().Eta();
535 +  fJPhi1      = iJet->RawMom().Phi();
536 +  fJD01       = JetTools::impactParameter(iJet,iVertex);  
537 +  fJDZ1       = JetTools::impactParameter(iJet,iVertex,true);
538 +  fBeta       = JetTools::Beta(iJet,iVertex,fDZCut);
539 +  fBetaStar   = JetTools::betaStar(iJet,iVertex,iVertices,fDZCut);
540 +  fNCharged   = iJet->ChargedMultiplicity();
541 +  fNNeutrals  = iJet->NeutralMultiplicity();
542 +  fNParticles = fNCharged+fNNeutrals;
543 +  fPtD        = JetTools::W(iJet,-1,0);  
544 +
545 +  fDRMean    = JetTools::dRMean(iJet,-1);
546 +  fDR2Mean   = JetTools::dR2Mean(iJet,-1);
547 +  fFrac01    = JetTools::frac  (iJet,0.1,0. ,-1);
548 +  fFrac02    = JetTools::frac  (iJet,0.2,0.1,-1);
549 +  fFrac03    = JetTools::frac  (iJet,0.3,0.2,-1);
550 +  fFrac04    = JetTools::frac  (iJet,0.4,0.3,-1);
551 +  fFrac05    = JetTools::frac  (iJet,0.5,0.4,-1);
552 +
553 +  double lMVA = 0;
554 +  lId[0] = fReader->EvaluateMulticlass( fHighPtMethodName )[0];
555 +  lId[1] = fReader->EvaluateMulticlass( fHighPtMethodName )[1];
556 +  lId[2] = fReader->EvaluateMulticlass( fHighPtMethodName )[2];
557 +  if (printDebug == kTRUE) {
558 +    std::cout << "Debug Jet MVA: "
559 +              << fNVtx      << " "
560 +              << fJPt1      << " "
561 +              << fJEta1     << " "
562 +              << fJPhi1     << " "
563 +              << fJD01      << " "
564 +              << fJDZ1      << " "
565 +              << fBeta      << " "
566 +              << fBetaStar  << " "
567 +              << fNCharged  << " "
568 +              << fNNeutrals << " "
569 +              << fDRMean    << " "
570 +              << fFrac01    << " "
571 +              << fFrac02    << " "
572 +              << fFrac03    << " "
573 +              << fFrac04    << " "
574 +              << fFrac05    << " "
575 +              << fDRMean    
576 +              << " === : === "
577 +              << lMVA << " "    
578 +              << std::endl;
579 +  }
580 +  return lId;
581 + }
582   Double_t JetIDMVA::correctedPt(const PFJet *iJet, FactorizedJetCorrector *iJetCorrector,
583                                 const PileupEnergyDensityCol *iPUEnergyDensity,
584 <                               RhoUtilities::RhoType type) {
584 >                               RhoUtilities::RhoType type,int iId) {
585    Double_t Rho = 0.0;
586    switch(type) {
587    case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
# Line 402 | Line 601 | Double_t JetIDMVA::correctedPt(const PFJ
601      break;
602    default:
603      // use the old default
604 <    Rho = iPUEnergyDensity->At(0)->Rho();
604 >    f42 ? Rho = iPUEnergyDensity->At(0)->RhoRandom() : Rho = iPUEnergyDensity->At(0)->Rho();
605      break;
606    }
607      
# Line 414 | Line 613 | Double_t JetIDMVA::correctedPt(const PFJ
613    iJetCorrector->setRho   (Rho);
614    iJetCorrector->setJetA  (iJet->JetArea());
615    iJetCorrector->setJetEMF(-99.0);    
616 <  Double_t correction = iJetCorrector->getCorrection();
616 >  Double_t correction = 1.;
617 >  if(iId < 0 || iId == 100) correction = iJetCorrector->getCorrection();
618 >  std::vector<float> lCorrections; if(iId != -1 && iId != 100) lCorrections = iJetCorrector->getSubCorrections();
619 >  if(iId > -1 && iId < int(lCorrections.size())) correction = lCorrections[iId];
620 >  if(iId == 100) {
621 >    iJetCorrector->setJetEta(rawMom.Eta());
622 >    iJetCorrector->setJetPt (rawMom.Pt());
623 >    iJetCorrector->setJetPhi(rawMom.Phi());
624 >    iJetCorrector->setJetE  (rawMom.E());
625 >    iJetCorrector->setRho   (Rho);
626 >    iJetCorrector->setJetA  (iJet->JetArea());
627 >    iJetCorrector->setJetEMF(-99.0);
628 >    lCorrections = iJetCorrector->getSubCorrections();
629 >    double correction2 = 1;
630 >    correction2 *= lCorrections[0];
631 >    correction = correction-correction2;
632 >  }
633 >
634    return rawMom.Pt()*correction;
635   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines