#include <TObject.h>
#include <TArrayS.h>
+#include <TArrayI.h>
//------------------------------------------------------------------------------
//
{
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)
-
-
+ enum {kShiftNcl=24}; // the min_Nclusters for each pattern is stored starting from this bit
+ //
AliITSUTrackCond(Int_t nLayers=0);
AliITSUTrackCond(const AliITSUTrackCond& src);
AliITSUTrackCond &operator=(const AliITSUTrackCond& src);
~AliITSUTrackCond() {}
void SetNLayers(Int_t nl);
+ void SetClSharing(Int_t lr, Char_t v=0) {fClSharing[lr] = v;}
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);
+ void AddGroupPattern(UShort_t patt,Int_t ncl);
Int_t GetID() const {return GetUniqueID();}
Int_t GetMaxBranches(Int_t lr) const {return fMaxBranches[lr];}
//
virtual void Print(Option_t* option = "") const;
- protected:
+ void SetMaxITSTPCMatchChi2(Float_t v) {fMaxITSTPCMatchChi2 = v;}
+ void SetMaxITSSAChi2(Int_t ncl, Float_t v) {if (ncl>0&&ncl<=2*fNLayers) fMaxITSSAChi2[ncl-1] = v;}
+ void SetMaxTr2ClChi2(Int_t lr, Float_t v) {fMaxTr2ClChi2[lr] = v;}
+ void SetMaxChi2GloNrm(Int_t lr, Float_t v) {fMaxChi2GloNrm[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;}
+ void ExcludeLayer(Int_t lr) {fAllowLayers &= ~(0x1<<lr);}
+ //
+ Float_t GetMaxITSTPCMatchChi2() const {return fMaxITSTPCMatchChi2;}
+ Float_t GetMaxITSSAChi2(Int_t ncl) const {return fMaxITSSAChi2[ncl-1];}
+ Char_t GetClSharing(Int_t lr) const {return fClSharing[lr];}
+ Float_t GetMissPenalty(Int_t lr) const {return fMissPenalty[lr];}
+ Float_t GetMaxTr2ClChi2(Int_t lr) const {return fMaxTr2ClChi2[lr];}
+ Float_t GetMaxChi2GloNrm(Int_t lr) const {return fMaxChi2GloNrm[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 !(fAllowLayers&(0x1<<lr));}
+ Int_t GetActiveLrInner() const {return fActiveLrInner;}
+ Int_t GetActiveLrOuter() const {return fActiveLrOuter;}
+ UShort_t GetAllowedLayers() const {return fAllowLayers;}
//
+ void Init();
+ Bool_t IsInitDone() const {return fInitDone;}
+ //
+ protected:
+ //
+ Bool_t fInitDone; // initialization flag
+ Char_t fActiveLrInner; // innermost active layer to consider
+ Char_t fActiveLrOuter; // outermose active layer to consider
+ UShort_t fAllowLayers; // pattern of active layers to be checked
Int_t fNLayers; // total number of layers
+ Int_t fMaxClus; // max number of clusters in track (by default, 2*fNLayers)
+ Float_t fMaxITSTPCMatchChi2; // max chi2 for ITS/TPC matching
+ Char_t* fClSharing; // [fNLayers] is cluster sharing allowed
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* fMaxITSSAChi2; // [fMaxClus] max chi2 for ITS standalone fit (backward) vs N cl
+ Float_t* fMaxTr2ClChi2; // [fNLayers] max track-to-cluster chi2
+ Float_t* fMaxChi2GloNrm; // [fNLayers] max norm global 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 fNConditions; // number of conditions defined
- TArrayS fConditions; // fNConditions set of conditions
+ TArrayI fConditions; // fNConditions set of conditions
TArrayS fAuxData; // condition beginning (1st group), n groups, min clus
//
- ClassDef(AliITSUTrackCond,2) // set of requirements on track hits pattern
+ static Char_t fgkClSharing; // def cl.sharing allowed level
+ 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 fgkMaxChi2GloNrm; // def global norm chi2 cut
+ static Float_t fgkMissPenalty; // penalty for missing cluster
+ static Float_t fgkMaxMatchChi2; // max acceptable matching chi2
+ static Float_t fgkMaxITSSAChi2; // max acceptable standalone ITS backward fit chi2
+ //
+ ClassDef(AliITSUTrackCond,10) // set of requirements on track hits pattern
};