73e02d66810e3e05b75efc89c2c2989916cdd01a
[u/mrichter/AliRoot.git] / 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
1038   delete gAlice;
1039   rootfile->Close();
1040   delete rootfile;
1041
1042   return SaveInitFile(filename);
1043 #endif
1044 }
1045
1046 Bool_t AliL3Transform::SaveInitFile(Char_t *filenamepath)
1047 {
1048   //store the parameters in the file "filenamepath"
1049   
1050   FILE *f = fopen(filenamepath,"w");
1051   if(!f){
1052     LOG(AliL3Log::kError,"AliL3Transform::SaveInitFile","File")
1053         <<"Could not open file: "<<filenamepath<<ENDLOG;
1054     return kFALSE;
1055   }
1056
1057   fprintf(f,"void AliL3Transform::Init(){\n");
1058   fprintf(f,"  fVersion = %d;\n", fVersion); 
1059   fprintf(f,"  fBFieldFactor = %.3f;\n",fBFieldFactor);
1060   fprintf(f,"  fSolenoidBField = %.3f;\n",fSolenoidBField);
1061   fprintf(f,"  fNTimeBins = %d;\n",fNTimeBins);
1062   fprintf(f,"  fNRowLow = %d;\n",fNRowLow);
1063   fprintf(f,"  fNRowUp = %d;\n",fNRowUp);
1064   fprintf(f,"  fNRowUp1 = %d;\n",fNRowUp1);
1065   fprintf(f,"  fNRowUp2 = %d;\n",fNRowUp2);
1066   fprintf(f,"  fNSectorLow = %d;\n",fNSectorLow);
1067   fprintf(f,"  fNSectorUp = %d;\n",fNSectorUp);
1068   fprintf(f,"  fNSector = %d;\n",fNSector);
1069   fprintf(f,"  fPadPitchWidthLow = %.3f;\n",fPadPitchWidthLow);
1070   fprintf(f,"  fPadPitchWidthUp = %.3f;\n",fPadPitchWidthUp);
1071   fprintf(f,"  fZWidth = %.4f;\n",fZWidth);
1072   fprintf(f,"  fZSigma = %.4f;\n",fZSigma);
1073   fprintf(f,"  fZLength = %.4f;\n",fZLength);
1074   fprintf(f,"  fZOffset = %.4f;\n",fZOffset);
1075   fprintf(f,"  fDiffT = %.4f;\n",fDiffT);
1076   fprintf(f,"  fDiffL = %.4f;\n",fDiffL);
1077   fprintf(f,"  fOmegaTau = %.4f;\n",fOmegaTau);
1078   fprintf(f,"  fInnerPadLength = %.3f;\n",fInnerPadLength);
1079   fprintf(f,"  fOuter1PadLength = %.3f;\n",fOuter1PadLength);
1080   fprintf(f,"  fOuter2PadLength = %.3f;\n",fOuter2PadLength);
1081   fprintf(f,"  fInnerPRFSigma = %.6f;\n",fInnerPRFSigma);
1082   fprintf(f,"  fOuter1PRFSigma = %.6f;\n",fOuter1PRFSigma);
1083   fprintf(f,"  fOuter2PRFSigma = %.6f;\n",fOuter2PRFSigma);
1084   fprintf(f,"  fTimeSigma = %.6f;\n",fTimeSigma);
1085   fprintf(f,"  fADCSat = %d;\n",fADCSat);
1086   fprintf(f,"  fZeroSup = %d;\n",fZeroSup);
1087   fprintf(f,"  fNSlice = %d;\n",fNSlice);
1088   fprintf(f,"  fNRow = %d;\n",fNRow);
1089   fprintf(f,"  fNRotShift = %.2f;\n",fNRotShift);
1090   //now do the arrays
1091   for(Int_t i=0;i<fNRow;i++){
1092     fprintf(f,"  fX[%d] = %3.2f;\n",i,fX[i]);
1093   } 
1094   for(Int_t i=0;i<fNRow;i++){
1095     fprintf(f,"  fNPads[%d] = %d;\n",i,fNPads[i]);
1096   }
1097
1098   //Slice/Sector dont belong to aliroot, but we want to be flexible
1099   for(Int_t i=0;i<fNSlice;i++){
1100     fprintf(f,"  fSlice2Sector[%d][0] = %d;\n",i,fSlice2Sector[i][0]);
1101     fprintf(f,"  fSlice2Sector[%d][1] = %d;\n",i,fSlice2Sector[i][1]);
1102   }  
1103   for(Int_t i=0;i<fNSector;i++){
1104     fprintf(f,"  fSector2Slice[%d] = %d;\n",i,fSector2Slice[i]);
1105   }  
1106   for(Int_t i=0;i<fNSector;i++){
1107     fprintf(f,"  fSectorLow[%d] = %d;\n",i,fSectorLow[i]);
1108   }  
1109
1110   //Patches also dont really belong to the aliroot settings (but nevermind)
1111   for(Int_t i=0;i<fNPatches;i++){
1112     fprintf(f,"  fNRows[%d] = %d;\n",i,fNRows[i]);
1113   }  
1114   for(Int_t i=0;i<fNPatches;i++){
1115     fprintf(f,"  fRows[%d][0] = %d;\n",i,fRows[i][0]);
1116     fprintf(f,"  fRows[%d][1] = %d;\n",i,fRows[i][1]);
1117   }  
1118
1119   //Rotation shift is an addon, too
1120   for(Int_t i=0;i<fNSlice;i++){
1121     Float_t cs = cos( (2*fPi/18) * (i+fNRotShift) );
1122     fprintf(f,"  fCos[%d] = %.10f;\n",i,cs);
1123   }
1124   for(Int_t i=0;i<fNSlice;i++){
1125     Float_t sn = sin( (2*fPi/18) * (i+fNRotShift) );
1126     fprintf(f,"  fSin[%d] = %.10f;\n",i,sn);
1127   }
1128
1129   fprintf(f,"}\n");
1130   fclose(f);
1131
1132   LOG(AliL3Log::kInformational,"AliL3Transform::SaveInitFile","File created")
1133     <<"Init file \""<<filenamepath<<"\" created"<<ENDLOG;
1134
1135   return kTRUE;
1136 }
1137
1138 Int_t AliL3Transform::GetNPads(Int_t row)
1139 {
1140   if(row < 0 || row >= fNRow)
1141     {
1142       LOG(AliL3Log::kError,"AliL3Transform::GetNPads","Row")
1143         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1144       return 0;
1145     }
1146
1147   return fNPads[row];
1148 }
1149
1150 Int_t AliL3Transform::GetFirstRow(Int_t patch)
1151 {
1152   if(patch==-1)
1153     return 0;
1154   else if(patch < -1 || patch >= 6)
1155     {
1156       LOG(AliL3Log::kError,"AliL3Transform::GetFirstRow","Patch")
1157         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1158       return 0;
1159     }
1160   else
1161     return fRows[patch][0];
1162 }
1163
1164 Int_t AliL3Transform::GetLastRow(Int_t patch)
1165 {
1166   if(patch==-1)
1167     return fRows[5][1];
1168   else if(patch < -1 || patch >= 6)
1169     {
1170       LOG(AliL3Log::kError,"AliL3Transform::GetLastRow","Patch")
1171         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1172       return 0;
1173     }
1174   else
1175     return fRows[patch][1];
1176 }
1177
1178 Int_t AliL3Transform::GetNRows(Int_t patch)
1179 {
1180   if(patch==-1)
1181     return fNRow;
1182   else if(patch < -1 || patch >= 6)
1183     {
1184       LOG(AliL3Log::kError,"AliL3Transform::GetNRows","Patch")
1185         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1186       return 0;
1187     }
1188   else
1189     return fNRows[patch];
1190 }
1191
1192 Int_t AliL3Transform::GetPadRow(Float_t xvalue)
1193 {
1194   //Find the padrow number corresponding to cartesian _local_ x value
1195
1196   if(xvalue < 0 || xvalue > 250)
1197     {
1198       LOG(AliL3Log::kError,"AliL3Transform::GetPadRow","X-value")
1199         <<AliL3Log::kDec<<"Suspicious x-value, make sure it is in local coordinate! "
1200         <<xvalue<<ENDLOG;
1201       return -1;
1202     }
1203   
1204   Int_t x = (Int_t)rint(xvalue*10);
1205   if(x < (Int_t)rint(fX[1]*10))
1206     return 0;
1207   else if(x > (Int_t)rint(fX[fNRow-2]*10))
1208     return fNRow-1;
1209   else
1210     {
1211       Int_t padrow=1; //Of course, a more clever algorithm could help here
1212       while(padrow < fNRow-2)
1213         {
1214           if(x > (Int_t)rint(fX[padrow-1]*10) && x < (Int_t)rint(fX[padrow+1]*10))
1215             break;
1216           padrow++;
1217         }
1218       return padrow;
1219     }
1220 }
1221
1222 Int_t AliL3Transform::GetPatch(Int_t padrow)
1223 {
1224   if(padrow < 0 || padrow >= fNRow)
1225     {
1226       LOG(AliL3Log::kError,"AliL3Transform::GetPatch","Padrow")
1227         <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1228       return -2;
1229     }
1230   Int_t patch=0;
1231   while(patch < fNPatches)
1232     {
1233       if(padrow >= fRows[patch][0] && padrow <= fRows[patch][1])
1234         break;
1235       patch++;
1236     }
1237   return patch;
1238 }
1239
1240 Double_t AliL3Transform::GetPadLength(Int_t padrow)
1241 {
1242   if(padrow >= fNRow){
1243       LOG(AliL3Log::kError,"AliL3Transform::GetPadLength","Padrow")
1244         <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1245       return 0;
1246     }
1247
1248   if(padrow < fNRowLow)
1249     return fInnerPadLength;
1250   if(padrow >= fNRowLow && padrow < fNRowLow + fNRowUp1 - 1)
1251     return fOuter1PadLength;
1252   if(padrow >= fNRowLow + fNRowUp1 - 1)
1253     return fOuter2PadLength;
1254
1255   //should never happen
1256   LOG(AliL3Log::kError,"AliL3Transform::GetPadLength","Padrow")
1257     <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1258   return -1.0; 
1259 }
1260
1261 Double_t AliL3Transform::GetPadPitchWidth(Int_t patch)
1262 {
1263   if(patch < 0 || patch > fNPatches)
1264     {
1265       LOG(AliL3Log::kError,"AliL3Transform::GetPadPitchWidth","patct")
1266         <<AliL3Log::kDec<<"Wrong patch "<<patch<<ENDLOG;
1267       return -1;
1268     }
1269   return patch < 2 ? fPadPitchWidthLow : fPadPitchWidthUp;  
1270 }
1271
1272 Double_t AliL3Transform::GetParSigmaY2(Int_t padrow,Float_t z,Float_t angle)
1273 {
1274   //Calculate the expected transverse cluster width as a function of 
1275   //drift distance and crossing angle.
1276   //z = local z-coordinate of cluster
1277   //angle = track crossing angle with normal to padrow plane
1278   //return value = sigma^2 (cartesian coordinates)
1279
1280   Double_t drift;
1281   if(z > 0)
1282     drift = fZLength - z;
1283   else
1284     drift = fZLength + z;
1285   
1286   Double_t t1 = GetPRFSigma(padrow)*GetPRFSigma(padrow);
1287   Double_t t2 = fDiffT*fDiffT*drift;
1288   Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tan(angle)*tan(angle)/12;
1289   Double_t t4 = fAnodeWireSpacing*fAnodeWireSpacing*(tan(angle) - fOmegaTau)*(tan(angle) - fOmegaTau)/12;
1290
1291   return (t1 + t2 + t3 + t4);
1292 }
1293
1294 Double_t AliL3Transform::GetParSigmaZ2(Int_t padrow,Float_t z,Float_t tgl)
1295 {
1296   //Calculate the expected longitudinal cluster width as a function of 
1297   //drift distance and track crossing angle.
1298   //z = local z-coordinate of cluster
1299   //tgl = tan(dipangle) 
1300   //return value = sigma^2 (cartesian coordinates)
1301
1302   Double_t drift;
1303   if(z > 0)
1304     drift = AliL3Transform::GetZLength() - z;
1305   else
1306     drift = AliL3Transform::GetZLength() + z;
1307   
1308   Double_t t1 = fZSigma*fZSigma;
1309   Double_t t2 = fDiffL*fDiffL*drift;
1310   Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tgl*tgl/12;
1311   
1312   return (t1 + t2 + t3);
1313 }
1314
1315 Double_t AliL3Transform::GetPRFSigma(Int_t padrow)
1316 {
1317   if(padrow >= fNRow){
1318     LOG(AliL3Log::kError,"AliL3Transform::GetPRFSigma","Padrow")
1319       <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1320     return 0;
1321   }
1322   if(padrow < fNRowLow)
1323     return fInnerPRFSigma;
1324   if(padrow >= fNRowLow && padrow < fNRowLow + fNRowUp1 - 1)
1325     return fOuter1PRFSigma;
1326   if(padrow >= fNRowLow + fNRowUp1 - 1)
1327     return fOuter2PRFSigma;
1328
1329   //should never happen
1330   LOG(AliL3Log::kError,"AliL3Transform::GetPRFSigma","Padrow")
1331     <<AliL3Log::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1332   return -1.; 
1333 }
1334
1335 Double_t AliL3Transform::GetEta(Float_t *xyz)
1336 {
1337   Double_t r3 = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1338   Double_t eta = 0.5 * log((r3+xyz[2])/(r3-xyz[2]));
1339   return eta;
1340 }
1341
1342 void AliL3Transform::XYZtoRPhiEta(Float_t *rpe, Float_t *xyz)
1343 {
1344   rpe[0] = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1345   rpe[1] = atan2(xyz[1],xyz[0]);
1346   rpe[2] = 0.5 * log((rpe[0]+xyz[2])/(rpe[0]-xyz[2]));
1347 }
1348
1349 Double_t AliL3Transform::GetEta(Int_t slice,Int_t padrow,Int_t pad,Int_t time)
1350 {
1351   Float_t xyz[3];
1352   Int_t sector,row;
1353   Slice2Sector(slice,padrow,sector,row);
1354   Raw2Local(xyz,sector,row,pad,time);
1355   
1356   return GetEta(xyz);
1357 }
1358
1359 Double_t AliL3Transform::GetPhi(Float_t *xyz)
1360 {
1361   Double_t phi = atan2(xyz[1],xyz[0]);
1362   return phi;
1363 }
1364
1365 Bool_t AliL3Transform::Slice2Sector(Int_t slice, Int_t slicerow, Int_t & sector, Int_t &row)
1366 {
1367   if(slicerow<0&&slicerow>=fNRow){
1368     LOG(AliL3Log::kError,"AliL3Transform::Slice2Sector","Slicerow")
1369       <<AliL3Log::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1370     return kFALSE;
1371   }
1372   if(slice<0||slice>=fNSlice){
1373     LOG(AliL3Log::kError,"AliL3Transform::Slice2Sector","Slice")
1374       <<AliL3Log::kDec<<"Wrong slice "<<slice<<ENDLOG;
1375     return kFALSE;
1376   }
1377
1378   if(slicerow<fNRowLow){
1379     sector = fSlice2Sector[slice][0];
1380     row    = slicerow;
1381   }
1382   else {
1383     sector = fSlice2Sector[slice][1];
1384     row    = slicerow-fNRowLow;
1385   }
1386
1387   return kTRUE;
1388 }
1389
1390 Bool_t AliL3Transform::Sector2Slice(Int_t & slice, Int_t  sector)
1391 {
1392   if(sector<0||sector>=fNSector){
1393     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Sector")
1394       <<AliL3Log::kDec<<"Wrong sector "<<sector<<ENDLOG;
1395     return kFALSE;
1396   }
1397
1398   slice=fSector2Slice[sector];
1399
1400   return kTRUE;
1401 }
1402
1403 Bool_t AliL3Transform::Sector2Slice(Int_t & slice, Int_t & slicerow, Int_t sector, Int_t row)
1404 {
1405   if(sector<0 || sector>=fNSector){
1406     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Sector")
1407       <<AliL3Log::kDec<<"Wrong sector "<<sector<<ENDLOG;
1408     return kFALSE;
1409   }
1410   if(row<0){
1411     LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1412       <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1413     return kFALSE;
1414   }
1415
1416   if(fSectorLow[sector]){
1417     if(row>=fNRowLow){
1418       LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1419         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1420       return kFALSE;
1421     }
1422     slice = fSector2Slice[sector];
1423     slicerow = row;
1424   }
1425   else{
1426     if(row>=fNRowUp){
1427       LOG(AliL3Log::kError,"AliL3Transform::Sector2Slice","Row")
1428         <<AliL3Log::kDec<<"Wrong row "<<row<<ENDLOG;
1429       return kFALSE;
1430     }
1431     slice = fSector2Slice[sector];
1432     slicerow = row + fNRowLow;
1433   }
1434
1435   return kTRUE;
1436 }
1437
1438 Double_t AliL3Transform::GetMaxY(Int_t slicerow)
1439 {
1440  if(slicerow < fNRowLow)
1441      return fPadPitchWidthLow*fNPads[slicerow]/2; 
1442  
1443  else
1444      return fPadPitchWidthUp*fNPads[slicerow]/2;
1445
1446 }
1447
1448 Double_t AliL3Transform::Row2X(Int_t slicerow){
1449   if(slicerow<0||slicerow>=fNRow){
1450     LOG(AliL3Log::kError,"AliL3Transform::Row2X","Slicerow")
1451       <<AliL3Log::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1452     return 0;
1453   }
1454   return fX[slicerow];
1455 }
1456
1457 Double_t AliL3Transform::GetZFast(Int_t slice, Int_t time, Float_t vertex)
1458 {
1459   Double_t z=fZWidth*time-fZOffset;
1460   if(slice < 18)
1461     z=fZLength-z-vertex;
1462   else
1463     z=z-fZLength-vertex;
1464   return z;
1465 }
1466
1467 void AliL3Transform::Local2Global(Float_t *xyz,Int_t slice)
1468 {
1469   //Transformation to global coordinate system
1470   Float_t x0 = xyz[0];
1471   Float_t y0 = xyz[1];
1472
1473   xyz[0]=x0*fCos[slice]-y0*fSin[slice];
1474   xyz[1]=x0*fSin[slice]+y0*fCos[slice];
1475   xyz[2]=xyz[2];//global z=local z
1476 }
1477
1478 void AliL3Transform::Local2GlobalAngle(Float_t *angle,Int_t slice){
1479   angle[0] = fmod(angle[0]+(slice+fNRotShift)*(2*fPi/18),2*fPi);
1480 }
1481
1482 void AliL3Transform::Global2LocalAngle(Float_t *angle,Int_t slice){
1483   angle[0] = angle[0]-(slice+fNRotShift)*(2*fPi/18);
1484   if(angle[0]<0) angle[0]+=2*fPi;
1485 }
1486
1487 void AliL3Transform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1488 {
1489   //Transformation from rawdata to local coordinate system
1490   
1491   Int_t slice,slicerow;
1492   Sector2Slice(slice, slicerow, sector, row);  
1493
1494   //X-Value
1495   xyz[0]=Row2X(slicerow); 
1496
1497   //Y-Value
1498   Int_t npads= fNPads[slicerow];
1499
1500   if(fSectorLow[sector])
1501     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthLow;
1502   else
1503     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthUp;
1504
1505   //Z-Value (remember PULSA Delay)
1506   if(slice < 18)
1507     xyz[2]=fZLength-fZWidth*time+fZOffset;
1508   else
1509     xyz[2]=fZWidth*time-fZOffset-fZLength;
1510 }
1511
1512 void AliL3Transform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Int_t pad,Int_t time)
1513 {
1514   //Transformation from rawdata to local coordinate system
1515   
1516   Int_t slice,slicerow;
1517   Sector2Slice(slice, slicerow, sector, row);  
1518
1519   //X-Value
1520   xyz[0]=Row2X(slicerow); 
1521
1522   //Y-Value
1523   Int_t npads= fNPads[slicerow];
1524
1525   if(fSectorLow[sector])
1526     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthLow;
1527   else
1528     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthUp;
1529
1530   //Z-Value (remember PULSA Delay)
1531   if(slice < 18)
1532     xyz[2]=fZLength-fZWidth*time+fZOffset;
1533   else
1534     xyz[2]=fZWidth*time-fZOffset-fZLength;
1535 }
1536
1537 void AliL3Transform::RawHLT2Local(Float_t *xyz,Int_t slice,
1538                                Int_t slicerow,Float_t pad,Float_t time)
1539 {
1540   //Transformation from HLT rawdata to local coordinate system
1541   
1542   //X-Value
1543   xyz[0]=Row2X(slicerow); 
1544
1545   //Y-Value
1546   Int_t npads= fNPads[slicerow];
1547   if(slicerow<fNRowLow)
1548     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthLow;
1549   else
1550     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthUp;
1551
1552   //Z-Value
1553   if(slice < 18)
1554     xyz[2]=fZLength-fZWidth*time+fZOffset;
1555   else
1556     xyz[2]=fZWidth*time-fZOffset-fZLength;
1557 }
1558
1559 void AliL3Transform::RawHLT2Local(Float_t *xyz,Int_t slice,
1560                                Int_t slicerow,Int_t pad,Int_t time)
1561 {
1562   //Transformation from HLT rawdata to local coordinate system
1563   
1564   //X-Value
1565   xyz[0]=Row2X(slicerow); 
1566
1567   //Y-Value
1568   Int_t npads= fNPads[slicerow];
1569   if(slicerow<fNRowLow)
1570     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthLow;
1571   else
1572     xyz[1]=(pad-0.5*(npads-1))*fPadPitchWidthUp;
1573
1574   //Z-Value
1575   if(slice < 18)
1576     xyz[2]=fZLength-fZWidth*time+fZOffset;
1577   else
1578     xyz[2]=fZWidth*time-fZOffset-fZLength;
1579 }
1580
1581 void AliL3Transform::Local2Global(Float_t *xyz,Int_t sector,Int_t row)
1582 {
1583   //Transformation to global coordinate system
1584   Int_t slice,slicerow;
1585   Sector2Slice(slice, slicerow, sector, row);  
1586   Float_t r=Row2X(slicerow); //have to get x value first
1587                              
1588   xyz[0]=r*fCos[slice]-xyz[1]*fSin[slice];
1589   xyz[1]=r*fSin[slice]+xyz[1]*fCos[slice];
1590   xyz[2]=xyz[2];//global z=local z
1591 }
1592
1593 void AliL3Transform::LocHLT2Global(Float_t *xyz,Int_t slice,Int_t slicerow)
1594 {
1595   //Transformation from HLT to global coordinate system
1596   Float_t r=Row2X(slicerow); //have to get x value first
1597                              
1598   xyz[0]=r*fCos[slice]-xyz[1]*fSin[slice];
1599   xyz[1]=r*fSin[slice]+xyz[1]*fCos[slice];
1600   xyz[2]=xyz[2];//global z=local z
1601 }
1602
1603 void AliL3Transform::Global2Local(Float_t *xyz,Int_t sector)
1604 { //check code
1605   Int_t slice;
1606   //if(!isSlice)
1607     Sector2Slice(slice, sector);  
1608     //else
1609     //slice = sector;
1610
1611   Float_t x1 =  xyz[0]*fCos[slice] + xyz[1]*fSin[slice];
1612   Float_t y1 = -xyz[0]*fSin[slice] + xyz[1]*fCos[slice];
1613   xyz[0] = x1;
1614   xyz[1] = y1;
1615 }
1616
1617 void AliL3Transform::Global2LocHLT(Float_t *xyz,Int_t slice)
1618 {
1619   Float_t x1 =  xyz[0]*fCos[slice] + xyz[1]*fSin[slice];
1620   Float_t y1 = -xyz[0]*fSin[slice] + xyz[1]*fCos[slice];
1621   xyz[0] = x1;
1622   xyz[1] = y1;
1623 }
1624
1625 void AliL3Transform::Raw2Global(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1626 {
1627   //Transformation from raw to global coordinates
1628  
1629   Raw2Local(xyz,sector,row,pad,time);
1630   Local2Global(xyz,sector,row);
1631 }
1632
1633 void AliL3Transform::Raw2Global(Float_t *xyz,Int_t sector,Int_t row,Int_t pad,Int_t time)
1634 {
1635   //Transformation from raw to global coordinates
1636  
1637   Raw2Local(xyz,sector,row,pad,time);
1638   Local2Global(xyz,sector,row);
1639 }
1640
1641 void AliL3Transform::RawHLT2Global(Float_t *xyz,Int_t slice,
1642                                    Int_t slicerow,Float_t pad,Float_t time)
1643 {
1644   //Transformation from raw to global coordinates
1645  
1646   RawHLT2Local(xyz,slice,slicerow,pad,time);
1647   LocHLT2Global(xyz,slice,slicerow);
1648 }
1649
1650 void AliL3Transform::RawHLT2Global(Float_t *xyz,Int_t slice,
1651                                    Int_t slicerow,Int_t pad,Int_t time)
1652 {
1653   //Transformation from raw to global coordinates
1654  
1655   RawHLT2Local(xyz,slice,slicerow,pad,time);
1656   LocHLT2Global(xyz,slice,slicerow);
1657 }
1658
1659 void AliL3Transform::Local2Raw(Float_t *xyz,Int_t sector,Int_t row)
1660 {
1661   //Transformation from local coordinates to raw
1662
1663   Int_t slice,slicerow;
1664   Sector2Slice(slice, slicerow, sector, row);  
1665    
1666   xyz[0]=slicerow;
1667
1668   if(fSectorLow[sector])
1669     xyz[1]=xyz[1]/fPadPitchWidthLow+0.5*(fNPads[slicerow]-1);
1670   else
1671     xyz[1]=xyz[1]/fPadPitchWidthUp+0.5*(fNPads[slicerow]-1);
1672
1673   if(slice < 18)
1674     xyz[2]=(fZLength-xyz[2]+fZOffset)/fZWidth;
1675   else
1676     xyz[2]=(fZLength+xyz[2]+fZOffset)/fZWidth;
1677 }
1678
1679 void AliL3Transform::LocHLT2Raw(Float_t *xyz,Int_t slice,Int_t slicerow)
1680 {
1681   //Transformation from local coordinates to raw
1682
1683   xyz[0]=slicerow;
1684
1685   if(slicerow<fNRowLow)
1686     xyz[1]=xyz[1]/fPadPitchWidthLow+0.5*(fNPads[slicerow]-1);
1687   else
1688     xyz[1]=xyz[1]/fPadPitchWidthUp+0.5*(fNPads[slicerow]-1);
1689
1690   if(slice < 18)
1691     xyz[2]=(fZLength-xyz[2]+fZOffset)/fZWidth;
1692   else
1693     xyz[2]=(fZLength+xyz[2]+fZOffset)/fZWidth;
1694 }
1695
1696 void AliL3Transform::Global2Raw(Float_t *xyz,Int_t sector,Int_t row)
1697 {
1698   //Transformation from global coordinates to raw. 
1699
1700   Global2Local(xyz,sector);
1701   Local2Raw(xyz,sector,row);
1702 }
1703
1704 void AliL3Transform::Global2HLT(Float_t *xyz,Int_t slice,Int_t slicerow)
1705 {
1706   //Transformation from global coordinates to raw. 
1707
1708   Global2LocHLT(xyz,slice);
1709   LocHLT2Raw(xyz,slice,slicerow);
1710 }
1711
1712 void AliL3Transform::PrintCompileOptions()
1713 {
1714 #if defined(__GNUC__)
1715   cout << "Compiler (g++) version used: " << __GNUC__ << endl;
1716 #endif
1717
1718 #ifdef no_root
1719   cout << "STANDALONE version: -Dno_root was given." << endl;
1720 #else
1721   const Char_t *roottest="$ROOTSYS/bin/root -n -b -q  | grep Version | cut -b 17-25 | cut -d\" \" -f1";
1722 #ifdef use_aliroot
1723 #ifdef use_cvs
1724   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";
1725 #else
1726   const Char_t *aliroottest="Unknown";
1727 #endif
1728   cout << "ALIROOT version: -Duse_aliroot and -Duse_root was given." << endl;
1729   cout << "Root Version: " << ROOTVERSION << " found " << flush;
1730   gSystem->Exec(roottest);
1731
1732   cout << "AliRoot Version: " << ALIROOTVERSION << " found " << flush;
1733   gSystem->Exec(aliroottest);
1734 #else
1735   cout << "ROOT version: -Duse_root was given." << endl;
1736   cout << "Root Version: " << ROOTVERSION << " found " << flush;
1737   gSystem->Exec(roottest);
1738 #endif
1739 #endif
1740
1741 #ifdef do_mc
1742   cout << "Using Monte Carlo Info: -Ddo_mc was given." << endl;
1743 #else
1744   cout << "NOT using Monte Carlo Info: -Ddo_mc was not given." << endl;
1745 #endif
1746
1747 #ifdef ROWHOUGHPARAMS
1748   cout << "Using extended AliL3TrackSegmentData: -DROWHOUGHPARAMS was given." << endl;
1749 #else
1750   cout << "NOT using extended AliL3TrackSegmentData: -DROWHOUGHPARAMS was not given." << endl;
1751 #endif
1752
1753 #ifdef use_newio
1754   cout << "Using NEWIO version: -Duse_newio was given." << endl;
1755 #else
1756   cout << "NOT using NEWIO version: -Duse_newio was not given." << endl;
1757 #endif
1758
1759 #ifdef use_logging
1760   cout << "Using logging classes (MLUC): -Duse_logging was given." << endl;
1761 #else
1762   cout << "NOT using logging classes (MLUC): -Duse_logging not was given." << endl;
1763 #endif
1764
1765 }