TPC/CalibMacros/RegisterCorrection.C

   1 /*
   2   marian.ivanov@cern.ch
   3   //
   4   Register primitive corrections: base functions for minimization:
   5   Id numbers are associated to given primitive corrections.
   6   See comments in the function headers.
   7   Used only for residuals minimization not in the reconstruction.
   8   File with all primitives expected to be in the current directory:
   9   filenames:
  10   TPCCorrectionPrimitives.root                  - Alignment, Quadrants, 2D symentrid and rod misalingment
  11   TPCCorrectionPrimitivesROC.root               - ExB distortion due to the common ROC misalignment
  12   TPCCorrectionPrimitivesSector.root            - ExB distortion due to the one sector misalingment (sector 0)
  13   TPCCorrectionPrimitivesFieldCage.root         - ExB distortion due to the Field cage missalignment
  14   //
  15
  16   RegisterCorrection();                         - Reserved id's  0 -999
  17   //
  18   RegisterAliTPCFCVoltError3D();                - Reserved id's  0 -99
  19   RegisterAliTPCBoundaryVoltError();            - Reserved id's  100-199
  20   RegisterAliTPCCalibGlobalMisalignment();      - Reserved id's  200-499
  21   RegisterAliTPCExBBShape();                    - Reserved id's  500-600
  22   RegisterAliTPCExBTwist();                     - Reserved id's  600-700
  23   RegisterAliTPCROCVoltError3D()                - Reserved id's  700-800
  24   RegisterAliTPCROCVoltError3DSector()          - Reserved id's  800-900
  25   .x ~/rootlogon.C
  26   .L $ALICE_ROOT/TPC/CalibMacros/RegisterCorrection.C+
  27   RegisterCorrection();
  28
  29 */
  30
  31 /*
  32  Example use:
  33  .x ~/rootlogon.C
  34  .L $ALICE_ROOT/PWGPP/CalibMacros/CPass0/ConfigCalibTrain.C
  35  ConfigCalibTrain(119037,"local:///cvmfs/alice.gsi.de/alice/data/2010/OCDB/")
  36
  37  .L $ALICE_ROOT/TPC/CalibMacros/RegisterCorrection.C+
  38  RegisterCorrection(0);
  39
  40  //See example usage of correction primitive/derivatives in file
  41
  42
  43 */
  44
  45
  46 #if !defined(__CINT__) || defined(__MAKECINT__)
  47 #include "TFile.h"
  48 #include "TObjArray.h"
  49 #include "TTreeStream.h"
  50 #include "TMath.h"
  51 #include "TGraph.h"
  52 #include "TRandom.h"
  53 #include "TTree.h"
  54 #include "TF1.h"
  55 #include "TH2F.h"
  56 #include "TH3F.h"
  57 #include "TAxis.h"
  58 #include "TPad.h"
  59 #include "TCanvas.h"
  60 #include "TStyle.h"
  61 #include "AliTPCParamSR.h"
  62 #include "TDatabasePDG.h"
  63 #include "AliTPCCorrection.h"
  64 #include "AliTPCFCVoltError3D.h"
  65 #include "AliTPCROCVoltError3D.h"
  66 #include "AliTPCComposedCorrection.h"
  67 #include "AliTPCBoundaryVoltError.h"
  68 #include "AliTPCCalibGlobalMisalignment.h"
  69 #include "AliTPCExBBShape.h"
  70 #include "AliTPCExBTwist.h"
  71 #include "AliTPCCorrectionDrift.h"
  72 #include "AliMagF.h"
  73 #include "AliCDBEntry.h"
  74 #include "AliTPCROC.h"
  75 #include <TStatToolkit.h>
  76 #include "TCut.h"
  77 #include "TGraphErrors.h"
  78 #include  "AliTrackerBase.h"
  79 #include  "TGeoGlobalMagField.h"
  80 #include  "TROOT.h"
  81 #include "TLinearFitter.h"
  82 #include "TStopwatch.h"
  83 #include "AliTPCCorrectionFit.h"
  84 #endif
  85
  86
  87
  88
  89 TFile *fCorrections=0;                         //file with corrections
  90 //
  91 //models E field distortion   AliTPCFCVoltError3D
  92 //
  93 AliTPCFCVoltError3D *rotOFC  =0;     // fit models
  94 AliTPCFCVoltError3D *rodOFC1 =0;
  95 AliTPCFCVoltError3D *rodOFC2 =0;
  96 AliTPCFCVoltError3D *rotIFC  =0;
  97 AliTPCFCVoltError3D *rodIFC1 =0;
  98 AliTPCFCVoltError3D *rodIFC2 =0;
  99 //
 100 AliTPCFCVoltError3D *rodIFCShift=0;     //common IFC shift
 101 AliTPCFCVoltError3D *rodIFCSin=0;       //common IFC shift -sinus
 102 AliTPCFCVoltError3D *rodOFCSin=0;       //common OFC shift -sinus
 103 AliTPCFCVoltError3D *rodOFCShift=0;     //common OFC shift
 104 AliTPCFCVoltError3D *rodIFCCos=0;       //common IFC shift -cos
 105 AliTPCFCVoltError3D *rodOFCCos=0;       //common OFC shift -cos
 106 //
 107 TObjArray  *rodFCSideRadiusType=0;  // field cage shift, A/C side, OFC/IFC, Fourier(const,sin,cos)
 108 //
 109
 110
 111
 112 AliTPCROCVoltError3D *rocRotgXA=0;     // roc rotation A side - inclination in X
 113 AliTPCROCVoltError3D *rocRotgYA=0;     // roc rotation A side - inclination in Y
 114 AliTPCROCVoltError3D *rocRotgXC=0;     // roc rotation C side - inclination in X
 115 AliTPCROCVoltError3D *rocRotgYC=0;     // roc rotation C side - inclination in Y
 116 //
 117 AliTPCROCVoltError3D *rocDzIROCA=0;      // roc shift A side - in Z
 118 AliTPCROCVoltError3D *rocDzIROCC=0;      // roc shift C side - in Z
 119 AliTPCROCVoltError3D *rocRotIROCA=0;      // roc rotation A side - in Z
 120 AliTPCROCVoltError3D *rocRotIROCC=0;      // roc rotation C side - in Z
 121 AliTPCROCVoltError3D *rocDzUDA=0;         // roc shift Up-Down A side
 122 AliTPCROCVoltError3D *rocDzUDC=0;         // roc shift Up-Down C side
 123 AliTPCROCVoltError3D *rocRotUDA=0;        // roc rotation updown A side
 124 AliTPCROCVoltError3D *rocRotUDC=0;        // roc rotation updown C side
 125
 126 //
 127 AliTPCROCVoltError3D *rocShiftIROCA0=0;      // IROC shift A0 side
 128 AliTPCROCVoltError3D *rocRotIROCA0=0;        // IROC rot   A0 side
 129 AliTPCROCVoltError3D *rocShiftOROCA0=0;      // OROC shift A0 side
 130 AliTPCROCVoltError3D *rocRotOROCA0=0;        // OROC rot   A0 side
 131 AliTPCROCVoltError3D *rocShiftIROCC0=0;      // IROC shift C0 side
 132 AliTPCROCVoltError3D *rocRotIROCC0=0;        // IROC rot   C0 side
 133 AliTPCROCVoltError3D *rocShiftOROCC0=0;      // OROC shift C0 side
 134 AliTPCROCVoltError3D *rocRotOROCC0=0;        // OROC rot   C0 side
 135 //
 136 //
 137 //
 138 AliTPCBoundaryVoltError *boundaryVoltErrorA[8];  // boundary voltage error A side
 139 AliTPCBoundaryVoltError *boundaryVoltErrorC[8];  // boundary voltage error C side
 140 AliTPCExBBShape *exbShape     = 0;               // nominal correctin
 141 AliTPCExBBShape *exbShapeT1X  = 0;               // nominal +deltaT1=0.1
 142 AliTPCExBBShape *exbShapeT2X  = 0;               // nominal +deltaT2=0.1
 143 AliTPCExBTwist  *twistX    = 0;
 144 AliTPCExBTwist  *twistY    = 0;
 145 //
 146 AliTPCCalibGlobalMisalignment *alignRot0=0;
 147 AliTPCCalibGlobalMisalignment *alignRot1=0;
 148 AliTPCCalibGlobalMisalignment *alignRot2=0;
 149 AliTPCCalibGlobalMisalignment *alignTrans0=0;
 150 AliTPCCalibGlobalMisalignment *alignTrans1=0;
 151 AliTPCCalibGlobalMisalignment *alignTrans2=0;
 152 //
 153 AliTPCCalibGlobalMisalignment *alignTrans0D[4]={0};       // delta alignemnt 4 quadrants
 154 AliTPCCalibGlobalMisalignment *alignTrans1D[4]={0};       //
 155 AliTPCCalibGlobalMisalignment *alignTrans2D[4]={0};       //
 156 AliTPCCalibGlobalMisalignment *alignRot0D[4]={0};
 157 AliTPCCalibGlobalMisalignment *alignRot1D[4]={0};
 158 AliTPCCalibGlobalMisalignment *alignRot2D[4]={0};
 159
 160
 161
 162
 163 AliTPCCorrectionDrift  *calibDrift[7]={0};
 164
 165
 166 //
 167 void RegisterAliTPCFCVoltError3D();
 168 void RegisterAliTPCCalibGlobalMisalignment();
 169 void RegisterAliTPCBoundaryVoltError();
 170 void RegisterAliTPCExBShape();
 171 void RegisterAliTPCExBTwist();
 172 void RegisterAliTPCROCVoltError3D();
 173 void RegisterAliTPCROCVoltError3DSector();
 174 void RegisterAliTPCCorrectionDrift();
 175 void RegisterAliTPCFCVoltError3DRodFCSideRadiusType();
 176 //
 177
 178 void RegisterCorrection(Int_t type=0){
 179   //
 180   //
 181   //
 182   // check the presence of corrections in file
 183   //
 184   //gROOT->Macro("ConfigCalibTrain.C(119037)");
 185   //
 186   //
 187   if (type==1) return RegisterAliTPCROCVoltError3D();            // 3D distortion due misalignemnt of FC ....
 188   if (type==2) return RegisterAliTPCROCVoltError3DSector();      // 3D distortion due misalingment of Sectors
 189   if (type==4) return RegisterAliTPCFCVoltError3DRodFCSideRadiusType();
 190   //
 191   if (type==3) {                                                 // 2D distortions
 192     fCorrections = TFile::Open("TPCCorrectionPrimitives.root","recreate");
 193     RegisterAliTPCCalibGlobalMisalignment();
 194     RegisterAliTPCBoundaryVoltError();
 195     RegisterAliTPCFCVoltError3D();
 196     RegisterAliTPCExBShape();
 197     RegisterAliTPCExBTwist();
 198     RegisterAliTPCCorrectionDrift();
 199     fCorrections->Close();
 200     delete fCorrections;
 201     return;
 202   }
 203   fCorrections = TFile::Open("TPCCorrectionPrimitives.root");
 204   AliTPCComposedCorrection *corrField3D = (AliTPCComposedCorrection*) fCorrections->Get("TPCFCVoltError3D");
 205   // if not make new file
 206   if (!corrField3D) fCorrections = TFile::Open("TPCCorrectionPrimitives.root","update");
 207   if (type==0) {
 208     RegisterAliTPCROCVoltError3D();
 209     RegisterAliTPCROCVoltError3DSector();
 210     RegisterAliTPCFCVoltError3DRodFCSideRadiusType();
 211   }
 212   RegisterAliTPCCalibGlobalMisalignment();
 213   RegisterAliTPCBoundaryVoltError();
 214   RegisterAliTPCFCVoltError3D();
 215   RegisterAliTPCExBShape();
 216   RegisterAliTPCExBTwist();
 217   RegisterAliTPCCorrectionDrift();
 218   if (fCorrections) fCorrections->Close();
 219   //
 220 }
 221
 222
 223
 224 void RegisterAliTPCFCVoltError3D(){
 225   //
 226   // Load the models from the file
 227   // Or create it
 228   // Register functions with following IDs:
 229   // IMPORTANT: The nominal shift is in mm
 230   //
 231   //  rotOFC  - 0
 232   //  rodOFC1 - 1
 233   //  rodOFC2 - 2
 234   //  rotIFC  - 3
 235   //  rodIFC1 - 4
 236   //  rodIFC2 - 5
 237   //  rodIFCShift - 6
 238   //  rodIFCSin   - 7
 239   //  rodIFCCos   - 8
 240   //  rodOFCShift - 9
 241   //  rodOFCSin   - 10
 242   //  rodOFCCos   - 11
 243   //
 244   printf("RegisterAliTPCFCVoltError3D()");
 245   Int_t volt = 40; // 40 V ~  1mm
 246   AliTPCComposedCorrection *corrField3D = (AliTPCComposedCorrection*) fCorrections->Get("TPCFCVoltError3D");
 247   if (corrField3D) { // load form file
 248     corrField3D->Print();
 249     TCollection *iter = corrField3D->GetCorrections();
 250     rotOFC = (AliTPCFCVoltError3D*)iter->FindObject("rotOFC");
 251     rodOFC1 = (AliTPCFCVoltError3D*)iter->FindObject("rodOFC1");
 252     rodOFC2 = (AliTPCFCVoltError3D*)iter->FindObject("rodOFC2");
 253     rotIFC = (AliTPCFCVoltError3D*)iter->FindObject("rotIFC");
 254     rodIFC1 = (AliTPCFCVoltError3D*)iter->FindObject("rodIFC1");
 255     rodIFC2 = (AliTPCFCVoltError3D*)iter->FindObject("rodIFC2");
 256     //
 257     rodIFCShift = (AliTPCFCVoltError3D*)iter->FindObject("rodIFCShift");
 258     rodOFCShift = (AliTPCFCVoltError3D*)iter->FindObject("rodOFCShift");
 259     rodIFCSin = (AliTPCFCVoltError3D*)iter->FindObject("rodIFCSin");
 260     rodOFCSin = (AliTPCFCVoltError3D*)iter->FindObject("rodOFCSin");
 261     rodIFCCos = (AliTPCFCVoltError3D*)iter->FindObject("rodIFCCos");
 262     rodOFCCos = (AliTPCFCVoltError3D*)iter->FindObject("rodOFCCos");
 263   } else {
 264     // OFC
 265     rotOFC = new AliTPCFCVoltError3D();
 266     rotOFC->SetOmegaTauT1T2(0,1,1);
 267     rotOFC->SetRotatedClipVoltA(1,volt);
 268     rotOFC->SetRotatedClipVoltC(1,volt);
 269     //
 270     rodOFC1 = new AliTPCFCVoltError3D();
 271     rodOFC1->SetOmegaTauT1T2(0,1,1);
 272     rodOFC1->SetRodVoltShiftA(18,volt);
 273     rodOFC1->SetRodVoltShiftC(18,volt);
 274     //
 275     rodOFC2 = new AliTPCFCVoltError3D();
 276     rodOFC2->SetOmegaTauT1T2(0,1,1);
 277     rodOFC2->SetCopperRodShiftA(18,volt);
 278     rodOFC2->SetCopperRodShiftC(18,volt);
 279     // IFC
 280     rotIFC = new AliTPCFCVoltError3D();
 281     rotIFC->SetOmegaTauT1T2(0,1,1);
 282     rotIFC->SetRotatedClipVoltA(0,volt);
 283     rotIFC->SetRotatedClipVoltC(0,volt);
 284     //
 285     rodIFC1 = new AliTPCFCVoltError3D();
 286     rodIFC1->SetOmegaTauT1T2(0,1,1);
 287     rodIFC1->SetRodVoltShiftA(0,volt);
 288     rodIFC1->SetRodVoltShiftC(0,volt);
 289     //
 290     rodIFC2 = new AliTPCFCVoltError3D();
 291     rodIFC2->SetOmegaTauT1T2(0,1,1);
 292     rodIFC2->SetCopperRodShiftA(0,volt);
 293     rodIFC2->SetCopperRodShiftC(0,volt);
 294     //
 295     rodIFCShift = new AliTPCFCVoltError3D();
 296     rodIFCSin = new AliTPCFCVoltError3D();
 297     rodIFCCos = new AliTPCFCVoltError3D();
 298     rodOFCShift = new AliTPCFCVoltError3D();
 299     rodOFCSin = new AliTPCFCVoltError3D();
 300     rodOFCCos = new AliTPCFCVoltError3D();
 301     for (Int_t isec=0; isec<18; isec++){
 302       Double_t phi=TMath::Pi()*isec/9.;
 303       rodIFCShift->SetOmegaTauT1T2(0,1,1);
 304       rodIFCShift->SetRodVoltShiftA(isec,volt);
 305       rodIFCShift->SetRodVoltShiftC(isec,volt);
 306       rodIFCSin->SetOmegaTauT1T2(0,1,1);
 307       rodIFCSin->SetRodVoltShiftA(isec,volt*TMath::Sin(phi));
 308       rodIFCSin->SetRodVoltShiftC(isec,volt*TMath::Sin(phi));
 309       rodIFCCos->SetOmegaTauT1T2(0,1,1);
 310       rodIFCCos->SetRodVoltShiftA(isec,volt*TMath::Cos(phi));
 311       rodIFCCos->SetRodVoltShiftC(isec,volt*TMath::Cos(phi));
 312       //
 313       rodOFCShift->SetOmegaTauT1T2(0,1,1);
 314       rodOFCShift->SetRodVoltShiftA(18+isec,volt);
 315       rodOFCShift->SetRodVoltShiftC(18+isec,volt);
 316       rodOFCSin->SetOmegaTauT1T2(0,1,1);
 317       rodOFCSin->SetRodVoltShiftA(18+isec,volt*TMath::Sin(phi));
 318       rodOFCSin->SetRodVoltShiftC(18+isec,volt*TMath::Sin(phi));
 319       rodOFCCos->SetOmegaTauT1T2(0,1,1);
 320       rodOFCCos->SetRodVoltShiftA(18+isec,volt*TMath::Cos(phi));
 321       rodOFCCos->SetRodVoltShiftC(18+isec,volt*TMath::Cos(phi));
 322     }
 323     //
 324     //
 325     // Initialization of the lookup tables
 326     //
 327     printf(" ------- OFC rotated clip:\n"); rotOFC->InitFCVoltError3D();
 328     printf(" ------- OFC rod & strip:\n");  rodOFC1->InitFCVoltError3D();
 329     printf(" ------- OFC copper rod:\n");   rodOFC2->InitFCVoltError3D();
 330     printf(" ------- IFC rotated clip:\n"); rotIFC->InitFCVoltError3D();
 331     printf(" ------- IFC rod & strip:\n");  rodIFC1->InitFCVoltError3D();
 332     printf(" ------- IFC copper rod:\n");   rodIFC2->InitFCVoltError3D();
 333
 334     printf(" ------- IFC rod & strip shift:\n");  rodIFCShift->InitFCVoltError3D();
 335     printf(" ------- IFC rod & strip sin:\n");    rodIFCSin->InitFCVoltError3D();
 336     printf(" ------- IFC rod & strip cos:\n");    rodIFCCos->InitFCVoltError3D();
 337     printf(" ------- OFC rod & strip shift:\n");  rodOFCShift->InitFCVoltError3D();
 338     printf(" ------- OFC rod & strip sin:\n");    rodOFCSin->InitFCVoltError3D();
 339     printf(" ------- OFC rod & strip cos:\n");    rodOFCCos->InitFCVoltError3D();
 340
 341     // give names
 342     rotOFC->SetName("rotOFC");rotOFC->SetTitle("rotOFC");
 343     rodOFC1->SetName("rodOFC1");rodOFC1->SetTitle("rodOFC1");
 344     rodOFC2->SetName("rodOFC2");rodOFC2->SetTitle("rodOFC2");
 345     rotIFC->SetName("rotIFC");rotIFC->SetTitle("rotIFC");
 346     rodIFC1->SetName("rodIFC1");rodIFC1->SetTitle("rodIFC1");
 347     rodIFC2->SetName("rodIFC2");rodIFC2->SetTitle("rodIFC2");
 348     //
 349     rodIFCShift->SetName("rodIFCShift");rodIFCShift->SetTitle("rodIFCShift");
 350     rodIFCSin->SetName("rodIFCSin");rodIFCSin->SetTitle("rodIFCSin");
 351     rodIFCCos->SetName("rodIFCCos");rodIFCCos->SetTitle("rodIFCCos");
 352     //
 353     rodOFCShift->SetName("rodOFCShift");rodOFCShift->SetTitle("rodOFCShift");
 354     rodOFCSin->SetName("rodOFCSin");rodOFCSin->SetTitle("rodOFCSin");
 355     rodOFCCos->SetName("rodOFCCos");rodOFCCos->SetTitle("rodOFCCos");
 356     //
 357     // save in file
 358     corrField3D = new AliTPCComposedCorrection();
 359     TObjArray *cs = new TObjArray();
 360     cs->Add(rotIFC); cs->Add(rotOFC);
 361     cs->Add(rodIFC1); cs->Add(rodOFC1);
 362     cs->Add(rodIFC2); cs->Add(rodOFC2);
 363     cs->Add(rodIFCShift);    cs->Add(rodIFCSin);    cs->Add(rodIFCCos);
 364     cs->Add(rodOFCShift);    cs->Add(rodOFCSin);    cs->Add(rodOFCCos);
 365     //
 366     corrField3D->SetCorrections(cs);
 367     corrField3D->SetOmegaTauT1T2(0,1.,1.);
 368     corrField3D->Print();
 369     fCorrections->cd();
 370     corrField3D->Write("TPCFCVoltError3D");
 371   }
 372   //
 373   AliTPCCorrection::AddVisualCorrection(rotOFC,0);
 374   AliTPCCorrection::AddVisualCorrection(rodOFC1,1);
 375   AliTPCCorrection::AddVisualCorrection(rodOFC2,2);
 376   AliTPCCorrection::AddVisualCorrection(rotIFC,3);
 377   AliTPCCorrection::AddVisualCorrection(rodIFC1,4);
 378   AliTPCCorrection::AddVisualCorrection(rodIFC2,5);
 379   // common corrections
 380   //
 381   AliTPCCorrection::AddVisualCorrection(rodIFCShift,6);
 382   AliTPCCorrection::AddVisualCorrection(rodIFCSin,7);
 383   AliTPCCorrection::AddVisualCorrection(rodIFCCos,8);
 384   //
 385   AliTPCCorrection::AddVisualCorrection(rodOFCShift,9);
 386   AliTPCCorrection::AddVisualCorrection(rodOFCSin,10);
 387   AliTPCCorrection::AddVisualCorrection(rodOFCCos,11);
 388 }
 389
 390
 391 void RegisterAliTPCFCVoltError3DRodFCSideRadiusType(){
 392   //
 393   // Load the models from the file
 394   // Or create it
 395   // Register functions with following IDs:
 396   // IMPORTANT: The nominal shift is in mm
 397   //
 398   // naming convention:
 399   // rodFCSide%dRadius%dType%d
 400   //
 401   ::Info("RegisterAliTPCFCVoltError3DRodFCSideRadiusType()","Start");
 402   Int_t volt = 40; // 40 V ~  1mm
 403   TFile * fCorrectionsRodFCSideRadiusType = TFile::Open("TPCCorrectionPrimitivesFieldCage.root","update");
 404   if (!fCorrectionsRodFCSideRadiusType)  fCorrectionsRodFCSideRadiusType = TFile::Open("TPCCorrectionPrimitivesFieldCage.root","recreate");
 405   rodFCSideRadiusType= new TObjArray(100);
 406   //
 407   AliTPCComposedCorrection *corrFieldCage = (AliTPCComposedCorrection*) fCorrectionsRodFCSideRadiusType->Get("TPCRodFCSideRadiusType");
 408   if (corrFieldCage) { // load from file
 409     TCollection *corrections = corrFieldCage->GetCorrections();
 410     for (Int_t itype=0; itype<3; itype++){
 411       for (Int_t iside=0; iside<2; iside++){
 412         for (Int_t ifc=0; ifc<2; ifc++){
 413           Int_t id=4*itype+2*iside+ifc;
 414           AliTPCFCVoltError3D *corr =  (AliTPCFCVoltError3D *)corrections->FindObject(TString::Format("rodFCSide%dRadius%dType%d",iside,ifc,itype).Data());
 415           rodFCSideRadiusType->AddLast(corr);
 416           ::Info("Read AliTPCFCVoltError3DRodFCSideRadiusType", TString::Format("Init: rodFCSide%dRadius%dType%d\tId=%d",iside,ifc,itype,900+id).Data());
 417           AliTPCCorrection::AddVisualCorrection(corr,900+id);
 418         }
 419       }
 420     }
 421     corrFieldCage->Print();
 422   } else {
 423     for (Int_t itype=0; itype<3; itype++){
 424       for (Int_t iside=0; iside<2; iside++){
 425         for (Int_t ifc=0; ifc<2; ifc++){
 426           Int_t id=4*itype+2*iside+ifc;
 427           AliTPCFCVoltError3D *corr =  new AliTPCFCVoltError3D();
 428           corr->SetName(TString::Format("rodFCSide%dRadius%dType%d",iside,ifc,itype).Data());
 429           corr->SetTitle(TString::Format("rodFCSide%dRadius%dType%d",iside,ifc,itype).Data());
 430           //
 431           for (Int_t isec=0; isec<18; isec++){
 432             Double_t phi=TMath::Pi()*isec/9.;
 433             Int_t sectorOffset=(ifc==0) ? 0:18;
 434             corr->SetOmegaTauT1T2(0,1,1);
 435             Double_t sectorVoltage=0;
 436             if (itype==0) sectorVoltage=volt;
 437             if (itype==1) sectorVoltage=volt*TMath::Sin(phi);
 438             if (itype==2) sectorVoltage=volt*TMath::Cos(phi);
 439             if (iside==0){
 440               corr->SetRodVoltShiftA(isec+sectorOffset,sectorVoltage);
 441             }
 442             if (iside==1){
 443               corr->SetRodVoltShiftC(isec+sectorOffset,sectorVoltage);
 444             }
 445           }
 446           rodFCSideRadiusType->AddLast(corr);
 447           ::Info("Generate AliTPCFCVoltError3DRodFCSideRadiusType", TString::Format("Init: rodFCSide%dRadius%dType%d",iside,ifc,itype).Data());
 448           corr->InitFCVoltError3D();
 449           AliTPCCorrection::AddVisualCorrection(corr,900+id);
 450         }
 451       }
 452     }
 453     //
 454     corrFieldCage = new AliTPCComposedCorrection();
 455     corrFieldCage->SetCorrections(rodFCSideRadiusType);
 456     corrFieldCage->SetOmegaTauT1T2(0,1.,1.);
 457
 458     corrFieldCage->Print();
 459     fCorrectionsRodFCSideRadiusType->cd();
 460     corrFieldCage->Write("TPCRodFCSideRadiusType");
 461   }
 462   fCorrectionsRodFCSideRadiusType->Close();
 463   ::Info("RegisterAliTPCFCVoltError3DRodFCSideRadiusType()","End");
 464 }
 465
 466
 467 void RegisterAliTPCCalibGlobalMisalignment(){
 468   //
 469   // Register primitive alignment components.
 470   // Linear conbination of primitev forulas used for fit
 471   // The nominal delta 1 mm in shift and 1 mrad in rotation
 472   // Primitive formulas registeren in AliTPCCoreection::AddvisualCorrection
 473   // 20 - deltaX
 474   // 21 - deltaY
 475   // 22 - deltaZ
 476   // 23 - rot0 (phi)
 477   // 24 - rot1 (theta)
 478   // 25 - rot2
 479   //
 480   printf("RegisterAliTPCCalibGlobalMisalignment()\n");
 481   TGeoHMatrix matrixX;
 482   TGeoHMatrix matrixY;
 483   TGeoHMatrix matrixZ;
 484   TGeoRotation rot0;
 485   TGeoRotation rot1;
 486   TGeoRotation rot2;  //transformation matrices
 487   TGeoRotation rot90;  //transformation matrices
 488   matrixX.SetDx(0.1); matrixY.SetDy(0.1); matrixZ.SetDz(0.1); //1 mm translation
 489   rot0.SetAngles(0.001*TMath::RadToDeg(),0,0);
 490   rot1.SetAngles(0,0.001*TMath::RadToDeg(),0);
 491   rot2.SetAngles(0,0,0.001*TMath::RadToDeg());
 492   //how to get rot02 ?
 493   rot90.SetAngles(0,90,0);
 494   rot2.MultiplyBy(&rot90,kTRUE);
 495   rot90.SetAngles(0,-90,0);
 496   rot2.MultiplyBy(&rot90,kFALSE);
 497   //
 498   alignRot0  =new  AliTPCCalibGlobalMisalignment;
 499   alignRot0->SetAlignGlobal(&rot0);
 500   alignRot0->SetName("alignRot0");
 501   alignRot1=new  AliTPCCalibGlobalMisalignment;
 502   alignRot1->SetAlignGlobal(&rot1);
 503   alignRot1->SetName("alignRot1");
 504   alignRot2=new  AliTPCCalibGlobalMisalignment;
 505   alignRot2->SetAlignGlobal(&rot2);
 506   alignRot2->SetName("alignRot2");
 507   //
 508   alignTrans0  =new  AliTPCCalibGlobalMisalignment;
 509   alignTrans0->SetAlignGlobal(&matrixX);
 510   alignTrans0->SetName("alignTrans0");
 511   alignTrans1=new  AliTPCCalibGlobalMisalignment;
 512   alignTrans1->SetAlignGlobal(&matrixY);
 513   alignTrans1->SetName("alignTrans1");
 514   alignTrans2=new  AliTPCCalibGlobalMisalignment;
 515   alignTrans2->SetAlignGlobal(&matrixZ);
 516   alignTrans2->SetName("alignTrans2");
 517   //
 518
 519
 520   alignRot0D[0]  =new  AliTPCCalibGlobalMisalignment;
 521   alignRot0D[0]->SetAlignGlobalDelta(&rot0);
 522   alignRot0D[0]->SetName("alignRot0D");
 523   alignRot1D[0]=new  AliTPCCalibGlobalMisalignment;
 524   alignRot1D[0]->SetAlignGlobalDelta(&rot1);
 525   alignRot1D[0]->SetName("alignRot1D");
 526   alignRot2D[0]=new  AliTPCCalibGlobalMisalignment;
 527   alignRot2D[0]->SetAlignGlobalDelta(&rot2);
 528   alignRot2D[0]->SetName("alignRot2D");
 529   //
 530   alignTrans0D[0]  =new  AliTPCCalibGlobalMisalignment;
 531   alignTrans0D[0]->SetAlignGlobalDelta(&matrixX);
 532   alignTrans0D[0]->SetName("alignTrans0D");
 533   alignTrans1D[0]=new  AliTPCCalibGlobalMisalignment;
 534   alignTrans1D[0]->SetAlignGlobalDelta(&matrixY);
 535   alignTrans1D[0]->SetName("alignTrans1D");
 536   alignTrans2D[0]=new  AliTPCCalibGlobalMisalignment;
 537   alignTrans2D[0]->SetAlignGlobalDelta(&matrixZ);
 538   alignTrans2D[0]->SetName("alignTrans2D");
 539
 540   TObjArray * arrayDX = new TObjArray(72);
 541   TObjArray * arrayDY = new TObjArray(72);
 542   TObjArray * arrayDPhi = new TObjArray(72);
 543   //
 544   // Up down A side
 545   //
 546   for (Int_t isec=0; isec<72; isec++){  //A side
 547     TGeoHMatrix *matrixDX = new TGeoHMatrix;
 548     TGeoHMatrix *matrixDY = new TGeoHMatrix;
 549     TGeoRotation *matrixDPhi= new TGeoRotation;
 550     arrayDX->AddAt(matrixDX,isec);
 551     arrayDY->AddAt(matrixDY,isec);
 552     arrayDPhi->AddAt(matrixDPhi,isec);
 553     if (isec%36<18) matrixDX->SetDx(isec%18<9?0.1:-0.1);
 554     if (isec%36<18) matrixDY->SetDy(isec%18<9?0.1:-0.1);
 555     if (isec%36<18) matrixDPhi->SetAngles((isec%18<9?0.001:-0.001)*TMath::RadToDeg(),0,0);
 556   }
 557   alignTrans0D[1]  =new  AliTPCCalibGlobalMisalignment;
 558   alignTrans0D[1]->SetName("alignTrans0UDA");
 559   alignTrans0D[1]->SetAlignSectors((TObjArray *)(arrayDX->Clone()));
 560   alignTrans1D[1]  =new  AliTPCCalibGlobalMisalignment;
 561   alignTrans1D[1]->SetName("alignTrans1UDA");
 562   alignTrans1D[1]->SetAlignSectors((TObjArray *)(arrayDY->Clone()));
 563   alignRot0D[1]  =new  AliTPCCalibGlobalMisalignment;
 564   alignRot0D[1]->SetName("alignRot0UDA");
 565   alignRot0D[1]->SetAlignSectors((TObjArray *)(arrayDPhi->Clone()));
 566   //
 567   // Uu-down C side
 568   //
 569   for (Int_t isec=0; isec<72; isec++){  //A side
 570     TGeoHMatrix *matrixDX = new TGeoHMatrix;
 571     TGeoHMatrix *matrixDY = new TGeoHMatrix;
 572     TGeoRotation *matrixDPhi= new TGeoRotation;
 573     arrayDX->AddAt(matrixDX,isec);
 574     arrayDY->AddAt(matrixDY,isec);
 575     arrayDPhi->AddAt(matrixDPhi,isec);
 576     if (isec%36>=18) matrixDX->SetDx(isec%18<9?0.1:-0.1);
 577     if (isec%36>=18) matrixDY->SetDy(isec%18<9?0.1:-0.1);
 578     if (isec%36>=18) matrixDPhi->SetAngles((isec%18<9?0.001:-0.001)*TMath::RadToDeg(),0,0);
 579   }
 580   alignTrans0D[2]  =new  AliTPCCalibGlobalMisalignment;
 581   alignTrans0D[2]->SetName("alignTrans0UDC");
 582   alignTrans0D[2]->SetAlignSectors((TObjArray *)(arrayDX->Clone()));
 583   alignTrans1D[2]  =new  AliTPCCalibGlobalMisalignment;
 584   alignTrans1D[2]->SetName("alignTrans1UDC");
 585   alignTrans1D[2]->SetAlignSectors((TObjArray *)(arrayDY->Clone()));
 586   alignRot0D[2]  =new  AliTPCCalibGlobalMisalignment;
 587   alignRot0D[2]->SetName("alignRot0UDC");
 588   alignRot0D[2]->SetAlignSectors((TObjArray *)(arrayDPhi->Clone()));
 589   //
 590
 591
 592   //
 593   AliTPCCorrection::AddVisualCorrection(alignTrans0  ,200);
 594   AliTPCCorrection::AddVisualCorrection(alignTrans1  ,201);
 595   AliTPCCorrection::AddVisualCorrection(alignTrans2  ,202);
 596   AliTPCCorrection::AddVisualCorrection(alignRot0    ,203);
 597   AliTPCCorrection::AddVisualCorrection(alignRot1    ,204);
 598   AliTPCCorrection::AddVisualCorrection(alignRot2    ,205);
 599
 600 }
 601
 602
 603 void RegisterAliTPCBoundaryVoltError(){
 604   //
 605   // Register phi symetric E filed distortions
 606   // 100-108 - A side 0 Field
 607   // 110-118 - C side 0 Field
 608   // 120-128 - A side +0.5 Field
 609   // 130-138 - C side +0.5 Field
 610   // 140-148 - A side -0.5 Field
 611   // 150-158 - C side -0.5 Field
 612   //
 613   Double_t vdrift = 2.64; // [cm/us]   // to be updated: per second (ideally)
 614   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
 615   Double_t T1 = 1.0;
 616   Double_t T2 = 1.0;
 617   Double_t wtP = -10.0 * (0.5*10) * vdrift /  ezField ;
 618   Double_t wtM = -10.0 * (0.5*10) * vdrift / -ezField ;
 619
 620   printf("RegisterAliTPCBoundaryVoltError()\n");
 621   AliTPCComposedCorrection *corrField2D = (AliTPCComposedCorrection*) fCorrections->Get("TPCFCVoltError2D");
 622   //
 623   if (!corrField2D){
 624     TObjArray *array=new TObjArray(16);
 625     Double_t val = 40.; // 1mm
 626     Float_t bound0[8] = { 0, 0,0,0,0,0,0,0};
 627     Float_t boundAi[8] = { 0, 0,0,0,0,0,0,0};
 628     Float_t boundCi[8] = { 0, 0,0,0,0,0,0,0};
 629     for (Int_t ipar=0; ipar<8; ipar++){
 630       //
 631       boundaryVoltErrorA[ipar] = new AliTPCBoundaryVoltError;
 632       boundaryVoltErrorC[ipar] = new AliTPCBoundaryVoltError;
 633       boundaryVoltErrorA[ipar]->SetName(Form("BoundaryVoltErrorAsidePar%d",ipar));
 634       boundaryVoltErrorA[ipar]->SetTitle(Form("BoundaryVoltErrorAsidePar%d",ipar));
 635       boundaryVoltErrorC[ipar]->SetName(Form("BoundaryVoltErrorCsidePar%d",ipar));
 636       boundaryVoltErrorC[ipar]->SetTitle(Form("BoundaryVoltErrorCsidePar%d",ipar));
 637       for (Int_t jpar=0; jpar<8; jpar++) if (ipar!=jpar){
 638         boundAi[jpar]=0;
 639         boundCi[jpar]=0;
 640       }
 641       boundAi[ipar]=val;
 642       boundCi[ipar]=val;
 643       //
 644       boundaryVoltErrorA[ipar]->SetBoundariesA(boundAi);
 645       boundaryVoltErrorA[ipar]->SetBoundariesC(bound0);
 646       boundaryVoltErrorA[ipar]->InitBoundaryVoltErrorDistortion();
 647       boundaryVoltErrorA[ipar]->SetOmegaTauT1T2(0.,1,1);
 648       //
 649       Float_t tempboundAi[8] = { 0, 0,0,0,0,0,-boundCi[6],-boundCi[7]};
 650       boundaryVoltErrorC[ipar]->SetBoundariesA(tempboundAi);
 651       boundaryVoltErrorC[ipar]->SetBoundariesC(boundCi);
 652
 653       boundaryVoltErrorC[ipar]->InitBoundaryVoltErrorDistortion();
 654       boundaryVoltErrorC[ipar]->SetOmegaTauT1T2(0.,1,1);
 655       array->AddAt(boundaryVoltErrorA[ipar],ipar);
 656       array->AddAt(boundaryVoltErrorC[ipar],ipar+8);
 657       boundaryVoltErrorA[ipar]->Print();
 658       boundaryVoltErrorC[ipar]->Print();
 659       AliTPCCorrection::AddVisualCorrection(boundaryVoltErrorA[ipar], 100+ipar);
 660       AliTPCCorrection::AddVisualCorrection(boundaryVoltErrorC[ipar], 150+ipar);
 661     }
 662     corrField2D = new AliTPCComposedCorrection;
 663     corrField2D->SetCorrections(array);
 664     corrField2D->SetOmegaTauT1T2(0,1.,1.);
 665     corrField2D->Print();
 666     fCorrections->cd();
 667     corrField2D->SetName("TPCFCVoltError2D");
 668     corrField2D->SetTitle("TPCFCVoltError2D");
 669     corrField2D->Write("TPCFCVoltError2D");
 670   }else{
 671     TObjArray *array = (TObjArray*)corrField2D->GetCorrections();
 672     for (Int_t ipar=0; ipar<8; ipar++){
 673       boundaryVoltErrorA[ipar] = (AliTPCBoundaryVoltError*) array->At(ipar);
 674       boundaryVoltErrorC[ipar] = (AliTPCBoundaryVoltError*) array->At(ipar+8);
 675     }
 676   }
 677   //
 678   // Register correction
 679   for (Int_t ipar=0; ipar<8; ipar++){
 680     AliTPCCorrection::AddVisualCorrection(boundaryVoltErrorA[ipar], 100+ipar);
 681     AliTPCCorrection::AddVisualCorrection(boundaryVoltErrorC[ipar], 110+ipar);
 682     //
 683     // correction for +-0.5 T setting
 684     AliTPCCorrection *corrField =0;
 685     corrField=(AliTPCCorrection *)boundaryVoltErrorA[ipar]->Clone();
 686     corrField->SetOmegaTauT1T2(wtP,T1,T2);
 687     AliTPCCorrection::AddVisualCorrection(corrField,120+ipar);
 688
 689     corrField=(AliTPCCorrection *)boundaryVoltErrorC[ipar]->Clone();
 690     corrField->SetOmegaTauT1T2(wtP,T1,T2);
 691     AliTPCCorrection::AddVisualCorrection(corrField,130+ipar);
 692     // correction for +-0.5 T setting
 693     corrField=(AliTPCCorrection *)boundaryVoltErrorA[ipar]->Clone();
 694     corrField->SetOmegaTauT1T2(wtM,T1,T2);
 695     AliTPCCorrection::AddVisualCorrection(corrField,140+ipar);
 696
 697     corrField=(AliTPCCorrection *)boundaryVoltErrorC[ipar]->Clone();
 698     corrField->SetOmegaTauT1T2(wtM,T1,T2);
 699     AliTPCCorrection::AddVisualCorrection(corrField,150+ipar);
 700   }
 701
 702 }
 703
 704
 705
 706 void RegisterAliTPCExBShape(){
 707   //
 708   //
 709   //
 710   AliMagF *magF = new AliMagF("mag","mag");
 711
 712   exbShape             = new AliTPCExBBShape;
 713   exbShape->SetBField(magF);
 714   exbShape->SetName("TPCExBShape");
 715   exbShape->SetTitle("TPCExBShape");
 716   exbShape->SetOmegaTauT1T2(0,1.,1.);
 717   exbShape->Print();
 718   AliTPCCorrection::AddVisualCorrection(exbShape,500);
 719   exbShapeT1X             = new AliTPCExBBShape;
 720   exbShapeT1X->SetBField(magF);
 721   exbShapeT1X->SetName("TPCExbShapeT1X");
 722   exbShapeT1X->SetTitle("TPCExbShapeT1X");
 723   exbShapeT1X->SetOmegaTauT1T2(0,1.2,1.);
 724   exbShapeT1X->Print();
 725   AliTPCCorrection::AddVisualCorrection(exbShapeT1X,501);
 726   exbShapeT2X             = new AliTPCExBBShape;
 727   exbShapeT2X->SetBField(magF);
 728   exbShapeT2X->SetName("TPCExbShapeT2X");
 729   exbShapeT2X->SetTitle("TPCExbShapeT2X");
 730   exbShapeT2X->SetOmegaTauT1T2(0,1.0,1.2);
 731   exbShapeT2X->Print();
 732   AliTPCCorrection::AddVisualCorrection(exbShapeT2X,502);
 733 }
 734
 735
 736 void RegisterAliTPCExBTwist(){
 737   //
 738   //
 739   //
 740   twistX    = new  AliTPCExBTwist;
 741   twistY    = new  AliTPCExBTwist;
 742   twistX->SetXTwist(0.001);  // 1 mrad twist in x
 743   twistX->SetName("ExBTwistX");
 744   twistX->SetTitle("ExBTwistX");
 745   twistY->SetYTwist(0.001);  // 1 mrad twist in y
 746   twistY->SetName("ExBTwistY");
 747   twistY->SetTitle("ExBTwistY");
 748   twistX->SetOmegaTauT1T2(0,1.,1.);
 749   twistY->SetOmegaTauT1T2(0,1.,1.);
 750   AliTPCCorrection::AddVisualCorrection(twistX,600);
 751   AliTPCCorrection::AddVisualCorrection(twistY,601);
 752 }
 753
 754 void RegisterAliTPCCorrectionDrift(){
 755   //
 756   // Drift distortion/correction
 757   //
 758   for (Int_t idrift=0; idrift<7; idrift++) {
 759     calibDrift[idrift]=new AliTPCCorrectionDrift;
 760   }
 761   calibDrift[0]->SetName("driftT0");
 762   calibDrift[0]->SetTitle("driftT0");
 763   calibDrift[0]->fZ0Aside=0.1;
 764   calibDrift[0]->fZ0Cside=0.1;
 765   calibDrift[1]->SetName("driftScale0");
 766   calibDrift[1]->SetTitle("driftScale0");
 767   calibDrift[1]->fVScale0=0.001;
 768   calibDrift[2]->SetName("driftScaleR");
 769   calibDrift[2]->SetTitle("driftScaleR");
 770   calibDrift[2]->fVScaleR=0.001;
 771   calibDrift[3]->SetName("driftScaleX");
 772   calibDrift[3]->SetTitle("driftScaleX");
 773   calibDrift[3]->fVScaleX=0.001;
 774   calibDrift[4]->SetName("driftScaleY");
 775   calibDrift[4]->SetTitle("driftScaleY");
 776   calibDrift[4]->fVScaleY=0.001;
 777   //
 778   calibDrift[5]->SetName("driftIROCDZ");
 779   calibDrift[5]->SetTitle("driftIROCDZ");
 780   calibDrift[5]->fIROCZ0=0.1; //delta Z for IROCORC
 781   //
 782   calibDrift[6]->SetName("driftOROCDT");
 783   calibDrift[6]->SetTitle("driftOROCDT");
 784   calibDrift[6]->fOROCDZ=0.001; //delta Z for IROCORC
 785
 786
 787 }
 788
 789
 790 void RegisterAliTPCROCVoltError3D(){
 791   //
 792   // ROC rotation transformation
 793   //       700 -709 - 0 field
 794   //       710 -719 - +0.5 field
 795   //       720 -729 - -0.5 field
 796   Double_t vdrift = 2.64; // [cm/us]   // to be updated: per second (ideally)
 797   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
 798   Double_t T1 = 1.0;
 799   Double_t T2 = 1.0;
 800   Double_t wtP = -10.0 * (0.5*10) * vdrift /  ezField ;
 801   Double_t wtM = -10.0 * (0.5*10) * vdrift / -ezField ;
 802
 803   //
 804   rocRotgXA=0;     // roc rotation A side - inclination in X
 805   rocRotgYA=0;     // roc rotation A side - inclination in Y
 806   rocRotgXC=0;     // roc rotation C side - inclination in X
 807   rocRotgYC=0;     // roc rotation C side - inclination in Y
 808   rocDzIROCA=0;      // roc shift A side - in Z
 809   rocDzIROCC=0;      // roc shift C side - in Z
 810   //
 811   rocDzUDA=0;        // roc shift up-down - A side
 812   rocDzUDC=0;        // roc shift up-down - C side
 813   //
 814   rocRotIROCA=0;      // roc rot IROC A side - in Z
 815   rocRotIROCC=0;      // roc rot OROC C side - in Z
 816   rocRotUDA=0;        // roc rot updown A side
 817   rocRotUDC=0;        // roc rot updown C side
 818  //
 819   printf("RegisterAliTPCROCVoltError3D()");
 820   Double_t kAngle=0.001;
 821   // reference in lx
 822   AliTPCROC * rocInfo = AliTPCROC::Instance();
 823   Double_t lxRef  = (rocInfo->GetPadRowRadii(0,62)+rocInfo->GetPadRowRadii(36,0))/2;
 824   //
 825   TMatrixD matrix(72,3);
 826
 827   AliTPCComposedCorrection *corrField3D = 0;
 828   TFile *fCorrectionsROC=0;
 829   fCorrectionsROC = TFile::Open("TPCCorrectionPrimitivesROC.root");
 830   corrField3D = ( AliTPCComposedCorrection *)fCorrectionsROC->Get("TPCROCVoltError3DRotationgXgY");
 831   //
 832   if (!corrField3D){
 833     fCorrectionsROC = TFile::Open("TPCCorrectionPrimitivesROC.root","recreate");
 834   }
 835   if (corrField3D) { // load from file
 836     corrField3D->Print();
 837     TCollection *iter = corrField3D->GetCorrections();
 838
 839     rocRotgXA=(AliTPCROCVoltError3D*)iter->FindObject("rocRotgXA");
 840
 841     rocRotgYA=(AliTPCROCVoltError3D*)iter->FindObject("rocRotgYA");
 842
 843     rocRotgXC=(AliTPCROCVoltError3D*)iter->FindObject("rocRotgXC");
 844
 845     rocRotgYC=(AliTPCROCVoltError3D*)iter->FindObject("rocRotgYC");
 846
 847     rocDzIROCA=(AliTPCROCVoltError3D*)iter->FindObject("rocDzIROCA");
 848
 849     rocDzIROCC=(AliTPCROCVoltError3D*)iter->FindObject("rocDzIROCC");
 850     //
 851     rocDzUDA=(AliTPCROCVoltError3D*)iter->FindObject("rocDzUDA");
 852
 853     rocDzUDC=(AliTPCROCVoltError3D*)iter->FindObject("rocDzUDC");
 854
 855     rocRotIROCA=(AliTPCROCVoltError3D*)iter->FindObject("rocRotIROCA");
 856
 857     rocRotIROCC=(AliTPCROCVoltError3D*)iter->FindObject("rocRotIROCC");
 858
 859     rocRotUDA=(AliTPCROCVoltError3D*)iter->FindObject("rocRotUDA");
 860
 861     rocRotUDC=(AliTPCROCVoltError3D*)iter->FindObject("rocRotUDC");
 862
 863   } else {
 864     corrField3D = new AliTPCComposedCorrection;
 865     rocRotgXA=new AliTPCROCVoltError3D;
 866     rocRotgYA=new AliTPCROCVoltError3D;
 867     rocRotgXC=new AliTPCROCVoltError3D;
 868     rocRotgYC=new AliTPCROCVoltError3D;
 869     rocDzIROCA=new AliTPCROCVoltError3D;
 870     rocDzIROCC=new AliTPCROCVoltError3D;
 871     rocDzUDA=new AliTPCROCVoltError3D;
 872     rocDzUDC=new AliTPCROCVoltError3D;
 873     rocRotIROCA=new AliTPCROCVoltError3D;
 874     rocRotIROCC=new AliTPCROCVoltError3D;
 875     rocRotUDA=new AliTPCROCVoltError3D;
 876     rocRotUDC=new AliTPCROCVoltError3D;
 877     //
 878     for (Int_t isec=0; isec<72; isec++){
 879       Double_t secAlpha = TMath::DegToRad()*(10.+20.*(((Int_t)isec)%18));
 880       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 881       if (isec%36<18){
 882         matrix(isec,0) = kAngle*TMath::Cos(secAlpha)*lxRef;
 883         matrix(isec,1) = kAngle*TMath::Cos(secAlpha);
 884         matrix(isec,2) = -kAngle*TMath::Sin(secAlpha);
 885       }
 886     }
 887     rocRotgXA->SetROCData(&matrix);
 888     //
 889     for (Int_t isec=0; isec<72; isec++){
 890       Double_t secAlpha = TMath::DegToRad()*(10.+20.*(((Int_t)isec)%18));
 891       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 892       if (isec%36<18){
 893         matrix(isec,0) = kAngle*TMath::Sin(secAlpha)*lxRef;
 894         matrix(isec,1) = kAngle*TMath::Sin(secAlpha);
 895         matrix(isec,2) = kAngle*TMath::Cos(secAlpha);
 896       }
 897     }
 898     rocRotgYA->SetROCData(&matrix);
 899     //
 900     for (Int_t isec=0; isec<72; isec++){
 901      Double_t secAlpha = TMath::DegToRad()*(10.+20.*(((Int_t)isec)%18));
 902       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 903       if (isec%36>=18){
 904         matrix(isec,0) = kAngle*TMath::Cos(secAlpha)*lxRef;
 905         matrix(isec,1) = kAngle*TMath::Cos(secAlpha);
 906         matrix(isec,2) = -kAngle*TMath::Sin(secAlpha);
 907       }
 908     }
 909     rocRotgXC->SetROCData(&matrix);
 910     //
 911     for (Int_t isec=0; isec<72; isec++){
 912       Double_t secAlpha = TMath::DegToRad()*(10.+20.*(((Int_t)isec)%18));
 913       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 914       if (isec%36>=18){
 915         matrix(isec,0) = kAngle*TMath::Sin(secAlpha)*lxRef;
 916         matrix(isec,1) = kAngle*TMath::Sin(secAlpha);
 917         matrix(isec,2) = kAngle*TMath::Cos(secAlpha);
 918       }
 919     }
 920     rocRotgYC->SetROCData(&matrix);
 921
 922     //
 923     //
 924     for (Int_t isec=0; isec<72; isec++){
 925       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 926       if (isec<18){
 927         matrix(isec,0) = 0.1;  // 1 mm
 928         matrix(isec,1) = 0;
 929         matrix(isec,2) = 0;
 930       }
 931     }
 932     rocDzIROCA->SetROCData(&matrix);
 933     //
 934     for (Int_t isec=0; isec<72; isec++){
 935       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 936       if (isec>=18 && isec<36){
 937         matrix(isec,0) = 0.1;  // 1 mm
 938         matrix(isec,1) = 0;
 939         matrix(isec,2) = 0;
 940       }
 941     }
 942     rocDzIROCC->SetROCData(&matrix);
 943
 944     //
 945     //
 946     for (Int_t isec=0; isec<72; isec++){
 947       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 948       if (isec%36<18){
 949         matrix(isec,0) = (isec%18<9)? 0.05:-0.05;  // 1 mm
 950         matrix(isec,1) = 0;
 951         matrix(isec,2) = 0;
 952       }
 953     }
 954     rocDzUDA->SetROCData(&matrix);
 955     //
 956     for (Int_t isec=0; isec<72; isec++){
 957       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 958       if (isec%36>=18){
 959         matrix(isec,0) = (isec%18<9)?0.05:-0.05;  // 1 mm
 960         matrix(isec,1) = 0;
 961         matrix(isec,2) = 0;
 962       }
 963     }
 964     rocDzUDC->SetROCData(&matrix);
 965     //
 966     //
 967     for (Int_t isec=0; isec<72; isec++){
 968       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 969       if (isec<18){
 970         matrix(isec,0) = 0;
 971         matrix(isec,1) = kAngle;
 972         matrix(isec,2) = 0;
 973       }
 974     }
 975     //
 976     rocRotIROCA->SetROCData(&matrix);
 977     //
 978     for (Int_t isec=0; isec<72; isec++){
 979       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 980       if (isec>=18 && isec<36){
 981         matrix(isec,0) = 0;
 982         matrix(isec,1) = kAngle;
 983         matrix(isec,2) = 0;
 984       }
 985     }
 986     rocRotIROCC->SetROCData(&matrix);
 987     //
 988     //
 989     for (Int_t isec=0; isec<72; isec++){
 990       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
 991       if (isec%36<18){
 992         matrix(isec,0) = 0;
 993         matrix(isec,1) = (isec%18<9)?kAngle:-kAngle;
 994         matrix(isec,2) = 0;
 995       }
 996     }
 997     //
 998     rocRotUDA->SetROCData(&matrix);
 999     //
1000     for (Int_t isec=0; isec<72; isec++){
1001       matrix(isec,0)=0; matrix(isec,1)=0; matrix(isec,2)=0;
1002       if (isec%36>=18){
1003         matrix(isec,0) = 0;
1004         matrix(isec,1) = (isec%18<9)?kAngle:-kAngle;
1005         matrix(isec,2) = 0;
1006       }
1007     }
1008     rocRotUDC->SetROCData(&matrix);
1009
1010
1011     //
1012     rocRotgXA->SetElectronArrivalCorrection(kFALSE);
1013     rocRotgYA->SetElectronArrivalCorrection(kFALSE);
1014     rocRotgXC->SetElectronArrivalCorrection(kFALSE);
1015     rocRotgYC->SetElectronArrivalCorrection(kFALSE);
1016     rocDzIROCA->SetElectronArrivalCorrection(kFALSE);
1017     rocDzIROCC->SetElectronArrivalCorrection(kFALSE);
1018     rocDzUDA->SetElectronArrivalCorrection(kFALSE);
1019     rocDzUDC->SetElectronArrivalCorrection(kFALSE);
1020     rocRotIROCA->SetElectronArrivalCorrection(kFALSE);
1021     rocRotIROCC->SetElectronArrivalCorrection(kFALSE);
1022     rocRotUDA->SetElectronArrivalCorrection(kFALSE);
1023     rocRotUDC->SetElectronArrivalCorrection(kFALSE);
1024
1025     /* // verification plots
1026     rocRotgXA.CreateHistoOfZAlignment(0,500,500)->Draw("surf2");
1027     rocRotgYA.CreateHistoOfZAlignment(0,500,500)->Draw("surf2");
1028     rocRotgXC.CreateHistoOfZAlignment(1,500,500)->Draw("surf2");
1029     rocRotgYC.CreateHistoOfZAlignment(1,500,500)->Draw("surf2");
1030     */
1031
1032     //
1033     rocRotgXA->SetName("rocRotgXA");rocRotgXA->SetTitle("rocRotgXA");
1034     rocRotgYA->SetName("rocRotgYA");rocRotgYA->SetTitle("rocRotgYA");
1035     rocRotgXC->SetName("rocRotgXC");rocRotgXC->SetTitle("rocRotgXC");
1036     rocRotgYC->SetName("rocRotgYC");rocRotgYC->SetTitle("rocRotgYC");
1037     rocDzIROCA->SetName("rocDzIROCA");rocDzIROCA->SetTitle("rocDzIROCA");
1038     rocDzIROCC->SetName("rocDzIROCC");rocDzIROCC->SetTitle("rocDzIROCC");
1039     rocDzUDA->SetName("rocDzUDA");rocDzUDA->SetTitle("rocDzUDA");
1040     rocDzUDC->SetName("rocDzUDC");rocDzUDC->SetTitle("rocDzUDC");
1041     rocRotIROCA->SetName("rocRotIROCA");rocRotIROCA->SetTitle("rocRotIROCA");
1042     rocRotIROCC->SetName("rocRotIROCC");rocRotIROCC->SetTitle("rocRotIROCC");
1043     rocRotUDA->SetName("rocRotUDA");rocRotUDA->SetTitle("rocRotUDA");
1044     rocRotUDC->SetName("rocRotUDC");rocRotUDC->SetTitle("rocRotUDC");
1045     //
1046     //
1047     TObjArray *cs = new TObjArray();
1048     cs->Add(rocRotgXA);
1049     cs->Add(rocRotgYA);
1050     cs->Add(rocRotgXC);
1051     cs->Add(rocRotgYC);
1052     cs->Add(rocDzIROCA);
1053     cs->Add(rocDzIROCC);
1054     cs->Add(rocDzUDA);
1055     cs->Add(rocDzUDC);
1056     cs->Add(rocRotIROCA);
1057     cs->Add(rocRotIROCC);
1058     cs->Add(rocRotUDA);
1059     cs->Add(rocRotUDC);
1060     corrField3D->SetCorrections(cs);
1061     corrField3D->SetOmegaTauT1T2(0,1.,1.);
1062     corrField3D->Print();
1063     fCorrectionsROC->cd();
1064     corrField3D->Init();
1065     corrField3D->Print("da");
1066     fCorrectionsROC->cd();
1067     corrField3D->Write("TPCROCVoltError3DRotationgXgY");
1068   }
1069   AliTPCCorrection::AddVisualCorrection(rocRotgXA,701);
1070   AliTPCCorrection::AddVisualCorrection(rocRotgYA,702);
1071   AliTPCCorrection::AddVisualCorrection(rocRotgXC,703);
1072   AliTPCCorrection::AddVisualCorrection(rocRotgYC,704);
1073   AliTPCCorrection::AddVisualCorrection(rocDzIROCA,705);
1074   AliTPCCorrection::AddVisualCorrection(rocDzIROCC,706);
1075   AliTPCCorrection::AddVisualCorrection(rocDzUDA,709);
1076   AliTPCCorrection::AddVisualCorrection(rocDzUDC,710);
1077   AliTPCCorrection::AddVisualCorrection(rocRotIROCA,707);
1078   AliTPCCorrection::AddVisualCorrection(rocRotIROCC,708);
1079   AliTPCCorrection::AddVisualCorrection(rocRotUDA,711);
1080   AliTPCCorrection::AddVisualCorrection(rocRotUDC,712);
1081
1082   AliTPCCorrection *corrPlus =0;
1083   //
1084   corrPlus=(AliTPCCorrection *)rocRotgXA->Clone();
1085   corrPlus->SetOmegaTauT1T2(wtP,T1,T2);
1086   AliTPCCorrection::AddVisualCorrection(corrPlus,711);
1087   //
1088   corrPlus=(AliTPCCorrection *)rocRotgYA->Clone();
1089   corrPlus->SetOmegaTauT1T2(wtP,T1,T2);
1090   AliTPCCorrection::AddVisualCorrection(corrPlus,712);
1091   //
1092   corrPlus=(AliTPCCorrection *)rocRotgXC->Clone();
1093   corrPlus->SetOmegaTauT1T2(wtP,T1,T2);
1094   AliTPCCorrection::AddVisualCorrection(corrPlus,713);
1095   //
1096   corrPlus=(AliTPCCorrection *)rocRotgYC->Clone();
1097   corrPlus->SetOmegaTauT1T2(wtP,T1,T2);
1098   AliTPCCorrection::AddVisualCorrection(corrPlus,714);
1099   //
1100   corrPlus=(AliTPCCorrection *)rocDzIROCA->Clone();
1101   corrPlus->SetOmegaTauT1T2(wtP,T1,T2);
1102   AliTPCCorrection::AddVisualCorrection(corrPlus,715);
1103   //
1104   corrPlus=(AliTPCCorrection *)rocDzIROCC->Clone();
1105   corrPlus->SetOmegaTauT1T2(wtP,T1,T2);
1106   AliTPCCorrection::AddVisualCorrection(corrPlus,716);
1107   //
1108   corrPlus=(AliTPCCorrection *)rocRotIROCA->Clone();
1109   corrPlus->SetOmegaTauT1T2(wtP,T1,T2);
1110   AliTPCCorrection::AddVisualCorrection(corrPlus,717);
1111   //
1112   corrPlus=(AliTPCCorrection *)rocDzIROCC->Clone();
1113   corrPlus->SetOmegaTauT1T2(wtP,T1,T2);
1114   AliTPCCorrection::AddVisualCorrection(corrPlus,718);
1115   //
1116   //
1117   AliTPCCorrection *corrMinus =0;
1118   //
1119   corrMinus=(AliTPCCorrection *)rocRotgXA->Clone();
1120   corrMinus->SetOmegaTauT1T2(wtM,T1,T2);
1121   AliTPCCorrection::AddVisualCorrection(corrMinus,721);
1122   //
1123   corrMinus=(AliTPCCorrection *)rocRotgYA->Clone();
1124   corrMinus->SetOmegaTauT1T2(wtM,T1,T2);
1125   AliTPCCorrection::AddVisualCorrection(corrMinus,722);
1126   //
1127   corrMinus=(AliTPCCorrection *)rocRotgXC->Clone();
1128   corrMinus->SetOmegaTauT1T2(wtM,T1,T2);
1129   AliTPCCorrection::AddVisualCorrection(corrMinus,723);
1130   //
1131   corrMinus=(AliTPCCorrection *)rocRotgYC->Clone();
1132   corrMinus->SetOmegaTauT1T2(wtM,T1,T2);
1133   AliTPCCorrection::AddVisualCorrection(corrMinus,724);
1134   //
1135   corrMinus=(AliTPCCorrection *)rocDzIROCA->Clone();
1136   corrMinus->SetOmegaTauT1T2(wtM,T1,T2);
1137   AliTPCCorrection::AddVisualCorrection(corrMinus,725);
1138   //
1139   corrMinus=(AliTPCCorrection *)rocDzIROCC->Clone();
1140   corrMinus->SetOmegaTauT1T2(wtM,T1,T2);
1141   AliTPCCorrection::AddVisualCorrection(corrMinus,726);
1142   //
1143   corrMinus=(AliTPCCorrection *)rocRotIROCA->Clone();
1144   corrMinus->SetOmegaTauT1T2(wtM,T1,T2);
1145   AliTPCCorrection::AddVisualCorrection(corrMinus,727);
1146   //
1147   corrMinus=(AliTPCCorrection *)rocDzIROCC->Clone();
1148   corrMinus->SetOmegaTauT1T2(wtM,T1,T2);
1149   AliTPCCorrection::AddVisualCorrection(corrMinus,728);
1150   //
1151
1152   fCorrectionsROC->Close();
1153   delete fCorrectionsROC;
1154 }
1155
1156
1157 void RegisterAliTPCROCVoltError3DSector(){
1158   //
1159   // ROC rotation and shift transformation
1160   // 800-819 -   0.0 Field
1161   // 820-839 -  +0.5 Field
1162   // 840-859 -  +0.5 Field
1163
1164   rocShiftIROCA0=0;      // IROC shift A0 side
1165   rocRotIROCA0=0;        // IROC rot   A0 side
1166   rocShiftOROCA0=0;      // OROC shift A0 side
1167   rocRotOROCA0=0;        // OROC rot   A0 side
1168   rocShiftIROCC0=0;      // IROC shift C0 side
1169   rocRotIROCC0=0;        // IROC rot   C0 side
1170   rocShiftOROCC0=0;      // OROC shift C0 side
1171   rocRotOROCC0=0;        // OROC rot   C0 side
1172   Double_t vdrift = 2.64; // [cm/us]   // to be updated: per second (ideally)
1173   Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
1174   Double_t T1 = 1.0;
1175   Double_t T2 = 1.0;
1176
1177   //  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
1178
1179   //
1180   //
1181   printf("RegisterAliTPCROCVoltError3DSector()");
1182   Double_t kAngle=0.001;
1183   Double_t kDz=0.1;
1184   // reference in lx
1185   //
1186   TMatrixD matrix(72,3);
1187
1188   AliTPCComposedCorrection *corrField3DSector = 0;
1189   TFile *fCorrectionsROC=0;
1190   fCorrectionsROC = TFile::Open("TPCCorrectionPrimitivesSector.root");
1191   corrField3DSector = ( AliTPCComposedCorrection *)fCorrectionsROC->Get("TPCROCVoltError3DSector");
1192   //
1193   if (!corrField3DSector){
1194     fCorrectionsROC = TFile::Open("TPCCorrectionPrimitivesSector.root","recreate");
1195   }
1196   if (corrField3DSector) { // load from file
1197     corrField3DSector->Print();
1198     TCollection *iter = corrField3DSector->GetCorrections();
1199     //
1200     rocShiftIROCA0=(AliTPCROCVoltError3D*)iter->FindObject("rocShiftIROCA0");   // IROC shift A0 side
1201     rocRotIROCA0=(AliTPCROCVoltError3D*)iter->FindObject("rocRotIROCA0");       // IROC rot   A0 side
1202     rocShiftOROCA0=(AliTPCROCVoltError3D*)iter->FindObject("rocShiftOROCA0");   // OROC shift A0 side
1203     rocRotOROCA0=(AliTPCROCVoltError3D*)iter->FindObject("rocRotOROCA0");       // OROC rot   A0 side
1204     rocShiftIROCC0=(AliTPCROCVoltError3D*)iter->FindObject("rocShiftIROCC0");   // IROC shift C0 side
1205     rocRotIROCC0=(AliTPCROCVoltError3D*)iter->FindObject("rocRotIROCC0");       // IROC rot   C0 side
1206     rocShiftOROCC0=(AliTPCROCVoltError3D*)iter->FindObject("rocShiftOROCC0");   // OROC shift C0 side
1207     rocRotOROCC0=(AliTPCROCVoltError3D*)iter->FindObject("rocRotOROCC0");       // OROC rot   C0 side
1208
1209   } else {
1210     corrField3DSector = new AliTPCComposedCorrection;
1211     rocShiftIROCA0=new AliTPCROCVoltError3D;      // IROC shift A0 side
1212     rocRotIROCA0=new AliTPCROCVoltError3D;        // IROC rot   A0 side
1213     rocShiftOROCA0=new AliTPCROCVoltError3D;      // OROC shift A0 side
1214     rocRotOROCA0=new AliTPCROCVoltError3D;        // OROC rot   A0 side
1215     rocShiftIROCC0=new AliTPCROCVoltError3D;      // IROC shift C0 side
1216     rocRotIROCC0=new AliTPCROCVoltError3D;        // IROC rot   C0 side
1217     rocShiftOROCC0=new AliTPCROCVoltError3D;      // OROC shift C0 side
1218     rocRotOROCC0=new AliTPCROCVoltError3D;        // OROC rot   C0 side
1219     //
1220     matrix.Zero(); matrix(0,0)=kDz;
1221     rocShiftIROCA0->SetROCData(&matrix);
1222     matrix.Zero(); matrix(0,1)=kAngle;
1223     rocRotIROCA0->SetROCData(&matrix);
1224     matrix.Zero(); matrix(36,0)=kDz;
1225     rocShiftOROCA0->SetROCData(&matrix);
1226     matrix.Zero(); matrix(36,1)=kAngle;
1227     rocRotOROCA0->SetROCData(&matrix);
1228
1229     matrix.Zero(); matrix(18,0)=kDz;
1230     rocShiftIROCC0->SetROCData(&matrix);
1231     matrix.Zero(); matrix(18,1)=kAngle;
1232     rocRotIROCC0->SetROCData(&matrix);
1233     matrix.Zero(); matrix(36+18,0)=kDz;
1234     rocShiftOROCC0->SetROCData(&matrix);
1235     matrix.Zero(); matrix(36+18,1)=kAngle;
1236     rocRotOROCC0->SetROCData(&matrix);
1237     //
1238     rocShiftIROCA0->SetElectronArrivalCorrection(kFALSE);     // IROC shift A0 side
1239     rocRotIROCA0->SetElectronArrivalCorrection(kFALSE);        // IROC rot   A0 side
1240     rocShiftOROCA0->SetElectronArrivalCorrection(kFALSE);      // OROC shift A0 side
1241     rocRotOROCA0->SetElectronArrivalCorrection(kFALSE);        // OROC rot   A0 side
1242     rocShiftIROCC0->SetElectronArrivalCorrection(kFALSE);      // IROC shift C0 side
1243     rocRotIROCC0->SetElectronArrivalCorrection(kFALSE);        // IROC rot   C0 side
1244     rocShiftOROCC0->SetElectronArrivalCorrection(kFALSE);      // OROC shift C0 side
1245     rocRotOROCC0->SetElectronArrivalCorrection(kFALSE);        // OROC rot   C0 side
1246
1247     /* // verification plots
1248     */
1249     //
1250     rocShiftIROCA0->SetName("rocShiftIROCA0");rocShiftIROCA0->SetTitle("rocShiftIROCA0");
1251     rocRotIROCA0->SetName("rocRotIROCA0");rocRotIROCA0->SetTitle("rocRotIROCA0");
1252     rocShiftOROCA0->SetName("rocShiftOROCA0"); rocShiftOROCA0->SetTitle("rocShiftOROCA0");
1253     rocRotOROCA0->SetName("rocRotOROCA0");rocRotOROCA0->SetTitle("rocRotOROCA0");
1254     //
1255     rocShiftIROCC0->SetName("rocShiftIROCC0");rocShiftIROCC0->SetTitle("rocShiftIROCC0");
1256     rocRotIROCC0->SetName("rocRotIROCC0");rocRotIROCC0->SetTitle("rocRotIROCC0");
1257     rocShiftOROCC0->SetName("rocShiftOROCC0");rocShiftOROCC0->SetTitle("rocShiftOROCC0");
1258     rocRotOROCC0->SetName("rocRotOROCC0");rocRotOROCC0->SetTitle("rocRotOROCC0");
1259     //
1260     //
1261     TObjArray *cs = new TObjArray();
1262     cs->Add(rocShiftIROCA0);      // IROC shift A0 side
1263     cs->Add(rocRotIROCA0);        // IROC rot   A0 side
1264     cs->Add(rocShiftOROCA0);      // OROC shift A0 side
1265     cs->Add(rocRotOROCA0);        // OROC rot   A0 side
1266     cs->Add(rocShiftIROCC0);      // IROC shift C0 side
1267     cs->Add(rocRotIROCC0);        // IROC rot   C0 side
1268     cs->Add(rocShiftOROCC0);      // OROC shift C0 side
1269     cs->Add(rocRotOROCC0);        // OROC rot   C0 side
1270     //
1271     corrField3DSector->SetCorrections(cs);
1272     corrField3DSector->SetOmegaTauT1T2(0,T1,T2);
1273     corrField3DSector->Print();
1274     //
1275
1276     fCorrectionsROC->cd();
1277     corrField3DSector->Init();
1278     corrField3DSector->Print("da");
1279     fCorrectionsROC->cd();
1280     corrField3DSector->Write("TPCROCVoltError3DSector");
1281   }
1282   AliTPCCorrection::AddVisualCorrection(rocShiftIROCA0,800);      // IROC shift A0 side
1283   AliTPCCorrection::AddVisualCorrection(rocRotIROCA0,801);        // IROC rot   A0 side
1284   AliTPCCorrection::AddVisualCorrection(rocShiftOROCA0,802);      // OROC shift A0 side
1285   AliTPCCorrection::AddVisualCorrection(rocRotOROCA0,803);        // OROC rot   A0 side
1286   AliTPCCorrection::AddVisualCorrection(rocShiftIROCC0,804);      // IROC shift C0 side
1287   AliTPCCorrection::AddVisualCorrection(rocRotIROCC0,805);        // IROC rot   C0 side
1288   AliTPCCorrection::AddVisualCorrection(rocShiftOROCC0,806);      // OROC shift C0 side
1289   AliTPCCorrection::AddVisualCorrection(rocRotOROCC0,807);        // OROC rot   C0 side
1290   //
1291   // Register correction for plus setting
1292   AliTPCCorrection *corr =0;
1293   Double_t wtp = -10.0 * (0.5*10) * vdrift / ezField ;
1294   Double_t wtm = -10.0 * (0.5*10) * vdrift / -ezField ;
1295
1296   corr=(AliTPCCorrection *)rocShiftIROCA0->Clone();
1297   corr->SetOmegaTauT1T2(wtp,T1,T2);
1298   AliTPCCorrection::AddVisualCorrection(corr,820);           // IROC shift A0 side + Plus field
1299   //
1300   corr=(AliTPCCorrection *)rocRotIROCA0->Clone();
1301   corr->SetOmegaTauT1T2(wtp,T1,T2);
1302   AliTPCCorrection::AddVisualCorrection(corr,821);           // IROC rot   A0 side
1303   //
1304   corr=(AliTPCCorrection *)rocShiftOROCA0->Clone();
1305   corr->SetOmegaTauT1T2(wtp,T1,T2);
1306   AliTPCCorrection::AddVisualCorrection(corr,822);            // OROC shift   A0 side
1307   //
1308   corr=(AliTPCCorrection *)rocRotOROCA0->Clone();
1309   corr->SetOmegaTauT1T2(wtp,T1,T2);
1310   AliTPCCorrection::AddVisualCorrection(corr,823);            // OROC rot   A0 side
1311   corr=(AliTPCCorrection *)rocShiftIROCC0->Clone();
1312   corr->SetOmegaTauT1T2(wtp,T1,T2);
1313   AliTPCCorrection::AddVisualCorrection(corr,824);           // IROC shift C0 side + Plus field
1314   //
1315   corr=(AliTPCCorrection *)rocRotIROCC0->Clone();
1316   corr->SetOmegaTauT1T2(wtp,T1,T2);
1317   AliTPCCorrection::AddVisualCorrection(corr,825);           // IROC rot   C0 side
1318   //
1319   corr=(AliTPCCorrection *)rocShiftOROCC0->Clone();
1320   corr->SetOmegaTauT1T2(wtp,T1,T2);
1321   AliTPCCorrection::AddVisualCorrection(corr,826);            // OROC shift   C0 side
1322   //
1323   corr=(AliTPCCorrection *)rocRotOROCC0->Clone();
1324   corr->SetOmegaTauT1T2(wtp,T1,T2);
1325   AliTPCCorrection::AddVisualCorrection(corr,827);            // OROC rot   C0 side
1326   //
1327   corr=(AliTPCCorrection *)rocShiftIROCA0->Clone();
1328   corr->SetOmegaTauT1T2(wtm,T1,T2);
1329   AliTPCCorrection::AddVisualCorrection(corr,840);           // IROC shift A0 side + Plus field
1330   //
1331   corr=(AliTPCCorrection *)rocRotIROCA0->Clone();
1332   corr->SetOmegaTauT1T2(wtm,T1,T2);
1333   AliTPCCorrection::AddVisualCorrection(corr,841);           // IROC rot   A0 side
1334   //
1335   corr=(AliTPCCorrection *)rocShiftOROCA0->Clone();
1336   corr->SetOmegaTauT1T2(wtm,T1,T2);
1337   AliTPCCorrection::AddVisualCorrection(corr,842);            // OROC shift   A0 side
1338   //
1339   corr=(AliTPCCorrection *)rocRotOROCA0->Clone();
1340   corr->SetOmegaTauT1T2(wtm,T1,T2);
1341   AliTPCCorrection::AddVisualCorrection(corr,843);            // OROC rot   A0 side
1342   corr=(AliTPCCorrection *)rocShiftIROCC0->Clone();
1343   corr->SetOmegaTauT1T2(wtm,T1,T2);
1344   AliTPCCorrection::AddVisualCorrection(corr,844);           // IROC shift C0 side + Plus field
1345   //
1346   corr=(AliTPCCorrection *)rocRotIROCC0->Clone();
1347   corr->SetOmegaTauT1T2(wtm,T1,T2);
1348   AliTPCCorrection::AddVisualCorrection(corr,845);           // IROC rot   C0 side
1349   //
1350   corr=(AliTPCCorrection *)rocShiftOROCC0->Clone();
1351   corr->SetOmegaTauT1T2(wtm,T1,T2);
1352   AliTPCCorrection::AddVisualCorrection(corr,846);            // OROC shift   C0 side
1353   //
1354   corr=(AliTPCCorrection *)rocRotOROCC0->Clone();
1355   corr->SetOmegaTauT1T2(wtm,T1,T2);
1356   AliTPCCorrection::AddVisualCorrection(corr,847);            // OROC rot   C0 side
1357   //
1358   fCorrectionsROC->Close();
1359   delete fCorrectionsROC;
1360 }
1361
1362
1363
1364
1365
1366 AliTPCComposedCorrection * MakeComposedCorrectionExB(){
1367   //
1368   // make composed corection for ExB scanning
1369   //
1370   RegisterCorrection();
1371   //
1372    //
1373   TObjArray * corr = new TObjArray;       // primitive corrections - for fitting
1374   TObjArray * testCorr = new TObjArray;   // test corrections - to be used as benchmark for fitting
1375   //
1376   corr->AddLast(twistX);
1377   corr->AddLast(twistY);
1378   corr->AddLast(exbShape);
1379   corr->AddLast(exbShapeT1X);
1380   corr->AddLast(exbShapeT2X);
1381   //
1382   for (Int_t i=0; i<8; i++){
1383     corr->AddLast(boundaryVoltErrorA[i]);
1384     corr->AddLast(boundaryVoltErrorC[i]);
1385   }
1386   //
1387   // ROD alignment
1388   //
1389   corr->AddLast(rodIFCCos);
1390   corr->AddLast(rodIFCSin);
1391   corr->AddLast(rodOFCSin);
1392   corr->AddLast(rodOFCCos);
1393   //alignment
1394   corr->AddLast(alignTrans0);
1395   corr->AddLast(alignTrans1);
1396   corr->AddLast(alignTrans2);
1397   corr->AddLast(alignRot0);
1398   corr->AddLast(alignRot1);
1399   corr->AddLast(alignRot2);
1400   //
1401   corr->AddLast(alignTrans0D[0]);
1402   corr->AddLast(alignTrans1D[0]);
1403   corr->AddLast(alignTrans2D[0]);
1404   corr->AddLast(alignRot0D[0]);
1405   corr->AddLast(alignRot1D[0]);
1406   corr->AddLast(alignRot2D[0]);
1407   corr->AddLast(alignTrans0D[1]);
1408   corr->AddLast(alignTrans1D[1]);
1409   corr->AddLast(alignRot0D[1]);
1410   corr->AddLast(alignTrans0D[2]);
1411   corr->AddLast(alignTrans1D[2]);
1412   corr->AddLast(alignRot0D[2]);
1413   //
1414   // z alignment + E field distortion due z misalignment
1415   //
1416   corr->AddLast(rocRotgXA);  // A side C side
1417   corr->AddLast(rocRotgYA);
1418   corr->AddLast(rocRotgXC);
1419   corr->AddLast(rocRotgYC);
1420   corr->AddLast(rocDzIROCA);
1421   corr->AddLast(rocDzIROCC);
1422   corr->AddLast(rocRotIROCA);
1423   corr->AddLast(rocRotIROCC);
1424   corr->AddLast(rocDzUDA);
1425   corr->AddLast(rocDzUDC);
1426   corr->AddLast(rocRotUDA);
1427   corr->AddLast(rocRotUDC);
1428   //
1429   //
1430   corr->AddLast(calibDrift[0]);
1431   corr->AddLast(calibDrift[1]);
1432   corr->AddLast(calibDrift[2]);
1433   corr->AddLast(calibDrift[3]);
1434   corr->AddLast(calibDrift[4]);
1435   corr->AddLast(calibDrift[5]);
1436   corr->AddLast(calibDrift[6]);
1437   //
1438   // setup test correction
1439   //
1440   testCorr->AddLast(rodIFCCos);
1441   testCorr->AddLast(rodIFCSin);
1442   testCorr->AddLast(rodOFCSin);
1443   testCorr->AddLast(rodOFCCos);
1444   //
1445   testCorr->AddLast(twistX);
1446   testCorr->AddLast(twistY);
1447   testCorr->AddLast(alignTrans0);
1448   testCorr->AddLast(alignTrans1);
1449   testCorr->AddLast(alignTrans2);
1450   testCorr->AddLast(alignRot0);
1451   testCorr->AddLast(alignRot1);
1452   testCorr->AddLast(alignRot2);
1453   testCorr->AddLast(rocRotgXA);  // A side C side
1454   testCorr->AddLast(rocRotgYA);
1455   testCorr->AddLast(rocRotgXC);
1456   testCorr->AddLast(rocRotgYC);
1457   testCorr->AddLast(rocDzIROCA);
1458   testCorr->AddLast(rocDzIROCC);
1459   testCorr->AddLast(rocRotIROCA);
1460   testCorr->AddLast(rocRotIROCC);
1461   Int_t entries=testCorr->GetEntries();
1462   TVectorD weights(entries);
1463   for (Int_t i=0; i<entries; i++) weights[i]=1;
1464   //
1465   AliTPCComposedCorrection *composedTest= new AliTPCComposedCorrection ;
1466   composedTest->SetName("FitSample");
1467   composedTest->SetTitle("FitSample");
1468   composedTest->SetCorrections(testCorr);
1469   composedTest->SetWeights(&weights);
1470   //
1471   corr->AddLast(composedTest);
1472   AliTPCComposedCorrection *cc= new AliTPCComposedCorrection ;
1473   cc->SetCorrections((TObjArray*)(corr));
1474    //cc->Init();
1475   cc->Print("DA"); // Print used correction classes
1476   cc->SetName("ComposedExB");
1477   TFile fexb("RegisterCorrectionExB.root","recreate");
1478   cc->Write("ComposedExB");
1479   fexb.Close();
1480   return cc;
1481 }
1482
1483
1484 AliTPCComposedCorrection * GetCorrectionFromFile(){
1485   //
1486   // Getthe appropariate correction form the closest file
1487   //
1488   TFile * fexb= TFile::Open("RegisterCorrectionExB.root");
1489   if (!fexb)  fexb= TFile::Open("../RegisterCorrectionExB.root");
1490   if (!fexb)  fexb= TFile::Open("../../RegisterCorrectionExB.root");
1491   if (!fexb)  fexb= TFile::Open("../../../RegisterCorrectionExB.root");
1492   //
1493   if (!fexb)   return 0;
1494   TFile * fitter= TFile::Open("fitCorrection.root");
1495
1496   if (!fitter)  fitter= TFile::Open("../fitCorrection.root");
1497   if (!fitter)  fitter= TFile::Open("../../fitCorrection.root");
1498   if (!fitter)  fitter= TFile::Open("../../../fitCorrection.root");
1499   //
1500   AliTPCComposedCorrection *cc=  (AliTPCComposedCorrection*) fexb->Get("ComposedExB");
1501   {if (!cc){
1502     printf("File or correction RegisterCorrectionExB.root doees not exist or corrupted\n\n\n");
1503     return 0;
1504     }}
1505   TObjArray * corr = (TObjArray*)(cc->GetCorrections());
1506   //  TObjArray * corrLocal =new TObjArray;
1507   // TObjArray * corrGlobal =new TObjArray;
1508   //
1509   if (fitter){
1510     if (fitter->GetKey("FitBoundary")) corr->AddLast(fitter->Get("FitBoundary"));
1511     if (fitter->GetKey("FitExBTwist"))  corr->AddLast(fitter->Get("FitExBTwist"));
1512     if (fitter->GetKey("FitAlignGlobal"))  corr->AddLast(fitter->Get("FitAlignGlobal"));
1513     if (fitter->GetKey("FitRodAlignGloba"))  corr->AddLast(fitter->Get("FitRodAlignGlobal"));
1514     if (fitter->GetKey("FitRocAlignGlobal"))  corr->AddLast(fitter->Get("FitRocAlignGlobal"));
1515     if (fitter->GetKey("FitRocAlignZ"))  corr->AddLast(fitter->Get("FitRocAlignZ"));
1516     if (fitter->GetKey("FitAlignLocal"))  corr->AddLast(fitter->Get("FitAlignLocal"));
1517     if (fitter->GetKey("FitAlignTPC"))  corr->AddLast(fitter->Get("FitAlignTPC"));
1518     if (fitter->GetKey("FitAlignTOF"))  corr->AddLast(fitter->Get("FitAlignTOF"));
1519     if (fitter->GetKey("FitAlignTRD"))  corr->AddLast(fitter->Get("FitAlignTRD"));
1520   }
1521   return cc;
1522 }
1523
1524 void TestParExample(){
1525   //
1526   // dz shift example: AliTPCCorrection::AddVisualCorrection(rocDzIROCA,705);
1527   // => parabolic fit and helix fit agrees - once significant ammount of points used
1528   //    160 point - agreement  ~2%;
1529   //     80 points - agreement ~5%
1530   AliTPCCorrection* corr = AliTPCCorrection::GetVisualCorrection(705);
1531   corr->SetOmegaTauT1T2(0.33,1,1);
1532   TF1 f705Par("f705","AliTPCCorrectionFit::EvalAtPar(0,0,85, x,0.1,705,0,80)",0,360);
1533   f705Par.SetLineColor(2);f705Par.SetNpx(500);
1534   TF1 f705Helix("f705Helix","AliTPCCorrectionFit::EvalAtHelix(0,0,85,x,0.1,705,0,80)",0,360);
1535   f705Helix.SetLineColor(4);f705Helix.SetNpx(500);
1536   f705Helix.Draw();
1537   f705Par.Draw("same");
1538
1539 }
1540
1541
1542
1543 void TestFitSpeed(Int_t nEvals){
1544   //
1545   //  test speed of helix fit/ resp. parabolic fir
1546   //
1547   TStopwatch timerh;
1548   ::Info("TestFitSpeed","Helix fit");
1549   for (Int_t i=0;i<nEvals; i++) AliTPCCorrectionFit::EvalAtPar(0,0,85,gRandom->Rndm(),0.1,705,0,80);
1550   timerh.Print();
1551   TStopwatch timerP;
1552   ::Info("TestFitSpeed","Parabolicfit");
1553   for (Int_t i=0;i<nEvals; i++) AliTPCCorrectionFit::EvalAtPar(0,0,85,gRandom->Rndm(),0.1,705,0,80);
1554   timerP.Print();
1555   /*
1556     For the test system CPU comsumption is the same:
1557     I-TestFitSpeed: Helix fit
1558     Real time 0:00:03, CP time 3.310
1559     I-TestFitSpeed: Parabolicfit
1560     Real time 0:00:03, CP time 3.280
1561   */
1562 }
1563