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

Comparing UserCode/MitPhysics/Utils/src/RecoilTools.cc (file contents):
Revision 1.7 by pharris, Mon Apr 23 17:40:23 2012 UTC vs.
Revision 1.16 by pharris, Fri May 18 17:02:14 2012 UTC

# Line 26 | Line 26 | bool RecoilTools::filter(const PFJet *iJ
26    if(pDR2 < 0.5) return false;
27    return true;
28   }
29 <
29 > //--------------------------------------------------------------------------------------------------
30 > bool RecoilTools::filter(const PFCandidate *iCand,Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2) {
31 >  double pDEta1 = iCand->Eta() - iEta1;
32 >  double pDPhi1 = fabs(iCand->Phi() - iPhi1); if(pDPhi1 > 2.*TMath::Pi()-pDPhi1) pDPhi1 = 2.*TMath::Pi()-pDPhi1;
33 >  double pDR1   = sqrt(pDEta1*pDEta1 + pDPhi1*pDPhi1);
34 >  if(pDR1 < 0.3) return false;
35 >  double pDEta2 = iCand->Eta() - iEta2;
36 >  double pDPhi2 = fabs(iCand->Phi() - iPhi2); if(pDPhi2 > 2.*TMath::Pi()-pDPhi2) pDPhi2 = 2.*TMath::Pi()-pDPhi2;
37 >  double pDR2   = sqrt(pDEta2*pDEta2 + pDPhi2*pDPhi2);
38 >  if(pDR2 < 0.3) return false;
39 >  return true;
40 > }
41   //--------------------------------------------------------------------------------------------------
42   Met RecoilTools::pfRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
43 <                          const PFMet *iMet) {
44 <  Met lPFMet(iMet->Px(),iMet->Py());
45 <  lPFMet.SetSumEt(iMet->SumEt());
43 >                          const PFCandidateCol *iCands) {
44 >  double lSumEt = 0;
45 >  FourVectorM lVec(0,0,0,0);
46 >  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
47 >    lVec -= iCands->At(i0)->Mom();
48 >    lSumEt += iCands->At(i0)->Et();
49 >  }
50 >  Met lPFMet(lVec.Px(),lVec.Py());
51 >  lPFMet.SetSumEt(lSumEt);
52    lPFMet.SetMex  (lPFMet.Mex()+iVisPt*cos(iVisPhi));  
53    lPFMet.SetMey  (lPFMet.Mey()+iVisPt*sin(iVisPhi));
54    lPFMet.SetSumEt(lPFMet.SumEt()-iVisSumEt);
55    return lPFMet;
56   }
57   //--------------------------------------------------------------------------------------------------
58 + Met RecoilTools::pfRecoil(double iPhi1,double iEta1,double iPhi2,double iEta2,
59 +                          const PFCandidateCol *iCands) {
60 +  double lSumEt = 0;
61 +  FourVectorM lVec(0,0,0,0);
62 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
63 +    if(!filter(iCands->At(i0),iPhi1,iEta1,iPhi2,iEta2)) continue;
64 +    lVec -= iCands->At(i0)->Mom();
65 +    lSumEt += iCands->At(i0)->Et();
66 +  }
67 +  Met lPFMet(lVec.Px(),lVec.Py());
68 +  lPFMet.SetSumEt(lSumEt);
69 +  return lPFMet;
70 + }
71 + //--------------------------------------------------------------------------------------------------
72   Met RecoilTools::trackMet(const PFCandidateCol *iCands,const Vertex *iVertex,Double_t iDZCut) {
73    double trkMetx  = 0;
74    double trkMety  = 0;
75    double trkSumEt = 0;
76 <  for(UInt_t i=0; i<iCands->GetEntries(); ++i) {
77 <    const PFCandidate *pfcand = iCands->At(i);
78 <    if( (pfcand->HasTrackerTrk() && (fabs(pfcand->TrackerTrk()->DzCorrected(*iVertex))< iDZCut)) ) {
79 <      //(pfcand->HasGsfTrk()     && (fabs(pfcand->GsfTrk()->DzCorrected(*iVertex))    < iDZCut)) ) {
76 >  for(UInt_t i0=0; i0<iCands->GetEntries(); i0++) {
77 >    const PFCandidate *pfcand = iCands->At(i0);
78 >    if( (pfcand->HasTrackerTrk() && (fabs(pfcand->TrackerTrk()->DzCorrected(*iVertex))< iDZCut)) ||
79 >        (pfcand->HasGsfTrk()     && (fabs(pfcand->GsfTrk()->DzCorrected(*iVertex))    < iDZCut)) ) {
80 >      trkMetx  -= pfcand->Px();
81 >      trkMety  -= pfcand->Py();
82 >      trkSumEt += pfcand->Pt();
83 >    }
84 >  }
85 >  Met lMet(trkMetx,trkMety);
86 >  lMet.SetSumEt(trkSumEt);
87 >  return lMet;
88 > }
89 > //--------------------------------------------------------------------------------------------------
90 > Met RecoilTools::trackRecoil(double iPhi1,double iEta1,double iPhi2,double iEta2,const PFCandidateCol *iCands,const Vertex *iVertex,Double_t iDZCut) {
91 >  double trkMetx  = 0;
92 >  double trkMety  = 0;
93 >  double trkSumEt = 0;
94 >  for(UInt_t i0=0; i0<iCands->GetEntries(); i0++) {
95 >    const PFCandidate *pfcand = iCands->At(i0);
96 >    if(!filter(pfcand,iPhi1,iEta1,iPhi2,iEta2)) continue;
97 >    if( (pfcand->HasTrackerTrk() && (fabs(pfcand->TrackerTrk()->DzCorrected(*iVertex))< iDZCut)) ||
98 >        (pfcand->HasGsfTrk()     && (fabs(pfcand->GsfTrk()->DzCorrected(*iVertex))    < iDZCut)) ) {
99        trkMetx  -= pfcand->Px();
100        trkMety  -= pfcand->Py();
101        trkSumEt += pfcand->Pt();
# Line 55 | Line 105 | Met RecoilTools::trackMet(const PFCandid
105    lMet.SetSumEt(trkSumEt);
106    return lMet;
107   }
58 –
108   //--------------------------------------------------------------------------------------------------
109   //Compute the recoil => here this requires the vector sum of the visible components
110   //VisPt    => Vector sum pT  of the visible non-recoiling components
# Line 75 | Line 124 | void RecoilTools::addNeut(const PFJet *i
124                            int iSign) {
125    FourVectorM lVec(0,0,0,0);
126    double lPt = fJetIDMVA->correctedPt(iJet,iJetCorrector,iPUEnergyDensity);
127 <  if(iJet->RawMom().Pt() < 10) lPt = TMath::Max(iJet->RawMom().Pt()-iJet->JetArea()*iPUEnergyDensity->At(0)->Rho(),0.);
128 <  lPt *= (iJet->NeutralEmEnergy()/iJet->E() + iJet->NeutralHadronEnergy()/iJet->E());
127 >  //if(iJet->RawMom().Pt() < 10) lPt = TMath::Max(iJet->RawMom().Pt()-iJet->JetArea()*iPUEnergyDensity->At(0)->Rho(),0.);
128 >  lPt *= (iJet->NeutralEmEnergy()/iJet->RawMom().E() + iJet->NeutralHadronEnergy()/iJet->RawMom().E());
129    lVec.SetPt(lPt); lVec.SetEta(iJet->Eta()); lVec.SetPhi(iJet->Phi()); lVec.SetM(iJet->Mass());
130    if(iSign > 0) iVec -= lVec;
131    if(iSign < 0) iVec += lVec;
132 <  iSumEt += lPt;
132 >  //iSumEt += lPt;
133    //=== Above was a bug in the training
134 <  //if(iSign > 0) iSumEt += lPt;
135 <  //if(iSign < 0) iSumEt -= lPt;
134 >  if(iSign > 0) iSumEt += lPt;
135 >  if(iSign < 0) iSumEt -= lPt;
136   }
137  
138   //--------------------------------------------------------------------------------------------------
139   //Corrected Jets
140 < void RecoilTools::addNeut(const PFJet *iJet,FourVectorM &iVec,Double_t &iSumEt,int iSign) {
140 > void RecoilTools::addNeut(const PFJet *iJet,FourVectorM &iVec,Double_t &iSumEt,double iRho,int iSign) {
141    FourVectorM lVec(0,0,0,0);
142    double lPt = iJet->Pt();
143 <  if(iJet->RawMom().Pt() < 10) lPt = iJet->RawMom().Pt()*iJet->L1OffsetCorrectionScale();
143 >  //if(iJet->RawMom().Pt() < 10) lPt = TMath::Max(iJet->RawMom().Pt()-iJet->JetArea()*iRho,0.);//to be fixed
144 >  //if(iJet->RawMom().Pt() < 10) lPt = iJet->RawMom().Pt()*iJet->L1OffsetCorrectionScale();
145    lPt *= (iJet->NeutralEmEnergy()/iJet->RawMom().E() + iJet->NeutralHadronEnergy()/iJet->RawMom().E());
146    lVec.SetPt(lPt); lVec.SetEta(iJet->Eta()); lVec.SetPhi(iJet->Phi()); lVec.SetM(iJet->Mass());
147    if(iSign > 0) iVec   -= lVec;
148    if(iSign < 0) iVec   += lVec;
149 <  iSumEt += lPt;
149 >  //iSumEt += lPt;
150    //=== Above was a bug in the training
151 <  //if(iSign > 0) iSumEt += lPt;
152 <  //if(iSign < 0) iSumEt -= lPt;
151 >  if(iSign > 0) iSumEt += lPt;
152 >  if(iSign < 0) iSumEt -= lPt;
153   }
154  
155   //--------------------------------------------------------------------------------------------------
# Line 116 | Line 166 | Met RecoilTools::NoPUMet( const PFJetCol
166      if(pTrack        ==  0                           ) continue;
167      if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
168             (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
169 +    lSumEt   += pPF->Pt();  
170      lVec     -= pPF->Mom();
120 –    lSumEt   += pPF->Pt();
171    }
172    int lNPass = 0;
173    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
174      const PFJet *pJet = iJets->At(i0);
175 <    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue; //Quick cleaning==> if not done already
175 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue;
176      if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
177      addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
178      lNPass++;
# Line 134 | Line 184 | Met RecoilTools::NoPUMet( const PFJetCol
184   //--------------------------------------------------------------------------------------------------
185   //Corrected Jets
186   Met RecoilTools::NoPUMet( const PFJetCol       *iJets,
187 <                          const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,
187 >                          const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,Double_t iRho,
188                            Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,Double_t iDZCut) {
189  
190    FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
# Line 146 | Line 196 | Met RecoilTools::NoPUMet( const PFJetCol
196      if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
197             (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
198      lVec     -= pPF->Mom();
199 <    lSumEt   += pPF->Pt();
199 >    lSumEt   += pPF->Pt();  
200    }
201    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
202      const PFJet *pJet = iJets->At(i0);
203 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                             continue;
204      if(!fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
205 <    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                             continue; //Quick cleaning==> if not done already
155 <    addNeut(pJet,lVec,lSumEt);
205 >    addNeut(pJet,lVec,lSumEt,iRho);
206    }
207    Met lMet(lVec.Px(),lVec.Py());
208    lMet.SetSumEt(lSumEt);
209    return lMet;
210   }
211   //--------------------------------------------------------------------------------------------------
212 + Met RecoilTools::NoPURecoil(Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
213 +                            const PFJetCol            *iJets,
214 +                            const PFCandidateCol   *iCands   ,
215 +                            const Vertex *iVertex,const VertexCol *iVertices,
216 +                            FactorizedJetCorrector *iJetCorrector,
217 +                            const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
218 +
219 +  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
220 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
221 +    const PFCandidate *pPF = iCands->At(i0);
222 +    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;
223 +    const Track* pTrack = pPF->TrackerTrk();
224 +    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
225 +    if(pTrack        ==  0                           ) continue;
226 +    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
227 +           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
228 +    lSumEt   += pPF->Pt();  
229 +    lVec     -= pPF->Mom();
230 +  }
231 +  int lNPass = 0;
232 +  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
233 +    const PFJet *pJet = iJets->At(i0);
234 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue;
235 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
236 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) if(!fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
237 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
238 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) addNeut(pJet,lVec,lSumEt,1.);
239 +    lNPass++;
240 +  }
241 +  Met lMet(lVec.Px(),lVec.Py());
242 +  lMet.SetSumEt( lSumEt);
243 +  return lMet;
244 + }
245 +
246 + //--------------------------------------------------------------------------------------------------
247   Met RecoilTools::NoPURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
248                              const PFJetCol            *iJets,FactorizedJetCorrector *iJetCorrector,
249                              const PileupEnergyDensityCol *iPileupEnergyDensity,
# Line 177 | Line 262 | Met RecoilTools::NoPURecoil(Double_t iVi
262   //Corrected Jets
263   Met RecoilTools::NoPURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
264                              const PFJetCol       *iJets,const PFCandidateCol *iCands,
265 <                            const Vertex *iVertex,const VertexCol            *iVertices,
265 >                            const Vertex *iVertex,const VertexCol            *iVertices,Double_t iRho,
266                              Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
267                              Double_t iDZCut) {
268    
269 <  Met lNoPUMet = NoPUMet(iJets,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
269 >  Met lNoPUMet = NoPUMet(iJets,iCands,iVertex,iVertices,iRho,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
270    lNoPUMet.SetMex  (lNoPUMet.Mex()+iVisPt*cos(iVisPhi));  
271    lNoPUMet.SetMey  (lNoPUMet.Mey()+iVisPt*sin(iVisPhi));
272    lNoPUMet.SetSumEt(lNoPUMet.SumEt()-iVisSumEt);
# Line 226 | Line 311 | Met RecoilTools::PUCMet( const PFJetCol
311   //--------------------------------------------------------------------------------------------------
312   //Corrected jets
313   Met RecoilTools::PUCMet( const PFJetCol       *iJets,const PFCandidateCol *iCands,
314 <                         const Vertex *iVertex,const VertexCol *iVertices,
314 >                         const Vertex *iVertex,const VertexCol *iVertices,Double_t iRho,
315                           Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
316                           Double_t iDZCut) {
317  
# Line 252 | Line 337 | Met RecoilTools::PUCMet( const PFJetCol
337      if(!JetTools::passPFLooseId(pJet))                                   continue;
338      if(fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
339      if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                            continue; //Quick cleaning==> if not done already
340 <    addNeut(pJet,lVec,lSumEt,-1);
340 >    addNeut(pJet,lVec,lSumEt,iRho,-1);
341 >  }
342 >  Met lMet(lVec.Px(),lVec.Py());
343 >  lMet.SetSumEt(lSumEt);
344 >  return lMet;
345 > }
346 > //--------------------------------------------------------------------------------------------------
347 > Met RecoilTools::PUCRecoil( Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
348 >                            const PFJetCol            *iJets,
349 >                            const PFCandidateCol   *iCands   ,
350 >                            const Vertex *iVertex,const VertexCol *iVertices,
351 >                            FactorizedJetCorrector *iJetCorrector,
352 >                           const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
353 >
354 >  
355 >  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
356 >  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
357 >    const PFCandidate *pPF = iCands->At(i0);
358 >    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;    
359 >    const Track* pTrack = pPF->TrackerTrk();
360 >    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
361 >    if(pTrack == 0                                   &&
362 >       (pPF->PFType() == PFCandidate::eGamma         ||
363 >        pPF->PFType() == PFCandidate::eEGammaHF      ||
364 >        pPF->PFType() == PFCandidate::eNeutralHadron ||
365 >        pPF->PFType() == PFCandidate::eHadronHF      ))
366 >      {lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
367 >    if(pTrack        ==  0                           ) continue;
368 >    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
369 >           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
370 >    lVec     -= pPF->Mom();
371 >    lSumEt   += pPF->Pt();
372 >  }
373 >  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
374 >    const PFJet *pJet = iJets->At(i0);
375 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning==> if not done already
376 >    if(!JetTools::passPFLooseId(pJet))                                             continue;
377 >    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
378 >    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) if(fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
379 >    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity,-1);
380 >    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) addNeut(pJet,lVec,lSumEt,1,-1);
381    }
382    Met lMet(lVec.Px(),lVec.Py());
383    lMet.SetSumEt(lSumEt);
# Line 278 | Line 403 | Met RecoilTools::PUCRecoil(Double_t iVis
403   Met RecoilTools::PUCRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
404                             const PFJetCol       *iJets,
405                             const PFCandidateCol *iCands,const Vertex *iVertex,
406 <                           const VertexCol *iVertices,
406 >                           const VertexCol *iVertices,Double_t iRho,
407                             Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
408                             Double_t iDZCut) {
409 <  Met lPUCMet = PUCMet(iJets,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
409 >  Met lPUCMet = PUCMet(iJets,iCands,iVertex,iVertices,iRho,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
410    lPUCMet.SetMex  (lPUCMet.Mex()+iVisPt*cos(iVisPhi));  
411    lPUCMet.SetMey  (lPUCMet.Mey()+iVisPt*sin(iVisPhi));
412    lPUCMet.SetSumEt(lPUCMet.SumEt()-iVisSumEt);
# Line 320 | Line 445 | Met RecoilTools::PUMet( const PFJetCol
445   //--------------------------------------------------------------------------------------------------
446   //Corrected Jets
447   Met RecoilTools::PUMet( const PFJetCol       *iJets,
448 <                        const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,
448 >                        const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,Double_t iRho,
449                          Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
450                          Double_t iDZCut) {
451  
# Line 340 | Line 465 | Met RecoilTools::PUMet( const PFJetCol
465      if(!JetTools::passPFLooseId(pJet))                                   continue;
466      if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                            continue; //Quick cleaning
467      if(fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
468 <    addNeut(pJet,lVec,lSumEt);
468 >    addNeut(pJet,lVec,lSumEt,iRho);
469 >  }
470 >  Met lMet(lVec.Px(),lVec.Py());
471 >  lMet.SetSumEt(lSumEt);
472 >  return lMet;
473 > }
474 > //--------------------------------------------------------------------------------------------------
475 > Met RecoilTools::PUMet( Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
476 >                        const PFJetCol            *iJets,
477 >                        const PFCandidateCol   *iCands   ,
478 >                        const Vertex *iVertex,const VertexCol *iVertices,
479 >                        FactorizedJetCorrector *iJetCorrector,
480 >                        const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
481 >  
482 >  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
483 >  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
484 >    const PFCandidate *pPF = iCands->At(i0);
485 >    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;    
486 >    const Track* pTrack = pPF->TrackerTrk();
487 >    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
488 >    if(pTrack        ==  0                           ) continue;
489 >    if(   ((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
490 >           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
491 >    lVec     -= pPF->Mom();
492 >    lSumEt   += pPF->Pt();
493 >  }
494 >  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
495 >    const PFJet *pJet = iJets->At(i0);
496 >    if(!JetTools::passPFLooseId(pJet))                                             continue;
497 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning
498 >    if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
499 >    addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
500    }
501    Met lMet(lVec.Px(),lVec.Py());
502    lMet.SetSumEt(lSumEt);
# Line 364 | Line 520 | Met RecoilTools::PURecoil(Double_t iVisP
520   //Corrected Jets
521   Met RecoilTools::PURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
522                            const PFJetCol       *iJets,
523 <                          const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,
523 >                          const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,Double_t iRho,
524                            Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
525                            Double_t iDZCut) {
526 <  Met lPUMet = PUMet(iJets,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
526 >  Met lPUMet = PUMet(iJets,iCands,iVertex,iVertices,iRho,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
527    lPUMet.SetMex  (lPUMet.Mex()+iVisPt*cos(iVisPhi));  
528    lPUMet.SetMey  (lPUMet.Mey()+iVisPt*sin(iVisPhi));
529    lPUMet.SetSumEt(lPUMet.SumEt()-iVisSumEt);

Diff Legend

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