4ad362dc5a2c2349154308a694119b49c701ec18
[u/mrichter/AliRoot.git] / PHOS / AliPHOSReconstructioner.cxx
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 //_________________________________________________________________________
19 //*--
20 //*-- Author: Gines Martinez & Yves Schutz (SUBATECH) 
21 //*-- Complitely redisigned by Dmitri Peressounko (SUBATECH & RRC KI) March 2001
22 /////////////////////////////////////////////////////////////////////////////////////
23 //  Wrapping class for reconstruction. Allows to produce reconstruction from 
24 //  different steps: from previously produced hits,sdigits, etc. Each new reconstruction
25 //  flow (e.g. gigits, made from them RecPoints, made from them TrackSegments, made from 
26 //  them RecParticles) are distinguished by the title of created branches. One can 
27 //  use this title as a comment, see user case below. Thanks to getters, one can set 
28 //  parameters to reconstruction bricks. The full set of parameters is saved in the 
29 //  correspoinding branch: e.g. parameters of clusterizer are stored in branch 
30 //  TreeR::AliPHOSClusterizer with the same title as the branch contaning RecPoints 
31 //  themself. TTree does not support overwriting, therefore one can not produce several 
32 //  branches with the same names and titles - use different titles.
33 //
34 //  User case: 
35 //
36 //  root [0] AliPHOSReconstructioner * r = new AliPHOSReconstructioner("galice.root")
37 //              //  Set the header file
38 //  root [1] r->ExecuteTask() 
39 //              //  Make full cheine of reconstruction
40 //
41 //              // One can specify the title for each branch 
42 //  root [2] r->SetBranchFileName("RecPoints","RecPoints1") ;
43 //      
44 //             // One can change parameters of reconstruction algorithms
45 //  root [3] r->GetClusterizer()->SetEmcLocalMaxCut(0.02)
46 //
47 //             // One can specify the starting point of the reconstruction and title of all 
48 //             // branches produced in this pass
49 //  root [4] r->StartFrom("AliPHOSClusterizer","Local max cut 0.02") 
50 //             // means that will use already generated Digits and produce only RecPoints, 
51 //             // TS and RecParticles 
52 //
53 //             // And finally one can call ExecuteTask() with the following options
54 //  root [5] r->ExecuteTask("debug all timing")
55 //             // deb     - prints the numbers of produced SDigits, Digits etc.
56 //             // deb all - prints in addition list of made SDigits, digits etc.
57 //             // timing  - prints benchmarking results
58 ///////////////////////////////////////////////////////////////////////////////////////////////////
59
60 // --- ROOT system ---
61
62 #include "TClonesArray.h"
63 #include "TROOT.h"
64 #include "TTree.h"
65
66 // --- Standard library ---
67 #include <iostream.h>   
68
69 // --- AliRoot header files ---
70 #include "AliRun.h"
71 #include "AliPHOSReconstructioner.h"
72 #include "AliPHOSClusterizerv1.h"
73 #include "AliPHOSDigitizer.h"
74 #include "AliPHOSSDigitizer.h"
75 #include "AliPHOSTrackSegmentMakerv1.h"
76 #include "AliPHOSPIDv1.h"
77 #include "AliPHOSFastRecParticle.h"
78 #include "AliPHOSCpvRecPoint.h"
79
80 ClassImp(AliPHOSReconstructioner)
81
82 //____________________________________________________________________________
83   AliPHOSReconstructioner::AliPHOSReconstructioner():TTask("AliPHOSReconstructioner","")
84 {
85   // ctor
86   fDigitizer   = 0 ;
87   fClusterizer = 0 ;
88   fTSMaker     = 0 ;
89   fPID         = 0 ; 
90   fSDigitizer  = 0 ;
91   fHeaderFileName = "galice.root" ;
92
93   fIsInitialized = kFALSE ;
94
95
96
97 //____________________________________________________________________________
98 AliPHOSReconstructioner::AliPHOSReconstructioner(const char* headerFile):TTask("AliPHOSReconstructioner","")
99 {
100   // ctor
101   
102   fHeaderFileName = headerFile ;
103
104   fSDigitsBranch="" ; 
105   fSDigitizer  = new AliPHOSSDigitizer(fHeaderFileName.Data(),fSDigitsBranch.Data()) ; 
106   Add(fSDigitizer) ;
107
108   fDigitsBranch="" ; 
109   fDigitizer   = new AliPHOSDigitizer(fHeaderFileName.Data(),fDigitsBranch.Data()) ; 
110   Add(fDigitizer) ;
111
112
113   fRecPointBranch="" ; 
114   fClusterizer = new AliPHOSClusterizerv1(fHeaderFileName.Data(),fRecPointBranch.Data()) ; 
115   Add(fClusterizer) ;
116   
117
118   fTSBranch="" ; 
119   fTSMaker     = new AliPHOSTrackSegmentMakerv1(fHeaderFileName.Data(),fTSBranch.Data()) ;
120   Add(fTSMaker) ;
121   
122   
123   fRecPartBranch="" ; 
124   fPID         = new AliPHOSPIDv1(fHeaderFileName.Data(),fRecPartBranch.Data()) ;
125   Add(fPID) ;
126   
127   fIsInitialized = kTRUE ;
128   
129
130 //____________________________________________________________________________
131 void AliPHOSReconstructioner::Exec(Option_t *option){
132   //chesk, if the names of branches, which should be made conicide with already
133   //existing
134   if(!fIsInitialized)
135     Init() ;
136
137   gAlice->GetEvent(0) ;
138
139   if(fSDigitizer->IsActive()&& gAlice->TreeS()){ //Will produce SDigits
140
141     TBranch * sdigitsBranch = 0;
142     TBranch * sdigitizerBranch = 0;
143
144     TObjArray * branches = gAlice->TreeS()->GetListOfBranches() ;
145     Int_t ibranch;
146     Bool_t phosNotFound = kTRUE ;
147     Bool_t sdigitizerNotFound = kTRUE ;
148
149     for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){            
150       if(phosNotFound){
151         sdigitsBranch=(TBranch *) branches->At(ibranch) ;
152         if(( strcmp("PHOS",sdigitsBranch->GetName())==0 ) &&
153            (fSDigitsBranch.CompareTo(sdigitsBranch->GetTitle())== 0 ))
154           phosNotFound = kFALSE ;
155       }
156       if(sdigitizerNotFound){
157         sdigitizerBranch = (TBranch *) branches->At(ibranch) ;
158         if(( strcmp(sdigitizerBranch->GetName(),"AliPHOSSDigitizer") == 0) &&
159            (fSDigitsBranch.CompareTo(sdigitizerBranch->GetTitle())== 0 ) )
160           sdigitizerNotFound = kFALSE ;
161       }
162     }
163     
164     if(!(sdigitizerNotFound && phosNotFound)){
165       cout << "AliPHOSReconstructioner error: "<< endl ;
166       cout << "       Branches ''PHOS'' or ''AliPHOSSDigitizer'' with title ``" << fSDigitsBranch.Data() << "''" << endl ;
167       cout << "       already exist in TreeS. ROOT does not allow updating/overwriting." << endl ;
168       cout << "       Specify another title for branches or use ''StartFrom()'' method" << endl ;
169       
170       //mark all tasks as inactive
171       TIter next(fTasks);
172       TTask *task;
173       while((task=(TTask*)next()))
174         task->SetActive(kFALSE) ;
175       
176       return ;
177     }
178   }
179
180   if(fDigitizer->IsActive() && gAlice->TreeD()){ //Will produce Digits
181     TBranch * digitsBranch = 0;
182     TBranch * digitizerBranch = 0;
183     
184     TObjArray * branches = gAlice->TreeD()->GetListOfBranches() ;
185     Int_t ibranch;
186     Bool_t phosNotFound = kTRUE ;
187     Bool_t digitizerNotFound = kTRUE ;
188     
189     for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){            
190       if(phosNotFound){
191         digitsBranch=(TBranch *) branches->At(ibranch) ;
192         if(( strcmp("PHOS",digitsBranch->GetName())==0 ) &&
193            (fDigitsBranch.CompareTo(digitsBranch->GetTitle())== 0 ))
194           phosNotFound = kFALSE ;
195       }
196       if(digitizerNotFound){
197         digitizerBranch = (TBranch *) branches->At(ibranch) ;
198         if(( strcmp(digitizerBranch->GetName(),"AliPHOSDigitizer") == 0) &&
199            (fDigitsBranch.CompareTo(digitizerBranch->GetTitle())== 0 ) )
200           digitizerNotFound = kFALSE ;
201       }
202     }
203     
204     if(!(digitizerNotFound && phosNotFound)){
205       cout << "AliPHOSReconstructioner error: "<< endl ;
206       cout << "       Branches ''PHOS'' or ''AliPHOSDigitizer'' with title ``" << fDigitsBranch.Data() << "''" << endl ;
207       cout << "       already exist in TreeD. ROOT does not allow updating/overwriting." << endl ;
208       cout << "       Specify another title for branches or use ''StartFrom()'' method" << endl ;
209       
210       //mark all tasks as inactive
211       TIter next(fTasks);
212       TTask *task;
213       while((task=(TTask*)next()))
214         task->SetActive(kFALSE) ;
215       
216       return ;
217     }
218   }
219
220   if(fClusterizer->IsActive() && gAlice->TreeR()){ //Will produce RecPoints
221     TBranch * emcBranch = 0;
222     TBranch * cpvBranch = 0;
223     TBranch * clusterizerBranch = 0;
224     
225     TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
226     Int_t ibranch;
227     Bool_t emcNotFound = kTRUE ;
228     Bool_t cpvNotFound = kTRUE ;  
229     Bool_t clusterizerNotFound = kTRUE ;
230     
231     for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){
232       
233       if(emcNotFound){
234         emcBranch=(TBranch *) branches->At(ibranch) ;
235         if(fRecPointBranch.CompareTo(emcBranch->GetTitle())==0 )
236           if( strcmp(emcBranch->GetName(),"PHOSEmcRP") == 0) 
237             emcNotFound = kFALSE ;
238       }
239       if(cpvNotFound){
240         cpvBranch=(TBranch *) branches->At(ibranch) ;
241         if(fRecPointBranch.CompareTo(cpvBranch->GetTitle())==0 )
242           if( strcmp(cpvBranch->GetName(),"PHOSCpvRP") == 0) 
243             cpvNotFound = kFALSE ;
244       }
245       if(clusterizerNotFound){
246         clusterizerBranch = (TBranch *) branches->At(ibranch) ;
247         if( fRecPointBranch.CompareTo(clusterizerBranch->GetTitle()) == 0)
248           if( strcmp(clusterizerBranch->GetName(),"AliPHOSClusterizer") == 0) 
249             clusterizerNotFound = kFALSE ;
250       }
251     }
252
253     if(!(clusterizerNotFound && emcNotFound && cpvNotFound)){
254       cout << "AliPHOSReconstructioner error: "<< endl ;
255       cout << "       Branches ''PHOSEmcRP'', ''PHOSCpvRP'' or ''AliPHOSClusterizer'' with title ``" 
256            << fRecPointBranch.Data() << "''" << endl ;
257       cout << "       already exist in TreeR. ROOT does not allow updating/overwriting." << endl ;
258       cout << "       Specify another title for branches or use ''StartFrom()'' method" << endl ;
259       
260       //mark all tasks as inactive
261       TIter next(fTasks);
262       TTask *task;
263       while((task=(TTask*)next()))
264         task->SetActive(kFALSE) ;
265       return ;
266     }
267   }
268   
269   if(fTSMaker->IsActive() && gAlice->TreeR()){ //Produce TrackSegments
270
271     TBranch * tsMakerBranch = 0;
272     TBranch * tsBranch = 0;
273     
274     TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
275     Int_t ibranch;
276     Bool_t tsMakerNotFound = kTRUE ;
277     Bool_t tsNotFound = kTRUE ;
278     
279     for(ibranch = 0;(ibranch <branches->GetEntries())&&(tsMakerNotFound||tsNotFound);ibranch++){
280       if(tsMakerNotFound){
281         tsMakerBranch=(TBranch *) branches->At(ibranch) ;
282         if( fTSBranch.CompareTo(tsMakerBranch->GetTitle())==0 )
283           if( strcmp(tsMakerBranch->GetName(),"AliPHOSTrackSegmentMaker") == 0) 
284             tsMakerNotFound = kFALSE ;
285       }
286       if(tsNotFound){
287         tsBranch=(TBranch *) branches->At(ibranch) ;
288         if( fTSBranch.CompareTo(tsBranch->GetTitle())==0 )
289           if( strcmp(tsBranch->GetName(),"PHOSTS") == 0) 
290             tsNotFound = kFALSE ;
291       }
292     }
293     
294     if(!(tsMakerNotFound &&tsNotFound) ){
295       cout << "AliPHOSReconstructioner error: "<< endl ;
296       cout << "       Branches ''PHOSTS'' or ''AliPHOSTrackSegmentMaker'' with title ``" 
297            << fTSBranch.Data() << "''" << endl ;
298       cout << "       already exist in TreeR. ROOT does not allow updating/overwriting." << endl ;
299       cout << "       Specify another title for branches or use ''StartFrom()'' method" << endl ;
300       
301       //mark all tasks as inactive
302       TIter next(fTasks);
303       TTask *task;
304       while((task=(TTask*)next()))
305         task->SetActive(kFALSE) ;
306       return ;
307       
308     }
309     
310   }
311
312   if(fPID->IsActive() && gAlice->TreeR()){ //Produce RecParticles
313     TBranch * pidBranch = 0;
314     TBranch * rpBranch = 0;
315     
316     TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
317     Int_t ibranch;
318     Bool_t pidNotFound = kTRUE ;
319     Bool_t rpNotFound = kTRUE ;
320     
321     for(ibranch = 0;(ibranch <branches->GetEntries()) && pidNotFound && rpNotFound ;ibranch++){
322       if(pidNotFound){
323         pidBranch=(TBranch *) branches->At(ibranch) ;
324         if( (strcmp(fRecPartBranch,pidBranch->GetTitle())==0 ) &&
325             (strcmp(pidBranch->GetName(),"AliPHOSPID") == 0) )
326           pidNotFound = kFALSE ;
327       }
328       if(rpNotFound){
329         rpBranch=(TBranch *) branches->At(ibranch) ;
330         if( (strcmp(fRecPartBranch,rpBranch->GetTitle())==0 ) &&
331             (strcmp(rpBranch->GetName(),"PHOSRP") == 0) )
332           rpNotFound = kFALSE ;
333       }
334     }
335     
336     if(!pidNotFound  || !rpNotFound ){
337       cout << "AliPHOSReconstructioner error: "<< endl ;
338       cout << "       Branches ''PHOSRP'' or ''AliPHOSPID'' with title ``" 
339            << fRecPartBranch.Data() << "''" << endl ;
340       cout << "       already exist in TreeR. ROOT does not allow updating/overwriting." << endl ;
341       cout << "       Specify another title for branches." << endl ;
342       
343       //mark all tasks as inactive
344       TIter next(fTasks);
345       TTask *task;
346       while((task=(TTask*)next()))
347         task->SetActive(kFALSE) ;
348       return ;
349     }
350     
351   }
352 }
353 //____________________________________________________________________________
354  void AliPHOSReconstructioner::Init()
355 {
356   //initiase Reconstructioner if necessary: we can not do this in default constructor
357
358   if(!fIsInitialized){
359     // Initialisation
360
361     fSDigitsBranch="" ; 
362     fSDigitizer  = new AliPHOSSDigitizer(fHeaderFileName.Data(),fSDigitsBranch.Data()) ; 
363     Add(fSDigitizer) ;
364
365     fDigitsBranch="" ; 
366     fDigitizer   = new AliPHOSDigitizer(fHeaderFileName.Data(),fDigitsBranch.Data()) ; 
367     Add(fDigitizer) ;
368
369     fRecPointBranch="" ; 
370     fClusterizer = new AliPHOSClusterizerv1(fHeaderFileName.Data(),fRecPointBranch.Data()) ; 
371     Add(fClusterizer) ;
372
373     fTSBranch="" ; 
374     fTSMaker     = new AliPHOSTrackSegmentMakerv1(fHeaderFileName.Data(),fTSBranch.Data()) ;
375     Add(fTSMaker) ;
376
377
378     fRecPartBranch="" ; 
379     fPID         = new AliPHOSPIDv1(fHeaderFileName.Data(),fRecPartBranch.Data()) ;
380     Add(fPID) ;
381     
382     fIsInitialized = kTRUE ;
383   }
384
385 //____________________________________________________________________________
386 AliPHOSReconstructioner::~AliPHOSReconstructioner()
387 {
388   
389   if(fSDigitizer)
390     delete fSDigitizer ;
391   
392   if(fDigitizer)
393     delete fDigitizer ;
394   
395   if(fClusterizer)
396     delete fClusterizer ;
397   
398   if(fTSMaker)
399     delete fTSMaker ;
400   
401   if(fPID)
402     delete fPID ;
403
404 //____________________________________________________________________________
405 void AliPHOSReconstructioner::SetBranchTitle(const char* branch, const char * title){
406   //Diverge correcpoinding branch to the file "title"
407
408   if(strcmp(branch,"SDigits") == 0){ 
409     fSDigitizer->SetSDigitsBranch(title) ;
410     fDigitizer->SetSDigitsBranch(title) ;
411     fSDigitsBranch = title ;
412     return ;
413   }
414   
415   if(strcmp(branch,"Digits") == 0){ 
416     fDigitizer->SetDigitsBranch(title) ;
417     fClusterizer->SetDigitsBranch(title) ;
418     fDigitsBranch = title ;
419     return ;
420   }
421
422   if(strcmp(branch,"RecPoints") == 0){ 
423     fClusterizer->SetRecPointsBranch(title) ;
424     fTSMaker->SetRecPointsBranch(title) ;
425     fRecPointBranch = title ;
426     return ;
427   }
428
429   if(strcmp(branch,"TrackSegments") == 0){
430     fTSMaker->SetTrackSegmentsBranch(title) ;
431     fPID->SetTrackSegmentsBranch(title) ;
432     fTSBranch = title ;
433     return ;
434   }
435
436   if(strcmp(branch,"RecParticles") == 0){ 
437     fPID->SetRecParticlesBranch(title) ;
438     fRecPartBranch = title ;
439     return ;
440   }
441
442   cout << "There is no branch " << branch << "!"<< endl ;
443   cout << "Available branches `SDigits', `Digits', `RecPoints', `TrackSegments' and `RecParticles' " << endl ;
444   
445 }
446 //____________________________________________________________________________
447 void AliPHOSReconstructioner::StartFrom(char * module,char* title){
448   // in the next pass of reconstruction (call ExecuteTask()) reconstruction will 
449   // start from the module "module", and in the case of nonsero title all 
450   // pruduced branches will have title "title". Recognize the following "modules"
451   // "SD" - AliPHOSSDigitizer,
452   // "D"  - AliPHOSDigitizer
453   // "C"  - AliPHOSClusterizer
454   // "TS" - AliPHOSTrackSegmentMaker
455   // "RP" - AliPHOSPID
456
457   if(!fIsInitialized)
458     Init() ;
459
460   char * moduleName = new char[30];
461   if(strstr(module,"SD"))
462     sprintf(moduleName,"AliPHOSSDigitizer") ;
463   else
464     if(strstr(module,"D") )
465       sprintf(moduleName,"AliPHOSDigitizer") ;
466     else
467       if(strstr(module,"C") || strstr(module,"RecPoint") )
468         sprintf(moduleName,"AliPHOSClusterizer") ;
469       else
470         if(strstr(module,"TS") || strstr(module,"Track") )
471           sprintf(moduleName,"AliPHOSTrackSegmentMaker") ;
472         else
473           if(strstr(module,"PID") || strstr(module,"Particle") || strstr(module,"RP") )
474             sprintf(moduleName,"AliPHOSPID") ;
475           else{
476             cout << "Do not know such a module / Rec Object " << endl;
477             return ;
478           }
479   
480   TIter next(fTasks);
481   TTask *task;
482   Bool_t active = kFALSE ;
483   while((task=(TTask*)next())){ 
484     if (strcmp(moduleName,task->GetName())==0)  
485       active = kTRUE;
486     task->SetActive(active) ;
487     if(active && title){ // set title to branches
488       switch(strlen(task->GetName()) ) {
489       case 17:   // "AliPHOSSDigitizer"
490         fSDigitizer->SetSDigitsBranch(title) ;
491         fDigitizer->SetSDigitsBranch(title) ;
492         fSDigitsBranch = title ;
493         break ;
494       case 16:   //"AliPHOSDigitizer"
495         fDigitizer->SetDigitsBranch(title) ;
496         fClusterizer->SetDigitsBranch(title) ;
497         fDigitsBranch = title ;
498         break ;
499       case 18:   //"AliPHOSClusterizer"
500         fClusterizer->SetRecPointsBranch(title) ;
501         fTSMaker->SetRecPointsBranch(title) ;
502         fRecPointBranch = title ;
503         break ;
504       case 24:   //"AliPHOSTrackSegmentMaker"
505         fTSMaker->SetTrackSegmentsBranch(title) ;
506         fPID->SetTrackSegmentsBranch(title) ;
507         fTSBranch = title ;
508         break ;
509       case 10:   // "AliPHOSPID"
510         fPID->SetRecParticlesBranch(title) ;
511         fRecPartBranch = title ;
512         break ;
513       }
514       
515     }
516   }
517   
518   delete moduleName;
519 }
520 //____________________________________________________________________________
521 void AliPHOSReconstructioner::Print(Option_t * option)const {
522   
523   cout << "-----------------AliPHOSReconstructioner---------------" << endl ;
524   cout << " Reconstruction of the header file " <<fHeaderFileName.Data() << endl ;
525   cout << " with the following modules: " << endl ;
526
527   if(fSDigitizer->IsActive()){
528     cout << "   (+)   " << fSDigitizer->GetName() << " to branch : " << fSDigitsBranch.Data() << endl ; 
529     cout << endl ;
530   }
531   if(fDigitizer->IsActive()){
532     cout << "   (+)   " << fDigitizer->GetName() << " to branch : " << fDigitsBranch.Data() << endl ;  
533     cout <<  endl ;
534   }
535   
536   if(fClusterizer->IsActive()){
537     cout << "   (+)   " <<fClusterizer->GetName() << " to branch : " <<fRecPointBranch.Data()  << endl ;  
538     cout <<  endl ;
539   }
540
541   if(fTSMaker->IsActive()){
542     cout << "   (+)   " << fTSMaker->GetName() << " to branch : " << fTSBranch.Data() << endl ;  
543     cout <<  endl ;
544   }
545
546
547   if(fPID->IsActive()){
548     cout << "   (+)   " << fPID->GetName() << " to branch : " <<fRecPartBranch.Data()  << endl ;  
549     cout <<  endl ;
550   }
551
552
553 }