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