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.1 by pharris, Wed Mar 21 18:56:26 2012 UTC vs.
Revision 1.17 by pharris, Fri May 25 14:10:22 2012 UTC

# Line 6 | Line 6 | ClassImp(mithep::RecoilTools)
6  
7   using namespace mithep;
8  
9 < RecoilTools::RecoilTools(TString iJetMVAFile) {
9 > RecoilTools::RecoilTools(TString iJetLowPtMVAFile,TString iJetHighPtMVAFile,TString iCutFile) {
10    fJetIDMVA = new JetIDMVA();
11 <  fJetIDMVA->Initialize( "JetIDMVA",iJetMVAFile,JetIDMVA::kBaseline);
11 >  fJetIDMVA->Initialize( JetIDMVA::kMET,iJetLowPtMVAFile,iJetHighPtMVAFile,JetIDMVA::kBaseline,iCutFile);
12   }
13   //--------------------------------------------------------------------------------------------------
14   RecoilTools::~RecoilTools() {
# 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 +    const PFCandidate *pfcand = iCands->At(i0);
64 +    if(!filter(pfcand,iPhi1,iEta1,iPhi2,iEta2)) continue;
65 +    lVec   -= pfcand->Mom();
66 +    lSumEt += pfcand->Et();
67 +  }
68 +  Met lPFMet(lVec.Px(),lVec.Py());
69 +  lPFMet.SetSumEt(lSumEt);
70 +  return lPFMet;
71 + }
72 + //--------------------------------------------------------------------------------------------------
73   Met RecoilTools::trackMet(const PFCandidateCol *iCands,const Vertex *iVertex,Double_t iDZCut) {
74    double trkMetx  = 0;
75    double trkMety  = 0;
76    double trkSumEt = 0;
77 <  for(UInt_t i=0; i<iCands->GetEntries(); ++i) {
78 <    const PFCandidate *pfcand = iCands->At(i);
77 >  for(UInt_t i0=0; i0<iCands->GetEntries(); i0++) {
78 >    const PFCandidate *pfcand = iCands->At(i0);
79      if( (pfcand->HasTrackerTrk() && (fabs(pfcand->TrackerTrk()->DzCorrected(*iVertex))< iDZCut)) ||
80 <        (pfcand->HasGsfTrk()     && (fabs(pfcand->GsfTrk()->DzCorrected(*iVertex))    < iDZCut)) ) {
80 >        (pfcand->HasGsfTrk()     && (fabs(pfcand->GsfTrk()->DzCorrected(*iVertex))    < iDZCut)) ) {
81 >      trkMetx  -= pfcand->Px();
82 >      trkMety  -= pfcand->Py();
83 >      trkSumEt += pfcand->Pt();
84 >    }
85 >  }
86 >  Met lMet(trkMetx,trkMety);
87 >  lMet.SetSumEt(trkSumEt);
88 >  return lMet;
89 > }
90 > //--------------------------------------------------------------------------------------------------
91 > Met RecoilTools::trackRecoil(double iPhi1,double iEta1,double iPhi2,double iEta2,const PFCandidateCol *iCands,const Vertex *iVertex,Double_t iDZCut) {
92 >  double trkMetx  = 0;
93 >  double trkMety  = 0;
94 >  double trkSumEt = 0;
95 >  for(UInt_t i0=0; i0<iCands->GetEntries(); i0++) {
96 >    const PFCandidate *pfcand = iCands->At(i0);
97 >    if(!filter(pfcand,iPhi1,iEta1,iPhi2,iEta2)) continue;
98 >    if( (pfcand->HasTrackerTrk() && (fabs(pfcand->TrackerTrk()->DzCorrected(*iVertex))< iDZCut)) ||
99 >        (pfcand->HasGsfTrk()     && (fabs(pfcand->GsfTrk()->DzCorrected(*iVertex))    < iDZCut)) ) {
100        trkMetx  -= pfcand->Px();
101        trkMety  -= pfcand->Py();
102        trkSumEt += pfcand->Pt();
# Line 55 | Line 106 | Met RecoilTools::trackMet(const PFCandid
106    lMet.SetSumEt(trkSumEt);
107    return lMet;
108   }
58 –
109   //--------------------------------------------------------------------------------------------------
110   //Compute the recoil => here this requires the vector sum of the visible components
111   //VisPt    => Vector sum pT  of the visible non-recoiling components
# Line 75 | Line 125 | void RecoilTools::addNeut(const PFJet *i
125                            int iSign) {
126    FourVectorM lVec(0,0,0,0);
127    double lPt = fJetIDMVA->correctedPt(iJet,iJetCorrector,iPUEnergyDensity);
128 <  lPt *= (iJet->NeutralEmEnergy()/iJet->E() + iJet->NeutralHadronEnergy()/iJet->E());
128 >  //if(iJet->RawMom().Pt() < 10) lPt = TMath::Max(iJet->RawMom().Pt()-iJet->JetArea()*iPUEnergyDensity->At(0)->Rho(),0.);
129 >  lPt *= (iJet->NeutralEmEnergy()/iJet->RawMom().E() + iJet->NeutralHadronEnergy()/iJet->RawMom().E());
130    lVec.SetPt(lPt); lVec.SetEta(iJet->Eta()); lVec.SetPhi(iJet->Phi()); lVec.SetM(iJet->Mass());
131    if(iSign > 0) iVec -= lVec;
132    if(iSign < 0) iVec += lVec;
133 <  iSumEt += lPt;
133 >  //iSumEt += lPt;
134 >  //=== Above was a bug in the training
135 >  if(iSign > 0) iSumEt += lPt;
136 >  if(iSign < 0) iSumEt -= lPt;
137   }
138 +
139 + //--------------------------------------------------------------------------------------------------
140 + //Corrected Jets
141 + void RecoilTools::addNeut(const PFJet *iJet,FourVectorM &iVec,Double_t &iSumEt,double iRho,int iSign) {
142 +  FourVectorM lVec(0,0,0,0);
143 +  double lPt = iJet->Pt();
144 +  //if(iJet->RawMom().Pt() < 10) lPt = TMath::Max(iJet->RawMom().Pt()-iJet->JetArea()*iRho,0.);//to be fixed
145 +  //if(iJet->RawMom().Pt() < 10) lPt = iJet->RawMom().Pt()*iJet->L1OffsetCorrectionScale();
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;
151 +  //=== Above was a bug in the training
152 +  if(iSign > 0) iSumEt += lPt;
153 +  if(iSign < 0) iSumEt -= lPt;
154 + }
155 +
156   //--------------------------------------------------------------------------------------------------
157   Met RecoilTools::NoPUMet( const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
158                            const PileupEnergyDensityCol *iPileupEnergyDensity,
159 <                          const PFCandidateCol *iCands,const Vertex *iVertex,
159 >                          const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,
160                            Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,Double_t iDZCut) {
161  
162    FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
# Line 95 | Line 167 | Met RecoilTools::NoPUMet( const PFJetCol
167      if(pTrack        ==  0                           ) continue;
168      if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
169             (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
170 +    lSumEt   += pPF->Pt();  
171      lVec     -= pPF->Mom();
99 –    lSumEt   += pPF->Pt();
172    }
173 +  int lNPass = 0;
174    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
175      const PFJet *pJet = iJets->At(i0);
176 <    if(!fJetIDMVA->pass(pJet,iVertex,iJetCorrector,iPileupEnergyDensity)) continue;
177 <    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                             continue; //Quick cleaning==> if not done already
176 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue;
177 >    if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
178      addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
179 +    lNPass++;
180 +  }
181 +  Met lMet(lVec.Px(),lVec.Py());
182 +  lMet.SetSumEt( lSumEt);
183 +  return lMet;
184 + }
185 + //-------------------------------------------------------------------------------------------------
186 + //Corrected Jets
187 + Met RecoilTools::NoPUMet( const PFJetCol       *iJets,
188 +                          const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,Double_t iRho,
189 +                          Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,Double_t iDZCut) {
190 +
191 +  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
192 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
193 +    const PFCandidate *pPF = iCands->At(i0);
194 +    const Track* pTrack = pPF->TrackerTrk();
195 +    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
196 +    if(pTrack        ==  0                           ) continue;
197 +    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
198 +           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
199 +    lVec     -= pPF->Mom();
200 +    lSumEt   += pPF->Pt();  
201 +  }
202 +  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
203 +    const PFJet *pJet = iJets->At(i0);
204 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                             continue;
205 +    if(!fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
206 +    addNeut(pJet,lVec,lSumEt,iRho);
207    }
208    Met lMet(lVec.Px(),lVec.Py());
209    lMet.SetSumEt(lSumEt);
210    return lMet;
211   }
212   //--------------------------------------------------------------------------------------------------
213 + Met RecoilTools::NoPURecoil(Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
214 +                            const PFJetCol            *iJets,
215 +                            const PFCandidateCol   *iCands   ,
216 +                            const Vertex *iVertex,const VertexCol *iVertices,
217 +                            FactorizedJetCorrector *iJetCorrector,
218 +                            const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
219 +
220 +  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
221 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
222 +    const PFCandidate *pPF = iCands->At(i0);
223 +    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;
224 +    const Track* pTrack = pPF->TrackerTrk();
225 +    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
226 +    if(pTrack        ==  0                           ) continue;
227 +    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
228 +           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
229 +    lSumEt   += pPF->Pt();  
230 +    lVec     -= pPF->Mom();
231 +  }
232 +  int lNPass = 0;
233 +  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
234 +    const PFJet *pJet = iJets->At(i0);
235 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue;
236 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
237 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) if(!fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
238 +    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
239 +    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) addNeut(pJet,lVec,lSumEt,1.);
240 +    lNPass++;
241 +  }
242 +  Met lMet(lVec.Px(),lVec.Py());
243 +  lMet.SetSumEt( lSumEt);
244 +  return lMet;
245 + }
246 +
247 + //--------------------------------------------------------------------------------------------------
248   Met RecoilTools::NoPURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
249 <                            const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
249 >                            const PFJetCol            *iJets,FactorizedJetCorrector *iJetCorrector,
250                              const PileupEnergyDensityCol *iPileupEnergyDensity,
251 <                            const PFCandidateCol *iCands,const Vertex *iVertex,
251 >                            const PFCandidateCol   *iCands   ,const Vertex *iVertex,
252 >                            const VertexCol *iVertices,
253                              Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
254                              Double_t iDZCut) {
255    
256 <  Met lNoPUMet = NoPUMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
256 >  Met lNoPUMet = NoPUMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
257 >  lNoPUMet.SetMex  (lNoPUMet.Mex()+iVisPt*cos(iVisPhi));  
258 >  lNoPUMet.SetMey  (lNoPUMet.Mey()+iVisPt*sin(iVisPhi));
259 >  lNoPUMet.SetSumEt(lNoPUMet.SumEt()-iVisSumEt);
260 >  return lNoPUMet;
261 > }
262 > //--------------------------------------------------------------------------------------------------
263 > //Corrected Jets
264 > Met RecoilTools::NoPURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
265 >                            const PFJetCol       *iJets,const PFCandidateCol *iCands,
266 >                            const Vertex *iVertex,const VertexCol            *iVertices,Double_t iRho,
267 >                            Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
268 >                            Double_t iDZCut) {
269 >  
270 >  Met lNoPUMet = NoPUMet(iJets,iCands,iVertex,iVertices,iRho,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
271    lNoPUMet.SetMex  (lNoPUMet.Mex()+iVisPt*cos(iVisPhi));  
272    lNoPUMet.SetMey  (lNoPUMet.Mey()+iVisPt*sin(iVisPhi));
273    lNoPUMet.SetSumEt(lNoPUMet.SumEt()-iVisSumEt);
# Line 125 | Line 276 | Met RecoilTools::NoPURecoil(Double_t iVi
276   //--------------------------------------------------------------------------------------------------
277   Met RecoilTools::PUCMet( const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
278                           const PileupEnergyDensityCol *iPileupEnergyDensity,
279 <                         const PFCandidateCol *iCands,const Vertex *iVertex,
279 >                         const PFCandidateCol *iCands,
280 >                         const Vertex *iVertex,const VertexCol *iVertices,
281 >                         Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
282 >                         Double_t iDZCut) {
283 >
284 >  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
285 >  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
286 >    const PFCandidate *pPF = iCands->At(i0);
287 >    const Track* pTrack = pPF->TrackerTrk();
288 >    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
289 >    if(pTrack == 0                                   &&
290 >       (pPF->PFType() == PFCandidate::eGamma         ||
291 >        pPF->PFType() == PFCandidate::eEGammaHF      ||
292 >        pPF->PFType() == PFCandidate::eNeutralHadron ||
293 >        pPF->PFType() == PFCandidate::eHadronHF      ))
294 >      {lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
295 >    if(pTrack        ==  0                           ) continue;
296 >    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
297 >           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
298 >    lVec     -= pPF->Mom();
299 >    lSumEt   += pPF->Pt();
300 >  }
301 >  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
302 >    const PFJet *pJet = iJets->At(i0);
303 >    if(!JetTools::passPFLooseId(pJet))                                             continue;
304 >    if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
305 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning==> if not done already
306 >    addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity,-1);
307 >  }
308 >  Met lMet(lVec.Px(),lVec.Py());
309 >  lMet.SetSumEt(lSumEt);
310 >  return lMet;
311 > }
312 > //--------------------------------------------------------------------------------------------------
313 > //Corrected jets
314 > Met RecoilTools::PUCMet( const PFJetCol       *iJets,const PFCandidateCol *iCands,
315 >                         const Vertex *iVertex,const VertexCol *iVertices,Double_t iRho,
316                           Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
317                           Double_t iDZCut) {
318  
# Line 148 | Line 335 | Met RecoilTools::PUCMet( const PFJetCol
335    }
336    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
337      const PFJet *pJet = iJets->At(i0);
151 –    if(fJetIDMVA->correctedPt(pJet,iJetCorrector,iPileupEnergyDensity) < fJetIDMVA->fJetPtMin
152 –       && pJet->TrackCountingHighEffBJetTagsDisc() == -100)              continue; //This line is a bug in the Met training//
338      if(!JetTools::passPFLooseId(pJet))                                   continue;
339 <    if(fJetIDMVA->pass(pJet,iVertex,iJetCorrector,iPileupEnergyDensity)) continue;
339 >    if(fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
340      if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                            continue; //Quick cleaning==> if not done already
341 <    addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity,-1);
341 >    addNeut(pJet,lVec,lSumEt,iRho,-1);
342 >  }
343 >  Met lMet(lVec.Px(),lVec.Py());
344 >  lMet.SetSumEt(lSumEt);
345 >  return lMet;
346 > }
347 > //--------------------------------------------------------------------------------------------------
348 > Met RecoilTools::PUCRecoil( Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
349 >                            const PFJetCol            *iJets,
350 >                            const PFCandidateCol   *iCands   ,
351 >                            const Vertex *iVertex,const VertexCol *iVertices,
352 >                            FactorizedJetCorrector *iJetCorrector,
353 >                           const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
354 >
355 >  
356 >  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
357 >  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
358 >    const PFCandidate *pPF = iCands->At(i0);
359 >    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;    
360 >    const Track* pTrack = pPF->TrackerTrk();
361 >    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
362 >    if(pTrack == 0                                   &&
363 >       (pPF->PFType() == PFCandidate::eGamma         ||
364 >        pPF->PFType() == PFCandidate::eEGammaHF      ||
365 >        pPF->PFType() == PFCandidate::eNeutralHadron ||
366 >        pPF->PFType() == PFCandidate::eHadronHF      ))
367 >      {lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
368 >    if(pTrack        ==  0                           ) continue;
369 >    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
370 >           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
371 >    lVec     -= pPF->Mom();
372 >    lSumEt   += pPF->Pt();
373 >  }
374 >  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
375 >    const PFJet *pJet = iJets->At(i0);
376 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning==> if not done already
377 >    if(!JetTools::passPFLooseId(pJet))                                             continue;
378 >    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
379 >    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) if(fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
380 >    if(iJetCorrector != 0 && iPileupEnergyDensity != 0) addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity,-1);
381 >    if(iJetCorrector == 0 || iPileupEnergyDensity == 0) addNeut(pJet,lVec,lSumEt,1,-1);
382    }
383    Met lMet(lVec.Px(),lVec.Py());
384    lMet.SetSumEt(lSumEt);
# Line 165 | Line 390 | Met RecoilTools::PUCRecoil(Double_t iVis
390                             const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
391                             const PileupEnergyDensityCol *iPileupEnergyDensity,
392                             const PFCandidateCol *iCands,const Vertex *iVertex,
393 +                           const VertexCol *iVertices,
394 +                           Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
395 +                           Double_t iDZCut) {
396 +  Met lPUCMet = PUCMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
397 +  lPUCMet.SetMex  (lPUCMet.Mex()+iVisPt*cos(iVisPhi));  
398 +  lPUCMet.SetMey  (lPUCMet.Mey()+iVisPt*sin(iVisPhi));
399 +  lPUCMet.SetSumEt(lPUCMet.SumEt()-iVisSumEt);
400 +  return lPUCMet;
401 + }
402 + //--------------------------------------------------------------------------------------------------
403 + //Corrected Jets
404 + Met RecoilTools::PUCRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
405 +                           const PFJetCol       *iJets,
406 +                           const PFCandidateCol *iCands,const Vertex *iVertex,
407 +                           const VertexCol *iVertices,Double_t iRho,
408                             Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
409                             Double_t iDZCut) {
410 <  Met lPUCMet = PUCMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
410 >  Met lPUCMet = PUCMet(iJets,iCands,iVertex,iVertices,iRho,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
411    lPUCMet.SetMex  (lPUCMet.Mex()+iVisPt*cos(iVisPhi));  
412    lPUCMet.SetMey  (lPUCMet.Mey()+iVisPt*sin(iVisPhi));
413    lPUCMet.SetSumEt(lPUCMet.SumEt()-iVisSumEt);
# Line 177 | Line 417 | Met RecoilTools::PUCRecoil(Double_t iVis
417   Met RecoilTools::PUMet( const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
418                          const PileupEnergyDensityCol *iPileupEnergyDensity,
419                          const PFCandidateCol *iCands,const Vertex *iVertex,
420 +                        const VertexCol      *iVertices,
421 +                        Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
422 +                        Double_t iDZCut) {
423 +
424 +  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
425 +  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
426 +    const PFCandidate *pPF = iCands->At(i0);
427 +    const Track* pTrack = pPF->TrackerTrk();
428 +    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
429 +    if(pTrack        ==  0                           ) continue;
430 +    if(   ((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
431 +           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
432 +    lVec     -= pPF->Mom();
433 +    lSumEt   += pPF->Pt();
434 +  }
435 +  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
436 +    const PFJet *pJet = iJets->At(i0);
437 +    if(!JetTools::passPFLooseId(pJet))                                             continue;
438 +    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning
439 +    if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
440 +    addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
441 +  }
442 +  Met lMet(lVec.Px(),lVec.Py());
443 +  lMet.SetSumEt(lSumEt);
444 +  return lMet;
445 + }
446 + //--------------------------------------------------------------------------------------------------
447 + //Corrected Jets
448 + Met RecoilTools::PUMet( const PFJetCol       *iJets,
449 +                        const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,Double_t iRho,
450                          Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
451                          Double_t iDZCut) {
452  
# Line 193 | Line 463 | Met RecoilTools::PUMet( const PFJetCol
463    }
464    for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
465      const PFJet *pJet = iJets->At(i0);
196 –    if(fJetIDMVA->correctedPt(pJet,iJetCorrector,iPileupEnergyDensity) < fJetIDMVA->fJetPtMin
197 –       && pJet->TrackCountingHighEffBJetTagsDisc() == -100)              continue; //This line is a bug in the Met training//
466      if(!JetTools::passPFLooseId(pJet))                                   continue;
467      if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                            continue; //Quick cleaning
468 <    if(fJetIDMVA->pass(pJet,iVertex,iJetCorrector,iPileupEnergyDensity)) continue;
468 >    if(fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
469 >    addNeut(pJet,lVec,lSumEt,iRho);
470 >  }
471 >  Met lMet(lVec.Px(),lVec.Py());
472 >  lMet.SetSumEt(lSumEt);
473 >  return lMet;
474 > }
475 > //--------------------------------------------------------------------------------------------------
476 > Met RecoilTools::PUMet( Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
477 >                        const PFJetCol            *iJets,
478 >                        const PFCandidateCol   *iCands   ,
479 >                        const Vertex *iVertex,const VertexCol *iVertices,
480 >                        FactorizedJetCorrector *iJetCorrector,
481 >                        const PileupEnergyDensityCol *iPileupEnergyDensity,Double_t iDZCut) {
482 >  
483 >  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0;
484 >  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
485 >    const PFCandidate *pPF = iCands->At(i0);
486 >    if(!filter(pPF,iPhi1,iEta1,iPhi2,iEta2)) continue;    
487 >    const Track* pTrack = pPF->TrackerTrk();
488 >    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
489 >    if(pTrack        ==  0                           ) continue;
490 >    if(   ((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
491 >           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue;
492 >    lVec     -= pPF->Mom();
493 >    lSumEt   += pPF->Pt();
494 >  }
495 >  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
496 >    const PFJet *pJet = iJets->At(i0);
497 >    if(!JetTools::passPFLooseId(pJet))                                             continue;
498 >    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning
499 >    if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
500      addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
501    }
502    Met lMet(lVec.Px(),lVec.Py());
# Line 209 | Line 508 | Met RecoilTools::PURecoil(Double_t iVisP
508                            const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
509                            const PileupEnergyDensityCol *iPileupEnergyDensity,
510                            const PFCandidateCol *iCands,const Vertex *iVertex,
511 +                          const VertexCol      *iVertices,
512 +                          Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
513 +                          Double_t iDZCut) {
514 +  Met lPUMet = PUMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
515 +  lPUMet.SetMex  (lPUMet.Mex()+iVisPt*cos(iVisPhi));  
516 +  lPUMet.SetMey  (lPUMet.Mey()+iVisPt*sin(iVisPhi));
517 +  lPUMet.SetSumEt(lPUMet.SumEt()-iVisSumEt);
518 +  return lPUMet;
519 + }
520 + //--------------------------------------------------------------------------------------------------
521 + //Corrected Jets
522 + Met RecoilTools::PURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
523 +                          const PFJetCol       *iJets,
524 +                          const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,Double_t iRho,
525                            Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
526                            Double_t iDZCut) {
527 <  Met lPUMet = PUMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
527 >  Met lPUMet = PUMet(iJets,iCands,iVertex,iVertices,iRho,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
528    lPUMet.SetMex  (lPUMet.Mex()+iVisPt*cos(iVisPhi));  
529    lPUMet.SetMey  (lPUMet.Mey()+iVisPt*sin(iVisPhi));
530    lPUMet.SetSumEt(lPUMet.SumEt()-iVisSumEt);

Diff Legend

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