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

Comparing UserCode/MitPhysics/Utils/src/MetTools.cc (file contents):
Revision 1.2 by ceballos, Tue Mar 15 08:35:01 2011 UTC vs.
Revision 1.10 by sixie, Thu Jul 7 20:22:19 2011 UTC

# Line 24 | Line 24 | MetTools::MetTools(const MuonCol *fMuons
24    for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
25  
26      // charged
27 <    if (fPFCandidates->At(i)->TrackerTrk()){
27 >    if (fPFCandidates->At(i)->HasTrackerTrk()){
28  
29        bool isMuonTrack = false;
30        for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
# Line 34 | Line 34 | MetTools::MetTools(const MuonCol *fMuons
34          }
35        }      
36        if (isMuonTrack) continue;
37 <      
37 >
38        if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
39          trackNumeratorX -= fPFCandidates->At(i)->Px();
40          trackNumeratorY -= fPFCandidates->At(i)->Py();
41 +        fRecoil += fPFCandidates->At(i)->Mom();
42 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
43        }
44      }
45  
# Line 46 | Line 48 | MetTools::MetTools(const MuonCol *fMuons
48        if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
49          neutralNumeratorX -= fPFCandidates->At(i)->Px();
50          neutralNumeratorY -= fPFCandidates->At(i)->Py();
51 +        fRecoil += fPFCandidates->At(i)->Mom();
52        }
53      }
54    }
55  
56 <  mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
57 <  mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
56 >  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
57 >  fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
58   }
59  
60   MetTools::MetTools(const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates, const Vertex *fVertex,
# Line 70 | Line 73 | MetTools::MetTools(const ElectronCol *fE
73    for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
74  
75      // charged
76 <    if (fPFCandidates->At(i)->TrackerTrk()){
76 >    if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
77        bool isElectronTrack = false;
78        for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
79 <        if ((fElectrons->At(m)->TrackerTrk() && fPFCandidates->At(i)->TrackerTrk() && fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
80 <            (fElectrons->At(m)->GsfTrk()     && fPFCandidates->At(i)->GsfTrk()     && fElectrons->At(m)->GsfTrk()     == fPFCandidates->At(i)->GsfTrk())) {
79 >        if ( (fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
80 >             (fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
81            isElectronTrack = true;
82            break;
83          }
84        }      
85        if (isElectronTrack) continue;
86  
87 +      if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
88 +          (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
89 +        trackNumeratorX -= fPFCandidates->At(i)->Px();
90 +        trackNumeratorY -= fPFCandidates->At(i)->Py();
91 +        fRecoil += fPFCandidates->At(i)->Mom();
92 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
93 +      }
94 +    }
95 +
96 +    // neutral    
97 +    if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
98 +      if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
99 +        neutralNumeratorX -= fPFCandidates->At(i)->Px();
100 +        neutralNumeratorY -= fPFCandidates->At(i)->Py();
101 +        fRecoil += fPFCandidates->At(i)->Mom();
102 +      }
103 +    }
104 +  }
105 +
106 +  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
107 +  fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
108 + }
109 +
110 +
111 + //--------------------------------------------------------------------------------------------------
112 + MetTools::MetTools(const MuonCol *fMuons, const PFCandidateCol *fPFCandidates, const PFJetCol *pfJets, const Vertex *fVertex,
113 +                   float deltaZCut, float ptCut, float etaCut) {
114 +
115 +  float trackNumeratorX  =0, trackNumeratorY  =0;
116 +  float neutralNumeratorX=0, neutralNumeratorY=0;
117 +
118 +  // muons Pt
119 +  for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
120 +    trackNumeratorX -= fMuons->At(m)->Px();
121 +    trackNumeratorY -= fMuons->At(m)->Py();
122 +  }
123 +  
124 +  // jets Pt
125 +  for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
126 +    trackNumeratorX -= pfJets->At(j)->Px();
127 +    trackNumeratorY -= pfJets->At(j)->Py();
128 +  }
129 +  
130 +  // PF candidates pT
131 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
132 +    
133 +    // jets
134 +    bool inTheJet = false;
135 +    for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
136 +      for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
137 +        if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
138 +          inTheJet=true;
139 +          break;
140 +        }
141 +      }
142 +      if (inTheJet) break;
143 +    }
144 +    if (inTheJet) continue;
145 +    
146 +    // charged
147 +    if (fPFCandidates->At(i)->HasTrackerTrk()){
148 +
149 +      bool isMuonTrack = false;
150 +      for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
151 +        if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
152 +          isMuonTrack = true;
153 +          break;
154 +        }
155 +      }      
156 +      if (isMuonTrack) continue;
157 +      
158        if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
159          trackNumeratorX -= fPFCandidates->At(i)->Px();
160          trackNumeratorY -= fPFCandidates->At(i)->Py();
161 +        fRecoil += fPFCandidates->At(i)->Mom();
162 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
163 +      }
164 +    }
165 +
166 +    // neutral    
167 +    if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
168 +      if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
169 +        neutralNumeratorX -= fPFCandidates->At(i)->Px();
170 +        neutralNumeratorY -= fPFCandidates->At(i)->Py();
171 +        fRecoil += fPFCandidates->At(i)->Mom();
172 +      }
173 +    }
174 +  }
175 +
176 +  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
177 +  fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
178 + }
179 +
180 +
181 + MetTools::MetTools(const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates, const PFJetCol *pfJets, const Vertex *fVertex,
182 +                   float deltaZCut, float ptCut, float etaCut) {
183 +
184 +  float trackNumeratorX  =0, trackNumeratorY  =0;
185 +  float neutralNumeratorX=0, neutralNumeratorY=0;
186 +
187 +  // electrons Pt
188 +  for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
189 +    trackNumeratorX -= fElectrons->At(m)->Px();
190 +    trackNumeratorY -= fElectrons->At(m)->Py();
191 +  }
192 +
193 +  // jets Pt
194 +  for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
195 +    trackNumeratorX -= pfJets->At(j)->Px();
196 +    trackNumeratorY -= pfJets->At(j)->Py();
197 +  }
198 +
199 +  // PF candidates pT
200 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
201 +
202 +    // jets
203 +    bool inTheJet = false;
204 +    for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
205 +      for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
206 +        if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
207 +          inTheJet=true;
208 +          break;
209 +        }
210 +      }
211 +      if (inTheJet) break;
212 +    }
213 +    if (inTheJet) continue;
214 +
215 +    // charged
216 +    if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
217 +      bool isElectronTrack = false;
218 +      for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
219 +        if ( (fElectrons->At(m)->HasTrackerTrk() and fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
220 +             (fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
221 +          isElectronTrack = true;
222 +          break;
223 +        }
224 +      }      
225 +      if (isElectronTrack) continue;
226 +
227 +      if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
228 +          (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
229 +        trackNumeratorX -= fPFCandidates->At(i)->Px();
230 +        trackNumeratorY -= fPFCandidates->At(i)->Py();
231 +        fRecoil += fPFCandidates->At(i)->Mom();
232 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
233 +      }
234 +    }
235 +
236 +    // neutral    
237 +    if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
238 +      if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
239 +        neutralNumeratorX -= fPFCandidates->At(i)->Px();
240 +        neutralNumeratorY -= fPFCandidates->At(i)->Py();
241 +        fRecoil += fPFCandidates->At(i)->Mom();
242 +      }
243 +    }
244 +  }
245 +
246 +  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
247 +  fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
248 + }
249 +
250 +
251 + void MetTools::AddToCorrectedTrackMet( const Particle *p, bool debug ) {
252 +  float MetX = fCorrectedTrackMet.Mex();
253 +  float MetY = fCorrectedTrackMet.Mey();
254 +
255 +  if (debug) std::cout << "AddToCorrectedTrackMet:\n";
256 +  if (debug) std::cout << "Before: " << MetX << " " << MetY << std::endl;
257 +
258 +  MetX -= p->Px();
259 +  MetY -= p->Py();
260 +
261 +  if (debug) std::cout << "Add : " << p->Px() << " " << p->Py() << std::endl;
262 +  if (debug) std::cout << "After : " << MetX << " " << MetY << std::endl;
263 +
264 +  fCorrectedTrackMet.SetMex(MetX);
265 +  fCorrectedTrackMet.SetMey(MetY);
266 +
267 +  return;
268 + }
269 +
270 + void MetTools::AddToCorrectedMet( const Particle *p) {
271 +  float MetX=fCorrectedMet.Mex();
272 +  float MetY=fCorrectedMet.Mey();
273 +  
274 +  MetX -= p->Px();
275 +  MetY -= p->Py();
276 +
277 +  fCorrectedMet.SetMex(MetX);
278 +  fCorrectedMet.SetMey(MetY);
279 +
280 +  return;
281 + }
282 +
283 + void MetTools::AddToRecoil( const Particle *p) {
284 +
285 +  if (p->Charge() != 0) {
286 +    fChargedRecoil += p->Mom();
287 +  }
288 +  fRecoil += p->Mom();
289 +
290 +  return;
291 + }
292 +
293 +
294 +
295 + void MetTools::RemoveParticleInIsoConeFromTrackMet( const Particle *p, const PFCandidateCol *fPFCandidates, const Vertex *fVertex, float deltaZCut , float deltaR, bool debug ) {
296 +  float MetX = fCorrectedTrackMet.Mex();
297 +  float MetY = fCorrectedTrackMet.Mey();
298 +  
299 +  if (debug) std::cout << "RemoveParticleInIsoConeFromTrackMet:\n";
300 +  if (debug) std::cout << "Before: " << MetX << " " << MetY << std::endl;
301 +
302 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
303 +    //charged
304 +    if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()) {
305 +      //passes dZ cut
306 +      if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
307 +          (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {        
308 +        //inside cone
309 +        if (MathUtils::DeltaR(fPFCandidates->At(i)->Mom(), p->Mom()) < deltaR ) {
310 +          MetX += fPFCandidates->At(i)->Px();
311 +          MetY += fPFCandidates->At(i)->Py();
312 +          if (debug) std::cout << "Subtract : " << fPFCandidates->At(i)->Px() << " " << fPFCandidates->At(i)->Py() << " : " << std::endl;
313 +        }
314 +      }
315 +    }
316 +  }
317 +
318 +  if (debug) std::cout << "After : " << MetX << " " << MetY << std::endl;
319 +
320 +  fCorrectedTrackMet.SetMex(MetX);
321 +  fCorrectedTrackMet.SetMey(MetY);
322 +
323 +  return;
324 + }
325 +
326 +
327 + void MetTools::RemoveParticleInIsoConeFromCorrectedMet( const Particle *p, const PFCandidateCol *fPFCandidates, const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut , float deltaR) {
328 +  float MetX = fCorrectedMet.Mex();
329 +  float MetY = fCorrectedMet.Mey();
330 +  
331 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
332 +
333 +    //inside cone
334 +    if (MathUtils::DeltaR(fPFCandidates->At(i)->Mom(), p->Mom()) < deltaR ) {
335 +
336 +      //charged
337 +      if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()) {
338 +        //passes dZ cut
339 +        if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
340 +            (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {                  
341 +          MetX += p->Px();
342 +          MetY += p->Py();
343 +        }
344 +      }
345 +
346 +      //neutrals
347 +      if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
348 +        if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
349 +          MetX += fPFCandidates->At(i)->Px();
350 +          MetY += fPFCandidates->At(i)->Py();
351 +        }
352 +      }
353 +    }
354 +
355 +  }
356 +
357 +  fCorrectedMet.SetMex(MetX);
358 +  fCorrectedMet.SetMey(MetY);
359 +
360 +  return;
361 + }
362 +
363 +
364 + void MetTools::RemoveParticleInIsoConeFromRecoil( const Particle *p, const PFCandidateCol *fPFCandidates, const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut , float deltaR) {
365 +  
366 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
367 +
368 +    //inside cone
369 +    if (MathUtils::DeltaR(fPFCandidates->At(i)->Mom(), p->Mom()) < deltaR ) {
370 +
371 +      //charged
372 +      if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()) {
373 +        //passes dZ cut
374 +        if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
375 +            (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {                  
376 +          fChargedRecoil -= fPFCandidates->At(i)->Mom();
377 +          fRecoil -= fPFCandidates->At(i)->Mom();
378 +        }
379 +      }
380 +
381 +      //neutrals
382 +      if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
383 +        if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {          
384 +          fRecoil -= fPFCandidates->At(i)->Mom();
385 +        }
386 +      }
387 +    }
388 +  }
389 +
390 +  return;
391 + }
392 +
393 +
394 + MetTools::MetTools(const MuonCol *fMuons, const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates,
395 +                   const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut) {
396 +
397 +  float trackNumeratorX  =0, trackNumeratorY  =0;
398 +  float neutralNumeratorX=0, neutralNumeratorY=0;
399 +
400 +  // muons Pt
401 +  for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
402 +    trackNumeratorX -= fMuons->At(m)->Px();
403 +    trackNumeratorY -= fMuons->At(m)->Py();
404 +  }
405 +
406 +  // electrons Pt
407 +  for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
408 +    trackNumeratorX -= fElectrons->At(m)->Px();
409 +    trackNumeratorY -= fElectrons->At(m)->Py();
410 +  }
411 +
412 +  // PF candidates pT
413 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
414 +
415 +    // charged
416 +    if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
417 +      bool isMuonTrack = false;
418 +      for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
419 +        if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
420 +          isMuonTrack = true;
421 +          break;
422 +        }
423 +      }      
424 +      if (isMuonTrack) continue;
425 +      
426 +      bool isElectronTrack = false;
427 +      for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
428 +        if ( (fElectrons->At(m)->HasTrackerTrk() and fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
429 +             (fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
430 +          isElectronTrack = true;
431 +          break;
432 +        }
433 +      }      
434 +      if (isElectronTrack) continue;
435 +
436 +      if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
437 +          (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
438 +        trackNumeratorX -= fPFCandidates->At(i)->Px();
439 +        trackNumeratorY -= fPFCandidates->At(i)->Py();
440 +        fRecoil += fPFCandidates->At(i)->Mom();
441 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
442        }
443      }
444  
# Line 92 | Line 447 | MetTools::MetTools(const ElectronCol *fE
447        if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
448          neutralNumeratorX -= fPFCandidates->At(i)->Px();
449          neutralNumeratorY -= fPFCandidates->At(i)->Py();
450 +        fRecoil += fPFCandidates->At(i)->Mom();
451        }
452      }
453    }
454 <  mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
455 <  mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
454 >  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
455 >  fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
456   }
457  
458 +
459   MetTools::MetTools(const MuonCol *fMuons, const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates,
460 +                   const PFJetCol *pfJets,
461                     const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut) {
462  
463    float trackNumeratorX  =0, trackNumeratorY  =0;
# Line 117 | Line 475 | MetTools::MetTools(const MuonCol *fMuons
475      trackNumeratorY -= fElectrons->At(m)->Py();
476    }
477  
478 +  // jets Pt
479 +  for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
480 +    trackNumeratorX -= pfJets->At(j)->Px();
481 +    trackNumeratorY -= pfJets->At(j)->Py();
482 +  }
483 +
484    // PF candidates pT
485    for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
486  
487 +    // jets
488 +    bool inTheJet = false;
489 +    for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
490 +      for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
491 +        if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
492 +          inTheJet=true;
493 +          break;
494 +        }
495 +      }
496 +      if (inTheJet) break;
497 +    }
498 +    if (inTheJet) continue;
499 +
500 +
501      // charged
502 <    if (fPFCandidates->At(i)->TrackerTrk()){
502 >    if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
503        bool isMuonTrack = false;
504        for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
505          if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
# Line 133 | Line 511 | MetTools::MetTools(const MuonCol *fMuons
511        
512        bool isElectronTrack = false;
513        for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
514 <        if ((fElectrons->At(m)->TrackerTrk() && fPFCandidates->At(i)->TrackerTrk() && fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
515 <            (fElectrons->At(m)->GsfTrk()     && fPFCandidates->At(i)->GsfTrk()     && fElectrons->At(m)->GsfTrk()     == fPFCandidates->At(i)->GsfTrk())) {
514 >        if ( (fElectrons->At(m)->HasTrackerTrk() and fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
515 >             (fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
516            isElectronTrack = true;
517            break;
518          }
519        }      
520        if (isElectronTrack) continue;
521  
522 <      if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
522 >      if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
523 >          (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
524          trackNumeratorX -= fPFCandidates->At(i)->Px();
525          trackNumeratorY -= fPFCandidates->At(i)->Py();
526 +        fRecoil += fPFCandidates->At(i)->Mom();
527 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
528        }
529      }
530  
# Line 152 | Line 533 | MetTools::MetTools(const MuonCol *fMuons
533        if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
534          neutralNumeratorX -= fPFCandidates->At(i)->Px();
535          neutralNumeratorY -= fPFCandidates->At(i)->Py();
536 +        fRecoil += fPFCandidates->At(i)->Mom();
537        }
538      }
539    }
540 <  mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
541 <  mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
540 >  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
541 >  fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
542   }
543  
544 < Met MetTools::GetMimumMet(const Met *UncorrectedMet) {
544 >
545 > Met MetTools::GetMinimumMet(const Met *UncorrectedMet) {
546  
547    return (fCorrectedMet.Pt() < UncorrectedMet->Pt()) ?  fCorrectedMet : *UncorrectedMet;
548   }
549  
550 < Met MetTools::GetMimumTrackMet(const Met *UncorrectedMet) {
550 > Met MetTools::GetMinimumTrackMet(const Met *UncorrectedMet) {
551  
552    return (fCorrectedTrackMet.Pt() < UncorrectedMet->Pt()) ?  fCorrectedTrackMet : *UncorrectedMet;
553   }

Diff Legend

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