Line data    Source code

       1             : #ifndef ALIITSVERTEXERZ_H
       2             : #define ALIITSVERTEXERZ_H
       3             : 
       4             : #include<AliITSVertexer.h>
       5             : 
       6             : ///////////////////////////////////////////////////////////////////
       7             : //                                                               //
       8             : // Class for primary vertex finding                              //
       9             : //                                                               //
      10             : ///////////////////////////////////////////////////////////////////
      11             : 
      12             : class TFile;
      13             : class TString;
      14             : class AliESDVertex;
      15             : class TH1F;
      16             : 
      17             : class AliITSVertexerZ : public AliITSVertexer {
      18             : 
      19             :  public:
      20             : 
      21             :   AliITSVertexerZ();
      22             :   AliITSVertexerZ(Float_t x0, Float_t y0);
      23             :   virtual ~AliITSVertexerZ();
      24             :   // The number of contributors set in the AliESDVertex object is the
      25             :   // number of tracklets used to determine the vertex position
      26             :   // If this number is <1, the procedure could not find a vertex position
      27             :   // and by default the Z coordinate is set to 0
      28             :   // Number of contributors = -1  --> No tracklets 
      29             :   // Number of contributors = -2  --> No SPD recpoints
      30             :   virtual AliESDVertex* FindVertexForCurrentEvent(TTree *itsClusterTree);
      31             :   virtual void PrintStatus() const;
      32           0 :   void SetDiffPhiMax(Float_t pm = 0.01){fDiffPhiMax = pm;}
      33             :   void ConfigIterations(Int_t noiter=4,Float_t *ptr=0);
      34           0 :   void SetFirstLayerModules(Int_t m1 = 0, Int_t m2 = 79){fFirstL1 = m1; fLastL1 = m2;}
      35           0 :   void SetSecondLayerModules(Int_t m1 = 80, Int_t m2 = 239){fFirstL2 = m1; fLastL2 = m2;}
      36           0 :   void SetLowLimit(Float_t lim=-40.){fLowLim = lim;}
      37           0 :   void SetHighLimit(Float_t lim=40.){fHighLim = lim;}
      38           0 :   Float_t GetLowLimit() const {return fLowLim;}
      39           0 :   Float_t GetHighLimit() const {return fHighLim;}
      40           0 :   void SetBinWidthCoarse(Float_t bw=0.01){fStepCoarse = bw;}
      41           0 :   void SetPPsetting(Float_t cl2=250., Float_t coarsebin=0.02){fPPsetting[0]=cl2; fPPsetting[1]=coarsebin;}
      42             :   static Int_t GetPeakRegion(TH1F* h, Int_t &binmin, Int_t &binmax);
      43             :   static Int_t FindSecondPeak(TH1F* h, Int_t binmin,Int_t binmax, Float_t& secPeakPos);
      44           0 :   Float_t GetBinWidthCoarse() const {return fStepCoarse;}
      45           0 :   void SetTolerance(Float_t tol = 20./10000.){fTolerance = tol;}
      46           0 :   void SetWindowWidth(Float_t ww=0.2){fWindowWidth=ww;}
      47           0 :   Float_t GetTolerance() const {return fTolerance;}
      48             :   //  virtual void MakeTracklet(Double_t * /* pA */, Double_t * /*pB */, Int_t & /* nolines */) {} // implemented in a derived class
      49             : 
      50           0 :   void SetSearchForPileup(Bool_t opt){fSearchForPileup=opt;}
      51           0 :   Bool_t IsSearchForPileupActive() const { return fSearchForPileup;}
      52             : 
      53             :  protected:
      54             :   void ResetHistograms();
      55             :   void VertexZFinder(TTree *itsClusterTree);
      56           0 :   Float_t GetPhiMaxIter(Int_t i) const {return fPhiDiffIter[i];}
      57             : 
      58             : 
      59             :   Int_t fFirstL1;          // first module of the first pixel layer used
      60             :   Int_t fLastL1;           // last module of the first pixel layer used
      61             :   Int_t fFirstL2;          // first module of the second pixel layer used
      62             :   Int_t fLastL2;           // last module of the second pixel layer used
      63             :   Float_t fDiffPhiMax;     // Maximum delta phi allowed among corr. pixels
      64             :   Float_t fZFound;         //! found value for the current event
      65             :   Float_t fZsig;           //! RMS of Z
      66             :   TH1F *fZCombc;           //! histogram with coarse z distribution
      67             :   Float_t fLowLim;         // low limit for fZComb histograms
      68             :   Float_t fHighLim;        // high limit for fZComb histograms
      69             :   Float_t fStepCoarse;     // bin width for fZCombc
      70             :   Float_t fTolerance;      // tolerance on the symmetry of the Z interval 
      71             :   Float_t fPPsetting[2];   // [0] is the max. number of clusters on L2 to use [1] as fStepCoarse
      72             :   Int_t fMaxIter;            // Maximum number of iterations (<=5)
      73             :   Float_t fPhiDiffIter[5];   // Delta phi used in iterations
      74             :   Float_t fWindowWidth;      // Z window width for symmetrization
      75             :   Bool_t  fSearchForPileup;  // flag to switch pileup off/on
      76             : 
      77             :  private:
      78             :   AliITSVertexerZ(const AliITSVertexerZ& vtxr);
      79             :   AliITSVertexerZ& operator=(const AliITSVertexerZ& vtxr );
      80             : 
      81         118 :   ClassDef(AliITSVertexerZ,11);
      82             : };
      83             : 
      84             : #endif