TPC/Rec/AliTPCtrackerSector.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16
  17 //-------------------------------------------------------
  18 //          Implementation of the TPC tracker helper clasess
  19 //  AliTPCtrackerRow
  20 //  AliTPCtrackerSector
  21 //
  22 //   Origin: Marian Ivanov   Marian.Ivanov@cern.ch
  23 //
  24 //  AliTPCtrakerMI -  parallel tracker helper clases
  25 //
  26
  27 /* $Id: AliTPCtrackerSector.cxx 25837 2008-05-16 16:39:00Z marian $ */
  28
  29 #include "Riostream.h"
  30 #include <TClonesArray.h>
  31 #include "AliLog.h"
  32 #include "AliComplexCluster.h"
  33 //#include "AliTPCcluster.h"
  34 #include "AliTPCclusterMI.h"
  35 #include "AliTPCClustersRow.h"
  36 #include "AliTPCParam.h"
  37 #include "AliTPCReconstructor.h"
  38 #include "AliTPCreco.h"
  39 //
  40 #include "AliTPCtrackerSector.h"
  41 #include "TStopwatch.h"
  42 #include "TTreeStream.h"
  43
  44 //
  45
  46 ClassImp(AliTPCtrackerRow)
  47 ClassImp(AliTPCtrackerSector)
  48
  49
  50
  51 AliTPCtrackerRow::AliTPCtrackerRow():
  52   fDeadZone(0.),
  53   fClusters1(0),
  54   fN1(0),
  55   fClusters2(0),
  56   fN2(0),
  57   fFastCluster(),
  58   fN(0),
  59   fClusters(),
  60   fIndex(),
  61   fX(0.)
  62 {
  63   //
  64   // default constructor
  65   //
  66 }
  67
  68 AliTPCtrackerRow::~AliTPCtrackerRow(){
  69   //
  70   delete fClusters1;
  71   delete fClusters2;
  72 }
  73
  74
  75
  76 //_________________________________________________________________________
  77 void
  78 AliTPCtrackerRow::InsertCluster(const AliTPCclusterMI* c, UInt_t index) {
  79   //-----------------------------------------------------------------------
  80   // Insert a cluster into this pad row in accordence with its y-coordinate
  81   //-----------------------------------------------------------------------
  82   if (!c) {
  83     AliError("Inserting Zerro cluster pointer");
  84     return;
  85   }
  86   if (fN==kMaxClusterPerRow) {
  87     //AliInfo("AliTPCtrackerRow::InsertCluster(): Too many clusters");
  88     return;
  89   }
  90   if (fN>=fN1+fN2) {
  91     //AliInfo("AliTPCtrackerRow::InsertCluster(): Too many clusters !");
  92   }
  93
  94   if (fN==0) {fIndex[0]=index; fClusters[fN++]=c; return;}
  95   Int_t i=Find(c->GetZ());
  96   if (i>=0 && i<=kMaxClusterPerRow-2) {
  97     memmove(fClusters+i+1 ,fClusters+i,(fN-i)*sizeof(AliTPCclusterMI*));
  98     memmove(fIndex   +i+1 ,fIndex   +i,(fN-i)*sizeof(UInt_t));
  99   }
 100   fIndex[i]=index; fClusters[i]=c; fN++;
 101 }
 102
 103 void AliTPCtrackerRow::ResetClusters() {
 104    //
 105    // reset clusters
 106    // MvL: Need to call destructors for AliTPCclusterMI, to delete fInfo
 107   if (fClusters1) fClusters1->Clear("C");
 108   if (fClusters2) fClusters2->Clear("C");
 109
 110    fN  = 0;
 111    fN1 = 0;
 112    fN2 = 0;
 113    //delete[] fClusterArray;
 114
 115    //fClusterArray=0;
 116 }
 117
 118
 119 //___________________________________________________________________
 120 Int_t AliTPCtrackerRow::Find(Double_t z) const {
 121   //-----------------------------------------------------------------------
 122   // Return the index of the nearest cluster
 123   //-----------------------------------------------------------------------
 124   if (fN==0) return 0;
 125   if (z <= fClusters[0]->GetZ()) return 0;
 126   if (z > fClusters[fN-1]->GetZ()) return fN;
 127   Int_t b=0, e=fN-1, m=(b+e)/2;
 128   for (; b<e; m=(b+e)/2) {
 129     if (z > fClusters[m]->GetZ()) b=m+1;
 130     else e=m;
 131   }
 132   return m;
 133 }
 134
 135
 136
 137 //___________________________________________________________________
 138 AliTPCclusterMI * AliTPCtrackerRow::FindNearest(Double_t y, Double_t z, Double_t roady, Double_t roadz) const {
 139   //-----------------------------------------------------------------------
 140   // Return the index of the nearest cluster in z y
 141   //-----------------------------------------------------------------------
 142   Float_t maxdistance = roady*roady + roadz*roadz;
 143
 144   AliTPCclusterMI *cl =0;
 145   for (Int_t i=Find(z-roadz); i<fN; i++) {
 146       AliTPCclusterMI *c=(AliTPCclusterMI*)(fClusters[i]);
 147       if (c->GetZ() > z+roadz) break;
 148 //       if ( (c->GetY()-y) >  roady ) continue; //JW: Why here not abs???
 149       if ( TMath::Abs(c->GetY()-y) >  roady ) continue;
 150       Float_t distance = (c->GetZ()-z)*(c->GetZ()-z)+(c->GetY()-y)*(c->GetY()-y);
 151       if (maxdistance>distance) {
 152         maxdistance = distance;
 153         cl=c;
 154       }
 155   }
 156   return cl;
 157 }
 158
 159 AliTPCclusterMI * AliTPCtrackerRow::FindNearest2(Double_t y, Double_t z, Double_t roady, Double_t roadz,UInt_t & index) const
 160 {
 161   //-----------------------------------------------------------------------
 162   // Return the index of the nearest cluster in z y
 163   //-----------------------------------------------------------------------
 164   Float_t maxdistance = roady*roady + roadz*roadz;
 165   AliTPCclusterMI *cl =0;
 166
 167   //PH Check boundaries. 510 is the size of fFastCluster
 168   Int_t iz1 = Int_t(z-roadz+254.5);
 169   if ( iz1>=510) return cl;
 170   if (iz1<0 ) iz1 = 0;
 171   iz1 = TMath::Max(GetFastCluster(iz1)-1,0);
 172   Int_t iz2 = Int_t(z+roadz+255.5);
 173   if (iz2<0 ) return cl;
 174   if ( iz2>=510) iz2 = 509;
 175   iz2 = TMath::Min(GetFastCluster(iz2)+1,fN);
 176   Bool_t skipUsed = !(AliTPCReconstructor::GetRecoParam()->GetClusterSharing());
 177   //FindNearest3(y,z,roady,roadz,index);
 178   //  for (Int_t i=Find(z-roadz); i<fN; i++) {
 179   for (Int_t i=iz1; i<iz2; i++) {
 180       AliTPCclusterMI *c=(AliTPCclusterMI*)(fClusters[i]);
 181       if (c->GetZ() > z+roadz) break;
 182       if ( c->GetY()-y >  roady ) continue;
 183       if ( y-c->GetY() >  roady ) continue;
 184       if (skipUsed && c->IsUsed(11)) continue;
 185       Float_t distance = (c->GetZ()-z)*(c->GetZ()-z)+(c->GetY()-y)*(c->GetY()-y);
 186       if (maxdistance>distance) {
 187         maxdistance = distance;
 188         cl=c;
 189         index =i;
 190         //roady = TMath::Sqrt(maxdistance);
 191       }
 192   }
 193   return cl;
 194 }
 195
 196
 197 void AliTPCtrackerRow::SetFastCluster(Int_t i, Short_t cl){
 198   //
 199   // Set cluster info for fast navigation
 200   //
 201   if (i>=510|| i<0){
 202   }else{
 203     fFastCluster[i]=cl;
 204   }
 205 }
 206
 207 Int_t  AliTPCtrackerSector::GetNClInSector(Int_t side)
 208 {
 209   // return number of all clusters in one sector; side =0 for A side and 1 for C side
 210
 211   Int_t nclSector=0;
 212   Int_t nrows = GetNRows();
 213
 214   for (Int_t row=0;row<nrows;row++) {
 215     AliTPCtrackerRow&  tpcrow = (*this)[row];
 216     Int_t ncl =  (side==0)?(tpcrow.GetN1()):(tpcrow.GetN2());
 217     nclSector+=ncl;
 218   }
 219
 220   return nclSector;
 221 }
 222
 223
 224
 225
 226 Int_t  AliTPCtrackerSector::GetRowNumber(Double_t x) const
 227 {
 228   //return pad row number for this x
 229   Double_t r;
 230   if (fN < 64){
 231     r=fRow[fN-1].GetX();
 232     if (x > r) return fN;
 233     r=fRow[0].GetX();
 234     if (x < r) return -1;
 235     return Int_t((x-r)/fPadPitchLength + 0.5);}
 236   else{
 237     r=fRow[fN-1].GetX();
 238     if (x > r) return fN;
 239     r=fRow[0].GetX();
 240     if (x < r) return -1;
 241     Double_t r1=fRow[64].GetX();
 242     if(x<r1){
 243       return Int_t((x-r)/f1PadPitchLength + 0.5);}
 244     else{
 245       return (Int_t((x-r1)/f2PadPitchLength + 0.5)+64);}
 246   }
 247 }
 248
 249
 250 void AliTPCtrackerRow::SetCluster1(Int_t i, const AliTPCclusterMI &cl)
 251 {
 252   // attach cluster
 253   if (!fClusters1) fClusters1 = new TClonesArray("AliTPCclusterMI",1000);
 254   if (i<=fClusters1->GetLast() && fClusters1->UncheckedAt(i)) fClusters1->RemoveAt(i);
 255   new( (*fClusters1)[fClusters1->GetEntriesFast()] ) AliTPCclusterMI(cl);
 256   //
 257 }
 258
 259 void AliTPCtrackerRow::SetCluster2(Int_t i, const AliTPCclusterMI &cl)
 260 {
 261   // attach cluster
 262   if (!fClusters2) fClusters2 = new TClonesArray("AliTPCclusterMI",1000);
 263   if (i<=fClusters2->GetLast() && fClusters2->UncheckedAt(i)) fClusters2->RemoveAt(i);
 264   new( (*fClusters2)[fClusters2->GetEntriesFast()] ) AliTPCclusterMI(cl);
 265   //
 266 }
 267
 268
 269 //_________________________________________________________________________
 270 void AliTPCtrackerSector::Setup(const AliTPCParam *par, Int_t f) {
 271   //-----------------------------------------------------------------------
 272   // Setup inner sector
 273   //-----------------------------------------------------------------------
 274   if (f==0) {
 275      fAlpha=par->GetInnerAngle();
 276      fAlphaShift=par->GetInnerAngleShift();
 277      fPadPitchWidth=par->GetInnerPadPitchWidth();
 278      fPadPitchLength=par->GetInnerPadPitchLength();
 279      fN=par->GetNRowLow();
 280      if(fRow)delete [] fRow;fRow = 0;
 281      fRow=new AliTPCtrackerRow[fN];
 282      for (Int_t i=0; i<fN; i++) {
 283        fRow[i].SetX(par->GetPadRowRadiiLow(i));
 284        fRow[i].SetDeadZone(1.5);  //1.5 cm of dead zone
 285      }
 286   } else {
 287      fAlpha=par->GetOuterAngle();
 288      fAlphaShift=par->GetOuterAngleShift();
 289      fPadPitchWidth  = par->GetOuterPadPitchWidth();
 290      fPadPitchLength = par->GetOuter1PadPitchLength();
 291      f1PadPitchLength = par->GetOuter1PadPitchLength();
 292      f2PadPitchLength = par->GetOuter2PadPitchLength();
 293      fN=par->GetNRowUp();
 294      if(fRow)delete [] fRow;fRow = 0;
 295      fRow=new AliTPCtrackerRow[fN];
 296      for (Int_t i=0; i<fN; i++) {
 297        fRow[i].SetX(par->GetPadRowRadiiUp(i));
 298        fRow[i].SetDeadZone(1.5);  // 1.5 cm of dead zone
 299      }
 300   }
 301 }
 302
 303 //_________________________________________________________________________
 304 void AliTPCtrackerSector::InsertCluster(AliTPCclusterMI *cl, Int_t size, const AliTPCParam *par) {
 305   //-----------------------------------------------------------------------
 306   // Insert cluster to the sector
 307   //-----------------------------------------------------------------------
 308
 309   if(!cl) return;
 310
 311   const Int_t fkNIS = par->GetNInnerSector()/2;
 312   const Int_t fkNOS = par->GetNOuterSector()/2;
 313   Int_t row = cl->GetRow();
 314   Int_t sec = cl->GetDetector();
 315
 316   // add cluster to the corresponding pad row
 317   AliTPCtrackerRow *tpcrow = 0x0;
 318
 319   Int_t left=0;
 320   if (sec<fkNIS*2){
 321     left = sec/fkNIS;
 322   }
 323   else{
 324     left = (sec-fkNIS*2)/fkNOS;
 325   }
 326   //
 327   if (left ==0){
 328     tpcrow = fRow+row;
 329     if(!tpcrow->GetClusters1()) {
 330        tpcrow->SetN1(0);
 331     }
 332     if(size < kMaxClusterPerRow) {
 333       tpcrow->SetCluster1(tpcrow->GetN1(), *cl);
 334       //printf("inner: size %d, tpcrow->GetN1() %d  sec %d row %d tpcrow %p cl %p\n", size, tpcrow->GetN1(), sec, row, tpcrow, cl);
 335
 336       tpcrow->IncrementN1();
 337     }
 338   }
 339   if (left ==1){
 340     tpcrow = fRow+row;
 341     if(!tpcrow->GetClusters2()) {
 342       tpcrow->SetN2(0);
 343     }
 344     if(size < kMaxClusterPerRow)  {
 345       tpcrow->SetCluster2(tpcrow->GetN2(), *cl);
 346       //printf("outer: size %d, tpcrow->GetN2() %d  sec %d row %d tpcrow %p cl %p\n", size, tpcrow->GetN2(), sec, row, tpcrow, cl);
 347
 348       tpcrow->IncrementN2();
 349     }
 350   }
 351 }
 352
 353 //_________________________________________________________________________
 354 Int_t  AliTPCtrackerSector::GetNClInSector(Int_t side) const
 355 {
 356   //return number of all clusters in one sector; side =0 for A side and 1 for C side
 357
 358   Int_t nclSector=0;
 359   Int_t nrows = GetNRows();
 360
 361   for (Int_t row=0;row<nrows;row++) {
 362     AliTPCtrackerRow&  tpcrow = (*this)[row];
 363     Int_t ncl =  (side==0)?(tpcrow.GetN1()):(tpcrow.GetN2());
 364     nclSector+=ncl;
 365   }
 366
 367   return nclSector;
 368 }
 369
 370 //_________________________________________________________________________
 371 Int_t  AliTPCtrackerSector::GetNClUsedInSector(Int_t side) const
 372 {
 373   //return number of clusters used in tracking in one sector; side =0 for A side and 1 for C side
 374
 375   Int_t nclSector=0;
 376   Int_t nrows = GetNRows();
 377
 378   for (Int_t row=0;row<nrows;row++) {
 379     AliTPCtrackerRow&  tpcrow = (*this)[row];
 380     Int_t nclusters = (side==0)?tpcrow.GetN1():tpcrow.GetN2();
 381     for (Int_t icluster=0; icluster<nclusters; icluster++)
 382     {
 383       AliTPCclusterMI* cluster = NULL;
 384       if (side==0) { cluster=tpcrow.GetCluster1(icluster); }
 385       else         { cluster=tpcrow.GetCluster2(icluster); }
 386       if (!cluster) continue;
 387       if (cluster->IsUsed(1)) nclSector++;
 388     }
 389   }
 390
 391   return nclSector;
 392 }
 393