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   Int_t isdir = 0;
 728   DIR *testdir=opendir(pathname);
 729   if(testdir){
 730     isdir=1;
 731     closedir(testdir);
 732   }
 733
 734   if(isdir) strcat(pathname,"/l3transform.config");
 735
 736   return ReadInitFile(pathname);
 737 }
 738
 739 Bool_t AliL3Transform::ReadInitFile(Char_t* pathname)
 740 {
 741   //read transformer settings from pathname
 742
 743   FILE *fptr=fopen(pathname,"r");
 744   if(!fptr){
 745     LOG(AliL3Log::kWarning,"AliL3Transform::Init","File Open")
 746       <<"Pointer to Config File \""<<pathname<<"\" 0x0!"<<ENDLOG;
 747     return kFALSE;
 748   }
 749
 750   Char_t d1[250], d2[100], d3[100];
 751   Int_t dummy=0;
 752   Double_t ddummy=0.0;
 753
 754   while(!feof(fptr)) {
 755     fscanf(fptr,"%s",d1);
 756     if(strcmp(d1,"fVersion")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fVersion=dummy;}
 757     else if(strcmp(d1,"fBFieldFactor")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fBFieldFactor=(Double_t)ddummy;}
 758     else if(strcmp(d1,"fSolenoidBField")==0)
 759       {
 760         fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);
 761         fSolenoidBField=(Double_t)ddummy;
 762       }
 763     else if(strcmp(d1,"fNTimeBins")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNTimeBins=(Int_t)dummy;}
 764     else if(strcmp(d1,"fNRowLow")==0)
 765       {
 766         fscanf(fptr,"%s %d %s",d2,&dummy,d3);
 767         fNRowLow=(Int_t)dummy;
 768         if(fNRowLow != 63)
 769           LOG(AliL3Log::kError,"AliL3Transform::Init","Overflow")
 770             <<"Number of inner PadRows should be 63! Check and fgrep the code for 63 to see the consequences of this major change!"<<ENDLOG;
 771       }
 772     else if(strcmp(d1,"fNRowUp")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRowUp=(Int_t)dummy;}
 773     else if(strcmp(d1,"fNRowUp1")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRowUp1=(Int_t)dummy;}
 774     else if(strcmp(d1,"fNRowUp2")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRowUp2=(Int_t)dummy;}
 775     else if(strcmp(d1,"fNSectorLow")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSectorLow=(Int_t)dummy;}
 776     else if(strcmp(d1,"fNSectorUp")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSectorUp=(Int_t)dummy;}
 777     else if(strcmp(d1,"fNSector")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSector=(Int_t)dummy;}
 778     else if(strcmp(d1,"fPadPitchWidthLow")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fPadPitchWidthLow=(Double_t)ddummy;}
 779     else if(strcmp(d1,"fPadPitchWidthUp")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fPadPitchWidthUp=(Double_t)ddummy;}
 780     else if(strcmp(d1,"fZWidth")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZWidth=(Double_t)ddummy;}
 781     else if(strcmp(d1,"fZSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZSigma=(Double_t)ddummy;}
 782     else if(strcmp(d1,"fZLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZLength=(Double_t)ddummy;}
 783     else if(strcmp(d1,"fZOffset")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fZOffset=(Double_t)ddummy;}
 784     else if(strcmp(d1,"fNSlice")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNSlice=(Int_t)dummy;}
 785     else if(strcmp(d1,"fDiffT")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fDiffT=(Double_t)ddummy;}
 786     else if(strcmp(d1,"fDiffL")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fDiffL=(Double_t)ddummy;}
 787     else if(strcmp(d1,"fOmegaTau")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOmegaTau=(Double_t)ddummy;}
 788     else if(strcmp(d1,"fInnerPadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fInnerPadLength=(Double_t)ddummy;}
 789     else if(strcmp(d1,"fOuter1PadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter1PadLength=(Double_t)ddummy;}
 790     else if(strcmp(d1,"fOuter2PadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter2PadLength=(Double_t)ddummy;}
 791     else if(strcmp(d1,"fInnerPRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fInnerPRFSigma=(Double_t)ddummy;}
 792     else if(strcmp(d1,"fOuter1PRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter1PRFSigma=(Double_t)ddummy;}
 793     else if(strcmp(d1,"fOuter2PRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fOuter2PRFSigma=(Double_t)ddummy;}
 794     else if(strcmp(d1,"fTimeSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fTimeSigma=(Double_t)ddummy;}
 795     else if(strcmp(d1,"fADCSat")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fADCSat=(Int_t)dummy;}
 796     else if(strcmp(d1,"fZeroSup")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fZeroSup=(Int_t)dummy;}
 797     else if(strcmp(d1,"fNRow")==0){
 798       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRow=(Int_t)dummy;
 799       if(fNRow!=159){
 800         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;
 801       }
 802     }
 803     else if(strcmp(d1,"fNRotShift")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fNRotShift=(Double_t)ddummy;}
 804     else if(strcmp(d1,"fX[0]")==0){
 805       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fX[0]=(Double_t)ddummy;
 806       for(Int_t i=1;i<fNRow;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fX[i]=(Double_t)ddummy;}
 807     }
 808     else if(strcmp(d1,"fNPads[0]")==0){
 809       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNPads[0]=(Int_t)dummy;
 810       for(Int_t i=1;i<fNRow;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fNPads[i]=(Int_t)dummy;}
 811     }
 812     else if(strcmp(d1,"fNRows[0]")==0){
 813       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fNRows[0]=(Int_t)dummy;
 814       for(Int_t i=1;i<fNPatches;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fNRows[i]=(Int_t)dummy;}
 815     }
 816     else if(strcmp(d1,"fRows[0][0]")==0){
 817       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fRows[0][0]=(Int_t)dummy;
 818       fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fRows[0][1]=(Int_t)dummy;
 819       for(Int_t i=1;i<fNPatches;i++){
 820         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fRows[i][0]=(Int_t)dummy;
 821         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fRows[i][1]=(Int_t)dummy;
 822       }
 823     }
 824     else if(strcmp(d1,"fSlice2Sector[0][0]")==0){
 825       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fSlice2Sector[0][0]=(Int_t)dummy;
 826       fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSlice2Sector[0][1]=(Int_t)dummy;
 827       for(Int_t i=1;i<fNSlice;i++){
 828         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSlice2Sector[i][0]=(Int_t)dummy;
 829         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSlice2Sector[i][1]=(Int_t)dummy;
 830       }
 831     }
 832     else if(strcmp(d1,"fSector2Slice[0]")==0){
 833       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fSector2Slice[0]=(Int_t)dummy;
 834       for(Int_t i=1;i<fNSector;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSector2Slice[i]=(Int_t)dummy;}
 835     }
 836     else if(strcmp(d1,"fSectorLow[0]")==0){
 837       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fSectorLow[0]=(Int_t)dummy;
 838       for(Int_t i=1;i<fNSector;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fSectorLow[i]=(Int_t)dummy;}
 839     }
 840     else if(strcmp(d1,"fCos[0]")==0){
 841       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fCos[0]=(Double_t)ddummy;
 842       for(Int_t i=1;i<fNSlice;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fCos[0]=(Double_t)ddummy;}
 843     }
 844     else if(strcmp(d1,"fSin[0]")==0){
 845       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fSin[0]=(Double_t)ddummy;
 846       for(Int_t i=1;i<fNSlice;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fSin[0]=(Double_t)ddummy;}
 847     }
 848   }
 849
 850   //The first multiplier gives the scale factor used to modify the field map
 851   //defined by the second multiplier.
 852   fBField=fBFieldFactor*fSolenoidBField*0.1;
 853
 854   fclose(fptr);
 855
 856   //Test if new config file has been used.
 857   if(fVersion==fV_deprecated){
 858     LOG(AliL3Log::kError,"AliL3Transform::Init","Version")
 859       <<"Version is deprecated, you have to create a new config file."<<ENDLOG;
 860     return kFALSE;
 861   }
 862
 863   return kTRUE;
 864 }
 865
 866 Bool_t AliL3Transform::ReadInit(Char_t *path)
 867 {
 868   //Read all the parameters from a aliroot file, and store it in a temporary
 869   //file which is read by Init. Use this if you want to read the parameters from
 870   //the rootfile "every" time.
 871
 872 #ifndef use_aliroot
 873   LOG(AliL3Log::kError,"AliL3Transform::ReadInit","Version")
 874     <<"You have to compile with use_aliroot flag in order to read from AliROOT file"<<ENDLOG;
 875   return kFALSE;
 876 #else
 877   Char_t filename[1024];
 878   //first test whether provided path is the rootfile itself
 879   Int_t saveErrIgLevel=gErrorIgnoreLevel;
 880   gErrorIgnoreLevel=kFatal; //dont report errors
 881   TFile *rootfile = TFile::Open(path);
 882   if(rootfile->IsZombie())
 883     { //ok assume its path to alirunfile file
 884       sprintf(filename,"%s/alirunfile.root",path); //create rootfile name
 885     } else { //path contains itself the rootfile name
 886       rootfile->Close();
 887       sprintf(filename,"%s",path);
 888     }
 889   gErrorIgnoreLevel=saveErrIgLevel;
 890
 891   //finally make dummy init file /tmp/$USER/l3transform.config-`date`
 892   Char_t tmppath[1024];
 893   sprintf(tmppath,"/tmp/%s",gSystem->Getenv("USER"));
 894   gSystem->mkdir(tmppath);
 895   TTimeStamp time;
 896   Char_t tmpfile[1024];
 897   sprintf(tmpfile,"%s/l3transform.config-%d",tmppath,(Int_t)time.GetSec());
 898   return MakeInitFile(filename,tmpfile);
 899 #endif
 900 }
 901
 902 Bool_t AliL3Transform::MakeInitFile(Char_t *rootfilename,Char_t *filename)
 903 {
 904   //Get the parameters from rootfile, and store it on the file "l3transform.config"
 905   //which is being read by Init. fVersion will be fV_aliroot!
 906
 907 #ifndef use_aliroot
 908   LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","Version")
 909     <<"You have to compile with use_aliroot flag in order to use this function"<<ENDLOG;
 910   return kFALSE;
 911 #else
 912   TFile *rootfile = TFile::Open(rootfilename);
 913   if(!rootfile)
 914     {
 915       LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","File")
 916         <<"Could not open file: "<<rootfilename<<ENDLOG;
 917       return kFALSE;
 918     }
 919   AliRun *gAlice = (AliRun*)rootfile->Get("gAlice");
 920   if(!gAlice)
 921     {
 922       LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","File")
 923         <<"No gAlice in file: "<<rootfilename<<ENDLOG;
 924       return kFALSE;
 925     }
 926   AliTPCParamSR *param=(AliTPCParamSR*)rootfile->Get(GetParamName());
 927   if(!param)
 928     {
 929       LOG(AliL3Log::kWarning,"AliL3Transform::MakeInitFile","File")
 930         <<"No TPC parameters found in \""<<rootfilename
 931         <<"\", creating standard parameters "
 932         <<"which might not be what you want!"<<ENDLOG;
 933       param=new AliTPCParamSR;
 934     }
 935
 936   AliTPCPRF2D    * prfinner    = new AliTPCPRF2D;
 937   AliTPCPRF2D    * prfouter1   = new AliTPCPRF2D;
 938   AliTPCPRF2D    * prfouter2   = new AliTPCPRF2D;
 939   AliTPCRF1D     * rf    = new AliTPCRF1D(kTRUE);
 940   rf->SetGauss(param->GetZSigma(),param->GetZWidth(),1.);
 941   rf->SetOffset(3*param->GetZSigma());
 942   rf->Update();
 943
 944   TDirectory *savedir=gDirectory;
 945   TFile *prf_file = TFile::Open("$ALICE_ROOT/TPC/AliTPCprf2d.root");
 946   if (!prf_file->IsOpen())
 947     {
 948       LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","File")
 949         <<"Can't open $ALICE_ROOT/TPC/AliTPCprf2d.root !"<<ENDLOG;
 950       return kFALSE;
 951     }
 952   prfinner ->Read("prf_07504_Gati_056068_d02");
 953   prfouter1->Read("prf_10006_Gati_047051_d03");
 954   prfouter2->Read("prf_15006_Gati_047051_d03");
 955   prf_file->Close();
 956   savedir->cd();
 957
 958   param->SetInnerPRF(prfinner);
 959   param->SetOuter1PRF(prfouter1);
 960   param->SetOuter2PRF(prfouter2);
 961   param->SetTimeRF(rf);
 962
 963   fNTimeBins = param->GetMaxTBin()+1;
 964   fNRowLow = param->GetNRowLow();
 965   fNRowUp  = param->GetNRowUp();
 966   fNRowUp1 = param->GetNRowUp1();
 967   fNRowUp2 = param->GetNRowUp2();
 968   fNRow= fNRowLow + fNRowUp;
 969   if(fNRow!=159){
 970     LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","fNRow")
 971       <<"Number of rows have changed in ALIROOT"<<ENDLOG;
 972     return kFALSE;
 973   }
 974
 975   fNSectorLow = param->GetNInnerSector();
 976   fNSectorUp = param->GetNOuterSector();
 977   fNSector = fNSectorLow + fNSectorUp;
 978
 979   //test whether they were changes to the rotation shift
 980   fNRotShift=0;
 981   Float_t irotshift = param->GetInnerAngleShift(); //shift angle
 982   Float_t orotshift = param->GetOuterAngleShift(); //shift angle
 983   const Float_t kDegtoRad = 0.01745329251994;
 984   Int_t shift1=TMath::Nint(irotshift/kDegtoRad);
 985   Int_t shift2=TMath::Nint(orotshift/kDegtoRad+0.1);
 986   if((shift1!=shift2) || (shift1!=10)){
 987     LOG(AliL3Log::kError,"AliL3Transform::MakeInitFile","Rotshiftangle")
 988       <<"Rotation shift angle has changed in ALIROOT"<<ENDLOG;
 989     return kFALSE;
 990   } else {
 991     fNRotShift=0.5; //our version of the shift angle
 992   }
 993
 994   fVersion=fV_aliroot;
 995   fBFieldFactor=(Double_t)gAlice->Field()->Factor();
 996   fSolenoidBField=(Double_t)gAlice->Field()->SolenoidField();
 997   fPadPitchWidthLow=param->GetInnerPadPitchWidth();
 998   fPadPitchWidthUp=param->GetOuterPadPitchWidth();
 999   fZWidth=param->GetZWidth();
1000   fZSigma=param->GetZSigma();
1001   fZLength=param->GetZLength();
1002   fZOffset=param->GetZOffset();
1003   fDiffT=param->GetDiffT();
1004   fDiffL=param->GetDiffL();
1005   fOmegaTau=param->GetOmegaTau();
1006   fInnerPadLength=param->GetInnerPadLength();
1007   fOuter1PadLength=param->GetOuter1PadLength();
1008   fOuter2PadLength=param->GetOuter2PadLength();
1009   fInnerPRFSigma=param->GetInnerPRF()->GetSigmaX();
1010   fOuter1PRFSigma=param->GetOuter1PRF()->GetSigmaX();
1011   fOuter2PRFSigma=param->GetOuter2PRF()->GetSigmaX();
1012   fTimeSigma=param->GetTimeRF()->GetSigma();
1013   fADCSat=param->GetADCSat();
1014   fZeroSup=param->GetZeroSup();
1015   fNSlice=fNSectorLow;
1016
1017   //now do the arrays
1018   for(Int_t i=0;i<fNRow;i++){
1019     Int_t sec,row;
1020     if( i < fNRowLow){sec =0;row =i;}
1021     else{sec = fNSectorLow;row =i-fNRowLow;}
1022     fX[i]=param->GetPadRowRadii(sec,row);
1023   }
1024   for(Int_t i=0;i<fNRow;i++){
1025     Int_t sec,row;
1026     if( i < fNRowLow){sec =0;row =i;}
1027     else{sec = fNSectorLow;row =i-fNRowLow;}
1028     fNPads[i]=param->GetNPads(sec,row);
1029   }
1030   for(Int_t i=0;i<fNSector;i++){
1031     if(i<fNSectorLow) fSectorLow[i]=1;
1032     else fSectorLow[i]=0;
1033   }
1034   return SaveInitFile(filename);
1035 #endif
1036 }
1037
1038 Bool_t AliL3Transform::SaveInitFile(Char_t *filenamepath)
1039 {
1040   //store the parameters in the file "filenamepath"
1041
1042   FILE *f = fopen(filenamepath,"w");
1043   if(!f){
1044     LOG(AliL3Log::kError,"AliL3Transform::SaveInitFile","File")
1045         <<"Could not open file: "<<filenamepath<<ENDLOG;
1046     return kFALSE;
1047   }
1048
1049   fprintf(f,"void AliL3Transform::Init(){\n");
1050   fprintf(f,"  fVersion = %d;\n", fVersion);
1051   fprintf(f,"  fBFieldFactor = %.3f;\n",fBFieldFactor);
1052   fprintf(f,"  fSolenoidBField = %.3f;\n",fSolenoidBField);
1053   fprintf(f,"  fNTimeBins = %d;\n",fNTimeBins);
1054   fprintf(f,"  fNRowLow = %d;\n",fNRowLow);
1055   fprintf(f,"  fNRowUp = %d;\n",fNRowUp);
1056   fprintf(f,"  fNRowUp1 = %d;\n",fNRowUp1);
1057   fprintf(f,"  fNRowUp2 = %d;\n",fNRowUp2);
1058   fprintf(f,"  fNSectorLow = %d;\n",fNSectorLow);
1059   fprintf(f,"  fNSectorUp = %d;\n",fNSectorUp);
1060   fprintf(f,"  fNSector = %d;\n",fNSector);
1061   fprintf(f,"  fPadPitchWidthLow = %.3f;\n",fPadPitchWidthLow);
1062   fprintf(f,"  fPadPitchWidthUp = %.3f;\n",fPadPitchWidthUp);
1063   fprintf(f,"  fZWidth = %.4f;\n",fZWidth);
1064   fprintf(f,"  fZSigma = %.4f;\n",fZSigma);
1065   fprintf(f,"  fZLength = %.4f;\n",fZLength);
1066   fprintf(f,"  fZOffset = %.4f;\n",fZOffset);
1067   fprintf(f,"  fDiffT = %.4f;\n",fDiffT);
1068   fprintf(f,"  fDiffL = %.4f;\n",fDiffL);
1069   fprintf(f,"  fOmegaTau = %.4f;\n",fOmegaTau);
1070   fprintf(f,"  fInnerPadLength = %.3f;\n",fInnerPadLength);
1071   fprintf(f,"  fOuter1PadLength = %.3f;\n",fOuter1PadLength);
1072   fprintf(f,"  fOuter2PadLength = %.3f;\n",fOuter2PadLength);
1073   fprintf(f,"  fInnerPRFSigma = %.6f;\n",fInnerPRFSigma);
1074   fprintf(f,"  fOuter1PRFSigma = %.6f;\n",fOuter1PRFSigma);
1075   fprintf(f,"  fOuter2PRFSigma = %.6f;\n",fOuter2PRFSigma);
1076   fprintf(f,"  fTimeSigma = %.6f;\n",fTimeSigma);
1077   fprintf(f,"  fADCSat = %d;\n",fADCSat);
1078   fprintf(f,"  fZeroSup = %d;\n",fZeroSup);
1079   fprintf(f,"  fNSlice = %d;\n",fNSlice);
1080   fprintf(f,"  fNRow = %d;\n",fNRow);
1081   fprintf(f,"  fNRotShift = %.2f;\n",fNRotShift);
1082   //now do the arrays
1083   for(Int_t i=0;i<fNRow;i++){
1084     fprintf(f,"  fX[%d] = %3.2f;\n",i,fX[i]);
1085   }
1086   for(Int_t i=0;i<fNRow;i++){
1087     fprintf(f,"  fNPads[%d] = %d;\n",i,fNPads[i]);
1088   }
1089
1090   //Slice/Sector dont belong to aliroot, but we want to be flexible
1091   for(Int_t i=0;i<fNSlice;i++){
1092     fprintf(f,"  fSlice2Sector[%d][0] = %d;\n",i,fSlice2Sector[i][0]);
1093     fprintf(f,"  fSlice2Sector[%d][1] = %d;\n",i,fSlice2Sector[i][1]);
1094   }
1095   for(Int_t i=0;i<fNSector;i++){
1096     fprintf(f,"  fSector2Slice[%d] = %d;\n",i,fSector2Slice[i]);
1097   }
1098   for(Int_t i=0;i<fNSector;i++){
1099     fprintf(f,"  fSectorLow[%d] = %d;\n",i,fSectorLow[i]);
1100   }
1101
1102   //Patches also dont really belong to the aliroot settings (but nevermind)
1103   for(Int_t i=0;i<fNPatches;i++){
1104     fprintf(f,"  fNRows[%d] = %d;\n",i,fNRows[i]);
1105   }
1106   for(Int_t i=0;i<fNPatches;i++){
1107     fprintf(f,"  fRows[%d][0] = %d;\n",i,fRows[i][0]);
1108     fprintf(f,"  fRows[%d][1] = %d;\n",i,fRows[i][1]);
1109   }
1110
1111   //Rotation shift is an addon, too
1112   for(Int_t i=0;i<fNSlice;i++){
1113     Float_t cs = cos( (2*fPi/18) * (i+fNRotShift) );
1114     fprintf(f,"  fCos[%d] = %.10f;\n",i,cs);
1115   }
1116   for(Int_t i=0;i<fNSlice;i++){
1117     Float_t sn = sin( (2*fPi/18) * (i+fNRotShift) );
1118     fprintf(f,"  fSin[%d] = %.10f;\n",i,sn);
1119   }
1120
1121   fprintf(f,"}\n");
1122   fclose(f);
1123
1124   LOG(AliL3Log::kInformational,"AliL3Transform::SaveInitFile","File created")
1125     <<"Init file \""<<filenamepath<<"\" created"<<ENDLOG;
1126
1127   return kTRUE;
1128 }
1129
1130 Int_t AliL3Transform::GetNPads(Int_t row)
1131 {
1132   if(row < 0 || row >= fNRow)
1133     {
1134       LOG(AliL3Log::kError,"AliL3Transform::GetNPads","Row")
1135         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1136       return 0;
1137     }
1138
1139   return fNPads[row];
1140 }
1141
1142 Int_t AliL3Transform::GetFirstRow(Int_t patch)
1143 {
1144   if(patch==-1)
1145     return 0;
1146   else if(patch < -1 || patch >= 6)
1147     {
1148       LOG(AliL3Log::kError,"AliL3Transform::GetFirstRow","Patch")
1149         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1150       return 0;
1151     }
1152   else
1153     return fRows[patch][0];
1154 }
1155
1156 Int_t AliL3Transform::GetLastRow(Int_t patch)
1157 {
1158   if(patch==-1)
1159     return fRows[5][1];
1160   else if(patch < -1 || patch >= 6)
1161     {
1162       LOG(AliL3Log::kError,"AliL3Transform::GetLastRow","Patch")
1163         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1164       return 0;
1165     }
1166   else
1167     return fRows[patch][1];
1168 }
1169
1170 Int_t AliL3Transform::GetNRows(Int_t patch)
1171 {
1172   if(patch==-1)
1173     return fNRow;
1174   else if(patch < -1 || patch >= 6)
1175     {
1176       LOG(AliL3Log::kError,"AliL3Transform::GetNRows","Patch")
1177         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1178       return 0;
1179     }
1180   else
1181     return fNRows[patch];
1182 }
1183
1184 Int_t AliL3Transform::GetPadRow(Float_t xvalue)
1185 {
1186   //Find the padrow number corresponding to cartesian _local_ x value
1187
1188   if(xvalue < 0 || xvalue > 250)
1189     {
1190       LOG(AliL3Log::kError,"AliL3Transform::GetPadRow","X-value")
1191         <<AliL3Log::kDec<<"Suspicious x-value, make sure it is in local coordinate! "
1192         <<xvalue<<ENDLOG;
1193       return -1;
1194     }
1195
1196   Int_t x = (Int_t)rint(xvalue*10);
1197   if(x < (Int_t)rint(fX[1]*10))
1198     return 0;
1199   else if(x > (Int_t)rint(fX[fNRow-2]*10))
1200     return fNRow-1;
1201   else
1202     {
1203       Int_t padrow=1; //Of course, a more clever algorithm could help here
1204       while(padrow < fNRow-2)
1205         {
1206           if(x > (Int_t)rint(fX[padrow-1]*10) && x < (Int_t)rint(fX[padrow+1]*10))
1207             break;
1208           padrow++;
1209         }
1210       return padrow;
1211     }
1212 }
1213
1214 Int_t AliL3Transform::GetPatch(Int_t padrow)
1215 {
1216   if(padrow < 0 || padrow >= fNRow)
1217     {
1218       LOG(AliL3Log::kError,"AliL3Transform::GetPatch","Padrow")
1219         <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1220       return -2;
1221     }
1222   Int_t patch=0;
1223   while(patch < fNPatches)
1224     {
1225       if(padrow >= fRows[patch][0] && padrow <= fRows[patch][1])
1226         break;
1227       patch++;
1228     }
1229   return patch;
1230 }
1231
1232 Double_t AliL3Transform::GetPadLength(Int_t padrow)
1233 {
1234   if(padrow >= fNRow){
1235       LOG(AliL3Log::kError,"AliL3Transform::GetPadLength","Padrow")
1236         <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1237       return 0;
1238     }
1239
1240   if(padrow < fNRowLow)
1241     return fInnerPadLength;
1242   if(padrow >= fNRowLow && padrow < fNRowLow + fNRowUp1 - 1)
1243     return fOuter1PadLength;
1244   if(padrow >= fNRowLow + fNRowUp1 - 1)
1245     return fOuter2PadLength;
1246
1247   //should never happen
1248   LOG(AliL3Log::kError,"AliL3Transform::GetPadLength","Padrow")
1249     <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1250   return -1.0;
1251 }
1252
1253 Double_t AliL3Transform::GetPadPitchWidth(Int_t patch)
1254 {
1255   if(patch < 0 || patch > fNPatches)
1256     {
1257       LOG(AliL3Log::kError,"AliL3Transform::GetPadPitchWidth","patct")
1258         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1259       return -1;
1260     }
1261   return patch < 2 ? fPadPitchWidthLow : fPadPitchWidthUp;
1262 }
1263
1264 Double_t AliL3Transform::GetParSigmaY2(Int_t padrow,Float_t z,Float_t angle)
1265 {
1266   //Calculate the expected transverse cluster width as a function of
1267   //drift distance and crossing angle.
1268   //z = local z-coordinate of cluster
1269   //angle = track crossing angle with normal to padrow plane
1270   //return value = sigma^2 (cartesian coordinates)
1271
1272   Double_t drift;
1273   if(z > 0)
1274     drift = fZLength - z;
1275   else
1276     drift = fZLength + z;
1277
1278   Double_t t1 = GetPRFSigma(padrow)*GetPRFSigma(padrow);
1279   Double_t t2 = fDiffT*fDiffT*drift;
1280   Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tan(angle)*tan(angle)/12;
1281   Double_t t4 = fAnodeWireSpacing*fAnodeWireSpacing*(tan(angle) - fOmegaTau)*(tan(angle) - fOmegaTau)/12;
1282
1283   return (t1 + t2 + t3 + t4);
1284 }
1285
1286 Double_t AliL3Transform::GetParSigmaZ2(Int_t padrow,Float_t z,Float_t tgl)
1287 {
1288   //Calculate the expected longitudinal cluster width as a function of
1289   //drift distance and track crossing angle.
1290   //z = local z-coordinate of cluster
1291   //tgl = tan(dipangle)
1292   //return value = sigma^2 (cartesian coordinates)
1293
1294   Double_t drift;
1295   if(z > 0)
1296     drift = AliL3Transform::GetZLength() - z;
1297   else
1298     drift = AliL3Transform::GetZLength() + z;
1299
1300   Double_t t1 = fZSigma*fZSigma;
1301   Double_t t2 = fDiffL*fDiffL*drift;
1302   Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tgl*tgl/12;
1303
1304   return (t1 + t2 + t3);
1305 }
1306
1307 Double_t AliL3Transform::GetPRFSigma(Int_t padrow)
1308 {
1309   if(padrow >= fNRow){
1310     LOG(AliL3Log::kError,"AliL3Transform::GetPRFSigma","Padrow")
1311       <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1312     return 0;
1313   }
1314   if(padrow < fNRowLow)
1315     return fInnerPRFSigma;
1316   if(padrow >= fNRowLow && padrow < fNRowLow + fNRowUp1 - 1)
1317     return fOuter1PRFSigma;
1318   if(padrow >= fNRowLow + fNRowUp1 - 1)
1319     return fOuter2PRFSigma;
1320
1321   //should never happen
1322   LOG(AliL3Log::kError,"AliL3Transform::GetPRFSigma","Padrow")
1323     <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1324   return -1.;
1325 }
1326
1327 Double_t AliL3Transform::GetEta(Float_t *xyz)
1328 {
1329   Double_t r3 = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1330   Double_t eta = 0.5 * log((r3+xyz[2])/(r3-xyz[2]));
1331   return eta;
1332 }
1333
1334 void AliL3Transform::XYZtoRPhiEta(Float_t *rpe, Float_t *xyz)
1335 {
1336   rpe[0] = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1337   rpe[1] = atan2(xyz[1],xyz[0]);
1338   rpe[2] = 0.5 * log((rpe[0]+xyz[2])/(rpe[0]-xyz[2]));
1339 }
1340
1341 Double_t AliL3Transform::GetEta(Int_t slice,Int_t padrow,Int_t pad,Int_t time)
1342 {
1343   Float_t xyz[3];
1344   Int_t sector,row;
1345   Slice2Sector(slice,padrow,sector,row);
1346   Raw2Local(xyz,sector,row,pad,time);
1347
1348   return GetEta(xyz);
1349 }
1350
1351 Double_t AliL3Transform::GetPhi(Float_t *xyz)
1352 {
1353   Double_t phi = atan2(xyz[1],xyz[0]);
1354   return phi;
1355 }
1356
1357 Bool_t AliL3Transform::Slice2Sector(Int_t slice, Int_t slicerow, Int_t & sector, Int_t &row)
1358 {
1359   if(slicerow<0&&slicerow>=fNRow){
1360     LOG(AliL3Log::kError,"AliL3Transform::Slice2Sector","Slicerow")
1361       <<AliL3Log::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1362     return kFALSE;
1363   }
1364   if(slice<0||slice>=fNSlice){
1365     LOG(AliL3Log::kError,"AliL3Transform::Slice2Sector","Slice")
1366       <<AliL3Log::kDec<<"Wrong slice "<<slice<<ENDLOG;
1367     return kFALSE;
1368   }
1369
1370   if(slicerow<fNRowLow){
1371     sector = fSlice2Sector[slice][0];
1372     row    = slicerow;
1373   }
1374   else {
1375     sector = fSlice2Sector[slice][1];
1376     row    = slicerow-fNRowLow;
1377   }
1378
1379   return kTRUE;
1380 }
1381
1382 Bool_t AliL3Transform::Sector2Slice(Int_t & slice, Int_t  sector)
1383 {
1384   if(sector<0||sector>=fNSector){
1385     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Sector")
1386       <<AliL3Log::kDec<<"Wrong sector "<<sector<<ENDLOG;
1387     return kFALSE;
1388   }
1389
1390   slice=fSector2Slice[sector];
1391
1392   return kTRUE;
1393 }
1394
1395 Bool_t AliL3Transform::Sector2Slice(Int_t & slice, Int_t & slicerow, Int_t sector, Int_t row)
1396 {
1397   if(sector<0 || sector>=fNSector){
1398     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Sector")
1399       <<AliL3Log::kDec<<"Wrong sector "<<sector<<ENDLOG;
1400     return kFALSE;
1401   }
1402   if(row<0){
1403     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1404       <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1405     return kFALSE;
1406   }
1407
1408   if(fSectorLow[sector]){
1409     if(row>=fNRowLow){
1410       LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1411         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1412       return kFALSE;
1413     }
1414     slice = fSector2Slice[sector];
1415     slicerow = row;
1416   }
1417   else{
1418     if(row>=fNRowUp){
1419       LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1420         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1421       return kFALSE;
1422     }
1423     slice = fSector2Slice[sector];
1424     slicerow = row + fNRowLow;
1425   }
1426
1427   return kTRUE;
1428 }
1429
1430 Double_t AliL3Transform::Row2X(Int_t slicerow){
1431   if(slicerow<0||slicerow>=fNRow){
1432     LOG(AliL3Log::kError,"AliL3Transform::Row2X","Slicerow")
1433       <<AliL3Log::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1434     return 0;
1435   }
1436   return fX[slicerow];
1437 }
1438
1439 void AliL3Transform::Local2Global(Float_t *xyz,Int_t slice)
1440 {
1441   //Transformation to global coordinate system
1442   Float_t x0 = xyz[0];
1443   Float_t y0 = xyz[1];
1444
1445   xyz[0]=x0*fCos[slice]-y0*fSin[slice];
1446   xyz[1]=x0*fSin[slice]+y0*fCos[slice];
1447   xyz[2]=xyz[2];//global z=local z
1448 }
1449
1450 void AliL3Transform::Local2GlobalAngle(Float_t *angle,Int_t slice){
1451   angle[0] = fmod(angle[0]+(slice+fNRotShift)*(2*fPi/18),2*fPi);
1452 }
1453
1454 void AliL3Transform::Global2LocalAngle(Float_t *angle,Int_t slice){
1455   angle[0] = angle[0]-(slice+fNRotShift)*(2*fPi/18);
1456   if(angle[0]<0) angle[0]+=2*fPi;
1457 }
1458
1459 void AliL3Transform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1460 {
1461   //Transformation from rawdata to local coordinate system
1462
1463   Int_t slice,slicerow;
1464   Sector2Slice(slice, slicerow, sector, row);
1465
1466   //X-Value
1467   xyz[0]=Row2X(slicerow);
1468
1469   //Y-Value
1470   Int_t npads= fNPads[slicerow];
1471
1472   if(fSectorLow[sector])
1473     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthLow;
1474   else
1475     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthUp;
1476
1477   //Z-Value (remember PULSA Delay)
1478   //xyz[2]=fZWidth*time-3.*fZSigma;
1479   xyz[2]=fZWidth*time-fZOffset;
1480   if(slice < 18)
1481     xyz[2]=fZLength-xyz[2];
1482   else
1483     xyz[2]=xyz[2]-fZLength;
1484 }
1485
1486 void AliL3Transform::Local2Global(Float_t *xyz,Int_t sector,Int_t row)
1487 {
1488   //Transformation to global coordinate system
1489   Int_t slice,slicerow;
1490   Sector2Slice(slice, slicerow, sector, row);
1491   Float_t r=Row2X(slicerow); //have to get x value first
1492
1493   xyz[0]=r*fCos[slice]-xyz[1]*fSin[slice];
1494   xyz[1]=r*fSin[slice]+xyz[1]*fCos[slice];
1495   xyz[2]=xyz[2];//global z=local z
1496 }
1497
1498 Double_t AliL3Transform::GetMaxY(Int_t slicerow)
1499 {
1500
1501  if(slicerow < fNRowLow)
1502      return fPadPitchWidthLow*fNPads[slicerow]/2;
1503
1504  else
1505      return fPadPitchWidthUp*fNPads[slicerow]/2;
1506
1507 }
1508
1509 void AliL3Transform::Global2Local(Float_t *xyz,Int_t sector,Bool_t isSlice)
1510 {
1511   Int_t slice;
1512   if(!isSlice)
1513     Sector2Slice(slice, sector);
1514   else
1515     slice = sector;
1516
1517   Float_t x1 =  xyz[0]*fCos[slice] + xyz[1]*fSin[slice];
1518   Float_t y1 = -xyz[0]*fSin[slice] + xyz[1]*fCos[slice];
1519   xyz[0] = x1;
1520   xyz[1] = y1;
1521 }
1522
1523 void AliL3Transform::Raw2Global(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1524 {
1525   //Transformation from raw to global coordinates
1526
1527   Raw2Local(xyz,sector,row,pad,time);
1528   Local2Global(xyz,sector,row);
1529 }
1530
1531 void AliL3Transform::Local2Raw(Float_t *xyz,Int_t sector,Int_t row)
1532 {
1533   //Transformation from local coordinates to raw
1534
1535   Int_t slice,slicerow;
1536   Sector2Slice(slice, slicerow, sector, row);
1537
1538   xyz[0]=slicerow;
1539   //xyz[0]=GetPadRow(xyz[0]);
1540
1541   if(fSectorLow[sector])
1542     xyz[1]=xyz[1]/fPadPitchWidthLow+0.5*(fNPads[slicerow]-1);
1543   else
1544     xyz[1]=xyz[1]/fPadPitchWidthUp+0.5*(fNPads[slicerow]-1);
1545
1546   Int_t sign=-1;
1547   if(slice < 18) sign = 1;
1548   xyz[2]=fZLength-sign*xyz[2];
1549   xyz[2]=(xyz[2]+fZOffset)/fZWidth;
1550 }
1551
1552 void AliL3Transform::Global2Raw(Float_t *xyz,Int_t sector,Int_t row)
1553 {
1554   //Transformation from global coordinates to raw.
1555
1556   Global2Local(xyz,sector);
1557   Local2Raw(xyz,sector,row);
1558 }
1559
1560 void AliL3Transform::PrintCompileOptions()
1561 {
1562   cout << "Compiler (g++) version used: " << GCCVERSION << endl;
1563
1564 #ifdef no_root
1565   cout << "STANDALONE version: -Dno_root was given." << endl;
1566 #else
1567   const Char_t *roottest="$ROOTSYS/bin/root -n -b -q  | grep Version | cut -b 17-25 | cut -d\" \" -f1";
1568 #ifdef use_aliroot
1569 #ifdef use_cvs
1570   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";
1571 #else
1572   const Char_t *aliroottest="Unknown";
1573 #endif
1574   cout << "ALIROOT version: -Duse_aliroot and -Duse_root was given." << endl;
1575   cout << "Root Version: " << ROOTVERSION << " found " << flush;
1576   gSystem->Exec(roottest);
1577
1578   cout << "AliRoot Version: " << ALIROOTVERSION << " found " << flush;
1579   gSystem->Exec(aliroottest);
1580 #else
1581   cout << "ROOT version: -Duse_root was given." << endl;
1582   cout << "Root Version: " << ROOTVERSION << " found " << flush;
1583   gSystem->Exec(roottest);
1584 #endif
1585 #endif
1586
1587 #ifdef do_mc
1588   cout << "Using Monte Carlo Info: -Ddo_mc was given." << endl;
1589 #else
1590   cout << "NOT using Monte Carlo Info: -Ddo_mc was not given." << endl;
1591 #endif
1592
1593 #ifdef use_logging
1594   cout << "Using logging classes (MLUC): -Duse_logging was given." << endl;
1595 #else
1596   cout << "NOT using logging classes (MLUC): -Duse_logging not was given." << endl;
1597 #endif
1598 }