TPC/AliTPCTransform.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 //          Implementation of the TPC transformation class
  18 //
  19 //   Origin: Marian Ivanov   Marian.Ivanov@cern.ch
  20 //           Magnus Mager
  21 //
  22 //   Class for tranformation of the coordinate frame
  23 //   Transformation
  24 //    local coordinate frame (sector, padrow, pad, timebine) ==>
  25 //    rotated global (tracking) cooridnate frame (sector, lx,ly,lz)
  26 //
  27 //    Unisochronity  - (substract time0 - pad by pad)
  28 //    Drift velocity - Currently common drift velocity - functionality of AliTPCParam
  29 //    ExB effect     -
  30 //
  31 //    Usage:
  32 //          AliTPCclustererMI::AddCluster
  33 //          AliTPCtrackerMI::Transform
  34 //
  35 //-------------------------------------------------------
  36
  37 /* To test it:
  38    cdb=AliCDBManager::Instance()
  39    cdb->SetDefaultStorage("local:///u/mmager/mycalib1")
  40    c=AliTPCcalibDB::Instance()
  41    c->SetRun(0)
  42    Double_t x[]={1.0,2.0,3.0}
  43    Int_t i[]={4}
  44    AliTPCTransform trafo
  45    trafo.Transform(x,i,0,1)
  46  */
  47
  48 /* $Id$ */
  49
  50 #include "AliTPCROC.h"
  51 #include "AliTPCCalPad.h"
  52 #include "AliTPCCalROC.h"
  53 #include "AliTPCcalibDB.h"
  54 #include "AliTPCParam.h"
  55 #include "TMath.h"
  56 #include "AliLog.h"
  57 #include "AliTPCExB.h"
  58 #include "TGeoMatrix.h"
  59 #include "AliTPCTransform.h"
  60
  61 ClassImp(AliTPCTransform)
  62
  63
  64 AliTPCTransform::AliTPCTransform() {
  65   //
  66   // Speed it up a bit!
  67   //
  68   for (Int_t i=0;i<18;++i) {
  69     Double_t alpha=TMath::DegToRad()*(10.+20.*(i%18));
  70     fSins[i]=TMath::Sin(alpha);
  71     fCoss[i]=TMath::Cos(alpha);
  72   }
  73 }
  74
  75 AliTPCTransform::~AliTPCTransform() {
  76   //
  77   // Destructor
  78   //
  79 }
  80
  81 void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/,
  82                                 Int_t /*coordinateType*/) {
  83   // input: x[0] - pad row
  84   //        x[1] - pad
  85   //        x[2] - time in us
  86   //        i[0] - sector
  87   // output: x[0] - x (all in the rotated global coordinate frame)
  88   //         x[1] - y
  89   //         x[2] - z
  90   Int_t row=TMath::Nint(x[0]);
  91   Int_t pad=TMath::Nint(x[1]);
  92   Int_t sector=i[0];
  93   AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();
  94   //
  95   AliTPCCalPad * time0TPC = calib->GetPadTime0();
  96   AliTPCParam  * param    = calib->GetParameters();
  97   if (!time0TPC){
  98     AliFatal("Time unisochronity missing");
  99   }
 100
 101   if (!param){
 102     AliFatal("Parameters missing");
 103   }
 104
 105   Double_t xx[3];
 106   //  Apply Time0 correction - Pad by pad fluctuation
 107   //
 108   x[2]-=time0TPC->GetCalROC(sector)->GetValue(row,pad);
 109   //
 110   // Tranform from pad - time coordinate system to the rotated global (tracking) system
 111   //
 112   Local2RotatedGlobal(sector,x);
 113   //
 114   //
 115   //
 116   // Alignment
 117   //TODO:  calib->GetParameters()->GetClusterMatrix(sector)->LocalToMaster(x,xx);
 118   RotatedGlobal2Global(sector,x);
 119   //
 120   //
 121   // ExB correction
 122   //
 123   calib->GetExB()->Correct(x,xx);
 124
 125   Global2RotatedGlobal(sector,xx);
 126
 127   x[0]=xx[0];x[1]=xx[1];x[2]=xx[2];
 128 }
 129
 130 void AliTPCTransform::Local2RotatedGlobal(Int_t sector, Double_t *x) const {
 131   //
 132   //
 133   // Tranform coordinate from
 134   // row, pad, time to x,y,z
 135   //
 136   // Drift Velocity
 137   // Current implementation - common drift velocity - for full chamber
 138   // TODO: use a map or parametrisation!
 139   //
 140   //
 141   //
 142   AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();
 143   AliTPCParam  * param    = calib->GetParameters();
 144   if (!param){
 145     AliFatal("Parameters missing");
 146   }
 147   Int_t row=TMath::Nint(x[0]);
 148   Int_t pad=TMath::Nint(x[1]);
 149   //
 150   const Int_t kNIS=param->GetNInnerSector(), kNOS=param->GetNOuterSector();
 151   Double_t sign = 1.;
 152   Double_t zwidth    = param->GetZWidth();
 153   Double_t padWidth  = 0;
 154   Double_t padLength = 0;
 155   Double_t    maxPad    = 0;
 156   //
 157   if (sector < kNIS) {
 158     maxPad = param->GetNPadsLow(row);
 159     sign = (sector < kNIS/2) ? 1 : -1;
 160     padLength = param->GetPadPitchLength(sector,row);
 161     padWidth = param->GetPadPitchWidth(sector);
 162   } else {
 163     maxPad = param->GetNPadsUp(row);
 164     sign = ((sector-kNIS) < kNOS/2) ? 1 : -1;
 165     padLength = param->GetPadPitchLength(sector,row);
 166     padWidth  = param->GetPadPitchWidth(sector);
 167   }
 168   //
 169   // X coordinate
 170   x[0] = param->GetPadRowRadii(sector,row);  // padrow X position - ideal
 171   //
 172   // Y coordinate
 173   //
 174   x[1]=(x[1]-0.5*maxPad)*padWidth;
 175   //
 176   // Z coordinate
 177   //
 178   x[2]*= zwidth;  // tranform time bin to the distance to the ROC
 179   x[2]-= 3.*param->GetZSigma() + param->GetNTBinsL1()*zwidth;
 180   // subtract the time offsets
 181   x[2] = sign*( param->GetZLength(sector) - x[2]);
 182 }
 183
 184 inline void AliTPCTransform::RotatedGlobal2Global(Int_t sector,Double_t *x) const {
 185   //
 186   // transform possition rotated global to the global
 187   //
 188   Double_t cos,sin;
 189   GetCosAndSin(sector,cos,sin);
 190   Double_t tmp=x[0];
 191   x[0]= cos*tmp+sin*x[1];
 192   x[1]=-sin*tmp+cos*x[1];
 193 }
 194
 195 inline void AliTPCTransform::Global2RotatedGlobal(Int_t sector,Double_t *x) const {
 196   //
 197   // tranform possition Global2RotatedGlobal
 198   //
 199   Double_t cos,sin;
 200   GetCosAndSin(sector,cos,sin);
 201   Double_t tmp=x[0];
 202   x[0]= cos*tmp-sin*x[1];
 203   x[1]= sin*tmp+cos*x[1];
 204 }
 205
 206 inline void AliTPCTransform::GetCosAndSin(Int_t sector,Double_t &cos,
 207                                           Double_t &sin) const {
 208   cos=fCoss[sector%18];
 209   sin=fSins[sector%18];
 210 }
 211
 212