TPC/AliTPCTransformation.cxx

   1 /*
   2
   3  Class AliTPCtransformation:
   4  Should represent general non linear transformation. Currently tune for TPConly.
   5  To be used:
   6  1. Simulation-Digitization
   7  2. Reconstruction - AliTPCTransform
   8  3. Calibration/Alignment (KalmanFilter, Milipedde)
   9  4. Set of transformation to be stored/retrieved as OCDB entry
  10
  11  Base functionality:
  12
  13  1. Double_t GetDeltaXYZ(Int_t coord, Int_t volID, Double_t param, Double_t x, Double_t y, Double_t z)
  14  Get correction - return the delta of coordinate coord dx or dy or dz for given volID for point at point (x,y,z)
  15  All coordinates are global
  16
  17  2. The transformation should work only for given volIDs and detector IDs
  18     Currently Bitmask is used for filtering
  19
  20
  21  Transformation - naming convention:
  22  //
  23  XXX(local)YYYZZZ
  24  TPClocaldLxdGX
  25  XXX   - detector if detector specific
  26  local - if local transforamtion
  27  YYY   - type of transformation
  28  ZZZ   - return type of transformation
  29
  30 */
  31
  32 #include <string.h>
  33 #include "TRandom.h"
  34 #include "TMath.h"
  35 #include "TBits.h"
  36 #include "TFormula.h"
  37 #include "TF1.h"
  38 #include "TLinearFitter.h"
  39 #include "TFile.h"
  40 #include "TObjString.h"
  41
  42 #include "TTreeStream.h"
  43 #include "AliTrackPointArray.h"
  44 #include "AliLog.h"
  45 #include "AliTPCTransformation.h"
  46
  47 ClassImp(AliTPCTransformation)
  48
  49
  50 AliTPCTransformation::GenFuncG    AliTPCTransformation::fgFormulas[10000];
  51 TObjArray*  AliTPCTransformation::fgFormulasName = new TObjArray(10000);
  52
  53
  54 void AliTPCTransformation::RegisterFormula(const char * name, GenFuncG formula){
  55   //
  56   // Add Formula to the list of formulas
  57   //
  58   Int_t last= fgFormulasName->GetEntries();
  59   fgFormulasName->AddLast(new TObjString(name));
  60   fgFormulas[last]=formula;
  61 }
  62
  63 Int_t  AliTPCTransformation::BuildBasicFormulas(){
  64   //
  65
  66   //
  67   //build list of basic TPC formulas - corrections
  68   //
  69   RegisterFormula("TPCscalingRPol",(GenFuncG)(AliTPCTransformation::TPCscalingRPol));
  70   RegisterFormula("TPCscalingRIFC",(GenFuncG)(AliTPCTransformation::TPCscalingRIFC));
  71   RegisterFormula("TPCscalingROFC",(GenFuncG)(AliTPCTransformation::TPCscalingROFC));
  72   //
  73   RegisterFormula("TPCdeltaFCROC",(GenFuncG)(AliTPCTransformation::TPCdeltaFCROC));
  74   RegisterFormula("TPCdeltaFCCE",(GenFuncG)(AliTPCTransformation::TPCdeltaFCCE));
  75   //
  76   RegisterFormula("TPCscalingZDr",(GenFuncG)(AliTPCTransformation::TPCscalingZDrift));
  77   RegisterFormula("TPCscalingZDrGy",(GenFuncG)(AliTPCTransformation::TPCscalingZDriftGy));
  78   RegisterFormula("TPCscalingZDriftT0",(GenFuncG)(AliTPCTransformation::TPCscalingZDriftT0));
  79   RegisterFormula("TPCscalingPhiLocal",(GenFuncG)(AliTPCTransformation::TPCscalingPhiLocal));
  80   RegisterFormula("TPClocalRPhiEdge",(GenFuncG)(AliTPCTransformation::TPClocalRPhiEdge));
  81   //
  82   // TPC Local X and Y misalignment + rotation
  83   //
  84   RegisterFormula("TPClocaldLxdGX",(GenFuncG)(AliTPCTransformation::TPClocaldLxdGX));
  85   RegisterFormula("TPClocaldLxdGY",(GenFuncG)(AliTPCTransformation::TPClocaldLxdGY));
  86   RegisterFormula("TPClocaldLydGX",(GenFuncG)(AliTPCTransformation::TPClocaldLydGX));
  87   RegisterFormula("TPClocaldLydGY",(GenFuncG)(AliTPCTransformation::TPClocaldLydGY));
  88   RegisterFormula("TPClocaldRzdGX",(GenFuncG)(AliTPCTransformation::TPClocaldRzdGX));
  89   RegisterFormula("TPClocaldRzdGY",(GenFuncG)(AliTPCTransformation::TPClocaldRzdGY));
  90
  91   //
  92   // Z offset
  93   //
  94   RegisterFormula("TPCDeltaZ",(GenFuncG)(AliTPCTransformation::TPCDeltaZ));
  95   RegisterFormula("TPCDeltaZMediumLong",(GenFuncG)(AliTPCTransformation::TPCDeltaZMediumLong));
  96   RegisterFormula("TPCTiltingZ",(GenFuncG)(AliTPCTransformation::TPCTiltingZ));
  97   return 0;
  98 }
  99
 100 AliTPCTransformation::GenFuncG  AliTPCTransformation::FindFormula(const char * name){
 101   //
 102   // find formula - if registered
 103   //
 104   if (fgFormulasName->FindObject(name)==0) return 0;
 105   Int_t entries = fgFormulasName->GetEntries();
 106   for (Int_t i=0;i<entries;i++){
 107     if (strcmp(fgFormulasName->At(i)->GetName(), name)==0){
 108       return fgFormulas[i];
 109     }
 110   }
 111   return 0;
 112 }
 113
 114 Double_t AliTPCTransformation::Eval(const char * name, const Double_t*x,const Double_t*par){
 115   //
 116   // Only for test purposes - very slow
 117   //
 118   GenFuncG fun = FindFormula(name);
 119   if (!fun) return 0;
 120   return fun(x,par);
 121 }
 122
 123
 124 AliTPCTransformation::AliTPCTransformation():
 125   TNamed(),
 126   fNameX(0),          // x formula name
 127   fNameY(0),          // y formula name
 128   fNameZ(0),          // z formula name
 129   //
 130   fBitMask(0),        // bitmaps - transformation only for specified volID
 131   fCoordSystem(0),    // coord system of  output deltas
 132   fParam(0),          // free parameter of transformation
 133   fSigma(0),          // uncertainty of the parameter
 134   fSigmaMax(0),       //maximal sigma (Not allowed to increase in propagate time by bigger factor)
 135   fSigma2Time(0),     // change of the error in time - (For kalman filter)
 136   fFixedParam(0),     // fixed parameters of tranformation
 137   fIsActive(kTRUE),   // swith - On/Off
 138   //
 139   fInit(kFALSE),      // initialization flag - set to kTRUE if corresponding formulas found
 140   fFormulaX(0),       // x formula - pointer to the function
 141   fFormulaY(0),       // y formula - pointer to the function
 142   fFormulaZ(0)       // z formula - pointer to the function
 143   //
 144 {
 145   //
 146   // default constructor
 147   //
 148 }
 149
 150
 151
 152 AliTPCTransformation::AliTPCTransformation(const char *name, TBits *mask, const char *fx, const char *fy, const char *fz, Int_t coordSystem):
 153   TNamed(name,name),
 154   fNameX(0),       // x formula name
 155   fNameY(0),       // y formula name
 156   fNameZ(0),       // z formula name
 157   fBitMask(mask),   // bitmaps - transformation only for specified volID
 158   fCoordSystem(coordSystem), // coordinate system of output deltas
 159   fParam(0),          // free parameter of transformation
 160   fSigma(0),
 161   fSigmaMax(0),       //maximal sigma (Not allowed to increase in propagate time by bigger factor)
 162   fSigma2Time(0),     // change of sigma in time
 163   fFixedParam(0),     // fixed parameters of tranformation
 164   fIsActive(kTRUE),   // swith - On/Off
 165   //
 166   fInit(kFALSE),      // initialization flag - set to kTRUE if corresponding formulas found
 167   fFormulaX(0),       // x formula - pointer to the function
 168   fFormulaY(0),       // y formula - pointer to the function
 169   fFormulaZ(0)       // z formula - pointer to the function
 170 {
 171   //
 172   // non default constructor
 173   //
 174   if (fx) fNameX= new TString(fx);
 175   if (fy) fNameY= new TString(fy);
 176   if (fz) fNameZ= new TString(fz);
 177   Init();
 178 }
 179
 180 AliTPCTransformation::AliTPCTransformation(const AliTPCTransformation&trafo):
 181   TNamed(trafo),
 182   fNameX(0),          // x formula name
 183   fNameY(0),          // y formula name
 184   fNameZ(0),          // z formula name
 185                      //
 186   fBitMask(0),        // bitmaps - transformation only for specified volID
 187   fCoordSystem(0),    // coord system of  output deltas
 188   fParam(trafo.fParam),          // free parameter of transformation
 189   fSigma(trafo.fSigma),          // uncertainty of the parameter
 190   fSigmaMax(trafo.fSigma),       //maximal sigma (Not allowed to increase in propagate time by bigger factor)
 191   fSigma2Time(trafo.fSigma2Time),     // change of the error in time - (For kalman filter)
 192   fFixedParam(0),     // fixed parameters of tranformation
 193   fIsActive(trafo.fIsActive),   // swith - On/Off
 194   //
 195   fInit(kFALSE),      // initialization flag - set to kTRUE if corresponding formulas found
 196   fFormulaX(0),       // x formula - pointer to the function
 197   fFormulaY(0),       // y formula - pointer to the function
 198   fFormulaZ(0)       // z formula - pointer to the function
 199 {
 200   //
 201   // comment are above
 202   //
 203   if (trafo.fNameX) fNameX = new TString(*(trafo.fNameX));
 204   if (trafo.fNameY) fNameY = new TString(*(trafo.fNameY));
 205   if (trafo.fNameZ) fNameZ = new TString(*(trafo.fNameZ));
 206   if (trafo.fBitMask)  fBitMask = new TBits(*(trafo.fBitMask));
 207 }
 208
 209 AliTPCTransformation::~AliTPCTransformation(){
 210   //
 211   // destructor
 212   //
 213   delete fNameX;
 214   delete fNameY;
 215   delete fNameZ;
 216   delete fBitMask;
 217   delete fFixedParam;
 218 }
 219 void AliTPCTransformation::SetParams(Double_t param, Double_t sigma, Double_t sigma2Time, const TVectorD *const fixedParams){
 220   //
 221   // Set parameters of transformation
 222   //
 223   fParam = param;
 224   fSigma = sigma;
 225   fSigmaMax = sigma;
 226   fSigma2Time = sigma2Time;
 227   if (fFixedParam) delete fFixedParam;
 228   fFixedParam = new TVectorD(*fixedParams);
 229   Init();
 230 }
 231
 232
 233 Bool_t AliTPCTransformation::Init(){
 234   //
 235   // associate formulas with pointer to the function
 236   //
 237   Bool_t isOK=kTRUE;
 238   if (fNameX) {
 239     fFormulaX=FindFormula(fNameX->Data());
 240     if (fFormulaX==0) isOK=kFALSE;
 241   }
 242   if (fNameY) {
 243     fFormulaY=FindFormula(fNameY->Data());
 244     if (fFormulaY==0) isOK=kFALSE;
 245   }
 246   if (fNameZ) {
 247     fFormulaZ=FindFormula(fNameZ->Data());
 248     if (!fFormulaZ) isOK=kFALSE;
 249   }
 250   return isOK;
 251 }
 252
 253
 254
 255 TBits * AliTPCTransformation::BitsSide(Bool_t aside){
 256   //
 257   // Set bits for given side
 258   //
 259   TBits * bits = new TBits(72);
 260   for (Int_t i=0; i<72;i++){
 261     if (i%36<18 && aside) (*bits)[i]=kTRUE;
 262     if (i%36<18 && (!aside)) (*bits)[i]=kFALSE;
 263     if (i%36>=18 && aside) (*bits)[i]=kFALSE;
 264     if (i%36>=18 && (!aside)) (*bits)[i]=kTRUE;
 265   }
 266   return bits;
 267 }
 268
 269 TBits * AliTPCTransformation::BitsAll(){
 270   //
 271   // Set all bits to kTRUE
 272   //
 273   TBits * bits = new TBits(72);
 274   for (Int_t i=0; i<72;i++){
 275     (*bits)[i]=kTRUE;
 276   }
 277   return bits;
 278 }
 279
 280 // Double_t AliTPCTransformation::GetDeltaXYZ(Int_t coord, Int_t volID, Double_t param, Double_t x, Double_t y, Double_t z){
 281 //   //
 282 //   //
 283 //   // coord - type of coordinate
 284 //   //       - 0 -X
 285 //   //         1 -Y
 286 //   //         2 -Z
 287 //   //         3 -R
 288 //   //         4 -RPhi
 289 //   if (!fIsActive) return 0;
 290 //   if (fBitMask && (!(*fBitMask)[volID])) return 0;
 291 //   Double_t xyz[5]={x,y,z, param,volID};
 292 //   if (fCoordSystem==0){
 293 //     // cartezian system
 294 //     if (coord==0 && fFormulaX) return fFormulaX(xyz,fFixedParam->GetMatrixArray());
 295 //     if (coord==1 && fFormulaY) return fFormulaY(xyz,fFixedParam->GetMatrixArray());
 296 //     if (coord==2 && fFormulaZ) return fFormulaZ(xyz,fFixedParam->GetMatrixArray());
 297 //   }
 298 //   if (fCoordSystem==1){
 299 //     // cylindrical system
 300 //     if (coord==2) {
 301 //       if (fFormulaZ==0) return 0;
 302 //       return fFormulaZ(xyz,fFixedParam->GetMatrixArray());
 303 //     }
 304 //     Double_t rrphiz[3]={0,0,0};
 305 //     if (fFormulaX) rrphiz[0] = fFormulaX(xyz,fFixedParam->GetMatrixArray());
 306 //     if (fFormulaY) rrphiz[1] = fFormulaY(xyz,fFixedParam->GetMatrixArray());
 307 //     Double_t alpha = TMath::ATan2(y,x);
 308 //     Double_t ca    = TMath::Cos(alpha);
 309 //     Double_t sa    = TMath::Sin(alpha);
 310 //     if (coord==0) return ca*rrphiz[0]-sa*rrphiz[1];
 311 //     if (coord==1) return sa*rrphiz[0]+ca*rrphiz[1];
 312 //   }
 313 //   return 0;
 314 // }
 315
 316
 317 Double_t AliTPCTransformation::GetDeltaXYZ(Int_t coord, Int_t volID, Double_t param, Double_t x, Double_t y, Double_t z){
 318   //
 319   //
 320   // coord - type of coordinate
 321   //       - 0 -X
 322   //         1 -Y
 323   //         2 -Z
 324   //         3 -R
 325   //         4 -RPhi
 326   //         5 -Z
 327   if (!fIsActive) return 0;
 328   if (fBitMask && (!(*fBitMask)[volID])) return 0;
 329   Double_t xyz[5]={x,y,z, param,volID};
 330   Double_t alpha = TMath::ATan2(y,x);
 331   Double_t ca    = TMath::Cos(alpha);
 332   Double_t sa    = TMath::Sin(alpha);
 333
 334   if (fCoordSystem==0){
 335     // cartezian system
 336     Double_t dxdydz[3]={0,0,0};
 337     if(fFormulaX) dxdydz[0]=fFormulaX(xyz,fFixedParam->GetMatrixArray());
 338     if(fFormulaY) dxdydz[1]=fFormulaY(xyz,fFixedParam->GetMatrixArray());
 339     if(fFormulaZ) dxdydz[2]=fFormulaZ(xyz,fFixedParam->GetMatrixArray());
 340
 341     if (coord==0) return dxdydz[0];
 342     if (coord==1) return dxdydz[1];
 343     if (coord==2) return dxdydz[2];
 344     if (coord==3) return dxdydz[0]*ca+dxdydz[1]*sa;
 345     if (coord==4) return -dxdydz[0]*sa+dxdydz[1]*ca;
 346     if (coord==5) return dxdydz[2];
 347   }
 348   if (fCoordSystem==1){
 349     // cylindrical system
 350     if (coord==2||coord==5) {
 351       if (fFormulaZ==0) return 0;
 352       return fFormulaZ(xyz,fFixedParam->GetMatrixArray());
 353     }
 354     Double_t rrphiz[3]={0,0,0};
 355     if (fFormulaX) rrphiz[0] = fFormulaX(xyz,fFixedParam->GetMatrixArray());
 356     if (fFormulaY) rrphiz[1] = fFormulaY(xyz,fFixedParam->GetMatrixArray());
 357     alpha = TMath::ATan2(y,x);
 358     ca    = TMath::Cos(alpha);
 359     sa    = TMath::Sin(alpha);
 360     if (coord==0) return ca*rrphiz[0]-sa*rrphiz[1];
 361     if (coord==1) return sa*rrphiz[0]+ca*rrphiz[1];
 362     if (coord==3) return rrphiz[0];
 363     if (coord==4) return rrphiz[1];
 364   }
 365   return 0;
 366 }
 367
 368
 369
 370 Double_t  AliTPCTransformation::TPCscalingRPol(Double_t *xyz, const Double_t * const param){
 371   //
 372   // Scaling and shift of TPC radius
 373   // xyz[0..2] - global xyz of point
 374   // xyz[3]    - scale parameter
 375   // param[0]  - radial scaling power
 376   // param[1]  - drift  scaling power
 377   // radius  from -1(at rInner)   to 1 (rOuter)
 378   // driftM  from -1(at 0 drift)  to 1 (250 cm drift)
 379
 380   Double_t rInner=78.8;
 381   Double_t rOuter=258.0;
 382   Double_t deltaR  = rOuter-rInner;
 383   Double_t radius  = (TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1])-rInner)*2./deltaR;
 384   Double_t driftM  = (0.5 - TMath::Abs(xyz[2]/250.))*2.0;
 385   Double_t delta   = TMath::Power(radius,param[0])*TMath::Power(driftM,param[1]);
 386   return delta*xyz[3];
 387 }
 388
 389
 390 Double_t  AliTPCTransformation::TPCscalingZDrift(Double_t *xyz, const Double_t * const param){
 391   //
 392   //
 393   // Scaling and shift of TPC radius
 394   // xyz[0..2] - global xyz of point
 395   // xyz[3]    - scale parameter
 396   Double_t driftP  = TMath::Power(1. - TMath::Abs(xyz[2]/250.), param[0]);
 397   Int_t    sector = TMath::Nint(xyz[4]);
 398   Double_t deltaZ  = (sector%36<18) ? -driftP : driftP;
 399   return deltaZ*xyz[3];
 400 }
 401
 402 Double_t  AliTPCTransformation::TPCscalingZDriftT0(Double_t *xyz, const Double_t * const /*param*/){
 403   //
 404   //
 405   // Z shift because time 0 offset
 406   // opposite on A and C side
 407   //
 408   // xyz[0..2] - global xyz of point
 409   // xyz[3]    - scale parameter
 410   Int_t    sector = TMath::Nint(xyz[4]);
 411   Double_t sign  = (sector%36<18) ? -1 : 1;
 412   return sign*xyz[3];
 413 }
 414
 415
 416 Double_t  AliTPCTransformation::TPCscalingZDriftGy(Double_t *xyz, const Double_t * const param){
 417   //
 418   //
 419   // Scaling and shift of TPC radius
 420   // xyz[0..2] - global xyz of point
 421   // xyz[3]    - scale parameter
 422   Double_t driftP  = TMath::Power(1. - TMath::Abs(xyz[2]/250.), param[0]);
 423   Double_t gy      = xyz[1]/250.;
 424   Int_t    sector = TMath::Nint(xyz[4]);
 425   Double_t deltaZ  = (sector%36<18) ? -driftP : driftP;
 426   return deltaZ*xyz[3]*gy;
 427 }
 428
 429
 430
 431 Double_t  AliTPCTransformation::TPCscalingPhiLocal(Double_t *xyz, const Double_t * const param){
 432   //
 433   //
 434   // Scaling if the local y -phi
 435   // xyz[0..2] - global xyz of point
 436   // xyz[3]    - scale parameter
 437   // value = 1 for ful drift length and parameter 1
 438   Double_t alpha       = TMath::ATan2(xyz[1],xyz[0]);
 439   Double_t sector      = TMath::Nint(9*alpha/TMath::Pi()-0.5);
 440   Double_t localAlpha  = (alpha-(sector+0.5)*TMath::Pi()/9.);
 441   Double_t radius      = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1])/250.;
 442   //
 443   Double_t deltaAlpha  = radius*TMath::Power(2.*9.*localAlpha/TMath::Pi(),param[0]);
 444   return deltaAlpha*xyz[3];
 445 }
 446
 447 Double_t  AliTPCTransformation::TPClocalRPhiEdge(Double_t *xyz, const Double_t *const param){
 448   //
 449   //
 450   // Scaling if the local y -phi
 451   // xyz[0..2] - global xyz of point
 452   // xyz[3]    - scale parameter
 453   // param[0]  - dedge offset - should be around gap size/2.
 454   // param[1]  - dedge factor - should be around gap size/2.
 455   Double_t alpha       = TMath::ATan2(xyz[1],xyz[0]);
 456   Double_t sector      = TMath::Nint(9*alpha/TMath::Pi()-0.5);
 457   Double_t localAlpha  = (alpha-(sector+0.5)*TMath::Pi()/9.);
 458   Double_t radius      = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
 459   Double_t deltaAlpha  = TMath::Pi()/18.-TMath::Abs(localAlpha);
 460   Double_t distEdge    = (deltaAlpha*radius);
 461   Double_t factor      = 1./(1.+(distEdge-param[0])/param[1]);
 462   return factor*xyz[3]*((localAlpha>0)? -1.:1.);
 463 }
 464
 465
 466 Double_t       AliTPCTransformation::TPCscalingRIFC(Double_t *xyz, const Double_t * const param){
 467   //
 468   // inner field cage r distorion - proportinal to 1 over distance to the IFC
 469   // param[0] - drift polynom order
 470   // distortion at first pad row - is normalized to
 471   Double_t rInner=78.8;
 472   Double_t rFirst=85.2;
 473   Double_t deltaR  = rFirst-rInner;
 474   Double_t ndistR  = (TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1])-rInner)/deltaR;
 475   Double_t driftM  = (0.5 - TMath::Abs(xyz[2]/250.))*2.;
 476   Double_t value   = TMath::Power(driftM,param[0])/ndistR;
 477   return xyz[3]*value;
 478 }
 479
 480 Double_t       AliTPCTransformation::TPCscalingROFC(Double_t *xyz, const Double_t * const param){
 481   //
 482   // outer field cage r distorion - proportinal to 1 over distance to the OFC
 483   // param[0] - drift polynom order
 484   // driftM   - from -1 to 1
 485   //
 486   Double_t rLast=245.8;
 487   Double_t rOuter=258.0;
 488   Double_t deltaR  = rOuter-rLast;
 489   Double_t ndistR  = (rOuter-TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]))/deltaR;
 490   Double_t driftM  = (0.5 - TMath::Abs(xyz[2]/250.))*2.;
 491   Double_t value   = TMath::Power(driftM,param[0])/ndistR;
 492   return xyz[3]*value;
 493 }
 494
 495
 496 Double_t       AliTPCTransformation::TPCdeltaFCROC(Double_t *xyz, const Double_t *const param){
 497   //
 498   // delta R(Z) ROC induced
 499   // param[0] - switch  0 - use distance to IFC - 1 - distance to IFC
 500   // param[1] - kFC scaling factor  (multiplication factor  of (OFC-IFC))
 501   // param[2] - kROC scaling factor
 502   // parameters [1] and [2] should be obtained from the electric field
 503   //            simulation
 504   //
 505   Double_t rInner=78.8;
 506   Double_t rFirst=85.2;
 507   Double_t rLast=245.8;
 508   Double_t rOuter=258.0;
 509
 510   Double_t radius  = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
 511   //calculate distance to the FC - inner or outer
 512   Double_t deltaFC = (param[0]<0.5)? TMath::Abs(radius-rFirst) : TMath::Abs(radius-rLast);
 513   deltaFC/=(rOuter-rInner);
 514   Double_t scalingFC = 1./(1.+deltaFC/(param[1]));
 515   //
 516   Double_t drift = 1.-TMath::Abs(xyz[2]/250.);  // normalized drift length
 517   Double_t scalingROC = (1.-1./(1.+drift/param[2]));
 518   //
 519   return xyz[3]*scalingFC*scalingROC;
 520 }
 521
 522
 523 Double_t       AliTPCTransformation::TPCdeltaFCCE(Double_t *xyz, const Double_t *const param){
 524   //
 525   // delta R(Z) CE (central electrode) induced
 526   // param[0] - switch  0 - use distance to IFC - 1 - distance to IFC
 527   // param[1] - kFC scaling factor  (multiplication factor  of (OFC-IFC))
 528   // param[2] - kCE scaling factor
 529   // parameters [1] and [2] should be obtained from the electric field
 530   //            simulation
 531   Double_t rInner=78.8;
 532   Double_t rFirst=85.2;
 533   Double_t rLast =245.8;
 534   Double_t rOuter=258.0;
 535
 536   Double_t radius  = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
 537   //calculate distance to the FC - inner or outer
 538   Double_t deltaFC = (param[0]<0.5)? TMath::Abs(radius-rFirst) : TMath::Abs(radius-rLast);
 539   deltaFC/=(rOuter-rInner);
 540   Double_t scalingFC = 1./(1.+deltaFC/(param[1]));
 541   //
 542   Double_t drift     = 1.-TMath::Abs(xyz[2]/250.);  // normalized drift length
 543   Double_t scalingCE = 1/(1.+(1.-drift)/param[2]);  //
 544   //
 545   return xyz[3]*scalingFC*scalingCE;
 546 }
 547
 548
 549
 550
 551
 552
 553
 554 //
 555 // TPC sector local misalignment
 556 //
 557 //
 558 //
 559 Double_t AliTPCTransformation:: TPClocaldLxdGX(Double_t *xyz, const Double_t *const param){
 560   //
 561   // xyz - [0..2] - position
 562   //       [3]    - scale parameter
 563   //       [4]    - volID
 564   // param[0]= n  - cos(n *alpha)
 565   // param[1]= n  - sin(n *alpha)
 566   // param[2]     - indication - 0 - the same for IROC OROC 1 - opposite
 567   // return delta in global coordiante system
 568   //
 569   Int_t    sector = TMath::Nint(xyz[4]);
 570   Double_t alpha  = TMath::Pi()*(sector+0.5)/9;
 571   Double_t ca     = TMath::Cos(alpha);
 572   //  Double_t sa     = TMath::Sin(alpha);
 573   const Double_t xIROCOROC = 133.4;
 574   Double_t factor = xyz[3];
 575   if (param[0]>0)  factor*=TMath::Cos(alpha*param[0]);
 576   if (param[1]>0)  factor*=TMath::Sin(alpha*param[1]);
 577   if (param[2]>0.5 && TMath::Sqrt(xyz[1]*xyz[1]+xyz[0]*xyz[0])>xIROCOROC) factor*=-1;
 578   return ca*factor;
 579 }
 580
 581 Double_t AliTPCTransformation::TPClocaldLxdGY(Double_t *xyz, const Double_t *const param){
 582   //
 583   // xyz - [0..2] - position
 584   //       [3]    - scale parameter
 585   //       [4]    - volID
 586   // param[0]= n  - cos(n *alpha)
 587   // param[1]= n  - sin(n *alpha)
 588   // param[2]     - indication - 0 - the same for IROC OROC 1 - opposite
 589   // return delta in global coordiante system
 590   //
 591   Int_t    sector = TMath::Nint(xyz[4]);
 592   Double_t alpha  = TMath::Pi()*(sector+0.5)/9;
 593   //Double_t ca     = TMath::Cos(alpha);
 594   Double_t sa     = TMath::Sin(alpha);
 595   const Double_t xIROCOROC = 133.4;
 596   Double_t factor = xyz[3];
 597   if (param[0]>0)  factor*=TMath::Cos(alpha*param[0]);
 598   if (param[1]>0)  factor*=TMath::Sin(alpha*param[1]);
 599   if (param[2]>0.5 && TMath::Sqrt(xyz[1]*xyz[1]+xyz[0]*xyz[0])>xIROCOROC) factor*=-1;
 600   return   sa*factor;
 601 }
 602
 603 Double_t AliTPCTransformation:: TPClocaldLydGX(Double_t *xyz, const Double_t *const param){
 604   //
 605   // xyz - [0..2] - position
 606   //       [3]    - scale parameter
 607   //       [4]    - volID
 608   // param[0]= n  - cos(n *alpha)
 609   // param[1]= n  - sin(n *alpha)
 610   // param[2]     - indication - 0 - the same for IROC OROC 1 - opposite
 611   // return delta in global coordiante system
 612   //
 613   Int_t    sector = TMath::Nint(xyz[4]);
 614   Double_t alpha  = TMath::Pi()*(sector+0.5)/9;
 615   //Double_t ca     = TMath::Cos(alpha);
 616   Double_t sa     = TMath::Sin(alpha);
 617   const Double_t xIROCOROC = 133.4;
 618   Double_t factor = xyz[3];
 619   if (param[0]>0)  factor*=TMath::Cos(alpha*param[0]);
 620   if (param[1]>0)  factor*=TMath::Sin(alpha*param[1]);
 621   if (param[2]>0.5 && TMath::Sqrt(xyz[1]*xyz[1]+xyz[0]*xyz[0])>xIROCOROC) factor*=-1;
 622   return            -sa*factor;
 623 }
 624
 625 Double_t AliTPCTransformation::TPClocaldLydGY(Double_t *xyz, const Double_t *const param){
 626   //
 627   // xyz - [0..2] - position
 628   //       [3]    - scale parameter
 629   //       [4]    - volID
 630   // param[0]= n  - cos(n *alpha)
 631   // param[1]= n  - sin(n *alpha)
 632   // param[2]     - indication - 0 - the same for IROC OROC 1 - opposite
 633   // return delta in global coordiante system
 634   //
 635   Int_t    sector = TMath::Nint(xyz[4]);
 636   Double_t alpha  = TMath::Pi()*(sector+0.5)/9;
 637   Double_t ca     = TMath::Cos(alpha);
 638   //Double_t sa     = TMath::Sin(alpha);
 639   const Double_t xIROCOROC = 133.4;
 640   Double_t factor = xyz[3];
 641   if (param[0]>0)  factor*=TMath::Cos(alpha*param[0]);
 642   if (param[1]>0)  factor*=TMath::Sin(alpha*param[1]);
 643   if (param[2]>0.5 && TMath::Sqrt(xyz[1]*xyz[1]+xyz[0]*xyz[0])>xIROCOROC) factor*=-1;
 644   return   ca*factor;
 645 }
 646
 647
 648 Double_t AliTPCTransformation::TPClocaldRzdGX(Double_t *xyz, const Double_t *const param){
 649   //
 650   // xyz - [0..2] - position
 651   //       [3]    - scale parameter - rotation angle in mrad
 652   //       [4]    - volID
 653   // param[0]= n  - cos(n *alpha)
 654   // param[1]= n  - sin(n *alpha)
 655   // param[2]     - indication - 0 - the same for IROC OROC 1 - opposite
 656   // return delta in global coordiante system
 657   //
 658   Int_t    sector = TMath::Nint(xyz[4]);
 659   Double_t alpha  = TMath::Pi()*(sector+0.5)/9;
 660   Double_t ca     = TMath::Cos(alpha);
 661   Double_t sa     = TMath::Sin(alpha);
 662   Double_t lx     =  xyz[0]*ca + xyz[1]*sa;
 663   Double_t ly     = -xyz[0]*sa + xyz[1]*ca;
 664   //
 665   const Double_t xIROCOROC = 133.4;
 666   lx-=xIROCOROC;
 667   Double_t rot      =  xyz[3]*0.001;    // rotation in mrad
 668   if (param[0]>0)  rot*=TMath::Cos(alpha*param[0]);
 669   if (param[1]>0)  rot*=TMath::Sin(alpha*param[1]);
 670   if (param[2]>0.5 && lx>0) rot*=-1;
 671   //
 672   Double_t dlxR     =  - ly*rot;
 673   Double_t dlyR     =    lx*rot;
 674   Double_t dgxR     =  dlxR*ca - dlyR*sa;
 675   //Double_t dgyR     =  dlxR*sa + dlyR*ca;
 676   return  dgxR;
 677 }
 678
 679 Double_t AliTPCTransformation::TPClocaldRzdGY(Double_t *xyz, const Double_t *const param){
 680   //
 681   // xyz - [0..2] - position
 682   //       [3]    - scale parameter - rotation angle in mrad
 683   //       [4]    - volID
 684   // param[0]= n  - cos(n *alpha)
 685   // param[1]= n  - sin(n *alpha)
 686   // param[2]     - indication - 0 - the same for IROC OROC 1 - opposite
 687   // return delta in global coordiante system
 688   //
 689   Int_t    sector = TMath::Nint(xyz[4]);
 690   Double_t alpha  = TMath::Pi()*(sector+0.5)/9;
 691   Double_t ca     = TMath::Cos(alpha);
 692   Double_t sa     = TMath::Sin(alpha);
 693   Double_t lx     =  xyz[0]*ca + xyz[1]*sa;
 694   Double_t ly     = -xyz[0]*sa + xyz[1]*ca;
 695   //
 696   const Double_t xIROCOROC = 133.4;
 697   lx-=xIROCOROC;
 698   Double_t rot      =  xyz[3]*0.001;    // rotation in mrad
 699   if (param[0]>0)  rot*=TMath::Cos(alpha*param[0]);
 700   if (param[1]>0)  rot*=TMath::Sin(alpha*param[1]);
 701   if (param[2]>0.5 && lx>0) rot*=-1;
 702   Double_t dlxR     =  - ly*rot;
 703   Double_t dlyR     =    lx*rot;
 704   //Double_t dgxR     =  dlxR*ca - dlyR*sa;
 705   Double_t dgyR     =  dlxR*sa + dlyR*ca;
 706   return  dgyR;
 707 }
 708
 709
 710
 711 Double_t        AliTPCTransformation::TPCDeltaZMediumLong(Double_t *xyz, Double_t * /*param*/){
 712   //
 713   // xyz - [0..2] - position
 714   //        [3]    - scale parameter
 715   //        [4]    - volID
 716   // return delta in global coordinate system
 717   //
 718   Int_t    sector = TMath::Nint(xyz[4]);
 719   Double_t signZ  = (sector%36<18) ? 1: -1;  // drift direction
 720   if    (sector<36) return 0;
 721   //
 722   const Double_t radiusLong = 198.1;
 723   //
 724   Double_t alpha  = TMath::Pi()*(sector+0.5)/9;
 725   Double_t ca     = TMath::Cos(alpha);
 726   Double_t sa     = TMath::Sin(alpha);
 727   Double_t lx     =  xyz[0]*ca + xyz[1]*sa;
 728   Double_t sign   = (lx<radiusLong) ? 1:-1;
 729   return xyz[3]*sign*signZ;
 730 }
 731
 732 Double_t        AliTPCTransformation::TPCDeltaZ(Double_t *xyz, const Double_t *const param){
 733   //
 734   // xyz - [0..2] - position
 735   //        [3]    - scale parameter
 736   //        [4]    - volID
 737   // return delta in global coordiante system
 738   //
 739   Int_t    sector = TMath::Nint(xyz[4]);
 740   Double_t delta  = (sector%36<18) ? 1: -1;  // drift direction
 741   Double_t alpha  = TMath::Pi()*(sector+0.5)/9;
 742   Double_t ca     = TMath::Cos(alpha);
 743   Double_t sa     = TMath::Sin(alpha);
 744   Double_t lx     =  xyz[0]*ca + xyz[1]*sa;
 745   //
 746   const Double_t xIROCOROC = 133.4;
 747   if (param[0]>0) delta     *= TMath::Cos(param[0]*alpha);
 748   if (param[1]>0) delta     *= TMath::Sin(param[1]*alpha);
 749   if (param[2]>0.5 && lx >xIROCOROC) delta *=-1;
 750   return delta*xyz[3];     // IROC shift
 751 }
 752
 753
 754 Double_t       AliTPCTransformation::TPCTiltingZ(Double_t *xyz, const Double_t *const param){
 755   // xyz - [0..2] - position
 756   //        [3]    - scale parameter
 757   //        [4]    - volID
 758   // param[0]      - n for cos
 759   // param[1]      - n for sin
 760   // param[2]      - IROC-ORC relative (if >0.5 )
 761   // return delta in global coordinate system
 762   const Double_t rFirst=85.2;
 763   const Double_t rLast =245.8;
 764   const Double_t xIROCOROC = 133.4;
 765   //
 766   Int_t    sector = TMath::Nint(xyz[4]);
 767   Double_t alpha  = TMath::Pi()*(sector+0.5)/9;
 768   Double_t ca     = TMath::Cos(alpha);
 769   Double_t sa     = TMath::Sin(alpha);
 770   Double_t lx     =  xyz[0]*ca + xyz[1]*sa;
 771   Double_t deltaR = 2.0*(lx-xIROCOROC)/(rLast-rFirst);
 772   if (param[0]>0) deltaR *= TMath::Cos(param[0]*alpha);
 773   if (param[1]>0) deltaR *= TMath::Sin(param[1]*alpha);
 774   if (param[2]>0.5 && lx >xIROCOROC) deltaR *=-1;
 775   return deltaR*xyz[3];
 776 }
 777