--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/* $Id$ */
+
+//_________________________________________________________________________
+//
+//
+//*-- Author : D.Peressounko (RRC KI)
+//////////////////////////////////////////////////////////////////////////////
+
+// --- ROOT system ---
+#include "TFile.h"
+// --- Standard library ---
+
+// --- AliRoot header files ---
+#include "AliPHOSCalibrationDB.h"
+#include "AliPHOSGetterLight.h"
+
+ClassImp(AliPHOSGetterLight)
+
+
+//____________________________________________________________________________
+ AliPHOSGetterLight::AliPHOSGetterLight():AliPHOSGetter(0)
+{
+ // ctor
+ fDigits = 0 ;
+ fEmcRecPoints = 0 ;
+ fCpvRecPoints = 0 ;
+ fTS = 0;
+ fRP = 0;
+ fcdb = 0 ;
+ fClusterizer = 0 ;
+ fTSM = 0 ;
+ fPID = 0 ;
+ fRawDigits =kTRUE;
+ fgObjGetter = this ;
+}
+//____________________________________________________________________________
+AliPHOSGetterLight::AliPHOSGetterLight(const char* /*alirunFileName*/, const char* /*version*/, Option_t * /*openingOption*/):AliPHOSGetter(0)
+{
+ // ctor
+ fDigits = new TClonesArray("AliPHOSDigit",256) ;
+ fEmcRecPoints = new TObjArray(50) ;
+ fEmcRecPoints->SetOwner(kTRUE) ;
+ fCpvRecPoints= new TObjArray(0);
+ fCpvRecPoints->SetOwner(kTRUE) ;
+ fTS = new TClonesArray("AliPHOSTrackSegment",50) ;
+ fRP = new TClonesArray("AliPHOSRecParticle",50) ;
+
+ fcdb = 0 ;
+
+ fClusterizer = 0;
+ fTSM = 0 ;
+ fPID = 0 ;
+
+ fRawDigits = kTRUE ;
+ fgObjGetter = this ;
+}
+
+//____________________________________________________________________________
+ AliPHOSGetterLight::~AliPHOSGetterLight()
+{
+ // ctor
+ if(fDigits){ delete fDigits ; fDigits = 0 ;}
+ if(fEmcRecPoints){ delete fEmcRecPoints; fEmcRecPoints = 0 ;}
+ if(fCpvRecPoints){ delete fCpvRecPoints; fCpvRecPoints = 0 ;}
+ if(fTS){ delete fTS; fTS = 0 ;}
+ if(fRP){ delete fRP; fRP = 0 ;}
+}
+//____________________________________________________________________________
+AliPHOSGetterLight * AliPHOSGetterLight::Instance(const char* alirunFileName, const char* version, Option_t * openingOption)
+{
+ // Creates and returns the pointer of the unique instance
+ // Must be called only when the environment has changed
+
+
+ if(!fgObjGetter){ // first time the getter is called
+ fgObjGetter = (AliPHOSGetter*) new AliPHOSGetterLight(alirunFileName, version, openingOption) ;
+ }
+ return (AliPHOSGetterLight*) fgObjGetter ;
+}
+//____________________________________________________________________________
+AliPHOSGetterLight * AliPHOSGetterLight::Instance(void)
+{
+ return (AliPHOSGetterLight*) fgObjGetter ;
+}
--- /dev/null
+#ifndef ALIPHOSGETTERLIGHT_H
+#define ALIPHOSGETTERLIGHT_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+//_________________________________________________________________________
+// Class to mask AliPHOSGetter in "on flight" reconstruction (i.e. without
+// writing to file and creation full ALICE data structure)
+//
+//*-- Author: D.Peressounko (RRC KI)
+
+
+// --- ROOT system ---
+class TClonesArray ;
+class TObjArray ;
+
+// --- Standard library ---
+
+// --- AliRoot header files ---
+#include "AliPHOSGetter.h"
+#include "AliPHOSGeometry.h"
+class AliPHOSClusterizer ;
+class AliPHOSTrackSegmentMaker ;
+class AliPHOSPID ;
+
+class AliPHOSGetterLight : public AliPHOSGetter {
+
+public:
+ AliPHOSGetterLight() ; // ctor
+
+ virtual ~AliPHOSGetterLight() ; // dtor
+
+ 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.;}
+
+ //========== PHOSGeometry and PHOS =============
+ virtual AliPHOS * PHOS() const { Error("PHOS()","NotDefined"); return 0 ;}
+ virtual AliPHOSGeometry * PHOSGeometry() const {AliPHOSGeometry * geom = AliPHOSGeometry::GetInstance("IHEP","IHEP") ; return 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;}
+
+ //========== 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 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 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 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:
+
+ AliPHOSGetterLight(const char* headerFile,
+ const char* version = AliConfig::GetDefaultEventFolderName(),
+ Option_t * openingOption = "READ") ;
+
+private :
+
+ TClonesArray * fDigits ;
+ TObjArray * fEmcRecPoints ;
+ TObjArray * fCpvRecPoints ;
+ TClonesArray * fTS ;
+ TClonesArray * fRP ;
+
+ AliPHOSCalibrationDB * fcdb ;
+
+ AliPHOSClusterizer * fClusterizer ;
+ AliPHOSTrackSegmentMaker * fTSM ;
+ AliPHOSPID * fPID ;
+
+ Bool_t fRawDigits ;
+
+ ClassDef(AliPHOSGetterLight,1) // Getter for \"on flyght\" reconstruction
+
+};
+
+#endif // AliPHOSGETTERLIGHT_H