Made chi2-cut, road definitions AliITSUTrackCond and layer dependent

[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUTrackCond.h

diff --git a/ITS/UPGRADE/AliITSUTrackCond.h b/ITS/UPGRADE/AliITSUTrackCond.h
index 756d01b242454d01111918d9f8d02430f4924530..d5fbd428517a5cca38408b29c477844f878971f6 100644 (file)
--- a/ITS/UPGRADE/AliITSUTrackCond.h
+++ b/ITS/UPGRADE/AliITSUTrackCond.h
@@ -24,6 +24,8 @@ class AliITSUTrackCond : public TObject
 {
  public:
   enum {kCondStart,kNGroups,kMinClus,kNAuxSz};
+  enum {kMaxBranches=50,kMaxCandidates=500};     // max number of branches one can create for single seed on any layer (except branch w/o cl. attached)
+  
 
   AliITSUTrackCond(Int_t nLayers=0);
   AliITSUTrackCond(const AliITSUTrackCond& src);
@@ -31,26 +33,57 @@ class AliITSUTrackCond : public TObject
 
   ~AliITSUTrackCond() {}
   
-  void        SetNLayers(Int_t nl)                 {fNLayers = nl;}
+  void        SetNLayers(Int_t nl);
+  void        SetMaxBranches(Int_t lr, Int_t mb)   {fMaxBranches[lr] = mb;}
+  void        SetMaxCandidates(Int_t lr, Int_t nc) {fMaxCandidates[lr] = nc;}
   void        SetID(Int_t id)                      {SetUniqueID(id);}
   void        AddNewCondition(Int_t minClusters);
   void        AddGroupPattern(UShort_t patt);
 
   Int_t       GetID()                                  const {return GetUniqueID();}
+  Int_t       GetMaxBranches(Int_t lr)                 const {return fMaxBranches[lr];}
+  Int_t       GetMaxCandidates(Int_t lr)               const {return fMaxCandidates[lr];}
   Int_t       GetNConditions()                         const {return fNConditions;}
   UShort_t    GetGroup(Int_t condID,Int_t grID)        const {return fConditions[fAuxData[condID*kNAuxSz+kCondStart]+grID];}
-  Bool_t      CheckPattern(Int_t ncl,UShort_t patt)    const;
+  Bool_t      CheckPattern(UShort_t patt)    const;
   //
   virtual void  Print(Option_t* option = "")           const;
 
- protected:
+  void        SetMaxTr2ClChi2(Int_t lr, Float_t v)           {fMaxTr2ClChi2[lr] = v;}
+  void        SetMissPenalty(Int_t lr,  Float_t v)           {fMissPenalty[lr] = v;}
+  void        SetNSigmaRoadY(Int_t lr,  Float_t v)           {fNSigmaRoadY[lr] = v;}
+  void        SetNSigmaRoadZ(Int_t lr,  Float_t v)           {fNSigmaRoadZ[lr] = v;}
+  //
+  Float_t     GetMissPenalty(Int_t lr)                 const {return fMissPenalty[lr];}
+  Float_t     GetMaxTr2ClChi2(Int_t lr)                const {return fMaxTr2ClChi2[lr];}
+  Float_t     GetNSigmaRoadY(Int_t lr)                 const {return fNSigmaRoadY[lr];}
+  Float_t     GetNSigmaRoadZ(Int_t lr)                 const {return fNSigmaRoadZ[lr];}
+  Bool_t      IsLayerExcluded(Int_t lr)                const {return GetMaxTr2ClChi2(lr)<=0;}
+  //
+  void        Init();
+  Bool_t      IsInitDone()                             const {return fInitDone;}
+  //
+ protected: 
+  //
+  Bool_t      fInitDone;                 // initialization flag
+  Int_t       fNLayers;                  // total number of layers
+  Short_t*    fMaxBranches;              // [fNLayers] max allowed branches per seed on each layer
+  Short_t*    fMaxCandidates;            // [fNLayers] max allowed candidates per TPC seed on each layer
+  Float_t*    fMaxTr2ClChi2;             // [fNLayers] max track-to-cluster chi2
+  Float_t*    fMissPenalty;              // [fNLayers] chi2 penalty for missing hit on the layer
+  Float_t*    fNSigmaRoadY;              // [fNLayers] number of sigmas in Y
+  Float_t*    fNSigmaRoadZ;              // [fNLayers] number of sigmas in Z
   //
-  Short_t     fNLayers;                  // total number of layers
   Short_t     fNConditions;              // number of conditions defined
-  TArrayS     fConditions;               //[fNConditions] set of conditions
+  TArrayS     fConditions;               // fNConditions  set of conditions
   TArrayS     fAuxData;                  // condition beginning (1st group), n groups, min clus
   //
-  ClassDef(AliITSUTrackCond,1)           // set of requirements on track hits pattern
+  static Int_t   fgkMaxBranches;          // def max number of branches per seed on current layer 
+  static Int_t   fgkMaxCandidates;        // def max number of total candidates on current layer 
+  static Float_t fgkMaxTr2ClChi2;         // def track-to-cluster chi2 cut
+  static Float_t fgkMissPenalty;          // penalty for missing cluster
+  //
+  ClassDef(AliITSUTrackCond,3)           // set of requirements on track hits pattern
 };