Coding convention sutisfied
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 28 Oct 2004 14:17:01 +0000 (14:17 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 28 Oct 2004 14:17:01 +0000 (14:17 +0000)
PHOS/AliPHOSGetter.h
PHOS/AliPHOSGetterLight.cxx
PHOS/AliPHOSGetterLight.h

index 8a93d8052b68084d5cc819a4b9d060c9f4229928..654f93396c2fe4ebd5a4572b1feb1689ab9fb374 100644 (file)
@@ -98,8 +98,9 @@ public:
  
   
   //-----------------now getter's data--------------------------------------
-  virtual AliPHOSCalibrationDB * CalibrationDB(){return  fcdb; }
-  virtual void ReadCalibrationDB(const char * /*name*/, const char * /*filename*/){ ;}
+  AliPHOSCalibrationDB * CalibrationDB(){return  fcdb; }
+  void ReadCalibrationDB(const char * /*name*/, const char * /*filename*/){ ;}
+  void SetCalibrationDB(AliPHOSCalibrationDB * cdb) {fcdb = cdb ;}
   
   //=========== Primaries ============
   virtual TClonesArray *    Primaries(void) ;
@@ -186,7 +187,7 @@ public:
   //========== Raw ===========
   virtual Int_t ReadRaw(Int_t event) ; 
 
-  virtual void SetDebug(Int_t level) {fgDebug = level;} // Set debug level 
+  void SetDebug(Int_t level) {fgDebug = level;} // Set debug level 
   virtual void PostClusterizer(AliPHOSClusterizer * clu) 
     const{PhosLoader()->PostClusterizer(clu) ; }
   virtual void PostPID(AliPHOSPID * pid) 
index 83e618af8a23eb55ad755576c36ce94c37734398..a37dd376cd72eed4615f04377bc42f5e6764edab 100644 (file)
 //
 //*-- Author :  D.Peressounko (RRC KI) 
 //////////////////////////////////////////////////////////////////////////////
+//Class designed to perform fast on-flight reconstruction of raw data
+//without writing it to file and without creation of all aliroot folder 
+//structure. This class keeps lists of (raw) digits, RecPoints TrackSegments and 
+//RecParticles for one (current) event. In addition, for convinience, it returns 
+//pointers to PHOS geometry, Clusterizser, TSMaker and PID maker.
 
 // --- ROOT system ---
-#include "TFile.h"
 // --- Standard library ---
 
 // --- AliRoot header files ---
-#include "AliPHOSCalibrationDB.h"
+//#include "AliPHOSCalibrationDB.h"
 #include "AliPHOSGetterLight.h"
 
 ClassImp(AliPHOSGetterLight)
@@ -41,17 +45,18 @@ ClassImp(AliPHOSGetterLight)
   fCpvRecPoints = 0 ;
   fTS = 0;
   fRP = 0;
-  fcdb = 0 ;
+  //  fcdb = 0 ;
   fClusterizer = 0 ; 
   fTSM = 0 ;
   fPID = 0 ;
-  fRawDigits =kTRUE;
+  SetRawDigits(kTRUE) ;
+  //  fRawDigits =kTRUE;
   fgObjGetter = this ;
 }
 //____________________________________________________________________________ 
 AliPHOSGetterLight::AliPHOSGetterLight(const char* /*alirunFileName*/, const char* /*version*/, Option_t * /*openingOption*/):AliPHOSGetter(0) 
 {
-  // ctor
+  //Create containers of reconstructed objects for one event
   fDigits = new TClonesArray("AliPHOSDigit",256) ;
   fEmcRecPoints = new TObjArray(50) ;
   fEmcRecPoints->SetOwner(kTRUE) ;
@@ -60,20 +65,22 @@ AliPHOSGetterLight::AliPHOSGetterLight(const char* /*alirunFileName*/, const cha
   fTS = new TClonesArray("AliPHOSTrackSegment",50) ;
   fRP = new TClonesArray("AliPHOSRecParticle",50) ;
 
-  fcdb = 0 ;
+  //Objects which are not owned by Getter
+  //  fcdb = 0 ;
 
   fClusterizer = 0; 
   fTSM = 0 ;
   fPID = 0 ;
 
-  fRawDigits = kTRUE ;
+  SetRawDigits(kTRUE) ;
+  //  fRawDigits = kTRUE ;
   fgObjGetter = this ;
 }
 
 //____________________________________________________________________________ 
   AliPHOSGetterLight::~AliPHOSGetterLight()
 {
-  // ctor
+  //Delete containers owned by Getter and do not touch other pointers
   if(fDigits){ delete fDigits ; fDigits = 0 ;}
   if(fEmcRecPoints){ delete fEmcRecPoints; fEmcRecPoints = 0 ;}
   if(fCpvRecPoints){ delete fCpvRecPoints; fCpvRecPoints = 0 ;}
@@ -86,7 +93,6 @@ AliPHOSGetterLight * AliPHOSGetterLight::Instance(const char* alirunFileName, co
   // 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) ;
   }
index 4c44390705ed17a0c4e2ed639ff0ad8f61f5241a..0de254f56cfcaba2ce7cd4235570bfcebe8e227a 100644 (file)
@@ -6,7 +6,7 @@
 /* $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)
@@ -29,124 +29,72 @@ class AliPHOSGetterLight : public AliPHOSGetter {
 
 public:
   AliPHOSGetterLight() ;          // ctor
+  AliPHOSGetterLight(const AliPHOSGetterLight & obj) : AliPHOSGetter(obj) {
+    // cpy ctor requested by Coding Convention 
+    Fatal("cpy ctor", "not implemented") ;
+  } 
+  
+  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 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 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 ; }
@@ -159,19 +107,19 @@ private:
 
 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