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.13 by pharris, Tue May 1 18:17:54 2012 UTC vs.
Revision 1.21 by pharris, Thu Aug 2 23:48:08 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 PFCandidateCol *iCands) {
44    double lSumEt = 0;
45    FourVectorM lVec(0,0,0,0);
46 <  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) { lVec -= iCands->At(i0)->Mom(); lSumEt += iCands->At(i0)->Et();}
46 >  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
47 >    lVec -= iCands->At(i0)->Mom();
48 >    lSumEt += iCands->At(i0)->Pt();
49 >  }
50    Met lPFMet(lVec.Px(),lVec.Py());
51    lPFMet.SetSumEt(lSumEt);
52    lPFMet.SetMex  (lPFMet.Mex()+iVisPt*cos(iVisPhi));  
# Line 41 | Line 55 | Met RecoilTools::pfRecoil(Double_t iVisP
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 +    const PFCandidate *pfcand = iCands->At(i0);
64 +    if(!filter(pfcand,iPhi1,iEta1,iPhi2,iEta2)) continue;
65 +    lVec   -= pfcand->Mom();
66 +    lSumEt += pfcand->Pt();
67 +  }
68 +  Met lPFMet(lVec.Px(),lVec.Py());
69 +  lPFMet.SetSumEt(lSumEt);
70 +  return lPFMet;
71 + }
72 + //--------------------------------------------------------------------------------------------------
73 + Met RecoilTools::pfCone(double iPhi1,double iEta1,
74 +                          const PFCandidateCol *iCands) {
75 +  double lSumEt = 0;
76 +  FourVectorM lVec(0,0,0,0);
77 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
78 +    const PFCandidate *pfcand = iCands->At(i0);
79 +    if(filter(pfcand,iPhi1,iEta1,100,100)) continue;
80 +    lVec   += pfcand->Mom();
81 +    lSumEt += pfcand->Pt();
82 +  }
83 +  Met lPFMet(lVec.Px(),lVec.Py());
84 +  lPFMet.SetSumEt(lSumEt);
85 +  return lPFMet;
86 + }
87 + //--------------------------------------------------------------------------------------------------
88   Met RecoilTools::trackMet(const PFCandidateCol *iCands,const Vertex *iVertex,Double_t iDZCut) {
89    double trkMetx  = 0;
90    double trkMety  = 0;
91    double trkSumEt = 0;
92    for(UInt_t i0=0; i0<iCands->GetEntries(); i0++) {
93      const PFCandidate *pfcand = iCands->At(i0);
94 +    double lDZ = 999;
95 +    if(pfcand->HasTrackerTrk())  lDZ =  fabs(pfcand->TrackerTrk()->DzCorrected(*iVertex));//
96 +    else if(pfcand->HasGsfTrk()) lDZ =  fabs(pfcand->GsfTrk()    ->DzCorrected(*iVertex));
97 +    if( fabs(lDZ) > iDZCut) continue;
98 +    trkMetx  -= pfcand->Px();
99 +    trkMety  -= pfcand->Py();
100 +    trkSumEt += pfcand->Pt();
101 +  }
102 +  Met lMet(trkMetx,trkMety);
103 +  lMet.SetSumEt(trkSumEt);
104 +  return lMet;
105 + }
106 + //--------------------------------------------------------------------------------------------------
107 + Met RecoilTools::trackRecoil(double iPhi1,double iEta1,double iPhi2,double iEta2,const PFCandidateCol *iCands,const Vertex *iVertex,Double_t iDZCut) {
108 +  double trkMetx  = 0;
109 +  double trkMety  = 0;
110 +  double trkSumEt = 0;
111 +  for(UInt_t i0=0; i0<iCands->GetEntries(); i0++) {
112 +    const PFCandidate *pfcand = iCands->At(i0);
113 +    if(!filter(pfcand,iPhi1,iEta1,iPhi2,iEta2)) continue;
114      if( (pfcand->HasTrackerTrk() && (fabs(pfcand->TrackerTrk()->DzCorrected(*iVertex))< iDZCut)) ||
115          (pfcand->HasGsfTrk()     && (fabs(pfcand->GsfTrk()->DzCorrected(*iVertex))    < iDZCut)) ) {
116        trkMetx  -= pfcand->Px();
# Line 58 | Line 122 | Met RecoilTools::trackMet(const PFCandid
122    lMet.SetSumEt(trkSumEt);
123    return lMet;
124   }
61 –
125   //--------------------------------------------------------------------------------------------------
126   //Compute the recoil => here this requires the vector sum of the visible components
127   //VisPt    => Vector sum pT  of the visible non-recoiling components
# Line 78 | Line 141 | void RecoilTools::addNeut(const PFJet *i
141                            int iSign) {
142    FourVectorM lVec(0,0,0,0);
143    double lPt = fJetIDMVA->correctedPt(iJet,iJetCorrector,iPUEnergyDensity);
144 <  if(iJet->RawMom().Pt() < 10) lPt = TMath::Max(iJet->RawMom().Pt()-iJet->JetArea()*iPUEnergyDensity->At(0)->Rho(),0.);
144 >  //if(lPt < 0) lPt = 0.;
145 >  //if(iJet->RawMom().Pt() < 10) lPt = TMath::Max(iJet->RawMom().Pt()-iJet->JetArea()*iPUEnergyDensity->At(0)->Rho(),0.);
146    lPt *= (iJet->NeutralEmEnergy()/iJet->RawMom().E() + iJet->NeutralHadronEnergy()/iJet->RawMom().E());
147    lVec.SetPt(lPt); lVec.SetEta(iJet->Eta()); lVec.SetPhi(iJet->Phi()); lVec.SetM(iJet->Mass());
148    if(iSign > 0) iVec -= lVec;
149    if(iSign < 0) iVec += lVec;
150 <  iSumEt += lPt;
150 >  //iSumEt += lPt;
151    //=== Above was a bug in the training
152 <  //if(iSign > 0) iSumEt += lPt;
153 <  //if(iSign < 0) iSumEt -= lPt;
152 >  if(iSign > 0) iSumEt += lPt;
153 >  if(iSign < 0) iSumEt -= lPt;
154   }
155  
156   //--------------------------------------------------------------------------------------------------
# Line 94 | Line 158 | void RecoilTools::addNeut(const PFJet *i
158   void RecoilTools::addNeut(const PFJet *iJet,FourVectorM &iVec,Double_t &iSumEt,double iRho,int iSign) {
159    FourVectorM lVec(0,0,0,0);
160    double lPt = iJet->Pt();
161 <  if(iJet->RawMom().Pt() < 10) lPt = TMath::Max(iJet->RawMom().Pt()-iJet->JetArea()*iRho,0.);//to be fixed
161 >  //if(iJet->RawMom().Pt() < 10) lPt = TMath::Max(iJet->RawMom().Pt()-iJet->JetArea()*iRho,0.);//to be fixed
162    //if(iJet->RawMom().Pt() < 10) lPt = iJet->RawMom().Pt()*iJet->L1OffsetCorrectionScale();
163    lPt *= (iJet->NeutralEmEnergy()/iJet->RawMom().E() + iJet->NeutralHadronEnergy()/iJet->RawMom().E());
164    lVec.SetPt(lPt); lVec.SetEta(iJet->Eta()); lVec.SetPhi(iJet->Phi()); lVec.SetM(iJet->Mass());
165    if(iSign > 0) iVec   -= lVec;
166    if(iSign < 0) iVec   += lVec;
167 <  iSumEt += lPt;
167 >  //iSumEt += lPt;
168    //=== Above was a bug in the training
169 <  //if(iSign > 0) iSumEt += lPt;
170 <  //if(iSign < 0) iSumEt -= lPt;
169 >  if(iSign > 0) iSumEt += lPt;
170 >  if(iSign < 0) iSumEt -= lPt;
171   }
172  
173   //--------------------------------------------------------------------------------------------------
# Line 118 | Line 182 | Met RecoilTools::NoPUMet( const PFJetCol
182      const Track* pTrack = pPF->TrackerTrk();
183      if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
184      if(pTrack        ==  0                           ) continue;
185 <     lSumEt   += pPF->Pt();  //=> another bug
122 <     if(         !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
185 >    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
186             (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
187 +    lSumEt   += pPF->Pt();  
188      lVec     -= pPF->Mom();
189    }
190    int lNPass = 0;
191    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
192      const PFJet *pJet = iJets->At(i0);
193 <    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue; //Quick cleaning==> if not done already
194 <    double lPt = fJetIDMVA->correctedPt(pJet,iJetCorrector,iPileupEnergyDensity);
195 <    //if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity))
132 <    //  std::cout << " =====> Jet Passes Id : " << lPt << " -- " << pJet->Eta() << " --- " << fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity) << std::endl;
133 <    //if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity))
134 <    //  std::cout << " =====> Jet Fails  Id :  " << lPt << " -- " << pJet->Eta() << " --- " << fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity) << std::endl;
193 >    if(!JetTools::passPFLooseId(pJet))                                              continue;
194 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue;
195 >    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                 continue;
196      if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
197      addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
198      lNPass++;
# Line 140 | Line 201 | Met RecoilTools::NoPUMet( const PFJetCol
201    lMet.SetSumEt( lSumEt);
202    return lMet;
203   }
204 < //--------------------------------------------------------------------------------------------------
204 > //-------------------------------------------------------------------------------------------------
205   //Corrected Jets
206   Met RecoilTools::NoPUMet( const PFJetCol       *iJets,
207                            const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,Double_t iRho,
# Line 152 | Line 213 | Met RecoilTools::NoPUMet( const PFJetCol
213      const Track* pTrack = pPF->TrackerTrk();
214      if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
215      if(pTrack        ==  0                           ) continue;
155 –    lSumEt   += pPF->Pt();  //=> another bug
216      if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
217             (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
218      lVec     -= pPF->Mom();
219 +    lSumEt   += pPF->Pt();  
220    }
221    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
222      const PFJet *pJet = iJets->At(i0);
223 <    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                             continue; //Quick cleaning==> if not done already
224 <    //if(fJetIDMVA->pass(pJet,iVertex,iVertices))
164 <    //  std::cout << " =====> Jet Passes Id : " << pJet->Pt() << " -- " << pJet->Eta() << " --- " << fJetIDMVA->pass(pJet,iVertex,iVertices) << std::endl;
165 <    //if(!fJetIDMVA->pass(pJet,iVertex,iVertices))
166 <    //  std::cout << " =====> Jet Fails  Id :  " << pJet->Pt() << " -- " << pJet->Eta() << " --- " << fJetIDMVA->pass(pJet,iVertex,iVertices) << std::endl;
223 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                             continue;
224 >    if(!fJetIDMVA->passPt(pJet))                                           continue;
225      if(!fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
226      addNeut(pJet,lVec,lSumEt,iRho);
227    }
# Line 172 | Line 230 | Met RecoilTools::NoPUMet( const PFJetCol
230    return lMet;
231   }
232   //--------------------------------------------------------------------------------------------------
233 + Met RecoilTools::NoPURecoil(Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
234 +                            const PFJetCol            *iJets,
235 +                            const PFCandidateCol   *iCands   ,
236 +                            const Vertex *iVertex,const VertexCol *iVertices,
237 +                            FactorizedJetCorrector *iJetCorrector,
238 +                            const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
239 +
240 +  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
241 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
242 +    const PFCandidate *pPF = iCands->At(i0);
243 +    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;
244 +    const Track* pTrack = pPF->TrackerTrk();
245 +    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
246 +    if(pTrack        ==  0                           ) continue;
247 +    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
248 +           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
249 +    lSumEt   += pPF->Pt();  
250 +    lVec     -= pPF->Mom();
251 +  }
252 +  int lNPass = 0;
253 +  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
254 +    const PFJet *pJet = iJets->At(i0);
255 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue;
256 +    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                continue;
257 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
258 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) if(!fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
259 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
260 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) addNeut(pJet,lVec,lSumEt,1.);
261 +    lNPass++;
262 +  }
263 +  Met lMet(lVec.Px(),lVec.Py());
264 +  lMet.SetSumEt( lSumEt);
265 +  return lMet;
266 + }
267 +
268 + //--------------------------------------------------------------------------------------------------
269   Met RecoilTools::NoPURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
270                              const PFJetCol            *iJets,FactorizedJetCorrector *iJetCorrector,
271                              const PileupEnergyDensityCol *iPileupEnergyDensity,
# Line 228 | Line 322 | Met RecoilTools::PUCMet( const PFJetCol
322    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
323      const PFJet *pJet = iJets->At(i0);
324      if(!JetTools::passPFLooseId(pJet))                                             continue;
325 +    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                continue;
326      if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
327 <    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning==> if not done already
327 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue;
328      addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity,-1);
329    }
330    Met lMet(lVec.Px(),lVec.Py());
# Line 263 | Line 358 | Met RecoilTools::PUCMet( const PFJetCol
358    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
359      const PFJet *pJet = iJets->At(i0);
360      if(!JetTools::passPFLooseId(pJet))                                   continue;
361 +    if(!fJetIDMVA->passPt(pJet))                                         continue;
362      if(fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
363      if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                            continue; //Quick cleaning==> if not done already
364      addNeut(pJet,lVec,lSumEt,iRho,-1);
# Line 271 | Line 367 | Met RecoilTools::PUCMet( const PFJetCol
367    lMet.SetSumEt(lSumEt);
368    return lMet;
369   }
370 + //--------------------------------------------------------------------------------------------------
371 + Met RecoilTools::PUCRecoil( Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
372 +                            const PFJetCol            *iJets,
373 +                            const PFCandidateCol   *iCands   ,
374 +                            const Vertex *iVertex,const VertexCol *iVertices,
375 +                            FactorizedJetCorrector *iJetCorrector,
376 +                           const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
377 +
378 +  
379 +  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
380 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
381 +    const PFCandidate *pPF = iCands->At(i0);
382 +    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;    
383 +    const Track* pTrack = pPF->TrackerTrk();
384 +    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
385 +    if(pTrack == 0                                   &&
386 +       (pPF->PFType() == PFCandidate::eGamma         ||
387 +        pPF->PFType() == PFCandidate::eEGammaHF      ||
388 +        pPF->PFType() == PFCandidate::eNeutralHadron ||
389 +        pPF->PFType() == PFCandidate::eHadronHF      ))
390 +      {lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
391 +    if(pTrack        ==  0                           ) continue;
392 +    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
393 +           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
394 +    lVec     -= pPF->Mom();
395 +    lSumEt   += pPF->Pt();
396 +  }
397 +  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
398 +    const PFJet *pJet = iJets->At(i0);
399 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning==> if not done already
400 +    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                continue;
401 +    if(!JetTools::passPFLooseId(pJet))                                             continue;
402 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
403 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) if(fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
404 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity,-1);
405 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) addNeut(pJet,lVec,lSumEt,1,-1);
406 +  }
407 +  Met lMet(lVec.Px(),lVec.Py());
408 +  lMet.SetSumEt(lSumEt);
409 +  return lMet;
410 + }
411   //----> This MET is a bug need to fix it
412   //--------------------------------------------------------------------------------------------------
413   Met RecoilTools::PUCRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
# Line 322 | Line 459 | Met RecoilTools::PUMet( const PFJetCol
459    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
460      const PFJet *pJet = iJets->At(i0);
461      if(!JetTools::passPFLooseId(pJet))                                             continue;
462 <    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning
462 >    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                continue;
463 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue;    
464      if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
465      addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
466    }
# Line 351 | Line 489 | Met RecoilTools::PUMet( const PFJetCol
489    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
490      const PFJet *pJet = iJets->At(i0);
491      if(!JetTools::passPFLooseId(pJet))                                   continue;
492 +    if(!fJetIDMVA->passPt(pJet))                                         continue;
493      if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                            continue; //Quick cleaning
494      if(fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
495      addNeut(pJet,lVec,lSumEt,iRho);
496    }
497    Met lMet(lVec.Px(),lVec.Py());
498    lMet.SetSumEt(lSumEt);
499 +  return lMet;
500 + }
501 + //--------------------------------------------------------------------------------------------------
502 + Met RecoilTools::PUMet( Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
503 +                        const PFJetCol            *iJets,
504 +                        const PFCandidateCol   *iCands   ,
505 +                        const Vertex *iVertex,const VertexCol *iVertices,
506 +                        FactorizedJetCorrector *iJetCorrector,
507 +                        const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
508 +  
509 +  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
510 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
511 +    const PFCandidate *pPF = iCands->At(i0);
512 +    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;    
513 +    const Track* pTrack = pPF->TrackerTrk();
514 +    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
515 +    if(pTrack        ==  0                           ) continue;
516 +    if(   ((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
517 +           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
518 +    lVec     -= pPF->Mom();
519 +    lSumEt   += pPF->Pt();
520 +  }
521 +  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
522 +    const PFJet *pJet = iJets->At(i0);
523 +    if(!JetTools::passPFLooseId(pJet))                                             continue;
524 +    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                continue;
525 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning
526 +    if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
527 +    addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
528 +  }
529 +  Met lMet(lVec.Px(),lVec.Py());
530 +  lMet.SetSumEt(lSumEt);
531    return lMet;
532   }
533   //--------------------------------------------------------------------------------------------------

Diff Legend

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