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 }