EMCAL/AliEMCALLoader.h

   1 #ifndef ALIEMCALLOADER_H
   2 #define ALIEMCALLOADER_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 //_________________________________________________________________________
   9 //  A singleton that returns various objects
  10 //  Should be used on the analysis stage to avoid confusing between different
  11 //  branches of reconstruction tree: e.g. reading RecPoints and TS made from
  12 //  another set of RecPoints.
  13 //
  14 //  The objects are retrived from folders.
  15 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
  16 //
  17
  18
  19 // --- ROOT system ---
  20 #include "TClonesArray.h"
  21 #include "TFolder.h"
  22 #include "TTree.h"
  23 class TString ;
  24 class TParticle ;
  25 class TTask ;
  26
  27 // --- Standard library ---
  28 #include <stdlib.h>
  29 #include <Riostream.h>
  30
  31 // --- AliRoot header files ---
  32
  33 #include "AliRun.h"
  34 #include "AliLoader.h"
  35 #include "AliRunLoader.h"
  36 #include "AliEMCAL.h"
  37 #include "AliEMCALHit.h"
  38 #include "AliEMCALDigit.h"
  39 #include "AliEMCALTowerRecPoint.h"
  40 #include "AliEMCALTrackSegment.h"
  41 #include "AliEMCALRecParticle.h"
  42 class AliEMCALGeometry ;
  43 #include "AliEMCALDigitizer.h"
  44 #include "AliEMCALSDigitizer.h"
  45 #include "AliEMCALClusterizer.h"
  46 #include "AliEMCALTrackSegmentMaker.h"
  47 #include "AliEMCALPID.h"
  48 class AliEMCALCalibrationDB ;
  49
  50
  51 //
  52
  53 class AliEMCALLoader : public AliLoader {
  54
  55  public:
  56
  57   AliEMCALLoader();
  58   AliEMCALLoader(const AliEMCALLoader & obj){}
  59   AliEMCALLoader(const Char_t *detname,const Char_t *eventfoldername);
  60
  61   virtual ~AliEMCALLoader() ;
  62
  63   // assignement operator requested by coding convention, but not needed
  64   AliEMCALLoader & operator = (const AliEMCALLoader & ) {return *this;}
  65
  66   Int_t   GetEvent();//extends the method on EMCAL RecPart posting
  67   Int_t   SetEvent();//extends the method on EMCAL RecPart posting
  68
  69   Bool_t  BranchExists(const TString& recName);
  70   Int_t   LoadHits(Option_t* opt=""); //reads  from disk and sends them to folder; array as well as tree
  71   Int_t   LoadSDigits(Option_t* opt="");
  72   Int_t   LoadDigits(Option_t* opt=""); //reads Digits from disk and sends them to folder; array as well as tree
  73   Int_t   LoadRecPoints(Option_t* opt=""); //reads RecPoints from disk and sends them to folder; array as well as tree
  74   Int_t   LoadTracks(Option_t* opt="");  //reads Tracks from disk and sends them to folder; array as well as tree
  75   Int_t   LoadRecParticles(Option_t* opt="");
  76
  77   void    UnloadRecParticles();
  78   void    UnloadTracks();
  79
  80   Int_t   PostHits();  //Posts the
  81   Int_t   PostSDigits();
  82   Int_t   PostDigits();
  83   Int_t   PostRecPoints();
  84   Int_t   PostTracks();
  85   Int_t   PostRecParticles();
  86
  87   void    CleanFolders();//cleans all the stuff loaded by this detector + calls AliLoader::Clean
  88
  89   void    CleanHits();
  90   void    CleanSDigits();
  91   void    CleanDigits();
  92   void    CleanRecPoints();
  93   void    CleanTracks();
  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  (AliEMCALPID * pid) const {return kTRUE;}
 101 //  Bool_t  PostQA   (void) const ; //it was empty anyway
 102
 103 /*******************************************************************/
 104 /*******************************************************************/
 105 /*******************************************************************/
 106
 107   TObject** HitsRef(){return GetDetectorDataRef(Hits());}
 108   TObject** SDigitsRef(){return GetDetectorDataRef(SDigits());}
 109   TObject** DigitsRef(){return GetDetectorDataRef(Digits());}
 110   TObject** PRERecPointsRef(){return GetDetectorDataRef(PRERecPoints());}
 111   TObject** ECARecPointsRef(){return GetDetectorDataRef(ECARecPoints());}
 112   TObject** HCARecPointsRef(){return GetDetectorDataRef(HCARecPoints());}
 113   TObject** TracksRef(){return GetDetectorDataRef(TrackSegments());}
 114   TObject** RecParticlesRef(){return GetDetectorDataRef(RecParticles());}
 115   TObject** AlarmsRef(){return GetDetectorDataRef(Alarms());}
 116   void   Track(Int_t itrack) ;
 117
 118   static AliEMCALGeometry* GetEMCALGeometry();
 119   static AliEMCALLoader* GetEMCALLoader(const  char* eventfoldername);
 120
 121   //Method to be used when digitizing under AliRunDigitizer, who opens all files etc.
 122   Int_t  EventNumber()       { return (Int_t) GetRunLoader()->GetEventNumber();}
 123   Int_t  MaxEvent()          { return (Int_t) GetRunLoader()->TreeE()->GetEntries();}
 124
 125   const AliEMCAL *         EMCAL();
 126   const AliEMCALGeometry  *EMCALGeometry() ;
 127   // Alarms
 128   // TFolder * Alarms() const { return (TFolder*)(ReturnO("Alarms", 0)); }
 129   TObjArray *  Alarms();
 130
 131   /*********************************************/
 132   /************    TClonesArrays     ***********/
 133   /*********************************************/
 134   /****   H i t s  ****/
 135   TClonesArray*  Hits(void);
 136   const AliEMCALHit*    Hit(Int_t index);
 137   void MakeHitsArray();
 138   /****   S D i g i t s  ****/
 139   TClonesArray*  SDigits();
 140   const AliEMCALDigit*  SDigit(Int_t index);
 141   void MakeSDigitsArray();
 142   /****  D i g i t s  ****/
 143   TClonesArray*   Digits();
 144   const AliEMCALDigit *  Digit(Int_t index);
 145   void MakeDigitsArray();
 146   /****  R e c P o i n t s  ****/
 147   TObjArray * PRERecPoints();
 148   TObjArray * ECARecPoints();
 149   TObjArray * HCARecPoints();
 150   const AliEMCALRecPoint * PRERecPoint(Int_t index) ;
 151   const AliEMCALTowerRecPoint * ECARecPoint(Int_t index) ;
 152   const AliEMCALTowerRecPoint * HCARecPoint(Int_t index) ;
 153   void MakeRecPointsArray();
 154   /****   T r a c k S e g m e n t s ****/
 155   TClonesArray * TrackSegments();
 156   const AliEMCALTrackSegment * TrackSegment(Int_t index);
 157   void MakeTrackSegmentsArray();
 158   /****  R e c P a r t ic l e s   ****/
 159   TClonesArray * RecParticles() ;
 160   const AliEMCALRecParticle * RecParticle(Int_t index);
 161   void MakeRecParticlesArray();
 162
 163   /*********************************************/
 164   /************    T A S K S      **************/
 165   /*********************************************/
 166   //
 167   //  AliEMCALSDigitizer*  EMCALSDigitizer(TString name = AliConfig::fgkDefaultEventFolderName);
 168   //AliEMCALDigitizer*   EMCALDigitizer()  { return  dynamic_cast<AliEMCALDigitizer*>(Digitizer()) ;}
 169
 170   AliEMCALClusterizer* Clusterizer ()  {return dynamic_cast<AliEMCALClusterizer*>(Reconstructioner()) ;}
 171   Int_t PostClusterizer(TTask* clust){return PostReconstructioner(clust);}
 172   Int_t LoadClusterizer(Option_t * opt="") {return LoadReconstructioner(opt);}
 173   Int_t WriteClusterizer(Option_t * opt="") {return WriteReconstructioner(opt);}
 174
 175   AliEMCALPID * PID (){return dynamic_cast<AliEMCALPID*>(PIDTask()) ;}
 176   Int_t PostPID(TTask* pid){return PostPIDTask(pid);}
 177   Int_t LoadPID(Option_t * opt="") {return LoadPIDTask(opt);}
 178   Int_t WritePID(Option_t * opt="") {return WritePIDTask(opt);}
 179
 180
 181   AliEMCALTrackSegmentMaker * TrackSegmentMaker ()  { return dynamic_cast<AliEMCALTrackSegmentMaker *>(Tracker()) ;}
 182   Int_t PostTrackSegmentMaker(TTask* segmaker){return PostTracker(segmaker);}
 183   Int_t LoadTrackSegmentMaker(Option_t * opt="") {return LoadTracker(opt);}
 184   Int_t WriteTrackSegmentMaker(Option_t * opt="") {return WriteTracker(opt);}
 185
 186
 187   void   SetDebug(Int_t level) {fDebug = level;} // Set debug level
 188   void   SetBranchTitle(const TString& btitle);
 189
 190   AliEMCALCalibrationDB * CalibrationDB(){return  fcdb; }
 191   //void ReadCalibrationDB(const char * name, const char * filename);
 192
 193 protected:
 194   TString fBranchTitle;            //Title of the branch
 195   Bool_t  fRecParticlesLoaded;     //Flag signing if Reconstructed Particles are loaded
 196   Bool_t  fTracksLoaded;           //Flag signing if Tracks are loaded
 197   TString fRecParticlesFileOption; //Loading Option for Reconstructed Particles
 198   AliEMCALCalibrationDB * fcdb ;       //!
 199
 200 private:
 201
 202   Int_t ReadHits();
 203   Int_t ReadDigits();
 204   Int_t ReadSDigits();
 205   Int_t ReadRecPoints();
 206   Int_t ReadTracks();
 207   Int_t ReadRecParticles();
 208
 209   void  ReadTreeQA() ;
 210   Int_t  fDebug ;             // Debug level
 211
 212  public:
 213
 214   static const TString fgkHitsName;//Name for TClonesArray with hits from one event
 215   static const TString fgkSDigitsName;//Name for TClonesArray
 216   static const TString fgkDigitsName;//Name for TClonesArray
 217   static const TString fgkPRERecPointsName;//Name for TClonesArray
 218   static const TString fgkECARecPointsName;//Name for TClonesArray
 219   static const TString fgkHCARecPointsName;//Name for TClonesArray
 220   static const TString fgkTracksName;//Name for TClonesArray
 221   static const TString fgkRecParticlesName;//Name for TClonesArray
 222
 223   static const TString fgkPRERecPointsBranchName;//Name for branch
 224   static const TString fgkECARecPointsBranchName;//Name for branch
 225   static const TString fgkHCARecPointsBranchName;//Name for branch
 226   static const TString fgkTrackSegmentsBranchName;//Name for branch
 227   static const TString fgkRecParticlesBranchName;//Name for branch
 228
 229   ClassDef(AliEMCALLoader,2)  // Algorithm class that provides methods to retrieve objects from a list knowing the index
 230
 231 };
 232
 233 /******************************************************************************/
 234 /****************    I N L I N E S     ****************************************/
 235 /******************************************************************************/
 236
 237 inline TClonesArray* AliEMCALLoader::Hits()
 238 {
 239  return (TClonesArray*)GetDetectorData(fgkHitsName);
 240 }
 241 /******************************************************************************/
 242
 243 inline const AliEMCALHit* AliEMCALLoader::Hit(Int_t index)
 244 {
 245   const TClonesArray* tcarr = Hits();
 246   if (tcarr)
 247     return (const AliEMCALHit*) tcarr->At(index);
 248   return 0x0;
 249 }
 250 /******************************************************************************/
 251
 252 inline TClonesArray* AliEMCALLoader::SDigits()
 253 {
 254    return dynamic_cast<TClonesArray*>(GetDetectorData(fgkSDigitsName));
 255 }
 256 /******************************************************************************/
 257
 258 inline const AliEMCALDigit*  AliEMCALLoader::SDigit(Int_t index)
 259 {
 260   const TClonesArray* tcarr = SDigits();
 261   if (tcarr)
 262     return (const AliEMCALDigit*) tcarr->At(index);
 263   return 0x0;
 264 }
 265 /******************************************************************************/
 266
 267 inline TClonesArray* AliEMCALLoader::Digits()
 268 {
 269  return dynamic_cast<TClonesArray*>(GetDetectorData(fgkDigitsName));
 270 }
 271 /******************************************************************************/
 272
 273 inline const AliEMCALDigit*  AliEMCALLoader::Digit(Int_t index)
 274 {
 275   const TClonesArray* tcarr = Digits();
 276   if (tcarr)
 277     return (const AliEMCALDigit*) tcarr->At(index);
 278   return 0x0;
 279 }
 280
 281 /******************************************************************************/
 282
 283 inline TObjArray * AliEMCALLoader::PRERecPoints()
 284 {
 285  return dynamic_cast<TObjArray*>(GetDetectorData(fgkPRERecPointsName));
 286 }
 287 /******************************************************************************/
 288
 289 inline const AliEMCALRecPoint * AliEMCALLoader::PRERecPoint(Int_t index)
 290 {
 291   TObjArray* tcarr = PRERecPoints();
 292   if (tcarr)
 293     return dynamic_cast<const AliEMCALRecPoint*>(tcarr->At(index));
 294   return 0x0;
 295 }
 296
 297 /******************************************************************************/
 298
 299 inline TObjArray * AliEMCALLoader::ECARecPoints()
 300 {
 301  return dynamic_cast<TObjArray*>(GetDetectorData(fgkECARecPointsName));
 302 }
 303
 304 /******************************************************************************/
 305
 306 inline const AliEMCALTowerRecPoint * AliEMCALLoader::ECARecPoint(Int_t index)
 307 {
 308   TObjArray* tcarr = ECARecPoints();
 309   if (tcarr)
 310     return dynamic_cast<const AliEMCALTowerRecPoint*>(tcarr->At(index));
 311   return 0x0;
 312 }
 313
 314 /******************************************************************************/
 315
 316 inline TObjArray * AliEMCALLoader::HCARecPoints()
 317 {
 318  return dynamic_cast<TObjArray*>(GetDetectorData(fgkHCARecPointsName));
 319 }
 320
 321 /******************************************************************************/
 322
 323 inline const AliEMCALTowerRecPoint * AliEMCALLoader::HCARecPoint(Int_t index)
 324 {
 325   TObjArray* tcarr = HCARecPoints();
 326   if (tcarr)
 327     return dynamic_cast<const AliEMCALTowerRecPoint*>(tcarr->At(index));
 328   return 0x0;
 329 }
 330
 331 /******************************************************************************/
 332
 333 inline TClonesArray * AliEMCALLoader::TrackSegments()
 334 {
 335  return dynamic_cast<TClonesArray*>(GetDetectorData(fgkTracksName));
 336 }
 337 /******************************************************************************/
 338
 339 inline const AliEMCALTrackSegment * AliEMCALLoader::TrackSegment(Int_t index)
 340 {
 341   const TClonesArray* tcarr = TrackSegments();
 342   if (tcarr)
 343     return (const AliEMCALTrackSegment*) tcarr->At(index);
 344   return 0x0;
 345 }
 346 /******************************************************************************/
 347
 348 inline TClonesArray * AliEMCALLoader::RecParticles()
 349 {
 350  return dynamic_cast<TClonesArray*>(GetDetectorData(fgkRecParticlesName));
 351 }
 352 /******************************************************************************/
 353
 354 inline const AliEMCALRecParticle* AliEMCALLoader::RecParticle(Int_t index)
 355 {
 356   TClonesArray* tcarr = RecParticles();
 357   if (tcarr)
 358     return (const AliEMCALRecParticle*) tcarr->At(index);
 359   return 0x0;
 360 }
 361 /******************************************************************************/
 362 inline TObjArray *  AliEMCALLoader::Alarms()
 363 { return (TObjArray*)(GetQAFolder()->FindObject(fDetectorName));}
 364
 365 #endif // AliEMCALLOADER_H