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.13 by ceballos, Sat Jul 7 11:33:59 2012 UTC

# Line 13 | Line 13 | MetTools::MetTools(const MuonCol *fMuons
13  
14    float trackNumeratorX  =0, trackNumeratorY  =0;
15    float neutralNumeratorX=0, neutralNumeratorY=0;
16 +  float CHSNumeratorX  =0, CHSNumeratorY  =0, NHSNumeratorX  =0, NHSNumeratorY  =0;
17  
18    // muons Pt
19    for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
# Line 23 | Line 24 | MetTools::MetTools(const MuonCol *fMuons
24    // PF candidates pT
25    for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
26  
27 +    // CHS computation
28 +    if (fPFCandidates->At(i)->HasTrk()){
29 +        CHSNumeratorX -= fPFCandidates->At(i)->Px();
30 +        CHSNumeratorY -= fPFCandidates->At(i)->Py();
31 +    }
32 +    // NHS computation
33 +    if (fPFCandidates->At(i)->HasTrk() ||
34 +       (fPFCandidates->At(i)->AbsEta() < 3.0 && fPFCandidates->At(i)->Pt() > 4.0)){
35 +        NHSNumeratorX -= fPFCandidates->At(i)->Px();
36 +        NHSNumeratorY -= fPFCandidates->At(i)->Py();
37 +    }
38 +
39      // charged
40 <    if (fPFCandidates->At(i)->TrackerTrk()){
40 >    if (fPFCandidates->At(i)->HasTrackerTrk()){
41  
42        bool isMuonTrack = false;
43        for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
# Line 34 | Line 47 | MetTools::MetTools(const MuonCol *fMuons
47          }
48        }      
49        if (isMuonTrack) continue;
50 <      
50 >
51        if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
52          trackNumeratorX -= fPFCandidates->At(i)->Px();
53          trackNumeratorY -= fPFCandidates->At(i)->Py();
54 +        fRecoil += fPFCandidates->At(i)->Mom();
55 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
56        }
57      }
58  
# Line 46 | Line 61 | MetTools::MetTools(const MuonCol *fMuons
61        if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
62          neutralNumeratorX -= fPFCandidates->At(i)->Px();
63          neutralNumeratorY -= fPFCandidates->At(i)->Py();
64 +        fRecoil += fPFCandidates->At(i)->Mom();
65        }
66      }
67    }
68  
69 <  mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
70 <  mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
69 >  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
70 >  fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
71 >  fCHSMet = mithep::Met(CHSNumeratorX, CHSNumeratorY);
72 >  fNHSMet = mithep::Met(NHSNumeratorX, NHSNumeratorY);
73   }
74  
75   MetTools::MetTools(const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates, const Vertex *fVertex,
# Line 59 | Line 77 | MetTools::MetTools(const ElectronCol *fE
77  
78    float trackNumeratorX  =0, trackNumeratorY  =0;
79    float neutralNumeratorX=0, neutralNumeratorY=0;
80 +  float CHSNumeratorX  =0, CHSNumeratorY  =0, NHSNumeratorX  =0, NHSNumeratorY  =0;
81  
82    // electrons Pt
83    for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
# Line 69 | Line 88 | MetTools::MetTools(const ElectronCol *fE
88    // PF candidates pT
89    for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
90  
91 +    // CHS computation
92 +    if (fPFCandidates->At(i)->HasTrk()){
93 +        CHSNumeratorX -= fPFCandidates->At(i)->Px();
94 +        CHSNumeratorY -= fPFCandidates->At(i)->Py();
95 +    }
96 +    // NHS computation
97 +    if (fPFCandidates->At(i)->HasTrk() ||
98 +       (fPFCandidates->At(i)->AbsEta() < 3.0 && fPFCandidates->At(i)->Pt() > 4.0)){
99 +        NHSNumeratorX -= fPFCandidates->At(i)->Px();
100 +        NHSNumeratorY -= fPFCandidates->At(i)->Py();
101 +    }
102 +
103      // charged
104 <    if (fPFCandidates->At(i)->TrackerTrk()){
104 >    if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
105        bool isElectronTrack = false;
106        for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
107 <        if ((fElectrons->At(m)->TrackerTrk() && fPFCandidates->At(i)->TrackerTrk() && fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
108 <            (fElectrons->At(m)->GsfTrk()     && fPFCandidates->At(i)->GsfTrk()     && fElectrons->At(m)->GsfTrk()     == fPFCandidates->At(i)->GsfTrk())) {
107 >        if ( (fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
108 >             (fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
109            isElectronTrack = true;
110            break;
111          }
112        }      
113        if (isElectronTrack) continue;
114  
115 +      if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
116 +          (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
117 +        trackNumeratorX -= fPFCandidates->At(i)->Px();
118 +        trackNumeratorY -= fPFCandidates->At(i)->Py();
119 +        fRecoil += fPFCandidates->At(i)->Mom();
120 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
121 +      }
122 +    }
123 +
124 +    // neutral    
125 +    if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
126 +      if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
127 +        neutralNumeratorX -= fPFCandidates->At(i)->Px();
128 +        neutralNumeratorY -= fPFCandidates->At(i)->Py();
129 +        fRecoil += fPFCandidates->At(i)->Mom();
130 +      }
131 +    }
132 +  }
133 +
134 +  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
135 +  fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
136 +  fCHSMet = mithep::Met(CHSNumeratorX, CHSNumeratorY);
137 +  fNHSMet = mithep::Met(NHSNumeratorX, NHSNumeratorY);
138 + }
139 +
140 +
141 + //--------------------------------------------------------------------------------------------------
142 + MetTools::MetTools(const MuonCol *fMuons, const PFCandidateCol *fPFCandidates, const PFJetCol *pfJets, const Vertex *fVertex,
143 +                   float deltaZCut, float ptCut, float etaCut) {
144 +
145 +  float trackNumeratorX  =0, trackNumeratorY  =0;
146 +  float neutralNumeratorX=0, neutralNumeratorY=0;
147 +  float CHSNumeratorX  =0, CHSNumeratorY  =0, NHSNumeratorX  =0, NHSNumeratorY  =0;
148 +
149 +  // muons Pt
150 +  for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
151 +    trackNumeratorX -= fMuons->At(m)->Px();
152 +    trackNumeratorY -= fMuons->At(m)->Py();
153 +  }
154 +  
155 +  // jets Pt
156 +  for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
157 +    trackNumeratorX -= pfJets->At(j)->Px();
158 +    trackNumeratorY -= pfJets->At(j)->Py();
159 +  }
160 +  
161 +  // PF candidates pT
162 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
163 +    
164 +    // CHS computation
165 +    if (fPFCandidates->At(i)->HasTrk()){
166 +        CHSNumeratorX -= fPFCandidates->At(i)->Px();
167 +        CHSNumeratorY -= fPFCandidates->At(i)->Py();
168 +    }
169 +    // NHS computation
170 +    if (fPFCandidates->At(i)->HasTrk() ||
171 +       (fPFCandidates->At(i)->AbsEta() < 3.0 && fPFCandidates->At(i)->Pt() > 4.0)){
172 +        NHSNumeratorX -= fPFCandidates->At(i)->Px();
173 +        NHSNumeratorY -= fPFCandidates->At(i)->Py();
174 +    }
175 +
176 +    // jets
177 +    bool inTheJet = false;
178 +    for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
179 +      for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
180 +        if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
181 +          inTheJet=true;
182 +          break;
183 +        }
184 +      }
185 +      if (inTheJet) break;
186 +    }
187 +    if (inTheJet) continue;
188 +    
189 +    // charged
190 +    if (fPFCandidates->At(i)->HasTrackerTrk()){
191 +
192 +      bool isMuonTrack = false;
193 +      for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
194 +        if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
195 +          isMuonTrack = true;
196 +          break;
197 +        }
198 +      }      
199 +      if (isMuonTrack) continue;
200 +      
201        if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
202          trackNumeratorX -= fPFCandidates->At(i)->Px();
203          trackNumeratorY -= fPFCandidates->At(i)->Py();
204 +        fRecoil += fPFCandidates->At(i)->Mom();
205 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
206 +      }
207 +    }
208 +
209 +    // neutral    
210 +    if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
211 +      if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
212 +        neutralNumeratorX -= fPFCandidates->At(i)->Px();
213 +        neutralNumeratorY -= fPFCandidates->At(i)->Py();
214 +        fRecoil += fPFCandidates->At(i)->Mom();
215 +      }
216 +    }
217 +  }
218 +
219 +  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
220 +  fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
221 +  fCHSMet = mithep::Met(CHSNumeratorX, CHSNumeratorY);
222 +  fNHSMet = mithep::Met(NHSNumeratorX, NHSNumeratorY);
223 + }
224 +
225 +
226 + MetTools::MetTools(const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates, const PFJetCol *pfJets, const Vertex *fVertex,
227 +                   float deltaZCut, float ptCut, float etaCut) {
228 +
229 +  float trackNumeratorX  =0, trackNumeratorY  =0;
230 +  float neutralNumeratorX=0, neutralNumeratorY=0;
231 +  float CHSNumeratorX  =0, CHSNumeratorY  =0, NHSNumeratorX  =0, NHSNumeratorY  =0;
232 +
233 +  // electrons Pt
234 +  for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
235 +    trackNumeratorX -= fElectrons->At(m)->Px();
236 +    trackNumeratorY -= fElectrons->At(m)->Py();
237 +  }
238 +
239 +  // jets Pt
240 +  for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
241 +    trackNumeratorX -= pfJets->At(j)->Px();
242 +    trackNumeratorY -= pfJets->At(j)->Py();
243 +  }
244 +
245 +  // PF candidates pT
246 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
247 +
248 +    // CHS computation
249 +    if (fPFCandidates->At(i)->HasTrk()){
250 +        CHSNumeratorX -= fPFCandidates->At(i)->Px();
251 +        CHSNumeratorY -= fPFCandidates->At(i)->Py();
252 +    }
253 +    // NHS computation
254 +    if (fPFCandidates->At(i)->HasTrk() ||
255 +       (fPFCandidates->At(i)->AbsEta() < 3.0 && fPFCandidates->At(i)->Pt() > 4.0)){
256 +        NHSNumeratorX -= fPFCandidates->At(i)->Px();
257 +        NHSNumeratorY -= fPFCandidates->At(i)->Py();
258 +    }
259 +
260 +    // jets
261 +    bool inTheJet = false;
262 +    for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
263 +      for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
264 +        if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
265 +          inTheJet=true;
266 +          break;
267 +        }
268 +      }
269 +      if (inTheJet) break;
270 +    }
271 +    if (inTheJet) continue;
272 +
273 +    // charged
274 +    if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
275 +      bool isElectronTrack = false;
276 +      for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
277 +        if ( (fElectrons->At(m)->HasTrackerTrk() and fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
278 +             (fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
279 +          isElectronTrack = true;
280 +          break;
281 +        }
282 +      }      
283 +      if (isElectronTrack) continue;
284 +
285 +      if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
286 +          (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
287 +        trackNumeratorX -= fPFCandidates->At(i)->Px();
288 +        trackNumeratorY -= fPFCandidates->At(i)->Py();
289 +        fRecoil += fPFCandidates->At(i)->Mom();
290 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
291        }
292      }
293  
# Line 92 | Line 296 | MetTools::MetTools(const ElectronCol *fE
296        if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
297          neutralNumeratorX -= fPFCandidates->At(i)->Px();
298          neutralNumeratorY -= fPFCandidates->At(i)->Py();
299 +        fRecoil += fPFCandidates->At(i)->Mom();
300        }
301      }
302    }
303 <  mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
304 <  mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
303 >
304 >  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
305 >  fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
306 >  fCHSMet = mithep::Met(CHSNumeratorX, CHSNumeratorY);
307 >  fNHSMet = mithep::Met(NHSNumeratorX, NHSNumeratorY);
308 > }
309 >
310 >
311 > void MetTools::AddToCorrectedTrackMet( const Particle *p, bool debug ) {
312 >  float MetX = fCorrectedTrackMet.Mex();
313 >  float MetY = fCorrectedTrackMet.Mey();
314 >
315 >  if (debug) std::cout << "AddToCorrectedTrackMet:\n";
316 >  if (debug) std::cout << "Before: " << MetX << " " << MetY << std::endl;
317 >
318 >  MetX -= p->Px();
319 >  MetY -= p->Py();
320 >
321 >  if (debug) std::cout << "Add : " << p->Px() << " " << p->Py() << std::endl;
322 >  if (debug) std::cout << "After : " << MetX << " " << MetY << std::endl;
323 >
324 >  fCorrectedTrackMet.SetMex(MetX);
325 >  fCorrectedTrackMet.SetMey(MetY);
326 >
327 >  return;
328 > }
329 >
330 > void MetTools::AddToCorrectedMet( const Particle *p) {
331 >  float MetX=fCorrectedMet.Mex();
332 >  float MetY=fCorrectedMet.Mey();
333 >  
334 >  MetX -= p->Px();
335 >  MetY -= p->Py();
336 >
337 >  fCorrectedMet.SetMex(MetX);
338 >  fCorrectedMet.SetMey(MetY);
339 >
340 >  return;
341 > }
342 >
343 > void MetTools::AddToRecoil( const Particle *p) {
344 >
345 >  if (p->Charge() != 0) {
346 >    fChargedRecoil += p->Mom();
347 >  }
348 >  fRecoil += p->Mom();
349 >
350 >  return;
351   }
352  
353 +
354 +
355 + void MetTools::RemoveParticleInIsoConeFromTrackMet( const Particle *p, const PFCandidateCol *fPFCandidates, const Vertex *fVertex, float deltaZCut , float deltaR, bool debug ) {
356 +  float MetX = fCorrectedTrackMet.Mex();
357 +  float MetY = fCorrectedTrackMet.Mey();
358 +  
359 +  if (debug) std::cout << "RemoveParticleInIsoConeFromTrackMet:\n";
360 +  if (debug) std::cout << "Before: " << MetX << " " << MetY << std::endl;
361 +
362 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
363 +    //charged
364 +    if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()) {
365 +      //passes dZ cut
366 +      if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
367 +          (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {        
368 +        //inside cone
369 +        if (MathUtils::DeltaR(fPFCandidates->At(i)->Mom(), p->Mom()) < deltaR ) {
370 +          MetX += fPFCandidates->At(i)->Px();
371 +          MetY += fPFCandidates->At(i)->Py();
372 +          if (debug) std::cout << "Subtract : " << fPFCandidates->At(i)->Px() << " " << fPFCandidates->At(i)->Py() << " : " << std::endl;
373 +        }
374 +      }
375 +    }
376 +  }
377 +
378 +  if (debug) std::cout << "After : " << MetX << " " << MetY << std::endl;
379 +
380 +  fCorrectedTrackMet.SetMex(MetX);
381 +  fCorrectedTrackMet.SetMey(MetY);
382 +
383 +  return;
384 + }
385 +
386 +
387 + void MetTools::RemoveParticleInIsoConeFromCorrectedMet( const Particle *p, const PFCandidateCol *fPFCandidates, const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut , float deltaR) {
388 +  float MetX = fCorrectedMet.Mex();
389 +  float MetY = fCorrectedMet.Mey();
390 +  
391 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
392 +
393 +    //inside cone
394 +    if (MathUtils::DeltaR(fPFCandidates->At(i)->Mom(), p->Mom()) < deltaR ) {
395 +
396 +      //charged
397 +      if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()) {
398 +        //passes dZ cut
399 +        if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
400 +            (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {                  
401 +          MetX += p->Px();
402 +          MetY += p->Py();
403 +        }
404 +      }
405 +
406 +      //neutrals
407 +      if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
408 +        if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
409 +          MetX += fPFCandidates->At(i)->Px();
410 +          MetY += fPFCandidates->At(i)->Py();
411 +        }
412 +      }
413 +    }
414 +
415 +  }
416 +
417 +  fCorrectedMet.SetMex(MetX);
418 +  fCorrectedMet.SetMey(MetY);
419 +
420 +  return;
421 + }
422 +
423 +
424 + void MetTools::RemoveParticleInIsoConeFromRecoil( const Particle *p, const PFCandidateCol *fPFCandidates, const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut , float deltaR) {
425 +  
426 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
427 +
428 +    //inside cone
429 +    if (MathUtils::DeltaR(fPFCandidates->At(i)->Mom(), p->Mom()) < deltaR ) {
430 +
431 +      //charged
432 +      if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()) {
433 +        //passes dZ cut
434 +        if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
435 +            (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {                  
436 +          fChargedRecoil -= fPFCandidates->At(i)->Mom();
437 +          fRecoil -= fPFCandidates->At(i)->Mom();
438 +        }
439 +      }
440 +
441 +      //neutrals
442 +      if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
443 +        if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {          
444 +          fRecoil -= fPFCandidates->At(i)->Mom();
445 +        }
446 +      }
447 +    }
448 +  }
449 +
450 +  return;
451 + }
452 +
453 +
454   MetTools::MetTools(const MuonCol *fMuons, const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates,
455 <                   const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut) {
455 >                   const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut, float intRadius,
456 >                   const GenericParticle *genP) {
457  
458    float trackNumeratorX  =0, trackNumeratorY  =0;
459    float neutralNumeratorX=0, neutralNumeratorY=0;
460 +  float CHSNumeratorX  =0, CHSNumeratorY  =0, NHSNumeratorX  =0, NHSNumeratorY  =0;
461 +
462 +  float trackNumeratorGenPX  =0, trackNumeratorGenPY  =0;
463 +  // added to the track quantities
464 +  if (genP) {
465 +    trackNumeratorGenPX -= genP->Px();
466 +    trackNumeratorGenPY -= genP->Py();
467 +  }
468  
469    // muons Pt
470    for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
# Line 120 | Line 481 | MetTools::MetTools(const MuonCol *fMuons
481    // PF candidates pT
482    for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
483  
484 +    // CHS computation
485 +    if (fPFCandidates->At(i)->HasTrk()){
486 +        CHSNumeratorX -= fPFCandidates->At(i)->Px();
487 +        CHSNumeratorY -= fPFCandidates->At(i)->Py();
488 +    }
489 +    // NHS computation
490 +    if (fPFCandidates->At(i)->HasTrk() ||
491 +       (fPFCandidates->At(i)->AbsEta() < 3.0 && fPFCandidates->At(i)->Pt() > 4.0)){
492 +        NHSNumeratorX -= fPFCandidates->At(i)->Px();
493 +        NHSNumeratorY -= fPFCandidates->At(i)->Py();
494 +    }
495 +
496      // charged
497 <    if (fPFCandidates->At(i)->TrackerTrk()){
497 >    if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
498        bool isMuonTrack = false;
499        for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
500          if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
501            isMuonTrack = true;
502            break;
503          }
504 +        if (intRadius > 0.0 && MathUtils::DeltaR(fPFCandidates->At(i)->Mom(), fMuons->At(m)->Mom()) < intRadius) {
505 +          isMuonTrack = true;
506 +          break;
507 +        }
508 +      }    
509 +      if (isMuonTrack) continue;
510 +      
511 +      bool isElectronTrack = false;
512 +      for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
513 +        if ( (fElectrons->At(m)->HasTrackerTrk() and fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
514 +             (fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
515 +          isElectronTrack = true;
516 +          break;
517 +        }
518 +        if (intRadius > 0.0 && MathUtils::DeltaR(fPFCandidates->At(i)->Mom(), fElectrons->At(m)->Mom()) < intRadius) {
519 +          isElectronTrack = true;
520 +          break;
521 +        }
522 +      }
523 +      if (isElectronTrack) continue;
524 +
525 +      if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
526 +          (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
527 +        trackNumeratorX -= fPFCandidates->At(i)->Px();
528 +        trackNumeratorY -= fPFCandidates->At(i)->Py();
529 +        fRecoil += fPFCandidates->At(i)->Mom();
530 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
531 +      }
532 +    }
533 +
534 +    // neutral    
535 +    if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
536 +      if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
537 +        neutralNumeratorX -= fPFCandidates->At(i)->Px();
538 +        neutralNumeratorY -= fPFCandidates->At(i)->Py();
539 +        fRecoil += fPFCandidates->At(i)->Mom();
540 +      }
541 +    }
542 +  }
543 +  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
544 +  fCorrectedTrackMet = mithep::Met(trackNumeratorX+trackNumeratorGenPX, trackNumeratorY+trackNumeratorGenPY);
545 +  fCHSMet = mithep::Met(CHSNumeratorX+trackNumeratorGenPX, CHSNumeratorY+trackNumeratorGenPY);
546 +  fNHSMet = mithep::Met(NHSNumeratorX, NHSNumeratorY);
547 + }
548 +
549 +
550 + MetTools::MetTools(const MuonCol *fMuons, const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates,
551 +                   const PFJetCol *pfJets,
552 +                   const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut, float intRadius,
553 +                   const GenericParticle *genP) {
554 +
555 +  float trackNumeratorX  =0, trackNumeratorY  =0;
556 +  float neutralNumeratorX=0, neutralNumeratorY=0;
557 +  float CHSNumeratorX  =0, CHSNumeratorY  =0, NHSNumeratorX  =0, NHSNumeratorY  =0;
558 +
559 +  float trackNumeratorGenPX  =0, trackNumeratorGenPY  =0;
560 +  // added to the track quantities
561 +  if (genP) {
562 +    trackNumeratorGenPX -= genP->Px();
563 +    trackNumeratorGenPY -= genP->Py();
564 +  }
565 +
566 +  // muons Pt
567 +  for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
568 +    trackNumeratorX -= fMuons->At(m)->Px();
569 +    trackNumeratorY -= fMuons->At(m)->Py();
570 +  }
571 +
572 +  // electrons Pt
573 +  for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
574 +    trackNumeratorX -= fElectrons->At(m)->Px();
575 +    trackNumeratorY -= fElectrons->At(m)->Py();
576 +  }
577 +
578 +  // jets Pt
579 +  for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
580 +    trackNumeratorX -= pfJets->At(j)->Px();
581 +    trackNumeratorY -= pfJets->At(j)->Py();
582 +  }
583 +
584 +  // PF candidates pT
585 +  for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
586 +
587 +    // CHS computation
588 +    if (fPFCandidates->At(i)->HasTrk()){
589 +        CHSNumeratorX -= fPFCandidates->At(i)->Px();
590 +        CHSNumeratorY -= fPFCandidates->At(i)->Py();
591 +    }
592 +    // NHS computation
593 +    if (fPFCandidates->At(i)->HasTrk() ||
594 +       (fPFCandidates->At(i)->AbsEta() < 3.0 && fPFCandidates->At(i)->Pt() > 4.0)){
595 +        NHSNumeratorX -= fPFCandidates->At(i)->Px();
596 +        NHSNumeratorY -= fPFCandidates->At(i)->Py();
597 +    }
598 +
599 +    // jets
600 +    bool inTheJet = false;
601 +    for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
602 +      for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
603 +        if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
604 +          inTheJet=true;
605 +          break;
606 +        }
607 +      }
608 +      if (inTheJet) break;
609 +    }
610 +    if (inTheJet) continue;
611 +
612 +    // charged
613 +    if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
614 +      bool isMuonTrack = false;
615 +      for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
616 +        if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
617 +          isMuonTrack = true;
618 +          break;
619 +        }
620 +        if (intRadius > 0.0 && MathUtils::DeltaR(fPFCandidates->At(i)->Mom(), fMuons->At(m)->Mom()) < intRadius) {
621 +          isMuonTrack = true;
622 +          break;
623 +        }
624        }      
625        if (isMuonTrack) continue;
626        
627        bool isElectronTrack = false;
628        for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
629 <        if ((fElectrons->At(m)->TrackerTrk() && fPFCandidates->At(i)->TrackerTrk() && fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
630 <            (fElectrons->At(m)->GsfTrk()     && fPFCandidates->At(i)->GsfTrk()     && fElectrons->At(m)->GsfTrk()     == fPFCandidates->At(i)->GsfTrk())) {
629 >        if ( (fElectrons->At(m)->HasTrackerTrk() and fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
630 >             (fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
631 >          isElectronTrack = true;
632 >          break;
633 >        }
634 >        if (intRadius > 0.0 && MathUtils::DeltaR(fPFCandidates->At(i)->Mom(), fElectrons->At(m)->Mom()) < intRadius) {
635            isElectronTrack = true;
636            break;
637          }
638        }      
639        if (isElectronTrack) continue;
640  
641 <      if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
641 >      if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
642 >          (fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
643          trackNumeratorX -= fPFCandidates->At(i)->Px();
644          trackNumeratorY -= fPFCandidates->At(i)->Py();
645 +        fRecoil += fPFCandidates->At(i)->Mom();
646 +        fChargedRecoil += fPFCandidates->At(i)->Mom();
647        }
648      }
649  
# Line 152 | Line 652 | MetTools::MetTools(const MuonCol *fMuons
652        if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
653          neutralNumeratorX -= fPFCandidates->At(i)->Px();
654          neutralNumeratorY -= fPFCandidates->At(i)->Py();
655 +        fRecoil += fPFCandidates->At(i)->Mom();
656        }
657      }
658    }
659 <  mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
660 <  mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
659 >  fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
660 >  fCorrectedTrackMet = mithep::Met(trackNumeratorX+trackNumeratorGenPX, trackNumeratorY+trackNumeratorGenPY);
661 >  fCHSMet = mithep::Met(CHSNumeratorX+trackNumeratorGenPX, CHSNumeratorY+trackNumeratorGenPY);
662 >  fNHSMet = mithep::Met(NHSNumeratorX, NHSNumeratorY);
663   }
664  
665 < Met MetTools::GetMimumMet(const Met *UncorrectedMet) {
665 >
666 > Met MetTools::GetMinimumMet(const Met *UncorrectedMet) {
667  
668    return (fCorrectedMet.Pt() < UncorrectedMet->Pt()) ?  fCorrectedMet : *UncorrectedMet;
669   }
670  
671 < Met MetTools::GetMimumTrackMet(const Met *UncorrectedMet) {
671 > Met MetTools::GetMinimumTrackMet(const Met *UncorrectedMet) {
672  
673    return (fCorrectedTrackMet.Pt() < UncorrectedMet->Pt()) ?  fCorrectedTrackMet : *UncorrectedMet;
674   }

Diff Legend

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