]>
Commit | Line | Data |
---|---|---|
c7ffd78f | 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 | ||
16 | /* $Id$ */ | |
17 | ||
a5556ea5 | 18 | //_________________________________________________________________________ |
19 | /////////////////////////////////////////////////////////////////////////// | |
20 | // | |
21 | // class AliReader | |
22 | // | |
e6b229c6 | 23 | // Reader Base class |
24 | // Reads particles and tracks and | |
25 | // puts them to the AliAOD objects and eventually, if needed, buffers AliAODs in AliAODRun(s) | |
26 | // | |
27 | // User loops over events calling method Next. In case of success this method returns 0. | |
28 | // In case of error or if there is no more events to read, non-0 value is returned | |
29 | // | |
30 | // Reading can be rewound to the beginning using method Rewind. | |
31 | // | |
32 | // Tracks are read to the fEventRec (contains reconstructed tracks) | |
33 | // and fEventSim (corresponding MC simulated data) data members, | |
34 | // that are of the type AliAOD. | |
35 | // | |
36 | // If a given reader has ability of reading both, reconstructed and simulated data, | |
37 | // these are structured in AODs so a "n'th" simulated particle | |
38 | // (the one stored in the fEventSim at slot n) | |
39 | // corresponds to the n'th reconstructed track (the one stored in the fEventRec at slot n). | |
40 | // | |
41 | // The same reconstructed track can be present more than ones in the AOD, | |
42 | // but with a different PID. In this case | |
43 | // pointer to the corresponding MC simulated particles is also present more than ones. | |
44 | // This situation happens if you want to read all particles | |
45 | // with PID probability of being , e.g., pion higher than 60% | |
46 | // and being kaon higher than 40%. Than, if a given track has probability Ppid(pi)=52% and Ppid(K)=48% | |
47 | // than it is read twise. | |
a5556ea5 | 48 | // |
49 | // Provides functionality for both buffering and non-buffering reading | |
50 | // This can be switched on/off via method SetEventBuffering(bool) | |
51 | // The main method that inheriting classes need to implement is ReadNext() | |
52 | // that read next event in queue. | |
e6b229c6 | 53 | // |
a5556ea5 | 54 | // The others are: |
55 | // Bool_t ReadsRec() const; specifies if reader is able to read simulated particles | |
56 | // Bool_t ReadsSim() const; specifies if reader is able to read reconstructed tracks | |
57 | // void Rewind(); rewind reading to the beginning | |
58 | // | |
a5556ea5 | 59 | // This class provides full functionality for reading from many sources |
e6b229c6 | 60 | // User can provide TObjArray of TObjStrings (SetDirs method or via parameter |
61 | // in the constructor) which desribes paths of directories to search data in. | |
a5556ea5 | 62 | // If none specified current directory is searched. |
e6b229c6 | 63 | // |
a5556ea5 | 64 | // Piotr.Skowronski@cern.ch |
e6b229c6 | 65 | // |
a5556ea5 | 66 | /////////////////////////////////////////////////////////////////////////// |
67 | ||
a5556ea5 | 68 | #include <TClass.h> |
b002433a | 69 | #include <TGliteXmlEventlist.h> |
c7ffd78f | 70 | #include <TH1.h> |
71 | #include <TObjArray.h> | |
72 | #include <TObjString.h> | |
73 | #include <TRandom.h> | |
74 | #include <TString.h> | |
b002433a | 75 | |
a5556ea5 | 76 | #include "AliAOD.h" |
c7ffd78f | 77 | #include "AliAODParticleCut.h" |
a5556ea5 | 78 | #include "AliAODRun.h" |
c7ffd78f | 79 | #include "AliLog.h" |
80 | #include "AliReader.h" | |
a5556ea5 | 81 | |
82 | ClassImp(AliReader) | |
83 | //pure virtual | |
84 | ||
85 | /*************************************************************************************/ | |
86 | ||
87 | AliReader::AliReader(): | |
b002433a | 88 | fEventList(0x0), |
a5556ea5 | 89 | fCuts(new TObjArray()), |
90 | fDirs(0x0), | |
91 | fCurrentEvent(0), | |
92 | fCurrentDir(0), | |
93 | fNEventsRead(0), | |
94 | fEventRec(0x0), | |
95 | fEventSim(0x0), | |
96 | fRunSim(0x0), | |
97 | fRunRec(0x0), | |
98 | fIsRead(kFALSE), | |
99 | fBufferEvents(kFALSE), | |
100 | fBlend(kFALSE), | |
101 | fFirst(0), | |
102 | fLast(0), | |
103 | fTrackCounter(0x0) | |
104 | { | |
105 | //constructor | |
106 | } | |
107 | /*************************************************************************************/ | |
108 | ||
109 | AliReader::AliReader(TObjArray* dirs): | |
b002433a | 110 | fEventList(0x0), |
a5556ea5 | 111 | fCuts(new TObjArray()), |
112 | fDirs(dirs), | |
113 | fCurrentEvent(0), | |
114 | fCurrentDir(0), | |
115 | fNEventsRead(0), | |
116 | fEventRec(0x0), | |
117 | fEventSim(0x0), | |
118 | fRunSim(0x0), | |
119 | fRunRec(0x0), | |
120 | fIsRead(kFALSE), | |
121 | fBufferEvents(kFALSE), | |
122 | fBlend(kFALSE), | |
123 | fFirst(0), | |
124 | fLast(0), | |
125 | fTrackCounter(0x0) | |
126 | { | |
127 | //ctor with array of directories to read as parameter | |
128 | } | |
129 | /*************************************************************************************/ | |
130 | AliReader::AliReader(const AliReader& in): | |
131 | TNamed(in), | |
b002433a | 132 | fEventList((in.fEventList)?(TGliteXmlEventlist*)in.fEventList->Clone():0x0), |
a5556ea5 | 133 | fCuts((in.fCuts)?(TObjArray*)in.fCuts->Clone():0x0), |
134 | fDirs((in.fDirs)?(TObjArray*)in.fDirs->Clone():0x0), | |
135 | fCurrentEvent(0), | |
136 | fCurrentDir(0), | |
137 | fNEventsRead(0), | |
138 | fEventRec(0x0), | |
139 | fEventSim(0x0), | |
140 | fRunSim(0x0), | |
141 | fRunRec(0x0), | |
142 | fIsRead(kFALSE), | |
143 | fBufferEvents(in.fBufferEvents), | |
144 | fBlend(in.fBlend), | |
145 | fFirst(in.fFirst), | |
146 | fLast(in.fLast), | |
147 | fTrackCounter(0x0) | |
148 | { | |
149 | //cpy constructor | |
150 | } | |
151 | ||
152 | AliReader::~AliReader() | |
153 | { | |
154 | //destructor | |
155 | if(fCuts) | |
156 | { | |
157 | fCuts->SetOwner(); | |
158 | delete fCuts; | |
159 | } | |
160 | delete fEventSim; | |
161 | delete fEventRec; | |
162 | delete fTrackCounter; | |
b002433a | 163 | delete fEventList; |
a5556ea5 | 164 | } |
165 | /*************************************************************************************/ | |
166 | ||
167 | AliReader& AliReader::operator=(const AliReader& in) | |
168 | { | |
169 | //Assigment operator | |
170 | if (this == &in) return *this; | |
171 | TNamed::operator=( (const TNamed&)in ); | |
172 | ||
173 | fCuts = (in.fCuts)?(TObjArray*)in.fCuts->Clone():0x0; | |
174 | fDirs = (in.fDirs)?(TObjArray*)in.fDirs->Clone():0x0; | |
175 | fCurrentEvent = 0; | |
176 | fCurrentDir = 0; | |
177 | fNEventsRead = 0; | |
178 | fEventRec = 0x0; | |
179 | fEventSim = 0x0; | |
180 | fRunSim = 0x0; | |
181 | fRunRec = 0x0; | |
182 | fIsRead = kFALSE; | |
183 | fBufferEvents = in.fBufferEvents; | |
184 | fBlend = in.fBlend; | |
185 | fFirst = in.fFirst; | |
186 | fLast = in.fLast; | |
187 | fTrackCounter = 0x0; | |
188 | return *this; | |
189 | } | |
190 | /*************************************************************************************/ | |
191 | ||
192 | Int_t AliReader::Next() | |
193 | { | |
194 | //moves to next event | |
195 | ||
196 | //if asked to read up to event nb. fLast, and it is overcome, report no more events | |
a83e8bd7 | 197 | if ((fNEventsRead >= fLast) && (fLast > 0) ) return kTRUE; |
a5556ea5 | 198 | |
199 | if (fTrackCounter == 0x0)//create Track Counter | |
200 | { | |
201 | fTrackCounter = new TH1I("trackcounter","Track Counter",20000,0,20000); | |
202 | fTrackCounter->SetDirectory(0x0); | |
203 | } | |
204 | ||
205 | do //if asked to read from event fFirst, rewind to it | |
206 | { | |
207 | if ( ReadNext() == kTRUE) //if no more evets, return it | |
208 | return kTRUE; | |
209 | }while (fNEventsRead < fFirst); | |
210 | ||
211 | //here we have event | |
212 | ||
213 | if (fBlend) Blend();//Mix particles order | |
214 | ||
215 | if (fBufferEvents)//store events if buffering is on | |
216 | { | |
217 | if ( ReadsRec() && fEventRec) | |
218 | fRunRec->SetEvent(fNEventsRead-1-fFirst,fEventRec); | |
219 | if ( ReadsSim() && fEventSim) | |
220 | fRunSim->SetEvent(fNEventsRead-1-fFirst,fEventSim); | |
221 | } | |
222 | return kFALSE; | |
223 | } | |
224 | /*************************************************************************************/ | |
225 | ||
226 | void AliReader::AddParticleCut(AliAODParticleCut* cut) | |
227 | { | |
228 | //sets the new cut. MAKES A COPY OF THE CUT !!!! | |
229 | ||
230 | if (!cut) //if cut is NULL return with error | |
231 | { | |
232 | Error("AddParticleType","NULL pointers are not accepted any more.\nIf You want to accept all particles of this type, set an empty cut "); | |
233 | return; | |
234 | } | |
235 | AliAODParticleCut *c = (AliAODParticleCut*)cut->Clone(); | |
236 | fCuts->Add(c); | |
237 | } | |
238 | /********************************************************************/ | |
239 | ||
240 | AliAOD* AliReader::GetEventSim(Int_t n) | |
241 | { | |
242 | //returns Nth event with simulated particles | |
243 | if (ReadsSim() == kFALSE) | |
244 | { | |
245 | Error("GetParticleEvent","This reader is not able to provide simulated particles."); | |
246 | return 0; | |
247 | } | |
248 | ||
249 | if (!fIsRead) | |
250 | { | |
251 | if (ReadsSim() && (fRunSim == 0x0)) fRunSim = new AliAODRun(); | |
252 | if (ReadsRec() && (fRunRec == 0x0)) fRunRec = new AliAODRun(); | |
253 | ||
254 | if (Read(fRunSim,fRunRec)) | |
255 | { | |
256 | Error("GetParticleEvent","Error in reading"); | |
257 | return 0x0; | |
258 | } | |
259 | else fIsRead = kTRUE; | |
260 | } | |
261 | return fRunSim->GetEvent(n); | |
262 | } | |
263 | /********************************************************************/ | |
264 | ||
265 | AliAOD* AliReader::GetEventRec(Int_t n) | |
266 | { | |
267 | //returns Nth event with reconstructed tracks | |
268 | if (ReadsRec() == kFALSE) | |
269 | { | |
270 | Error("GetTrackEvent","This reader is not able to provide recosntructed tracks."); | |
271 | return 0; | |
272 | } | |
273 | if (!fIsRead) | |
274 | { | |
275 | if (ReadsSim() && (fRunSim == 0x0)) fRunSim = new AliAODRun(); | |
276 | if (ReadsRec() && (fRunRec == 0x0)) fRunRec = new AliAODRun(); | |
277 | ||
278 | if(Read(fRunSim,fRunRec)) | |
279 | { | |
280 | Error("GetTrackEvent","Error in reading"); | |
281 | return 0x0; | |
282 | } | |
283 | else fIsRead = kTRUE; | |
284 | } | |
285 | return fRunRec->GetEvent(n); | |
286 | } | |
287 | /********************************************************************/ | |
288 | ||
289 | Int_t AliReader::GetNumberOfSimEvents() | |
290 | { | |
291 | //returns number of events of particles | |
292 | if (ReadsSim() == kFALSE) | |
293 | { | |
294 | Error("GetNumberOfPartEvents","This reader is not able to provide simulated particles."); | |
295 | return 0; | |
296 | } | |
297 | ||
298 | if (!fIsRead) | |
299 | { | |
300 | if (ReadsSim() && (fRunSim == 0x0)) fRunSim = new AliAODRun(); | |
301 | if (ReadsRec() && (fRunRec == 0x0)) fRunRec = new AliAODRun(); | |
302 | ||
303 | if (Read(fRunSim,fRunRec)) | |
304 | { | |
305 | Error("GetNumberOfPartEvents","Error in reading"); | |
306 | return 0; | |
307 | } | |
308 | else fIsRead = kTRUE; | |
309 | } | |
310 | return fRunSim->GetNumberOfEvents(); | |
311 | } | |
312 | /********************************************************************/ | |
313 | ||
314 | Int_t AliReader::GetNumberOfRecEvents() | |
315 | { | |
316 | //returns number of events of tracks | |
317 | if (ReadsRec() == kFALSE) | |
318 | { | |
319 | Error("GetNumberOfTrackEvents","This reader is not able to provide recosntructed tracks."); | |
320 | return 0; | |
321 | } | |
322 | if (!fIsRead) | |
323 | { | |
324 | if (ReadsSim() && (fRunSim == 0x0)) fRunSim = new AliAODRun(); | |
325 | if (ReadsRec() && (fRunRec == 0x0)) fRunRec = new AliAODRun(); | |
326 | ||
327 | if(Read(fRunSim,fRunRec)) | |
328 | { | |
329 | Error("GetNumberOfTrackEvents","Error in reading"); | |
330 | return 0; | |
331 | } | |
332 | else fIsRead = kTRUE; | |
333 | } | |
334 | return fRunRec->GetNumberOfEvents(); | |
335 | } | |
336 | /********************************************************************/ | |
337 | ||
338 | Int_t AliReader::Read(AliAODRun* particles, AliAODRun *tracks) | |
339 | { | |
340 | //reads data and puts put to the particles and tracks objects | |
341 | //reurns 0 if everything is OK | |
342 | // | |
343 | Info("Read",""); | |
344 | ||
345 | if ( ReadsSim() && (particles == 0x0) ) //check if an object is instatiated | |
346 | { | |
347 | Error("Read"," particles object must be instatiated before passing it to the reader"); | |
348 | return 1; | |
349 | } | |
350 | if ( ReadsRec() && (tracks == 0x0) ) //check if an object is instatiated | |
351 | { | |
352 | Error("Read"," tracks object must be instatiated before passing it to the reader"); | |
353 | return 1; | |
354 | } | |
355 | ||
356 | if (ReadsSim()) particles->Reset();//clear runs == delete all old events | |
357 | if (ReadsRec()) tracks->Reset(); | |
358 | ||
359 | Rewind(); | |
360 | ||
361 | Int_t i = 0; | |
362 | while(Next() == kFALSE) | |
363 | { | |
364 | if (ReadsRec()) tracks->SetEvent(i,fEventRec); | |
365 | if (ReadsSim()) particles->SetEvent(i,fEventSim); | |
366 | i++; | |
367 | } | |
368 | return 0; | |
369 | } | |
370 | /*************************************************************************************/ | |
371 | ||
cea0a066 | 372 | Bool_t AliReader::Rejected(AliVAODParticle* p) |
a5556ea5 | 373 | { |
374 | //Method examines whether particle meets all cut and particle type criteria | |
375 | ||
376 | if(p==0x0)//of corse we not pass NULL pointers | |
377 | { | |
cea0a066 | 378 | Warning("Rejected()","No Pasaran! We never accept NULL pointers"); |
a5556ea5 | 379 | return kTRUE; |
380 | } | |
381 | //if no particle is specified, we pass all particles | |
382 | //excluding NULL pointers, of course | |
383 | if ( fCuts->GetEntriesFast() == 0 ) return kFALSE; //if no cut specified accept all particles | |
384 | for(Int_t i=0; i<fCuts->GetEntriesFast(); i++) | |
385 | { | |
386 | AliAODParticleCut &cut = *((AliAODParticleCut*)fCuts->At(i)); | |
cea0a066 | 387 | if(!cut.Rejected(p)) return kFALSE; //accepted |
a5556ea5 | 388 | } |
389 | ||
390 | return kTRUE;//not accepted | |
391 | } | |
392 | /*************************************************************************************/ | |
393 | ||
cea0a066 | 394 | Bool_t AliReader::Rejected(Int_t pid) |
a5556ea5 | 395 | { |
396 | //this method checks if any of existing cuts accepts this pid particles | |
397 | //or any cuts accepts all particles | |
398 | ||
399 | if(pid == 0) | |
400 | return kTRUE; | |
401 | ||
402 | if ( fCuts->GetEntriesFast() == 0 ) return kFALSE; //if no cut specified accept all particles | |
403 | ||
404 | for(Int_t i=0; i<fCuts->GetEntriesFast(); i++) | |
405 | { | |
406 | AliAODParticleCut &cut = *((AliAODParticleCut*)fCuts->At(i)); | |
407 | //if some of cuts accepts all particles or some accepts particles of this type, accept | |
408 | if ( (cut.GetPID() == 0) || (cut.GetPID() == pid) ) return kFALSE; | |
409 | } | |
410 | return kTRUE; | |
411 | } | |
412 | /*************************************************************************************/ | |
413 | ||
efdb0cc9 | 414 | TString AliReader::GetDirName(Int_t entry) |
a5556ea5 | 415 | { |
416 | //returns directory name of next one to read | |
efdb0cc9 | 417 | TString retval;//return value |
a5556ea5 | 418 | if (fDirs == 0x0) |
efdb0cc9 | 419 | { |
420 | if (entry == 0) | |
421 | { | |
422 | retval = "."; | |
423 | return retval; | |
424 | } | |
425 | else | |
426 | { | |
d9122a01 | 427 | return retval; |
efdb0cc9 | 428 | } |
a5556ea5 | 429 | } |
d9122a01 | 430 | |
431 | ||
432 | if ( (entry >= fDirs->GetEntries()) || (entry < 0))//if out of bounds return empty string | |
a5556ea5 | 433 | { //note that entry==0 is accepted even if array is empty (size=0) |
d9122a01 | 434 | if ( (fDirs->GetEntries() == 0) && (entry == 0) ) |
435 | { | |
436 | retval = "."; | |
437 | return retval; | |
438 | } | |
c7ffd78f | 439 | AliDebug(1,Form("Index %d out of bounds",entry)); |
440 | ||
efdb0cc9 | 441 | return retval; |
a5556ea5 | 442 | } |
443 | ||
a5556ea5 | 444 | |
445 | TClass *objclass = fDirs->At(entry)->IsA(); | |
446 | TClass *stringclass = TObjString::Class(); | |
447 | ||
448 | TObjString *dir = (TObjString*)objclass->DynamicCast(stringclass,fDirs->At(entry)); | |
449 | ||
450 | if(dir == 0x0) | |
451 | { | |
452 | Error("GetDirName","Object in TObjArray is not a TObjString or its descendant"); | |
efdb0cc9 | 453 | return retval; |
a5556ea5 | 454 | } |
c7ffd78f | 455 | AliDebug(1,Form("Returned ok %s",dir->String().Data())); |
efdb0cc9 | 456 | retval = dir->String(); |
457 | return retval; | |
a5556ea5 | 458 | } |
459 | /*************************************************************************************/ | |
460 | ||
461 | void AliReader::Blend() | |
462 | { | |
463 | //randomly change positions of the particles after reading | |
464 | //is used to check if some distributions (of many particle properties) | |
465 | //depend on the order of particles | |
466 | //(tracking gives particles Pt sorted) | |
d9122a01 | 467 | Int_t npart = 0; |
468 | ||
469 | if (fEventSim ) | |
470 | { | |
471 | npart = fEventSim->GetNumberOfParticles(); | |
472 | } | |
473 | else | |
474 | if (fEventRec ) | |
475 | { | |
476 | npart = fEventRec->GetNumberOfParticles(); | |
477 | } | |
478 | else | |
479 | { | |
480 | return; | |
481 | } | |
482 | for (Int_t i = 2; i < npart; i++) | |
a5556ea5 | 483 | { |
484 | Int_t with = gRandom->Integer(i); | |
d9122a01 | 485 | // Info("Blend","%d %d",i, with); |
486 | if (fEventSim) fEventSim->SwapParticles(i,with); | |
a5556ea5 | 487 | if (fEventRec) fEventRec->SwapParticles(i,with); |
488 | } | |
489 | } | |
490 | /*************************************************************************************/ | |
491 | ||
492 | void AliReader::WriteTrackCounter() const | |
493 | { | |
494 | //writes the counter histogram | |
495 | ||
496 | if (fTrackCounter) fTrackCounter->Write(0,TObject::kOverwrite); | |
497 | else | |
498 | { | |
499 | Warning("WriteTrackCounter","Counter is NULL"); | |
500 | } | |
501 | } |