HBTAN/AliHBTReader.cxx

   1 #include "AliHBTReader.h"
   2 //_________________________________________________________________________
   3 ///////////////////////////////////////////////////////////////////////////
   4 //
   5 // class AliHBTReader
   6 //
   7 // Reader Base class (reads particles and tracks and
   8 // puts it to the AliHBTRun objects
   9 //
  10 // Provides functionality for both buffering and non-buffering reading
  11 // This can be switched on/off via method SetEventBuffering(bool)
  12 // The main method that inheriting classes need to implement is ReadNext()
  13 // that read next event in queue.
  14 // The others are:
  15 // Bool_t  ReadsTracks() const; specifies if reader is able to read simulated particles
  16 // Bool_t  ReadsParticles() const; specifies if reader is able to read reconstructed tracks
  17 // void    Rewind(); rewind reading to the beginning
  18 //
  19 // reading of next event is triggered via method Next()
  20 //
  21 // This class provides full functionality for reading from many sources
  22 // User can provide TObjArray of TObjString (SetDirs method or via parameter
  23 // in constructor) which desribes paths of directories to search data in.
  24 // If none specified current directory is searched.
  25 //
  26 // Piotr.Skowronski@cern.ch
  27 ///////////////////////////////////////////////////////////////////////////
  28
  29 #include <TString.h>
  30 #include <TObjString.h>
  31 #include <TObjArray.h>
  32 #include <TClass.h>
  33 #include <TRandom.h>
  34 #include <TH1.h>
  35
  36 #include "AliHBTParticleCut.h"
  37 #include "AliHBTEvent.h"
  38 #include "AliHBTRun.h"
  39
  40 ClassImp(AliHBTReader)
  41 //pure virtual
  42
  43 /*************************************************************************************/
  44
  45 AliHBTReader::AliHBTReader():
  46  fCuts(new TObjArray()),
  47  fDirs(0x0),
  48  fCurrentEvent(0),
  49  fCurrentDir(0),
  50  fNEventsRead(0),
  51  fTracksEvent(0x0),
  52  fParticlesEvent(0x0),
  53  fParticles(0x0),
  54  fTracks(0x0),
  55  fIsRead(kFALSE),
  56  fBufferEvents(kFALSE),
  57  fBlend(kFALSE),
  58  fFirst(0),
  59  fLast(0),
  60  fTrackCounter(0x0)
  61 {
  62 //constructor
  63 }
  64 /*************************************************************************************/
  65
  66 AliHBTReader::AliHBTReader(TObjArray* dirs):
  67  fCuts(new TObjArray()),
  68  fDirs(dirs),
  69  fCurrentEvent(0),
  70  fCurrentDir(0),
  71  fNEventsRead(0),
  72  fTracksEvent(0x0),
  73  fParticlesEvent(0x0),
  74  fParticles(0x0),
  75  fTracks(0x0),
  76  fIsRead(kFALSE),
  77  fBufferEvents(kFALSE),
  78  fBlend(kFALSE),
  79  fFirst(0),
  80  fLast(0),
  81  fTrackCounter(0x0)
  82 {
  83 //ctor with array of directories to read as parameter
  84 }
  85 /*************************************************************************************/
  86 AliHBTReader::AliHBTReader(const AliHBTReader& in):
  87  TNamed(in),
  88  fCuts((in.fCuts)?(TObjArray*)in.fCuts->Clone():0x0),
  89  fDirs((in.fDirs)?(TObjArray*)in.fDirs->Clone():0x0),
  90  fCurrentEvent(0),
  91  fCurrentDir(0),
  92  fNEventsRead(0),
  93  fTracksEvent(0x0),
  94  fParticlesEvent(0x0),
  95  fParticles(0x0),
  96  fTracks(0x0),
  97  fIsRead(kFALSE),
  98  fBufferEvents(in.fBufferEvents),
  99  fBlend(in.fBlend),
 100  fFirst(in.fFirst),
 101  fLast(in.fLast),
 102  fTrackCounter(0x0)
 103 {
 104  //cpy constructor
 105 }
 106
 107 AliHBTReader::~AliHBTReader()
 108 {
 109 //destructor
 110  if(fCuts)
 111   {
 112    fCuts->SetOwner();
 113    delete fCuts;
 114   }
 115  delete fParticlesEvent;
 116  delete fTracksEvent;
 117  delete fTrackCounter;
 118 }
 119 /*************************************************************************************/
 120
 121 AliHBTReader& AliHBTReader::operator=(const AliHBTReader& in)
 122 {
 123   //Assigment operator
 124  if (this == &in) return *this;
 125  TNamed::operator=( (const TNamed&)in );
 126
 127  fCuts = (in.fCuts)?(TObjArray*)in.fCuts->Clone():0x0;
 128  fDirs = (in.fDirs)?(TObjArray*)in.fDirs->Clone():0x0;
 129  fCurrentEvent = 0;
 130  fCurrentDir = 0;
 131  fNEventsRead = 0;
 132  fTracksEvent = 0x0;
 133  fParticlesEvent = 0x0;
 134  fParticles = 0x0;
 135  fTracks = 0x0;
 136  fIsRead = kFALSE;
 137  fBufferEvents = in.fBufferEvents;
 138  fBlend = in.fBlend;
 139  fFirst = in.fFirst;
 140  fLast = in.fLast;
 141  fTrackCounter = 0x0;
 142  return *this;
 143 }
 144 /*************************************************************************************/
 145
 146 Int_t AliHBTReader::Next()
 147 {
 148 //moves to next event
 149
 150   //if asked to read up to event nb. fLast, and it is overcome, report no more events
 151   if ((fNEventsRead > fLast) && (fLast > 0) ) return kTRUE;
 152
 153   if (fTrackCounter == 0x0)//create Track Counter
 154    {
 155      fTrackCounter = new TH1I("trackcounter","Track Counter",20000,0,20000);
 156      fTrackCounter->SetDirectory(0x0);
 157    }
 158
 159   do //if asked to read from event fFirst, rewind to it
 160    {
 161     if ( ReadNext() == kTRUE) //if no more evets, return it
 162       return kTRUE;
 163    }while (fNEventsRead < fFirst);
 164
 165   //here we have event
 166
 167   if (fBlend) Blend();//Mix particles order
 168
 169   if (fBufferEvents)//store events if buffering is on
 170    {
 171      if ( ReadsTracks() && fTracksEvent)
 172        fTracks->SetEvent(fNEventsRead-1-fFirst,fTracksEvent);
 173      if ( ReadsParticles() && fParticlesEvent)
 174        fParticles->SetEvent(fNEventsRead-1-fFirst,fParticlesEvent);
 175    }
 176   return kFALSE;
 177 }
 178 /*************************************************************************************/
 179
 180 void AliHBTReader::AddParticleCut(AliHBTParticleCut* cut)
 181 {
 182  //sets the new cut
 183
 184   if (!cut) //if cut is NULL return with error
 185    {
 186     Error("AddParticleType","NULL pointers are not accepted any more.\nIf You want to accept all particles of this type, set an empty cut ");
 187     return;
 188    }
 189   AliHBTParticleCut *c = (AliHBTParticleCut*)cut->Clone();
 190   fCuts->Add(c);
 191 }
 192 /********************************************************************/
 193
 194 AliHBTEvent* AliHBTReader::GetParticleEvent(Int_t n)
 195  {
 196  //returns Nth event with simulated particles
 197   if (ReadsParticles() == kFALSE)
 198    {
 199      Error("GetParticleEvent","This reader is not able to provide simulated particles.");
 200      return 0;
 201    }
 202
 203   if (!fIsRead)
 204    {
 205     if (ReadsParticles() && (fParticles == 0x0)) fParticles = new AliHBTRun();
 206     if (ReadsTracks() && (fTracks == 0x0)) fTracks = new AliHBTRun();
 207
 208     if (Read(fParticles,fTracks))
 209      {
 210        Error("GetParticleEvent","Error in reading");
 211        return 0x0;
 212      }
 213     else fIsRead = kTRUE;
 214    }
 215   return fParticles->GetEvent(n);
 216  }
 217 /********************************************************************/
 218
 219 AliHBTEvent* AliHBTReader::GetTrackEvent(Int_t n)
 220  {
 221  //returns Nth event with reconstructed tracks
 222   if (ReadsTracks() == kFALSE)
 223    {
 224      Error("GetTrackEvent","This reader is not able to provide recosntructed tracks.");
 225      return 0;
 226    }
 227   if (!fIsRead)
 228    {
 229     if (ReadsParticles() && (fParticles == 0x0)) fParticles = new AliHBTRun();
 230     if (ReadsTracks() && (fTracks == 0x0)) fTracks = new AliHBTRun();
 231
 232     if(Read(fParticles,fTracks))
 233      {
 234        Error("GetTrackEvent","Error in reading");
 235        return 0x0;
 236      }
 237     else fIsRead = kTRUE;
 238    }
 239   return fTracks->GetEvent(n);
 240  }
 241 /********************************************************************/
 242
 243 Int_t AliHBTReader::GetNumberOfPartEvents()
 244  {
 245  //returns number of events of particles
 246   if (ReadsParticles() == kFALSE)
 247    {
 248      Error("GetNumberOfPartEvents","This reader is not able to provide simulated particles.");
 249      return 0;
 250    }
 251
 252   if (!fIsRead)
 253    {
 254     if (ReadsParticles() && (fParticles == 0x0)) fParticles = new AliHBTRun();
 255     if (ReadsTracks() && (fTracks == 0x0)) fTracks = new AliHBTRun();
 256
 257     if (Read(fParticles,fTracks))
 258      {
 259        Error("GetNumberOfPartEvents","Error in reading");
 260        return 0;
 261      }
 262     else fIsRead = kTRUE;
 263    }
 264    return fParticles->GetNumberOfEvents();
 265  }
 266 /********************************************************************/
 267
 268 Int_t AliHBTReader::GetNumberOfTrackEvents()
 269  {
 270  //returns number of events of tracks
 271   if (ReadsTracks() == kFALSE)
 272    {
 273      Error("GetNumberOfTrackEvents","This reader is not able to provide recosntructed tracks.");
 274      return 0;
 275    }
 276   if (!fIsRead)
 277    {
 278      if (ReadsParticles() && (fParticles == 0x0)) fParticles = new AliHBTRun();
 279      if (ReadsTracks() && (fTracks == 0x0)) fTracks = new AliHBTRun();
 280
 281      if(Read(fParticles,fTracks))
 282       {
 283         Error("GetNumberOfTrackEvents","Error in reading");
 284         return 0;
 285       }
 286      else fIsRead = kTRUE;
 287    }
 288   return fTracks->GetNumberOfEvents();
 289  }
 290 /********************************************************************/
 291
 292 Int_t AliHBTReader::Read(AliHBTRun* particles, AliHBTRun *tracks)
 293 {
 294  //reads data and puts put to the particles and tracks objects
 295  //reurns 0 if everything is OK
 296  //
 297   Info("Read","");
 298
 299   if ( ReadsParticles() && (particles == 0x0) ) //check if an object is instatiated
 300    {
 301      Error("Read"," particles object must be instatiated before passing it to the reader");
 302      return 1;
 303    }
 304   if ( ReadsTracks() && (tracks == 0x0) )  //check if an object is instatiated
 305    {
 306      Error("Read"," tracks object must be instatiated before passing it to the reader");
 307      return 1;
 308    }
 309
 310   if (ReadsParticles()) particles->Reset();//clear runs == delete all old events
 311   if (ReadsTracks()) tracks->Reset();
 312
 313   Rewind();
 314
 315   Int_t i = 0;
 316   while(Next() == kFALSE)
 317    {
 318      if (ReadsTracks()) tracks->SetEvent(i,fTracksEvent);
 319      if (ReadsParticles()) particles->SetEvent(i,fParticlesEvent);
 320      i++;
 321    }
 322   return 0;
 323 }
 324 /*************************************************************************************/
 325
 326 Bool_t AliHBTReader::Pass(AliHBTParticle* p)
 327 {
 328  //Method examines whether particle meets all cut and particle type criteria
 329
 330    if(p==0x0)//of corse we not pass NULL pointers
 331     {
 332      Warning("Pass()","No Pasaran! We never accept NULL pointers");
 333      return kTRUE;
 334     }
 335    //if no particle is specified, we pass all particles
 336    //excluding NULL pointers, of course
 337   if ( fCuts->GetEntriesFast() == 0 ) return kFALSE; //if no cut specified accept all particles
 338   for(Int_t i=0; i<fCuts->GetEntriesFast(); i++)
 339    {
 340      AliHBTParticleCut &cut = *((AliHBTParticleCut*)fCuts->At(i));
 341      if(!cut.Pass(p)) return kFALSE;  //accepted
 342    }
 343
 344   return kTRUE;//not accepted
 345 }
 346 /*************************************************************************************/
 347
 348 Bool_t  AliHBTReader::Pass(Int_t pid)
 349 {
 350 //this method checks if any of existing cuts accepts this pid particles
 351 //or any cuts accepts all particles
 352
 353  if(pid == 0)
 354   return kTRUE;
 355
 356  if ( fCuts->GetEntriesFast() == 0 ) return kFALSE; //if no cut specified accept all particles
 357
 358  for(Int_t i=0; i<fCuts->GetEntriesFast(); i++)
 359    {
 360      AliHBTParticleCut &cut = *((AliHBTParticleCut*)fCuts->At(i));
 361      //if some of cuts accepts all particles or some accepts particles of this type, accept
 362      if ( (cut.GetPID() == 0) || (cut.GetPID() == pid) ) return kFALSE;
 363    }
 364  return kTRUE;
 365 }
 366 /*************************************************************************************/
 367
 368 TString& AliHBTReader::GetDirName(Int_t entry)
 369 {
 370 //returns directory name of next one to read
 371   TString* retval;//return value
 372   if (fDirs ==  0x0)
 373    {
 374      retval = new TString(".");
 375      return *retval;
 376    }
 377
 378   if ( (entry>fDirs->GetEntries()) || (entry<0))//if out of bounds return empty string
 379    {                                            //note that entry==0 is accepted even if array is empty (size=0)
 380      Error("GetDirName","Name out of bounds");
 381      retval = new TString();
 382      return *retval;
 383    }
 384
 385   if (fDirs->GetEntries() == 0)
 386    {
 387      retval = new TString(".");
 388      return *retval;
 389    }
 390
 391   TClass *objclass = fDirs->At(entry)->IsA();
 392   TClass *stringclass = TObjString::Class();
 393
 394   TObjString *dir = (TObjString*)objclass->DynamicCast(stringclass,fDirs->At(entry));
 395
 396   if(dir == 0x0)
 397    {
 398      Error("GetDirName","Object in TObjArray is not a TObjString or its descendant");
 399      retval = new TString();
 400      return *retval;
 401    }
 402   if (gDebug > 0) Info("GetDirName","Returned ok %s",dir->String().Data());
 403   return dir->String();
 404 }
 405 /*************************************************************************************/
 406
 407 void AliHBTReader::Blend()
 408 {
 409   //randomly change positions of the particles after reading
 410   //is used to check if some distr depends on order of particles
 411   //(tracking gives particles Pt sorted)
 412
 413   if (fParticlesEvent == 0x0) return;
 414
 415   for (Int_t i = 2; i < fParticlesEvent->GetNumberOfParticles(); i++)
 416    {
 417      Int_t with = gRandom->Integer(i);
 418      fParticlesEvent->SwapParticles(i,with);
 419      if (fTracksEvent) fTracksEvent->SwapParticles(i,with);
 420    }
 421 }
 422 /*************************************************************************************/
 423
 424 void AliHBTReader::WriteTrackCounter() const
 425 {
 426  //writes the counter histogram
 427
 428  if (fTrackCounter) fTrackCounter->Write(0,TObject::kOverwrite);
 429  else
 430   {
 431     Warning("WriteTrackCounter","Counter is NULL");
 432   }
 433 }