/* $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)
//
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"
-//
+class AliLoader ;
+class AliEMCAL ;
+class AliEMCALDigit ;
+class AliEMCALSDigit ;
+class AliEMCALRecPoint ;
class AliEMCALLoader : public AliLoader {
public:
AliEMCALLoader();
- AliEMCALLoader(const AliEMCALLoader & obj):AliLoader(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 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
+
+
+ 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
- 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
+
+ static AliEMCALCalibData * fgCalibData; // calibration data
+ // static AliCaloCalibPedestal * fgCaloPed; // dead map
+ static AliEMCALSimParam * fgSimParam; // sim param
- ClassDef(AliEMCALLoader,3) // Algorithm class that provides methods to retrieve objects from a list knowing the index
-
+ 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
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff