]>
Commit | Line | Data |
---|---|---|
83974468 | 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 | ||
18 | //_________________________________________________________________________ | |
f035f6ce | 19 | // A singleton. This class should be used on the analysiz stage to get |
20 | // reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles, | |
21 | // instead of direct reading them from galice.root file. This container | |
22 | // ensures, that one reads Digits, made of these particular digits RecPoints, | |
23 | // made of these particlar RecPoints TrackSegments and RecParticles, what is | |
24 | // not trivial if there are several identical branches, but produced with | |
25 | // different set of parameters. | |
26 | // | |
27 | // An example of use (see as well class AliPHOSAnalyser): | |
28 | // AliPHOSIndexToObject * please = AliPHOSIndexToObject::GetInstance("galice.root","RecParticles","") ; | |
29 | // for(Int_t irecp = 0; irecp < please->GimeNRecParticles() ; irecp++) | |
30 | // AliPHOSRecParticle * part = please->GimeRecParticle(1) ; | |
31 | // ................ | |
32 | // please->GetEvent(event) ; // reads new event from galice.root | |
83974468 | 33 | // |
3e3852a0 | 34 | //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH) |
f035f6ce | 35 | //*-- Complitely redesigned by Dmitri Peressounko March 2001 |
83974468 | 36 | ////////////////////////////////////////////////////////////////////////////// |
37 | ||
ed4205d8 | 38 | |
83974468 | 39 | // --- ROOT system --- |
40 | ||
3e3852a0 | 41 | #include "TFile.h" |
94de3818 | 42 | #include "TTree.h" |
3e3852a0 | 43 | #include "TROOT.h" |
44 | #include "TObjString.h" | |
94de3818 | 45 | |
83974468 | 46 | // --- Standard library --- |
3e3852a0 | 47 | #include <iostream.h> |
83974468 | 48 | |
49 | // --- AliRoot header files --- | |
50 | ||
3e3852a0 | 51 | #include "AliRun.h" |
83974468 | 52 | #include "AliPHOSIndexToObject.h" |
3e3852a0 | 53 | #include "AliPHOSDigitizer.h" |
54 | #include "AliPHOSClusterizer.h" | |
55 | #include "AliPHOSTrackSegmentMaker.h" | |
56 | #include "AliPHOSPID.h" | |
83974468 | 57 | |
58 | ClassImp(AliPHOSIndexToObject) | |
59 | ||
88714635 | 60 | AliPHOSIndexToObject * AliPHOSIndexToObject::fgObjGetter = 0 ; |
83974468 | 61 | |
62 | //____________________________________________________________________________ | |
3e3852a0 | 63 | AliPHOSIndexToObject::AliPHOSIndexToObject(char* headerFile,char* branch,char* branchTitle ) |
83974468 | 64 | { |
3e3852a0 | 65 | //Initiate all lists |
66 | fEvent = 0 ; | |
67 | ||
68 | fDigits = new TClonesArray("AliPHOSDigit",100) ; | |
69 | fEmcRecPoints = new TObjArray(100) ; | |
70 | fCpvRecPoints = new TObjArray(100) ; | |
71 | fTS = new TClonesArray("AliPHOSTrackSegment",100) ; | |
72 | fRecParticles = new TClonesArray("AliPHOSRecParticle",100) ; | |
73 | fPrimaries = new TObjArray(1) ; | |
74 | ||
75 | fDigitizer = 0 ; | |
76 | fClusterizer = 0 ; | |
77 | fTSMaker = 0 ; | |
78 | fPID = 0 ; | |
79 | ||
80 | //open headers file | |
81 | fHeaderFile = headerFile ; | |
82 | TFile * file = (TFile*) gROOT->GetFile(fHeaderFile.Data() ) ; | |
83 | ||
84 | if(file == 0){ | |
f035f6ce | 85 | if(fHeaderFile.Contains("rfio")) // if we read file using HPSS |
86 | file = TFile::Open(fHeaderFile.Data(),"update") ; | |
87 | else | |
88 | file = new TFile(fHeaderFile.Data(),"update") ; | |
3e3852a0 | 89 | gAlice = (AliRun *) file->Get("gAlice") ; |
90 | } | |
91 | ||
92 | fMaxEvent = (Int_t) gAlice->TreeE()->GetEntries() ; | |
93 | ||
94 | char * dummyfile = 0 ; | |
95 | ||
96 | gAlice->GetEvent(fEvent) ; | |
97 | ||
98 | Bool_t isRead = kFALSE; | |
99 | //now read branches | |
100 | if((strcmp(branch,"PHOSRP")==0) || (strcmp(branch,"PHOSPID")==0)){ | |
101 | ReadRecParticles(branchTitle) ; //first read RecPartcles and branche TS from which they are made | |
102 | ReadTS(dummyfile); //read TS from which made RecParticles above | |
103 | ReadRecPoints(dummyfile) ; //RecPoints from which TS above made | |
104 | ReadDigits(dummyfile) ; //digits. from whic RecPoints made | |
105 | isRead= kTRUE ; | |
106 | } | |
107 | ||
108 | if((strcmp(branch,"PHOSTS")==0) || (strcmp(branch,"PHOSTSMaker")==0)){ | |
109 | ReadTS(branchTitle); //read TS and branch of RecPoints from which they are made | |
110 | ReadRecPoints(dummyfile) ; //recpoints abd branch of digits | |
111 | ReadDigits(dummyfile) ; //digits and branch of Primaries | |
112 | ReadRecParticles(dummyfile) ; //posiible completion of TS | |
113 | isRead= kTRUE ; | |
114 | } | |
115 | ||
116 | if((strcmp(branch,"PHOSEmcRP")==0)|| (strcmp(branch,"PHOSCpvRP")==0) || | |
117 | (strcmp(branch,"PHOSClusterizer")==0)){ | |
118 | ReadRecPoints(branchTitle) ; //RecPoints and Digits branch filename | |
119 | ReadDigits(dummyfile) ; //digits and primary file name | |
120 | ReadTS(dummyfile); //possible completion of RecPoints | |
121 | ReadRecParticles(dummyfile) ; //possible completion of TS | |
122 | isRead= kTRUE ; | |
123 | } | |
124 | ||
125 | if((strcmp(branch,"PHOS")==0) || (strcmp(branch,"PHOSDigitizer")==0)){ | |
126 | ReadDigits(branchTitle) ; | |
127 | ReadRecPoints(dummyfile) ; | |
128 | ReadTS(dummyfile); | |
129 | ReadRecParticles(dummyfile) ; | |
130 | isRead= kTRUE ; | |
131 | } | |
132 | ||
133 | if(!isRead){ | |
134 | cout << "AliPHOSIndexToObject: wrong branch name specified: " << branch << endl ; | |
135 | cout << " avalilable names are `PHOSRP', `PHOSPID'"<<endl ; | |
136 | cout << " `PHOSTS', `PHOSTSMaker'"<<endl ; | |
137 | cout << " `PHOSEmcRP', `PHOSCpvRP', `PHOSClusterizer'"<< endl ; | |
138 | cout << " `PHOS' and `PHOSDigitizer'"<< endl ; | |
139 | } | |
140 | ReadPrimaries() ; // should be called when digits are already read | |
83974468 | 141 | |
83974468 | 142 | } |
83974468 | 143 | //____________________________________________________________________________ |
144 | AliPHOSIndexToObject * AliPHOSIndexToObject::GetInstance() | |
145 | { | |
146 | // Returns the pointer of the unique instance already defined | |
147 | ||
148 | AliPHOSIndexToObject * rv = 0 ; | |
88714635 | 149 | if ( fgObjGetter ) |
150 | rv = fgObjGetter ; | |
83974468 | 151 | else |
152 | cout << "AliPHOSIndexToObject::GetInstance ERROR: not yet initialized" << endl ; | |
3e3852a0 | 153 | |
83974468 | 154 | return rv ; |
155 | } | |
156 | ||
157 | //____________________________________________________________________________ | |
3e3852a0 | 158 | AliPHOSIndexToObject * AliPHOSIndexToObject::GetInstance(char* headerFile,char* branch,char* branchTitle) |
83974468 | 159 | { |
160 | // Creates and returns the pointer of the unique instance | |
3e3852a0 | 161 | // Must be called only when the environment has changed |
83974468 | 162 | |
88714635 | 163 | if ( fgObjGetter ) // delete it if already exists |
164 | delete fgObjGetter ; | |
83974468 | 165 | |
3e3852a0 | 166 | fgObjGetter = new AliPHOSIndexToObject(headerFile,branch,branchTitle) ; |
83974468 | 167 | |
88714635 | 168 | return fgObjGetter ; |
83974468 | 169 | |
170 | } | |
171 | ||
172 | //____________________________________________________________________________ | |
3e3852a0 | 173 | TParticle * AliPHOSIndexToObject::GimePrimary(Int_t index) |
83974468 | 174 | { |
3e3852a0 | 175 | |
176 | ||
177 | Int_t primaryList = (Int_t) (TMath::Ceil(index/10000000.) ) - 1 ; | |
178 | Int_t primaryIndex = index - primaryList*10000000 ; | |
179 | ||
180 | if ( primaryList > 0 ) { | |
181 | cout << " IndexToObject does not support currently Mixing of primary " << endl ; | |
182 | cout << " can not return primary: " << index<< " (list "<< primaryList<< " primary # " << primaryIndex << " )"<<endl ; | |
183 | return 0; | |
184 | } | |
185 | ||
186 | return gAlice->Particle(primaryIndex) ; | |
83974468 | 187 | |
188 | } | |
83974468 | 189 | |
3e3852a0 | 190 | //____________________________________________________________________________ |
191 | Bool_t AliPHOSIndexToObject::ReadRecParticles(char * branchTitle){ | |
83974468 | 192 | |
3e3852a0 | 193 | if(gAlice->TreeR()==0) |
194 | return kFALSE ; | |
83974468 | 195 | |
3e3852a0 | 196 | if(fPID) // already read |
197 | branchTitle = fPID->GetRecParticlesBranch() ; | |
198 | ||
199 | ||
200 | if(branchTitle){ // we should read a specific branch | |
201 | TBranch * pidBranch = 0; | |
202 | TBranch * rpBranch = 0; | |
203 | ||
204 | TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ; | |
205 | Int_t ibranch; | |
206 | Bool_t pidNotFound = kTRUE ; | |
207 | Bool_t rpNotFound = kTRUE ; | |
208 | ||
209 | for(ibranch = 0;(ibranch <branches->GetEntries())&&(pidNotFound||rpNotFound);ibranch++){ | |
210 | ||
211 | if(pidNotFound){ | |
212 | pidBranch=(TBranch *) branches->At(ibranch) ; | |
213 | if( (strcmp(branchTitle,pidBranch->GetTitle())==0 ) && | |
214 | (strcmp(pidBranch->GetName(),"AliPHOSPID") == 0) ) | |
215 | pidNotFound = kFALSE ; | |
216 | } | |
217 | if(rpNotFound){ | |
218 | rpBranch=(TBranch *) branches->At(ibranch) ; | |
219 | if( (strcmp(branchTitle,rpBranch->GetTitle())==0 ) && | |
220 | (strcmp(rpBranch->GetName(),"PHOSRP") == 0) ) | |
221 | rpNotFound = kFALSE ; | |
222 | } | |
223 | } | |
224 | ||
225 | if(pidNotFound ||rpNotFound ){ | |
226 | cout << "AliPHOSIndexToObject error" << endl ; | |
227 | cout << " Can't find Branch with PID and RecParticles " ; | |
228 | return kFALSE ; | |
229 | } | |
230 | ||
231 | pidBranch->SetAddress(&fPID) ; | |
232 | rpBranch->SetAddress(&fRecParticles) ; | |
233 | gAlice->TreeR()->GetEvent(0) ; | |
234 | } | |
235 | else{ //we Should read any branch and print warning if there are other possibilities | |
236 | if(fTSMaker){//if TrackSegments already read, we should read RecParticles Made from it | |
237 | TBranch * pidBranch = 0; | |
238 | TBranch * rpBranch = 0; | |
239 | ||
240 | TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ; | |
241 | ||
242 | Int_t branchRead = 0; | |
243 | Bool_t allNotFound = kTRUE ; | |
244 | while(allNotFound){ | |
245 | Bool_t pidNotFound = kTRUE ; | |
246 | Bool_t rpNotFound = kTRUE ; | |
247 | Int_t ibranch ; | |
248 | for(ibranch = branchRead;(ibranch <branches->GetEntries() )&& pidNotFound;ibranch++){ | |
249 | pidBranch=(TBranch *) branches->At(ibranch) ; | |
250 | if(strcmp(pidBranch->GetName(),"AliPHOSPID") == 0) | |
251 | pidNotFound = kFALSE ; | |
252 | } | |
253 | branchRead = ibranch +1 ; | |
254 | for(ibranch = 0 ;(ibranch <branches->GetEntries() )&& rpNotFound;ibranch++){ | |
255 | rpBranch=(TBranch *) branches->At(ibranch) ; | |
256 | if( (strcmp(pidBranch->GetTitle(),rpBranch->GetTitle())==0 ) && | |
257 | (strcmp(rpBranch->GetName(),"PHOSRP") == 0) ) | |
258 | rpNotFound = kFALSE ; | |
259 | } | |
260 | ||
261 | if(pidNotFound ||rpNotFound ){ | |
262 | cout << "AliPHOSIndexToObject error" << endl ; | |
263 | cout << " Can't find Branch with PID and RecParticles " ; | |
264 | return kFALSE ; | |
265 | } | |
266 | ||
267 | pidBranch->SetAddress(&fPID) ; | |
268 | rpBranch->SetAddress(&fRecParticles) ; | |
269 | gAlice->TreeR()->GetEvent(0) ; | |
270 | ||
271 | if(strcmp(fTSMaker->GetTrackSegmentsBranch(),fPID->GetTrackSegmentsBranch()) == 0) | |
272 | allNotFound = kFALSE ; | |
273 | } | |
274 | } | |
275 | else{//we read any (first) recparticles | |
276 | TBranch * pidBranch = 0; | |
277 | TBranch * rpBranch = 0; | |
278 | TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ; | |
279 | ||
280 | Bool_t pidNotFound = kTRUE ; | |
281 | Bool_t rpNotFound = kTRUE ; | |
282 | Int_t ibranch ; | |
283 | for(ibranch = 0;(ibranch <branches->GetEntries() )&& pidNotFound;ibranch++){ | |
284 | pidBranch=(TBranch *) branches->At(ibranch) ; | |
285 | if(strcmp(pidBranch->GetName(),"AliPHOSPID") == 0) | |
286 | pidNotFound = kFALSE ; | |
287 | } | |
288 | for(ibranch = 0 ;(ibranch <branches->GetEntries() )&& rpNotFound;ibranch++){ | |
289 | rpBranch=(TBranch *) branches->At(ibranch) ; | |
290 | if( (strcmp(pidBranch->GetTitle(),rpBranch->GetTitle())==0 ) && | |
291 | (strcmp(rpBranch->GetName(),"PHOSRP") == 0) ) | |
292 | rpNotFound = kFALSE ; | |
293 | } | |
294 | ||
295 | if(pidNotFound ||rpNotFound ){ | |
296 | cout << "AliPHOSIndexToObject worning: " << endl ; | |
297 | cout << " Can't find Branch with PID and RecParticles " << endl; | |
298 | return kFALSE ; | |
299 | } | |
300 | ||
301 | pidBranch->SetAddress(&fPID) ; | |
302 | rpBranch->SetAddress(&fRecParticles) ; | |
303 | gAlice->TreeR()->GetEvent(0) ; | |
304 | ||
305 | } | |
306 | } | |
307 | return kTRUE ; | |
83974468 | 308 | } |
83974468 | 309 | //____________________________________________________________________________ |
3e3852a0 | 310 | Bool_t AliPHOSIndexToObject::ReadTS(char * branchTitle){ |
83974468 | 311 | |
3e3852a0 | 312 | if(gAlice->TreeR()==0) |
313 | return kFALSE ; | |
83974468 | 314 | |
3e3852a0 | 315 | if(fPID)//if RecParticles already read, we should read TS from which they are made |
316 | branchTitle= fPID->GetTrackSegmentsBranch() ; | |
83974468 | 317 | |
3e3852a0 | 318 | if(branchTitle){ // we should read a specific branch |
319 | ||
320 | TBranch * tsMakerBranch = 0; | |
321 | TBranch * tsBranch = 0; | |
322 | ||
323 | TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ; | |
324 | Int_t ibranch; | |
325 | Bool_t tsMakerNotFound = kTRUE ; | |
326 | Bool_t tsNotFound = kTRUE ; | |
327 | ||
328 | for(ibranch = 0;(ibranch <branches->GetEntries())&&(tsMakerNotFound||tsNotFound);ibranch++){ | |
329 | if(tsMakerNotFound){ | |
330 | tsMakerBranch=(TBranch *) branches->At(ibranch) ; | |
331 | if( strcmp(branchTitle,tsMakerBranch->GetTitle())==0 ) | |
332 | if( strcmp(tsMakerBranch->GetName(),"AliPHOSTrackSegmentMaker") == 0) | |
333 | tsMakerNotFound = kFALSE ; | |
334 | } | |
335 | if(tsNotFound){ | |
336 | tsBranch=(TBranch *) branches->At(ibranch) ; | |
337 | if( strcmp(branchTitle,tsBranch->GetTitle())==0 ) | |
338 | if( strcmp(tsBranch->GetName(),"PHOSTS") == 0) | |
339 | tsNotFound = kFALSE ; | |
340 | } | |
341 | } | |
342 | ||
343 | if(tsMakerNotFound ||tsNotFound ){ | |
344 | cout << "AliPHOSIndexToObject error" << endl ; | |
345 | cout << " Can't find Branch with TrackSegmentMaker and TrackSegments " ; | |
346 | cout << " Do nothing" <<endl ; | |
347 | return kFALSE ; | |
348 | } | |
349 | ||
350 | tsMakerBranch->SetAddress(&fTSMaker) ; | |
351 | tsBranch->SetAddress(&fTS) ; | |
352 | gAlice->TreeR()->GetEvent(0) ; | |
353 | ||
354 | } | |
355 | else{ | |
356 | if(fClusterizer){//Clusterizer aready read, | |
357 | //we should read TrackSegments made from these RecPoints | |
358 | ||
359 | Int_t branchRead = 0 ; | |
360 | TBranch * tsMakerBranch = 0; | |
361 | TBranch * tsBranch = 0; | |
362 | ||
363 | TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ; | |
364 | Int_t ibranch; | |
365 | Bool_t allNotFound = kTRUE ; | |
366 | while(allNotFound){ | |
367 | Bool_t tsMakerNotFound = kTRUE ; | |
368 | Bool_t tsNotFound = kTRUE ; | |
369 | ||
370 | for(ibranch = branchRead;(ibranch <branches->GetEntries())&&(tsMakerNotFound);ibranch++){ | |
371 | tsMakerBranch=(TBranch *) branches->At(ibranch) ; | |
372 | if( strcmp(tsMakerBranch->GetName(),"AliPHOSTrackSegmentMaker") == 0) | |
373 | tsMakerNotFound = kFALSE ; | |
374 | } | |
375 | branchRead = ibranch++ ; | |
376 | for(ibranch = 0 ;(ibranch <branches->GetEntries())&&(tsNotFound);ibranch++){ | |
377 | tsBranch=(TBranch *) branches->At(ibranch) ; | |
378 | if( (strcmp(tsBranch->GetName(),"PHOSTS") == 0) && | |
379 | (strcmp(tsBranch->GetName(),tsMakerBranch->GetTitle())==0)) | |
380 | tsNotFound = kFALSE ; | |
381 | } | |
382 | ||
383 | branchRead = ibranch++ ; | |
384 | ||
385 | if(tsMakerNotFound ||tsNotFound ){ | |
386 | cout << "AliPHOSIndexToObject error" << endl ; | |
387 | cout << " Can't find Branch with TrackSegmentMaker and TrackSegments " ; | |
388 | cout << " Do nothing" <<endl ; | |
389 | return kFALSE ; | |
390 | } | |
391 | ||
392 | tsMakerBranch->SetAddress(&fTSMaker) ; | |
393 | tsBranch->SetAddress(&fTS) ; | |
394 | gAlice->TreeR()->GetEvent(0) ; | |
395 | ||
396 | if(strcmp(fTSMaker->GetRecPointsBranch(),fClusterizer->GetRecPointsBranch()) == 0) | |
397 | allNotFound = kFALSE ; | |
398 | } | |
399 | ||
400 | } | |
401 | else{//Neither Title,neither fPID, neither fClusterizer: we read any (first) occurence | |
402 | TBranch * tsMakerBranch = 0; | |
403 | TBranch * tsBranch = 0; | |
404 | TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ; | |
405 | Bool_t tsMakerNotFound = kTRUE ; | |
406 | Bool_t tsNotFound = kTRUE ; | |
407 | Int_t ibranch ; | |
408 | for(ibranch = 0;(ibranch <branches->GetEntries())&& tsMakerNotFound;ibranch++){ | |
409 | tsMakerBranch=(TBranch *) branches->At(ibranch) ; | |
410 | if( strcmp(tsMakerBranch->GetName(),"AliPHOSTrackSegmentMaker") == 0) | |
411 | tsMakerNotFound = kFALSE ; | |
412 | } | |
413 | for(ibranch = 0 ;(ibranch <branches->GetEntries())&&(tsNotFound);ibranch++){ | |
414 | tsBranch=(TBranch *) branches->At(ibranch) ; | |
415 | if( (strcmp(tsBranch->GetName(),"PHOSTS") == 0) && | |
416 | (strcmp(tsBranch->GetName(),tsMakerBranch->GetTitle())==0)) | |
417 | tsNotFound = kFALSE ; | |
418 | } | |
419 | if(tsMakerNotFound ||tsNotFound ){ | |
420 | cout << "AliPHOSIndexToObject error" << endl ; | |
421 | cout << " Can't find Branch with TrackSegmentMaker and TrackSegments " ; | |
422 | cout << " Do nothing" <<endl ; | |
423 | return kFALSE ; | |
424 | } | |
425 | ||
426 | tsMakerBranch->SetAddress(&fTSMaker) ; | |
427 | tsBranch->SetAddress(&fTS) ; | |
428 | gAlice->TreeR()->GetEvent(0) ; | |
429 | } | |
430 | } | |
431 | ||
432 | return kTRUE ; | |
83974468 | 433 | } |
83974468 | 434 | //____________________________________________________________________________ |
3e3852a0 | 435 | Bool_t AliPHOSIndexToObject::ReadRecPoints(char * branchTitle){ |
83974468 | 436 | |
3e3852a0 | 437 | if(gAlice->TreeR() == 0) |
438 | return kFALSE ; | |
439 | ||
440 | if(fTSMaker) //if TrackSegment maker already read, read corresponding branches | |
441 | branchTitle = fTSMaker->GetRecPointsBranch() ; | |
442 | ||
443 | if(branchTitle){ // we should read a specific branch | |
444 | TBranch * emcBranch = 0; | |
445 | TBranch * cpvBranch = 0; | |
446 | TBranch * clusterizerBranch = 0; | |
447 | ||
448 | TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ; | |
449 | Int_t ibranch; | |
450 | Bool_t emcNotFound = kTRUE ; | |
451 | Bool_t cpvNotFound = kTRUE ; | |
452 | Bool_t clusterizerNotFound = kTRUE ; | |
453 | ||
454 | for(ibranch = 0;((ibranch < branches->GetEntries())&&(emcNotFound ||cpvNotFound || clusterizerNotFound)) ;ibranch++){ | |
455 | if(emcNotFound){ | |
456 | emcBranch=(TBranch *) branches->At(ibranch) ; | |
457 | if( (strcmp(emcBranch->GetTitle(),branchTitle) == 0) && | |
458 | (strcmp(emcBranch->GetName(),"PHOSEmcRP") == 0) ) | |
459 | emcNotFound = kFALSE ; | |
460 | } | |
461 | if(cpvNotFound){ | |
462 | cpvBranch=(TBranch *) branches->At(ibranch) ; | |
463 | if( (strcmp(cpvBranch->GetTitle(),branchTitle) == 0) && | |
464 | (strcmp(cpvBranch->GetName(),"PHOSCpvRP") == 0) ) | |
465 | cpvNotFound = kFALSE ; | |
466 | } | |
467 | if(clusterizerNotFound){ | |
468 | clusterizerBranch = (TBranch *) branches->At(ibranch) ; | |
469 | if( (strcmp(clusterizerBranch->GetTitle(),branchTitle) == 0) && | |
470 | (strcmp(clusterizerBranch->GetName(),"AliPHOSClusterizer") == 0) ) | |
471 | clusterizerNotFound = kFALSE ; | |
472 | } | |
473 | ||
474 | } | |
475 | ||
476 | if(clusterizerNotFound || emcNotFound || cpvNotFound){ | |
477 | cout << "AliPHOSIndexToObject error" << endl ; | |
478 | cout << " Can't find Branch with RecPoints or Clusterizer " << endl ; | |
479 | return kFALSE ; | |
480 | } | |
481 | ||
482 | emcBranch->SetAddress(&fEmcRecPoints) ; | |
483 | cpvBranch->SetAddress(&fCpvRecPoints) ; | |
484 | clusterizerBranch->SetAddress(&fClusterizer) ; | |
485 | gAlice->TreeR()->GetEvent(0) ; | |
486 | } | |
487 | else{ //no specific branch | |
488 | if(fDigitizer){//Digitizer aready read, | |
489 | //we should read RecPoints made from these Digits | |
490 | TBranch * emcBranch = 0; | |
491 | TBranch * cpvBranch = 0; | |
492 | TBranch * clusterizerBranch = 0; | |
493 | ||
494 | TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ; | |
495 | Int_t branchRead = 0; | |
496 | Bool_t allNotFound = kTRUE ; | |
497 | while(allNotFound){ | |
498 | Bool_t emcNotFound = kTRUE ; | |
499 | Bool_t cpvNotFound = kTRUE ; | |
500 | Bool_t clusterizerNotFound = kTRUE ; | |
501 | Int_t ibranch ; | |
502 | for(ibranch = branchRead;ibranch < branches->GetEntries();ibranch++){ | |
503 | emcBranch=(TBranch *) branches->At(ibranch) ; | |
504 | if( strcmp(emcBranch->GetName(),"PHOSEmcRP") == 0) | |
505 | emcNotFound = kFALSE ; | |
506 | } | |
507 | branchRead = ibranch + 1 ; | |
508 | for(ibranch = 0 ;ibranch < branches->GetEntries();ibranch++){ | |
509 | cpvBranch=(TBranch *) branches->At(ibranch) ; | |
510 | if( (strcmp(cpvBranch->GetTitle(),emcBranch->GetTitle()) == 0) && | |
511 | (strcmp(cpvBranch->GetName(),"PHOSCpvRP") == 0) ) | |
512 | cpvNotFound = kFALSE ; | |
513 | } | |
514 | for(ibranch = 0 ;ibranch < branches->GetEntries();ibranch++){ | |
515 | clusterizerBranch = (TBranch *) branches->At(ibranch) ; | |
516 | if( (strcmp(clusterizerBranch->GetTitle(),emcBranch->GetTitle()) == 0) && | |
517 | (strcmp(clusterizerBranch->GetName(),"AliPHOSClusterizer") == 0) ) | |
518 | clusterizerNotFound = kFALSE ; | |
519 | } | |
520 | ||
521 | if(clusterizerNotFound || emcNotFound || cpvNotFound){ | |
522 | cout << "AliPHOSIndexToObject error" << endl ; | |
523 | cout << " Can't find Branch with RecPoints or Clusterizer " << endl ; | |
524 | return kFALSE ; | |
525 | } | |
526 | ||
527 | emcBranch->SetAddress(&fEmcRecPoints) ; | |
528 | cpvBranch->SetAddress(&fCpvRecPoints) ; | |
529 | clusterizerBranch->SetAddress(&fClusterizer) ; | |
530 | gAlice->TreeR()->GetEvent(0) ; | |
531 | ||
532 | if(strcmp(fClusterizer->GetDigitsBranch(),fDigitizer->GetDigitsBranch())== 0) | |
533 | allNotFound = kFALSE ; | |
534 | } | |
535 | } | |
536 | else{//Neither Title, Neither TSMaker, Neither Digits: we read any (first) RecPoints | |
537 | TBranch * emcBranch = 0; | |
538 | TBranch * cpvBranch = 0; | |
539 | TBranch * clusterizerBranch = 0; | |
540 | TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ; | |
541 | Bool_t emcNotFound = kTRUE ; | |
542 | Bool_t cpvNotFound = kTRUE ; | |
543 | Bool_t clusterizerNotFound = kTRUE ; | |
544 | Int_t ibranch ; | |
545 | for(ibranch = 0 ;ibranch < branches->GetEntries();ibranch++){ | |
546 | emcBranch=(TBranch *) branches->At(ibranch) ; | |
547 | if( strcmp(emcBranch->GetName(),"PHOSEmcRP") == 0) | |
548 | emcNotFound = kFALSE ; | |
549 | } | |
550 | for(ibranch = 0 ;ibranch < branches->GetEntries();ibranch++){ | |
551 | cpvBranch=(TBranch *) branches->At(ibranch) ; | |
552 | if( (strcmp(cpvBranch->GetTitle(),emcBranch->GetTitle()) == 0) && | |
553 | (strcmp(cpvBranch->GetName(),"PHOSCpvRP") == 0) ) | |
554 | cpvNotFound = kFALSE ; | |
555 | } | |
556 | for(ibranch = 0;ibranch < branches->GetEntries();ibranch++){ | |
557 | clusterizerBranch = (TBranch *) branches->At(ibranch) ; | |
558 | if( (strcmp(clusterizerBranch->GetTitle(),emcBranch->GetTitle()) == 0) && | |
559 | (strcmp(clusterizerBranch->GetName(),"AliPHOSClusterizer") == 0) ) | |
560 | clusterizerNotFound = kFALSE ; | |
561 | } | |
562 | ||
563 | if(clusterizerNotFound || emcNotFound || cpvNotFound){ | |
564 | cout << "AliPHOSIndexToObject error" << endl ; | |
565 | cout << " Can't find Branch with RecPoints or Clusterizer " << endl ; | |
566 | return kFALSE ; | |
567 | } | |
568 | ||
569 | emcBranch->SetAddress(&fEmcRecPoints) ; | |
570 | cpvBranch->SetAddress(&fCpvRecPoints) ; | |
571 | clusterizerBranch->SetAddress(&fClusterizer) ; | |
572 | gAlice->TreeR()->GetEvent(0) ; | |
573 | } | |
574 | } | |
575 | ||
576 | return kTRUE ; | |
83974468 | 577 | } |
83974468 | 578 | //____________________________________________________________________________ |
3e3852a0 | 579 | Bool_t AliPHOSIndexToObject::ReadDigits(char * branchTitle){ |
83974468 | 580 | |
3e3852a0 | 581 | if(gAlice->TreeD()== 0) |
582 | return kFALSE ; | |
f035f6ce | 583 | |
584 | ||
83974468 | 585 | |
3e3852a0 | 586 | //if RecPoints are already read, we should read Digits from which they are made |
587 | if(fClusterizer) | |
588 | branchTitle = fClusterizer->GetDigitsBranch() ; | |
83974468 | 589 | |
3e3852a0 | 590 | if(branchTitle){ // we should read a specific branch |
591 | TBranch * digitsBranch = 0; | |
592 | TBranch * digitizerBranch = 0; | |
593 | ||
594 | TObjArray * branches = gAlice->TreeD()->GetListOfBranches() ; | |
595 | Int_t ibranch; | |
596 | Bool_t phosNotFound = kTRUE ; | |
597 | Bool_t digitizerNotFound = kTRUE ; | |
598 | ||
599 | for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){ | |
600 | ||
601 | if(phosNotFound){ | |
602 | digitsBranch=(TBranch *) branches->At(ibranch) ; | |
603 | if( (strcmp(digitsBranch->GetTitle(),branchTitle)==0 ) && | |
604 | (strcmp(digitsBranch->GetName(),"PHOS") == 0) ) | |
605 | phosNotFound = kFALSE ; | |
606 | } | |
607 | if(digitizerNotFound){ | |
608 | digitizerBranch = (TBranch *) branches->At(ibranch) ; | |
609 | if( (strcmp(digitizerBranch->GetTitle(),branchTitle) == 0) && | |
610 | (strcmp(digitizerBranch->GetName(),"AliPHOSDigitizer") == 0) ) | |
611 | digitizerNotFound = kFALSE ; | |
612 | } | |
613 | } | |
614 | ||
615 | if(digitizerNotFound || phosNotFound){ | |
616 | cout << "AliPHOSIndexToObject error: " << endl ; | |
617 | cout << " Can't find Branch with Digits or Digitizer "<< endl ; ; | |
618 | return kFALSE ; | |
619 | } | |
620 | ||
621 | digitsBranch->SetAddress(&fDigits) ; | |
622 | digitizerBranch->SetAddress(&fDigitizer) ; | |
83974468 | 623 | |
3e3852a0 | 624 | } |
625 | else{ //we should read any branch and print warning if there are other possibilities | |
626 | TBranch * digitsBranch = 0; | |
627 | TBranch * digitizerBranch = 0; | |
628 | ||
629 | TObjArray * branches = gAlice->TreeD()->GetListOfBranches() ; | |
630 | Int_t ibranch; | |
631 | Bool_t phosNotFound = kTRUE ; | |
632 | Bool_t digitizerNotFound = kTRUE ; | |
633 | ||
634 | for(ibranch = 0;(ibranch <branches->GetEntries())&& phosNotFound ;ibranch++){ | |
635 | digitsBranch=(TBranch *) branches->At(ibranch) ; | |
636 | if(strcmp(digitsBranch->GetName(),"PHOS") == 0) | |
637 | phosNotFound = kFALSE ; | |
638 | } | |
639 | for(ibranch = 0;(ibranch <branches->GetEntries())&& digitizerNotFound ;ibranch++){ | |
640 | digitizerBranch = (TBranch *) branches->At(ibranch) ; | |
641 | if( (strcmp(digitizerBranch->GetTitle(),digitsBranch->GetTitle()) == 0) && | |
642 | (strcmp(digitizerBranch->GetName(),"AliPHOSDigitizer") == 0) ) | |
643 | digitizerNotFound = kFALSE ; | |
644 | } | |
645 | ||
646 | if(digitizerNotFound || phosNotFound){ | |
647 | cout << "AliPHOSIndexToObject error: " << endl ; | |
648 | cout << " Can't find Branch with Digits or Digitizer "<< endl ; ; | |
649 | return kFALSE ; | |
650 | } | |
651 | ||
652 | digitsBranch->SetAddress(&fDigits) ; | |
653 | digitizerBranch->SetAddress(&fDigitizer) ; | |
f035f6ce | 654 | |
3e3852a0 | 655 | } |
656 | ||
f035f6ce | 657 | gAlice->TreeD()->GetEvent(0) ; |
658 | ||
3e3852a0 | 659 | return kTRUE ; |
660 | } | |
661 | //____________________________________________________________________________ | |
662 | Bool_t AliPHOSIndexToObject::ReadPrimaries(){ | |
663 | //read specific branches of primaries | |
664 | ||
665 | // //Check, is it necessary to open new files | |
666 | // TArrayI* events = fDigitizer->GetCurrentEvents() ; | |
667 | // TClonesArray * filenames = fDigitizer->GetHeadersFiles() ; | |
668 | // Int_t input ; | |
669 | // for(input = 0; input < filenames->GetEntriesFast(); input++){ | |
670 | ||
671 | // TObjString * filename = (TObjString *) filenames->At(input) ; | |
672 | ||
673 | // //Test, if this file already open | |
674 | // TFile *file = (TFile*) gROOT->GetFile( filename->GetString() ) ; | |
675 | // if(file == 0) | |
676 | // file = new TFile( filename->GetString()) ; | |
677 | // file->cd() ; | |
678 | ||
679 | // // Get Kine Tree from file | |
680 | // // char treeName[20]; | |
681 | // // sprintf(treeName,"TreeK%d",events->At(input)); | |
682 | // // TTree * treeK = (TTree*)gDirectory->Get(treeName); | |
683 | // // if (treeK) | |
684 | // // treeK->SetBranchAddress("Particles", &fParticleBuffer); | |
685 | // // else | |
686 | // // cout << "AliPHOSIndexToObject: cannot find Kine Tree for event:" << events->At(input) << endl; | |
687 | ||
688 | // // // Create the particle stack | |
689 | // // if(!fParticles) fParticles = new TClonesArray("TParticle",1000); | |
690 | // // // Build the pointer list | |
691 | // // if(fParticleMap) { <---- | |
692 | // // fParticleMap->Clear(); | |
693 | // // fParticleMap->Expand(treeK->GetEntries()); | |
694 | // // } else | |
695 | // // fParticleMap = new TObjArray(treeK->GetEntries()); | |
696 | ||
697 | // // From gAlice->Particle(i) | |
698 | ||
699 | ||
700 | // // if(!(*fParticleMap)[i]) { | |
701 | // // Int_t nentries = fParticles->GetEntries(); | |
702 | ||
703 | // // // algorithmic way of getting entry index | |
704 | // // // (primary particles are filled after secondaries) | |
705 | // // Int_t entry; | |
706 | // // if (i<fHeader.GetNprimary()) | |
707 | // // entry = i+fHeader.GetNsecondary(); | |
708 | // // else | |
709 | // // entry = i-fHeader.GetNprimary(); | |
710 | ||
711 | // // // only check the algorithmic way and give | |
712 | // // // the fatal error if it is wrong | |
713 | // // if (entry != fParticleFileMap[i]) { | |
714 | // // Fatal("Particle", | |
715 | // // "!!!! The algorithmic way is WRONG: !!!\n entry: %d map: %d", | |
716 | // // entry, fParticleFileMap[i]); | |
717 | // // } | |
718 | ||
719 | // // fTreeK->GetEntry(fParticleFileMap[i]); | |
720 | // // new ((*fParticles)[nentries]) TParticle(*fParticleBuffer); | |
721 | // // fParticleMap->AddAt((*fParticles)[nentries],i); | |
722 | // // } | |
723 | // // return (TParticle *) (*fParticleMap)[i]; | |
724 | ||
725 | ||
726 | ||
727 | // } | |
728 | ||
729 | ||
730 | // //scan over opened files and read corresponding TreeK## | |
731 | ||
732 | return kTRUE ; | |
733 | } | |
734 | //____________________________________________________________________________ | |
735 | void AliPHOSIndexToObject::GetEvent(Int_t event){ | |
736 | if(event == fEvent) // do nothing | |
737 | return ; | |
738 | ||
f035f6ce | 739 | if(event > fMaxEvent) |
740 | return ; | |
741 | ||
3e3852a0 | 742 | fEvent = event ; |
743 | gAlice->GetEvent(fEvent) ; | |
83974468 | 744 | |
3e3852a0 | 745 | ReadRecParticles(fPID->GetRecParticlesBranch()) ; |
746 | ReadTS(fTSMaker->GetTrackSegmentsBranch()) ; | |
747 | ReadRecPoints(fClusterizer->GetRecPointsBranch()) ; | |
748 | ReadDigits(fDigitizer->GetDigitsBranch()) ; | |
749 | ReadPrimaries() ; | |
83974468 | 750 | } |
3e3852a0 | 751 |