HLT/src/AliL3Transform.cxx

   1 // @(#) $Id$
   2
   3 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>, Constantin Loizides <mailto:loizides@ikf.uni-frankfurt.de>
   4 //*-- Copyright &copy ALICE HLT Group
   5
   6
   7 #include "AliL3StandardIncludes.h"
   8 #include "dirent.h"
   9
  10 #ifdef use_aliroot
  11 #include <AliRun.h>
  12 #include <AliMagF.h>
  13 #include <AliTPCParamSR.h>
  14 #include <AliTPCPRF2D.h>
  15 #include <AliTPCRF1D.h>
  16 #endif
  17 #ifdef use_root
  18 #include <TFile.h>
  19 #include <TUnixSystem.h>
  20 #include <TTimeStamp.h>
  21 #include <TError.h>
  22 #endif
  23
  24 #include "AliL3Logging.h"
  25 #include "AliL3Transform.h"
  26
  27 #if GCCVERSION == 3
  28 using namespace std;
  29 #endif
  30
  31 /** \class AliL3Transform
  32 <pre>
  33 //_____________________________________________________________
  34 // AliL3Transform
  35 //
  36 // Transformation class for ALICE TPC.
  37 //
  38 // Class which contains all detector specific parameters for the TPC,
  39 // and different useful functions for coordinate transforms.
  40 //
  41 // The class is completely static, which means that no object needs
  42 // to be instantiated. Function calls should then be done like, e.g.:
  43 //
  44 // Double_t eta = AliL3Transform::GetEta(xyz);
  45 //
  46 // IMPORTANT: If used as is, default detector parameters will be used,
  47 //            and you really have to make sure that these correspond to
  48 //            the AliROOT version you are currently working on!!
  49 //            You should therefore always initialize the parameters by
  50 //
  51 //            AliL3Transform::Init(path);
  52 //
  53 //            where path is a char*, giving the path to where file containing
  54 //            the detector parameter is located. This file should be called
  55 //            "l3transform.config", and can be created with the function MakeInitFile.
  56 //
  57 //            You can also force reading the parameters from a AliTPCParam object
  58 //            by setting the flag;
  59 //
  60 //            AliL3Transform::Init(path,kTRUE);
  61 //
  62 //            where path is a char*
  63 //            either providing the rootfile name containing the geometry or
  64 //            the path to the rootfile which should then be called alirunfile.root.
  65 //            Note that for both of these cases you have to
  66 //            compile with USEPACKAGE=ALIROOT set (see level3code/Makefile.conf).
  67 //
  68 //            Currently, there are 4 versions of the Transformer:
  69 //             fVersion==fV_aliroot: ALIROOT-head compatible
  70 //             fVersion==fV_cosmics: Cosmics data run (2003) compatible
  71 //             fVersion==fV_default: means no config file has been loaded
  72 //             fVersion==fV_deprecated: dont use old (before July 2003) style of transformer
  73 //
  74 </pre>
  75 */
  76
  77
  78 ClassImp(AliL3Transform)
  79
  80
  81 const Double_t AliL3Transform::fAnodeWireSpacing = 0.25; //Taken from the TDR
  82 const Double_t AliL3Transform::fBFACT = 0.0029980;       //Conversion Factor
  83 const Double_t AliL3Transform::fPi = 3.141592653589793;
  84
  85 //Defined by HLT and GSI
  86 Int_t AliL3Transform::fNPatches = 6;
  87 Int_t AliL3Transform::fRows[6][2] = {{0,29},{30,62},{63,90},{91,116},{117,139},{140,158}};
  88 Int_t AliL3Transform::fNRows[6] = {30,33,28,26,23,19};
  89
  90 // The following definition is generated by MakeInitFile function
  91 Double_t AliL3Transform::fBField = 0.2;
  92 Double_t AliL3Transform::fSolenoidBField = 2;
  93 Double_t AliL3Transform::fBFieldFactor = 1;
  94 Int_t AliL3Transform::fVersion = fV_default;
  95 Int_t AliL3Transform::fNTimeBins = 446;
  96 Int_t AliL3Transform::fNRowLow = 63;
  97 Int_t AliL3Transform::fNRowUp = 96;
  98 Int_t AliL3Transform::fNRowUp1 = 64;
  99 Int_t AliL3Transform::fNRowUp2 = 32;
 100 Int_t AliL3Transform::fNSectorLow = 36;
 101 Int_t AliL3Transform::fNSectorUp = 36;
 102 Int_t AliL3Transform::fNSector = 72;
 103 Double_t AliL3Transform::fPadPitchWidthLow = 0.4;
 104 Double_t AliL3Transform::fPadPitchWidthUp = 0.6;
 105 Double_t AliL3Transform::fZWidth = 0.5660;
 106 Double_t AliL3Transform::fZSigma = 0.2288;
 107 Double_t AliL3Transform::fZLength = 250.0000;
 108 Double_t AliL3Transform::fZOffset = 0.6864;
 109 Double_t AliL3Transform::fDiffT = 0.0220;
 110 Double_t AliL3Transform::fDiffL = 0.0220;
 111 Double_t AliL3Transform::fOmegaTau = 0.1450;
 112 Double_t AliL3Transform::fInnerPadLength = 0.75;
 113 Double_t AliL3Transform::fOuter1PadLength = 1.00;
 114 Double_t AliL3Transform::fOuter2PadLength = 1.50;
 115 Double_t AliL3Transform::fInnerPRFSigma = 0.203811;
 116 Double_t AliL3Transform::fOuter1PRFSigma = 0.299325;
 117 Double_t AliL3Transform::fOuter2PRFSigma = 0.299323;
 118 Double_t AliL3Transform::fTimeSigma = 0.228809;
 119 Int_t AliL3Transform::fADCSat = 1024;
 120 Int_t AliL3Transform::fZeroSup = 0;
 121 Int_t AliL3Transform::fNSlice = 36;
 122 Int_t AliL3Transform::fNRow = 159;
 123 Double_t AliL3Transform::fNRotShift = 0.5;
 124 Int_t AliL3Transform::fSlice2Sector[36][2] = { { 0, 36},
 125                                                { 1, 37},
 126                                                { 2, 38},
 127                                                { 3, 39},
 128                                                { 4, 40},
 129                                                { 5, 41},
 130                                                { 6, 42},
 131                                                { 7, 43},
 132                                                { 8, 44},
 133                                                { 9, 45},
 134                                                {10, 46},
 135                                                {11, 47},
 136                                                {12, 48},
 137                                                {13, 49},
 138                                                {14, 50},
 139                                                {15, 51},
 140                                                {16, 52},
 141                                                {17, 53},
 142                                                {18, 54},
 143                                                {19, 55},
 144                                                {20, 56},
 145                                                {21, 57},
 146                                                {22, 58},
 147                                                {23, 59},
 148                                                {24, 60},
 149                                                {25, 61},
 150                                                {26, 62},
 151                                                {27, 63},
 152                                                {28, 64},
 153                                                {29, 65},
 154                                                {30, 66},
 155                                                {31, 67},
 156                                                {32, 68},
 157                                                {33, 69},
 158                                                {34, 70},
 159                                                {35, 71}
 160 };
 161
 162 Int_t AliL3Transform::fSector2Slice[72] = { 0,
 163                                             1,
 164                                             2,
 165                                             3,
 166                                             4,
 167                                             5,
 168                                             6,
 169                                             7,
 170                                             8,
 171                                             9,
 172                                             10,
 173                                             11,
 174                                             12,
 175                                             13,
 176                                             14,
 177                                             15,
 178                                             16,
 179                                             17,
 180                                             18,
 181                                             19,
 182                                             20,
 183                                             21,
 184                                             22,
 185                                             23,
 186                                             24,
 187                                             25,
 188                                             26,
 189                                             27,
 190                                             28,
 191                                             29,
 192                                             30,
 193                                             31,
 194                                             32,
 195                                             33,
 196                                             34,
 197                                             35,
 198                                             0,
 199                                             1,
 200                                             2,
 201                                             3,
 202                                             4,
 203                                             5,
 204                                             6,
 205                                             7,
 206                                             8,
 207                                             9,
 208                                             10,
 209                                             11,
 210                                             12,
 211                                             13,
 212                                             14,
 213                                             15,
 214                                             16,
 215                                             17,
 216                                             18,
 217                                             19,
 218                                             20,
 219                                             21,
 220                                             22,
 221                                             23,
 222                                             24,
 223                                             25,
 224                                             26,
 225                                             27,
 226                                             28,
 227                                             29,
 228                                             30,
 229                                             31,
 230                                             32,
 231                                             33,
 232                                             34,
 233                                             35
 234 };
 235
 236 Int_t AliL3Transform::fSectorLow[72] = { 1,
 237                                          1,
 238                                          1,
 239                                          1,
 240                                          1,
 241                                          1,
 242                                          1,
 243                                          1,
 244                                          1,
 245                                          1,
 246                                          1,
 247                                          1,
 248                                          1,
 249                                          1,
 250                                          1,
 251                                          1,
 252                                          1,
 253                                          1,
 254                                          1,
 255                                          1,
 256                                          1,
 257                                          1,
 258                                          1,
 259                                          1,
 260                                          1,
 261                                          1,
 262                                          1,
 263                                          1,
 264                                          1,
 265                                          1,
 266                                          1,
 267                                          1,
 268                                          1,
 269                                          1,
 270                                          1,
 271                                          1,
 272                                          0,
 273                                          0,
 274                                          0,
 275                                          0,
 276                                          0,
 277                                          0,
 278                                          0,
 279                                          0,
 280                                          0,
 281                                          0,
 282                                          0,
 283                                          0,
 284                                          0,
 285                                          0,
 286                                          0,
 287                                          0,
 288                                          0,
 289                                          0,
 290                                          0,
 291                                          0,
 292                                          0,
 293                                          0,
 294                                          0,
 295                                          0,
 296                                          0,
 297                                          0,
 298                                          0,
 299                                          0,
 300                                          0,
 301                                          0,
 302                                          0,
 303                                          0,
 304                                          0,
 305                                          0,
 306                                          0,
 307                                          0
 308 };
 309
 310 Double_t AliL3Transform::fX[159] = { 85.195,
 311                                      85.945,
 312                                      86.695,
 313                                      87.445,
 314                                      88.195,
 315                                      88.945,
 316                                      89.695,
 317                                      90.445,
 318                                      91.195,
 319                                      91.945,
 320                                      92.695,
 321                                      93.445,
 322                                      94.195,
 323                                      94.945,
 324                                      95.695,
 325                                      96.445,
 326                                      97.195,
 327                                      97.945,
 328                                      98.695,
 329                                      99.445,
 330                                      100.195,
 331                                      100.945,
 332                                      101.695,
 333                                      102.445,
 334                                      103.195,
 335                                      103.945,
 336                                      104.695,
 337                                      105.445,
 338                                      106.195,
 339                                      106.945,
 340                                      107.695,
 341                                      108.445,
 342                                      109.195,
 343                                      109.945,
 344                                      110.695,
 345                                      111.445,
 346                                      112.195,
 347                                      112.945,
 348                                      113.695,
 349                                      114.445,
 350                                      115.195,
 351                                      115.945,
 352                                      116.695,
 353                                      117.445,
 354                                      118.195,
 355                                      118.945,
 356                                      119.695,
 357                                      120.445,
 358                                      121.195,
 359                                      121.945,
 360                                      122.695,
 361                                      123.445,
 362                                      124.195,
 363                                      124.945,
 364                                      125.695,
 365                                      126.445,
 366                                      127.195,
 367                                      127.945,
 368                                      128.695,
 369                                      129.445,
 370                                      130.195,
 371                                      130.945,
 372                                      131.695,
 373                                      135.180,
 374                                      136.180,
 375                                      137.180,
 376                                      138.180,
 377                                      139.180,
 378                                      140.180,
 379                                      141.180,
 380                                      142.180,
 381                                      143.180,
 382                                      144.180,
 383                                      145.180,
 384                                      146.180,
 385                                      147.180,
 386                                      148.180,
 387                                      149.180,
 388                                      150.180,
 389                                      151.180,
 390                                      152.180,
 391                                      153.180,
 392                                      154.180,
 393                                      155.180,
 394                                      156.180,
 395                                      157.180,
 396                                      158.180,
 397                                      159.180,
 398                                      160.180,
 399                                      161.180,
 400                                      162.180,
 401                                      163.180,
 402                                      164.180,
 403                                      165.180,
 404                                      166.180,
 405                                      167.180,
 406                                      168.180,
 407                                      169.180,
 408                                      170.180,
 409                                      171.180,
 410                                      172.180,
 411                                      173.180,
 412                                      174.180,
 413                                      175.180,
 414                                      176.180,
 415                                      177.180,
 416                                      178.180,
 417                                      179.180,
 418                                      180.180,
 419                                      181.180,
 420                                      182.180,
 421                                      183.180,
 422                                      184.180,
 423                                      185.180,
 424                                      186.180,
 425                                      187.180,
 426                                      188.180,
 427                                      189.180,
 428                                      190.180,
 429                                      191.180,
 430                                      192.180,
 431                                      193.180,
 432                                      194.180,
 433                                      195.180,
 434                                      196.180,
 435                                      197.180,
 436                                      198.180,
 437                                      199.430,
 438                                      200.930,
 439                                      202.430,
 440                                      203.930,
 441                                      205.430,
 442                                      206.930,
 443                                      208.430,
 444                                      209.930,
 445                                      211.430,
 446                                      212.930,
 447                                      214.430,
 448                                      215.930,
 449                                      217.430,
 450                                      218.930,
 451                                      220.430,
 452                                      221.930,
 453                                      223.430,
 454                                      224.930,
 455                                      226.430,
 456                                      227.930,
 457                                      229.430,
 458                                      230.930,
 459                                      232.430,
 460                                      233.930,
 461                                      235.430,
 462                                      236.930,
 463                                      238.430,
 464                                      239.930,
 465                                      241.430,
 466                                      242.930,
 467                                      244.430,
 468                                      245.930
 469 };
 470
 471 Int_t AliL3Transform::fNPads[159] = {67,
 472                                      67,
 473                                      69,
 474                                      69,
 475                                      69,
 476                                      71,
 477                                      71,
 478                                      71,
 479                                      73,
 480                                      73,
 481                                      73,
 482                                      75,
 483                                      75,
 484                                      75,
 485                                      77,
 486                                      77,
 487                                      77,
 488                                      79,
 489                                      79,
 490                                      79,
 491                                      81,
 492                                      81,
 493                                      81,
 494                                      83,
 495                                      83,
 496                                      83,
 497                                      85,
 498                                      85,
 499                                      85,
 500                                      87,
 501                                      87,
 502                                      87,
 503                                      89,
 504                                      89,
 505                                      89,
 506                                      91,
 507                                      91,
 508                                      91,
 509                                      93,
 510                                      93,
 511                                      93,
 512                                      95,
 513                                      95,
 514                                      95,
 515                                      97,
 516                                      97,
 517                                      97,
 518                                      99,
 519                                      99,
 520                                      99,
 521                                      99,
 522                                      101,
 523                                      101,
 524                                      101,
 525                                      103,
 526                                      103,
 527                                      103,
 528                                      105,
 529                                      105,
 530                                      105,
 531                                      107,
 532                                      107,
 533                                      107,
 534                                      73,
 535                                      75,
 536                                      75,
 537                                      75,
 538                                      75,
 539                                      77,
 540                                      77,
 541                                      77,
 542                                      79,
 543                                      79,
 544                                      79,
 545                                      81,
 546                                      81,
 547                                      81,
 548                                      81,
 549                                      83,
 550                                      83,
 551                                      83,
 552                                      85,
 553                                      85,
 554                                      85,
 555                                      85,
 556                                      87,
 557                                      87,
 558                                      87,
 559                                      89,
 560                                      89,
 561                                      89,
 562                                      91,
 563                                      91,
 564                                      91,
 565                                      91,
 566                                      93,
 567                                      93,
 568                                      93,
 569                                      95,
 570                                      95,
 571                                      95,
 572                                      95,
 573                                      97,
 574                                      97,
 575                                      97,
 576                                      99,
 577                                      99,
 578                                      99,
 579                                      101,
 580                                      101,
 581                                      101,
 582                                      101,
 583                                      103,
 584                                      103,
 585                                      103,
 586                                      105,
 587                                      105,
 588                                      105,
 589                                      105,
 590                                      107,
 591                                      107,
 592                                      107,
 593                                      109,
 594                                      109,
 595                                      109,
 596                                      111,
 597                                      111,
 598                                      111,
 599                                      113,
 600                                      113,
 601                                      113,
 602                                      115,
 603                                      115,
 604                                      117,
 605                                      117,
 606                                      119,
 607                                      119,
 608                                      121,
 609                                      121,
 610                                      121,
 611                                      123,
 612                                      123,
 613                                      125,
 614                                      125,
 615                                      127,
 616                                      127,
 617                                      127,
 618                                      129,
 619                                      129,
 620                                      131,
 621                                      131,
 622                                      133,
 623                                      133,
 624                                      135,
 625                                      135,
 626                                      135,
 627                                      137,
 628                                      137,
 629                                      139
 630 };
 631
 632 Double_t AliL3Transform::fCos[36] = { 0.9848077297,
 633                                       0.8660253882,
 634                                       0.6427876353,
 635                                       0.3420201540,
 636                                       0.0000000000,
 637                                       -0.3420201540,
 638                                       -0.6427876353,
 639                                       -0.8660253882,
 640                                       -0.9848077297,
 641                                       -0.9848077297,
 642                                       -0.8660253882,
 643                                       -0.6427876353,
 644                                       -0.3420201540,
 645                                       -0.0000000000,
 646                                       0.3420201540,
 647                                       0.6427876353,
 648                                       0.8660253882,
 649                                       0.9848077297,
 650                                       0.9848077297,
 651                                       0.8660253882,
 652                                       0.6427876353,
 653                                       0.3420201540,
 654                                       0.0000000000,
 655                                       -0.3420201540,
 656                                       -0.6427876353,
 657                                       -0.8660253882,
 658                                       -0.9848077297,
 659                                       -0.9848077297,
 660                                       -0.8660253882,
 661                                       -0.6427876353,
 662                                       -0.3420201540,
 663                                       -0.0000000000,
 664                                       0.3420201540,
 665                                       0.6427876353,
 666                                       0.8660253882,
 667                                       0.9848077297
 668 };
 669
 670 Double_t AliL3Transform::fSin[36] = { 0.1736481786,
 671                                       0.5000000000,
 672                                       0.7660444379,
 673                                       0.9396926165,
 674                                       1.0000000000,
 675                                       0.9396926165,
 676                                       0.7660444379,
 677                                       0.5000000000,
 678                                       0.1736481786,
 679                                       -0.1736481786,
 680                                       -0.5000000000,
 681                                       -0.7660444379,
 682                                       -0.9396926165,
 683                                       -1.0000000000,
 684                                       -0.9396926165,
 685                                       -0.7660444379,
 686                                       -0.5000000000,
 687                                       -0.1736481786,
 688                                       0.1736481786,
 689                                       0.5000000000,
 690                                       0.7660444379,
 691                                       0.9396926165,
 692                                       1.0000000000,
 693                                       0.9396926165,
 694                                       0.7660444379,
 695                                       0.5000000000,
 696                                       0.1736481786,
 697                                       -0.1736481786,
 698                                       -0.5000000000,
 699                                       -0.7660444379,
 700                                       -0.9396926165,
 701                                       -1.0000000000,
 702                                       -0.9396926165,
 703                                       -0.7660444379,
 704                                       -0.5000000000,
 705                                       -0.1736481786
 706 };
 707
 708 Bool_t AliL3Transform::Init(Char_t* path,Bool_t UseAliTPCParam)
 709 {
 710   //Overwrite the parameters with values stored in file "l3transform.config" in path.
 711   //If file does not exist, old default values will be used.
 712   //If flag UseAliTPCParam is set, the parameters will be read from the the rootfile
 713   //which then has to be called path/digitfile.root
 714
 715   if(fVersion != fV_default)
 716     LOG(AliL3Log::kWarning,"AliL3Transform::Init","Init values")
 717       <<AliL3Log::kDec<<"You are initializing the parameters more than once; check your code please! "<<fVersion<<ENDLOG;
 718
 719   if(UseAliTPCParam) //use rootfile to generate temporary init file
 720     return ReadInit(path);
 721
 722   //create filename
 723   Char_t pathname[1024];
 724   strcpy(pathname,path);
 725
 726   //test whether provided path is the file itself
 727   //Long_t id=0,size=0,flags=0,modtime=0;
 728   //gSystem->GetPathInfo(pathname, &id, &size, &flags, &modtime);
 729   Int_t isdir = 0;// (Int_t)flags & 2;
 730   DIR *testdir=opendir(pathname);
 731   if(testdir){
 732     isdir=1;
 733     closedir(testdir);
 734   }
 735
 736   if(isdir) strcat(pathname,"/l3transform.config");
 737
 738   return ReadInitFile(pathname);
 739 }
 740
 741 Bool_t AliL3Transform::ReadInitFile(Char_t* pathname)
 742 {
 743   //read transformer settings from pathname
 744
 745   FILE *fptr=fopen(pathname,"r");
 746   if(!fptr){
 747     LOG(AliL3Log::kWarning,"AliL3Transform::Init","File Open")
 748       <<"Pointer to Config File \""<<pathname<<"\" 0x0!"<<ENDLOG;
 749     return kFALSE;
 750   }
 751
 752   Char_t d1[250], d2[100], d3[100];
 753   Int_t dummy=0;
 754   Double_t ddummy=0.0;
 755
 756   while(!feof(fptr)) {
 757     fscanf(fptr,"%s",d1);
 758     if(strcmp(d1,"fVersion")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fVersion=dummy;}
 759     else if(strcmp(d1,"fBFieldFactor")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fBFieldFactor=(Double_t)ddummy;}
 760     else if(strcmp(d1,"fSolenoidBField")==0)
 761       {
 762         fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);
 763         fSolenoidBField=(Double_t)ddummy;
 764       }
 765     else if(strcmp(d1,"fNTimeBins")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNTimeBins=(Int_t)dummy;}
 766     else if(strcmp(d1,"fNRowLow")==0)
 767       {
 768         fscanf(fptr,"%s %d %s",d2,&dummy,d3);
 769         fNRowLow=(Int_t)dummy;
 770         if(fNRowLow != 63)
 771           LOG(AliL3Log::kError,"AliL3Transform::Init","Overflow")
 772             <<"Number of inner PadRows should be 63! Check and fgrep the code for 63 to see the consequences of this major change!"<<ENDLOG;
 773       }
 774     else if(strcmp(d1,"fNRowUp")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRowUp=(Int_t)dummy;}
 775     else if(strcmp(d1,"fNRowUp1")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRowUp1=(Int_t)dummy;}
 776     else if(strcmp(d1,"fNRowUp2")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRowUp2=(Int_t)dummy;}
 777     else if(strcmp(d1,"fNSectorLow")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSectorLow=(Int_t)dummy;}
 778     else if(strcmp(d1,"fNSectorUp")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSectorUp=(Int_t)dummy;}
 779     else if(strcmp(d1,"fNSector")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSector=(Int_t)dummy;}
 780     else if(strcmp(d1,"fPadPitchWidthLow")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fPadPitchWidthLow=(Double_t)ddummy;}
 781     else if(strcmp(d1,"fPadPitchWidthUp")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fPadPitchWidthUp=(Double_t)ddummy;}
 782     else if(strcmp(d1,"fZWidth")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZWidth=(Double_t)ddummy;}
 783     else if(strcmp(d1,"fZSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZSigma=(Double_t)ddummy;}
 784     else if(strcmp(d1,"fZLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZLength=(Double_t)ddummy;}
 785     else if(strcmp(d1,"fZOffset")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZOffset=(Double_t)ddummy;}
 786     else if(strcmp(d1,"fNSlice")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSlice=(Int_t)dummy;}
 787     else if(strcmp(d1,"fDiffT")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fDiffT=(Double_t)ddummy;}
 788     else if(strcmp(d1,"fDiffL")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fDiffL=(Double_t)ddummy;}
 789     else if(strcmp(d1,"fOmegaTau")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOmegaTau=(Double_t)ddummy;}
 790     else if(strcmp(d1,"fInnerPadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fInnerPadLength=(Double_t)ddummy;}
 791     else if(strcmp(d1,"fOuter1PadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter1PadLength=(Double_t)ddummy;}
 792     else if(strcmp(d1,"fOuter2PadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter2PadLength=(Double_t)ddummy;}
 793     else if(strcmp(d1,"fInnerPRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fInnerPRFSigma=(Double_t)ddummy;}
 794     else if(strcmp(d1,"fOuter1PRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter1PRFSigma=(Double_t)ddummy;}
 795     else if(strcmp(d1,"fOuter2PRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter2PRFSigma=(Double_t)ddummy;}
 796     else if(strcmp(d1,"fTimeSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fTimeSigma=(Double_t)ddummy;}
 797     else if(strcmp(d1,"fADCSat")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fADCSat=(Int_t)dummy;}
 798     else if(strcmp(d1,"fZeroSup")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fZeroSup=(Int_t)dummy;}
 799     else if(strcmp(d1,"fNRow")==0){
 800       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRow=(Int_t)dummy;
 801       if(fNRow!=159){
 802         LOG(AliL3Log::kError,"AliL3Transform::Init","Overflow")<<"Number of PadRows should be 159! Check and fgrep the code for 159 to see the consequences of this major change!"<<ENDLOG;
 803       }
 804     }
 805     else if(strcmp(d1,"fNRotShift")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fNRotShift=(Double_t)ddummy;}
 806     else if(strcmp(d1,"fX[0]")==0){
 807       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fX[0]=(Double_t)ddummy;
 808       for(Int_t i=1;i<fNRow;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fX[i]=(Double_t)ddummy;}
 809     }
 810     else if(strcmp(d1,"fNPads[0]")==0){
 811       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNPads[0]=(Int_t)dummy;
 812       for(Int_t i=1;i<fNRow;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fNPads[i]=(Int_t)dummy;}
 813     }
 814     else if(strcmp(d1,"fNRows[0]")==0){
 815       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRows[0]=(Int_t)dummy;
 816       for(Int_t i=1;i<fNPatches;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fNRows[i]=(Int_t)dummy;}
 817     }
 818     else if(strcmp(d1,"fRows[0][0]")==0){
 819       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fRows[0][0]=(Int_t)dummy;
 820       fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fRows[0][1]=(Int_t)dummy;
 821       for(Int_t i=1;i<fNPatches;i++){
 822         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fRows[i][0]=(Int_t)dummy;
 823         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fRows[i][1]=(Int_t)dummy;
 824       }
 825     }
 826     else if(strcmp(d1,"fSlice2Sector[0][0]")==0){
 827       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fSlice2Sector[0][0]=(Int_t)dummy;
 828       fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSlice2Sector[0][1]=(Int_t)dummy;
 829       for(Int_t i=1;i<fNSlice;i++){
 830         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSlice2Sector[i][0]=(Int_t)dummy;
 831         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSlice2Sector[i][1]=(Int_t)dummy;
 832       }
 833     }
 834     else if(strcmp(d1,"fSector2Slice[0]")==0){
 835       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fSector2Slice[0]=(Int_t)dummy;
 836       for(Int_t i=1;i<fNSector;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSector2Slice[i]=(Int_t)dummy;}
 837     }
 838     else if(strcmp(d1,"fSectorLow[0]")==0){
 839       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fSectorLow[0]=(Int_t)dummy;
 840       for(Int_t i=1;i<fNSector;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSectorLow[i]=(Int_t)dummy;}
 841     }
 842     else if(strcmp(d1,"fCos[0]")==0){
 843       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fCos[0]=(Double_t)ddummy;
 844       for(Int_t i=1;i<fNSlice;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fCos[0]=(Double_t)ddummy;}
 845     }
 846     else if(strcmp(d1,"fSin[0]")==0){
 847       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fSin[0]=(Double_t)ddummy;
 848       for(Int_t i=1;i<fNSlice;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fSin[0]=(Double_t)ddummy;}
 849     }
 850   }
 851
 852   //The first multiplier gives the scale factor used to modify the field map
 853   //defined by the second multiplier.
 854   fBField=fBFieldFactor*fSolenoidBField*0.1;
 855
 856   fclose(fptr);
 857
 858   //Test if new config file has been used.
 859   if(fVersion==fV_deprecated){
 860     LOG(AliL3Log::kError,"AliL3Transform::Init","Version")
 861       <<"Version is deprecated, you have to create a new config file."<<ENDLOG;
 862     return kFALSE;
 863   }
 864
 865   return kTRUE;
 866 }
 867
 868 Bool_t AliL3Transform::ReadInit(Char_t *path)
 869 {
 870   //Read all the parameters from a aliroot file, and store it in a temporary
 871   //file which is read by Init. Use this if you want to read the parameters from
 872   //the rootfile "every" time.
 873
 874 #ifndef use_aliroot
 875   LOG(AliL3Log::kError,"AliL3Transform::ReadInit","Version")
 876     <<"You have to compile with use_aliroot flag in order to read from AliROOT file"<<ENDLOG;
 877   return kFALSE;
 878 #else
 879   Char_t filename[1024];
 880   //first test whether provided path is the rootfile itself
 881   Int_t saveErrIgLevel=gErrorIgnoreLevel;
 882   gErrorIgnoreLevel=kFatal; //dont report errors
 883   TFile *rootfile = TFile::Open(path);
 884   if(rootfile->IsZombie())
 885     { //ok assume its path to alirunfile file
 886       sprintf(filename,"%s/alirunfile.root",path); //create rootfile name
 887     } else { //path contains itself the rootfile name
 888       rootfile->Close();
 889       sprintf(filename,"%s",path);
 890     }
 891   gErrorIgnoreLevel=saveErrIgLevel;
 892   //finally make dummy init file /tmp/l3transform.config
 893   if(MakeInitFile(filename,"/tmp/"))
 894     {
 895       Bool_t ret=Init("/tmp/");
 896       //Move the temp file to /tmp/l3transform.config-"time in seconds"
 897       TTimeStamp time;
 898       sprintf(filename,"/tmp/l3transform.config-%ld",(long)time.GetSec());
 899       gSystem->Rename("/tmp/l3transform.config",filename);
 900       return ret;
 901     }
 902
 903   return kFALSE;
 904 #endif
 905 }
 906
 907 Bool_t AliL3Transform::MakeInitFile(Char_t *filename,Char_t *path)
 908 {
 909   //Get the parameters from rootfile, and store it on the file "l3transform.config"
 910   //which is being read by Init. fVersion will be fV_aliroot!
 911
 912 #ifndef use_aliroot
 913   LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","Version")
 914     <<"You have to compile with use_aliroot flag in order to use this function"<<ENDLOG;
 915   return kFALSE;
 916 #else
 917   TFile *rootfile = TFile::Open(filename);
 918   if(!rootfile)
 919     {
 920       LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","File")
 921         <<"Could not open file: "<<filename<<ENDLOG;
 922       return kFALSE;
 923     }
 924   AliRun *gAlice = (AliRun*)rootfile->Get("gAlice");
 925   if(!gAlice)
 926     {
 927       LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","File")
 928         <<"No gAlice in file: "<<filename<<ENDLOG;
 929       return kFALSE;
 930     }
 931   AliTPCParamSR *param=(AliTPCParamSR*)rootfile->Get(GetParamName());
 932   if(!param)
 933     {
 934       LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","File")
 935         <<"No TPC parameters found"<<ENDLOG;
 936       return kFALSE;
 937     }
 938
 939   AliTPCPRF2D    * prfinner    = new AliTPCPRF2D;
 940   AliTPCPRF2D    * prfouter1   = new AliTPCPRF2D;
 941   AliTPCPRF2D    * prfouter2   = new AliTPCPRF2D;
 942   AliTPCRF1D     * rf    = new AliTPCRF1D(kTRUE);
 943   rf->SetGauss(param->GetZSigma(),param->GetZWidth(),1.);
 944   rf->SetOffset(3*param->GetZSigma());
 945   rf->Update();
 946
 947   TDirectory *savedir=gDirectory;
 948   TFile *prf_file = TFile::Open("$ALICE_ROOT/TPC/AliTPCprf2d.root");
 949   if (!prf_file->IsOpen())
 950     {
 951       LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","File")
 952         <<"Can't open $ALICE_ROOT/TPC/AliTPCprf2d.root !"<<ENDLOG;
 953       return kFALSE;
 954     }
 955   prfinner ->Read("prf_07504_Gati_056068_d02");
 956   prfouter1->Read("prf_10006_Gati_047051_d03");
 957   prfouter2->Read("prf_15006_Gati_047051_d03");
 958   prf_file->Close();
 959   savedir->cd();
 960
 961   param->SetInnerPRF(prfinner);
 962   param->SetOuter1PRF(prfouter1);
 963   param->SetOuter2PRF(prfouter2);
 964   param->SetTimeRF(rf);
 965
 966   fNTimeBins = param->GetMaxTBin()+1;
 967   fNRowLow = param->GetNRowLow();
 968   fNRowUp  = param->GetNRowUp();
 969   fNRowUp1 = param->GetNRowUp1();
 970   fNRowUp2 = param->GetNRowUp2();
 971   fNRow= fNRowLow + fNRowUp;
 972   if(fNRow!=159){
 973     LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","fNRow")
 974       <<"Number of rows have changed in ALIROOT"<<ENDLOG;
 975     return kFALSE;
 976   }
 977
 978   fNSectorLow = param->GetNInnerSector();
 979   fNSectorUp = param->GetNOuterSector();
 980   fNSector = fNSectorLow + fNSectorUp;
 981
 982   //test whether they were changes to the rotation shift
 983   fNRotShift=0;
 984   Float_t irotshift = param->GetInnerAngleShift(); //shift angle
 985   Float_t orotshift = param->GetOuterAngleShift(); //shift angle
 986   const Float_t kDegtoRad = 0.01745329251994;
 987   Int_t shift1=TMath::Nint(irotshift/kDegtoRad);
 988   Int_t shift2=TMath::Nint(orotshift/kDegtoRad+0.1);
 989   if((shift1!=shift2) || (shift1!=10)){
 990     LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","Rotshiftangle")
 991       <<"Rotation shift angle has changed in ALIROOT"<<ENDLOG;
 992     return kFALSE;
 993   } else {
 994     fNRotShift=0.5; //our version of the shift angle
 995   }
 996
 997   fVersion=fV_aliroot;
 998   fBFieldFactor=(Double_t)gAlice->Field()->Factor();
 999   fSolenoidBField=(Double_t)gAlice->Field()->SolenoidField();
1000   fPadPitchWidthLow=param->GetInnerPadPitchWidth();
1001   fPadPitchWidthUp=param->GetOuterPadPitchWidth();
1002   fZWidth=param->GetZWidth();
1003   fZSigma=param->GetZSigma();
1004   fZLength=param->GetZLength();
1005   fZOffset=param->GetZOffset();
1006   fDiffT=param->GetDiffT();
1007   fDiffL=param->GetDiffL();
1008   fOmegaTau=param->GetOmegaTau();
1009   fInnerPadLength=param->GetInnerPadLength();
1010   fOuter1PadLength=param->GetOuter1PadLength();
1011   fOuter2PadLength=param->GetOuter2PadLength();
1012   fInnerPRFSigma=param->GetInnerPRF()->GetSigmaX();
1013   fOuter1PRFSigma=param->GetOuter1PRF()->GetSigmaX();
1014   fOuter2PRFSigma=param->GetOuter2PRF()->GetSigmaX();
1015   fTimeSigma=param->GetTimeRF()->GetSigma();
1016   fADCSat=param->GetADCSat();
1017   fZeroSup=param->GetZeroSup();
1018   fNSlice=fNSectorLow;
1019
1020   //now do the arrays
1021   for(Int_t i=0;i<fNRow;i++){
1022     Int_t sec,row;
1023     if( i < fNRowLow){sec =0;row =i;}
1024     else{sec = fNSectorLow;row =i-fNRowLow;}
1025     fX[i]=param->GetPadRowRadii(sec,row);
1026   }
1027   for(Int_t i=0;i<fNRow;i++){
1028     Int_t sec,row;
1029     if( i < fNRowLow){sec =0;row =i;}
1030     else{sec = fNSectorLow;row =i-fNRowLow;}
1031     fNPads[i]=param->GetNPads(sec,row);
1032   }
1033   for(Int_t i=0;i<fNSector;i++){
1034     if(i<fNSectorLow) fSectorLow[i]=1;
1035     else fSectorLow[i]=0;
1036   }
1037   //generate filename
1038   Char_t tofile[1024];
1039   sprintf(tofile,"%s/l3transform.config",path);
1040   //cout << tofile <<endl;
1041   return SaveInitFile(tofile);
1042 #endif
1043 }
1044
1045 Bool_t AliL3Transform::SaveInitFile(Char_t *filenamepath)
1046 {
1047   //store the parameters in the file "filenamepath"
1048
1049   FILE *f = fopen(filenamepath,"w");
1050   if(!f){
1051     //todo
1052     return kFALSE;
1053   }
1054
1055   fprintf(f,"void AliL3Transform::Init(){\n");
1056   fprintf(f,"  fVersion = %d;\n", fVersion);
1057   fprintf(f,"  fBFieldFactor = %.3f;\n",fBFieldFactor);
1058   fprintf(f,"  fSolenoidBField = %.3f;\n",fSolenoidBField);
1059   fprintf(f,"  fNTimeBins = %d;\n",fNTimeBins);
1060   fprintf(f,"  fNRowLow = %d;\n",fNRowLow);
1061   fprintf(f,"  fNRowUp = %d;\n",fNRowUp);
1062   fprintf(f,"  fNRowUp1 = %d;\n",fNRowUp1);
1063   fprintf(f,"  fNRowUp2 = %d;\n",fNRowUp2);
1064   fprintf(f,"  fNSectorLow = %d;\n",fNSectorLow);
1065   fprintf(f,"  fNSectorUp = %d;\n",fNSectorUp);
1066   fprintf(f,"  fNSector = %d;\n",fNSector);
1067   fprintf(f,"  fPadPitchWidthLow = %.3f;\n",fPadPitchWidthLow);
1068   fprintf(f,"  fPadPitchWidthUp = %.3f;\n",fPadPitchWidthUp);
1069   fprintf(f,"  fZWidth = %.4f;\n",fZWidth);
1070   fprintf(f,"  fZSigma = %.4f;\n",fZSigma);
1071   fprintf(f,"  fZLength = %.4f;\n",fZLength);
1072   fprintf(f,"  fZOffset = %.4f;\n",fZOffset);
1073   fprintf(f,"  fDiffT = %.4f;\n",fDiffT);
1074   fprintf(f,"  fDiffL = %.4f;\n",fDiffL);
1075   fprintf(f,"  fOmegaTau = %.4f;\n",fOmegaTau);
1076   fprintf(f,"  fInnerPadLength = %.3f;\n",fInnerPadLength);
1077   fprintf(f,"  fOuter1PadLength = %.3f;\n",fOuter1PadLength);
1078   fprintf(f,"  fOuter2PadLength = %.3f;\n",fOuter2PadLength);
1079   fprintf(f,"  fInnerPRFSigma = %.6f;\n",fInnerPRFSigma);
1080   fprintf(f,"  fOuter1PRFSigma = %.6f;\n",fOuter1PRFSigma);
1081   fprintf(f,"  fOuter2PRFSigma = %.6f;\n",fOuter2PRFSigma);
1082   fprintf(f,"  fTimeSigma = %.6f;\n",fTimeSigma);
1083   fprintf(f,"  fADCSat = %d;\n",fADCSat);
1084   fprintf(f,"  fZeroSup = %d;\n",fZeroSup);
1085   fprintf(f,"  fNSlice = %d;\n",fNSlice);
1086   fprintf(f,"  fNRow = %d;\n",fNRow);
1087   fprintf(f,"  fNRotShift = %.2f;\n",fNRotShift);
1088   //now do the arrays
1089   for(Int_t i=0;i<fNRow;i++){
1090     fprintf(f,"  fX[%d] = %3.2f;\n",i,fX[i]);
1091   }
1092   for(Int_t i=0;i<fNRow;i++){
1093     fprintf(f,"  fNPads[%d] = %d;\n",i,fNPads[i]);
1094   }
1095
1096   //Slice/Sector dont belong to aliroot, but we want to be flexible
1097   for(Int_t i=0;i<fNSlice;i++){
1098     fprintf(f,"  fSlice2Sector[%d][0] = %d;\n",i,fSlice2Sector[i][0]);
1099     fprintf(f,"  fSlice2Sector[%d][1] = %d;\n",i,fSlice2Sector[i][1]);
1100   }
1101   for(Int_t i=0;i<fNSector;i++){
1102     fprintf(f,"  fSector2Slice[%d] = %d;\n",i,fSector2Slice[i]);
1103   }
1104   for(Int_t i=0;i<fNSector;i++){
1105     fprintf(f,"  fSectorLow[%d] = %d;\n",i,fSectorLow[i]);
1106   }
1107
1108   //Patches also dont really belong to the aliroot settings (but nevermind)
1109   for(Int_t i=0;i<fNPatches;i++){
1110     fprintf(f,"  fNRows[%d] = %d;\n",i,fNRows[i]);
1111   }
1112   for(Int_t i=0;i<fNPatches;i++){
1113     fprintf(f,"  fRows[%d][0] = %d;\n",i,fRows[i][0]);
1114     fprintf(f,"  fRows[%d][1] = %d;\n",i,fRows[i][1]);
1115   }
1116
1117   //Rotation shift is an addon, too
1118   for(Int_t i=0;i<fNSlice;i++){
1119     Float_t cs = cos( (2*fPi/18) * (i+fNRotShift) );
1120     fprintf(f,"  fCos[%d] = %.10f;\n",i,cs);
1121   }
1122   for(Int_t i=0;i<fNSlice;i++){
1123     Float_t sn = sin( (2*fPi/18) * (i+fNRotShift) );
1124     fprintf(f,"  fSin[%d] = %.10f;\n",i,sn);
1125   }
1126
1127   fprintf(f,"}\n");
1128   fclose(f);
1129
1130   LOG(AliL3Log::kInformational,"AliL3Transform::SaveInitFile","File created")
1131     <<"Init file \""<<filenamepath<<"\" created"<<ENDLOG;
1132
1133   return kTRUE;
1134 }
1135
1136 Int_t AliL3Transform::GetNPads(Int_t row)
1137 {
1138   if(row < 0 || row >= fNRow)
1139     {
1140       LOG(AliL3Log::kError,"AliL3Transform::GetNPads","Row")
1141         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1142       return 0;
1143     }
1144
1145   return fNPads[row];
1146 }
1147
1148 Int_t AliL3Transform::GetFirstRow(Int_t patch)
1149 {
1150   if(patch==-1)
1151     return 0;
1152   else if(patch < -1 || patch >= 6)
1153     {
1154       LOG(AliL3Log::kError,"AliL3Transform::GetFirstRow","Patch")
1155         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1156       return 0;
1157     }
1158   else
1159     return fRows[patch][0];
1160 }
1161
1162 Int_t AliL3Transform::GetLastRow(Int_t patch)
1163 {
1164   if(patch==-1)
1165     return fRows[5][1];
1166   else if(patch < -1 || patch >= 6)
1167     {
1168       LOG(AliL3Log::kError,"AliL3Transform::GetLastRow","Patch")
1169         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1170       return 0;
1171     }
1172   else
1173     return fRows[patch][1];
1174 }
1175
1176 Int_t AliL3Transform::GetNRows(Int_t patch)
1177 {
1178   if(patch==-1)
1179     return fNRow;
1180   else if(patch < -1 || patch >= 6)
1181     {
1182       LOG(AliL3Log::kError,"AliL3Transform::GetNRows","Patch")
1183         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1184       return 0;
1185     }
1186   else
1187     return fNRows[patch];
1188 }
1189
1190 Int_t AliL3Transform::GetPadRow(Float_t xvalue)
1191 {
1192   //Find the padrow number corresponding to cartesian _local_ x value
1193
1194   if(xvalue < 0 || xvalue > 250)
1195     {
1196       LOG(AliL3Log::kError,"AliL3Transform::GetPadRow","X-value")
1197         <<AliL3Log::kDec<<"Suspicious x-value, make sure it is in local coordinate! "
1198         <<xvalue<<ENDLOG;
1199       return -1;
1200     }
1201
1202   Int_t x = (Int_t)rint(xvalue*10);
1203   if(x < (Int_t)rint(fX[1]*10))
1204     return 0;
1205   else if(x > (Int_t)rint(fX[fNRow-2]*10))
1206     return fNRow-1;
1207   else
1208     {
1209       Int_t padrow=1; //Of course, a more clever algorithm could help here
1210       while(padrow < fNRow-2)
1211         {
1212           if(x > (Int_t)rint(fX[padrow-1]*10) && x < (Int_t)rint(fX[padrow+1]*10))
1213             break;
1214           padrow++;
1215         }
1216       return padrow;
1217     }
1218 }
1219
1220 Int_t AliL3Transform::GetPatch(Int_t padrow)
1221 {
1222   if(padrow < 0 || padrow >= fNRow)
1223     {
1224       LOG(AliL3Log::kError,"AliL3Transform::GetPatch","Padrow")
1225         <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1226       return -2;
1227     }
1228   Int_t patch=0;
1229   while(patch < fNPatches)
1230     {
1231       if(padrow >= fRows[patch][0] && padrow <= fRows[patch][1])
1232         break;
1233       patch++;
1234     }
1235   return patch;
1236 }
1237
1238 Double_t AliL3Transform::GetPadLength(Int_t padrow)
1239 {
1240   if(padrow >= fNRow){
1241       LOG(AliL3Log::kError,"AliL3Transform::GetPadLength","Padrow")
1242         <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1243       return 0;
1244     }
1245
1246   if(padrow < fNRowLow)
1247     return fInnerPadLength;
1248   if(padrow >= fNRowLow && padrow < fNRowLow + fNRowUp1 - 1)
1249     return fOuter1PadLength;
1250   if(padrow >= fNRowLow + fNRowUp1 - 1)
1251     return fOuter2PadLength;
1252
1253   //should never happen
1254   LOG(AliL3Log::kError,"AliL3Transform::GetPadLength","Padrow")
1255     <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1256   return -1.0;
1257 }
1258
1259 Double_t AliL3Transform::GetPadPitchWidth(Int_t patch)
1260 {
1261   if(patch < 0 || patch > fNPatches)
1262     {
1263       LOG(AliL3Log::kError,"AliL3Transform::GetPadPitchWidth","patct")
1264         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1265       return -1;
1266     }
1267   return patch < 2 ? fPadPitchWidthLow : fPadPitchWidthUp;
1268 }
1269
1270 Double_t AliL3Transform::GetParSigmaY2(Int_t padrow,Float_t z,Float_t angle)
1271 {
1272   //Calculate the expected transverse cluster width as a function of
1273   //drift distance and crossing angle.
1274   //z = local z-coordinate of cluster
1275   //angle = track crossing angle with normal to padrow plane
1276   //return value = sigma^2 (cartesian coordinates)
1277
1278   Double_t drift;
1279   if(z > 0)
1280     drift = fZLength - z;
1281   else
1282     drift = fZLength + z;
1283
1284   Double_t t1 = GetPRFSigma(padrow)*GetPRFSigma(padrow);
1285   Double_t t2 = fDiffT*fDiffT*drift;
1286   Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tan(angle)*tan(angle)/12;
1287   Double_t t4 = fAnodeWireSpacing*fAnodeWireSpacing*(tan(angle) - fOmegaTau)*(tan(angle) - fOmegaTau)/12;
1288
1289   return (t1 + t2 + t3 + t4);
1290 }
1291
1292 Double_t AliL3Transform::GetParSigmaZ2(Int_t padrow,Float_t z,Float_t tgl)
1293 {
1294   //Calculate the expected longitudinal cluster width as a function of
1295   //drift distance and track crossing angle.
1296   //z = local z-coordinate of cluster
1297   //tgl = tan(dipangle)
1298   //return value = sigma^2 (cartesian coordinates)
1299
1300   Double_t drift;
1301   if(z > 0)
1302     drift = AliL3Transform::GetZLength() - z;
1303   else
1304     drift = AliL3Transform::GetZLength() + z;
1305
1306   Double_t t1 = fZSigma*fZSigma;
1307   Double_t t2 = fDiffL*fDiffL*drift;
1308   Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tgl*tgl/12;
1309
1310   return (t1 + t2 + t3);
1311 }
1312
1313 Double_t AliL3Transform::GetPRFSigma(Int_t padrow)
1314 {
1315   if(padrow >= fNRow){
1316     LOG(AliL3Log::kError,"AliL3Transform::GetPRFSigma","Padrow")
1317       <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1318     return 0;
1319   }
1320   if(padrow < fNRowLow)
1321     return fInnerPRFSigma;
1322   if(padrow >= fNRowLow && padrow < fNRowLow + fNRowUp1 - 1)
1323     return fOuter1PRFSigma;
1324   if(padrow >= fNRowLow + fNRowUp1 - 1)
1325     return fOuter2PRFSigma;
1326
1327   //should never happen
1328   LOG(AliL3Log::kError,"AliL3Transform::GetPRFSigma","Padrow")
1329     <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1330   return -1.;
1331 }
1332
1333 Double_t AliL3Transform::GetEta(Float_t *xyz)
1334 {
1335   Double_t r3 = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1336   Double_t eta = 0.5 * log((r3+xyz[2])/(r3-xyz[2]));
1337   return eta;
1338 }
1339
1340 void AliL3Transform::XYZtoRPhiEta(Float_t *rpe, Float_t *xyz)
1341 {
1342   rpe[0] = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1343   rpe[1] = atan2(xyz[1],xyz[0]);
1344   rpe[2] = 0.5 * log((rpe[0]+xyz[2])/(rpe[0]-xyz[2]));
1345 }
1346
1347 Double_t AliL3Transform::GetEta(Int_t slice,Int_t padrow,Int_t pad,Int_t time)
1348 {
1349   Float_t xyz[3];
1350   Int_t sector,row;
1351   Slice2Sector(slice,padrow,sector,row);
1352   Raw2Local(xyz,sector,row,pad,time);
1353
1354   return GetEta(xyz);
1355 }
1356
1357 Double_t AliL3Transform::GetPhi(Float_t *xyz)
1358 {
1359   Double_t phi = atan2(xyz[1],xyz[0]);
1360   return phi;
1361 }
1362
1363 Bool_t AliL3Transform::Slice2Sector(Int_t slice, Int_t slicerow, Int_t & sector, Int_t &row)
1364 {
1365   if(slicerow<0&&slicerow>=fNRow){
1366     LOG(AliL3Log::kError,"AliL3Transform::Slice2Sector","Slicerow")
1367       <<AliL3Log::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1368     return kFALSE;
1369   }
1370   if(slice<0||slice>=fNSlice){
1371     LOG(AliL3Log::kError,"AliL3Transform::Slice2Sector","Slice")
1372       <<AliL3Log::kDec<<"Wrong slice "<<slice<<ENDLOG;
1373     return kFALSE;
1374   }
1375
1376   if(slicerow<fNRowLow){
1377     sector = fSlice2Sector[slice][0];
1378     row    = slicerow;
1379   }
1380   else {
1381     sector = fSlice2Sector[slice][1];
1382     row    = slicerow-fNRowLow;
1383   }
1384
1385   return kTRUE;
1386 }
1387
1388 Bool_t AliL3Transform::Sector2Slice(Int_t & slice, Int_t  sector)
1389 {
1390   if(sector<0||sector>=fNSector){
1391     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Sector")
1392       <<AliL3Log::kDec<<"Wrong sector "<<sector<<ENDLOG;
1393     return kFALSE;
1394   }
1395
1396   slice=fSector2Slice[sector];
1397
1398   return kTRUE;
1399 }
1400
1401 Bool_t AliL3Transform::Sector2Slice(Int_t & slice, Int_t & slicerow, Int_t sector, Int_t row)
1402 {
1403   if(sector<0 || sector>=fNSector){
1404     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Sector")
1405       <<AliL3Log::kDec<<"Wrong sector "<<sector<<ENDLOG;
1406     return kFALSE;
1407   }
1408   if(row<0){
1409     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1410       <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1411     return kFALSE;
1412   }
1413
1414   if(fSectorLow[sector]){
1415     if(row>=fNRowLow){
1416       LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1417         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1418       return kFALSE;
1419     }
1420     slice = fSector2Slice[sector];
1421     slicerow = row;
1422   }
1423   else{
1424     if(row>=fNRowUp){
1425       LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1426         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1427       return kFALSE;
1428     }
1429     slice = fSector2Slice[sector];
1430     slicerow = row + fNRowLow;
1431   }
1432
1433   return kTRUE;
1434 }
1435
1436 Double_t AliL3Transform::Row2X(Int_t slicerow){
1437   if(slicerow<0||slicerow>=fNRow){
1438     LOG(AliL3Log::kError,"AliL3Transform::Row2X","Slicerow")
1439       <<AliL3Log::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1440     return 0;
1441   }
1442   return fX[slicerow];
1443 }
1444
1445 void AliL3Transform::Local2Global(Float_t *xyz,Int_t slice)
1446 {
1447   //Transformation to global coordinate system
1448   Float_t x0 = xyz[0];
1449   Float_t y0 = xyz[1];
1450
1451   xyz[0]=x0*fCos[slice]-y0*fSin[slice];
1452   xyz[1]=x0*fSin[slice]+y0*fCos[slice];
1453   xyz[2]=xyz[2];//global z=local z
1454 }
1455
1456 void AliL3Transform::Local2GlobalAngle(Float_t *angle,Int_t slice){
1457   angle[0] = fmod(angle[0]+(slice+fNRotShift)*(2*fPi/18),2*fPi);
1458 }
1459
1460 void AliL3Transform::Global2LocalAngle(Float_t *angle,Int_t slice){
1461   angle[0] = angle[0]-(slice+fNRotShift)*(2*fPi/18);
1462   if(angle[0]<0) angle[0]+=2*fPi;
1463 }
1464
1465 void AliL3Transform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1466 {
1467   //Transformation from rawdata to local coordinate system
1468
1469   Int_t slice,slicerow;
1470   Sector2Slice(slice, slicerow, sector, row);
1471
1472   //X-Value
1473   xyz[0]=Row2X(slicerow);
1474
1475   //Y-Value
1476   Int_t npads= fNPads[slicerow];
1477
1478   if(fSectorLow[sector])
1479     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthLow;
1480   else
1481     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthUp;
1482
1483   //Z-Value (remember PULSA Delay)
1484   //xyz[2]=fZWidth*time-3.*fZSigma;
1485   xyz[2]=fZWidth*time-fZOffset;
1486   if(slice < 18)
1487     xyz[2]=fZLength-xyz[2];
1488   else
1489     xyz[2]=xyz[2]-fZLength;
1490 }
1491
1492 void AliL3Transform::Local2Global(Float_t *xyz,Int_t sector,Int_t row)
1493 {
1494   //Transformation to global coordinate system
1495   Int_t slice,slicerow;
1496   Sector2Slice(slice, slicerow, sector, row);
1497   Float_t r=Row2X(slicerow); //have to get x value first
1498
1499   xyz[0]=r*fCos[slice]-xyz[1]*fSin[slice];
1500   xyz[1]=r*fSin[slice]+xyz[1]*fCos[slice];
1501   xyz[2]=xyz[2];//global z=local z
1502 }
1503
1504 Double_t AliL3Transform::GetMaxY(Int_t slicerow)
1505 {
1506
1507  if(slicerow < fNRowLow)
1508      return fPadPitchWidthLow*fNPads[slicerow]/2;
1509
1510  else
1511      return fPadPitchWidthUp*fNPads[slicerow]/2;
1512
1513 }
1514
1515 void AliL3Transform::Global2Local(Float_t *xyz,Int_t sector,Bool_t isSlice)
1516 {
1517   Int_t slice;
1518   if(!isSlice)
1519     Sector2Slice(slice, sector);
1520   else
1521     slice = sector;
1522
1523   Float_t x1 =  xyz[0]*fCos[slice] + xyz[1]*fSin[slice];
1524   Float_t y1 = -xyz[0]*fSin[slice] + xyz[1]*fCos[slice];
1525   xyz[0] = x1;
1526   xyz[1] = y1;
1527 }
1528
1529 void AliL3Transform::Raw2Global(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1530 {
1531   //Transformation from raw to global coordinates
1532
1533   Raw2Local(xyz,sector,row,pad,time);
1534   Local2Global(xyz,sector,row);
1535 }
1536
1537 void AliL3Transform::Local2Raw(Float_t *xyz,Int_t sector,Int_t row)
1538 {
1539   //Transformation from local coordinates to raw
1540
1541   Int_t slice,slicerow;
1542   Sector2Slice(slice, slicerow, sector, row);
1543
1544   xyz[0]=slicerow;
1545   //xyz[0]=GetPadRow(xyz[0]);
1546
1547   if(fSectorLow[sector])
1548     xyz[1]=xyz[1]/fPadPitchWidthLow+0.5*(fNPads[slicerow]-1);
1549   else
1550     xyz[1]=xyz[1]/fPadPitchWidthUp+0.5*(fNPads[slicerow]-1);
1551
1552   Int_t sign=-1;
1553   if(slice < 18) sign = 1;
1554   xyz[2]=fZLength-sign*xyz[2];
1555   xyz[2]=(xyz[2]+fZOffset)/fZWidth;
1556 }
1557
1558 void AliL3Transform::Global2Raw(Float_t *xyz,Int_t sector,Int_t row)
1559 {
1560   //Transformation from global coordinates to raw.
1561
1562   Global2Local(xyz,sector);
1563   Local2Raw(xyz,sector,row);
1564 }
1565
1566 void AliL3Transform::PrintCompileOptions()
1567 {
1568   cout << "Compiler (g++) version used: " << GCCVERSION << endl;
1569
1570 #ifdef no_root
1571   cout << "STANDALONE version: -Dno_root was given." << endl;
1572 #else
1573   const Char_t *roottest="$ROOTSYS/bin/root -n -b -q  | grep Version | cut -b 17-25 | cut -d\" \" -f1";
1574 #ifdef use_aliroot
1575 #ifdef use_cvs
1576   const Char_t *aliroottest="if test -n \"`cd $ALICE_ROOT/STEER/ && cvs stat AliRun.cxx | grep \"Sticky Tag\" | grep none`\"; then echo HEAD; else cd $ALICE_ROOT/STEER/ && cvs stat AliRun.cxx | grep \"Sticky Tag\" | cut -b 18- | cut -d\" \" -f1; fi";
1577 #else
1578   const Char_t *aliroottest="Unknown";
1579 #endif
1580   cout << "ALIROOT version: -Duse_aliroot and -Duse_root was given." << endl;
1581   cout << "Root Version: " << ROOTVERSION << " found " << flush;
1582   gSystem->Exec(roottest);
1583
1584   cout << "AliRoot Version: " << ALIROOTVERSION << " found " << flush;
1585   gSystem->Exec(aliroottest);
1586 #else
1587   cout << "ROOT version: -Duse_root was given." << endl;
1588   cout << "Root Version: " << ROOTVERSION << " found " << flush;
1589   gSystem->Exec(roottest);
1590 #endif
1591 #endif
1592
1593 #ifdef do_mc
1594   cout << "Using Monte Carlo Info: -Ddo_mc was given." << endl;
1595 #else
1596   cout << "NOT using Monte Carlo Info: -Ddo_mc was not given." << endl;
1597 #endif
1598
1599 #ifdef use_logging
1600   cout << "Using logging classes (MLUC): -Duse_logging was given." << endl;
1601 #else
1602   cout << "NOT using logging classes (MLUC): -Duse_logging not was given." << endl;
1603 #endif
1604
1605 #ifdef ASVVERSION
1606   cout << "Using ASV version for the digitization: -DASVVERSION was given." << endl;
1607 #else
1608   cout << "NOT using ASV version for the digitization: -DASVVERSION was not given." << endl;
1609 #endif
1610 }