Line data    Source code

       1             : #ifndef ALITPCRECONSTRUCTOR_H
       2             : #define ALITPCRECONSTRUCTOR_H
       3             : /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
       4             :  * See cxx source for full Copyright notice                               */
       5             : 
       6             : /* $Id$ */
       7             : 
       8             : #include "AliReconstructor.h"
       9             : #include "AliTPCRecoParam.h"
      10             : #include "TVector.h"
      11             : #include <TString.h>
      12             : 
      13             : class AliTPCParam;
      14             : class AliTPCclusterer;
      15             : class AliTPCtracker;
      16             : class AliTPCAltroEmulator;
      17             : class TObjArray;
      18             : class TTreeSRedirector;
      19             : 
      20             : class AliTPCReconstructor: public AliReconstructor {
      21             : public:
      22             :   AliTPCReconstructor();
      23             :   virtual ~AliTPCReconstructor();
      24             :   virtual void         Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
      25             :   virtual void         Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
      26             : 
      27             :   virtual AliTracker*  CreateTracker() const;
      28             : 
      29             :   virtual void         FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/, 
      30             :                                AliESDEvent* esd) const;
      31             :   virtual void         FillESD(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/, 
      32             :                                AliESDEvent* esd) const
      33           8 :   {FillESD((TTree*)NULL,(TTree*)NULL,esd);}
      34             : 
      35     2737126 :   static const AliTPCRecoParam* GetRecoParam() { return dynamic_cast<const AliTPCRecoParam*>(AliReconstructor::GetRecoParam(1)); }
      36             :   virtual void                 GetPidSettings(AliESDpid *esdPID);
      37             :   //
      38           0 :   static void        SetPIDRespnonsePath(const char* pth) {fgPIDRespnonsePath = pth;}
      39           0 :   static const char* GetPIDRespnonsePath() {return fgPIDRespnonsePath.Data();}  
      40             :   //
      41      161452 :   static Double_t GetCtgRange()     { return GetRecoParam()->GetCtgRange();}
      42      552992 :   static Double_t GetMaxSnpTracker(){ return GetRecoParam()->GetMaxSnpTracker();}
      43      141480 :   static Double_t GetMaxSnpTrack()  { return GetRecoParam()->GetMaxSnpTrack();}
      44             : 
      45      934938 :   static Int_t StreamLevel()               { return fgStreamLevel;}
      46           0 :   static void  SetStreamLevel(Int_t level) { fgStreamLevel = level;}
      47           0 :   static void  SetAltroEmulator(AliTPCAltroEmulator *altro) { fAltroEmulator=altro;}
      48           0 :   static AliTPCAltroEmulator *  GetAltroEmulator() { return fAltroEmulator;}
      49           0 :   static TTreeSRedirector    *GetDebugStreamer(){return fgDebugStreamer;}
      50           0 :   static void SetDebugStreamer(TTreeSRedirector    *debugStreamer){fgDebugStreamer=debugStreamer;}
      51             :   void ParseOptions(AliTPCtracker* tracker) const;
      52        4068 :   static  const Double_t * GetSystematicError()  { return (fSystematicErrors)? fSystematicErrors->GetMatrixArray():0;}
      53          24 :   static  const Double_t * GetSystematicErrorCluster() { return (fSystematicErrorClusters) ? fSystematicErrorClusters->GetMatrixArray():0;}
      54          24 :   static  const Double_t * GetExtendedRoads()  { return (fgExtendedRoads)? fgExtendedRoads->GetMatrixArray():0; }
      55          24 :   static  const Double_t * GetPrimaryDCACut()  { return (fgPrimaryDCACut)? fgPrimaryDCACut->GetMatrixArray():0; }
      56          16 :   static        Double_t   GetPrimaryZ2XCut()  { return fgPrimaryZ2XCut; }
      57          16 :   static        Double_t   GetZOutSectorCut()  { return fgZOutSectorCut; }
      58      129896 :   static        Bool_t     GetCompactClusters() { return fgCompactClusters;}
      59             : 
      60           0 :   static  void SetSystematicError( TVectorD *vec)  { fSystematicErrors=vec;}
      61             :   static  void SetSystematicErrorCluster( TVectorD *vec );
      62           0 :   static  void SetExtendedRoads( TVectorD *extendedRoads ) { fgExtendedRoads=extendedRoads;}
      63             :   static  void SetPrimaryDCACut( TVectorD *dcacut );
      64           0 :   static  void SetPrimaryZ2XCut( double v )                { fgPrimaryZ2XCut=v; }
      65           0 :   static  void SetZOutSectorCut( double v )                { fgZOutSectorCut=v; }
      66           0 :   static  void SetCompactClusters(Bool_t v)                { fgCompactClusters=v;}
      67             : 
      68             : private:
      69             :   AliTPCReconstructor(const AliTPCReconstructor&); //Not implemented
      70             :   AliTPCReconstructor& operator=(const AliTPCReconstructor&); //Not implemented
      71             :   AliTPCParam*         GetTPCParam() const;
      72             :   static Int_t               fgStreamLevel; // flag for streaming      - for TPC reconstruction
      73             :   static TTreeSRedirector    *fgDebugStreamer; // pointer to the streamer
      74             :   AliTPCclusterer*           fClusterer;   // TPC clusterer
      75             :   static AliTPCAltroEmulator * fAltroEmulator;    // ALTRO emulator
      76             :   static TString             fgPIDRespnonsePath;           // path to PIDResponse
      77             :   //
      78             :   // varaibles which overwrite content of the TPCRecoParam in case of custom recosntrcution (e.g CPass0 with imperfect calibration)
      79             :   static TVectorD            * fSystematicErrors;    // systematic errors for the TPC tracks
      80             :   static TVectorD            * fSystematicErrorClusters;    // systematic errors for the TPC tracks
      81             :   static TVectorD            * fgExtendedRoads;       // extended roads for clusters
      82             :   static TVectorD            * fgPrimaryDCACut;       // only primaries passing DCAYZ cut are reconstructed
      83             :   static Double_t              fgPrimaryZ2XCut;       // cut on Z2X for fast primaries reco 
      84             :   static Double_t              fgZOutSectorCut;       // cut on Z going on other side of CE 
      85             :   static Bool_t                fgCompactClusters;     // if true, cluster coordinates will be set to 0 in clusterizer
      86             :   TObjArray *fArrSplines;                  // array of pid splines
      87             : 
      88             :   void SetSplinesFromOADB(const char* tmplt, AliESDpid *esdPID);
      89             :   
      90          88 :   ClassDef(AliTPCReconstructor, 0)   // class for the TPC reconstruction
      91             : };
      92             : 
      93             : #endif