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.22 by pharris, Thu Aug 9 13:15:43 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 115 | Line 179 | Met RecoilTools::NoPUMet( const PFJetCol
179    FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
180    for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
181      const PFCandidate *pPF = iCands->At(i0);
182 <    const Track* pTrack = pPF->TrackerTrk();
183 <    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
184 <    if(pTrack        ==  0                           ) continue;
185 <     lSumEt   += pPF->Pt();  //=> another bug
186 <     if(         !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
123 <           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
182 >    double lDZ = 999;
183 >    if(pPF->HasTrackerTrk())  lDZ =  fabs(pPF->TrackerTrk()->DzCorrected(*iVertex));//
184 >    else if(pPF->HasGsfTrk()) lDZ =  fabs(pPF->GsfTrk()    ->DzCorrected(*iVertex));
185 >    if( fabs(lDZ) > iDZCut) continue;
186 >    lSumEt   += pPF->Pt();  
187      lVec     -= pPF->Mom();
188    }
189    int lNPass = 0;
190    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
191      const PFJet *pJet = iJets->At(i0);
192 <    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue; //Quick cleaning==> if not done already
193 <    double lPt = fJetIDMVA->correctedPt(pJet,iJetCorrector,iPileupEnergyDensity);
194 <    //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;
192 >    if(!JetTools::passPFLooseId(pJet))                                              continue;
193 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue;
194 >    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                 continue;
195      if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
196 +    double pDPhi1 = fabs(pJet->Phi() - iPhi1); if(pDPhi1 > 2.*TMath::Pi()-pDPhi1) pDPhi1 = 2.*TMath::Pi()-pDPhi1;
197 +    double pDPhi2 = fabs(pJet->Phi() - iPhi2); if(pDPhi2 > 2.*TMath::Pi()-pDPhi2) pDPhi2 = 2.*TMath::Pi()-pDPhi2;
198      addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
199      lNPass++;
200    }
# Line 140 | Line 202 | Met RecoilTools::NoPUMet( const PFJetCol
202    lMet.SetSumEt( lSumEt);
203    return lMet;
204   }
205 < //--------------------------------------------------------------------------------------------------
205 > //-------------------------------------------------------------------------------------------------
206   //Corrected Jets
207   Met RecoilTools::NoPUMet( const PFJetCol       *iJets,
208                            const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,Double_t iRho,
# Line 149 | Line 211 | Met RecoilTools::NoPUMet( const PFJetCol
211    FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
212    for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
213      const PFCandidate *pPF = iCands->At(i0);
214 <    const Track* pTrack = pPF->TrackerTrk();
215 <    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
216 <    if(pTrack        ==  0                           ) continue;
217 <    lSumEt   += pPF->Pt();  //=> another bug
156 <    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
157 <           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
214 >    double lDZ = 999;
215 >    if(pPF->HasTrackerTrk())  lDZ =  fabs(pPF->TrackerTrk()->DzCorrected(*iVertex));//
216 >    else if(pPF->HasGsfTrk()) lDZ =  fabs(pPF->GsfTrk()    ->DzCorrected(*iVertex));
217 >    if( fabs(lDZ) > 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 +    double lDZ = 999;
245 +    if(pPF->HasTrackerTrk())  lDZ =  fabs(pPF->TrackerTrk()->DzCorrected(*iVertex));//
246 +    else if(pPF->HasGsfTrk()) lDZ =  fabs(pPF->GsfTrk()    ->DzCorrected(*iVertex));
247 +    if( fabs(lDZ) > iDZCut) continue;
248 +    lSumEt   += pPF->Pt();  
249 +    lVec     -= pPF->Mom();
250 +  }
251 +  int lNPass = 0;
252 +  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
253 +    const PFJet *pJet = iJets->At(i0);
254 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue;
255 +    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                continue;
256 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
257 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) if(!fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
258 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
259 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) addNeut(pJet,lVec,lSumEt,1.);
260 +    lNPass++;
261 +  }
262 +  Met lMet(lVec.Px(),lVec.Py());
263 +  lMet.SetSumEt( lSumEt);
264 +  return lMet;
265 + }
266 +
267 + //--------------------------------------------------------------------------------------------------
268   Met RecoilTools::NoPURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
269                              const PFJetCol            *iJets,FactorizedJetCorrector *iJetCorrector,
270                              const PileupEnergyDensityCol *iPileupEnergyDensity,
# Line 220 | Line 313 | Met RecoilTools::PUCMet( const PFJetCol
313          pPF->PFType() == PFCandidate::eHadronHF      ))
314        {lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
315      if(pTrack        ==  0                           ) continue;
316 <    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
317 <           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
316 >    double lDZ = 999;
317 >    if(pPF->HasTrackerTrk())  lDZ =  fabs(pPF->TrackerTrk()->DzCorrected(*iVertex));//
318 >    else if(pPF->HasGsfTrk()) lDZ =  fabs(pPF->GsfTrk()    ->DzCorrected(*iVertex));
319 >    if( fabs(lDZ) > iDZCut) continue;
320      lVec     -= pPF->Mom();
321      lSumEt   += pPF->Pt();
322    }
323    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
324      const PFJet *pJet = iJets->At(i0);
325      if(!JetTools::passPFLooseId(pJet))                                             continue;
326 +    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                continue;
327      if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
328 <    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning==> if not done already
328 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue;
329      addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity,-1);
330    }
331    Met lMet(lVec.Px(),lVec.Py());
# Line 255 | Line 351 | Met RecoilTools::PUCMet( const PFJetCol
351          pPF->PFType() == PFCandidate::eHadronHF      ))
352        {lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
353      if(pTrack        ==  0                           ) continue;
354 <    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
355 <           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
354 >    double lDZ = 999;
355 >    if(pPF->HasTrackerTrk())  lDZ =  fabs(pPF->TrackerTrk()->DzCorrected(*iVertex));//
356 >    else if(pPF->HasGsfTrk()) lDZ =  fabs(pPF->GsfTrk()    ->DzCorrected(*iVertex));
357 >    if( fabs(lDZ) > iDZCut) continue;
358      lVec     -= pPF->Mom();
359      lSumEt   += pPF->Pt();
360    }
361    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
362      const PFJet *pJet = iJets->At(i0);
363      if(!JetTools::passPFLooseId(pJet))                                   continue;
364 +    if(!fJetIDMVA->passPt(pJet))                                         continue;
365      if(fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
366      if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                            continue; //Quick cleaning==> if not done already
367      addNeut(pJet,lVec,lSumEt,iRho,-1);
# Line 271 | Line 370 | Met RecoilTools::PUCMet( const PFJetCol
370    lMet.SetSumEt(lSumEt);
371    return lMet;
372   }
373 + //--------------------------------------------------------------------------------------------------
374 + Met RecoilTools::PUCRecoil( Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
375 +                            const PFJetCol            *iJets,
376 +                            const PFCandidateCol   *iCands   ,
377 +                            const Vertex *iVertex,const VertexCol *iVertices,
378 +                            FactorizedJetCorrector *iJetCorrector,
379 +                           const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
380 +
381 +  
382 +  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
383 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
384 +    const PFCandidate *pPF = iCands->At(i0);
385 +    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;    
386 +    const Track* pTrack = pPF->TrackerTrk();
387 +    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
388 +    if(pTrack == 0                                   &&
389 +       (pPF->PFType() == PFCandidate::eGamma         ||
390 +        pPF->PFType() == PFCandidate::eEGammaHF      ||
391 +        pPF->PFType() == PFCandidate::eNeutralHadron ||
392 +        pPF->PFType() == PFCandidate::eHadronHF      ))
393 +      {lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
394 +    if(pTrack        ==  0                           ) continue;
395 +    double lDZ = 999;
396 +    if(pPF->HasTrackerTrk())  lDZ =  fabs(pPF->TrackerTrk()->DzCorrected(*iVertex));//
397 +    else if(pPF->HasGsfTrk()) lDZ =  fabs(pPF->GsfTrk()    ->DzCorrected(*iVertex));
398 +    if( fabs(lDZ) > iDZCut) continue;
399 +    lVec     -= pPF->Mom();
400 +    lSumEt   += pPF->Pt();
401 +  }
402 +  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
403 +    const PFJet *pJet = iJets->At(i0);
404 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning==> if not done already
405 +    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                continue;
406 +    if(!JetTools::passPFLooseId(pJet))                                             continue;
407 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
408 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) if(fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
409 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity,-1);
410 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) addNeut(pJet,lVec,lSumEt,1,-1);
411 +  }
412 +  Met lMet(lVec.Px(),lVec.Py());
413 +  lMet.SetSumEt(lSumEt);
414 +  return lMet;
415 + }
416   //----> This MET is a bug need to fix it
417   //--------------------------------------------------------------------------------------------------
418   Met RecoilTools::PUCRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
# Line 314 | Line 456 | Met RecoilTools::PUMet( const PFJetCol
456      const Track* pTrack = pPF->TrackerTrk();
457      if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
458      if(pTrack        ==  0                           ) continue;
459 <    if(   ((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
460 <           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
459 >    double lDZ = 999;
460 >    if(pPF->HasTrackerTrk())  lDZ =  fabs(pPF->TrackerTrk()->DzCorrected(*iVertex));//
461 >    else if(pPF->HasGsfTrk()) lDZ =  fabs(pPF->GsfTrk()    ->DzCorrected(*iVertex));
462 >    if( fabs(lDZ) < iDZCut) continue;
463      lVec     -= pPF->Mom();
464      lSumEt   += pPF->Pt();
465    }
466    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
467      const PFJet *pJet = iJets->At(i0);
468      if(!JetTools::passPFLooseId(pJet))                                             continue;
469 <    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning
469 >    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                continue;
470 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue;    
471      if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
472      addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
473    }
# Line 343 | Line 488 | Met RecoilTools::PUMet( const PFJetCol
488      const Track* pTrack = pPF->TrackerTrk();
489      if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
490      if(pTrack        ==  0                           ) continue;
491 <    if(   ((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
492 <           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
491 >    double lDZ = 999;
492 >    if(pPF->HasTrackerTrk())  lDZ =  fabs(pPF->TrackerTrk()->DzCorrected(*iVertex));//
493 >    else if(pPF->HasGsfTrk()) lDZ =  fabs(pPF->GsfTrk()    ->DzCorrected(*iVertex));
494 >    if( fabs(lDZ) < iDZCut) continue;
495      lVec     -= pPF->Mom();
496      lSumEt   += pPF->Pt();
497    }
498    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
499      const PFJet *pJet = iJets->At(i0);
500      if(!JetTools::passPFLooseId(pJet))                                   continue;
501 +    if(!fJetIDMVA->passPt(pJet))                                         continue;
502      if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                            continue; //Quick cleaning
503      if(fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
504      addNeut(pJet,lVec,lSumEt,iRho);
505    }
506    Met lMet(lVec.Px(),lVec.Py());
507    lMet.SetSumEt(lSumEt);
508 +  return lMet;
509 + }
510 + //--------------------------------------------------------------------------------------------------
511 + Met RecoilTools::PUMet( Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
512 +                        const PFJetCol            *iJets,
513 +                        const PFCandidateCol   *iCands   ,
514 +                        const Vertex *iVertex,const VertexCol *iVertices,
515 +                        FactorizedJetCorrector *iJetCorrector,
516 +                        const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
517 +  
518 +  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
519 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
520 +    const PFCandidate *pPF = iCands->At(i0);
521 +    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;    
522 +    const Track* pTrack = pPF->TrackerTrk();
523 +    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
524 +    if(pTrack        ==  0                           ) continue;
525 +    double lDZ = 999;
526 +    if(pPF->HasTrackerTrk())  lDZ =  fabs(pPF->TrackerTrk()->DzCorrected(*iVertex));//
527 +    else if(pPF->HasGsfTrk()) lDZ =  fabs(pPF->GsfTrk()    ->DzCorrected(*iVertex));
528 +    if( fabs(lDZ) < iDZCut) continue;
529 +    lVec     -= pPF->Mom();
530 +    lSumEt   += pPF->Pt();
531 +  }
532 +  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
533 +    const PFJet *pJet = iJets->At(i0);
534 +    if(!JetTools::passPFLooseId(pJet))                                             continue;
535 +    if(!fJetIDMVA->passPt(pJet,iJetCorrector,iPileupEnergyDensity))                continue;
536 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning
537 +    if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
538 +    addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
539 +  }
540 +  Met lMet(lVec.Px(),lVec.Py());
541 +  lMet.SetSumEt(lSumEt);
542    return lMet;
543   }
544   //--------------------------------------------------------------------------------------------------

Diff Legend

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