]>
Commit | Line | Data |
---|---|---|
f1d945a1 | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | /* $Id */ | |
16 | ||
17 | #include "Riostream.h" | |
18 | #include "AliFlowEventSimpleMaker.h" | |
19 | #include "AliFlowEventSimple.h" | |
20 | #include "AliFlowTrackSimple.h" | |
21 | #include "TTree.h" | |
22 | #include "TParticle.h" | |
23 | #include "AliMCEvent.h" | |
24 | #include "AliMCParticle.h" | |
25 | #include "AliESDEvent.h" | |
26 | #include "AliESDtrack.h" | |
27 | #include "AliAODEvent.h" | |
28 | #include "AliAODTrack.h" | |
29 | ||
30 | // AliFlowEventSimpleMaker: | |
31 | // Class to fill the AliFlowEventSimple | |
32 | // with AliFlowTrackSimple objects | |
33 | // Has fill methods for TTree, AliMCEvent, AliESDEvent and AliAODEvent | |
34 | // author: N. van der Kolk (kolk@nikhef.nl) | |
35 | ||
36 | ||
37 | ||
38 | ClassImp(AliFlowEventSimpleMaker) | |
39 | //----------------------------------------------------------------------- | |
40 | AliFlowEventSimpleMaker::AliFlowEventSimpleMaker(): | |
41 | fEvent(0), | |
42 | fTrack(0), | |
43 | fParticle(0) | |
44 | { | |
45 | ||
46 | //constructor | |
47 | ||
48 | } | |
49 | ||
50 | ||
51 | //----------------------------------------------------------------------- | |
52 | AliFlowEventSimpleMaker::~AliFlowEventSimpleMaker() | |
53 | { | |
54 | //desstructor | |
55 | } | |
56 | ||
57 | ||
58 | //----------------------------------------------------------------------- | |
59 | AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(TTree* fInput) | |
60 | { | |
61 | //fills the event from a TTree of kinematic.root files | |
62 | Bool_t fDoubleLoop = kFALSE; | |
63 | ||
64 | Int_t fNumberOfInputTracks = fInput->GetEntries() ; | |
65 | //cerr<<"fNumberOfInputTracks = "<<fNumberOfInputTracks<<endl; | |
66 | fParticle = new TParticle(); | |
67 | fInput->SetBranchAddress("Particles",&fParticle); | |
68 | // fEvent = new AliFlowEventSimple(fNumberOfInputTracks); | |
69 | fEvent = new AliFlowEventSimple(10); | |
70 | //cerr<<fEvent<<" fEvent "<<endl; | |
71 | ||
72 | Int_t fN = fNumberOfInputTracks; | |
73 | // Int_t fN = 576; //multiplicity for chi=1.5 | |
74 | // Int_t fN = 256; //multiplicity for chi=1 | |
75 | // Int_t fN = 164; //multiplicity for chi=0.8 | |
76 | Int_t fGoodTracks = 0; | |
77 | Int_t ftrkN = 0; | |
78 | Int_t fSelParticlesDiff = 0; | |
79 | Int_t fSelParticlesInt = 0; | |
80 | ||
81 | if (fDoubleLoop) | |
82 | { //double loop | |
83 | while (fGoodTracks < fN*2 && ftrkN < fNumberOfInputTracks) | |
84 | { | |
85 | fInput->GetEntry(ftrkN); //get input particle | |
86 | //cut on tracks | |
87 | if(TMath::Abs(fParticle->Eta()) < 0.9) | |
88 | { | |
89 | // Int_t fLoop = floor(2.*fParticle->Pt())+2; | |
90 | // for(Int_t d=0;d<fLoop;d++) | |
91 | for(Int_t d=0;d<2;d++) | |
92 | { | |
93 | if( | |
94 | TMath::Abs(fParticle->GetPdgCode()) == 211 | |
95 | // TMath::Abs(fParticle->GetPdgCode()) == 211 || | |
96 | // TMath::Abs(fParticle->GetPdgCode()) == 321 || | |
97 | // TMath::Abs(fParticle->GetPdgCode()) == 2212 | |
98 | ) | |
99 | { | |
100 | fTrack = new AliFlowTrackSimple(); | |
101 | fTrack->SetPt(fParticle->Pt() ); | |
102 | fTrack->SetEta(fParticle->Eta() ); | |
103 | fTrack->SetPhi(fParticle->Phi() ); | |
104 | fTrack->SetForIntegratedFlow(kTRUE); | |
105 | fTrack->SetForDifferentialFlow(kTRUE); | |
106 | ||
107 | if (fTrack->UseForIntegratedFlow()) | |
108 | { fSelParticlesInt++; } | |
109 | if (fTrack->UseForDifferentialFlow()) | |
110 | { fSelParticlesDiff++; } | |
111 | fGoodTracks++; | |
112 | fEvent->TrackCollection()->Add(fTrack); | |
113 | } | |
114 | /* | |
115 | else if( | |
116 | TMath::Abs(fParticle->GetPdgCode()) == 2212 | |
117 | ) | |
118 | { | |
119 | fTrack = new AliFlowTrackSimple(); | |
120 | fTrack->SetPt(fParticle->Pt() ); | |
121 | fTrack->SetEta(fParticle->Eta() ); | |
122 | fTrack->SetPhi(fParticle->Phi() ); | |
123 | fTrack->SetForIntegratedFlow(kFALSE); | |
124 | fTrack->SetForDifferentialFlow(kTRUE); | |
125 | ||
126 | if (fTrack->UseForIntegratedFlow()) | |
127 | { fSelParticlesInt++; } | |
128 | if (fTrack->UseForDifferentialFlow()) | |
129 | { fSelParticlesDiff++; } | |
130 | fGoodTracks++; | |
131 | fEvent->TrackCollection()->Add(fTrack); | |
132 | } | |
133 | */ | |
134 | } | |
135 | } | |
136 | ftrkN++; | |
137 | } | |
138 | } | |
139 | ||
140 | else { //normal loop | |
141 | while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) { | |
142 | fInput->GetEntry(ftrkN); //get input particle | |
143 | //cut on tracks | |
144 | if (TMath::Abs(fParticle->Eta()) < 0.2) | |
145 | { | |
146 | if( | |
147 | TMath::Abs(fParticle->GetPdgCode()) == 211 | |
148 | // TMath::Abs(fParticle->GetPdgCode()) == 211 || | |
149 | // TMath::Abs(fParticle->GetPdgCode()) == 321 || | |
150 | // TMath::Abs(fParticle->GetPdgCode()) == 2212 | |
151 | ) | |
152 | { | |
153 | fTrack = new AliFlowTrackSimple() ; | |
154 | fTrack->SetPt(fParticle->Pt() ); | |
155 | fTrack->SetEta(fParticle->Eta() ); | |
156 | fTrack->SetPhi(fParticle->Phi() ); | |
157 | fTrack->SetForIntegratedFlow(kTRUE); | |
158 | fTrack->SetForDifferentialFlow(kTRUE); | |
159 | ||
160 | if (fTrack->UseForIntegratedFlow()) | |
161 | { fSelParticlesInt++; } | |
162 | if (fTrack->UseForDifferentialFlow()) | |
163 | { fSelParticlesDiff++; } | |
164 | fGoodTracks++; | |
165 | fEvent->TrackCollection()->Add(fTrack) ; | |
166 | } | |
167 | /* else if( | |
168 | TMath::Abs(fParticle->GetPdgCode()) == 211 | |
169 | ) | |
170 | { | |
171 | fTrack = new AliFlowTrackSimple(); | |
172 | fTrack->SetPt(fParticle->Pt() ); | |
173 | fTrack->SetEta(fParticle->Eta() ); | |
174 | fTrack->SetPhi(fParticle->Phi() ); | |
175 | fTrack->SetForIntegratedFlow(kFALSE); | |
176 | fTrack->SetForDifferentialFlow(kTRUE); | |
177 | ||
178 | if (fTrack->UseForIntegratedFlow()) | |
179 | { fSelParticlesInt++; } | |
180 | if (fTrack->UseForDifferentialFlow()) | |
181 | { fSelParticlesDiff++; } | |
182 | fGoodTracks++; | |
183 | fEvent->TrackCollection()->Add(fTrack); | |
184 | } | |
185 | */ | |
186 | } | |
187 | ||
188 | ftrkN++; | |
189 | } | |
190 | } | |
191 | ||
192 | fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt); | |
193 | fEvent->SetNumberOfTracks(fGoodTracks); | |
194 | cout<<" fGoodTracks = "<<fGoodTracks<<endl; | |
195 | cout << " fSelectedTracksInt = " << fSelParticlesInt << endl; | |
196 | return fEvent; | |
197 | ||
198 | } | |
199 | ||
200 | //----------------------------------------------------------------------- | |
201 | AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliMCEvent* fInput) | |
202 | { | |
203 | //Fills the event from the MC kinematic information | |
0b7f49e9 | 204 | |
f1d945a1 | 205 | Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ; |
206 | cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl; | |
207 | ||
208 | fEvent = new AliFlowEventSimple(10); | |
209 | ||
210 | //Int_t fN = 256; //multiplicity for chi=1 | |
211 | Int_t fN = fNumberOfInputTracks; | |
212 | Int_t fGoodTracks = 0; | |
213 | Int_t ftrkN = 0; | |
214 | Int_t fSelParticlesDiff = 0; | |
215 | Int_t fSelParticlesInt = 0; | |
216 | ||
0b7f49e9 | 217 | |
218 | //normal loop | |
219 | while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) { | |
220 | AliMCParticle* fParticle = fInput->GetTrack(ftrkN); //get input particle | |
221 | //cut on tracks | |
222 | if (TMath::Abs(fParticle->Eta()) < 0.2) | |
223 | { | |
224 | if( | |
225 | TMath::Abs(fParticle->Particle()->GetPdgCode()) == 211 | |
226 | // TMath::Abs(fParticle->Particle()->GetPdgCode()) == 211 || | |
227 | // TMath::Abs(fParticle->Particle()->GetPdgCode()) == 321 || | |
228 | // TMath::Abs(fParticle->Particle()->GetPdgCode()) == 2212 | |
229 | ) | |
230 | { | |
231 | fTrack = new AliFlowTrackSimple() ; | |
232 | fTrack->SetPt(fParticle->Pt() ); | |
233 | fTrack->SetEta(fParticle->Eta() ); | |
234 | fTrack->SetPhi(fParticle->Phi() ); | |
235 | fTrack->SetForIntegratedFlow(kTRUE); | |
236 | fTrack->SetForDifferentialFlow(kTRUE); | |
237 | ||
238 | if (fTrack->UseForIntegratedFlow()) | |
239 | { fSelParticlesInt++; } | |
240 | if (fTrack->UseForDifferentialFlow()) | |
241 | { fSelParticlesDiff++; } | |
242 | fGoodTracks++; | |
243 | fEvent->TrackCollection()->Add(fTrack) ; | |
244 | } | |
f1d945a1 | 245 | /* else if( |
246 | TMath::Abs(fParticle->Particle()->GetPdgCode()) == 211 | |
247 | ) | |
248 | { | |
249 | fTrack = new AliFlowTrackSimple(); | |
250 | fTrack->SetPt(fParticle->Pt() ); | |
251 | fTrack->SetEta(fParticle->Eta() ); | |
252 | fTrack->SetPhi(fParticle->Phi() ); | |
253 | fTrack->SetForIntegratedFlow(kFALSE); | |
254 | fTrack->SetForDifferentialFlow(kTRUE); | |
255 | ||
256 | if (fTrack->UseForIntegratedFlow()) | |
257 | { fSelParticlesInt++; } | |
258 | if (fTrack->UseForDifferentialFlow()) | |
259 | { fSelParticlesDiff++; } | |
260 | fGoodTracks++; | |
261 | fEvent->TrackCollection()->Add(fTrack); | |
262 | } | |
263 | */ | |
0b7f49e9 | 264 | } |
f1d945a1 | 265 | |
0b7f49e9 | 266 | ftrkN++; |
f1d945a1 | 267 | } |
0b7f49e9 | 268 | |
f1d945a1 | 269 | fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt); |
270 | fEvent->SetNumberOfTracks(fGoodTracks); | |
271 | cout<<" fGoodTracks = "<<fGoodTracks<<endl; | |
272 | cout << " fSelectedTracksInt = " << fSelParticlesInt << endl; | |
273 | return fEvent; | |
274 | ||
275 | ||
276 | } | |
277 | ||
278 | ||
279 | //----------------------------------------------------------------------- | |
280 | AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput) | |
281 | { | |
282 | //Fills the event from the ESD | |
0b7f49e9 | 283 | |
f1d945a1 | 284 | Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ; |
285 | cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl; | |
286 | ||
287 | fEvent = new AliFlowEventSimple(10); | |
288 | ||
289 | //Int_t fN = 256; //multiplicity for chi=1 | |
290 | Int_t fN = fNumberOfInputTracks; | |
291 | Int_t fGoodTracks = 0; | |
292 | Int_t ftrkN = 0; | |
293 | Int_t fSelParticlesDiff = 0; | |
294 | Int_t fSelParticlesInt = 0; | |
295 | ||
296 | ||
0b7f49e9 | 297 | //normal loop |
298 | while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) { | |
299 | AliESDtrack* fParticle = fInput->GetTrack(ftrkN); //get input particle | |
300 | //cut on tracks | |
301 | if (TMath::Abs(fParticle->Eta()) < 0.2) | |
302 | { | |
303 | fTrack = new AliFlowTrackSimple() ; | |
304 | fTrack->SetPt(fParticle->Pt() ); | |
305 | fTrack->SetEta(fParticle->Eta() ); | |
306 | fTrack->SetPhi(fParticle->Phi() ); | |
307 | fTrack->SetForIntegratedFlow(kTRUE); | |
308 | fTrack->SetForDifferentialFlow(kTRUE); | |
309 | ||
310 | if (fTrack->UseForIntegratedFlow()) | |
311 | { fSelParticlesInt++; } | |
312 | if (fTrack->UseForDifferentialFlow()) | |
313 | { fSelParticlesDiff++; } | |
314 | fGoodTracks++; | |
315 | fEvent->TrackCollection()->Add(fTrack) ; | |
316 | } | |
f1d945a1 | 317 | |
0b7f49e9 | 318 | ftrkN++; |
f1d945a1 | 319 | } |
0b7f49e9 | 320 | |
f1d945a1 | 321 | fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt); |
322 | fEvent->SetNumberOfTracks(fGoodTracks); | |
323 | cout<<" fGoodTracks = "<<fGoodTracks<<endl; | |
324 | cout << " fSelectedTracksInt = " << fSelParticlesInt << endl; | |
325 | return fEvent; | |
0b7f49e9 | 326 | |
f1d945a1 | 327 | |
328 | } | |
329 | ||
330 | ||
331 | ||
332 | //----------------------------------------------------------------------- | |
333 | AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliAODEvent* fInput) | |
334 | { | |
335 | //Fills the event from the AOD | |
0b7f49e9 | 336 | |
f1d945a1 | 337 | Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ; |
338 | cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl; | |
339 | ||
340 | fEvent = new AliFlowEventSimple(10); | |
341 | ||
342 | //Int_t fN = 256; //multiplicity for chi=1 | |
343 | Int_t fN = fNumberOfInputTracks; | |
344 | Int_t fGoodTracks = 0; | |
345 | Int_t ftrkN = 0; | |
346 | Int_t fSelParticlesDiff = 0; | |
347 | Int_t fSelParticlesInt = 0; | |
348 | ||
349 | ||
0b7f49e9 | 350 | //normal loop |
351 | while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) { | |
352 | AliAODTrack* fParticle = fInput->GetTrack(ftrkN); //get input particle | |
353 | //cut on tracks | |
354 | if (TMath::Abs(fParticle->Eta()) < 0.2) | |
355 | { | |
356 | fTrack = new AliFlowTrackSimple() ; | |
357 | fTrack->SetPt(fParticle->Pt() ); | |
358 | fTrack->SetEta(fParticle->Eta() ); | |
359 | fTrack->SetPhi(fParticle->Phi() ); | |
360 | fTrack->SetForIntegratedFlow(kTRUE); | |
361 | fTrack->SetForDifferentialFlow(kTRUE); | |
362 | ||
363 | if (fTrack->UseForIntegratedFlow()) | |
364 | { fSelParticlesInt++; } | |
365 | if (fTrack->UseForDifferentialFlow()) | |
366 | { fSelParticlesDiff++; } | |
367 | fGoodTracks++; | |
368 | fEvent->TrackCollection()->Add(fTrack) ; | |
369 | } | |
f1d945a1 | 370 | |
0b7f49e9 | 371 | ftrkN++; |
372 | } | |
373 | ||
374 | fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt); | |
375 | fEvent->SetNumberOfTracks(fGoodTracks); | |
376 | cout<<" fGoodTracks = "<<fGoodTracks<<endl; | |
377 | cout << " fSelectedTracksInt = " << fSelParticlesInt << endl; | |
378 | return fEvent; | |
379 | ||
380 | } | |
381 | //----------------------------------------------------------------------- | |
382 | AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput, AliMCEvent* fInputMc, Int_t fOption) | |
383 | { | |
384 | //fills the event with tracks from the ESD and kinematics from the MC info via the track label | |
385 | ||
386 | if (!(fOption ==0 || fOption ==1)) { | |
387 | cout<<"WRONG OPTION IN AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput, AliMCEvent* fInputMc, Int_t fOption)"<<endl; | |
388 | exit(1); | |
f1d945a1 | 389 | } |
390 | ||
0b7f49e9 | 391 | Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ; |
392 | cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl; | |
393 | ||
394 | fEvent = new AliFlowEventSimple(10); | |
395 | ||
396 | //Int_t fN = 256; //multiplicity for chi=1 | |
397 | Int_t fN = fNumberOfInputTracks; | |
398 | Int_t fGoodTracks = 0; | |
399 | Int_t ftrkN = 0; | |
400 | Int_t fSelParticlesDiff = 0; | |
401 | Int_t fSelParticlesInt = 0; | |
f1d945a1 | 402 | |
0b7f49e9 | 403 | //normal loop |
404 | while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) { | |
405 | AliESDtrack* fParticle = fInput->GetTrack(ftrkN); //get input particle | |
406 | //get Label | |
407 | Int_t fLabel = fParticle->GetLabel(); | |
408 | //match to mc particle | |
409 | AliMCParticle* fMcParticle = fInputMc->GetTrack(TMath::Abs(fLabel)); | |
410 | ||
411 | //check | |
412 | if (TMath::Abs(fParticle->GetLabel())!=fMcParticle->Label()) cout<<"fParticle->GetLabel()!=fMcParticle->Label() "<<fParticle->GetLabel()<<" "<<fMcParticle->Label()<<endl; | |
413 | ||
414 | //cut on tracks | |
415 | if (TMath::Abs(fParticle->Eta()) < 0.2) | |
416 | { | |
417 | if( | |
418 | TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 211 //pions | |
419 | // TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 211 || | |
420 | // TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 321 || | |
421 | // TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 2212 | |
422 | ) | |
423 | { | |
424 | if(fOption == 0) { //take the PID from the MC & the kinematics from the ESD | |
425 | fTrack = new AliFlowTrackSimple() ; | |
426 | fTrack->SetPt(fParticle->Pt() ); | |
427 | fTrack->SetEta(fParticle->Eta() ); | |
428 | fTrack->SetPhi(fParticle->Phi() ); | |
429 | fTrack->SetForIntegratedFlow(kTRUE); | |
430 | fTrack->SetForDifferentialFlow(kTRUE); | |
431 | } | |
432 | else if (fOption == 1) { //take the PID and kinematics from the MC | |
433 | fTrack = new AliFlowTrackSimple() ; | |
434 | fTrack->SetPt(fMcParticle->Pt() ); | |
435 | fTrack->SetEta(fMcParticle->Eta() ); | |
436 | fTrack->SetPhi(fMcParticle->Phi() ); | |
437 | fTrack->SetForIntegratedFlow(kTRUE); | |
438 | fTrack->SetForDifferentialFlow(kTRUE); | |
439 | } | |
440 | else { cout<<"Not a valid option"<<endl; } | |
441 | if (fTrack->UseForIntegratedFlow()) | |
442 | { fSelParticlesInt++; } | |
443 | if (fTrack->UseForDifferentialFlow()) | |
444 | { fSelParticlesDiff++; } | |
445 | fGoodTracks++; | |
446 | fEvent->TrackCollection()->Add(fTrack) ; | |
447 | } | |
448 | } | |
449 | ftrkN++; | |
450 | } | |
451 | ||
f1d945a1 | 452 | fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt); |
453 | fEvent->SetNumberOfTracks(fGoodTracks); | |
454 | cout<<" fGoodTracks = "<<fGoodTracks<<endl; | |
455 | cout << " fSelectedTracksInt = " << fSelParticlesInt << endl; | |
456 | return fEvent; | |
457 | ||
0b7f49e9 | 458 | |
f1d945a1 | 459 | } |
460 | ||
0b7f49e9 | 461 | |
462 | ||
f1d945a1 | 463 | /* |
464 | $Log$ | |
465 | */ | |
466 |