add getter for the array with digits and initialization inside, just for analysis...
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALLoader.h
index 0600f65..0ed29b8 100644 (file)
@@ -6,12 +6,13 @@
 /* $Id$ */
 
 //_________________________________________________________________________
-//  A singleton that returns various objects 
-//  Should be used on the analysis stage to avoid confusing between different
-//  branches of reconstruction tree: e.g. reading RecPoints and TS made from 
-//  another set of RecPoints.
-// 
-//  The objects are retrived from folders.  
+//  The AliEMCALLoader gets the TClonesArray and TObjArray for reading
+//  Hits, Dgits, SDigits and RecPoints. Filling is managed in the GetEvent()
+//  method. The objects are retrived from  the corresponding folders.  
+//
+//  It also provides acces methods to the calibration and simulation OCDB parameters 
+//
+
 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
 //    
 
 #include "TTree.h"
 class TString ;
 class TParticle ;
-class TTask ;
-
-// --- Standard library ---
-#include <stdlib.h>
-#include <Riostream.h>
 
 // --- AliRoot header files ---
-
-#include "AliRun.h"
 #include "AliLoader.h"
-#include "AliRunLoader.h"
-#include "AliEMCAL.h" 
-#include "AliEMCALHit.h" 
-#include "AliEMCALDigit.h"
-#include "AliEMCALTowerRecPoint.h"
-#include "AliEMCALTrackSegment.h"
-#include "AliEMCALRecParticle.h"
-class AliEMCALGeometry ;
-#include "AliEMCALDigitizer.h"
-#include "AliEMCALSDigitizer.h"
-#include "AliEMCALClusterizer.h"
-#include "AliEMCALTrackSegmentMaker.h"
-#include "AliEMCALPID.h"
-class AliEMCALCalibrationDB ;
-
+#include "AliEMCALCalibData.h"
+#include "AliCaloCalibPedestal.h"
+#include "AliEMCALSimParam.h"
+#include "AliEMCALRecParam.h"
 
-//
+class AliLoader ;
+class AliEMCAL ; 
+class AliEMCALDigit ;
+class AliEMCALSDigit ;
+class AliEMCALRecPoint ; 
 
 class AliEMCALLoader : public AliLoader {
   
  public:
 
   AliEMCALLoader();
-  AliEMCALLoader(const AliEMCALLoader & obj){}
   AliEMCALLoader(const Char_t *detname,const Char_t *eventfoldername); 
+  AliEMCALLoader(const Char_t *name,TFolder *topfolder);
   
   virtual ~AliEMCALLoader() ; 
 
-  // assignement operator requested by coding convention, but not needed
-  AliEMCALLoader & operator = (const AliEMCALLoader & ) {return *this;}
+  virtual Int_t GetEvent();  // Overload to fill TClonesArray
 
-  Int_t   GetEvent();//extends the method on EMCAL RecPart posting
-  Int_t   SetEvent();//extends the method on EMCAL RecPart posting
+  //Clean arrays methods
+  virtual void    CleanHits() const {GetHitsDataLoader()->Clean();}       
+  virtual void    CleanSDigits() const {GetSDigitsDataLoader()->Clean();}  
+  virtual void    CleanDigits() const {GetDigitsDataLoader()->Clean();}  
+  virtual void    CleanRecPoints() const {GetRecPointsDataLoader()->Clean();}  
   
-  Bool_t  BranchExists(const TString& recName);
-  Int_t   LoadHits(Option_t* opt=""); //reads  from disk and sends them to folder; array as well as tree
-  Int_t   LoadSDigits(Option_t* opt="");
-  Int_t   LoadDigits(Option_t* opt=""); //reads Digits from disk and sends them to folder; array as well as tree
-  Int_t   LoadRecPoints(Option_t* opt=""); //reads RecPoints from disk and sends them to folder; array as well as tree
-  Int_t   LoadTracks(Option_t* opt="");  //reads Tracks from disk and sends them to folder; array as well as tree
-  Int_t   LoadRecParticles(Option_t* opt="");
-  void    UnloadRecParticles();
-  void    UnloadTracks();
+  // Initialize arrays methods
+  void MakeSDigitsArray() ;
+  void MakeDigitsArray() ;
+  void MakeRecPointsArray() ;
   
-  Int_t   PostHits();  //Posts the 
-  Int_t   PostSDigits();
-  Int_t   PostDigits();
-  Int_t   PostRecPoints();
-  Int_t   PostTracks();
-  Int_t   PostRecParticles();
+  // ************    TClonesArrays Access functions
   
-  void    CleanFolders();//cleans all the stuff loaded by this detector + calls AliLoader::Clean
-
-  void    CleanHits();
-  void    CleanSDigits();
-  void    CleanDigits();
-  void    CleanRecPoints();
-  void    CleanTracks();
-  void    CleanRecParticles();
-
-//up to now it is only here -> no definition about global/incremental tracking/PID
-//   Int_t   WriteRecParticles(Option_t* opt="");//writes the reconstructed particles
-//   Int_t   WritePID(Option_t* opt="");//writes the task for PID to file
-//   Bool_t  PostPID  (AliEMCALPID * pid) const {return kTRUE;}
-//  Bool_t  PostQA   (void) const ; //it was empty anyway
+  TClonesArray*  SDigits() {return (TClonesArray*)GetDetectorData(fgkECASDigitsBranchName);} //const { return fSDigits;}
+  const AliEMCALDigit*  SDigit(Int_t index)  {
+    if (SDigits())return (const AliEMCALDigit*) SDigits()->At(index);
+    return 0x0; 
+  }
   
-/*******************************************************************/
-/*******************************************************************/
-/*******************************************************************/
-
-  TObject** HitsRef(){return GetDetectorDataRef(Hits());}
-  TObject** SDigitsRef(){return GetDetectorDataRef(SDigits());}
-  TObject** DigitsRef(){return GetDetectorDataRef(Digits());}
-  TObject** PRERecPointsRef(){return GetDetectorDataRef(PRERecPoints());}
-  TObject** ECARecPointsRef(){return GetDetectorDataRef(ECARecPoints());}
-  TObject** HCARecPointsRef(){return GetDetectorDataRef(HCARecPoints());}
-  TObject** TracksRef(){return GetDetectorDataRef(TrackSegments());}
-  TObject** RecParticlesRef(){return GetDetectorDataRef(RecParticles());}
-  TObject** AlarmsRef(){return GetDetectorDataRef(Alarms());}
-  void   Track(Int_t itrack) ;
-
-  static AliEMCALGeometry* GetEMCALGeometry();
-  static AliEMCALLoader* GetEMCALLoader(const  char* eventfoldername);
-
-  //Method to be used when digitizing under AliRunDigitizer, who opens all files etc.
-  Int_t  EventNumber()       { return (Int_t) GetRunLoader()->GetEventNumber();}
-  Int_t  MaxEvent()          { return (Int_t) GetRunLoader()->TreeE()->GetEntries();}
-
-  const AliEMCAL *         EMCAL();
-  const AliEMCALGeometry  *EMCALGeometry() ; 
-  // Alarms
-  // TFolder * Alarms() const { return (TFolder*)(ReturnO("Alarms", 0)); }
-  TObjArray *  Alarms();  
-
-  /*********************************************/
-  /************    TClonesArrays     ***********/
-  /*********************************************/
-  /****   H i t s  ****/
-  TClonesArray*  Hits(void);
-  const AliEMCALHit*    Hit(Int_t index);
-  void MakeHitsArray();
-  /****   S D i g i t s  ****/ 
-  TClonesArray*  SDigits();
-  const AliEMCALDigit*  SDigit(Int_t index);
-  void MakeSDigitsArray();
-  /****  D i g i t s  ****/
-  TClonesArray*   Digits();
-  const AliEMCALDigit *  Digit(Int_t index);
-  void MakeDigitsArray();
-  /****  R e c P o i n t s  ****/
-  TObjArray * PRERecPoints();
-  TObjArray * ECARecPoints();
-  TObjArray * HCARecPoints();
-  const AliEMCALRecPoint * PRERecPoint(Int_t index) ;
-  const AliEMCALTowerRecPoint * ECARecPoint(Int_t index) ;
-  const AliEMCALTowerRecPoint * HCARecPoint(Int_t index) ;
-  void MakeRecPointsArray();
-  /****   T r a c k S e g m e n t s ****/
-  TClonesArray * TrackSegments();
-  const AliEMCALTrackSegment * TrackSegment(Int_t index);
-  void MakeTrackSegmentsArray();
-  /****  R e c P a r t ic l e s   ****/
-  TClonesArray * RecParticles() ;
-  const AliEMCALRecParticle * RecParticle(Int_t index);
-  void MakeRecParticlesArray();
-
-  /*********************************************/
-  /************    T A S K S      **************/
-  /*********************************************/
-  // 
-  //  AliEMCALSDigitizer*  EMCALSDigitizer(TString name = AliConfig::fgkDefaultEventFolderName);
-  //AliEMCALDigitizer*   EMCALDigitizer()  { return  dynamic_cast<AliEMCALDigitizer*>(Digitizer()) ;}
-
-  AliEMCALClusterizer* Clusterizer ()  {return dynamic_cast<AliEMCALClusterizer*>(Reconstructioner()) ;}
-  Int_t PostClusterizer(TTask* clust){return PostReconstructioner(clust);}
-  Int_t LoadClusterizer(Option_t * opt="") {return LoadReconstructioner(opt);}
-  Int_t WriteClusterizer(Option_t * opt="") {return WriteReconstructioner(opt);}
-
-  AliEMCALPID * PID (){return dynamic_cast<AliEMCALPID*>(PIDTask()) ;}
-  Int_t PostPID(TTask* pid){return PostPIDTask(pid);}
-  Int_t LoadPID(Option_t * opt="") {return LoadPIDTask(opt);}
-  Int_t WritePID(Option_t * opt="") {return WritePIDTask(opt);}
-
-
-  AliEMCALTrackSegmentMaker * TrackSegmentMaker ()  { return dynamic_cast<AliEMCALTrackSegmentMaker *>(Tracker()) ;}
-  Int_t PostTrackSegmentMaker(TTask* segmaker){return PostTracker(segmaker);}
-  Int_t LoadTrackSegmentMaker(Option_t * opt="") {return LoadTracker(opt);}
-  Int_t WriteTrackSegmentMaker(Option_t * opt="") {return WriteTracker(opt);}
-
+  TClonesArray*   Digits() {return (TClonesArray*)GetDetectorData(fgkECADigitsBranchName);}//const { return fDigits;}
+  const AliEMCALDigit *  Digit(Int_t index)  {
+    if (Digits()) return (const AliEMCALDigit*) Digits()->At(index);
+    return 0x0; 
+  }
+  
+  TObjArray * RecPoints()  {return (TObjArray*)GetDetectorData(fgkECARecPointsBranchName);}//const { return fRecPoints;}
+  const AliEMCALRecPoint * RecPoint(Int_t index)  {
+    if (RecPoints())return (const AliEMCALRecPoint*) RecPoints()->At(index);
+    return 0x0; 
+  }
   
   void   SetDebug(Int_t level) {fDebug = level;} // Set debug level
-  void   SetBranchTitle(const TString& btitle);
   
-  AliEMCALCalibrationDB * CalibrationDB(){return  fcdb; }
-  //void ReadCalibrationDB(const char * name, const char * filename);
+  //OCDB access methods
   
-protected:
-  TString fBranchTitle;            //Title of the branch
-  Bool_t  fRecParticlesLoaded;     //Flag signing if Reconstructed Particles are loaded
-  Bool_t  fTracksLoaded;           //Flag signing if Tracks are loaded
-  TString fRecParticlesFileOption; //Loading Option for Reconstructed Particles
-  AliEMCALCalibrationDB * fcdb ;       //!
-
-private:
-
-  Int_t ReadHits();
-  Int_t ReadDigits();
-  Int_t ReadSDigits();
-  Int_t ReadRecPoints();
-  Int_t ReadTracks();
-  Int_t ReadRecParticles();
+  void  SetCalibData(AliEMCALCalibData* calibda)  { fgCalibData = calibda; }
+  AliEMCALCalibData * CalibData();              // to get the calibration CDB object
   
-  void  ReadTreeQA() ;
-  Int_t  fDebug ;             // Debug level
- public:
-
-  static const TString fgkHitsName;//Name for TClonesArray with hits from one event
-  static const TString fgkSDigitsName;//Name for TClonesArray 
-  static const TString fgkDigitsName;//Name for TClonesArray 
-  static const TString fgkPRERecPointsName;//Name for TClonesArray 
-  static const TString fgkECARecPointsName;//Name for TClonesArray 
-  static const TString fgkHCARecPointsName;//Name for TClonesArray 
-  static const TString fgkTracksName;//Name for TClonesArray 
-  static const TString fgkRecParticlesName;//Name for TClonesArray
-
-  static const TString fgkPRERecPointsBranchName;//Name for branch
-  static const TString fgkECARecPointsBranchName;//Name for branch
-  static const TString fgkHCARecPointsBranchName;//Name for branch
-  static const TString fgkTrackSegmentsBranchName;//Name for branch
-  static const TString fgkRecParticlesBranchName;//Name for branch
+  void  SetPedestalData(AliCaloCalibPedestal* caloped)  { fgCaloPed = caloped; }
+  AliCaloCalibPedestal* PedestalData();         // to get the pedestal CDB object
+  
+  void  SetSimParam(AliEMCALSimParam* simparam)  { fgSimParam = simparam; }
+  AliEMCALSimParam* SimulationParameters();     // to get the simulation parameter CDB object
   
-  ClassDef(AliEMCALLoader,2)  // Algorithm class that provides methods to retrieve objects from a list knowing the index 
+  void  SetRecParam(AliEMCALRecParam* recparam)  { fgRecParam = recparam; }
+  AliEMCALRecParam* ReconstructionParameters(Int_t eventType); // to get the reconstruction parameter CDB object
 
+ private:
+  
+  // assignement operator requested by coding convention, but not needed
+  AliEMCALLoader(const AliEMCALLoader &); //Not implemented
+  const AliEMCALLoader & operator = (const AliEMCALLoader &); //Not implemented
+  
+  static const TString fgkECASDigitsBranchName;   //! Name of branch with ECA SDigits
+  static const TString fgkECADigitsBranchName;    //! Name of branch with ECA Digits
+  static const TString fgkECARecPointsBranchName; //! Name of branch with ECA Reconstructed Points
+  
+  Int_t  fDebug ;             // Debug level
+       
+  static AliEMCALCalibData    * fgCalibData;  //  calibration data 
+  static AliCaloCalibPedestal * fgCaloPed;    //  dead map
+  static AliEMCALSimParam     * fgSimParam;   //  sim param 
+  static AliEMCALRecParam     * fgRecParam;   //  rec param 
+
+  ClassDef(AliEMCALLoader,7)  // Algorithm class that provides methods to retrieve objects from a list knowing the index 
+    
 };
 
-/******************************************************************************/
-/****************    I N L I N E S     ****************************************/
-/******************************************************************************/
-
-inline TClonesArray* AliEMCALLoader::Hits()  
-{
- return (TClonesArray*)GetDetectorData(fgkHitsName);
-}
-/******************************************************************************/
-
-inline const AliEMCALHit* AliEMCALLoader::Hit(Int_t index)  
-{
-  const TClonesArray* tcarr = Hits();
-  if (tcarr)
-    return (const AliEMCALHit*) tcarr->At(index);
-  return 0x0; 
-}
-/******************************************************************************/
-
-inline TClonesArray* AliEMCALLoader::SDigits()
-{
-   return dynamic_cast<TClonesArray*>(GetDetectorData(fgkSDigitsName));
-}
-/******************************************************************************/
-
-inline const AliEMCALDigit*  AliEMCALLoader::SDigit(Int_t index)
-{
-  const TClonesArray* tcarr = SDigits();
-  if (tcarr)
-    return (const AliEMCALDigit*) tcarr->At(index);
-  return 0x0; 
-}
-/******************************************************************************/
-
-inline TClonesArray* AliEMCALLoader::Digits()
-{
- return dynamic_cast<TClonesArray*>(GetDetectorData(fgkDigitsName));
-}
-/******************************************************************************/
-
-inline const AliEMCALDigit*  AliEMCALLoader::Digit(Int_t index)
-{
-  const TClonesArray* tcarr = Digits();
-  if (tcarr)
-    return (const AliEMCALDigit*) tcarr->At(index);
-  return 0x0; 
-}
-
-/******************************************************************************/
-
-inline TObjArray * AliEMCALLoader::PRERecPoints()
-{
- return dynamic_cast<TObjArray*>(GetDetectorData(fgkPRERecPointsName));
-}
-/******************************************************************************/
-
-inline const AliEMCALRecPoint * AliEMCALLoader::PRERecPoint(Int_t index)
-{
-  TObjArray* tcarr = PRERecPoints();
-  if (tcarr)
-    return dynamic_cast<const AliEMCALRecPoint*>(tcarr->At(index));
-  return 0x0; 
-}
-
-/******************************************************************************/
-
-inline TObjArray * AliEMCALLoader::ECARecPoints()
-{
- return dynamic_cast<TObjArray*>(GetDetectorData(fgkECARecPointsName));
-}
-
-/******************************************************************************/
-
-inline const AliEMCALTowerRecPoint * AliEMCALLoader::ECARecPoint(Int_t index)
-{
-  TObjArray* tcarr = ECARecPoints();
-  if (tcarr)
-    return dynamic_cast<const AliEMCALTowerRecPoint*>(tcarr->At(index));
-  return 0x0; 
-}
-
-/******************************************************************************/
-
-inline TObjArray * AliEMCALLoader::HCARecPoints()
-{
- return dynamic_cast<TObjArray*>(GetDetectorData(fgkHCARecPointsName));
-}
-
-/******************************************************************************/
-
-inline const AliEMCALTowerRecPoint * AliEMCALLoader::HCARecPoint(Int_t index)
-{
-  TObjArray* tcarr = HCARecPoints();
-  if (tcarr)
-    return dynamic_cast<const AliEMCALTowerRecPoint*>(tcarr->At(index));
-  return 0x0; 
-}
-
-/******************************************************************************/
-
-inline TClonesArray * AliEMCALLoader::TrackSegments()
-{
- return dynamic_cast<TClonesArray*>(GetDetectorData(fgkTracksName));
-}
-/******************************************************************************/
-
-inline const AliEMCALTrackSegment * AliEMCALLoader::TrackSegment(Int_t index)
-{
-  const TClonesArray* tcarr = TrackSegments();
-  if (tcarr)
-    return (const AliEMCALTrackSegment*) tcarr->At(index);
-  return 0x0; 
-}
-/******************************************************************************/
-
-inline TClonesArray * AliEMCALLoader::RecParticles() 
-{
- return dynamic_cast<TClonesArray*>(GetDetectorData(fgkRecParticlesName)); 
-}
-/******************************************************************************/
-
-inline const AliEMCALRecParticle* AliEMCALLoader::RecParticle(Int_t index)
-{
-  TClonesArray* tcarr = RecParticles();
-  if (tcarr)
-    return (const AliEMCALRecParticle*) tcarr->At(index);
-  return 0x0;  
-}
-/******************************************************************************/
-inline TObjArray *  AliEMCALLoader::Alarms()
-{ return (TObjArray*)(GetQAFolder()->FindObject(fDetectorName));}
-
 #endif // AliEMCALLOADER_H