1) Fix in tracking condition pattern definition
[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUTrackCond.h
CommitLineData
3c18eefd 1#ifndef ALIITSUTRACKCOND_H
2#define ALIITSUTRACKCOND_H
3
4#include <TObject.h>
5#include <TArrayS.h>
70f61d86 6#include <TArrayI.h>
3c18eefd 7
8//------------------------------------------------------------------------------
9//
10// This class defines a set of hit patterns (conditions) to consider the track reconstructable
11// Each condidition (few consequitive elements from fConditions array) is set of bit patterns,
12// with each element of condition defining a group of layers which must be present in the tracks.
13// For instance, if we require the track to have contributions from
14// {lr0 or lr1 or lr2} AND {lr2 or lr 3 or lr 4} AND {lr5 or lr6} then the condition should
15// be {BIT(0)|BIT(1)|BIT(2), BIT(2)|BIT(3)|BIT(4), BIT(5)|BIT(6)}.
16// Additionally, each condition may request min number of hits to be present
17//
18// Each AliITSUTrackCond should correspond to single track finding pass and may contain multiple
19// conditions. To consider the track reconstructable it is enough to satisfy 1 condition
20//
21//------------------------------------------------------------------------------
22
23
24class AliITSUTrackCond : public TObject
25{
26 public:
27 enum {kCondStart,kNGroups,kMinClus,kNAuxSz};
70f61d86 28 enum {kShiftNcl=24}; // the min_Nclusters for each pattern is stored starting from this bit
6cd80116 29 //
3c18eefd 30 AliITSUTrackCond(Int_t nLayers=0);
31 AliITSUTrackCond(const AliITSUTrackCond& src);
32 AliITSUTrackCond &operator=(const AliITSUTrackCond& src);
33
34 ~AliITSUTrackCond() {}
35
38997c3c 36 void SetNLayers(Int_t nl);
c03e4f8a 37 void SetClSharing(Int_t lr, Char_t v=0) {fClSharing[lr] = v;}
38997c3c 38 void SetMaxBranches(Int_t lr, Int_t mb) {fMaxBranches[lr] = mb;}
39 void SetMaxCandidates(Int_t lr, Int_t nc) {fMaxCandidates[lr] = nc;}
3c18eefd 40 void SetID(Int_t id) {SetUniqueID(id);}
41 void AddNewCondition(Int_t minClusters);
70f61d86 42 void AddGroupPattern(UShort_t patt,Int_t ncl);
3c18eefd 43
44 Int_t GetID() const {return GetUniqueID();}
38997c3c 45 Int_t GetMaxBranches(Int_t lr) const {return fMaxBranches[lr];}
46 Int_t GetMaxCandidates(Int_t lr) const {return fMaxCandidates[lr];}
3c18eefd 47 Int_t GetNConditions() const {return fNConditions;}
48 UShort_t GetGroup(Int_t condID,Int_t grID) const {return fConditions[fAuxData[condID*kNAuxSz+kCondStart]+grID];}
c8d1f258 49 Bool_t CheckPattern(UShort_t patt) const;
3c18eefd 50 //
51 virtual void Print(Option_t* option = "") const;
52
9cdcba2c 53 void SetMaxITSTPCMatchChi2(Float_t v) {fMaxITSTPCMatchChi2 = v;}
54 void SetMaxITSSAChi2(Float_t v) {fMaxITSSAChi2 = v;}
ee54014a 55 void SetMaxTr2ClChi2(Int_t lr, Float_t v) {fMaxTr2ClChi2[lr] = v;}
08419930 56 void SetMaxChi2GloNrm(Int_t lr, Float_t v) {fMaxChi2GloNrm[lr] = v;}
ee54014a 57 void SetMissPenalty(Int_t lr, Float_t v) {fMissPenalty[lr] = v;}
58 void SetNSigmaRoadY(Int_t lr, Float_t v) {fNSigmaRoadY[lr] = v;}
59 void SetNSigmaRoadZ(Int_t lr, Float_t v) {fNSigmaRoadZ[lr] = v;}
3c18eefd 60 //
9cdcba2c 61 Float_t GetMaxITSTPCMatchChi2() const {return fMaxITSTPCMatchChi2;}
62 Float_t GetMaxITSSAChi2() const {return fMaxITSSAChi2;}
c03e4f8a 63 Char_t GetClSharing(Int_t lr) const {return fClSharing[lr];}
ee54014a 64 Float_t GetMissPenalty(Int_t lr) const {return fMissPenalty[lr];}
65 Float_t GetMaxTr2ClChi2(Int_t lr) const {return fMaxTr2ClChi2[lr];}
08419930 66 Float_t GetMaxChi2GloNrm(Int_t lr) const {return fMaxChi2GloNrm[lr];}
ee54014a 67 Float_t GetNSigmaRoadY(Int_t lr) const {return fNSigmaRoadY[lr];}
68 Float_t GetNSigmaRoadZ(Int_t lr) const {return fNSigmaRoadZ[lr];}
69 Bool_t IsLayerExcluded(Int_t lr) const {return GetMaxTr2ClChi2(lr)<=0;}
70 //
71 void Init();
72 Bool_t IsInitDone() const {return fInitDone;}
73 //
74 protected:
75 //
76 Bool_t fInitDone; // initialization flag
38997c3c 77 Int_t fNLayers; // total number of layers
9cdcba2c 78 Float_t fMaxITSTPCMatchChi2; // max chi2 for ITS/TPC matching
79 Float_t fMaxITSSAChi2; // max chi2 for ITS standalone fit (backward)
c03e4f8a 80 Char_t* fClSharing; // [fNLayers] is cluster sharing allowed
38997c3c 81 Short_t* fMaxBranches; // [fNLayers] max allowed branches per seed on each layer
82 Short_t* fMaxCandidates; // [fNLayers] max allowed candidates per TPC seed on each layer
ee54014a 83 Float_t* fMaxTr2ClChi2; // [fNLayers] max track-to-cluster chi2
08419930 84 Float_t* fMaxChi2GloNrm; // [fNLayers] max norm global chi2
ee54014a 85 Float_t* fMissPenalty; // [fNLayers] chi2 penalty for missing hit on the layer
86 Float_t* fNSigmaRoadY; // [fNLayers] number of sigmas in Y
87 Float_t* fNSigmaRoadZ; // [fNLayers] number of sigmas in Z
88 //
3c18eefd 89 Short_t fNConditions; // number of conditions defined
70f61d86 90 TArrayI fConditions; // fNConditions set of conditions
3c18eefd 91 TArrayS fAuxData; // condition beginning (1st group), n groups, min clus
92 //
c03e4f8a 93 static Char_t fgkClSharing; // def cl.sharing allowed level
ee54014a 94 static Int_t fgkMaxBranches; // def max number of branches per seed on current layer
95 static Int_t fgkMaxCandidates; // def max number of total candidates on current layer
96 static Float_t fgkMaxTr2ClChi2; // def track-to-cluster chi2 cut
08419930 97 static Float_t fgkMaxChi2GloNrm; // def global norm chi2 cut
ee54014a 98 static Float_t fgkMissPenalty; // penalty for missing cluster
9cdcba2c 99 static Float_t fgkMaxMatchChi2; // max acceptable matching chi2
100 static Float_t fgkMaxITSSAChi2; // max acceptable standalone ITS backward fit chi2
ee54014a 101 //
70f61d86 102 ClassDef(AliITSUTrackCond,6) // set of requirements on track hits pattern
3c18eefd 103};
104
105
106
107#endif