ITS/UPGRADE/AliITSUTrackCond.cxx

   1 #include "AliITSUTrackCond.h"
   2 #include "AliITSUAux.h"
   3 #include "AliLog.h"
   4 #include <TMath.h>
   5
   6 using namespace AliITSUAux;
   7 using namespace TMath;
   8
   9 Char_t    AliITSUTrackCond::fgkClSharing = 0;
  10 Int_t     AliITSUTrackCond::fgkMaxBranches = 50;
  11 Int_t     AliITSUTrackCond::fgkMaxCandidates = 500;
  12 Float_t   AliITSUTrackCond::fgkMaxTr2ClChi2  = 50.;
  13 Float_t   AliITSUTrackCond::fgkMaxChi2GloNrm = 50.;
  14 Float_t   AliITSUTrackCond::fgkMissPenalty  = 2.;
  15 Float_t   AliITSUTrackCond::fgkMaxMatchChi2 = 15.;
  16 Float_t   AliITSUTrackCond::fgkMaxITSSAChi2 = 15;
  17 //______________________________________________________________
  18 AliITSUTrackCond::AliITSUTrackCond(int nLayers)
  19   :fInitDone(kFALSE)
  20   ,fActiveLrInner(0)
  21   ,fActiveLrOuter(0)
  22   ,fExlLayers(0)
  23   ,fNLayers(0)
  24   ,fMaxITSTPCMatchChi2(fgkMaxMatchChi2)
  25   ,fMaxITSSAChi2(fgkMaxITSSAChi2)
  26   ,fClSharing(0)
  27   ,fMaxBranches(0)
  28   ,fMaxCandidates(0)
  29   ,fMaxTr2ClChi2(0)
  30   ,fMaxChi2GloNrm(0)
  31   ,fMissPenalty(0)
  32   ,fNSigmaRoadY(0)
  33   ,fNSigmaRoadZ(0)
  34   ,fNConditions(0)
  35   ,fConditions(0)
  36   ,fAuxData(0)
  37 {
  38   // def c-tor
  39   if (nLayers) SetNLayers(nLayers);
  40 }
  41
  42 //______________________________________________________________
  43 AliITSUTrackCond::AliITSUTrackCond(const AliITSUTrackCond& src)
  44   :TObject(src)
  45   ,fInitDone(src.fInitDone)
  46   ,fActiveLrInner(src.fActiveLrInner)
  47   ,fActiveLrOuter(src.fActiveLrOuter)
  48   ,fExlLayers(src.fExlLayers)
  49   ,fNLayers(0)
  50   ,fMaxITSTPCMatchChi2(src.fMaxITSTPCMatchChi2)
  51   ,fMaxITSSAChi2(src.fMaxITSSAChi2)
  52   ,fClSharing(0)
  53   ,fMaxBranches(0)
  54   ,fMaxCandidates(0)
  55   ,fMaxTr2ClChi2(0)
  56   ,fMaxChi2GloNrm(0)
  57   ,fMissPenalty(0)
  58   ,fNSigmaRoadY(0)
  59   ,fNSigmaRoadZ(0)
  60   ,fNConditions(src.fNConditions)
  61   ,fConditions(src.fConditions)
  62   ,fAuxData(src.fAuxData)
  63 {
  64   // copy c-tor
  65   SetNLayers(src.fNLayers);
  66   for (int i=fNLayers;i--;) {
  67     SetMaxBranches(i,src.GetMaxBranches(i));
  68     SetMaxCandidates(i,src.GetMaxCandidates(i));
  69     SetMaxTr2ClChi2(i,src.GetMaxTr2ClChi2(i));
  70     SetMaxChi2GloNrm(i,src.GetMaxChi2GloNrm(i));
  71     SetMissPenalty(i,src.GetMissPenalty(i));
  72     SetNSigmaRoadY(i,src.GetNSigmaRoadY(i));
  73     SetNSigmaRoadZ(i,src.GetNSigmaRoadZ(i));
  74     SetClSharing(i,src.GetClSharing(i));
  75   }
  76 }
  77
  78 //______________________________________________________________
  79 AliITSUTrackCond& AliITSUTrackCond::operator=(const AliITSUTrackCond& src)
  80 {
  81   // copy op.
  82   if (this!=&src) {
  83     fInitDone = src.fInitDone;
  84     fActiveLrInner = src.fActiveLrInner;
  85     fActiveLrOuter = src.fActiveLrOuter;
  86     //
  87     fExlLayers = src.fExlLayers;
  88     fNConditions = src.fNConditions;
  89     fConditions  = src.fConditions;
  90     fMaxITSTPCMatchChi2 = src.fMaxITSTPCMatchChi2;
  91     fMaxITSSAChi2       = src.fMaxITSSAChi2;
  92     //
  93     SetNLayers(src.fNLayers);
  94     //
  95     for (int i=fNLayers;i--;) {
  96       SetMaxBranches(i,src.GetMaxBranches(i));
  97       SetMaxCandidates(i,src.GetMaxCandidates(i));
  98       SetMaxTr2ClChi2(i,src.GetMaxTr2ClChi2(i));
  99       SetMaxChi2GloNrm(i,src.GetMaxChi2GloNrm(i));
 100       SetMissPenalty(i,src.GetMissPenalty(i));
 101       SetNSigmaRoadY(i,src.GetNSigmaRoadY(i));
 102       SetNSigmaRoadZ(i,src.GetNSigmaRoadZ(i));
 103       SetClSharing(i,src.GetClSharing(i));
 104     }
 105     fAuxData = src.fAuxData;
 106   }
 107   return *this;
 108 }
 109
 110 //______________________________________________________________
 111 void AliITSUTrackCond::SetNLayers(int nLayers)
 112 {
 113   // set number of layers
 114   fInitDone = kFALSE;
 115   if (fNLayers) {
 116     delete[] fClSharing;
 117     delete[] fMaxBranches;
 118     delete[] fMaxCandidates;
 119     delete[] fMaxTr2ClChi2;
 120     delete[] fMaxChi2GloNrm;
 121     delete[] fMissPenalty;
 122     delete[] fNSigmaRoadY;
 123     delete[] fNSigmaRoadZ;
 124   }
 125   fNLayers = nLayers;
 126   //
 127   if (fNLayers>0) {
 128     fActiveLrInner = 0;
 129     fActiveLrOuter = fNLayers-1;
 130     fClSharing     = new Char_t[fNLayers];
 131     fMaxBranches   = new Short_t[fNLayers];
 132     fMaxCandidates = new Short_t[fNLayers];
 133     fMaxTr2ClChi2  = new Float_t[fNLayers];
 134     fMaxChi2GloNrm = new Float_t[fNLayers];
 135     fMissPenalty   = new Float_t[fNLayers];
 136     fNSigmaRoadY   = new Float_t[fNLayers];
 137     fNSigmaRoadZ   = new Float_t[fNLayers];
 138     for (int i=fNLayers;i--;) {
 139       SetClSharing(i,fgkClSharing);
 140       SetMaxBranches(i,fgkMaxBranches);
 141       SetMaxCandidates(i,fgkMaxCandidates);
 142       SetMaxTr2ClChi2(i,fgkMaxTr2ClChi2);
 143       SetMaxChi2GloNrm(i,fgkMaxChi2GloNrm);
 144       SetMissPenalty(i,fgkMissPenalty);
 145       SetNSigmaRoadY(i,-1); // force recalculation
 146       SetNSigmaRoadZ(i,-1); // force recalculation
 147     }
 148   }
 149   else {
 150     fClSharing     = 0;
 151     fMaxBranches   = 0;
 152     fMaxCandidates = 0;
 153     fMaxTr2ClChi2  = 0;
 154     fMaxChi2GloNrm = 0;
 155     fMissPenalty   = 0;
 156     fNSigmaRoadY   = 0;
 157     fNSigmaRoadZ   = 0;
 158   }
 159   //
 160 }
 161
 162 //______________________________________________________________
 163 void AliITSUTrackCond::AddGroupPattern(UShort_t patt,Int_t minCl)
 164 {
 165   // add new group pattern to last condition: the track should have at least minCl clusters at layers given by patt
 166   if (fNConditions<1) AliFatal("Can be called only after AddCondition");
 167   if (minCl>int(AliITSUAux::kMaxLayers)) AliFatal(Form("Requested Nlayers=%d exceeds max alowed %d",minCl,AliITSUAux::kMaxLayers));
 168   if (minCl<1)                           AliFatal(Form("Requested Nlayers=%d for pattern %x",minCl,patt));
 169   int ind = fConditions.GetSize();
 170   fConditions.Set(ind+1);
 171   fConditions[ind] = (patt&AliITSUAux::kMaxLrMask) | (minCl<<kShiftNcl);
 172   fAuxData[(fNConditions-1)*kNAuxSz + kNGroups]++;
 173 }
 174
 175 //______________________________________________________________
 176 void AliITSUTrackCond::AddNewCondition(Int_t minClusters)
 177 {
 178   // add new track condition
 179   fAuxData.Set( (1+fNConditions)*kNAuxSz );
 180   fAuxData[fNConditions*kNAuxSz+kCondStart] = fConditions.GetSize();
 181   fAuxData[fNConditions*kNAuxSz+kNGroups]   = 0;
 182   fAuxData[fNConditions*kNAuxSz+kMinClus]   = minClusters;
 183   fNConditions++;
 184   //
 185 }
 186
 187 //______________________________________________________________
 188 Bool_t AliITSUTrackCond::CheckPattern(UShort_t patt) const
 189 {
 190   // check if the pattern matches to some condition
 191   Short_t *arrAux = (Short_t*)fAuxData.GetArray();
 192   UInt_t  *arrGrp = (UInt_t*)fConditions.GetArray();
 193   int ncl = NumberOfBitsSet(patt);
 194   int cntCond = 0;
 195   for (int ic=0;ic<fNConditions;ic++) {
 196     if (arrAux[cntCond+kMinClus]>ncl) {cntCond+=kNAuxSz; continue;} // check number of clusters
 197     int grAddr = arrAux[cntCond+kCondStart]; // 1st group pattern address in the condition
 198     Bool_t ok = kTRUE;
 199     // if every group of the condition does not match, check next contition
 200     for (int ig=arrAux[cntCond+kNGroups];ig--;) {
 201       UInt_t pattReq = arrGrp[grAddr++];
 202       UShort_t actLr = (pattReq&AliITSUAux::kMaxLrMask)&patt;  // patter of active layers satisfying to mask
 203       if (!actLr || NumberOfBitsSet(actLr)<int(pattReq>>kShiftNcl)) {ok = kFALSE; break;}
 204     }
 205     if (ok) return kTRUE;
 206     cntCond += kNAuxSz;
 207   }
 208   return kFALSE;
 209 }
 210
 211 //______________________________________________________________
 212 void AliITSUTrackCond::Print(Option_t*) const
 213 {
 214   // print conditions
 215   int nc = GetNConditions();
 216   Short_t *arrAux = (Short_t*)fAuxData.GetArray();
 217   UInt_t  *arrGrp = (UInt_t*)fConditions.GetArray();
 218   int cntCond = 0;
 219   printf("Conditions set ID=%d : %d entries\n",GetID(),nc);
 220   for (int i=0;i<nc;i++) {
 221     printf("#%2d: MinCl:%2d | %d groups :",i,arrAux[cntCond+kMinClus],arrAux[cntCond+kNGroups]);
 222     int grAddr = arrAux[cntCond+kCondStart];
 223     for (int ig=arrAux[cntCond+kNGroups];ig--;) {
 224       UInt_t patt = arrGrp[grAddr];
 225       printf("{");
 226       PrintBits(patt, fNLayers);
 227       printf("|%d}",patt>>kShiftNcl);
 228       grAddr++;
 229     }
 230     printf("\n");
 231     cntCond += kNAuxSz;
 232   }
 233   if (fExlLayers) {
 234     printf("Exluded Layers: ");
 235     for (int i=0;i<fNLayers;i++) if (IsLayerExcluded(i)) printf(" %d",i); printf("\n");
 236   }
 237   printf("Cuts:\t%6s\t%6s\t%4s\t%8s\t%8s\t%8s\t%8s\t%8s\n", "MaxBrn","MaxCnd","ClSh","Chi2Cl","Chi2Glo","Mis.Pen.","NSig.Y","NSig.Z");
 238   for (int i=0;i<fNLayers;i++) {
 239     printf("Lr%2d:\t%6d\t%6d\t%4d\t%8.1f\t%8.2f\t%8.2f\t%8.2f\t%8.2f\n",i,
 240            fMaxBranches[i],fMaxCandidates[i],fClSharing[i],fMaxTr2ClChi2[i],fMaxChi2GloNrm[i],fMissPenalty[i],fNSigmaRoadY[i],fNSigmaRoadZ[i]);
 241   }
 242   //
 243   printf("ITS/TPC matching MaxChi2: %.3f\n",fMaxITSTPCMatchChi2);
 244   printf("ITS_SA BWD fit   MaxChi2: %.3f\n",fMaxITSSAChi2);
 245   //
 246 }
 247
 248 //______________________________________________________________
 249 void AliITSUTrackCond::Init()
 250 {
 251   // finalize and check consistency
 252   if (fInitDone) return;
 253   //
 254   fActiveLrInner = -1;
 255   for (int ilr=0;ilr<fNLayers;ilr++) {
 256     if (IsLayerExcluded(ilr)) continue;
 257     if (fActiveLrInner<0) fActiveLrInner = ilr;
 258     fActiveLrOuter = ilr;
 259     float nsig = Sqrt(2*GetMaxTr2ClChi2(ilr));
 260     if (GetNSigmaRoadY(ilr)<0) SetNSigmaRoadY(ilr,nsig);
 261     if (GetNSigmaRoadZ(ilr)<0) SetNSigmaRoadZ(ilr,nsig);
 262     //
 263   }
 264   if (fMaxITSTPCMatchChi2<1e-6) SetMaxITSTPCMatchChi2(fgkMaxMatchChi2);
 265   if (fMaxITSSAChi2<1e-6)       SetMaxITSSAChi2(fgkMaxITSSAChi2);
 266   //
 267   fInitDone = kTRUE;
 268 }