PHOS/AliPHOSPIDv0.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 /* History of cvs commits:
  19  *
  20  * $Log$
  21  * Revision 1.14  2006/09/07 18:31:08  kharlov
  22  * Effective c++ corrections (T.Pocheptsov)
  23  *
  24  * Revision 1.13  2005/05/28 14:19:04  schutz
  25  * Compilation warnings fixed by T.P.
  26  *
  27  */
  28
  29 //_________________________________________________________________________
  30 // Implementation version v0 of the PHOS particle identifier
  31 // Particle identification based on the
  32 //     - CPV information,
  33 //     - Preshower information (in MIXT or GPS2 geometries)
  34 //     - shower width.
  35 //
  36 // CPV or Preshower clusters should be closer in PHOS plane than fCpvEmcDistance (in cm).
  37 // This parameter can be set by method SetCpvtoEmcDistanceCut(Float_t cut)
  38 //
  39 // One can set desirable ID method by the function SetIdentificationMethod(option).
  40 // Presently the following options can be used together or separately :
  41 //     - "disp": use dispersion cut on shower width
  42 //               (width can be set by method SetDispersionCut(Float_t cut)
  43 //     - "ell" : use cut on the axis of the ellipse, drawn around shower
  44 //       (this cut can be changed by SetShowerProfileCut(char* formula),
  45 //        where formula - any function of two variables f(lambda[0],lambda[1]).
  46 //        Shower is considered as EM if f() > 0 )
  47 // One can visualize current cuts calling method PlotDispersionCuts().
  48 //
  49 // use case:
  50 //  root [0] AliPHOSPIDv0 * p1 = new AliPHOSPIDv0("galice.root")
  51 //  Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
  52 //  root [1] p1->SetIdentificationMethod("disp ellipse")
  53 //  root [2] p1->ExecuteTask()
  54 //  root [3] AliPHOSPIDv0 * p2 = new AliPHOSPIDv0("galice1.root","ts1")
  55 //  Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
  56 //                // reading headers from file galice1.root and TrackSegments
  57 //                // with title "ts1"
  58 //  root [4] p2->SetRecParticlesBranch("rp1")
  59 //                // set file name for the branch RecParticles
  60 //  root [5] p2->ExecuteTask("deb all time")
  61 //                // available options
  62 //                // "deb" - prints # of reconstructed particles
  63 //                // "deb all" -  prints # and list of RecParticles
  64 //                // "time" - prints benchmarking results
  65 //
  66 //*-- Author: Yves Schutz (SUBATECH)  & Gines Martinez (SUBATECH) &
  67 //            Dmitri Peressounko (SUBATECH & Kurchatov Institute)
  68 //            Completely redesined by Dmitri Peressounko, March 2001
  69
  70 // --- ROOT system ---
  71 #include "TTree.h"
  72 #include "TF2.h"
  73 #include "TFormula.h"
  74 #include "TCanvas.h"
  75
  76 #include "TBenchmark.h"
  77 // --- Standard library ---
  78
  79 // --- AliRoot header files ---
  80 #include "AliLog.h"
  81 #include "AliRun.h"
  82 #include "AliGenerator.h"
  83 #include "AliPHOSPIDv0.h"
  84 #include "AliPHOSEmcRecPoint.h"
  85 #include "AliPHOSTrackSegment.h"
  86 #include "AliPHOSRecParticle.h"
  87 #include "AliPHOSGeometry.h"
  88 #include "AliPHOSLoader.h"
  89
  90 ClassImp( AliPHOSPIDv0)
  91
  92 //____________________________________________________________________________
  93 AliPHOSPIDv0::AliPHOSPIDv0():
  94   fTrackSegmentsTitle(""),
  95   fRecPointsTitle(""),
  96   fRecParticlesTitle(""),
  97   fIDOptions("dis time"),
  98   fNEvent(0),
  99   fClusterizer(0),
 100   fTSMaker(0),
 101   fFormula(0),
 102   fDispersion(0.f),
 103   fCpvEmcDistance(0.f),
 104   fTimeGate(2.e-9f),
 105   fRecParticlesInRun(0)
 106 {
 107   // default ctor
 108   fEventFolderName = "";
 109 }
 110
 111 //____________________________________________________________________________
 112 AliPHOSPIDv0::AliPHOSPIDv0(const char * evFolderName,const char * name) :
 113   AliPHOSPID(evFolderName, name),
 114   fTrackSegmentsTitle(GetName()),
 115   fRecPointsTitle(GetName()),
 116   fRecParticlesTitle(GetName()),
 117   fIDOptions("dis time"),
 118   fNEvent(0),
 119   fClusterizer(0),
 120   fTSMaker(0),
 121   fFormula(new TFormula("LambdaCuts","(x>1)*(x<2.5)*(y>0)*(y<x)")),
 122   fDispersion(2.f),
 123   fCpvEmcDistance(3.f),
 124   fTimeGate(2.e-9f),
 125   fRecParticlesInRun(0)
 126 {
 127   //ctor with the indication on where to look for the track segments
 128   fEventFolderName    = GetTitle() ;
 129   Init() ;
 130 }
 131
 132 //____________________________________________________________________________
 133 AliPHOSPIDv0::AliPHOSPIDv0(const AliPHOSPIDv0 & rhs) :
 134   AliPHOSPID(rhs),
 135   fTrackSegmentsTitle(rhs.fTrackSegmentsTitle),
 136   fRecPointsTitle(rhs.fRecPointsTitle),
 137   fRecParticlesTitle(rhs.fRecParticlesTitle),
 138   fIDOptions(rhs.fIDOptions),
 139   fNEvent(rhs.fNEvent),
 140   fClusterizer(rhs.fClusterizer),
 141   fTSMaker(rhs.fTSMaker),
 142   fFormula(rhs.fFormula),
 143   fDispersion(rhs.fDispersion),
 144   fCpvEmcDistance(rhs.fCpvEmcDistance),
 145   fTimeGate(rhs.fTimeGate),
 146   fRecParticlesInRun(rhs.fRecParticlesInRun)
 147 {
 148   //Copy ctor, the same as compiler-generated, possibly wrong if
 149   //someone implements dtor correctly.
 150 }
 151
 152 //____________________________________________________________________________
 153 AliPHOSPIDv0 & AliPHOSPIDv0::operator = (const AliPHOSPIDv0 & rhs)
 154 {
 155   //Copy-assignment, emulates compiler generated, possibly wrong.
 156   AliPHOSPID::operator = (rhs);
 157   fTrackSegmentsTitle = rhs.fTrackSegmentsTitle;
 158   fRecPointsTitle = rhs.fRecPointsTitle;
 159   fRecParticlesTitle = rhs.fRecParticlesTitle;
 160   fIDOptions = rhs.fIDOptions;
 161   fNEvent = rhs.fNEvent;
 162   fClusterizer = rhs.fClusterizer;
 163   fTSMaker = rhs.fTSMaker;
 164   fFormula = rhs.fFormula;
 165   fDispersion = rhs.fDispersion;
 166   fCpvEmcDistance = rhs.fCpvEmcDistance;
 167   fTimeGate = rhs.fTimeGate;
 168   fRecParticlesInRun = rhs.fRecParticlesInRun;
 169
 170   return *this;
 171 }
 172
 173 //____________________________________________________________________________
 174 AliPHOSPIDv0::~AliPHOSPIDv0()
 175 {
 176   //Empty dtor, fFormula leaks
 177 }
 178
 179 //DP
 180 ////____________________________________________________________________________
 181 //Float_t  AliPHOSPIDv0::GetDistance(AliPHOSEmcRecPoint * emc,AliPHOSRecPoint * cpv, Option_t *  Axis)const
 182 //{
 183 //  // Calculates the distance between the EMC RecPoint and the PPSD RecPoint
 184 //
 185 //  const AliPHOSGeometry * geom = AliPHOSLoader::GetPHOSGeometry() ;
 186 //  TVector3 vecEmc ;
 187 //  TVector3 vecCpv ;
 188 //
 189 //  emc->GetLocalPosition(vecEmc) ;
 190 //  cpv->GetLocalPosition(vecCpv) ;
 191 //  if(emc->GetPHOSMod() == cpv->GetPHOSMod()){
 192 //
 193 //    // Correct to difference in CPV and EMC position due to different distance to center.
 194 //    // we assume, that particle moves from center
 195 //    Float_t dCPV = geom->GetIPtoOuterCoverDistance();
 196 //    Float_t dEMC = geom->GetIPtoCrystalSurface() ;
 197 //    dEMC         = dEMC / dCPV ;
 198 //    vecCpv = dEMC * vecCpv  - vecEmc ;
 199 //    if (Axis == "X") return vecCpv.X();
 200 //    if (Axis == "Y") return vecCpv.Y();
 201 //    if (Axis == "Z") return vecCpv.Z();
 202 //    if (Axis == "R") return vecCpv.Mag();
 203 //  }
 204 //
 205 //  return 100000000 ;
 206 //}
 207
 208 //____________________________________________________________________________
 209 void  AliPHOSPIDv0::Exec(Option_t * option)
 210 {
 211   //Steering method
 212
 213   if( strcmp(GetName(), "")== 0 )
 214     Init() ;
 215
 216   if(strstr(option,"tim"))
 217     gBenchmark->Start("PHOSPID");
 218
 219   if(strstr(option,"print")) {
 220     Print() ;
 221     return ;
 222   }
 223
 224   AliRunLoader* runget = AliRunLoader::GetRunLoader(GetTitle());
 225   if(runget == 0x0)
 226    {
 227      AliError(Form("Can not find run getter in event folder \"%s\"",
 228                    GetTitle()));
 229      return;
 230    }
 231
 232   AliPHOSLoader* gime = dynamic_cast<AliPHOSLoader*>(runget->GetLoader("PHOSLoader"));
 233   if ( gime == 0 )
 234    {
 235      AliError("Could not obtain the Loader object !");
 236      return ;
 237    }
 238
 239   if(gime->BranchExists("RecParticles") )
 240     return ;
 241
 242
 243   Int_t nevents = runget->GetNumberOfEvents() ;       //(Int_t) gAlice->TreeE()->GetEntries() ;
 244
 245   Int_t ievent ;
 246
 247   for(ievent = 0; ievent < nevents; ievent++){
 248     runget->GetEvent(ievent);
 249     AliInfo(Form("event %d %d %d",
 250                  ievent, gime->EmcRecPoints(),
 251                  gime->TrackSegments())) ;
 252     MakeRecParticles() ;
 253
 254     WriteRecParticles();
 255
 256     if(strstr(option,"deb"))
 257       PrintRecParticles(option) ;
 258
 259     //increment the total number of rec particles per run
 260     fRecParticlesInRun += gime->RecParticles()->GetEntriesFast() ;
 261
 262   }
 263
 264   if(strstr(option,"tim")){
 265     gBenchmark->Stop("PHOSPID");
 266     AliInfo(Form("took %f seconds for PID %f seconds per event",
 267                  gBenchmark->GetCpuTime("PHOSPID"),
 268                  gBenchmark->GetCpuTime("PHOSPID")/nevents)) ;
 269   }
 270
 271 }
 272 //____________________________________________________________________________
 273 void AliPHOSPIDv0::Init()
 274 {
 275   // Make all memory allocations that are not possible in default constructor
 276   // Add the PID task to the list of PHOS tasks
 277
 278   AliRunLoader* runget = AliRunLoader::GetRunLoader(GetTitle());
 279   if(runget == 0x0)
 280    {
 281      AliError(Form("Can not find run getter in event folder \"%s\"",
 282                    GetTitle()));
 283      return;
 284    }
 285
 286   AliPHOSLoader* gime = dynamic_cast<AliPHOSLoader*>(runget->GetLoader("PHOSLoader"));
 287   if ( gime == 0 )
 288    {
 289      AliError("Could not obtain the Loader object !");
 290      return ;
 291    }
 292
 293   gime->PostPID(this);
 294   gime->LoadRecParticles("UPDATE");
 295
 296 }
 297
 298 //____________________________________________________________________________
 299 void  AliPHOSPIDv0::MakeRecParticles()
 300 {
 301   // Reconstructs the particles from the tracksegments
 302
 303   TString taskName(GetName()) ;
 304   taskName.Remove(taskName.Index(Version())-1) ;
 305
 306   AliRunLoader* runget = AliRunLoader::GetRunLoader(GetTitle());
 307   if(runget == 0x0)
 308    {
 309      AliError(Form("Can not find run getter in event folder \"%s\"",
 310                    GetTitle()));
 311      return;
 312    }
 313
 314   AliPHOSLoader* gime = dynamic_cast<AliPHOSLoader*>(runget->GetLoader("PHOSLoader"));
 315   if ( gime == 0 )
 316    {
 317      AliError("Could not obtain the Loader object !");
 318      return ;
 319    }
 320
 321   TObjArray * emcRecPoints = gime->EmcRecPoints() ;
 322   TObjArray * cpvRecPoints = gime->CpvRecPoints() ;
 323   TClonesArray * trackSegments = gime->TrackSegments() ;
 324   TClonesArray * recParticles  = gime->RecParticles() ;
 325
 326   recParticles->Clear();
 327
 328   TIter next(trackSegments) ;
 329   AliPHOSTrackSegment * ts ;
 330   Int_t index = 0 ;
 331   AliPHOSRecParticle * rp ;
 332
 333   Bool_t ellips = fIDOptions.Contains("ell",TString::kIgnoreCase ) ;
 334   Bool_t disp   = fIDOptions.Contains("dis",TString::kIgnoreCase ) ;
 335   Bool_t time   = fIDOptions.Contains("tim",TString::kIgnoreCase ) ;
 336
 337   while ( (ts = (AliPHOSTrackSegment *)next()) ) {
 338
 339     new( (*recParticles)[index] ) AliPHOSRecParticle() ;
 340     rp = (AliPHOSRecParticle *)recParticles->At(index) ;
 341     rp->SetTrackSegment(index) ;
 342     rp->SetIndexInList(index) ;
 343
 344     AliPHOSEmcRecPoint * emc = 0 ;
 345     if(ts->GetEmcIndex()>=0)
 346       emc = (AliPHOSEmcRecPoint *) emcRecPoints->At(ts->GetEmcIndex()) ;
 347
 348     AliPHOSRecPoint    * cpv = 0 ;
 349     if(ts->GetCpvIndex()>=0)
 350       cpv = (AliPHOSRecPoint *)   cpvRecPoints->At(ts->GetCpvIndex()) ;
 351
 352     //set momentum and energy first
 353     Float_t    e = emc->GetEnergy() ;
 354     TVector3 dir = GetMomentumDirection(emc,cpv) ;
 355     dir.SetMag(e) ;
 356
 357     rp->SetMomentum(dir.X(),dir.Y(),dir.Z(),e) ;
 358     rp->SetCalcMass(0);
 359
 360     //now set type (reconstructed) of the particle
 361     Int_t showerprofile = 0;  // 0 narrow and 1 wide
 362
 363     if(ellips){
 364       Float_t lambda[2] ;
 365       emc->GetElipsAxis(lambda) ;
 366       if(fFormula->Eval(lambda[0],lambda[1]) <= 0 )
 367         showerprofile = 1 ;  // not narrow
 368     }
 369
 370     if(disp)
 371       if(emc->GetDispersion() > fDispersion )
 372         showerprofile = 1 ;  // not narrow
 373
 374     Int_t slow = 0 ;
 375     if(time)
 376       if(emc->GetTime() > fTimeGate )
 377         slow = 0 ;
 378
 379     // Looking at the CPV detector
 380     Int_t cpvdetector= 0 ;  //1 hit and 0 no hit
 381     if(cpv)
 382       if(ts->GetCpvDistance("R") < fCpvEmcDistance)
 383         cpvdetector = 1 ;
 384
 385     Int_t type = showerprofile + 2 * slow  + 4 * cpvdetector ;
 386     rp->SetType(type) ;
 387     rp->SetProductionVertex(0,0,0,0);
 388     rp->SetFirstMother(-1);
 389     rp->SetLastMother(-1);
 390     rp->SetFirstDaughter(-1);
 391     rp->SetLastDaughter(-1);
 392     rp->SetPolarisation(0,0,0);
 393     index++ ;
 394   }
 395
 396 }
 397
 398 //____________________________________________________________________________
 399 void  AliPHOSPIDv0:: Print(const Option_t *) const
 400 {
 401   // Print the parameters used for the particle type identification
 402   TString message ;
 403   message  = "=============== AliPHOSPIDv0 ================\n" ;
 404   message += "Making PID\n" ;
 405   message += "    Headers file:               %s\n" ;
 406   message += "    RecPoints branch title:     %s\n" ;
 407   message += "    TrackSegments Branch title: %s\n" ;
 408   message += "    RecParticles Branch title   %s\n" ;
 409   message += "with parameters:\n"  ;
 410   message += "    Maximal EMC - CPV  distance (cm) %f\n" ;
 411   AliInfo(Form( message.Data(),
 412        GetTitle(),
 413        fRecPointsTitle.Data(),
 414        fTrackSegmentsTitle.Data(),
 415        fRecParticlesTitle.Data(),
 416        fCpvEmcDistance ));
 417
 418   if(fIDOptions.Contains("dis",TString::kIgnoreCase ))
 419     AliInfo(Form("                    dispersion cut %f",  fDispersion )) ;
 420   if(fIDOptions.Contains("ell",TString::kIgnoreCase ))
 421     AliInfo(Form("             Eliptic cuts function: %s",
 422                  fFormula->GetTitle() )) ;
 423   if(fIDOptions.Contains("tim",TString::kIgnoreCase ))
 424     AliInfo(Form("             Time Gate used: %f",  fTimeGate)) ;
 425 }
 426
 427 //____________________________________________________________________________
 428 void  AliPHOSPIDv0::SetShowerProfileCut(const char * formula)
 429 {
 430   //set shape of the cut on the axis of ellipce, drown around shouer
 431   //shower considered "narrow" if Formula(lambda[0],lambda[1]) > 0.
 432   if(fFormula)
 433     delete fFormula;
 434   fFormula = new TFormula("Lambda Cut",formula) ;
 435 }
 436 //____________________________________________________________________________
 437 void  AliPHOSPIDv0::WriteRecParticles()
 438 {
 439   // Saves the reconstructed particles too a file
 440
 441   AliRunLoader* runget = AliRunLoader::GetRunLoader(GetTitle());
 442   if(runget == 0x0)
 443    {
 444      AliError(Form("Can not find run getter in event folder \"%s\"",
 445                    GetTitle()));
 446      return;
 447    }
 448
 449   AliPHOSLoader* gime = dynamic_cast<AliPHOSLoader*>(runget->GetLoader("PHOSLoader"));
 450   if ( gime == 0 )
 451    {
 452      AliError("Could not obtain the Loader object !");
 453      return ;
 454    }
 455
 456   TClonesArray * recParticles = gime->RecParticles() ;
 457   recParticles->Expand(recParticles->GetEntriesFast() ) ;
 458
 459   TTree * treeR = gime->TreeR();
 460
 461   if(!treeR){
 462     gime->MakeTree("R");
 463     treeR = gime->TreeR() ;
 464   }
 465
 466   //First rp
 467   Int_t bufferSize = 32000 ;
 468   TBranch * rpBranch = treeR->Branch("PHOSRP",&recParticles,bufferSize);
 469   rpBranch->SetTitle(fRecParticlesTitle);
 470
 471   //second, pid
 472   Int_t splitlevel = 0 ;
 473   AliPHOSPIDv0 * pid = this ;
 474   TBranch * pidBranch = treeR->Branch("AliPHOSPID","AliPHOSPIDv0",&pid,bufferSize,splitlevel);
 475   pidBranch->SetTitle(fRecParticlesTitle.Data());
 476
 477   rpBranch->Fill() ;
 478   pidBranch->Fill() ;
 479
 480   gime->WriteRecParticles("OVERWRITE");
 481   gime->WritePID("OVERWRITE");
 482
 483 }
 484
 485 //____________________________________________________________________________
 486 void  AliPHOSPIDv0::PlotDispersionCuts()const
 487 {
 488   // produces a plot of the dispersion cut
 489   TCanvas*  lambdas = new TCanvas("lambdas","Cuts on the ellipse axis",200,10,700,500);
 490
 491   if(fIDOptions.Contains("ell",TString::kIgnoreCase ) ){
 492     TF2 * ell = new TF2("Elliptic Cuts",fFormula->GetName(),0,3,0,3) ;
 493     ell->SetMinimum(0.0000001) ;
 494     ell->SetMaximum(0.001) ;
 495     ell->SetLineStyle(1) ;
 496     ell->SetLineWidth(2) ;
 497     ell->Draw() ;
 498   }
 499
 500   if( fIDOptions.Contains("dis",TString::kIgnoreCase ) ){
 501     TF2 * dsp = new TF2("dispersion","(y<x)*(x*x+y*y < [0]*[0])",0,3,0,3) ;
 502     dsp->SetParameter(0,fDispersion) ;
 503     dsp->SetMinimum(0.0000001) ;
 504     dsp->SetMaximum(0.001) ;
 505     dsp->SetLineStyle(1) ;
 506     dsp->SetLineColor(2) ;
 507     dsp->SetLineWidth(2) ;
 508     dsp->SetNpx(200) ;
 509     dsp->SetNpy(200) ;
 510     if(fIDOptions.Contains("ell",TString::kIgnoreCase ) )
 511       dsp->Draw("same") ;
 512     else
 513       dsp->Draw() ;
 514   }
 515   lambdas->Update();
 516 }
 517
 518 //____________________________________________________________________________
 519 TVector3 AliPHOSPIDv0::GetMomentumDirection(AliPHOSEmcRecPoint * emc, AliPHOSRecPoint * )const
 520 {
 521   // Calculates the momentum direction:
 522   //   1. if only a EMC RecPoint, direction is given by IP and this RecPoint
 523   //   2. if a EMC RecPoint and CPV RecPoint, direction is given by the line through the 2 recpoints
 524   //  However because of the poor position resolution of PPSD the direction is always taken as if we were
 525   //  in case 1.
 526
 527   TVector3 dir(0,0,0) ;
 528
 529   TVector3 emcglobalpos ;
 530   TMatrix  dummy ;
 531
 532   emc->GetGlobalPosition(emcglobalpos, dummy) ;
 533
 534
 535   // The following commented code becomes valid once the PPSD provides
 536   // a reasonable position resolution, at least as good as EMC !
 537   //   TVector3 ppsdlglobalpos ;
 538   //   TVector3 ppsduglobalpos ;
 539   //   if( fPpsdLowRecPoint ){ // certainly a photon that has concerted
 540   //     fPpsdLowRecPoint->GetGlobalPosition(ppsdlglobalpos, mdummy) ;
 541   //     dir = emcglobalpos -  ppsdlglobalpos ;
 542   //     if( fPpsdUpRecPoint ){ // not looks like a charged
 543   //        fPpsdUpRecPoint->GetGlobalPosition(ppsduglobalpos, mdummy) ;
 544   //        dir = ( dir +  emcglobalpos -  ppsduglobalpos ) * 0.5 ;
 545   //      }
 546   //   }
 547   //   else { // looks like a neutral
 548   //    dir = emcglobalpos ;
 549   //  }
 550
 551   dir = emcglobalpos ;
 552   dir.SetZ( -dir.Z() ) ;   // why ?
 553   dir.SetMag(1.) ;
 554
 555   //account correction to the position of IP
 556   Float_t xo,yo,zo ; //Coordinates of the origin
 557   gAlice->Generator()->GetOrigin(xo,yo,zo) ;
 558   TVector3 origin(xo,yo,zo);
 559   dir = dir - origin ;
 560
 561   return dir ;
 562 }
 563 //____________________________________________________________________________
 564 void AliPHOSPIDv0::PrintRecParticles(Option_t * option)
 565 {
 566   // Print table of reconstructed particles
 567
 568   AliRunLoader* runget = AliRunLoader::GetRunLoader(GetTitle());
 569   if(runget == 0x0)
 570    {
 571      AliError(Form("Can not find run getter in event folder \"%s\"",
 572                    GetTitle()));
 573      return;
 574    }
 575
 576   AliPHOSLoader* gime = dynamic_cast<AliPHOSLoader*>(runget->GetLoader("PHOSLoader"));
 577   if ( gime == 0 )
 578    {
 579      AliError("Could not obtain the Loader object !");
 580      return ;
 581    }
 582
 583   TString taskName(GetName()) ;
 584   taskName.Remove(taskName.Index(Version())-1) ;
 585   TClonesArray * recParticles = gime->RecParticles() ;
 586
 587   TString message ;
 588   message  = "event %d\n" ;
 589   message += "       found %d RecParticles\n" ;
 590   AliInfo(Form(message.Data(),
 591                gAlice->GetEvNumber(), recParticles->GetEntriesFast() )) ;
 592
 593   if(strstr(option,"all")) {  // printing found TS
 594     AliInfo("  PARTICLE   Index"  ) ;
 595
 596     Int_t index ;
 597     for (index = 0 ; index < recParticles->GetEntries() ; index++) {
 598       AliPHOSRecParticle * rp = (AliPHOSRecParticle * ) recParticles->At(index) ;
 599
 600       Text_t particle[11];
 601       switch(rp->GetType()) {
 602       case  AliPHOSFastRecParticle::kNEUTRALEMFAST:
 603         strcpy( particle, "NEUTRAL EM FAST");
 604         break;
 605       case  AliPHOSFastRecParticle::kNEUTRALHAFAST:
 606         strcpy(particle, "NEUTRAL HA FAST");
 607         break;
 608       case  AliPHOSFastRecParticle::kNEUTRALEMSLOW:
 609         strcpy(particle, "NEUTRAL EM SLOW");
 610         break ;
 611       case  AliPHOSFastRecParticle::kNEUTRALHASLOW:
 612         strcpy(particle, "NEUTRAL HA SLOW");
 613         break ;
 614       case  AliPHOSFastRecParticle::kCHARGEDEMFAST:
 615         strcpy(particle, "CHARGED EM FAST") ;
 616         break ;
 617       case  AliPHOSFastRecParticle::kCHARGEDHAFAST:
 618         strcpy(particle, "CHARGED HA FAST") ;
 619         break ;
 620       case  AliPHOSFastRecParticle::kCHARGEDEMSLOW:
 621         strcpy(particle, "CHARGEDEMSLOW") ;
 622         break ;
 623       case  AliPHOSFastRecParticle::kCHARGEDHASLOW:
 624         strcpy(particle, "CHARGED HA SLOW") ;
 625         break ;
 626       }
 627
 628       //    Int_t * primaries;
 629       //    Int_t nprimaries;
 630       //    primaries = rp->GetPrimaries(nprimaries);
 631
 632       AliInfo(Form("          %s     %d",
 633                    particle, rp->GetIndexInList())) ;
 634     }
 635   }
 636 }
 637
 638
 639