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 defined(__GNUC__) && __GNUC__ == 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 ClassImp(AliL3Transform)
  78
  79 const Double_t AliL3Transform::fAnodeWireSpacing = 0.25; //Taken from the TDR
  80 const Double_t AliL3Transform::fBFACT = 0.0029980;       //Conversion Factor
  81 const Double_t AliL3Transform::fPi  =   3.141592653589793;
  82 const Double_t AliL3Transform::f2Pi = 2*3.141592653589793;
  83 const Double_t AliL3Transform::fPi2 = 0.5*3.141592653589793;
  84 const Double_t AliL3Transform::fToDeg = 180/3.141592653589793;
  85
  86 //Defined by HLT and GSI
  87 Int_t AliL3Transform::fNPatches = 6;
  88 Int_t AliL3Transform::fRows[6][2] = {{0,29},{30,62},{63,90},{91,116},{117,139},{140,158}};
  89 Int_t AliL3Transform::fNRows[6] = {30,33,28,26,23,19};
  90
  91 // The following definition is generated by MakeInitFile function
  92 Double_t AliL3Transform::fBField = 0.2;
  93 Double_t AliL3Transform::fSolenoidBField = 2;
  94 Double_t AliL3Transform::fBFieldFactor = 1;
  95 Int_t AliL3Transform::fVersion = fV_default;
  96 Int_t AliL3Transform::fNTimeBins = 446;
  97 Int_t AliL3Transform::fNRowLow = 63;
  98 Int_t AliL3Transform::fNRowUp = 96;
  99 Int_t AliL3Transform::fNRowUp1 = 64;
 100 Int_t AliL3Transform::fNRowUp2 = 32;
 101 Int_t AliL3Transform::fNSectorLow = 36;
 102 Int_t AliL3Transform::fNSectorUp = 36;
 103 Int_t AliL3Transform::fNSector = 72;
 104 Double_t AliL3Transform::fPadPitchWidthLow = 0.4;
 105 Double_t AliL3Transform::fPadPitchWidthUp = 0.6;
 106 Double_t AliL3Transform::fZWidth = 0.5660;
 107 Double_t AliL3Transform::fZSigma = 0.2288;
 108 Double_t AliL3Transform::fZLength = 250.0000;
 109 Double_t AliL3Transform::fZOffset = 0.6864;
 110 Double_t AliL3Transform::fDiffT = 0.0220;
 111 Double_t AliL3Transform::fDiffL = 0.0220;
 112 Double_t AliL3Transform::fOmegaTau = 0.1450;
 113 Double_t AliL3Transform::fInnerPadLength = 0.75;
 114 Double_t AliL3Transform::fOuter1PadLength = 1.00;
 115 Double_t AliL3Transform::fOuter2PadLength = 1.50;
 116 Double_t AliL3Transform::fInnerPRFSigma = 0.203811;
 117 Double_t AliL3Transform::fOuter1PRFSigma = 0.299325;
 118 Double_t AliL3Transform::fOuter2PRFSigma = 0.299323;
 119 Double_t AliL3Transform::fTimeSigma = 0.228809;
 120 Int_t AliL3Transform::fADCSat = 1024;
 121 Int_t AliL3Transform::fZeroSup = 0;
 122 Int_t AliL3Transform::fNSlice = 36;
 123 Int_t AliL3Transform::fNRow = 159;
 124 Double_t AliL3Transform::fNRotShift = 0.5;
 125 Int_t AliL3Transform::fSlice2Sector[36][2] = { { 0, 36},
 126                                                { 1, 37},
 127                                                { 2, 38},
 128                                                { 3, 39},
 129                                                { 4, 40},
 130                                                { 5, 41},
 131                                                { 6, 42},
 132                                                { 7, 43},
 133                                                { 8, 44},
 134                                                { 9, 45},
 135                                                {10, 46},
 136                                                {11, 47},
 137                                                {12, 48},
 138                                                {13, 49},
 139                                                {14, 50},
 140                                                {15, 51},
 141                                                {16, 52},
 142                                                {17, 53},
 143                                                {18, 54},
 144                                                {19, 55},
 145                                                {20, 56},
 146                                                {21, 57},
 147                                                {22, 58},
 148                                                {23, 59},
 149                                                {24, 60},
 150                                                {25, 61},
 151                                                {26, 62},
 152                                                {27, 63},
 153                                                {28, 64},
 154                                                {29, 65},
 155                                                {30, 66},
 156                                                {31, 67},
 157                                                {32, 68},
 158                                                {33, 69},
 159                                                {34, 70},
 160                                                {35, 71}
 161 };
 162
 163 Int_t AliL3Transform::fSector2Slice[72] = { 0,
 164                                             1,
 165                                             2,
 166                                             3,
 167                                             4,
 168                                             5,
 169                                             6,
 170                                             7,
 171                                             8,
 172                                             9,
 173                                             10,
 174                                             11,
 175                                             12,
 176                                             13,
 177                                             14,
 178                                             15,
 179                                             16,
 180                                             17,
 181                                             18,
 182                                             19,
 183                                             20,
 184                                             21,
 185                                             22,
 186                                             23,
 187                                             24,
 188                                             25,
 189                                             26,
 190                                             27,
 191                                             28,
 192                                             29,
 193                                             30,
 194                                             31,
 195                                             32,
 196                                             33,
 197                                             34,
 198                                             35,
 199                                             0,
 200                                             1,
 201                                             2,
 202                                             3,
 203                                             4,
 204                                             5,
 205                                             6,
 206                                             7,
 207                                             8,
 208                                             9,
 209                                             10,
 210                                             11,
 211                                             12,
 212                                             13,
 213                                             14,
 214                                             15,
 215                                             16,
 216                                             17,
 217                                             18,
 218                                             19,
 219                                             20,
 220                                             21,
 221                                             22,
 222                                             23,
 223                                             24,
 224                                             25,
 225                                             26,
 226                                             27,
 227                                             28,
 228                                             29,
 229                                             30,
 230                                             31,
 231                                             32,
 232                                             33,
 233                                             34,
 234                                             35
 235 };
 236
 237 Int_t AliL3Transform::fSectorLow[72] = { 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                                          1,
 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                                          0
 309 };
 310
 311 Double_t AliL3Transform::fX[159] = { 85.195,
 312                                      85.945,
 313                                      86.695,
 314                                      87.445,
 315                                      88.195,
 316                                      88.945,
 317                                      89.695,
 318                                      90.445,
 319                                      91.195,
 320                                      91.945,
 321                                      92.695,
 322                                      93.445,
 323                                      94.195,
 324                                      94.945,
 325                                      95.695,
 326                                      96.445,
 327                                      97.195,
 328                                      97.945,
 329                                      98.695,
 330                                      99.445,
 331                                      100.195,
 332                                      100.945,
 333                                      101.695,
 334                                      102.445,
 335                                      103.195,
 336                                      103.945,
 337                                      104.695,
 338                                      105.445,
 339                                      106.195,
 340                                      106.945,
 341                                      107.695,
 342                                      108.445,
 343                                      109.195,
 344                                      109.945,
 345                                      110.695,
 346                                      111.445,
 347                                      112.195,
 348                                      112.945,
 349                                      113.695,
 350                                      114.445,
 351                                      115.195,
 352                                      115.945,
 353                                      116.695,
 354                                      117.445,
 355                                      118.195,
 356                                      118.945,
 357                                      119.695,
 358                                      120.445,
 359                                      121.195,
 360                                      121.945,
 361                                      122.695,
 362                                      123.445,
 363                                      124.195,
 364                                      124.945,
 365                                      125.695,
 366                                      126.445,
 367                                      127.195,
 368                                      127.945,
 369                                      128.695,
 370                                      129.445,
 371                                      130.195,
 372                                      130.945,
 373                                      131.695,
 374                                      135.180,
 375                                      136.180,
 376                                      137.180,
 377                                      138.180,
 378                                      139.180,
 379                                      140.180,
 380                                      141.180,
 381                                      142.180,
 382                                      143.180,
 383                                      144.180,
 384                                      145.180,
 385                                      146.180,
 386                                      147.180,
 387                                      148.180,
 388                                      149.180,
 389                                      150.180,
 390                                      151.180,
 391                                      152.180,
 392                                      153.180,
 393                                      154.180,
 394                                      155.180,
 395                                      156.180,
 396                                      157.180,
 397                                      158.180,
 398                                      159.180,
 399                                      160.180,
 400                                      161.180,
 401                                      162.180,
 402                                      163.180,
 403                                      164.180,
 404                                      165.180,
 405                                      166.180,
 406                                      167.180,
 407                                      168.180,
 408                                      169.180,
 409                                      170.180,
 410                                      171.180,
 411                                      172.180,
 412                                      173.180,
 413                                      174.180,
 414                                      175.180,
 415                                      176.180,
 416                                      177.180,
 417                                      178.180,
 418                                      179.180,
 419                                      180.180,
 420                                      181.180,
 421                                      182.180,
 422                                      183.180,
 423                                      184.180,
 424                                      185.180,
 425                                      186.180,
 426                                      187.180,
 427                                      188.180,
 428                                      189.180,
 429                                      190.180,
 430                                      191.180,
 431                                      192.180,
 432                                      193.180,
 433                                      194.180,
 434                                      195.180,
 435                                      196.180,
 436                                      197.180,
 437                                      198.180,
 438                                      199.430,
 439                                      200.930,
 440                                      202.430,
 441                                      203.930,
 442                                      205.430,
 443                                      206.930,
 444                                      208.430,
 445                                      209.930,
 446                                      211.430,
 447                                      212.930,
 448                                      214.430,
 449                                      215.930,
 450                                      217.430,
 451                                      218.930,
 452                                      220.430,
 453                                      221.930,
 454                                      223.430,
 455                                      224.930,
 456                                      226.430,
 457                                      227.930,
 458                                      229.430,
 459                                      230.930,
 460                                      232.430,
 461                                      233.930,
 462                                      235.430,
 463                                      236.930,
 464                                      238.430,
 465                                      239.930,
 466                                      241.430,
 467                                      242.930,
 468                                      244.430,
 469                                      245.930
 470 };
 471
 472 Int_t AliL3Transform::fNPads[159] = {67,
 473                                      67,
 474                                      69,
 475                                      69,
 476                                      69,
 477                                      71,
 478                                      71,
 479                                      71,
 480                                      73,
 481                                      73,
 482                                      73,
 483                                      75,
 484                                      75,
 485                                      75,
 486                                      77,
 487                                      77,
 488                                      77,
 489                                      79,
 490                                      79,
 491                                      79,
 492                                      81,
 493                                      81,
 494                                      81,
 495                                      83,
 496                                      83,
 497                                      83,
 498                                      85,
 499                                      85,
 500                                      85,
 501                                      87,
 502                                      87,
 503                                      87,
 504                                      89,
 505                                      89,
 506                                      89,
 507                                      91,
 508                                      91,
 509                                      91,
 510                                      93,
 511                                      93,
 512                                      93,
 513                                      95,
 514                                      95,
 515                                      95,
 516                                      97,
 517                                      97,
 518                                      97,
 519                                      99,
 520                                      99,
 521                                      99,
 522                                      99,
 523                                      101,
 524                                      101,
 525                                      101,
 526                                      103,
 527                                      103,
 528                                      103,
 529                                      105,
 530                                      105,
 531                                      105,
 532                                      107,
 533                                      107,
 534                                      107,
 535                                      73,
 536                                      75,
 537                                      75,
 538                                      75,
 539                                      75,
 540                                      77,
 541                                      77,
 542                                      77,
 543                                      79,
 544                                      79,
 545                                      79,
 546                                      81,
 547                                      81,
 548                                      81,
 549                                      81,
 550                                      83,
 551                                      83,
 552                                      83,
 553                                      85,
 554                                      85,
 555                                      85,
 556                                      85,
 557                                      87,
 558                                      87,
 559                                      87,
 560                                      89,
 561                                      89,
 562                                      89,
 563                                      91,
 564                                      91,
 565                                      91,
 566                                      91,
 567                                      93,
 568                                      93,
 569                                      93,
 570                                      95,
 571                                      95,
 572                                      95,
 573                                      95,
 574                                      97,
 575                                      97,
 576                                      97,
 577                                      99,
 578                                      99,
 579                                      99,
 580                                      101,
 581                                      101,
 582                                      101,
 583                                      101,
 584                                      103,
 585                                      103,
 586                                      103,
 587                                      105,
 588                                      105,
 589                                      105,
 590                                      105,
 591                                      107,
 592                                      107,
 593                                      107,
 594                                      109,
 595                                      109,
 596                                      109,
 597                                      111,
 598                                      111,
 599                                      111,
 600                                      113,
 601                                      113,
 602                                      113,
 603                                      115,
 604                                      115,
 605                                      117,
 606                                      117,
 607                                      119,
 608                                      119,
 609                                      121,
 610                                      121,
 611                                      121,
 612                                      123,
 613                                      123,
 614                                      125,
 615                                      125,
 616                                      127,
 617                                      127,
 618                                      127,
 619                                      129,
 620                                      129,
 621                                      131,
 622                                      131,
 623                                      133,
 624                                      133,
 625                                      135,
 626                                      135,
 627                                      135,
 628                                      137,
 629                                      137,
 630                                      139
 631 };
 632
 633 Double_t AliL3Transform::fCos[36] = { 0.9848077297,
 634                                       0.8660253882,
 635                                       0.6427876353,
 636                                       0.3420201540,
 637                                       0.0000000000,
 638                                       -0.3420201540,
 639                                       -0.6427876353,
 640                                       -0.8660253882,
 641                                       -0.9848077297,
 642                                       -0.9848077297,
 643                                       -0.8660253882,
 644                                       -0.6427876353,
 645                                       -0.3420201540,
 646                                       -0.0000000000,
 647                                       0.3420201540,
 648                                       0.6427876353,
 649                                       0.8660253882,
 650                                       0.9848077297,
 651                                       0.9848077297,
 652                                       0.8660253882,
 653                                       0.6427876353,
 654                                       0.3420201540,
 655                                       0.0000000000,
 656                                       -0.3420201540,
 657                                       -0.6427876353,
 658                                       -0.8660253882,
 659                                       -0.9848077297,
 660                                       -0.9848077297,
 661                                       -0.8660253882,
 662                                       -0.6427876353,
 663                                       -0.3420201540,
 664                                       -0.0000000000,
 665                                       0.3420201540,
 666                                       0.6427876353,
 667                                       0.8660253882,
 668                                       0.9848077297
 669 };
 670
 671 Double_t AliL3Transform::fSin[36] = { 0.1736481786,
 672                                       0.5000000000,
 673                                       0.7660444379,
 674                                       0.9396926165,
 675                                       1.0000000000,
 676                                       0.9396926165,
 677                                       0.7660444379,
 678                                       0.5000000000,
 679                                       0.1736481786,
 680                                       -0.1736481786,
 681                                       -0.5000000000,
 682                                       -0.7660444379,
 683                                       -0.9396926165,
 684                                       -1.0000000000,
 685                                       -0.9396926165,
 686                                       -0.7660444379,
 687                                       -0.5000000000,
 688                                       -0.1736481786,
 689                                       0.1736481786,
 690                                       0.5000000000,
 691                                       0.7660444379,
 692                                       0.9396926165,
 693                                       1.0000000000,
 694                                       0.9396926165,
 695                                       0.7660444379,
 696                                       0.5000000000,
 697                                       0.1736481786,
 698                                       -0.1736481786,
 699                                       -0.5000000000,
 700                                       -0.7660444379,
 701                                       -0.9396926165,
 702                                       -1.0000000000,
 703                                       -0.9396926165,
 704                                       -0.7660444379,
 705                                       -0.5000000000,
 706                                       -0.1736481786
 707 };
 708
 709 Bool_t AliL3Transform::Init(Char_t* path,Bool_t UseAliTPCParam)
 710 {
 711   //Overwrite the parameters with values stored in file "l3transform.config" in path.
 712   //If file does not exist, old default values will be used.
 713   //If flag UseAliTPCParam is set, the parameters will be read from the the rootfile
 714   //which then has to be called path/digitfile.root
 715
 716   if(fVersion != fV_default)
 717     LOG(AliL3Log::kWarning,"AliL3Transform::Init","Init values")
 718       <<AliL3Log::kDec<<"You are initializing the parameters more than once; check your code please! "<<fVersion<<ENDLOG;
 719
 720   if(UseAliTPCParam) //use rootfile to generate temporary init file
 721     return ReadInit(path);
 722
 723   //create filename
 724   Char_t pathname[1024];
 725   strcpy(pathname,path);
 726
 727   //test whether provided path is the file itself
 728   Int_t isdir = 0;
 729   DIR *testdir=opendir(pathname);
 730   if(testdir){
 731     isdir=1;
 732     closedir(testdir);
 733   }
 734
 735   if(isdir) strcat(pathname,"/l3transform.config");
 736
 737   return ReadInitFile(pathname);
 738 }
 739
 740 Bool_t AliL3Transform::ReadInitFile(Char_t* pathname)
 741 {
 742   //read transformer settings from pathname
 743
 744   FILE *fptr=fopen(pathname,"r");
 745   if(!fptr){
 746     LOG(AliL3Log::kWarning,"AliL3Transform::ReadInitFile","File Open")
 747       <<"Pointer to Config File \""<<pathname<<"\" 0x0!"<<ENDLOG;
 748     return kFALSE;
 749   }
 750
 751   Char_t d1[250], d2[100], d3[100];
 752   Int_t dummy=0;
 753   Double_t ddummy=0.0;
 754
 755   while(!feof(fptr)) {
 756     fscanf(fptr,"%s",d1);
 757     if(strcmp(d1,"fVersion")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fVersion=dummy;}
 758     else if(strcmp(d1,"fBFieldFactor")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fBFieldFactor=(Double_t)ddummy;}
 759     else if(strcmp(d1,"fSolenoidBField")==0)
 760       {
 761         fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);
 762         fSolenoidBField=(Double_t)ddummy;
 763       }
 764     else if(strcmp(d1,"fNTimeBins")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNTimeBins=(Int_t)dummy;}
 765     else if(strcmp(d1,"fNRowLow")==0)
 766       {
 767         fscanf(fptr,"%s %d %s",d2,&dummy,d3);
 768         fNRowLow=(Int_t)dummy;
 769         if(fNRowLow != 63)
 770           LOG(AliL3Log::kError,"AliL3Transform::ReadInitFile","Overflow")
 771             <<"Number of inner PadRows should be 63! Check and fgrep the code for 63 to see the consequences of this major change!"<<ENDLOG;
 772       }
 773     else if(strcmp(d1,"fNRowUp")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRowUp=(Int_t)dummy;}
 774     else if(strcmp(d1,"fNRowUp1")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRowUp1=(Int_t)dummy;}
 775     else if(strcmp(d1,"fNRowUp2")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRowUp2=(Int_t)dummy;}
 776     else if(strcmp(d1,"fNSectorLow")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSectorLow=(Int_t)dummy;}
 777     else if(strcmp(d1,"fNSectorUp")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSectorUp=(Int_t)dummy;}
 778     else if(strcmp(d1,"fNSector")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSector=(Int_t)dummy;}
 779     else if(strcmp(d1,"fPadPitchWidthLow")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fPadPitchWidthLow=(Double_t)ddummy;}
 780     else if(strcmp(d1,"fPadPitchWidthUp")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fPadPitchWidthUp=(Double_t)ddummy;}
 781     else if(strcmp(d1,"fZWidth")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZWidth=(Double_t)ddummy;}
 782     else if(strcmp(d1,"fZSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZSigma=(Double_t)ddummy;}
 783     else if(strcmp(d1,"fZLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZLength=(Double_t)ddummy;}
 784     else if(strcmp(d1,"fZOffset")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZOffset=(Double_t)ddummy;}
 785     else if(strcmp(d1,"fNSlice")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSlice=(Int_t)dummy;}
 786     else if(strcmp(d1,"fDiffT")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fDiffT=(Double_t)ddummy;}
 787     else if(strcmp(d1,"fDiffL")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fDiffL=(Double_t)ddummy;}
 788     else if(strcmp(d1,"fOmegaTau")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOmegaTau=(Double_t)ddummy;}
 789     else if(strcmp(d1,"fInnerPadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fInnerPadLength=(Double_t)ddummy;}
 790     else if(strcmp(d1,"fOuter1PadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter1PadLength=(Double_t)ddummy;}
 791     else if(strcmp(d1,"fOuter2PadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter2PadLength=(Double_t)ddummy;}
 792     else if(strcmp(d1,"fInnerPRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fInnerPRFSigma=(Double_t)ddummy;}
 793     else if(strcmp(d1,"fOuter1PRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter1PRFSigma=(Double_t)ddummy;}
 794     else if(strcmp(d1,"fOuter2PRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter2PRFSigma=(Double_t)ddummy;}
 795     else if(strcmp(d1,"fTimeSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fTimeSigma=(Double_t)ddummy;}
 796     else if(strcmp(d1,"fADCSat")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fADCSat=(Int_t)dummy;}
 797     else if(strcmp(d1,"fZeroSup")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fZeroSup=(Int_t)dummy;}
 798     else if(strcmp(d1,"fNRow")==0){
 799       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRow=(Int_t)dummy;
 800       if(fNRow!=159){
 801         LOG(AliL3Log::kError,"AliL3Transform::ReadInitFile","Overflow")<<"Number of PadRows should be 159! Check and fgrep the code for 159 to see the consequences of this major change!"<<ENDLOG;
 802       }
 803     }
 804     else if(strcmp(d1,"fNRotShift")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fNRotShift=(Double_t)ddummy;}
 805     else if(strcmp(d1,"fX[0]")==0){
 806       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fX[0]=(Double_t)ddummy;
 807       for(Int_t i=1;i<fNRow;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fX[i]=(Double_t)ddummy;}
 808     }
 809     else if(strcmp(d1,"fNPads[0]")==0){
 810       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNPads[0]=(Int_t)dummy;
 811       for(Int_t i=1;i<fNRow;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fNPads[i]=(Int_t)dummy;}
 812     }
 813     else if(strcmp(d1,"fNRows[0]")==0){
 814       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRows[0]=(Int_t)dummy;
 815       for(Int_t i=1;i<fNPatches;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fNRows[i]=(Int_t)dummy;}
 816     }
 817     else if(strcmp(d1,"fRows[0][0]")==0){
 818       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fRows[0][0]=(Int_t)dummy;
 819       fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fRows[0][1]=(Int_t)dummy;
 820       for(Int_t i=1;i<fNPatches;i++){
 821         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fRows[i][0]=(Int_t)dummy;
 822         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fRows[i][1]=(Int_t)dummy;
 823       }
 824     }
 825     else if(strcmp(d1,"fSlice2Sector[0][0]")==0){
 826       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fSlice2Sector[0][0]=(Int_t)dummy;
 827       fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSlice2Sector[0][1]=(Int_t)dummy;
 828       for(Int_t i=1;i<fNSlice;i++){
 829         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSlice2Sector[i][0]=(Int_t)dummy;
 830         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSlice2Sector[i][1]=(Int_t)dummy;
 831       }
 832     }
 833     else if(strcmp(d1,"fSector2Slice[0]")==0){
 834       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fSector2Slice[0]=(Int_t)dummy;
 835       for(Int_t i=1;i<fNSector;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSector2Slice[i]=(Int_t)dummy;}
 836     }
 837     else if(strcmp(d1,"fSectorLow[0]")==0){
 838       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fSectorLow[0]=(Int_t)dummy;
 839       for(Int_t i=1;i<fNSector;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSectorLow[i]=(Int_t)dummy;}
 840     }
 841     else if(strcmp(d1,"fCos[0]")==0){
 842       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fCos[0]=(Double_t)ddummy;
 843       for(Int_t i=1;i<fNSlice;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fCos[i]=(Double_t)ddummy;}
 844     }
 845     else if(strcmp(d1,"fSin[0]")==0){
 846       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fSin[0]=(Double_t)ddummy;
 847       for(Int_t i=1;i<fNSlice;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fSin[i]=(Double_t)ddummy;}
 848     }
 849   }
 850   fclose(fptr);
 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   //Test if new config file has been used.
 857   if(fVersion==fV_deprecated){
 858     LOG(AliL3Log::kError,"AliL3Transform::ReadInitFile","Version")
 859       <<"Version is deprecated, you have to create a new config file."<<ENDLOG;
 860     return kFALSE;
 861   }
 862
 863   LOG(AliL3Log::kInformational,"AliL3Transform::ReadInitFile","Config")
 864     <<"Successfully loaded values from config file \""<<pathname<<"\""<<ENDLOG;
 865
 866   return kTRUE;
 867 }
 868
 869 Bool_t AliL3Transform::ReadInit(Char_t *path)
 870 {
 871   //Read all the parameters from a aliroot file, and store it in a temporary
 872   //file which is read by Init. Use this if you want to read the parameters from
 873   //the rootfile "every" time.
 874
 875 #ifndef use_aliroot
 876   LOG(AliL3Log::kError,"AliL3Transform::ReadInit","Version")
 877     <<"You have to compile with use_aliroot flag in order to read from AliROOT file"<<ENDLOG;
 878   return kFALSE;
 879 #else
 880   Char_t filename[1024];
 881   //first test whether provided path is the rootfile itself
 882   Int_t saveErrIgLevel=gErrorIgnoreLevel;
 883   gErrorIgnoreLevel=kFatal; //dont report errors
 884   TFile *rootfile = TFile::Open(path);
 885   if(!rootfile || rootfile->IsZombie())
 886     { //ok assume its path to alirunfile file
 887       sprintf(filename,"%s/alirunfile.root",path); //create rootfile name
 888     } else { //path contains itself the rootfile name
 889       rootfile->Close();
 890       sprintf(filename,"%s",path);
 891     }
 892   gErrorIgnoreLevel=saveErrIgLevel;
 893
 894   //finally make dummy init file /tmp/$USER/l3transform.config-`date`
 895   Char_t tmppath[1024];
 896   sprintf(tmppath,"/tmp/%s",gSystem->Getenv("USER"));
 897   gSystem->mkdir(tmppath);
 898   TTimeStamp time;
 899   Char_t tmpfile[1024];
 900   sprintf(tmpfile,"%s/l3transform.config-%d",tmppath,(Int_t)time.GetSec());
 901   return MakeInitFile(filename,tmpfile);
 902 #endif
 903 }
 904
 905 Bool_t AliL3Transform::MakeInitFile(Char_t *rootfilename,Char_t *filename)
 906 {
 907   //Get the parameters from rootfile, and store it on the file "l3transform.config"
 908   //which is being read by Init. fVersion will be fV_aliroot!
 909
 910 #ifndef use_aliroot
 911   LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","Version")
 912     <<"You have to compile with use_aliroot flag in order to use this function"<<ENDLOG;
 913   return kFALSE;
 914 #else
 915   TFile *rootfile = TFile::Open(rootfilename);
 916   if(!rootfile)
 917     {
 918       LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","File")
 919         <<"Could not open file: "<<rootfilename<<ENDLOG;
 920       return kFALSE;
 921     }
 922   AliRun *gAlice = (AliRun*)rootfile->Get("gAlice");
 923   if(!gAlice)
 924     {
 925       LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","File")
 926         <<"No gAlice in file: "<<rootfilename<<ENDLOG;
 927       return kFALSE;
 928     }
 929   AliTPCParamSR *param=(AliTPCParamSR*)rootfile->Get(GetParamName());
 930   if(!param)
 931     {
 932       LOG(AliL3Log::kWarning,"AliL3Transform::MakeInitFile","File")
 933         <<"No TPC parameters found in \""<<rootfilename
 934         <<"\", creating standard parameters "
 935         <<"which might not be what you want!"<<ENDLOG;
 936       param=new AliTPCParamSR;
 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   SetBFieldFactor((Double_t)gAlice->Field()->Factor());
 999   SetSolenoidBField((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   return SaveInitFile(filename);
1038 #endif
1039 }
1040
1041 Bool_t AliL3Transform::SaveInitFile(Char_t *filenamepath)
1042 {
1043   //store the parameters in the file "filenamepath"
1044
1045   FILE *f = fopen(filenamepath,"w");
1046   if(!f){
1047     LOG(AliL3Log::kError,"AliL3Transform::SaveInitFile","File")
1048         <<"Could not open file: "<<filenamepath<<ENDLOG;
1049     return kFALSE;
1050   }
1051
1052   fprintf(f,"void AliL3Transform::Init(){\n");
1053   fprintf(f,"  fVersion = %d;\n", fVersion);
1054   fprintf(f,"  fBFieldFactor = %.3f;\n",fBFieldFactor);
1055   fprintf(f,"  fSolenoidBField = %.3f;\n",fSolenoidBField);
1056   fprintf(f,"  fNTimeBins = %d;\n",fNTimeBins);
1057   fprintf(f,"  fNRowLow = %d;\n",fNRowLow);
1058   fprintf(f,"  fNRowUp = %d;\n",fNRowUp);
1059   fprintf(f,"  fNRowUp1 = %d;\n",fNRowUp1);
1060   fprintf(f,"  fNRowUp2 = %d;\n",fNRowUp2);
1061   fprintf(f,"  fNSectorLow = %d;\n",fNSectorLow);
1062   fprintf(f,"  fNSectorUp = %d;\n",fNSectorUp);
1063   fprintf(f,"  fNSector = %d;\n",fNSector);
1064   fprintf(f,"  fPadPitchWidthLow = %.3f;\n",fPadPitchWidthLow);
1065   fprintf(f,"  fPadPitchWidthUp = %.3f;\n",fPadPitchWidthUp);
1066   fprintf(f,"  fZWidth = %.4f;\n",fZWidth);
1067   fprintf(f,"  fZSigma = %.4f;\n",fZSigma);
1068   fprintf(f,"  fZLength = %.4f;\n",fZLength);
1069   fprintf(f,"  fZOffset = %.4f;\n",fZOffset);
1070   fprintf(f,"  fDiffT = %.4f;\n",fDiffT);
1071   fprintf(f,"  fDiffL = %.4f;\n",fDiffL);
1072   fprintf(f,"  fOmegaTau = %.4f;\n",fOmegaTau);
1073   fprintf(f,"  fInnerPadLength = %.3f;\n",fInnerPadLength);
1074   fprintf(f,"  fOuter1PadLength = %.3f;\n",fOuter1PadLength);
1075   fprintf(f,"  fOuter2PadLength = %.3f;\n",fOuter2PadLength);
1076   fprintf(f,"  fInnerPRFSigma = %.6f;\n",fInnerPRFSigma);
1077   fprintf(f,"  fOuter1PRFSigma = %.6f;\n",fOuter1PRFSigma);
1078   fprintf(f,"  fOuter2PRFSigma = %.6f;\n",fOuter2PRFSigma);
1079   fprintf(f,"  fTimeSigma = %.6f;\n",fTimeSigma);
1080   fprintf(f,"  fADCSat = %d;\n",fADCSat);
1081   fprintf(f,"  fZeroSup = %d;\n",fZeroSup);
1082   fprintf(f,"  fNSlice = %d;\n",fNSlice);
1083   fprintf(f,"  fNRow = %d;\n",fNRow);
1084   fprintf(f,"  fNRotShift = %.2f;\n",fNRotShift);
1085   //now do the arrays
1086   for(Int_t i=0;i<fNRow;i++){
1087     fprintf(f,"  fX[%d] = %3.2f;\n",i,fX[i]);
1088   }
1089   for(Int_t i=0;i<fNRow;i++){
1090     fprintf(f,"  fNPads[%d] = %d;\n",i,fNPads[i]);
1091   }
1092
1093   //Slice/Sector dont belong to aliroot, but we want to be flexible
1094   for(Int_t i=0;i<fNSlice;i++){
1095     fprintf(f,"  fSlice2Sector[%d][0] = %d;\n",i,fSlice2Sector[i][0]);
1096     fprintf(f,"  fSlice2Sector[%d][1] = %d;\n",i,fSlice2Sector[i][1]);
1097   }
1098   for(Int_t i=0;i<fNSector;i++){
1099     fprintf(f,"  fSector2Slice[%d] = %d;\n",i,fSector2Slice[i]);
1100   }
1101   for(Int_t i=0;i<fNSector;i++){
1102     fprintf(f,"  fSectorLow[%d] = %d;\n",i,fSectorLow[i]);
1103   }
1104
1105   //Patches also dont really belong to the aliroot settings (but nevermind)
1106   for(Int_t i=0;i<fNPatches;i++){
1107     fprintf(f,"  fNRows[%d] = %d;\n",i,fNRows[i]);
1108   }
1109   for(Int_t i=0;i<fNPatches;i++){
1110     fprintf(f,"  fRows[%d][0] = %d;\n",i,fRows[i][0]);
1111     fprintf(f,"  fRows[%d][1] = %d;\n",i,fRows[i][1]);
1112   }
1113
1114   //Rotation shift is an addon, too
1115   for(Int_t i=0;i<fNSlice;i++){
1116     Float_t cs = cos( (2*fPi/18) * (i+fNRotShift) );
1117     fprintf(f,"  fCos[%d] = %.10f;\n",i,cs);
1118   }
1119   for(Int_t i=0;i<fNSlice;i++){
1120     Float_t sn = sin( (2*fPi/18) * (i+fNRotShift) );
1121     fprintf(f,"  fSin[%d] = %.10f;\n",i,sn);
1122   }
1123
1124   fprintf(f,"}\n");
1125   fclose(f);
1126
1127   LOG(AliL3Log::kInformational,"AliL3Transform::SaveInitFile","File created")
1128     <<"Init file \""<<filenamepath<<"\" created"<<ENDLOG;
1129
1130   return kTRUE;
1131 }
1132
1133 Int_t AliL3Transform::GetNPads(Int_t row)
1134 {
1135   if(row < 0 || row >= fNRow)
1136     {
1137       LOG(AliL3Log::kError,"AliL3Transform::GetNPads","Row")
1138         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1139       return 0;
1140     }
1141
1142   return fNPads[row];
1143 }
1144
1145 Int_t AliL3Transform::GetFirstRow(Int_t patch)
1146 {
1147   if(patch==-1)
1148     return 0;
1149   else if(patch < -1 || patch >= 6)
1150     {
1151       LOG(AliL3Log::kError,"AliL3Transform::GetFirstRow","Patch")
1152         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1153       return 0;
1154     }
1155   else
1156     return fRows[patch][0];
1157 }
1158
1159 Int_t AliL3Transform::GetLastRow(Int_t patch)
1160 {
1161   if(patch==-1)
1162     return fRows[5][1];
1163   else if(patch < -1 || patch >= 6)
1164     {
1165       LOG(AliL3Log::kError,"AliL3Transform::GetLastRow","Patch")
1166         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1167       return 0;
1168     }
1169   else
1170     return fRows[patch][1];
1171 }
1172
1173 Int_t AliL3Transform::GetNRows(Int_t patch)
1174 {
1175   if(patch==-1)
1176     return fNRow;
1177   else if(patch < -1 || patch >= 6)
1178     {
1179       LOG(AliL3Log::kError,"AliL3Transform::GetNRows","Patch")
1180         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1181       return 0;
1182     }
1183   else
1184     return fNRows[patch];
1185 }
1186
1187 Int_t AliL3Transform::GetPadRow(Float_t xvalue)
1188 {
1189   //Find the padrow number corresponding to cartesian _local_ x value
1190
1191   if(xvalue < 0 || xvalue > 250)
1192     {
1193       LOG(AliL3Log::kError,"AliL3Transform::GetPadRow","X-value")
1194         <<AliL3Log::kDec<<"Suspicious x-value, make sure it is in local coordinate! "
1195         <<xvalue<<ENDLOG;
1196       return -1;
1197     }
1198
1199   Int_t x = (Int_t)rint(xvalue*10);
1200   if(x < (Int_t)rint(fX[1]*10))
1201     return 0;
1202   else if(x > (Int_t)rint(fX[fNRow-2]*10))
1203     return fNRow-1;
1204   else
1205     {
1206       Int_t padrow=1; //Of course, a more clever algorithm could help here
1207       while(padrow < fNRow-2)
1208         {
1209           if(x > (Int_t)rint(fX[padrow-1]*10) && x < (Int_t)rint(fX[padrow+1]*10))
1210             break;
1211           padrow++;
1212         }
1213       return padrow;
1214     }
1215 }
1216
1217 Int_t AliL3Transform::GetPatch(Int_t padrow)
1218 {
1219   if(padrow < 0 || padrow >= fNRow)
1220     {
1221       LOG(AliL3Log::kError,"AliL3Transform::GetPatch","Padrow")
1222         <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1223       return -2;
1224     }
1225   Int_t patch=0;
1226   while(patch < fNPatches)
1227     {
1228       if(padrow >= fRows[patch][0] && padrow <= fRows[patch][1])
1229         break;
1230       patch++;
1231     }
1232   return patch;
1233 }
1234
1235 Double_t AliL3Transform::GetPadLength(Int_t padrow)
1236 {
1237   if(padrow >= fNRow){
1238       LOG(AliL3Log::kError,"AliL3Transform::GetPadLength","Padrow")
1239         <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1240       return 0;
1241     }
1242
1243   if(padrow < fNRowLow)
1244     return fInnerPadLength;
1245   if(padrow >= fNRowLow && padrow < fNRowLow + fNRowUp1 - 1)
1246     return fOuter1PadLength;
1247   if(padrow >= fNRowLow + fNRowUp1 - 1)
1248     return fOuter2PadLength;
1249
1250   //should never happen
1251   LOG(AliL3Log::kError,"AliL3Transform::GetPadLength","Padrow")
1252     <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1253   return -1.0;
1254 }
1255
1256 Double_t AliL3Transform::GetPadPitchWidth(Int_t patch)
1257 {
1258   if(patch < 0 || patch > fNPatches)
1259     {
1260       LOG(AliL3Log::kError,"AliL3Transform::GetPadPitchWidth","patct")
1261         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1262       return -1;
1263     }
1264   return patch < 2 ? fPadPitchWidthLow : fPadPitchWidthUp;
1265 }
1266
1267 Double_t AliL3Transform::GetParSigmaY2(Int_t padrow,Float_t z,Float_t angle)
1268 {
1269   //Calculate the expected transverse cluster width as a function of
1270   //drift distance and crossing angle.
1271   //z = local z-coordinate of cluster
1272   //angle = track crossing angle with normal to padrow plane
1273   //return value = sigma^2 (cartesian coordinates)
1274
1275   Double_t drift;
1276   if(z > 0)
1277     drift = fZLength - z;
1278   else
1279     drift = fZLength + z;
1280
1281   Double_t t1 = GetPRFSigma(padrow)*GetPRFSigma(padrow);
1282   Double_t t2 = fDiffT*fDiffT*drift;
1283   Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tan(angle)*tan(angle)/12;
1284   Double_t t4 = fAnodeWireSpacing*fAnodeWireSpacing*(tan(angle) - fOmegaTau)*(tan(angle) - fOmegaTau)/12;
1285
1286   return (t1 + t2 + t3 + t4);
1287 }
1288
1289 Double_t AliL3Transform::GetParSigmaZ2(Int_t padrow,Float_t z,Float_t tgl)
1290 {
1291   //Calculate the expected longitudinal cluster width as a function of
1292   //drift distance and track crossing angle.
1293   //z = local z-coordinate of cluster
1294   //tgl = tan(dipangle)
1295   //return value = sigma^2 (cartesian coordinates)
1296
1297   Double_t drift;
1298   if(z > 0)
1299     drift = AliL3Transform::GetZLength() - z;
1300   else
1301     drift = AliL3Transform::GetZLength() + z;
1302
1303   Double_t t1 = fZSigma*fZSigma;
1304   Double_t t2 = fDiffL*fDiffL*drift;
1305   Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tgl*tgl/12;
1306
1307   return (t1 + t2 + t3);
1308 }
1309
1310 Double_t AliL3Transform::GetPRFSigma(Int_t padrow)
1311 {
1312   if(padrow >= fNRow){
1313     LOG(AliL3Log::kError,"AliL3Transform::GetPRFSigma","Padrow")
1314       <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1315     return 0;
1316   }
1317   if(padrow < fNRowLow)
1318     return fInnerPRFSigma;
1319   if(padrow >= fNRowLow && padrow < fNRowLow + fNRowUp1 - 1)
1320     return fOuter1PRFSigma;
1321   if(padrow >= fNRowLow + fNRowUp1 - 1)
1322     return fOuter2PRFSigma;
1323
1324   //should never happen
1325   LOG(AliL3Log::kError,"AliL3Transform::GetPRFSigma","Padrow")
1326     <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1327   return -1.;
1328 }
1329
1330 Double_t AliL3Transform::GetEta(Float_t *xyz)
1331 {
1332   Double_t r3 = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1333   Double_t eta = 0.5 * log((r3+xyz[2])/(r3-xyz[2]));
1334   return eta;
1335 }
1336
1337 void AliL3Transform::XYZtoRPhiEta(Float_t *rpe, Float_t *xyz)
1338 {
1339   rpe[0] = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1340   rpe[1] = atan2(xyz[1],xyz[0]);
1341   rpe[2] = 0.5 * log((rpe[0]+xyz[2])/(rpe[0]-xyz[2]));
1342 }
1343
1344 Double_t AliL3Transform::GetEta(Int_t slice,Int_t padrow,Int_t pad,Int_t time)
1345 {
1346   Float_t xyz[3];
1347   Int_t sector,row;
1348   Slice2Sector(slice,padrow,sector,row);
1349   Raw2Local(xyz,sector,row,pad,time);
1350
1351   return GetEta(xyz);
1352 }
1353
1354 Double_t AliL3Transform::GetPhi(Float_t *xyz)
1355 {
1356   Double_t phi = atan2(xyz[1],xyz[0]);
1357   return phi;
1358 }
1359
1360 Bool_t AliL3Transform::Slice2Sector(Int_t slice, Int_t slicerow, Int_t & sector, Int_t &row)
1361 {
1362   if(slicerow<0&&slicerow>=fNRow){
1363     LOG(AliL3Log::kError,"AliL3Transform::Slice2Sector","Slicerow")
1364       <<AliL3Log::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1365     return kFALSE;
1366   }
1367   if(slice<0||slice>=fNSlice){
1368     LOG(AliL3Log::kError,"AliL3Transform::Slice2Sector","Slice")
1369       <<AliL3Log::kDec<<"Wrong slice "<<slice<<ENDLOG;
1370     return kFALSE;
1371   }
1372
1373   if(slicerow<fNRowLow){
1374     sector = fSlice2Sector[slice][0];
1375     row    = slicerow;
1376   }
1377   else {
1378     sector = fSlice2Sector[slice][1];
1379     row    = slicerow-fNRowLow;
1380   }
1381
1382   return kTRUE;
1383 }
1384
1385 Bool_t AliL3Transform::Sector2Slice(Int_t & slice, Int_t  sector)
1386 {
1387   if(sector<0||sector>=fNSector){
1388     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Sector")
1389       <<AliL3Log::kDec<<"Wrong sector "<<sector<<ENDLOG;
1390     return kFALSE;
1391   }
1392
1393   slice=fSector2Slice[sector];
1394
1395   return kTRUE;
1396 }
1397
1398 Bool_t AliL3Transform::Sector2Slice(Int_t & slice, Int_t & slicerow, Int_t sector, Int_t row)
1399 {
1400   if(sector<0 || sector>=fNSector){
1401     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Sector")
1402       <<AliL3Log::kDec<<"Wrong sector "<<sector<<ENDLOG;
1403     return kFALSE;
1404   }
1405   if(row<0){
1406     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1407       <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1408     return kFALSE;
1409   }
1410
1411   if(fSectorLow[sector]){
1412     if(row>=fNRowLow){
1413       LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1414         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1415       return kFALSE;
1416     }
1417     slice = fSector2Slice[sector];
1418     slicerow = row;
1419   }
1420   else{
1421     if(row>=fNRowUp){
1422       LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1423         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1424       return kFALSE;
1425     }
1426     slice = fSector2Slice[sector];
1427     slicerow = row + fNRowLow;
1428   }
1429
1430   return kTRUE;
1431 }
1432
1433 Double_t AliL3Transform::GetMaxY(Int_t slicerow)
1434 {
1435  if(slicerow < fNRowLow)
1436      return fPadPitchWidthLow*fNPads[slicerow]/2;
1437
1438  else
1439      return fPadPitchWidthUp*fNPads[slicerow]/2;
1440
1441 }
1442
1443 Double_t AliL3Transform::Row2X(Int_t slicerow){
1444   if(slicerow<0||slicerow>=fNRow){
1445     LOG(AliL3Log::kError,"AliL3Transform::Row2X","Slicerow")
1446       <<AliL3Log::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1447     return 0;
1448   }
1449   return fX[slicerow];
1450 }
1451
1452 Double_t AliL3Transform::GetZFast(Int_t slice, Int_t time, Float_t /*vertex*/)
1453 {
1454   Double_t ret=0;
1455   if(slice < 18)
1456     ret=fZLength-fZWidth*time+fZOffset;
1457   else
1458     ret=fZWidth*time-fZOffset-fZLength;
1459   return ret;
1460 }
1461
1462 void AliL3Transform::Local2Global(Float_t *xyz,Int_t slice)
1463 {
1464   //Transformation to global coordinate system
1465   Float_t x0 = xyz[0];
1466   Float_t y0 = xyz[1];
1467
1468   xyz[0]=x0*fCos[slice]-y0*fSin[slice];
1469   xyz[1]=x0*fSin[slice]+y0*fCos[slice];
1470   xyz[2]=xyz[2];//global z=local z
1471 }
1472
1473 void AliL3Transform::Local2GlobalAngle(Float_t *angle,Int_t slice){
1474   angle[0] = fmod(angle[0]+(slice+fNRotShift)*(2*fPi/18),2*fPi);
1475 }
1476
1477 void AliL3Transform::Global2LocalAngle(Float_t *angle,Int_t slice){
1478   angle[0] = angle[0]-(slice+fNRotShift)*(2*fPi/18);
1479   if(angle[0]<0) angle[0]+=2*fPi;
1480 }
1481
1482 void AliL3Transform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1483 {
1484   //Transformation from rawdata to local coordinate system
1485
1486   Int_t slice,slicerow;
1487   Sector2Slice(slice, slicerow, sector, row);
1488
1489   //X-Value
1490   xyz[0]=Row2X(slicerow);
1491
1492   //Y-Value
1493   Int_t npads= fNPads[slicerow];
1494
1495   if(fSectorLow[sector])
1496     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthLow;
1497   else
1498     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthUp;
1499
1500   //Z-Value (remember PULSA Delay)
1501   if(slice < 18)
1502     xyz[2]=fZLength-fZWidth*time+fZOffset;
1503   else
1504     xyz[2]=fZWidth*time-fZOffset-fZLength;
1505 }
1506
1507 void AliL3Transform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Int_t pad,Int_t time)
1508 {
1509   //Transformation from rawdata to local coordinate system
1510
1511   Int_t slice,slicerow;
1512   Sector2Slice(slice, slicerow, sector, row);
1513
1514   //X-Value
1515   xyz[0]=Row2X(slicerow);
1516
1517   //Y-Value
1518   Int_t npads= fNPads[slicerow];
1519
1520   if(fSectorLow[sector])
1521     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthLow;
1522   else
1523     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthUp;
1524
1525   //Z-Value (remember PULSA Delay)
1526   if(slice < 18)
1527     xyz[2]=fZLength-fZWidth*time+fZOffset;
1528   else
1529     xyz[2]=fZWidth*time-fZOffset-fZLength;
1530 }
1531
1532 void AliL3Transform::RawHLT2Local(Float_t *xyz,Int_t slice,
1533                                Int_t slicerow,Float_t pad,Float_t time)
1534 {
1535   //Transformation from HLT rawdata to local coordinate system
1536
1537   //X-Value
1538   xyz[0]=Row2X(slicerow);
1539
1540   //Y-Value
1541   Int_t npads= fNPads[slicerow];
1542   if(slicerow<fNRowLow)
1543     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthLow;
1544   else
1545     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthUp;
1546
1547   //Z-Value
1548   if(slice < 18)
1549     xyz[2]=fZLength-fZWidth*time+fZOffset;
1550   else
1551     xyz[2]=fZWidth*time-fZOffset-fZLength;
1552 }
1553
1554 void AliL3Transform::RawHLT2Local(Float_t *xyz,Int_t slice,
1555                                Int_t slicerow,Int_t pad,Int_t time)
1556 {
1557   //Transformation from HLT rawdata to local coordinate system
1558
1559   //X-Value
1560   xyz[0]=Row2X(slicerow);
1561
1562   //Y-Value
1563   Int_t npads= fNPads[slicerow];
1564   if(slicerow<fNRowLow)
1565     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthLow;
1566   else
1567     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthUp;
1568
1569   //Z-Value
1570   if(slice < 18)
1571     xyz[2]=fZLength-fZWidth*time+fZOffset;
1572   else
1573     xyz[2]=fZWidth*time-fZOffset-fZLength;
1574 }
1575
1576 void AliL3Transform::Local2Global(Float_t *xyz,Int_t sector,Int_t row)
1577 {
1578   //Transformation to global coordinate system
1579   Int_t slice,slicerow;
1580   Sector2Slice(slice, slicerow, sector, row);
1581   Float_t r=Row2X(slicerow); //have to get x value first
1582
1583   xyz[0]=r*fCos[slice]-xyz[1]*fSin[slice];
1584   xyz[1]=r*fSin[slice]+xyz[1]*fCos[slice];
1585   xyz[2]=xyz[2];//global z=local z
1586 }
1587
1588 void AliL3Transform::LocHLT2Global(Float_t *xyz,Int_t slice,Int_t slicerow)
1589 {
1590   //Transformation from HLT to global coordinate system
1591   Float_t r=Row2X(slicerow); //have to get x value first
1592
1593   xyz[0]=r*fCos[slice]-xyz[1]*fSin[slice];
1594   xyz[1]=r*fSin[slice]+xyz[1]*fCos[slice];
1595   xyz[2]=xyz[2];//global z=local z
1596 }
1597
1598 void AliL3Transform::Global2Local(Float_t *xyz,Int_t sector)
1599 { //check code
1600   Int_t slice;
1601   //if(!isSlice)
1602     Sector2Slice(slice, sector);
1603     //else
1604     //slice = sector;
1605
1606   Float_t x1 =  xyz[0]*fCos[slice] + xyz[1]*fSin[slice];
1607   Float_t y1 = -xyz[0]*fSin[slice] + xyz[1]*fCos[slice];
1608   xyz[0] = x1;
1609   xyz[1] = y1;
1610 }
1611
1612 void AliL3Transform::Global2LocHLT(Float_t *xyz,Int_t slice)
1613 {
1614   Float_t x1 =  xyz[0]*fCos[slice] + xyz[1]*fSin[slice];
1615   Float_t y1 = -xyz[0]*fSin[slice] + xyz[1]*fCos[slice];
1616   xyz[0] = x1;
1617   xyz[1] = y1;
1618 }
1619
1620 void AliL3Transform::Raw2Global(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1621 {
1622   //Transformation from raw to global coordinates
1623
1624   Raw2Local(xyz,sector,row,pad,time);
1625   Local2Global(xyz,sector,row);
1626 }
1627
1628 void AliL3Transform::Raw2Global(Float_t *xyz,Int_t sector,Int_t row,Int_t pad,Int_t time)
1629 {
1630   //Transformation from raw to global coordinates
1631
1632   Raw2Local(xyz,sector,row,pad,time);
1633   Local2Global(xyz,sector,row);
1634 }
1635
1636 void AliL3Transform::RawHLT2Global(Float_t *xyz,Int_t slice,
1637                                    Int_t slicerow,Float_t pad,Float_t time)
1638 {
1639   //Transformation from raw to global coordinates
1640
1641   RawHLT2Local(xyz,slice,slicerow,pad,time);
1642   LocHLT2Global(xyz,slice,slicerow);
1643 }
1644
1645 void AliL3Transform::RawHLT2Global(Float_t *xyz,Int_t slice,
1646                                    Int_t slicerow,Int_t pad,Int_t time)
1647 {
1648   //Transformation from raw to global coordinates
1649
1650   RawHLT2Local(xyz,slice,slicerow,pad,time);
1651   LocHLT2Global(xyz,slice,slicerow);
1652 }
1653
1654 void AliL3Transform::Local2Raw(Float_t *xyz,Int_t sector,Int_t row)
1655 {
1656   //Transformation from local coordinates to raw
1657
1658   Int_t slice,slicerow;
1659   Sector2Slice(slice, slicerow, sector, row);
1660
1661   xyz[0]=slicerow;
1662
1663   if(fSectorLow[sector])
1664     xyz[1]=xyz[1]/fPadPitchWidthLow+0.5*(fNPads[slicerow]-1);
1665   else
1666     xyz[1]=xyz[1]/fPadPitchWidthUp+0.5*(fNPads[slicerow]-1);
1667
1668   if(slice < 18)
1669     xyz[2]=(fZLength-xyz[2]+fZOffset)/fZWidth;
1670   else
1671     xyz[2]=(fZLength+xyz[2]+fZOffset)/fZWidth;
1672 }
1673
1674 void AliL3Transform::LocHLT2Raw(Float_t *xyz,Int_t slice,Int_t slicerow)
1675 {
1676   //Transformation from local coordinates to raw
1677
1678   xyz[0]=slicerow;
1679
1680   if(slicerow<fNRowLow)
1681     xyz[1]=xyz[1]/fPadPitchWidthLow+0.5*(fNPads[slicerow]-1);
1682   else
1683     xyz[1]=xyz[1]/fPadPitchWidthUp+0.5*(fNPads[slicerow]-1);
1684
1685   if(slice < 18)
1686     xyz[2]=(fZLength-xyz[2]+fZOffset)/fZWidth;
1687   else
1688     xyz[2]=(fZLength+xyz[2]+fZOffset)/fZWidth;
1689 }
1690
1691 void AliL3Transform::Global2Raw(Float_t *xyz,Int_t sector,Int_t row)
1692 {
1693   //Transformation from global coordinates to raw.
1694
1695   Global2Local(xyz,sector);
1696   Local2Raw(xyz,sector,row);
1697 }
1698
1699 void AliL3Transform::Global2HLT(Float_t *xyz,Int_t slice,Int_t slicerow)
1700 {
1701   //Transformation from global coordinates to raw.
1702
1703   Global2LocHLT(xyz,slice);
1704   LocHLT2Raw(xyz,slice,slicerow);
1705 }
1706
1707 void AliL3Transform::PrintCompileOptions()
1708 {
1709 #if defined(__GNUC__)
1710   cout << "Compiler (g++) version used: " << __GNUC__ << endl;
1711 #endif
1712
1713 #ifdef no_root
1714   cout << "STANDALONE version: -Dno_root was given." << endl;
1715 #else
1716   const Char_t *roottest="$ROOTSYS/bin/root -n -b -q  | grep Version | cut -b 17-25 | cut -d\" \" -f1";
1717 #ifdef use_aliroot
1718 #ifdef use_cvs
1719   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";
1720 #else
1721   const Char_t *aliroottest="Unknown";
1722 #endif
1723   cout << "ALIROOT version: -Duse_aliroot and -Duse_root was given." << endl;
1724   cout << "Root Version: " << ROOTVERSION << " found " << flush;
1725   gSystem->Exec(roottest);
1726
1727   cout << "AliRoot Version: " << ALIROOTVERSION << " found " << flush;
1728   gSystem->Exec(aliroottest);
1729 #else
1730   cout << "ROOT version: -Duse_root was given." << endl;
1731   cout << "Root Version: " << ROOTVERSION << " found " << flush;
1732   gSystem->Exec(roottest);
1733 #endif
1734 #endif
1735
1736 #ifdef do_mc
1737   cout << "Using Monte Carlo Info: -Ddo_mc was given." << endl;
1738 #else
1739   cout << "NOT using Monte Carlo Info: -Ddo_mc was not given." << endl;
1740 #endif
1741
1742 #ifdef ROWHOUGH
1743   cout << "Using row transformer version: -DROWHOUGH was given." << endl;
1744 #else
1745   cout << "NOT using row transformer version: -DROWHOUGH was not given." << endl;
1746 #endif
1747
1748 #ifdef use_newio
1749   cout << "Using NEWIO version: -Duse_newio was given." << endl;
1750 #else
1751   cout << "NOT using NEWIO version: -Duse_newio was not given." << endl;
1752 #endif
1753
1754 #ifdef use_logging
1755   cout << "Using logging classes (MLUC): -Duse_logging was given." << endl;
1756 #else
1757   cout << "NOT using logging classes (MLUC): -Duse_logging not was given." << endl;
1758 #endif
1759
1760 }