]>
Commit | Line | Data |
---|---|---|
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 | ||
24 | class 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;} |
5e3587be | 54 | void SetMaxITSSAChi2(Int_t ncl, Float_t v) {if (ncl>0&&ncl<=2*fNLayers) fMaxITSSAChi2[ncl-1] = v;} |
ee54014a | 55 | void SetMaxTr2ClChi2(Int_t lr, Float_t v) {fMaxTr2ClChi2[lr] = v;} |
d99994b2 | 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;} | |
c0098d78 | 60 | void ExcludeLayer(Int_t lr) {fAllowLayers &= ~(0x1<<lr);} |
3c18eefd | 61 | // |
9cdcba2c | 62 | Float_t GetMaxITSTPCMatchChi2() const {return fMaxITSTPCMatchChi2;} |
5e3587be | 63 | Float_t GetMaxITSSAChi2(Int_t ncl) const {return fMaxITSSAChi2[ncl-1];} |
c03e4f8a | 64 | Char_t GetClSharing(Int_t lr) const {return fClSharing[lr];} |
ee54014a | 65 | Float_t GetMissPenalty(Int_t lr) const {return fMissPenalty[lr];} |
66 | Float_t GetMaxTr2ClChi2(Int_t lr) const {return fMaxTr2ClChi2[lr];} | |
08419930 | 67 | Float_t GetMaxChi2GloNrm(Int_t lr) const {return fMaxChi2GloNrm[lr];} |
ee54014a | 68 | Float_t GetNSigmaRoadY(Int_t lr) const {return fNSigmaRoadY[lr];} |
69 | Float_t GetNSigmaRoadZ(Int_t lr) const {return fNSigmaRoadZ[lr];} | |
c0098d78 | 70 | Bool_t IsLayerExcluded(Int_t lr) const {return !(fAllowLayers&(0x1<<lr));} |
d99994b2 | 71 | Int_t GetActiveLrInner() const {return fActiveLrInner;} |
72 | Int_t GetActiveLrOuter() const {return fActiveLrOuter;} | |
c0098d78 | 73 | UShort_t GetAllowedLayers() const {return fAllowLayers;} |
ee54014a | 74 | // |
75 | void Init(); | |
76 | Bool_t IsInitDone() const {return fInitDone;} | |
77 | // | |
78 | protected: | |
79 | // | |
80 | Bool_t fInitDone; // initialization flag | |
d99994b2 | 81 | Char_t fActiveLrInner; // innermost active layer to consider |
82 | Char_t fActiveLrOuter; // outermose active layer to consider | |
c0098d78 | 83 | UShort_t fAllowLayers; // pattern of active layers to be checked |
38997c3c | 84 | Int_t fNLayers; // total number of layers |
6cb10ec2 | 85 | Int_t fMaxClus; // max number of clusters in track (by default, 2*fNLayers) |
9cdcba2c | 86 | Float_t fMaxITSTPCMatchChi2; // max chi2 for ITS/TPC matching |
c03e4f8a | 87 | Char_t* fClSharing; // [fNLayers] is cluster sharing allowed |
38997c3c | 88 | Short_t* fMaxBranches; // [fNLayers] max allowed branches per seed on each layer |
89 | Short_t* fMaxCandidates; // [fNLayers] max allowed candidates per TPC seed on each layer | |
6cb10ec2 | 90 | Float_t* fMaxITSSAChi2; // [fMaxClus] max chi2 for ITS standalone fit (backward) vs N cl |
ee54014a | 91 | Float_t* fMaxTr2ClChi2; // [fNLayers] max track-to-cluster chi2 |
08419930 | 92 | Float_t* fMaxChi2GloNrm; // [fNLayers] max norm global chi2 |
ee54014a | 93 | Float_t* fMissPenalty; // [fNLayers] chi2 penalty for missing hit on the layer |
94 | Float_t* fNSigmaRoadY; // [fNLayers] number of sigmas in Y | |
95 | Float_t* fNSigmaRoadZ; // [fNLayers] number of sigmas in Z | |
96 | // | |
3c18eefd | 97 | Short_t fNConditions; // number of conditions defined |
70f61d86 | 98 | TArrayI fConditions; // fNConditions set of conditions |
3c18eefd | 99 | TArrayS fAuxData; // condition beginning (1st group), n groups, min clus |
100 | // | |
d99994b2 | 101 | static Char_t fgkClSharing; // def cl.sharing allowed level |
ee54014a | 102 | static Int_t fgkMaxBranches; // def max number of branches per seed on current layer |
103 | static Int_t fgkMaxCandidates; // def max number of total candidates on current layer | |
104 | static Float_t fgkMaxTr2ClChi2; // def track-to-cluster chi2 cut | |
08419930 | 105 | static Float_t fgkMaxChi2GloNrm; // def global norm chi2 cut |
ee54014a | 106 | static Float_t fgkMissPenalty; // penalty for missing cluster |
9cdcba2c | 107 | static Float_t fgkMaxMatchChi2; // max acceptable matching chi2 |
108 | static Float_t fgkMaxITSSAChi2; // max acceptable standalone ITS backward fit chi2 | |
ee54014a | 109 | // |
6cb10ec2 | 110 | ClassDef(AliITSUTrackCond,10) // set of requirements on track hits pattern |
3c18eefd | 111 | }; |
112 | ||
113 | ||
114 | ||
115 | #endif |