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