PHOS/AliPHOSLoader.h

   1 #ifndef ALIPHOSLOADER_H
   2 #define ALIPHOSLOADER_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 /* $Id$ */
   7
   8 /* History of cvs commits:
   9  *
  10  * $Log$
  11  * Revision 1.12  2006/08/25 16:00:53  kharlov
  12  * Compliance with Effective C++AliPHOSHit.cxx
  13  *
  14  * Revision 1.11  2006/08/01 12:15:03  cvetan
  15  * Adding a constructor from TFolder. Needed by AliReconstruction plugin scheme
  16  *
  17  * Revision 1.10  2005/05/28 14:19:04  schutz
  18  * Compilation warnings fixed by T.P.
  19  *
  20  */
  21
  22 //_________________________________________________________________________
  23 //  A singleton that returns various objects
  24 //  Should be used on the analysis stage to avoid confusing between different
  25 //  branches of reconstruction tree: e.g. reading RecPoints and TS made from
  26 //  another set of RecPoints.
  27 //
  28 //  The objects are retrived from folders.
  29 //-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
  30 //
  31
  32
  33 // --- ROOT system ---
  34 class TString ;
  35 class TParticle ;
  36 class TTask ;
  37 #include <TClonesArray.h>
  38 #include <TTree.h>
  39
  40 // --- Standard library ---
  41
  42 // --- AliRoot header files ---
  43 #include "AliRun.h"
  44 #include "AliLoader.h"
  45 #include "AliRunLoader.h"
  46 #include "AliPHOSClusterizer.h"
  47 #include "AliPHOSTrackSegmentMaker.h"
  48 #include "AliPHOSPID.h"
  49 class AliPHOS ;
  50 class AliPHOSHit ;
  51 class AliPHOSDigit ;
  52 class AliPHOSEmcRecPoint ;
  53 class AliPHOSCpvRecPoint ;
  54 class AliPHOSTrackSegment ;
  55 class AliPHOSRecParticle ;
  56 class AliPHOSSDigitizer ;
  57 class AliPHOSDigitizer ;
  58
  59 class AliPHOSLoader : public AliLoader {
  60
  61 public:
  62
  63   AliPHOSLoader();
  64   AliPHOSLoader(const Char_t *detname,const Char_t *eventfoldername);
  65   AliPHOSLoader(const Char_t *detname,TFolder *topfolder);
  66
  67   virtual ~AliPHOSLoader() ;
  68
  69   Int_t   GetEvent();//extends the method on PHOS RecPart posting
  70   Int_t   SetEvent();//extends the method on PHOS RecPart posting
  71
  72   Bool_t  BranchExists(const TString& recName);
  73   Int_t   LoadHits(Option_t* opt=""); //reads  from disk and sends them to folder; array as well as tree
  74   Int_t   LoadSDigits(Option_t* opt="");
  75   Int_t   LoadDigits(Option_t* opt=""); //reads Digits from disk and sends them to folder; array as well as tree
  76   Int_t   LoadRecPoints(Option_t* opt=""); //reads RecPoints from disk and sends them to folder; array as well as tree
  77   Int_t   LoadTracks(Option_t* opt="");  //reads Tracks from disk and sends them to folder; array as well as tree
  78   Int_t   LoadRecParticles(Option_t* opt="");
  79
  80   Int_t   PostHits()const;  //Posts the
  81   Int_t   PostSDigits()const;
  82   Int_t   PostDigits()const;
  83   Int_t   PostRecPoints()const;
  84   Int_t   PostTracks()const;
  85   Int_t   PostRecParticles()const;
  86
  87   void    CleanFolders();//cleans all the stuff loaded by this detector + calls AliLoader::Clean
  88
  89   void    CleanHits()const;
  90   void    CleanSDigits()const;
  91   void    CleanDigits()const;
  92   void    CleanRecPoints()const;
  93   void    CleanTracks()const;
  94   void    CleanRecParticles();
  95
  96 //up to now it is only here -> no definition about global/incremental tracking/PID
  97
  98 //   Int_t   WriteRecParticles(Option_t* opt="");//writes the reconstructed particles
  99 //   Int_t   WritePID(Option_t* opt="");//writes the task for PID to file
 100 //   Bool_t  PostPID  (AliPHOSPID * pid) const {return kTRUE;}
 101
 102 /*******************************************************************/
 103 /*******************************************************************/
 104 /*******************************************************************/
 105
 106   TObject** HitsRef(){return GetDetectorDataRef(Hits());}
 107   TObject** SDigitsRef(){return GetDetectorDataRef(SDigits());}
 108   TObject** DigitsRef(){return GetDetectorDataRef(Digits());}
 109   TObject** EmcRecPointsRef(){return GetDetectorDataRef(EmcRecPoints());}
 110   TObject** CpvRecPointsRef(){return GetDetectorDataRef(CpvRecPoints());}
 111   TObject** TracksRef(){return GetDetectorDataRef(TrackSegments());}
 112   TObject** RecParticlesRef(){return GetDetectorDataRef(RecParticles());}
 113   TObject** AlarmsRef(){return GetDetectorDataRef(Alarms());}
 114   void   Track(Int_t itrack) ;
 115
 116   static AliPHOSLoader* GetPHOSLoader(const  char* eventfoldername);
 117
 118   //Method to be used when digitizing under AliRunDigitizer, who opens all files etc.
 119   Int_t  EventNumber()       { return (Int_t) GetRunLoader()->GetEventNumber();}
 120   Int_t  MaxEvent()          { return (Int_t) GetRunLoader()->TreeE()->GetEntries();}
 121
 122 /*   const AliPHOS *         PHOS(); */
 123   // Alarms
 124   // TFolder * Alarms() const { return (TFolder*)(ReturnO("Alarms", 0)); }
 125   TObjArray *  Alarms() {return 0x0;}
 126
 127   /*********************************************/
 128   /************    TClonesArrays     ***********/
 129   /*********************************************/
 130   /****   H i t s  ****/
 131   TClonesArray*  Hits(void);
 132   const AliPHOSHit*    Hit(Int_t index);
 133   void MakeHitsArray();
 134   /****   S D i g i t s  ****/
 135   TClonesArray*  SDigits();
 136   const AliPHOSDigit*  SDigit(Int_t index);
 137   void MakeSDigitsArray();
 138   /****  D i g i t s  ****/
 139   TClonesArray*   Digits();
 140   const AliPHOSDigit *  Digit(Int_t index);
 141   void MakeDigitsArray();
 142   /****  R e c P o i n t s  ****/
 143   TObjArray * EmcRecPoints();
 144   TObjArray * CpvRecPoints();
 145   const AliPHOSEmcRecPoint * EmcRecPoint(Int_t index) ;
 146   const AliPHOSCpvRecPoint * CpvRecPoint(Int_t index) ;
 147   void MakeRecPointsArray();
 148   /****   T r a c k S e g m e n t s ****/
 149   TClonesArray * TrackSegments();
 150   const AliPHOSTrackSegment * TrackSegment(Int_t index);
 151   void MakeTrackSegmentsArray();
 152   /****  R e c P a r t ic l e s   ****/
 153   TClonesArray * RecParticles() ;
 154   const AliPHOSRecParticle * RecParticle(Int_t index);
 155   void MakeRecParticlesArray();
 156
 157   /*********************************************/
 158   /************    T A S K S      **************/
 159   /*********************************************/
 160   //
 161   //  AliPHOSSDigitizer*  PHOSSDigitizer(TString name = AliConfig::GetDefaultEventFolderName());
 162   //AliPHOSDigitizer*   PHOSDigitizer()  { return  dynamic_cast<AliPHOSDigitizer*>(Digitizer()) ;}
 163
 164   AliPHOSPID * PID () const {return dynamic_cast<AliPHOSPID*>(PIDTask()) ;}
 165   Int_t LoadPID(Option_t * opt="") const {return LoadPIDTask(opt);}
 166   Int_t WritePID(Option_t * opt="") const {return WritePIDTask(opt);}
 167
 168
 169   AliPHOSTrackSegmentMaker * TrackSegmentMaker () const { return dynamic_cast<AliPHOSTrackSegmentMaker *>(Tracker()) ;}
 170   Int_t LoadTrackSegmentMaker(Option_t * opt="") const {return LoadTracker(opt);}
 171   Int_t WriteTrackSegmentMaker(Option_t * opt="") const {return WriteTracker(opt);}
 172
 173
 174   void   SetDebug(Int_t level) {fDebug = level;} // Set debug level
 175   void   SetBranchTitle(const TString& btitle);
 176
 177   Int_t   GetDebug()                     const {return fDebug;      }
 178   TString GetBranchTitle()               const {return fBranchTitle;}
 179
 180 protected:
 181   TString fBranchTitle;            //Title of the branch
 182
 183 private:
 184
 185   // assignement operator requested by coding convention, but not needed
 186   AliPHOSLoader(const AliPHOSLoader &);                //Not implemented
 187   AliPHOSLoader & operator = (const AliPHOSLoader & ); //Not implemented
 188
 189   Int_t ReadHits();
 190   Int_t ReadDigits();
 191   Int_t ReadSDigits();
 192   Int_t ReadRecPoints();
 193   Int_t ReadTracks();
 194   Int_t ReadRecParticles();
 195
 196   Int_t  fDebug ;             // Debug level
 197   TClonesArray *fTmpHits;     //! Temporary array of hits per track
 198
 199   static const TString fgkHitsName;//Name for TClonesArray with hits from one event
 200   static const TString fgkSDigitsName;//Name for TClonesArray
 201   static const TString fgkDigitsName;//Name for TClonesArray
 202   static const TString fgkEmcRecPointsName;//Name for TClonesArray
 203   static const TString fgkCpvRecPointsName;//Name for TClonesArray
 204   static const TString fgkTracksName;//Name for TClonesArray
 205   static const TString fgkRecParticlesName;//Name for TClonesArray
 206
 207   static const TString fgkEmcRecPointsBranchName;//Name for branch
 208   static const TString fgkCpvRecPointsBranchName;//Name for branch
 209   static const TString fgkTrackSegmentsBranchName;//Name for branch
 210   static const TString fgkRecParticlesBranchName;//Name for branch
 211
 212
 213   ClassDef(AliPHOSLoader,4)  // Algorithm class that provides methods to retrieve objects from a list knowing the index
 214
 215 };
 216
 217 /******************************************************************************/
 218 /****************    I N L I N E S     ****************************************/
 219 /******************************************************************************/
 220
 221 inline TClonesArray* AliPHOSLoader::Hits()
 222 {
 223  return (TClonesArray*)GetDetectorData(fgkHitsName);
 224 }
 225 /******************************************************************************/
 226
 227 inline const AliPHOSHit* AliPHOSLoader::Hit(Int_t index)
 228 {
 229   const TClonesArray* tcarr = Hits();
 230   if (tcarr)
 231     return (const AliPHOSHit*) tcarr->At(index);
 232   return 0x0;
 233 }
 234 /******************************************************************************/
 235
 236 inline TClonesArray* AliPHOSLoader::SDigits()
 237 {
 238    return dynamic_cast<TClonesArray*>(GetDetectorData(fgkSDigitsName));
 239 }
 240 /******************************************************************************/
 241
 242 inline const AliPHOSDigit*  AliPHOSLoader::SDigit(Int_t index)
 243 {
 244   const TClonesArray* tcarr = SDigits();
 245   if (tcarr)
 246     return (const AliPHOSDigit*) tcarr->At(index);
 247   return 0x0;
 248 }
 249 /******************************************************************************/
 250
 251 inline TClonesArray* AliPHOSLoader::Digits()
 252 {
 253  return dynamic_cast<TClonesArray*>(GetDetectorData(fgkDigitsName));
 254 }
 255 /******************************************************************************/
 256
 257 inline const AliPHOSDigit*  AliPHOSLoader::Digit(Int_t index)
 258 {
 259   const TClonesArray* tcarr = Digits();
 260   if (tcarr)
 261     return (const AliPHOSDigit*) tcarr->At(index);
 262   return 0x0;
 263 }
 264 /******************************************************************************/
 265
 266 inline TObjArray * AliPHOSLoader::EmcRecPoints()
 267 {
 268  return dynamic_cast<TObjArray*>(GetDetectorData(fgkEmcRecPointsName));
 269 }
 270 /******************************************************************************/
 271
 272 inline const AliPHOSEmcRecPoint * AliPHOSLoader::EmcRecPoint(Int_t index)
 273 {
 274   TObjArray* tcarr = EmcRecPoints();
 275   if (tcarr)
 276     return (const AliPHOSEmcRecPoint*) tcarr->At(index);
 277   return 0x0;
 278 }
 279 /******************************************************************************/
 280
 281 inline TObjArray * AliPHOSLoader::CpvRecPoints()
 282 {
 283  return dynamic_cast<TObjArray*>(GetDetectorData(fgkCpvRecPointsName));
 284 }
 285 /******************************************************************************/
 286
 287 inline const AliPHOSCpvRecPoint * AliPHOSLoader::CpvRecPoint(Int_t index)
 288 {
 289   TObjArray* tcarr = CpvRecPoints();
 290   if (tcarr)
 291     return (const AliPHOSCpvRecPoint*) tcarr->At(index);
 292   return 0x0;
 293 }
 294 /******************************************************************************/
 295
 296 inline TClonesArray * AliPHOSLoader::TrackSegments()
 297 {
 298  return dynamic_cast<TClonesArray*>(GetDetectorData(fgkTracksName));
 299 }
 300 /******************************************************************************/
 301
 302 inline const AliPHOSTrackSegment * AliPHOSLoader::TrackSegment(Int_t index)
 303 {
 304   const TClonesArray* tcarr = TrackSegments();
 305   if (tcarr)
 306     return (const AliPHOSTrackSegment*) tcarr->At(index);
 307   return 0x0;
 308 }
 309 /******************************************************************************/
 310
 311 inline TClonesArray * AliPHOSLoader::RecParticles()
 312 {
 313  return dynamic_cast<TClonesArray*>(GetDetectorData(fgkRecParticlesName));
 314 }
 315 /******************************************************************************/
 316
 317 inline const AliPHOSRecParticle* AliPHOSLoader::RecParticle(Int_t index)
 318 {
 319   TClonesArray* tcarr = RecParticles();
 320   if (tcarr)
 321     return (const AliPHOSRecParticle*) tcarr->At(index);
 322   return 0x0;
 323 }
 324
 325 #endif // AliPHOSLOADER_H