HLT/ITS/tracking/AliHLTITSLayer.cxx

   1 // **************************************************************************
   2 // This file is property of and copyright by the ALICE HLT Project          *
   3 // ALICE Experiment at CERN, All rights reserved.                           *
   4 //                                                                          *
   5 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
   6 //                  for The ALICE HLT Project.                              *
   7 //                                                                          *
   8 // Permission to use, copy, modify and distribute this software and its     *
   9 // documentation strictly for non-commercial purposes is hereby granted     *
  10 // without fee, provided that the above copyright notice appears in all     *
  11 // copies and that both the copyright notice and this permission notice     *
  12 // appear in the supporting documentation. The authors make no claims       *
  13 // about the suitability of this software for any purpose. It is            *
  14 // provided "as is" without express or implied warranty.                    *
  15 //                                                                          *
  16 //***************************************************************************
  17
  18
  19 #include "AliHLTITSLayer.h"
  20
  21 //------------------------------------------------------------------------
  22 AliHLTITSLayer::AliHLTITSLayer():
  23 fR(0),
  24 fPhiOffset(0),
  25 fNladders(0),
  26 fZOffset(0),
  27 fNdetectors(0),
  28 fDetectors(0),
  29 fN(0),
  30 fDy5(0),
  31 fDy10(0),
  32 fDy20(0),
  33 fClustersCs(0),
  34 fClusterIndexCs(0),
  35 fYcs(0),
  36 fZcs(0),
  37 fNcs(0),
  38 fCurrentSlice(-1),
  39 fZmax(0),
  40 fYmin(0),
  41 fYmax(0),
  42 fI(0),
  43 fImax(0),
  44 fSkip(0),
  45 fAccepted(0),
  46 fRoad(0){
  47   //--------------------------------------------------------------------
  48   //default AliHLTITSLayer constructor
  49   //--------------------------------------------------------------------
  50   for (Int_t i=0; i<AliITSRecoParam::GetMaxClusterPerLayer(); i++) {
  51     fClusterWeight[i]=0;
  52     fClusterTracks[0][i]=-1;
  53     fClusterTracks[1][i]=-1;
  54     fClusterTracks[2][i]=-1;
  55     fClusterTracks[3][i]=-1;
  56   }
  57 }
  58 //------------------------------------------------------------------------
  59 AliHLTITSLayer::
  60 AliHLTITSLayer(Double_t r,Double_t p,Double_t z,Int_t nl,Int_t nd):
  61 fR(r),
  62 fPhiOffset(p),
  63 fNladders(nl),
  64 fZOffset(z),
  65 fNdetectors(nd),
  66 fDetectors(0),
  67 fN(0),
  68 fDy5(0),
  69 fDy10(0),
  70 fDy20(0),
  71 fClustersCs(0),
  72 fClusterIndexCs(0),
  73 fYcs(0),
  74 fZcs(0),
  75 fNcs(0),
  76 fCurrentSlice(-1),
  77 fZmax(0),
  78 fYmin(0),
  79 fYmax(0),
  80 fI(0),
  81 fImax(0),
  82 fSkip(0),
  83 fAccepted(0),
  84 fRoad(0) {
  85   //--------------------------------------------------------------------
  86   //main AliHLTITSLayer constructor
  87   //--------------------------------------------------------------------
  88   fDetectors=new AliHLTITSDetector[fNladders*fNdetectors];
  89   fRoad=2*fR*TMath::Sqrt(TMath::Pi()/1.);//assuming that there's only one cluster
  90 }
  91 //------------------------------------------------------------------------
  92 AliHLTITSLayer::AliHLTITSLayer(const AliHLTITSLayer& layer):
  93 fR(layer.fR),
  94 fPhiOffset(layer.fPhiOffset),
  95 fNladders(layer.fNladders),
  96 fZOffset(layer.fZOffset),
  97 fNdetectors(layer.fNdetectors),
  98 fDetectors(layer.fDetectors),
  99 fN(layer.fN),
 100 fDy5(layer.fDy5),
 101 fDy10(layer.fDy10),
 102 fDy20(layer.fDy20),
 103 fClustersCs(layer.fClustersCs),
 104 fClusterIndexCs(layer.fClusterIndexCs),
 105 fYcs(layer.fYcs),
 106 fZcs(layer.fZcs),
 107 fNcs(layer.fNcs),
 108 fCurrentSlice(layer.fCurrentSlice),
 109 fZmax(layer.fZmax),
 110 fYmin(layer.fYmin),
 111 fYmax(layer.fYmax),
 112 fI(layer.fI),
 113 fImax(layer.fImax),
 114 fSkip(layer.fSkip),
 115 fAccepted(layer.fAccepted),
 116 fRoad(layer.fRoad){
 117   //Copy constructor
 118 }
 119 //------------------------------------------------------------------------
 120 AliHLTITSLayer::~AliHLTITSLayer() {
 121   //--------------------------------------------------------------------
 122   // AliHLTITSLayer destructor
 123   //--------------------------------------------------------------------
 124   delete [] fDetectors;
 125   for (Int_t i=0; i<fN; i++) delete fClusters[i];
 126   for (Int_t i=0; i<AliITSRecoParam::GetMaxClusterPerLayer(); i++) {
 127     fClusterWeight[i]=0;
 128     fClusterTracks[0][i]=-1;
 129     fClusterTracks[1][i]=-1;
 130     fClusterTracks[2][i]=-1;
 131     fClusterTracks[3][i]=-1;
 132   }
 133 }
 134 //------------------------------------------------------------------------
 135 void AliHLTITSLayer::ResetClusters() {
 136   //--------------------------------------------------------------------
 137   // This function removes loaded clusters
 138   //--------------------------------------------------------------------
 139   for (Int_t i=0; i<fN; i++) delete fClusters[i];
 140   for (Int_t i=0; i<AliITSRecoParam::GetMaxClusterPerLayer(); i++){
 141     fClusterWeight[i]=0;
 142     fClusterTracks[0][i]=-1;
 143     fClusterTracks[1][i]=-1;
 144     fClusterTracks[2][i]=-1;
 145     fClusterTracks[3][i]=-1;
 146   }
 147
 148   fN=0;
 149   fI=0;
 150 }
 151 //------------------------------------------------------------------------
 152 void AliHLTITSLayer::ResetWeights() {
 153   //--------------------------------------------------------------------
 154   // This function reset weights of the clusters
 155   //--------------------------------------------------------------------
 156   for (Int_t i=0; i<AliITSRecoParam::GetMaxClusterPerLayer(); i++) {
 157     fClusterWeight[i]=0;
 158     fClusterTracks[0][i]=-1;
 159     fClusterTracks[1][i]=-1;
 160     fClusterTracks[2][i]=-1;
 161     fClusterTracks[3][i]=-1;
 162   }
 163   for (Int_t i=0; i<fN;i++) {
 164     AliITSRecPoint * cl = (AliITSRecPoint*)GetCluster(i);
 165     if (cl&&cl->IsUsed()) cl->Use();
 166   }
 167
 168 }
 169 //------------------------------------------------------------------------
 170 void AliHLTITSLayer::ResetRoad() {
 171   //--------------------------------------------------------------------
 172   // This function calculates the road defined by the cluster density
 173   //--------------------------------------------------------------------
 174   Int_t n=0;
 175   for (Int_t i=0; i<fN; i++) {
 176      if (TMath::Abs(fClusters[i]->GetZ())<fR) n++;
 177   }
 178   if (n>1) fRoad=2*fR*TMath::Sqrt(TMath::Pi()/n);
 179 }
 180 //------------------------------------------------------------------------
 181 Int_t AliHLTITSLayer::InsertCluster(AliITSRecPoint *cl) {
 182   //--------------------------------------------------------------------
 183   //This function adds a cluster to this layer
 184   //--------------------------------------------------------------------
 185   if (fN==AliITSRecoParam::GetMaxClusterPerLayer()) {
 186     ::Error("InsertCluster","Too many clusters !\n");
 187     return 1;
 188   }
 189   fCurrentSlice=-1;
 190   fClusters[fN]=cl;
 191   fN++;
 192   AliHLTITSDetector &det=GetDetector(cl->GetDetectorIndex());
 193   if (cl->GetY()<det.GetYmin()) det.SetYmin(cl->GetY());
 194   if (cl->GetY()>det.GetYmax()) det.SetYmax(cl->GetY());
 195   if (cl->GetZ()<det.GetZmin()) det.SetZmin(cl->GetZ());
 196   if (cl->GetZ()>det.GetZmax()) det.SetZmax(cl->GetZ());
 197
 198   return 0;
 199 }
 200 //------------------------------------------------------------------------
 201 void  AliHLTITSLayer::SortClusters()
 202 {
 203   //
 204   //sort clusters
 205   //
 206   AliITSRecPoint **clusters = new AliITSRecPoint*[fN];
 207   Float_t *z                = new Float_t[fN];
 208   Int_t   * index           = new Int_t[fN];
 209   //
 210   for (Int_t i=0;i<fN;i++){
 211     z[i] = fClusters[i]->GetZ();
 212   }
 213   TMath::Sort(fN,z,index,kFALSE);
 214   for (Int_t i=0;i<fN;i++){
 215     clusters[i] = fClusters[index[i]];
 216   }
 217   //
 218   for (Int_t i=0;i<fN;i++){
 219     fClusters[i] = clusters[i];
 220     fZ[i]        = fClusters[i]->GetZ();
 221     AliHLTITSDetector &det=GetDetector(fClusters[i]->GetDetectorIndex());
 222     Double_t y=fR*det.GetPhi() + fClusters[i]->GetY();
 223     if (y>2.*fR*TMath::Pi()) y -= 2.*fR*TMath::Pi();
 224     fY[i] = y;
 225   }
 226   delete[] index;
 227   delete[] z;
 228   delete[] clusters;
 229   //
 230
 231   fYB[0]=10000000;
 232   fYB[1]=-10000000;
 233   for (Int_t i=0;i<fN;i++){
 234     if (fY[i]<fYB[0]) fYB[0]=fY[i];
 235     if (fY[i]>fYB[1]) fYB[1]=fY[i];
 236     fClusterIndex[i] = i;
 237   }
 238   //
 239   // fill slices
 240   fDy5 = (fYB[1]-fYB[0])/5.;
 241   fDy10 = (fYB[1]-fYB[0])/10.;
 242   fDy20 = (fYB[1]-fYB[0])/20.;
 243   for (Int_t i=0;i<6;i++)  fN5[i] =0;
 244   for (Int_t i=0;i<11;i++) fN10[i]=0;
 245   for (Int_t i=0;i<21;i++) fN20[i]=0;
 246   //
 247   for (Int_t i=0;i<6;i++) {fBy5[i][0] =  fYB[0]+(i-0.75)*fDy5; fBy5[i][1] =  fYB[0]+(i+0.75)*fDy5;}
 248   for (Int_t i=0;i<11;i++) {fBy10[i][0] =  fYB[0]+(i-0.75)*fDy10; fBy10[i][1] =  fYB[0]+(i+0.75)*fDy10;}
 249   for (Int_t i=0;i<21;i++) {fBy20[i][0] =  fYB[0]+(i-0.75)*fDy20; fBy20[i][1] =  fYB[0]+(i+0.75)*fDy20;}
 250   //
 251   //
 252   for (Int_t i=0;i<fN;i++)
 253     for (Int_t irot=-1;irot<=1;irot++){
 254       Float_t curY = fY[i]+irot*TMath::TwoPi()*fR;
 255       // slice 5
 256       for (Int_t slice=0; slice<6;slice++){
 257         if (fBy5[slice][0]<curY && curY<fBy5[slice][1]&&fN5[slice]<AliITSRecoParam::GetMaxClusterPerLayer5()){
 258           fClusters5[slice][fN5[slice]] = fClusters[i];
 259           fY5[slice][fN5[slice]] = curY;
 260           fZ5[slice][fN5[slice]] = fZ[i];
 261           fClusterIndex5[slice][fN5[slice]]=i;
 262           fN5[slice]++;
 263         }
 264       }
 265       // slice 10
 266       for (Int_t slice=0; slice<11;slice++){
 267         if (fBy10[slice][0]<curY && curY<fBy10[slice][1]&&fN10[slice]<AliITSRecoParam::GetMaxClusterPerLayer10()){
 268           fClusters10[slice][fN10[slice]] = fClusters[i];
 269           fY10[slice][fN10[slice]] = curY;
 270           fZ10[slice][fN10[slice]] = fZ[i];
 271           fClusterIndex10[slice][fN10[slice]]=i;
 272           fN10[slice]++;
 273         }
 274       }
 275       // slice 20
 276       for (Int_t slice=0; slice<21;slice++){
 277         if (fBy20[slice][0]<curY && curY<fBy20[slice][1]&&fN20[slice]<AliITSRecoParam::GetMaxClusterPerLayer20()){
 278           fClusters20[slice][fN20[slice]] = fClusters[i];
 279           fY20[slice][fN20[slice]] = curY;
 280           fZ20[slice][fN20[slice]] = fZ[i];
 281           fClusterIndex20[slice][fN20[slice]]=i;
 282           fN20[slice]++;
 283         }
 284       }
 285     }
 286
 287   //
 288   // consistency check
 289   //
 290   for (Int_t i=0;i<fN-1;i++){
 291     if (fZ[i]>fZ[i+1]){
 292       printf("Bug\n");
 293     }
 294   }
 295   //
 296   for (Int_t slice=0;slice<21;slice++)
 297   for (Int_t i=0;i<fN20[slice]-1;i++){
 298     if (fZ20[slice][i]>fZ20[slice][i+1]){
 299       printf("Bug\n");
 300     }
 301   }
 302
 303
 304 }
 305 //------------------------------------------------------------------------
 306 Int_t AliHLTITSLayer::FindClusterIndex(Float_t z) const {
 307   //--------------------------------------------------------------------
 308   // This function returns the index of the nearest cluster
 309   //--------------------------------------------------------------------
 310   Int_t ncl=0;
 311   const Float_t *zcl;
 312   if (fCurrentSlice<0) {
 313     ncl = fN;
 314     zcl   = fZ;
 315   }
 316   else{
 317     ncl   = fNcs;
 318     zcl   = fZcs;;
 319   }
 320
 321   if (ncl==0) return 0;
 322   Int_t b=0, e=ncl-1, m=(b+e)/2;
 323   for (; b<e; m=(b+e)/2) {
 324     //    if (z > fClusters[m]->GetZ()) b=m+1;
 325     if (z > zcl[m]) b=m+1;
 326     else e=m;
 327   }
 328   return m;
 329 }
 330
 331 //------------------------------------------------------------------------
 332 void AliHLTITSLayer::
 333 SelectClusters(Double_t zmin,Double_t zmax,Double_t ymin, Double_t ymax) {
 334   //--------------------------------------------------------------------
 335   // This function sets the "window"
 336   //--------------------------------------------------------------------
 337
 338   Double_t circle=2*TMath::Pi()*fR;
 339   fYmin = ymin; fYmax =ymax;
 340   Float_t ymiddle = (fYmin+fYmax)*0.5;
 341   if (ymiddle<fYB[0]) {
 342     fYmin+=circle; fYmax+=circle; ymiddle+=circle;
 343   } else if (ymiddle>fYB[1]) {
 344     fYmin-=circle; fYmax-=circle; ymiddle-=circle;
 345   }
 346
 347   //
 348   fCurrentSlice =-1;
 349   // defualt take all
 350   fClustersCs = fClusters;
 351   fClusterIndexCs = fClusterIndex;
 352   fYcs  = fY;
 353   fZcs  = fZ;
 354   fNcs  = fN;
 355   //
 356   //is in 20 slice?
 357   if (fCurrentSlice<0&&TMath::Abs(fYmax-fYmin)<1.49*fDy20){
 358     Int_t slice = int(0.5+(ymiddle-fYB[0])/fDy20);
 359     if (slice<0) slice=0;
 360     if (slice>20) slice=20;
 361     Bool_t isOK = (fYmin>fBy20[slice][0]&&fYmax<fBy20[slice][1]);
 362     if (isOK) {
 363       fCurrentSlice=slice;
 364       fClustersCs = fClusters20[fCurrentSlice];
 365       fClusterIndexCs = fClusterIndex20[fCurrentSlice];
 366       fYcs  = fY20[fCurrentSlice];
 367       fZcs  = fZ20[fCurrentSlice];
 368       fNcs  = fN20[fCurrentSlice];
 369     }
 370   }
 371   //
 372   //is in 10 slice?
 373   if (fCurrentSlice<0&&TMath::Abs(fYmax-fYmin)<1.49*fDy10){
 374     Int_t slice = int(0.5+(ymiddle-fYB[0])/fDy10);
 375     if (slice<0) slice=0;
 376     if (slice>10) slice=10;
 377     Bool_t isOK = (fYmin>fBy10[slice][0]&&fYmax<fBy10[slice][1]);
 378     if (isOK) {
 379       fCurrentSlice=slice;
 380       fClustersCs = fClusters10[fCurrentSlice];
 381       fClusterIndexCs = fClusterIndex10[fCurrentSlice];
 382       fYcs  = fY10[fCurrentSlice];
 383       fZcs  = fZ10[fCurrentSlice];
 384       fNcs  = fN10[fCurrentSlice];
 385     }
 386   }
 387   //
 388   //is in 5 slice?
 389   if (fCurrentSlice<0&&TMath::Abs(fYmax-fYmin)<1.49*fDy5){
 390     Int_t slice = int(0.5+(ymiddle-fYB[0])/fDy5);
 391     if (slice<0) slice=0;
 392     if (slice>5) slice=5;
 393     Bool_t isOK = (fYmin>fBy5[slice][0]&&fYmax<fBy5[slice][1]);
 394     if (isOK) {
 395       fCurrentSlice=slice;
 396       fClustersCs = fClusters5[fCurrentSlice];
 397       fClusterIndexCs = fClusterIndex5[fCurrentSlice];
 398       fYcs  = fY5[fCurrentSlice];
 399       fZcs  = fZ5[fCurrentSlice];
 400       fNcs  = fN5[fCurrentSlice];
 401     }
 402   }
 403   //
 404   fI=FindClusterIndex(zmin); fZmax=zmax;
 405   fImax = TMath::Min(FindClusterIndex(zmax)+1,fNcs);
 406   fSkip = 0;
 407   fAccepted =0;
 408
 409   return;
 410 }
 411 //------------------------------------------------------------------------
 412 Int_t AliHLTITSLayer::
 413 FindDetectorIndex(Double_t phi, Double_t z) const {
 414   //--------------------------------------------------------------------
 415   //This function finds the detector crossed by the track
 416   //--------------------------------------------------------------------
 417   Double_t dphi;
 418   if (fZOffset<0)            // old geometry
 419     dphi = -(phi-fPhiOffset);
 420   else                       // new geometry
 421     dphi = phi-fPhiOffset;
 422
 423
 424   if      (dphi <  0) dphi += 2*TMath::Pi();
 425   else if (dphi >= 2*TMath::Pi()) dphi -= 2*TMath::Pi();
 426   Int_t np=Int_t(dphi*fNladders*0.5/TMath::Pi()+0.5);
 427   if (np>=fNladders) np-=fNladders;
 428   if (np<0)          np+=fNladders;
 429
 430
 431   Double_t dz=fZOffset-z;
 432   Double_t nnz = dz*(fNdetectors-1)*0.5/fZOffset+0.5;
 433   Int_t nz = (nnz<0 ? -1 : (Int_t)nnz);
 434   if (nz>=fNdetectors) return -1;
 435   if (nz<0)            return -1;
 436
 437   // ad hoc correction for 3rd ladder of SDD inner layer,
 438   // which is reversed (rotated by pi around local y)
 439   // this correction is OK only from AliITSv11Hybrid onwards
 440   if (GetR()>12. && GetR()<20.) { // SDD inner
 441     if(np==2) { // 3rd ladder
 442       nz = (fNdetectors-1) - nz;
 443     }
 444   }
 445   //printf("ndet %d phi %f z %f  np %d nz %d\n",fNdetectors,phi,z,np,nz);
 446
 447
 448   return np*fNdetectors + nz;
 449 }
 450 //------------------------------------------------------------------------
 451 const AliITSRecPoint *AliHLTITSLayer::GetNextCluster(Int_t &ci,Bool_t test)
 452 {
 453   //--------------------------------------------------------------------
 454   // This function returns clusters within the "window"
 455   //--------------------------------------------------------------------
 456
 457   if (fCurrentSlice<0) {
 458     Double_t rpi2 = 2.*fR*TMath::Pi();
 459     for (Int_t i=fI; i<fImax; i++) {
 460       Double_t y = fY[i];
 461       if (fYmax<y) y -= rpi2;
 462       if (fYmin>y) y += rpi2;
 463       if (y<fYmin) continue;
 464       if (y>fYmax) continue;
 465       if (fClusters[i]->GetQ()==0&&fSkip==2) continue;
 466       ci=i;
 467       if (!test) fI=i+1;
 468       return fClusters[i];
 469     }
 470   } else {
 471     for (Int_t i=fI; i<fImax; i++) {
 472       if (fYcs[i]<fYmin) continue;
 473       if (fYcs[i]>fYmax) continue;
 474       if (fClustersCs[i]->GetQ()==0&&fSkip==2) continue;
 475       ci=fClusterIndexCs[i];
 476       if (!test) fI=i+1;
 477       return fClustersCs[i];
 478     }
 479   }
 480   return 0;
 481 }
 482 //------------------------------------------------------------------------
 483 Double_t AliHLTITSLayer::GetThickness(Double_t y,Double_t z,Double_t &x0)
 484 const {
 485   //--------------------------------------------------------------------
 486   // This function returns the layer thickness at this point (units X0)
 487   //--------------------------------------------------------------------
 488   Double_t d=0.0085;
 489   x0=AliITSRecoParam::GetX0Air();
 490   if (43<fR&&fR<45) { //SSD2
 491      Double_t dd=0.0034;
 492      d=dd;
 493      if (TMath::Abs(y-0.00)>3.40) d+=dd;
 494      if (TMath::Abs(y-1.90)<0.45) {d+=(0.013-0.0034);}
 495      if (TMath::Abs(y+1.90)<0.45) {d+=(0.013-0.0034);}
 496      for (Int_t i=0; i<12; i++) {
 497        if (TMath::Abs(z-3.9*(i+0.5))<0.15) {
 498           if (TMath::Abs(y-0.00)>3.40) d+=dd;
 499           d+=0.0034;
 500           break;
 501        }
 502        if (TMath::Abs(z+3.9*(i+0.5))<0.15) {
 503           if (TMath::Abs(y-0.00)>3.40) d+=dd;
 504           d+=0.0034;
 505           break;
 506        }
 507        if (TMath::Abs(z-3.4-3.9*i)<0.50) {d+=(0.016-0.0034); break;}
 508        if (TMath::Abs(z+0.5+3.9*i)<0.50) {d+=(0.016-0.0034); break;}
 509      }
 510   } else
 511   if (37<fR&&fR<41) { //SSD1
 512      Double_t dd=0.0034;
 513      d=dd;
 514      if (TMath::Abs(y-0.00)>3.40) d+=dd;
 515      if (TMath::Abs(y-1.90)<0.45) {d+=(0.013-0.0034);}
 516      if (TMath::Abs(y+1.90)<0.45) {d+=(0.013-0.0034);}
 517      for (Int_t i=0; i<11; i++) {
 518        if (TMath::Abs(z-3.9*i)<0.15) {
 519           if (TMath::Abs(y-0.00)>3.40) d+=dd;
 520           d+=dd;
 521           break;
 522        }
 523        if (TMath::Abs(z+3.9*i)<0.15) {
 524           if (TMath::Abs(y-0.00)>3.40) d+=dd;
 525           d+=dd;
 526           break;
 527        }
 528        if (TMath::Abs(z-1.85-3.9*i)<0.50) {d+=(0.016-0.0034); break;}
 529        if (TMath::Abs(z+2.05+3.9*i)<0.50) {d+=(0.016-0.0034); break;}
 530      }
 531   } else
 532   if (13<fR&&fR<26) { //SDD
 533      Double_t dd=0.0033;
 534      d=dd;
 535      if (TMath::Abs(y-0.00)>3.30) d+=dd;
 536
 537      if (TMath::Abs(y-1.80)<0.55) {
 538         d+=0.016;
 539         for (Int_t j=0; j<20; j++) {
 540           if (TMath::Abs(z+0.7+1.47*j)<0.12) {d+=0.08; x0=9.; break;}
 541           if (TMath::Abs(z-0.7-1.47*j)<0.12) {d+=0.08; x0=9.; break;}
 542         }
 543      }
 544      if (TMath::Abs(y+1.80)<0.55) {
 545         d+=0.016;
 546         for (Int_t j=0; j<20; j++) {
 547           if (TMath::Abs(z-0.7-1.47*j)<0.12) {d+=0.08; x0=9.; break;}
 548           if (TMath::Abs(z+0.7+1.47*j)<0.12) {d+=0.08; x0=9.; break;}
 549         }
 550      }
 551
 552      for (Int_t i=0; i<4; i++) {
 553        if (TMath::Abs(z-7.3*i)<0.60) {
 554           d+=dd;
 555           if (TMath::Abs(y-0.00)>3.30) d+=dd;
 556           break;
 557        }
 558        if (TMath::Abs(z+7.3*i)<0.60) {
 559           d+=dd;
 560           if (TMath::Abs(y-0.00)>3.30) d+=dd;
 561           break;
 562        }
 563      }
 564   } else
 565   if (6<fR&&fR<8) {   //SPD2
 566      Double_t dd=0.0063; x0=21.5;
 567      d=dd;
 568      if (TMath::Abs(y-3.08)>0.5) d+=dd;
 569      if (TMath::Abs(y-3.03)<0.10) d+=0.014;
 570   } else
 571   if (3<fR&&fR<5) {   //SPD1
 572      Double_t dd=0.0063; x0=21.5;
 573      d=dd;
 574      if (TMath::Abs(y+0.21)>0.6) d+=dd;
 575      if (TMath::Abs(y+0.10)<0.10) d+=0.014;
 576   }
 577
 578   return d;
 579 }
 580
 581 //------------------------------------------------------------------------
 582 Int_t AliHLTITSLayer::InRoad() const {
 583   //-------------------------------------------------------------------
 584   // This function returns number of clusters within the "window"
 585   //--------------------------------------------------------------------
 586   Int_t ncl=0;
 587   for (Int_t i=fI; i<fN; i++) {
 588     const AliITSRecPoint *c=fClusters[i];
 589     if (c->GetZ() > fZmax) break;
 590     if (c->IsUsed()) continue;
 591     const AliHLTITSDetector &det=GetDetector(c->GetDetectorIndex());
 592     Double_t y=fR*det.GetPhi() + c->GetY();
 593
 594     if (y>2.*fR*TMath::Pi()) y -= 2*fR*TMath::Pi();
 595     if (y>1.*fR*TMath::Pi() && fYmax<y) y -= 2*fR*TMath::Pi();
 596
 597     if (y<fYmin) continue;
 598     if (y>fYmax) continue;
 599     ncl++;
 600   }
 601   return ncl;
 602 }
 603