/* $Id$ */
//_________________________________________________________________________
-// Class to mask AliPHOSGetter in "on flight" reconstruction (i.e. without
+// Class to substitute AliPHOSGetter in "on flight" reconstruction (i.e. without
// writing to file and creation full ALICE data structure)
//
//*-- Author: D.Peressounko (RRC KI)
public:
AliPHOSGetterLight() ; // ctor
+ AliPHOSGetterLight(const AliPHOSGetterLight & obj);
+
+ AliPHOSGetterLight & operator = (const AliPHOSGetterLight & ) {
+ // assignement operator requested by coding convention, but not needed
+ Fatal("operator =", "not implemented") ;
+ return *this ;
+ }
virtual ~AliPHOSGetterLight() ; // dtor
+ //method normally used for creation of this class
static AliPHOSGetterLight * Instance(const char* /*headerFile*/,
const char* version = AliConfig::GetDefaultEventFolderName(),
Option_t * openingOption = "READ" ) ;
static AliPHOSGetterLight * Instance() ;
//=========== General information about run ==============
- virtual Bool_t IsLoaded(TString /*tree*/) const { Error("IsLoaded","NotDefined"); return kFALSE ; }
- virtual void SetLoaded(TString /*tree*/) { Error("SetLoaded","NotDefined"); }
virtual Int_t MaxEvent() const {return 1 ;} //always "read" event 1
virtual Int_t EventNumber() const {return 0; } //always the same event
virtual Bool_t VersionExists(TString & /*opt*/) const {return kFALSE;}
- virtual UShort_t EventPattern(void) const {return 0;}
- virtual Float_t BeamEnergy(void) const {return 10.;}
+ virtual UShort_t EventPattern(void) const {return 0;} //not needed in on-flight reconstruction
+ virtual Float_t BeamEnergy(void) const {return 10.;} //not needed in on-flight reconstruction
//========== PHOSGeometry and PHOS =============
- virtual AliPHOS * PHOS() const { Error("PHOS()","NotDefined"); return 0 ;}
- virtual AliPHOSGeometry * PHOSGeometry() const {AliPHOSGeometry * geom = AliPHOSGeometry::GetInstance("IHEP","IHEP") ; return geom ;}
+ //Dummy function not necessary for on-flight reconstruction, but has to be overloaded
+ virtual AliPHOSGeometry * PHOSGeometry() const {return AliPHOSGeometry::GetInstance("IHEP","IHEP") ; } //Create if necessary geom
//========== Methods to read something from file ==========
virtual void Event(Int_t /*event*/, const char * /*opt = "HSDRTP"*/){} //Use data already in memory
- virtual void Track(Int_t /*itrack*/) { Error("Track()","NotDefined");}
//-----------------now getter's data--------------------------------------
- virtual AliPHOSCalibrationDB * CalibrationDB(){return fcdb; }
- virtual void SetCalibrationDB(AliPHOSCalibrationDB * cdb) {fcdb = cdb ;}
-
- //=========== Primaries ============
- virtual TClonesArray * Primaries(void) {Error("Primaries()","NotDefined"); return 0;}
- virtual TParticle * Primary(Int_t /*index*/) const {Error("Primary()","NotDefined"); return 0;}
- virtual Int_t NPrimaries()const {Error("NPrimaries()","NotDefined"); return 0; }
- virtual TParticle * Secondary(const TParticle * /*p*/, Int_t /*index*/) const {Error("Secondary()","NotDefined"); return 0; }
-
- //=========== Hits =================
- virtual TClonesArray * Hits(void) {Error("Hits()","Method not defined") ; return 0;}
- virtual AliPHOSHit * Hit(Int_t /*index*/) {Error("Hit()","Method not defined"); return 0 ;}
- virtual TTree * TreeH() const {Error("TreeH","Method not defined") ; return 0;}
-
- //=========== SDigits ==============
- virtual TClonesArray * SDigits(){Error("Sdigits","Method not defined") ; return 0;}
- virtual AliPHOSDigit * SDigit(Int_t /*index*/) { Error("SDigit","Method not defined") ;return 0 ;}
- virtual TTree * TreeS() const {Error("TresS","Method not defined") ; return 0 ;}
- virtual AliPHOSSDigitizer * SDigitizer() {Error("SDigitizer","Method not defined") ; return 0 ;}
-
- virtual TString GetSDigitsFileName() const { Error("OnFlight","Method not defined") ; return "" ; }
- virtual Int_t LoadSDigits(Option_t* /*opt=""*/) const { Error("LoadSDigits","Method not defined") ;return 0 ; }
- virtual Int_t LoadSDigitizer(Option_t* /*opt=""*/) const { Error("LoadSdigitizer","Method not defined") ; return 0 ; }
- virtual Int_t WriteSDigits(Option_t* /*opt=""*/) const { Error("WriteSDigits","Method not defined") ; return 0 ; }
- virtual Int_t WriteSDigitizer(Option_t* /*opt=""*/) const {Error("WriteSDigitizer","Method not defined") ; return 0 ; }
//========== Digits ================
- virtual TClonesArray * Digits(){return fDigits ; }
- virtual AliPHOSDigit * Digit(Int_t index) { return static_cast<AliPHOSDigit *>(fDigits->At(index)) ;}
- virtual TTree * TreeD() const {Error("TreeD","Method not defined") ; return 0;}
- virtual AliPHOSDigitizer * Digitizer(){Error("Digitizer","Method not defined") ; return 0;}
- virtual TString GetDigitsFileName() const { Error("GetDigitsFileName","Method not defined") ; return "" ; }
- virtual Int_t LoadDigits(Option_t* /*opt=""*/) const {Error("LoadDigits","Method not defined") ; return 0 ; }
- virtual Int_t LoadDigitizer(Option_t* /*opt=""*/) const {Error("LoadDigitizer","Method not defined") ; return 0;}
- virtual Int_t WriteDigits(Option_t* /*opt=""*/) const { Error("WriteDigits","Method not defined") ; return 0; }
- virtual Int_t WriteDigitizer(Option_t* /*opt=""*/) const {Error("WriteDigitizer","Method not defined"); return 0 ;}
-
- //Methods to distinguish raw and simulated digits
- virtual Bool_t IsRawDigits(void) const {return fRawDigits;}
- virtual void SetRawDigits(Bool_t isRaw = kTRUE){fRawDigits = isRaw;}
+ virtual TClonesArray * Digits() const {return fDigits ; }
+ virtual AliPHOSDigit * Digit(Int_t index) const { return static_cast<AliPHOSDigit *>(fDigits->At(index)) ;}
+ // virtual AliPHOSDigitizer * Digitizer(){Error("Digitizer","Method not defined") ; return 0;}
//========== RecPoints =============
- virtual TObjArray * EmcRecPoints(){return fEmcRecPoints ;}
- virtual AliPHOSEmcRecPoint * EmcRecPoint(Int_t index) { return static_cast<AliPHOSEmcRecPoint *>(fEmcRecPoints->At(index)) ;}
- virtual TObjArray * CpvRecPoints(){return fCpvRecPoints ;}
- virtual AliPHOSCpvRecPoint * CpvRecPoint(Int_t index) { return static_cast<AliPHOSCpvRecPoint *>(fCpvRecPoints->At(index)) ;}
- virtual TTree * TreeR() const {Error("TreeR","Method not defined") ; return 0;}
+ virtual TObjArray * EmcRecPoints() const {return fEmcRecPoints ;}
+ virtual AliPHOSEmcRecPoint * EmcRecPoint(Int_t index) const { return static_cast<AliPHOSEmcRecPoint *>(fEmcRecPoints->At(index)) ;}
+ virtual TObjArray * CpvRecPoints() const {return fCpvRecPoints ;}
+ virtual AliPHOSCpvRecPoint * CpvRecPoint(Int_t index) const { return static_cast<AliPHOSCpvRecPoint *>(fCpvRecPoints->At(index)) ;}
virtual AliPHOSClusterizer * Clusterizer() { return fClusterizer;}
- virtual TString GetRecPointsFileName() const { Error("RecPointsFileName","Method not defined") ;return "" ; }
- virtual Int_t LoadRecPoints(Option_t* /*opt=""*/) const {Error("LoadRecPoints","Method not defined") ; return 0; }
- virtual Int_t LoadClusterizer(Option_t* /*opt=""*/) const {Error("LoadClusterizer","Method not defined") ; return 0 ;}
- virtual Int_t WriteRecPoints(Option_t* /*opt=""*/) const {Error("WriteRecPoints","Method not defined") ; return 0; }
- virtual Int_t WriteClusterizer(Option_t* /*opt=""*/) const {Error("WriteClusterizer","Method not defined"); return 0 ;}
//========== TrackSegments TClonesArray * TrackSegments(const char * name = 0) {
- virtual TClonesArray * TrackSegments(){return fTS ;} ;
- virtual AliPHOSTrackSegment * TrackSegment(Int_t index) { return static_cast<AliPHOSTrackSegment *>(fTS->At(index)) ;}
- virtual TTree * TreeT() const {Error("TreeT","Method not defined") ; return 0 ;}
+ virtual TClonesArray * TrackSegments() const {return fTS ;} ;
+ virtual AliPHOSTrackSegment * TrackSegment(Int_t index) const { return static_cast<AliPHOSTrackSegment *>(fTS->At(index)) ;}
virtual AliPHOSTrackSegmentMaker * TrackSegmentMaker(){ return fTSM ;}
- virtual TString GetTracksFileName() const { Error("GetTSFileName","Method not defiled") ; return "" ; }
- virtual Int_t LoadTracks(Option_t* /*opt=""*/) const { Error("LoadTracks","Method not defined") ;return 0; }
- virtual Int_t LoadTrackSegementMaker(Option_t* /*opt=""*/) const {Error("LoadTSMaker","Method noe defined") ; return 0 ;}
- virtual Int_t WriteTracks(Option_t* /*opt=""*/) const { Error("WriteTracks","Method not defined") ; return 0; }
- virtual Int_t WriteTrackSegmentMaker(Option_t* /*opt=""*/) const {Error("WriteTSM","Method not defined") ; return 0 ;}
//========== RecParticles ===========
- virtual TClonesArray * RecParticles(){ return fRP;}
- virtual AliPHOSRecParticle * RecParticle(Int_t index) { return static_cast<AliPHOSRecParticle *>(fRP->At(index)) ;}
- virtual TTree * TreeP() const {Error("TreeP","Method net defined"); return 0 ;}
+ virtual TClonesArray * RecParticles() const { return fRP;}
+ virtual AliPHOSRecParticle * RecParticle(Int_t index) const { return static_cast<AliPHOSRecParticle *>(fRP->At(index)) ;}
virtual AliPHOSPID * PID(){return fPID ;}
- virtual TString GetRecParticlesFileName() const { Error("GetRPFileName","Method not defined") ; return "" ; }
- virtual Int_t LoadRecParticles(Option_t* /*opt=""*/) const { Error("LoadRP","Method not defined") ;return 0 ; }
- virtual Int_t LoadPID(Option_t* /*opt=""*/) const {Error("LoadPID","Method not defined") ;return 0 ; }
- virtual Int_t WriteRecParticles(Option_t* /*opt=""*/) const { Error("WriteRP","Method not defined"); return 0 ; }
- virtual Int_t WritePID(Option_t* /*opt=""*/) const {Error("WritePID","Method not defined"); return 0 ; }
//========== Raw ===========
// virtual Int_t ReadRaw(Int_t event) ;
- // virtual void SetDebug(Int_t level) {fgDebug = level;} // Set debug level
virtual void PostClusterizer(AliPHOSClusterizer * clu)const{((AliPHOSGetterLight*)fgObjGetter)->fClusterizer = clu;}
virtual void PostPID(AliPHOSPID * pid)const{((AliPHOSGetterLight*)fgObjGetter)->fPID = pid ;}
virtual void PostTrackSegmentMaker(AliPHOSTrackSegmentMaker * tr)const{((AliPHOSGetterLight*)fgObjGetter)->fTSM = tr ;}
- //virtual void PostSDigitizer (AliPHOSSDigitizer * sdigitizer)
- // const {PhosLoader()->PostSDigitizer(sdigitizer);}
- //virtual void PostDigitizer (AliPHOSDigitizer * digitizer)
- // const {PhosLoader()->PostDigitizer(dynamic_cast<AliDigitizer *>(digitizer));}
-
virtual TString Version() const { return "OnFlight" ; }
- virtual AliPHOSLoader * PhosLoader() const { Error("PhosLoader","Method not defined") ;return 0 ; }
virtual void Reset(){}
virtual AliESD * ESD() const { return 0 ; }
private :
- TClonesArray * fDigits ;
- TObjArray * fEmcRecPoints ;
- TObjArray * fCpvRecPoints ;
- TClonesArray * fTS ;
- TClonesArray * fRP ;
+ TClonesArray * fDigits ; //Digits container for current event
+ TObjArray * fEmcRecPoints ; //EmcRecPoints container for current event
+ TObjArray * fCpvRecPoints ; //CPV RecPoints container for current event
+ TClonesArray * fTS ; //TrackSegments container for currect event
+ TClonesArray * fRP ; //Rec Particles conatiner for currect event
- AliPHOSCalibrationDB * fcdb ;
+ // AliPHOSCalibrationDB * fcdb ; //Pointer to calibration database
- AliPHOSClusterizer * fClusterizer ;
- AliPHOSTrackSegmentMaker * fTSM ;
- AliPHOSPID * fPID ;
+ AliPHOSClusterizer * fClusterizer ; //Pointer to clusterizer
+ AliPHOSTrackSegmentMaker * fTSM ; //Pointer to TrackSegmentMaker
+ AliPHOSPID * fPID ; //Pointer to PIDMaker
- Bool_t fRawDigits ;
+ // Bool_t fRawDigits ; //Do we reconstruct raw digits
ClassDef(AliPHOSGetterLight,1) // Getter for \"on flyght\" reconstruction
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff