ITS/UPGRADE/AliITSsegmentationPixUpg.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 /* $Id: AliITSsegmentationPixUpg.cxx 47180 2011-02-08 09:42:29Z masera $ */
  17 #include <TGeoManager.h>
  18 #include <TGeoVolume.h>
  19 #include <TGeoBBox.h>
  20 #include "AliITSsegmentationPixUpg.h"
  21
  22 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
  23 // Segmentation class for pixels                                                                          //
  24 // Questions to solve: are guardrings needed and do they belong to the sensor or to the module in TGeo    //
  25 //                     At the moment assume that the local coord syst. is located at bottom left corner   //
  26 //                     of the ACTIVE matrix. If the guardring to be accounted in the local coords, in     //
  27 //                     the Z and X conversions one needs to first subtract the  fGuardLft and fGuardBot   //
  28 //                     from the local Z,X coordinates                                                     //
  29 //                                                                                                        //
  30 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
  31
  32 ClassImp(AliITSsegmentationPixUpg)
  33
  34 //_____________________________________________________________________________RS
  35 AliITSsegmentationPixUpg::AliITSsegmentationPixUpg(int nchips,int ncol,int nrow,
  36                                                    double pitchX,double pitchZ,
  37                                                    double pitchLftC,double pitchRgtC,
  38                                                    double thickness,
  39                                                    double edgL,double edgR,double edgT,double edgB)
  40 : AliITSsegmentation()
  41   ,fGuardLft(edgL)
  42   ,fGuardRgt(edgR)
  43   ,fGuardTop(edgT)
  44   ,fGuardBot(edgB)
  45   ,fPitchX(pitchX)
  46   ,fPitchZ(pitchZ)
  47   ,fPitchZLftCol(pitchLftC<0 ? pitchZ:pitchLftC)
  48   ,fPitchZRgtCol(pitchRgtC<0 ? pitchZ:pitchRgtC)
  49   ,fChipDZ(0)
  50   ,fNChips(nchips)
  51   ,fNColPerChip(nchips>0 ? ncol/nchips:0)
  52   ,fNRow(nrow)
  53   ,fNCol(ncol)
  54 {
  55   // Default constructor, sizes in microns
  56   fChipDZ = (fNColPerChip-2)*fPitchZ + fPitchZLftCol + fPitchZRgtCol;
  57   SetDetSize( fNRow*fPitchX /*+fGuardTop+fGuardBot*/,
  58               fNChips*fChipDZ /*+fGuardLft+fGuardRgt*/,
  59               thickness);
  60   //
  61 }
  62
  63 //_____________________________________________________________________________RS
  64 void AliITSsegmentationPixUpg::GetPadIxz(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const
  65 {
  66   //  Returns pixel coordinates (ix,iz) for given real local coordinates (x,z)
  67   //  expects x, z in microns
  68   ix = int(x/fPitchX) + 1;
  69   iz = int(Z2Col(z)) + 1;
  70   //
  71   if (iz >  fNCol) iz= fNCol;
  72   if (ix >  fNRow) ix= fNRow;
  73   //
  74 }
  75
  76 //_____________________________________________________________________________RS
  77 void AliITSsegmentationPixUpg::GetPadTxz(Float_t &x,Float_t &z) const
  78 {
  79   //  local transformation of real local coordinates (x,z)
  80   //  expects x, z in microns
  81   x /= fPitchX;
  82   z = Z2Col(z);
  83   //
  84 }
  85
  86 //_____________________________________________________________________________RS
  87 void AliITSsegmentationPixUpg::GetPadCxz(Int_t ix,Int_t iz,Float_t &x,Float_t&z) const
  88 {
  89   // Transform from pixel to real local coordinates
  90   // returns x, z in microns
  91   x = (ix>0) ? Float_t((ix-0.5)*fPitchX) : Float_t((ix+0.5)*fPitchX);
  92   z = Col2Z(iz);
  93   //
  94 }
  95
  96 //_____________________________________________________________________________RS
  97 Float_t AliITSsegmentationPixUpg::Z2Col(Float_t z) const
  98 {
  99   // get column number (from 0) from local Z
 100   int chip = z/fChipDZ;
 101   float col = chip*fNColPerChip;
 102   z -= chip*fChipDZ;
 103   if (z<fPitchZLftCol) col += z/fPitchZLftCol;
 104   else {
 105     z = fPitchZLftCol;
 106     col += 1;
 107     if (z<(fChipDZ-fPitchZRgtCol)) col += 1+z/fPitchZ;
 108     else col += 1+(z - (fNColPerChip-2)*fPitchZ)/fPitchZRgtCol;
 109   }
 110   return col;
 111 }
 112
 113 //_____________________________________________________________________________RS
 114 Float_t AliITSsegmentationPixUpg::Col2Z(Int_t col) const
 115 {
 116   // convert column number (from 0) to Z coordinate
 117   int nchip = col/fNColPerChip;
 118   col %= fNColPerChip;
 119   float z = nchip*fChipDZ;
 120   if (!col) z -= fPitchZRgtCol/2;
 121   else if (col==1) z += fPitchZLftCol/2;
 122   else if (col==fNColPerChip-1) z += fChipDZ - fPitchZRgtCol/2;
 123   else    z += fPitchZLftCol + (col-0.5)*fChipDZ;
 124   return z;
 125   //
 126 }
 127
 128 //______________________________________________________________________RS
 129 AliITSsegmentationPixUpg& AliITSsegmentationPixUpg::operator=(const AliITSsegmentationPixUpg &src)
 130 {
 131   // = operator
 132   if(this==&src) return *this;
 133   AliITSsegmentation::operator=(src);
 134   fNCol  = src.fNCol;
 135   fNRow  = src.fNRow;
 136   fNColPerChip  = src.fNColPerChip;
 137   fNChips = src.fNChips;
 138   fChipDZ = src.fChipDZ;
 139   fPitchZRgtCol = src.fPitchZRgtCol;
 140   fPitchZLftCol = src.fPitchZLftCol;
 141   fPitchZ = src.fPitchZ;
 142   fPitchX = src.fPitchX;
 143   //
 144   fGuardBot = src.fGuardBot;
 145   fGuardTop = src.fGuardTop;
 146   fGuardRgt = src.fGuardRgt;
 147   fGuardLft = src.fGuardLft;
 148   //
 149   return *this;
 150 }
 151
 152 //____________________________________________________________________________RS
 153 AliITSsegmentationPixUpg::AliITSsegmentationPixUpg(const AliITSsegmentationPixUpg &src) :
 154   AliITSsegmentation(src)
 155   ,fGuardLft(src.fGuardLft)
 156   ,fGuardRgt(src.fGuardRgt)
 157   ,fGuardTop(src.fGuardTop)
 158   ,fGuardBot(src.fGuardBot)
 159   ,fPitchX(src.fPitchX)
 160   ,fPitchZ(src.fPitchZ)
 161   ,fPitchZLftCol(src.fPitchZLftCol)
 162   ,fPitchZRgtCol(src.fPitchZRgtCol)
 163   ,fChipDZ(src.fChipDZ)
 164   ,fNChips(src.fNChips)
 165   ,fNColPerChip(src.fNColPerChip)
 166   ,fNRow(src.fNRow)
 167   ,fNCol(src.fNCol)
 168 {
 169 }
 170
 171 //____________________________________________________________________________RS
 172 Float_t AliITSsegmentationPixUpg::Dpx(Int_t ) const
 173 {
 174   //returs x pixel pitch for a give pixel
 175   return fPitchX;
 176 }
 177
 178 //____________________________________________________________________________RS
 179 Float_t AliITSsegmentationPixUpg::Dpz(Int_t col) const
 180 {
 181   // returns z pixel pitch for a given pixel (cols starts from 0)
 182   col %= fNColPerChip;
 183   if (!col) return fPitchZLftCol;
 184   if (col==fNColPerChip-1) return fPitchZRgtCol;
 185   return fPitchZ;
 186   //
 187 }
 188
 189 //------------------------------
 190 void AliITSsegmentationPixUpg::Neighbours(Int_t iX, Int_t iZ, Int_t* nlist, Int_t xlist[8], Int_t zlist[8]) const
 191 {
 192   // returns the neighbouring pixels for use in Cluster Finders and the like.
 193   //
 194   *nlist=8;
 195   xlist[0]=xlist[1]=iX;
 196   xlist[2]=iX-1;
 197   xlist[3]=iX+1;
 198   zlist[0]=iZ-1;
 199   zlist[1]=iZ+1;
 200   zlist[2]=zlist[3]=iZ;
 201   // Diagonal elements
 202   xlist[4]=iX+1;
 203   zlist[4]=iZ+1;
 204   //
 205   xlist[5]=iX-1;
 206   zlist[5]=iZ-1;
 207   //
 208   xlist[6]=iX-1;
 209   zlist[6]=iZ+1;
 210   //
 211   xlist[7]=iX+1;
 212   zlist[7]=iZ-1;
 213   //
 214 }
 215
 216 //______________________________________________________________________
 217 Bool_t AliITSsegmentationPixUpg::LocalToDet(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const
 218 {
 219   // Transformation from Geant detector centered local coordinates (cm) to
 220   // Pixel cell numbers ix and iz.
 221   // Input:
 222   //    Float_t   x        detector local coordinate x in cm with respect to
 223   //                       the center of the sensitive volume.
 224   //    Float_t   z        detector local coordinate z in cm with respect to
 225   //                       the center of the sensitive volulme.
 226   // Output:
 227   //    Int_t    ix        detector x cell coordinate. Has the range
 228   //                       0<=ix<fNRow.
 229   //    Int_t    iz        detector z cell coordinate. Has the range
 230   //                       0<=iz<fNCol.
 231   // Return:
 232   //   kTRUE if point x,z is inside sensitive volume, kFALSE otherwise.
 233   //   A value of -1 for ix or iz indecates that this point is outside of the
 234   //   detector segmentation as defined.
 235   x = x*kCM2MC+0.5*Dx();
 236   z = z*kCM2MC+0.5*Dz();
 237   ix = iz = -1;
 238   if(x<0 || x>Dx()) return kFALSE; // outside x range.
 239   if(z<0 || z>Dz()) return kFALSE; // outside z range.
 240   ix = int(x/fPitchX);
 241   iz = Z2Col(z);
 242   return kTRUE; // Found ix and iz, return.
 243 }
 244
 245 //______________________________________________________________________
 246 void AliITSsegmentationPixUpg::DetToLocal(Int_t ix,Int_t iz,Float_t &x,Float_t &z) const
 247 {
 248 // Transformation from Detector cell coordiantes to Geant detector centerd
 249 // local coordinates (cm).
 250 // Input:
 251 // Int_t    ix        detector x cell coordinate. Has the range 0<=ix<fNRow.
 252 // Int_t    iz        detector z cell coordinate. Has the range 0<=iz<fNCol.
 253 // Output:
 254 // Float_t   x        detector local coordinate x in cm with respect to the
 255 //                    center of the sensitive volume.
 256 // Float_t   z        detector local coordinate z in cm with respect to the
 257 //                    center of the sensitive volulme.
 258 // If ix and or iz is outside of the segmentation range a value of -0.5*Dx()
 259 // or -0.5*Dz() is returned.
 260   //
 261   x = -0.5/kCM2MC*Dx(); // default value.
 262   z = -0.5/kCM2MC*Dz(); // default value.
 263   // RS: to check: why we don't do strict check for [0:n)
 264   if(ix<0 || ix>=fNRow) return; // outside of detector
 265   if(iz<0 || iz>=fNCol) return; // outside of detctor
 266   x += (ix+0.5)*fPitchX*(1./kCM2MC);       // RS: we go to the center of the pad, i.e. + pitch/2, not to the boundary as in SPD
 267   z += Col2Z(iz)*(1./kCM2MC);
 268   return; // Found x and z, return.
 269 }
 270
 271 //______________________________________________________________________
 272 void AliITSsegmentationPixUpg::CellBoundries(Int_t ix,Int_t iz,Double_t &xl,Double_t &xu,Double_t &zl,Double_t &zu) const
 273 {
 274   // Transformation from Detector cell coordiantes to Geant detector centerd
 275   // local coordinates (cm).
 276   // Input:
 277   // Int_t    ix        detector x cell coordinate. Has the range 0<=ix<fNRow.
 278   // Int_t    iz        detector z cell coordinate. Has the range 0<=iz<fNCol.
 279   // Output:
 280   // Double_t   xl       detector local coordinate cell lower bounds x in cm
 281   //                    with respect to the center of the sensitive volume.
 282   // Double_t   xu       detector local coordinate cell upper bounds x in cm
 283   //                    with respect to the center of the sensitive volume.
 284   // Double_t   zl       detector local coordinate lower bounds z in cm with
 285   //                    respect to the center of the sensitive volulme.
 286   // Double_t   zu       detector local coordinate upper bounds z in cm with
 287   //                    respect to the center of the sensitive volulme.
 288   // If ix and or iz is outside of the segmentation range a value of -0.5*Dx()
 289   // and -0.5*Dx() or -0.5*Dz() and -0.5*Dz() are returned.
 290   Float_t x,z;
 291   DetToLocal(ix,iz,x,z);
 292   //
 293   if( ix<0 || ix>=fNRow || iz<0 || iz>=fNCol) {
 294     xl = xu = -0.5/kCM2MC*Dx(); // default value.
 295     zl = zu = -0.5/kCM2MC*Dz(); // default value.
 296     return; // outside of detctor
 297   }
 298   float zpitchH = Dpz(iz)/2./kCM2MC;
 299   float xpitchH = fPitchX/2./kCM2MC;
 300   xl -= xpitchH;
 301   xu += xpitchH;
 302   zl -= zpitchH;
 303   zu += zpitchH;
 304   return; // Found x and z, return.
 305 }
 306
 307 //______________________________________________________________________
 308 Int_t AliITSsegmentationPixUpg::GetChipFromChannel(Int_t, Int_t iz) const
 309 {
 310   // returns chip number (in range 0-4) starting from channel number
 311   if(iz>=fNCol  || iz<0 ){
 312     AliWarning("Bad cell number");
 313     return -1;
 314   }
 315   return iz/fNColPerChip;
 316 }
 317
 318 //______________________________________________________________________
 319 Int_t AliITSsegmentationPixUpg::GetChipFromLocal(Float_t, Float_t zloc) const
 320 {
 321   // returns chip number (in range 0-4) starting from local coordinates
 322   Int_t ix0,iz;
 323   if (!LocalToDet(0,zloc,ix0,iz)) {
 324     AliWarning("Bad local coordinate");
 325     return -1;
 326   }
 327   return GetChipFromChannel(ix0,iz);
 328 }
 329
 330 //______________________________________________________________________
 331 Int_t AliITSsegmentationPixUpg::GetChipsInLocalWindow(Int_t* array, Float_t zmin, Float_t zmax, Float_t, Float_t) const
 332 {
 333   // returns the number of chips containing a road defined by given local coordinate limits
 334   //
 335   const Float_t kconv = 1./kCM2MC; // converts microns to cm.
 336   //
 337   if (zmin>zmax) {
 338     AliWarning("Bad coordinate limits: zmin>zmax!");
 339     return -1;
 340   }
 341   //
 342   Int_t nChipInW = 0;
 343   //
 344   Float_t zminDet = -0.5*kconv*Dz();
 345   Float_t zmaxDet =  0.5*kconv*Dz();
 346   if(zmin<zminDet) zmin=zminDet;
 347   if(zmax>zmaxDet) zmax=zmaxDet;
 348
 349   Int_t n1 = GetChipFromLocal(0,zmin);
 350   array[nChipInW] = n1;
 351   nChipInW++;
 352
 353   Int_t n2 = GetChipFromLocal(0,zmax);
 354
 355   if(n2!=n1){
 356     Int_t imin=TMath::Min(n1,n2);
 357     Int_t imax=TMath::Max(n1,n2);
 358     for(Int_t ichip=imin; ichip<=imax; ichip++){
 359       if(ichip==n1) continue;
 360       array[nChipInW]=ichip;
 361       nChipInW++;
 362     }
 363   }
 364   //
 365   return nChipInW;
 366 }
 367
 368 //______________________________________________________________________
 369 void AliITSsegmentationPixUpg::Init()
 370 {
 371   // init settings
 372 }