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.13 by bendavid, Tue May 29 16:55:43 2012 UTC vs.
Revision 1.20 by arapyan, Fri Apr 5 13:14:28 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 58 | Line 59 | void JetIDMVA::Initialize( JetIDMVA::Cut
59    fIsInitialized = kTRUE;
60    fType          = iType;
61    fCutType       = iCutType;
62 +  
63 +  std::string lCutId = "JetIdParams";
64 +  if(fType == k42)     lCutId = "PuJetIdOptMVA_wp";
65 +  if(fType == k52)     lCutId = "full_5x_wp";
66 +  if(fType == kCut)    lCutId = "PuJetIdCutBased_wp";
67 +  if(fType == k53)     lCutId = "full_53x_wp";
68 +  if(fType == k53MET)  lCutId = "met_53x_wp";
69 +
70 + //Load Cut Matrix
71 +  edm::ParameterSet lDefConfig = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>("JetIdParams");
72 +  edm::ParameterSet lConfig    = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>(lCutId);
73 +  std::string lCutType = "Tight";
74 +  if(fCutType == kMedium) lCutType = "Medium";
75 +  if(fCutType == kLoose ) lCutType = "Loose";
76 +  if(fCutType == kMET   ) lCutType = "MET";
77 +  if(fType != kCut) {
78 +    std::string lLowPtCut = "MET";
79 +    std::vector<double> lPt010  = lDefConfig.getParameter<std::vector<double> >(("Pt010_" +lLowPtCut).c_str());
80 +    std::vector<double> lPt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lCutType).c_str());
81 +    std::vector<double> lPt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lCutType).c_str());
82 +    std::vector<double> lPt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lCutType).c_str());
83 +    for(int i0 = 0; i0 < 4; i0++) fMVACut[0][i0] = lPt010 [i0];
84 +    for(int i0 = 0; i0 < 4; i0++) fMVACut[1][i0] = lPt1020[i0];
85 +    for(int i0 = 0; i0 < 4; i0++) fMVACut[2][i0] = lPt2030[i0];
86 +    for(int i0 = 0; i0 < 4; i0++) fMVACut[3][i0] = lPt3050[i0];
87 +  }
88 +  if(fType == kCut) {
89 +    for(int i0 = 0; i0 < 2; i0++) {
90 +      std::string lFullCutType = lCutType;
91 +      if(i0 == 0) lFullCutType = "BetaStar"+ lCutType;
92 +      if(i0 == 1) lFullCutType = "RMS"     + lCutType;
93 +      std::vector<double> pt010  = lConfig.getParameter<std::vector<double> >(("Pt010_" +lFullCutType).c_str());
94 +      std::vector<double> pt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lFullCutType).c_str());
95 +      std::vector<double> pt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lFullCutType).c_str());
96 +      std::vector<double> pt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lFullCutType).c_str());
97 +      if(i0 == 0) {
98 +        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[0][i2] = pt010 [i2];
99 +        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[1][i2] = pt1020[i2];
100 +        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[2][i2] = pt2030[i2];
101 +        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[3][i2] = pt3050[i2];
102 +      }
103 +      if(i0 == 1) {
104 +        for(int i2 = 0; i2 < 4; i2++) fRMSCut[0][i2] = pt010 [i2];
105 +        for(int i2 = 0; i2 < 4; i2++) fRMSCut[1][i2] = pt1020[i2];
106 +        for(int i2 = 0; i2 < 4; i2++) fRMSCut[2][i2] = pt2030[i2];
107 +        for(int i2 = 0; i2 < 4; i2++) fRMSCut[3][i2] = pt3050[i2];
108 +      }
109 +    }
110 +    return;
111 +  }
112 +  
113 +  
114    fLowPtReader   = 0;
115    fLowPtReader   = new TMVA::Reader( "!Color:!Silent:Error" );  
116    fLowPtReader->AddVariable( "nvtx"     , &fNVtx      );
117 <  fLowPtReader->AddVariable( "jetPt"    , &fJPt1      );  
118 <  fLowPtReader->AddVariable( "jetEta"   , &fJEta1     );
119 <  fLowPtReader->AddVariable( "jetPhi"   , &fJPhi1     );            
117 >  if(fType != k53) fLowPtReader->AddVariable( "jetPt"    , &fJPt1      );  
118 >  if(fType != k53) fLowPtReader->AddVariable( "jetEta"   , &fJEta1     );
119 >  if(fType != k53) fLowPtReader->AddVariable( "jetPhi"   , &fJPhi1     );            
120    fLowPtReader->AddVariable( "dZ"       , &fJDZ1      );
121 <  fLowPtReader->AddVariable( "d0"       , &fJD01      );
121 >  if(fType != k53 && fType != k53MET) fLowPtReader->AddVariable( "d0"       , &fJD01      );
122    fLowPtReader->AddVariable( "beta"     , &fBeta      );
123    fLowPtReader->AddVariable( "betaStar" , &fBetaStar  );
124    fLowPtReader->AddVariable( "nCharged" , &fNCharged  );
125    fLowPtReader->AddVariable( "nNeutrals", &fNNeutrals );
126 <  fLowPtReader->AddVariable( "dRMean"   , &fDRMean    );
126 >  if(fType != k53 && fType != k53MET) fLowPtReader->AddVariable( "dRMean"   , &fDRMean    );
127 >  if(fType == k53 || fType == k53MET) fLowPtReader->AddVariable( "dR2Mean"  , &fDR2Mean   );
128 >  if(fType == k53 || fType == k53MET) fLowPtReader->AddVariable( "ptD"      , &fPtD       );
129    fLowPtReader->AddVariable( "frac01"   , &fFrac01    );
130    fLowPtReader->AddVariable( "frac02"   , &fFrac02    );
131    fLowPtReader->AddVariable( "frac03"   , &fFrac03    );
132    fLowPtReader->AddVariable( "frac04"   , &fFrac04    );
133    fLowPtReader->AddVariable( "frac05"   , &fFrac05    );
134 +  if(fType == k53) fLowPtReader->AddSpectator( "jetPt"   , &fJPt1      );  
135 +  if(fType == k53) fLowPtReader->AddSpectator( "jetEta"  , &fJEta1     );
136 +  if(fType == k53) fLowPtReader->AddSpectator( "jetPhi"  , &fJPhi1     );  
137    
138    fReader        = 0;
139    fReader        = new TMVA::Reader( "!Color:!Silent:Error" );  
# Line 128 | Line 186 | void JetIDMVA::Initialize( JetIDMVA::Cut
186      fReader->AddSpectator( "jetPt"    , &fJPt1      );  
187      fReader->AddSpectator( "jetEta"   , &fJEta1     );
188    }
189 +  if (fType == k53) {
190 +    fReader->AddVariable( "nvtx"     , &fNVtx      );
191 +    fReader->AddVariable( "dZ"       , &fJDZ1      );
192 +    fReader->AddVariable( "beta"     , &fBeta      );
193 +    fReader->AddVariable( "betaStar" , &fBetaStar  );
194 +    fReader->AddVariable( "nCharged" , &fNCharged  );
195 +    fReader->AddVariable( "nNeutrals", &fNNeutrals );
196 +    fReader->AddVariable( "dR2Mean"  , &fDR2Mean   );
197 +    fReader->AddVariable( "ptD"      , &fPtD       );
198 +    fReader->AddVariable( "frac01"   , &fFrac01    );
199 +    fReader->AddVariable( "frac02"   , &fFrac02    );
200 +    fReader->AddVariable( "frac03"   , &fFrac03    );
201 +    fReader->AddVariable( "frac04"   , &fFrac04    );
202 +    fReader->AddVariable( "frac05"   , &fFrac05    );
203 +    fReader->AddSpectator( "jetPt"   , &fJPt1      );  
204 +    fReader->AddSpectator( "jetEta"  , &fJEta1     );
205 +    fReader->AddSpectator( "jetPhi"  , &fJPhi1     );  
206 +  }
207 +  if (fType == k53MET) {
208 +    fReader->AddVariable( "nvtx"     , &fNVtx      );
209 +    fReader->AddVariable( "jetPt"    , &fJPt1      );  
210 +    fReader->AddVariable( "jetEta"   , &fJEta1     );
211 +    fReader->AddVariable( "jetPhi"   , &fJPhi1     );  
212 +    fReader->AddVariable( "dZ"       , &fJDZ1      );
213 +    fReader->AddVariable( "beta"     , &fBeta      );
214 +    fReader->AddVariable( "betaStar" , &fBetaStar  );
215 +    fReader->AddVariable( "nCharged" , &fNCharged  );
216 +    fReader->AddVariable( "nNeutrals", &fNNeutrals );
217 +    fReader->AddVariable( "dR2Mean"  , &fDR2Mean   );
218 +    fReader->AddVariable( "ptD"      , &fPtD       );
219 +    fReader->AddVariable( "frac01"   , &fFrac01    );
220 +    fReader->AddVariable( "frac02"   , &fFrac02    );
221 +    fReader->AddVariable( "frac03"   , &fFrac03    );
222 +    fReader->AddVariable( "frac04"   , &fFrac04    );
223 +    fReader->AddVariable( "frac05"   , &fFrac05    );
224 +  }
225 +  if (fType == kQGP) {
226 +    fReader->AddVariable( "nvtx"      , &fNVtx       );
227 +    fReader->AddVariable( "jetPt"     , &fJPt1       );  
228 +    fReader->AddVariable( "jetEta"    , &fJEta1      );
229 +    fReader->AddVariable( "jetPhi"    , &fJPhi1      );            
230 +    fReader->AddVariable( "beta"      , &fBeta      );
231 +    fReader->AddVariable( "betaStar"  , &fBetaStar  );
232 +    fReader->AddVariable( "nParticles", &fNNeutrals );
233 +    fReader->AddVariable( "nCharged"  , &fNCharged  );
234 +    fReader->AddVariable( "dRMean"    , &fDRMean    );
235 +    fReader->AddVariable( "ptD"       , &fPtD       );
236 +    fReader->AddVariable( "frac01"    , &fFrac01    );
237 +    fReader->AddVariable( "frac02"    , &fFrac02    );
238 +    fReader->AddVariable( "frac03"    , &fFrac03    );
239 +    fReader->AddVariable( "frac04"    , &fFrac04    );
240 +    fReader->AddVariable( "frac05"    , &fFrac05    );
241 +  }
242  
243    fLowPtReader->BookMVA(fLowPtMethodName  , iLowPtWeights );
244    fReader->BookMVA(fHighPtMethodName , iHighPtWeights );
245    std::cout << "Jet ID MVA Initialization\n";
246    std::cout << "MethodName : " << fLowPtMethodName << " , type == " << fType << std::endl;
247  
137 –  std::string lCutId = "JetIdParams";
138 –  if(fType == k42)  lCutId = "PuJetIdOptMVA_wp";
139 –  if(fType == k52)  lCutId = "full_5x_wp";
140 –  if(fType == kCut) lCutId = "PuJetIdCutBased_wp";
141 –  //Load Cut Matrix
142 –  edm::ParameterSet lDefConfig = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>("JetIdParams");
143 –  edm::ParameterSet lConfig    = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>(lCutId);
144 –  std::string lCutType = "Tight";
145 –  if(fCutType == kMedium) lCutType = "Medium";
146 –  if(fCutType == kLoose ) lCutType = "Loose";
147 –  if(fCutType == kMET   ) lCutType = "MET";
148 –  if(fType != kCut) {
149 –    std::string lLowPtCut = "MET";
150 –    std::vector<double> lPt010  = lDefConfig.getParameter<std::vector<double> >(("Pt010_" +lLowPtCut).c_str());
151 –    std::vector<double> lPt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lCutType).c_str());
152 –    std::vector<double> lPt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lCutType).c_str());
153 –    std::vector<double> lPt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lCutType).c_str());
154 –    for(int i0 = 0; i0 < 4; i0++) fMVACut[0][i0] = lPt010 [i0];
155 –    for(int i0 = 0; i0 < 4; i0++) fMVACut[1][i0] = lPt1020[i0];
156 –    for(int i0 = 0; i0 < 4; i0++) fMVACut[2][i0] = lPt2030[i0];
157 –    for(int i0 = 0; i0 < 4; i0++) fMVACut[3][i0] = lPt3050[i0];
158 –  }
159 –  if(fType == kCut) {
160 –    for(int i0 = 0; i0 < 2; i0++) {
161 –      std::string lFullCutType = lCutType;
162 –      if(i0 == 0) lFullCutType = "BetaStar"+ lCutType;
163 –      if(i0 == 1) lFullCutType = "RMS"     + lCutType;
164 –      std::vector<double> pt010  = lConfig.getParameter<std::vector<double> >(("Pt010_" +lFullCutType).c_str());
165 –      std::vector<double> pt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lFullCutType).c_str());
166 –      std::vector<double> pt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lFullCutType).c_str());
167 –      std::vector<double> pt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lFullCutType).c_str());
168 –      if(i0 == 0) {
169 –        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[0][i2] = pt010 [i2];
170 –        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[1][i2] = pt1020[i2];
171 –        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[2][i2] = pt2030[i2];
172 –        for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[3][i2] = pt3050[i2];
173 –      }
174 –      if(i0 == 1) {
175 –        for(int i2 = 0; i2 < 4; i2++) fRMSCut[0][i2] = pt010 [i2];
176 –        for(int i2 = 0; i2 < 4; i2++) fRMSCut[1][i2] = pt1020[i2];
177 –        for(int i2 = 0; i2 < 4; i2++) fRMSCut[2][i2] = pt2030[i2];
178 –        for(int i2 = 0; i2 < 4; i2++) fRMSCut[3][i2] = pt3050[i2];
179 –      }
180 –    }
181 –  }
248   }
249  
250   //--------------------------------------------------------------------------------------------------
# Line 199 | Line 265 | Double_t JetIDMVA::MVAValue(
265                              Float_t iFrac03  ,
266                              Float_t iFrac04  ,
267                              Float_t iFrac05  ,
268 <                            Float_t iDR2Mean  
268 >                            Float_t iDR2Mean ,
269 >                            Float_t iPtD
270                              ){
271    
272    if(!fIsInitialized) {
# Line 218 | Line 285 | Double_t JetIDMVA::MVAValue(
285    fNCharged  = iNCharged;
286    fNNeutrals = iNNeutrals;
287    fDRMean    = iDRMean;
288 +  fPtD       = iPtD;
289    fFrac01    = iFrac01;
290    fFrac02    = iFrac02;
291    fFrac03    = iFrac03;
# Line 228 | Line 296 | Double_t JetIDMVA::MVAValue(
296    Double_t lMVA = -9999;  
297    if(iJPt1 < 10) lMVA = fLowPtReader->EvaluateMVA( fLowPtMethodName  );
298    if(iJPt1 > 10) lMVA = fReader->EvaluateMVA( fHighPtMethodName );
231 –
299    return lMVA;
300   }
301   //--------------------------------------------------------------------------------------------------
302 + Bool_t JetIDMVA::passPt(const PFJet *iJet, FactorizedJetCorrector *iJetCorrector,
303 +                        const PileupEnergyDensityCol *iPileupEnergyDensity,
304 +                        RhoUtilities::RhoType type) {
305 +  if(iJetCorrector == 0) return (iJet->Pt() > fJetPtMin);
306 +  double lPt  = correctedPt(iJet,                  iJetCorrector,iPileupEnergyDensity,type);
307 +  if(lPt < fJetPtMin)                         return false;
308 +  return true;
309 + }
310 + //--------------------------------------------------------------------------------------------------
311   Bool_t JetIDMVA::pass(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices,
312                        FactorizedJetCorrector *iJetCorrector,
313                        const PileupEnergyDensityCol *iPileupEnergyDensity,
# Line 336 | Line 412 | Double_t JetIDMVA::MVAValue(const PFJet
412  
413    fDRMean    = JetTools::dRMean(iJet,-1);
414    fDR2Mean   = JetTools::dR2Mean(iJet,-1);
415 +  fPtD       = JetTools::W(iJet,-1,0);  
416    fFrac01    = JetTools::frac  (iJet,0.1,0. ,-1);
417    fFrac02    = JetTools::frac  (iJet,0.2,0.1,-1);
418    fFrac03    = JetTools::frac  (iJet,0.3,0.2,-1);
# Line 358 | Line 435 | Double_t JetIDMVA::MVAValue(const PFJet
435                << fNCharged  << " "
436                << fNNeutrals << " "
437                << fDRMean    << " "
438 +              << fPtD       << " "
439                << fFrac01    << " "
440                << fFrac02    << " "
441                << fFrac03    << " "
442                << fFrac04    << " "
443                << fFrac05    << " "
444 <              << fDRMean    
444 >              << fDR2Mean    
445                << " === : === "
446                << lMVA << " "    
447 <              << std::endl;
447 >              << " -----> raw pt " << iJet->Pt() << std::endl;
448    }
449 <
449 >  //std::cout << " === " << iJet->Pt() << " -- " << iJet->Eta() << " -- "  << fPtD << " -- " << lMVA << std::endl;
450    return lMVA;
451   }
452   Double_t JetIDMVA::MVAValue(const PFJet *iJet,const Vertex *iVertex, const VertexCol *iVertices,//Vertex here is the PV
# Line 391 | Line 469 | Double_t JetIDMVA::MVAValue(const PFJet
469    fBetaStar  = JetTools::betaStar(iJet,iVertex,iVertices,fDZCut);
470    fNCharged  = iJet->ChargedMultiplicity();
471    fNNeutrals = iJet->NeutralMultiplicity();
472 <
472 >  fPtD       = JetTools::W(iJet,-1,0);  
473    fDRMean    = JetTools::dRMean (iJet,-1);
474    fDR2Mean   = JetTools::dR2Mean(iJet,-1);
475    fFrac01    = JetTools::frac   (iJet,0.1,0. ,-1);
# Line 417 | Line 495 | Double_t JetIDMVA::MVAValue(const PFJet
495                << fNCharged  << " "
496                << fNNeutrals << " "
497                << fDRMean    << " "
498 +              << fPtD       << " "
499                << fFrac01    << " "
500                << fFrac02    << " "
501                << fFrac03    << " "
502                << fFrac04    << " "
503                << fFrac05    << " "
504 <              << fDRMean    
504 >              << fDR2Mean    
505                << " === : === "
506                << lMVA << " "    
507                << std::endl;
# Line 430 | Line 509 | Double_t JetIDMVA::MVAValue(const PFJet
509  
510    return lMVA;
511   }
512 + //--------------------------------------------------------------------------------------------------
513 + Double_t* JetIDMVA::QGValue(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices, //Vertex here is the PV
514 +                            FactorizedJetCorrector *iJetCorrector,
515 +                            const PileupEnergyDensityCol *iPileupEnergyDensity,
516 +                            Bool_t printDebug) {
517 +
518 +  Double_t *lId = new double[3];
519 +  lId[0] = -2;
520 +  lId[1] = -2;
521 +  lId[2] = -2;
522 +  if (!fIsInitialized) {
523 +    std::cout << "Error: JetIDMVA not properly initialized.\n";
524 +    return lId;
525 +  }
526 +  if(!JetTools::passPFLooseId(iJet)) return lId;
527 +
528 +  fJPt1       = correctedPt(iJet,iJetCorrector,iPileupEnergyDensity);
529 +  if(fJPt1 < 20) return lId;
530 +
531 +  //set all input variables
532 +  fNVtx       = iVertices->GetEntries();
533 +  fJEta1      = iJet->RawMom().Eta();
534 +  fJPhi1      = iJet->RawMom().Phi();
535 +  fJD01       = JetTools::impactParameter(iJet,iVertex);  
536 +  fJDZ1       = JetTools::impactParameter(iJet,iVertex,true);
537 +  fBeta       = JetTools::Beta(iJet,iVertex,fDZCut);
538 +  fBetaStar   = JetTools::betaStar(iJet,iVertex,iVertices,fDZCut);
539 +  fNCharged   = iJet->ChargedMultiplicity();
540 +  fNNeutrals  = iJet->NeutralMultiplicity();
541 +  fNParticles = fNCharged+fNNeutrals;
542 +  fPtD        = JetTools::W(iJet,-1,0);  
543 +
544 +  fDRMean    = JetTools::dRMean(iJet,-1);
545 +  fDR2Mean   = JetTools::dR2Mean(iJet,-1);
546 +  fFrac01    = JetTools::frac  (iJet,0.1,0. ,-1);
547 +  fFrac02    = JetTools::frac  (iJet,0.2,0.1,-1);
548 +  fFrac03    = JetTools::frac  (iJet,0.3,0.2,-1);
549 +  fFrac04    = JetTools::frac  (iJet,0.4,0.3,-1);
550 +  fFrac05    = JetTools::frac  (iJet,0.5,0.4,-1);
551 +
552 +  double lMVA = 0;
553 +  lId[0] = fReader->EvaluateMulticlass( fHighPtMethodName )[0];
554 +  lId[1] = fReader->EvaluateMulticlass( fHighPtMethodName )[1];
555 +  lId[2] = fReader->EvaluateMulticlass( fHighPtMethodName )[2];
556 +  if (printDebug == kTRUE) {
557 +    std::cout << "Debug Jet MVA: "
558 +              << fNVtx      << " "
559 +              << fJPt1      << " "
560 +              << fJEta1     << " "
561 +              << fJPhi1     << " "
562 +              << fJD01      << " "
563 +              << fJDZ1      << " "
564 +              << fBeta      << " "
565 +              << fBetaStar  << " "
566 +              << fNCharged  << " "
567 +              << fNNeutrals << " "
568 +              << fDRMean    << " "
569 +              << fFrac01    << " "
570 +              << fFrac02    << " "
571 +              << fFrac03    << " "
572 +              << fFrac04    << " "
573 +              << fFrac05    << " "
574 +              << fDRMean    
575 +              << " === : === "
576 +              << lMVA << " "    
577 +              << std::endl;
578 +  }
579 +  return lId;
580 + }
581   Double_t JetIDMVA::correctedPt(const PFJet *iJet, FactorizedJetCorrector *iJetCorrector,
582                                 const PileupEnergyDensityCol *iPUEnergyDensity,
583 <                               RhoUtilities::RhoType type) {
583 >                               RhoUtilities::RhoType type,int iId) {
584    Double_t Rho = 0.0;
585    switch(type) {
586    case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
# Line 464 | Line 612 | Double_t JetIDMVA::correctedPt(const PFJ
612    iJetCorrector->setRho   (Rho);
613    iJetCorrector->setJetA  (iJet->JetArea());
614    iJetCorrector->setJetEMF(-99.0);    
615 <  Double_t correction = iJetCorrector->getCorrection();
615 >  Double_t correction = 1.;
616 >  if(iId < 0 || iId == 100) correction = iJetCorrector->getCorrection();
617 >  std::vector<float> lCorrections; if(iId != -1 && iId != 100) lCorrections = iJetCorrector->getSubCorrections();
618 >  if(iId > -1 && iId < int(lCorrections.size())) correction = lCorrections[iId];
619 >  if(iId == 100) {
620 >    iJetCorrector->setJetEta(rawMom.Eta());
621 >    iJetCorrector->setJetPt (rawMom.Pt());
622 >    iJetCorrector->setJetPhi(rawMom.Phi());
623 >    iJetCorrector->setJetE  (rawMom.E());
624 >    iJetCorrector->setRho   (Rho);
625 >    iJetCorrector->setJetA  (iJet->JetArea());
626 >    iJetCorrector->setJetEMF(-99.0);
627 >    lCorrections = iJetCorrector->getSubCorrections();
628 >    double correction2 = 1;
629 >    correction2 *= lCorrections[0];
630 >    correction = correction-correction2;
631 >  }
632 >
633    return rawMom.Pt()*correction;
634   }

Diff Legend

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