HLT/hough/AliHLTHoughTransformerGlobal.cxx

   1 // @(#) $Id$
   2
   3 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
   4 //*-- Copyright &copy ALICE HLT Group
   5
   6 #include "AliHLTStandardIncludes.h"
   7
   8 #include "AliHLTLogging.h"
   9 #include "AliHLTHoughTransformerGlobal.h"
  10 #include "AliHLTFileHandler.h"
  11 #include "AliHLTTransform.h"
  12 #include "AliHLTDigitData.h"
  13 #include "AliHLTTrack.h"
  14 #include "AliHLTHistogram.h"
  15 #include "AliHLTTrackArray.h"
  16 #include "AliHLTHoughMaxFinder.h"
  17 #include "AliHLTHoughTrack.h"
  18 #include "AliHLTSpacePointData.h"
  19
  20 #include <TH2.h>
  21
  22 #if __GNUC__ >= 3
  23 using namespace std;
  24 #endif
  25
  26 //_____________________________________________________________
  27 // AliHLTHoughTransformerGlobal
  28 //
  29 // Hough transformation class
  30 //
  31
  32 ClassImp(AliHLTHoughTransformerGlobal)
  33
  34 AliHLTHoughTransformerGlobal::AliHLTHoughTransformerGlobal()
  35 {
  36   //default ctor
  37   fPadMin=0;
  38   fPadMax=0;
  39   fNActiveSlice=0;
  40   fMemHandler=0;
  41   fEvent=0;
  42   fPsi=0;
  43   fPtMin=0;
  44   fTracks=0;
  45   fPeakFinder=0;
  46   fSeedPadRow=-1;
  47 }
  48
  49 AliHLTHoughTransformerGlobal::AliHLTHoughTransformerGlobal(Char_t *path,Int_t event)
  50 {
  51   //normal ctor
  52   strcpy(fPath,path);
  53   fEvent=event;
  54   fMemHandler=0;
  55   fPadMin=0;
  56   fPadMax=0;
  57   fPsi=0;
  58   fPtMin=0;
  59   fNActiveSlice=0;
  60   fTracks = new AliHLTTrackArray("AliHLTHoughTrack");
  61   fPeakFinder = new AliHLTHoughMaxFinder("KappaPhi",1000);
  62 }
  63
  64 AliHLTHoughTransformerGlobal::~AliHLTHoughTransformerGlobal()
  65 {
  66   //dtor
  67   if(fPadMin)
  68     delete [] fPadMin;
  69   if(fPadMax)
  70     delete [] fPadMax;
  71   if(fTracks)
  72     delete fTracks;
  73   if(fPeakFinder)
  74     delete fPeakFinder;
  75   UnloadActiveSlices();
  76
  77 }
  78
  79 void AliHLTHoughTransformerGlobal::CreateHistograms(Float_t /*ptmin*/,Int_t nxbin,Int_t nybin)
  80 {
  81   //create histograms for HT
  82   if(fPsi==0)
  83     {
  84       cerr<<"AliHLTHoughTransformerGlobal::CreateHistograms : Call DefineRegion first"<<endl;
  85       exit(5);
  86     }
  87   AliHLTHoughTransformer::CreateHistograms(nxbin,fPtMin,nybin,-fPsi,fPsi);
  88   //AliHLTHoughTransformer::CreateHistograms(fPtMin,ptmax,ptres,nybin,fPsi);
  89 }
  90
  91 void AliHLTHoughTransformerGlobal::TransformCircleC()
  92 {
  93   //Hough Transform
  94   AliHLTSeed *clusters = new AliHLTSeed[1000];
  95   Int_t nclusters = LoadClusterSeeds(clusters);
  96
  97   Int_t i=0,sector,row,slice;
  98   UInt_t dummy=0;
  99   Float_t xyz[3],rpe[3],kappa,psi;
 100
 101   for(Int_t sl=GetSlice()-fNActiveSlice; sl<=GetSlice()+fNActiveSlice; sl++)
 102     {
 103       if(sl < 0 || sl < 18 && GetSlice() >= 18)
 104         slice = sl + 18;
 105       else if(sl > 35 || sl > 17 && GetSlice() <= 17)
 106         slice = sl-18;
 107       else
 108         slice = sl;
 109       cout<<"Transforming in slice "<<slice<<endl;
 110
 111       AliHLTDigitRowData *rowPt = (AliHLTDigitRowData*)fMemHandler[i++]->GetDataPointer(dummy);
 112
 113       for(Int_t padrow=0; padrow<AliHLTTransform::GetNRows(); padrow++)
 114         {
 115           if(padrow == fSeedPadRow) continue;
 116           AliHLTDigitData *digits = (AliHLTDigitData*)rowPt->fDigitData;
 117
 118           for(UInt_t j=0; j<rowPt->fNDigit; j++)
 119             {
 120               Int_t pad = digits[j].fPad;
 121
 122               if(i==1 && pad < fPadMin[padrow])
 123                 continue;
 124               if(i==fNActiveSlice*2+1 && pad>fPadMax[padrow])
 125                 continue;
 126
 127               Int_t time = digits[j].fTime;
 128               Int_t charge = digits[j].fCharge;
 129
 130               if(charge > GetUpperThreshold() || charge < GetLowerThreshold())
 131                 continue;
 132
 133               AliHLTTransform::Slice2Sector(slice,padrow,sector,row);
 134               AliHLTTransform::Raw2Local(xyz,sector,row,pad,time);
 135
 136               Rotate(xyz,i-1-fNActiveSlice);
 137
 138               AliHLTTransform::XYZtoRPhiEta(rpe,xyz);
 139               rpe[0] = sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]);
 140
 141               Int_t etaindex = GetEtaIndex(rpe[2]);
 142
 143               AliHLTHistogram *hist = GetHistogram(etaindex);
 144
 145               for(Int_t l=0; l<nclusters; l++)
 146                 {
 147                   if(clusters[l].fIndex != etaindex) continue;
 148                   psi = atan( (clusters[l].fRadius*sin(rpe[1])-rpe[0]*sin(clusters[l].fPhi))/
 149                               (clusters[l].fRadius*cos(rpe[1])-rpe[0]*cos(clusters[l].fPhi)) );
 150                   kappa = 2*sin(clusters[l].fPhi-psi)/clusters[l].fRadius;
 151                   if(fabs(kappa) < 1e-33)
 152                     continue;
 153                   //hist->Fill(kappa,psi,(int)rint(log((Float_t)charge)));
 154                   hist->Fill(kappa,psi,charge);
 155                 }
 156             }
 157           AliHLTMemHandler::UpdateRowPointer(rowPt);
 158         }
 159     }
 160   delete [] clusters;
 161 }
 162
 163 void AliHLTHoughTransformerGlobal::TransformCircle()
 164 {
 165   //Hough Transform
 166   Int_t i=0,sector,row,slice;
 167   UInt_t dummy=0;
 168   Float_t xyz[3],rpe[3],kappa,psi;
 169
 170   for(Int_t sl=GetSlice()-fNActiveSlice; sl<=GetSlice()+fNActiveSlice; sl++)
 171     {
 172       if(sl < 0 || sl < 18 && GetSlice() >= 18)
 173         slice = sl + 18;
 174       else if(sl > 35 || sl > 17 && GetSlice() <= 17)
 175         slice = sl-18;
 176       else
 177         slice = sl;
 178       cout<<"Transforming in slice "<<slice<<endl;
 179
 180       AliHLTDigitRowData *rowPt = (AliHLTDigitRowData*)fMemHandler[i++]->GetDataPointer(dummy);
 181
 182       for(Int_t padrow=0; padrow<AliHLTTransform::GetNRows(); padrow++)
 183         {
 184
 185           AliHLTDigitData *digits = (AliHLTDigitData*)rowPt->fDigitData;
 186
 187           for(UInt_t j=0; j<rowPt->fNDigit; j++)
 188             {
 189               Int_t pad = digits[j].fPad;
 190
 191               if(i==1 && pad < fPadMin[padrow])
 192                 continue;
 193               if(i==fNActiveSlice*2+1 && pad>fPadMax[padrow])
 194                 continue;
 195
 196               Int_t time = digits[j].fTime;
 197               Int_t charge = digits[j].fCharge;
 198
 199               if(charge > GetUpperThreshold() || charge < GetLowerThreshold())
 200                 continue;
 201
 202               AliHLTTransform::Slice2Sector(slice,padrow,sector,row);
 203               AliHLTTransform::Raw2Local(xyz,sector,row,pad,time);
 204
 205               Rotate(xyz,i-1-fNActiveSlice);
 206
 207               AliHLTTransform::XYZtoRPhiEta(rpe,xyz);
 208               rpe[0] = sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]);
 209
 210               Int_t etaindex = GetEtaIndex(rpe[2]);
 211
 212               AliHLTHistogram *hist = GetHistogram(etaindex);
 213
 214               for(Int_t b=hist->GetFirstYbin(); b<=hist->GetLastYbin(); b++)
 215                 {
 216                   psi = hist->GetBinCenterY(b);
 217                   kappa = 2*sin(rpe[1] - psi)/rpe[0];
 218
 219                   if(fabs(kappa) < 1e-33)
 220                     continue;
 221
 222                   hist->Fill(kappa,psi,charge);
 223                   //hist->Fill(kappa,psi,(int)rint(log((Float_t)charge)));
 224                 }
 225             }
 226           AliHLTMemHandler::UpdateRowPointer(rowPt);
 227         }
 228     }
 229 }
 230
 231 void AliHLTHoughTransformerGlobal::VerifyTracks(AliHLTTrackArray *tracks,Int_t &index)
 232 {
 233   //remove tracks which do not cross the seed padrow
 234   for(int i=index; i<tracks->GetNTracks(); i++)
 235     {
 236       AliHLTHoughTrack *tr = (AliHLTHoughTrack*)tracks->GetCheckedTrack(i);
 237       if(!tr) continue;
 238
 239       Float_t angle=0;
 240       AliHLTTransform::Local2GlobalAngle(&angle,GetSlice());
 241       if(!tr->CalculateReferencePoint(angle,AliHLTTransform::Row2X(fSeedPadRow)))
 242         {
 243           tracks->Remove(i);
 244           continue;
 245         }
 246       Int_t sector,row;
 247       AliHLTTransform::Slice2Sector(GetSlice(),fSeedPadRow,sector,row);
 248       float xyz[3] = {tr->GetPointX(),tr->GetPointY(),tr->GetPointZ()};
 249       AliHLTTransform::Global2Raw(xyz,sector,row);
 250       if(xyz[1]<0 || xyz[1]>=AliHLTTransform::GetNPads(fSeedPadRow) ||
 251          xyz[2]<0 || xyz[2]>=AliHLTTransform::GetNTimeBins())
 252         tracks->Remove(i);
 253     }
 254   tracks->Compress();
 255   index = tracks->GetNTracks();
 256 }
 257
 258 void AliHLTHoughTransformerGlobal::FindPeaks(AliHLTHistogram *hist,Float_t eta)
 259 {
 260   //Peak Finder
 261   fPeakFinder->Reset();
 262   fPeakFinder->SetHistogram(hist);
 263   fPeakFinder->FindAbsMaxima();
 264   if(fPeakFinder->GetWeight(0) < 1000)
 265     return;
 266
 267   AliHLTHoughTrack *track = (AliHLTHoughTrack*)fTracks->NextTrack();
 268   track->SetTrackParameters(fPeakFinder->GetXPeak(0),fPeakFinder->GetYPeak(0),fPeakFinder->GetWeight(0));
 269   track->SetEta(eta);
 270   track->SetRowRange(AliHLTTransform::GetFirstRow(0),AliHLTTransform::GetLastRow(5));
 271 }
 272
 273 void AliHLTHoughTransformerGlobal::Rotate(Float_t *xyz,Int_t relslice)
 274 {
 275   //Rotate coordinates from one slice to the slice relative to it;
 276   //-1 means lower
 277   //1 means upper
 278
 279   Float_t angle = (Float_t)relslice*AliHLTTransform::Deg2Rad(20);
 280   Float_t x=xyz[0],y=xyz[1];
 281   xyz[0] = x*cos(angle) - y*sin(angle);
 282   xyz[1] = x*sin(angle) + y*cos(angle);
 283 }
 284
 285
 286 void AliHLTHoughTransformerGlobal::DefineRegion(Float_t minpt,Float_t /*linephi*/,Int_t seedpadrow)
 287 {
 288   //Setup the region to be included in the transform
 289   //This function should be called only once, since it is the same for all slices.
 290
 291   fSeedPadRow=seedpadrow;
 292   fPtMin = minpt;
 293
 294   fPadMin = new Int_t[AliHLTTransform::GetNRows()];
 295   fPadMax = new Int_t[AliHLTTransform::GetNRows()];
 296
 297   //Phirange of data which should be included in the transform
 298   //Here we assume a min pt to define it; fPtMin
 299   //Based on pt (kappa) and the two points; origo and middle point, we can get psi angle
 300
 301   //Calculate the upper point, the lower point is symmetrical around the x-axis
 302   //The track in this calculation has a positive charge, and the kappa sign is the opposite:
 303
 304   Float_t xyz[3],phi,phi2;
 305
 306   phi = CalculateBorder(xyz,-1); //upward bending track
 307   phi2 = CalculateBorder(xyz,1); //downward bending track
 308   if(phi2 > phi)
 309     phi = phi2;
 310
 311   cout<<"Phiangle "<<phi*180/AliHLTTransform::Pi()<<" psi "<<fPsi*180/AliHLTTransform::Pi()<<" nslices "<<fNActiveSlice<<endl;
 312
 313   Float_t rotangle = fNActiveSlice*20;
 314
 315   //Calculate the LUT for min/max pad for every padrow, and check which slices we need.
 316   Int_t pad,sector,row;
 317   for(Int_t i=0; i<AliHLTTransform::GetNRows(); i++)
 318     {
 319       AliHLTTransform::Slice2Sector(0,i,sector,row);
 320
 321       //Lower boundary:
 322       pad = AliHLTTransform::GetNPads(i)-1;
 323       while(pad >= 0)
 324         {
 325           AliHLTTransform::Raw2Local(xyz,sector,row,pad,0);
 326           if(AliHLTTransform::GetPhi(xyz) > -1.*phi + AliHLTTransform::Deg2Rad(rotangle))
 327             fPadMin[i] = pad;
 328           else
 329             break;
 330           pad--;
 331         }
 332
 333       //Upper boundary
 334       pad = 0;
 335       while(pad < AliHLTTransform::GetNPads(i))
 336         {
 337           AliHLTTransform::Raw2Local(xyz,sector,row,pad,0);
 338           if(AliHLTTransform::GetPhi(xyz) < phi - AliHLTTransform::Deg2Rad(rotangle))
 339             fPadMax[i] = pad;
 340           else
 341             break;
 342           pad++;
 343         }
 344     }
 345
 346   cout<<"Padmax "<<fPadMax[155]<<endl;
 347
 348 }
 349
 350 Float_t AliHLTHoughTransformerGlobal::CalculateBorder(Float_t *xyz,Int_t charge)
 351 {
 352   //Define Hough space borders
 353   Double_t lineradius = sqrt(pow(AliHLTTransform::Row2X(fSeedPadRow),2) + pow(AliHLTTransform::GetMaxY(fSeedPadRow),2));
 354
 355   Double_t kappa = -charge*AliHLTTransform::GetBField()*AliHLTTransform::GetBFact()/fPtMin;
 356
 357   //Calculate the psi angle of the track = emission angle with x-axis in origo
 358   if( fabs(lineradius*kappa/2) > 1)
 359     {
 360       cerr<<"AliHLTTransformerGlobal::DefineRegion : Angle too big"<<endl;
 361       exit(5);
 362     }
 363
 364   Int_t nslices=0;
 365   Float_t psi = AliHLTTransform::Deg2Rad(10) - asin(lineradius*kappa/2);
 366   if(charge > 0)
 367     fPsi=psi;
 368
 369   cout<<"Calculated psi-angle "<<fPsi<<endl;
 370
 371   AliHLTTrack track;
 372   track.SetFirstPoint(0,0,0);
 373   track.SetPt(fPtMin);
 374   track.SetPsi(psi);
 375   track.SetCharge(charge);
 376   track.CalculateHelix();
 377
 378   Int_t crossingrow=0;
 379   if(charge < 0)
 380     crossingrow = AliHLTTransform::GetNRows()-1;
 381
 382   Float_t rotangle;
 383
 384  redefine:
 385
 386   rotangle = nslices*20;
 387
 388   if(nslices==0)//here we are in local slice, so we use the appropriate function. a mess of course...
 389     {
 390       while(!track.GetCrossingPoint(crossingrow,xyz))
 391         {
 392           if(crossingrow==0)
 393             {
 394               cerr<<"AliHLTHoughTransformerGlobal::DefineRegion : Error calculating point1 on row "<<crossingrow<<endl;
 395               exit(5);
 396             }
 397           crossingrow--;
 398         }
 399     }
 400   else
 401     {
 402       while(!track.CalculateReferencePoint(AliHLTTransform::Deg2Rad(rotangle),AliHLTTransform::Row2X(crossingrow)))
 403         {
 404           if(crossingrow==0)
 405             {
 406               cerr<<"AliHLTHoughTransformerGlobal::DefineRegion : Error calculating point2 on row "<<crossingrow<<endl;
 407               exit(5);
 408             }
 409           crossingrow--;
 410         }
 411
 412       xyz[0] = track.GetPointX();
 413       xyz[1] = track.GetPointY();
 414       xyz[2] = track.GetPointZ();
 415     }
 416
 417   Float_t phi = atan2(xyz[1],xyz[0]);
 418
 419   //Rotate coordinates back to local coordinates:
 420   Rotate(xyz,-1*nslices);
 421
 422   Int_t sector,row;
 423   AliHLTTransform::Slice2Sector(0,crossingrow,sector,row);
 424   AliHLTTransform::Local2Raw(xyz,sector,row);
 425   if(xyz[1] < 0)
 426     {
 427       if(crossingrow>0)
 428         {
 429           cerr<<"AliHLTHoughTransformerGlobal::DefineRegion : Wrong pad, probably a deadzone... "<<xyz[1]<<endl;
 430           exit(5);
 431         }
 432       else
 433         return 0;//here you only want the crossing point with the outer padrow
 434     }
 435   if(xyz[1] >= AliHLTTransform::GetNPads(crossingrow)) //Here the range is even one more slice away
 436     {
 437       cerr<<"One more slice with pad "<<xyz[1]<<endl;
 438       nslices++;
 439       if(charge < 0)
 440         crossingrow = AliHLTTransform::GetNRows()-1;
 441       goto redefine;
 442     }
 443
 444   if(nslices > fNActiveSlice)
 445     fNActiveSlice = nslices;
 446
 447   cout<<"Calculated phi "<<phi<<" and pad "<<xyz[1]<<" on row "<<crossingrow<<endl;
 448   return phi;
 449 }
 450
 451 void AliHLTHoughTransformerGlobal::LoadActiveSlices(Bool_t binary)
 452 {
 453   //Load active slices
 454   if(fMemHandler)
 455     UnloadActiveSlices();
 456   fMemHandler = new AliHLTMemHandler*[(fNActiveSlice*2 + 1)];
 457   Char_t filename[1024];
 458   UInt_t dummy;
 459   Int_t i=0,slice;
 460   for(Int_t sl=GetSlice()-fNActiveSlice; sl<=GetSlice()+fNActiveSlice; sl++)
 461     {
 462       if(sl < 0 || sl < 18 && GetSlice() >= 18)
 463         slice = sl + 18;
 464       else if(sl > 35 || sl > 17 && GetSlice() <= 17)
 465         slice = sl-18;
 466       else
 467         slice = sl;
 468       cout<<"Loading slice "<<slice<<endl;
 469       fMemHandler[i] = new AliHLTFileHandler();
 470       fMemHandler[i]->Init(slice,-1);
 471       if(binary)
 472         {
 473           sprintf(filename,"%s/binaries/digits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
 474           fMemHandler[i]->SetBinaryInput(filename);
 475           fMemHandler[i]->CompBinary2Memory(dummy);
 476           fMemHandler[i++]->CloseBinaryInput();
 477         }
 478       else
 479         {
 480           sprintf(filename,"%s/digitfile.root",fPath);
 481           fMemHandler[i]->SetAliInput(filename);
 482           fMemHandler[i]->AliAltroDigits2Memory(dummy,fEvent);
 483           fMemHandler[i++]->CloseAliInput();
 484         }
 485     }
 486
 487 }
 488
 489 void AliHLTHoughTransformerGlobal::UnloadActiveSlices()
 490 {
 491   //Unload active slices
 492   if(!fMemHandler)
 493     return;
 494   for(Int_t i=0; i<=fNActiveSlice*2; i++)
 495     {
 496       if(!fMemHandler[i]) continue;
 497       delete fMemHandler[i];
 498     }
 499   delete [] fMemHandler;
 500   fMemHandler=0;
 501 }
 502
 503 Int_t AliHLTHoughTransformerGlobal::LoadClusterSeeds(AliHLTSeed *seeds)
 504 {
 505   //Load cluster seeds
 506   Char_t filename[1024];
 507   UInt_t npoints;
 508   sprintf(filename,"%s/hough/points_%d_%d_%d.raw",fPath,fEvent,GetSlice(),-1);
 509   //sprintf(filename,"../tracker/points_%d_%d_%d.raw",fEvent,GetSlice(),-1);
 510   AliHLTMemHandler mem;
 511   if(!mem.SetBinaryInput(filename))
 512     {
 513       cerr<<"AliHLTHoughTransformerGlobal::LoadClusterSeeds : Cannot open file "<<filename<<endl;
 514       exit(5);
 515     }
 516   AliHLTSpacePointData *points = (AliHLTSpacePointData*)mem.Allocate();
 517   mem.Binary2Memory(npoints,points);
 518   mem.CloseBinaryInput();
 519
 520   Int_t counter=0;
 521   for(UInt_t i=0; i<npoints; i++)
 522     {
 523       Int_t lrow = (Int_t)points[i].fPadRow;
 524       if(lrow < fSeedPadRow) continue;
 525       if(lrow > fSeedPadRow) break;
 526       if(fabs(points[i].fY) > AliHLTTransform::GetMaxY(lrow))
 527         {
 528           cerr<<"AliHLTHoughTransformerGlobal::LoadClusterSeeds : Seeds seems not to be in local coordinates: "
 529               <<points[i].fY<<endl;
 530           exit(5);
 531         }
 532       Float_t xyz[3] = {AliHLTTransform::Row2X(lrow),points[i].fY,points[i].fZ};
 533       Double_t eta = AliHLTTransform::GetEta(xyz);
 534       seeds[counter].fPhi = atan2(xyz[1],xyz[0]);
 535       seeds[counter].fRadius = sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]);
 536       seeds[counter].fIndex = GetEtaIndex(eta);
 537       seeds[counter++].fEta = eta;
 538     }
 539   cout<<"Loaded "<<counter<<" cluster seeds on slice "<<GetSlice()<<" padrow "<<fSeedPadRow<<endl;
 540   mem.Free();
 541   return counter;
 542 }
 543
 544 void AliHLTHoughTransformerGlobal::DisplayActiveRegion(TH2F *hist,Int_t etaindex)
 545 {
 546   //Fill the active region in a histogram
 547
 548   Int_t i=0,sector,row,slice;
 549   UInt_t dummy=0;
 550   Float_t xyz[3];
 551   for(Int_t sl=GetSlice()-fNActiveSlice; sl<=GetSlice()+fNActiveSlice; sl++)
 552     {
 553       if(sl < 0 || sl < 18 && GetSlice() >= 18)
 554         slice = sl + 18;
 555       else if(sl > 35 || sl > 17 && GetSlice() <= 17)
 556         slice = sl-18;
 557       else
 558         slice = sl;
 559       cout<<"Displaying slice "<<slice<<endl;
 560       AliHLTDigitRowData *rowPt = (AliHLTDigitRowData*)fMemHandler[i++]->GetDataPointer(dummy);
 561       for(Int_t padrow=0; padrow<AliHLTTransform::GetNRows(); padrow++)
 562         {
 563           AliHLTDigitData *digits = (AliHLTDigitData*)rowPt->fDigitData;
 564           for(UInt_t j=0; j<rowPt->fNDigit; j++)
 565             {
 566               Int_t pad = digits[j].fPad;
 567               if(i==1 && pad < fPadMin[padrow])
 568                 continue;
 569               if(i==fNActiveSlice*2+1 && pad>fPadMax[padrow])
 570                 continue;
 571               Int_t time = digits[j].fTime;
 572               AliHLTTransform::Slice2Sector(slice,padrow,sector,row);
 573               AliHLTTransform::Raw2Local(xyz,sector,row,pad,time);
 574
 575               Rotate(xyz,i-1-fNActiveSlice);
 576
 577               Double_t eta = AliHLTTransform::GetEta(xyz);
 578               if(GetEtaIndex(eta) == etaindex)
 579                 hist->Fill(xyz[0],xyz[1]);
 580             }
 581           AliHLTMemHandler::UpdateRowPointer(rowPt);
 582         }
 583     }
 584 }