New version of SPD raw-data reconstruction. The format now correponds to the actual...
[u/mrichter/AliRoot.git] / HLT / src / AliHLTTransform.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 "AliHLTStandardIncludes.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 "AliHLTLogging.h"
25 #include "AliHLTTransform.h"
26
27 #if defined(__GNUC__) && __GNUC__ >= 3
28 using namespace std;
29 #endif
30
31 /** \class AliHLTTransform 
32 <pre>
33 //_____________________________________________________________
34 // AliHLTTransform
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 = AliHLTTransform::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 //            AliHLTTransform::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 //            AliHLTTransform::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==kValiroot: ALIROOT-head compatible
70 //             fVersion==kVcosmics: Cosmics data run (2003) compatible
71 //             fVersion==kVdefault: means no config file has been loaded
72 //             fVersion==kVdeprecated: dont use old (before July 2003) style of transformer
73 //
74 </pre>
75 */
76
77 ClassImp(AliHLTTransform)
78
79 const Double_t AliHLTTransform::fgkAnodeWireSpacing = 0.25; //Taken from the TDR
80 const Double_t AliHLTTransform::fgkBFACT = 0.0029980;       //Conversion Factor
81 const Double_t AliHLTTransform::fgkPi  =   3.141592653589793;
82 const Double_t AliHLTTransform::fgk2Pi = 2*3.141592653589793;
83 const Double_t AliHLTTransform::fgkPi2 = 0.5*3.141592653589793;
84 const Double_t AliHLTTransform::fgkToDeg = 180/3.141592653589793;
85
86 //Defined by HLT and GSI
87 Int_t AliHLTTransform::fgNPatches = 6;
88 Int_t AliHLTTransform::fgRows[6][2] = {{0,29},{30,62},{63,90},{91,116},{117,139},{140,158}}; 
89 Int_t AliHLTTransform::fgNRows[6] = {30,33,28,26,23,19};
90
91 // The following definition is generated by MakeInitFile function
92 Double_t AliHLTTransform::fgBField = 0.2;
93 Double_t AliHLTTransform::fgSolenoidBField = 2;
94 Double_t AliHLTTransform::fgBFieldFactor = 1;
95 Int_t AliHLTTransform::fgVersion = kVdefault;
96 Int_t AliHLTTransform::fgNTimeBins = 446;
97 Int_t AliHLTTransform::fgNRowLow = 63;
98 Int_t AliHLTTransform::fgNRowUp = 96;
99 Int_t AliHLTTransform::fgNRowUp1 = 64;
100 Int_t AliHLTTransform::fgNRowUp2 = 32;
101 Int_t AliHLTTransform::fgNSectorLow = 36;
102 Int_t AliHLTTransform::fgNSectorUp = 36;
103 Int_t AliHLTTransform::fgNSector = 72;
104 Double_t AliHLTTransform::fgPadPitchWidthLow = 0.4;
105 Double_t AliHLTTransform::fgPadPitchWidthUp = 0.6;
106 Double_t AliHLTTransform::fgZWidth = 0.5660;
107 Double_t AliHLTTransform::fgZSigma = 0.2288;
108 Double_t AliHLTTransform::fgZLength = 250.0000;
109 Double_t AliHLTTransform::fgZOffset = 0.6864;
110 Double_t AliHLTTransform::fgDiffT = 0.0220;
111 Double_t AliHLTTransform::fgDiffL = 0.0220;
112 Double_t AliHLTTransform::fgOmegaTau = 0.1450;
113 Double_t AliHLTTransform::fgInnerPadLength = 0.75;
114 Double_t AliHLTTransform::fgOuter1PadLength = 1.00;
115 Double_t AliHLTTransform::fgOuter2PadLength = 1.50;
116 Double_t AliHLTTransform::fgInnerPRFSigma = 0.203811;
117 Double_t AliHLTTransform::fgOuter1PRFSigma = 0.299325;
118 Double_t AliHLTTransform::fgOuter2PRFSigma = 0.299323;
119 Double_t AliHLTTransform::fgTimeSigma = 0.228809;
120 Int_t AliHLTTransform::fgADCSat = 1024;
121 Int_t AliHLTTransform::fgZeroSup = 0;
122 Int_t AliHLTTransform::fgNSlice = 36;
123 Int_t AliHLTTransform::fgNRow = 159;
124 Double_t AliHLTTransform::fgNRotShift = 0.5;
125 Int_t AliHLTTransform::fgSlice2Sector[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 AliHLTTransform::fgSector2Slice[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 AliHLTTransform::fgSectorLow[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 AliHLTTransform::fgX[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 AliHLTTransform::fgNPads[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 AliHLTTransform::fgCos[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 AliHLTTransform::fgSin[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 #ifdef use_aliroot
710 Bool_t AliHLTTransform::Init(AliRunLoader *runLoader)
711
712   //init with runloader
713   if(!runLoader) {
714     LOG(AliHLTLog::kFatal,"AliHLTTransform::Init","RunLoader")
715       <<" Missing RunLoader! 0x0"<<ENDLOG;
716     return kFALSE;
717   }
718  
719   if(fgVersion != kVdefault)
720     LOG(AliHLTLog::kWarning,"AliHLTTransform::Init","Init values")
721       <<AliHLTLog::kDec<<"You are initializing the parameters more than once; check your code please! "<<fgVersion<<ENDLOG;
722
723   TDirectory* savedir1 = gDirectory;
724   runLoader->CdGAFile();
725   AliTPCParamSR *param=(AliTPCParamSR*)gDirectory->Get(GetParamName());
726   savedir1->cd();
727   if(!param)
728     {
729       LOG(AliHLTLog::kFatal,"AliHLTTransform::Init","File")
730         <<"No TPC parameters found!"<<ENDLOG;
731       return kFALSE;
732     }
733
734   AliTPCPRF2D    * prfinner    = new AliTPCPRF2D;
735   AliTPCPRF2D    * prfouter1   = new AliTPCPRF2D;
736   AliTPCPRF2D    * prfouter2   = new AliTPCPRF2D;  
737   AliTPCRF1D     * rf    = new AliTPCRF1D(kTRUE);
738   rf->SetGauss(param->GetZSigma(),param->GetZWidth(),1.);
739   rf->SetOffset(3*param->GetZSigma());
740   rf->Update();
741   
742   TDirectory *savedir2=gDirectory;
743   TFile *prf_file = TFile::Open("$ALICE_ROOT/TPC/AliTPCprf2d.root");
744   if (!prf_file->IsOpen()) 
745     { 
746       LOG(AliHLTLog::kError,"AliHLTTransform::Init","File")
747         <<"Can't open $ALICE_ROOT/TPC/AliTPCprf2d.root !"<<ENDLOG;
748       return kFALSE;
749     }
750   prfinner ->Read("prf_07504_Gati_056068_d02");
751   prfouter1->Read("prf_10006_Gati_047051_d03");
752   prfouter2->Read("prf_15006_Gati_047051_d03");  
753   prf_file->Close();
754   savedir2->cd();
755   
756   param->SetInnerPRF(prfinner);
757   param->SetOuter1PRF(prfouter1); 
758   param->SetOuter2PRF(prfouter2);
759   param->SetTimeRF(rf);
760   
761   fgNTimeBins = param->GetMaxTBin()+1;
762   fgNRowLow = param->GetNRowLow();
763   fgNRowUp  = param->GetNRowUp();
764   fgNRowUp1 = param->GetNRowUp1();
765   fgNRowUp2 = param->GetNRowUp2();
766   fgNRow= fgNRowLow + fgNRowUp;
767   if(fgNRow!=159){
768     LOG(AliHLTLog::kError,"AliHLTTransform::Init","fNRow")
769       <<"Number of rows have changed in ALIROOT"<<ENDLOG;
770     return kFALSE;
771   }
772   
773   fgNSectorLow = param->GetNInnerSector();
774   fgNSectorUp = param->GetNOuterSector();
775   fgNSector = fgNSectorLow + fgNSectorUp;
776
777   //test whether they were changes to the rotation shift
778   fgNRotShift=0;
779   Float_t irotshift = param->GetInnerAngleShift(); //shift angle
780   Float_t orotshift = param->GetOuterAngleShift(); //shift angle
781   const Float_t kDegtoRad = 0.01745329251994;
782   Int_t shift1=TMath::Nint(irotshift/kDegtoRad);
783   Int_t shift2=TMath::Nint(orotshift/kDegtoRad+0.1);
784   if((shift1!=shift2) || (shift1!=10)){
785     LOG(AliHLTLog::kError,"AliHLTTransform::Init","Rotshiftangle")
786       <<"Rotation shift angle has changed in ALIROOT"<<ENDLOG;
787     return kFALSE;
788   } else {
789     fgNRotShift=0.5; //our version of the shift angle
790   }
791   
792   fgVersion=kValiroot;
793   SetBFieldFactor((Double_t)runLoader->GetAliRun()->Field()->Factor());
794   SetSolenoidBField(-
795                     (Double_t)runLoader->GetAliRun()->Field()->SolenoidField()/
796                     (Double_t)runLoader->GetAliRun()->Field()->Factor()
797                     );
798   fgPadPitchWidthLow=param->GetInnerPadPitchWidth();
799   fgPadPitchWidthUp=param->GetOuterPadPitchWidth();
800   fgZWidth=param->GetZWidth();
801   fgZSigma=param->GetZSigma();
802   fgZLength=param->GetZLength();
803   fgZOffset=param->GetZOffset();
804   fgDiffT=param->GetDiffT();
805   fgDiffL=param->GetDiffL();
806   fgOmegaTau=param->GetOmegaTau();
807   fgInnerPadLength=param->GetInnerPadLength();
808   fgOuter1PadLength=param->GetOuter1PadLength();
809   fgOuter2PadLength=param->GetOuter2PadLength();
810   fgInnerPRFSigma=param->GetInnerPRF()->GetSigmaX();
811   fgOuter1PRFSigma=param->GetOuter1PRF()->GetSigmaX();
812   fgOuter2PRFSigma=param->GetOuter2PRF()->GetSigmaX();
813   fgTimeSigma=param->GetTimeRF()->GetSigma();
814   fgADCSat=param->GetADCSat();
815   fgZeroSup=param->GetZeroSup();
816   fgNSlice=fgNSectorLow;
817     
818   //now do the arrays
819   for(Int_t i=0;i<fgNRow;i++){
820     Int_t sec,row;
821     if( i < fgNRowLow){sec =0;row =i;}
822     else{sec = fgNSectorLow;row =i-fgNRowLow;}
823     fgX[i]=param->GetPadRowRadii(sec,row);
824   } 
825   for(Int_t i=0;i<fgNRow;i++){
826     Int_t sec,row;
827     if( i < fgNRowLow){sec =0;row =i;}
828     else{sec = fgNSectorLow;row =i-fgNRowLow;}
829     fgNPads[i]=param->GetNPads(sec,row);
830   }
831   for(Int_t i=0;i<fgNSector;i++){
832     if(i<fgNSectorLow) fgSectorLow[i]=1;
833     else fgSectorLow[i]=0;
834   }
835
836   return kTRUE;
837
838   /* not needed 
839   TTimeStamp time;
840   Char_t tmpfile[1024];
841   sprintf(tmpfile,"./l3transform.config-%d",(Int_t)time.GetSec());
842
843   return SaveInitFile(tmpfile);
844   */
845 }
846 #endif
847
848 Bool_t AliHLTTransform::Init(Char_t* path,Bool_t UseAliTPCParam)
849 {
850   //Overwrite the parameters with values stored in file "l3transform.config" in path.
851   //If file does not exist, old default values will be used.
852   //If flag UseAliTPCParam is set, the parameters will be read from the the rootfile
853   //which then has to be called path/digitfile.root
854   
855   if(fgVersion != kVdefault)
856     LOG(AliHLTLog::kWarning,"AliHLTTransform::Init","Init values")
857       <<AliHLTLog::kDec<<"You are initializing the parameters more than once; check your code please! "<<fgVersion<<ENDLOG;
858   
859   if(UseAliTPCParam) //use rootfile to generate temporary init file
860     return ReadInit(path);
861
862   //create filename
863   Char_t pathname[1024];
864   strcpy(pathname,path);
865
866   //test whether provided path is the file itself
867   Int_t isdir = 0;
868   DIR *testdir=opendir(pathname);
869   if(testdir){
870     isdir=1;
871     closedir(testdir);
872   }
873
874   if(isdir) strcat(pathname,"/l3transform.config");
875
876   return ReadInitFile(pathname);
877 }
878
879 Bool_t AliHLTTransform::ReadInitFile(Char_t* pathname)
880 {
881   //read transformer settings from pathname
882   FILE *fptr=fopen(pathname,"r");
883   if(!fptr){
884     LOG(AliHLTLog::kWarning,"AliHLTTransform::ReadInitFile","File Open")
885       <<"Pointer to Config File \""<<pathname<<"\" 0x0!"<<ENDLOG;
886     return kFALSE;
887   }
888
889   Char_t d1[250], d2[100], d3[100];
890   Int_t dummy=0;
891   Double_t ddummy=0.0;
892
893   while(!feof(fptr)) {
894     fscanf(fptr,"%s",d1);
895     if(strcmp(d1,"fVersion")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgVersion=dummy;}
896     else if(strcmp(d1,"fBFieldFactor")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgBFieldFactor=(Double_t)ddummy;}
897     else if(strcmp(d1,"fSolenoidBField")==0)
898       {
899         fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);
900         fgSolenoidBField=(Double_t)ddummy;
901       }
902     else if(strcmp(d1,"fNTimeBins")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNTimeBins=(Int_t)dummy;}
903     else if(strcmp(d1,"fNRowLow")==0)
904       {
905         fscanf(fptr,"%s %d %s",d2,&dummy,d3);
906         fgNRowLow=(Int_t)dummy;
907         if(fgNRowLow != 63)
908           LOG(AliHLTLog::kError,"AliHLTTransform::ReadInitFile","Overflow")
909             <<"Number of inner PadRows should be 63! Check and fgrep the code for 63 to see the consequences of this major change!"<<ENDLOG;
910       }
911     else if(strcmp(d1,"fNRowUp")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNRowUp=(Int_t)dummy;}
912     else if(strcmp(d1,"fNRowUp1")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNRowUp1=(Int_t)dummy;}
913     else if(strcmp(d1,"fNRowUp2")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNRowUp2=(Int_t)dummy;}
914     else if(strcmp(d1,"fNSectorLow")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNSectorLow=(Int_t)dummy;}
915     else if(strcmp(d1,"fNSectorUp")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNSectorUp=(Int_t)dummy;}
916     else if(strcmp(d1,"fNSector")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNSector=(Int_t)dummy;}
917     else if(strcmp(d1,"fPadPitchWidthLow")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgPadPitchWidthLow=(Double_t)ddummy;}
918     else if(strcmp(d1,"fPadPitchWidthUp")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgPadPitchWidthUp=(Double_t)ddummy;}
919     else if(strcmp(d1,"fZWidth")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgZWidth=(Double_t)ddummy;}
920     else if(strcmp(d1,"fZSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgZSigma=(Double_t)ddummy;}
921     else if(strcmp(d1,"fZLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgZLength=(Double_t)ddummy;}
922     else if(strcmp(d1,"fZOffset")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgZOffset=(Double_t)ddummy;}
923     else if(strcmp(d1,"fNSlice")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNSlice=(Int_t)dummy;}
924     else if(strcmp(d1,"fDiffT")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgDiffT=(Double_t)ddummy;}
925     else if(strcmp(d1,"fDiffL")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgDiffL=(Double_t)ddummy;}
926     else if(strcmp(d1,"fOmegaTau")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgOmegaTau=(Double_t)ddummy;}
927     else if(strcmp(d1,"fInnerPadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgInnerPadLength=(Double_t)ddummy;}
928     else if(strcmp(d1,"fOuter1PadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgOuter1PadLength=(Double_t)ddummy;}
929     else if(strcmp(d1,"fOuter2PadLength")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgOuter2PadLength=(Double_t)ddummy;}
930     else if(strcmp(d1,"fInnerPRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgInnerPRFSigma=(Double_t)ddummy;}
931     else if(strcmp(d1,"fOuter1PRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgOuter1PRFSigma=(Double_t)ddummy;}
932     else if(strcmp(d1,"fOuter2PRFSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgOuter2PRFSigma=(Double_t)ddummy;}
933     else if(strcmp(d1,"fTimeSigma")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgTimeSigma=(Double_t)ddummy;}
934     else if(strcmp(d1,"fADCSat")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgADCSat=(Int_t)dummy;}
935     else if(strcmp(d1,"fZeroSup")==0){fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgZeroSup=(Int_t)dummy;}
936     else if(strcmp(d1,"fNRow")==0){
937       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNRow=(Int_t)dummy;
938       if(fgNRow!=159){
939         LOG(AliHLTLog::kError,"AliHLTTransform::ReadInitFile","Overflow")<<"Number of PadRows should be 159! Check and fgrep the code for 159 to see the consequences of this major change!"<<ENDLOG;
940       }
941     }
942     else if(strcmp(d1,"fNRotShift")==0){fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgNRotShift=(Double_t)ddummy;}
943     else if(strcmp(d1,"fX[0]")==0){
944       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgX[0]=(Double_t)ddummy;
945       for(Int_t i=1;i<fgNRow;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fgX[i]=(Double_t)ddummy;}
946     }
947     else if(strcmp(d1,"fNPads[0]")==0){
948       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNPads[0]=(Int_t)dummy;
949       for(Int_t i=1;i<fgNRow;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fgNPads[i]=(Int_t)dummy;}
950     }
951     else if(strcmp(d1,"fNRows[0]")==0){
952       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgNRows[0]=(Int_t)dummy;
953       for(Int_t i=1;i<fgNPatches;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fgNRows[i]=(Int_t)dummy;}
954     }
955     else if(strcmp(d1,"fRows[0][0]")==0){
956       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgRows[0][0]=(Int_t)dummy;
957       fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fgRows[0][1]=(Int_t)dummy;
958       for(Int_t i=1;i<fgNPatches;i++){
959         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fgRows[i][0]=(Int_t)dummy;
960         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fgRows[i][1]=(Int_t)dummy;
961       }
962     }
963     else if(strcmp(d1,"fSlice2Sector[0][0]")==0){
964       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgSlice2Sector[0][0]=(Int_t)dummy;
965       fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fgSlice2Sector[0][1]=(Int_t)dummy;
966       for(Int_t i=1;i<fgNSlice;i++){
967         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fgSlice2Sector[i][0]=(Int_t)dummy;
968         fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fgSlice2Sector[i][1]=(Int_t)dummy;
969       }
970     }
971     else if(strcmp(d1,"fSector2Slice[0]")==0){
972       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgSector2Slice[0]=(Int_t)dummy;
973       for(Int_t i=1;i<fgNSector;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fgSector2Slice[i]=(Int_t)dummy;}
974     }
975     else if(strcmp(d1,"fSectorLow[0]")==0){
976       fscanf(fptr,"%s %d %s",d2,&dummy,d3);fgSectorLow[0]=(Int_t)dummy;
977       for(Int_t i=1;i<fgNSector;i++){fscanf(fptr,"%s %s %d %s",d1,d2,&dummy,d3);fgSectorLow[i]=(Int_t)dummy;}
978     }
979     else if(strcmp(d1,"fCos[0]")==0){
980       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgCos[0]=(Double_t)ddummy;
981       for(Int_t i=1;i<fgNSlice;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fgCos[i]=(Double_t)ddummy;}
982     }
983     else if(strcmp(d1,"fSin[0]")==0){
984       fscanf(fptr,"%s %lf %s",d2,&ddummy,d3);fgSin[0]=(Double_t)ddummy;
985       for(Int_t i=1;i<fgNSlice;i++){fscanf(fptr,"%s %s %lf %s",d1,d2,&ddummy,d3);fgSin[i]=(Double_t)ddummy;}
986     }
987   }
988   fclose(fptr);
989
990   //The first multiplier gives the scale factor used to modify the field map 
991   //defined by the second multiplier.
992   fgBField=fgBFieldFactor*fgSolenoidBField*0.1;
993
994   //Test if new config file has been used.
995   if(fgVersion==kVdeprecated){
996     LOG(AliHLTLog::kError,"AliHLTTransform::ReadInitFile","Version")
997       <<"Version is deprecated, you have to create a new config file."<<ENDLOG;
998     return kFALSE;
999   }
1000
1001   LOG(AliHLTLog::kInformational,"AliHLTTransform::ReadInitFile","Config")
1002     <<"Successfully loaded values from config file \""<<pathname<<"\""<<ENDLOG;
1003
1004   return kTRUE;
1005 }
1006
1007 Bool_t AliHLTTransform::ReadInit(Char_t *path)
1008 {
1009   //Read all the parameters from a aliroot file, and store it in a temporary 
1010   //file which is read by Init. Use this if you want to read the parameters from
1011   //the rootfile "every" time.
1012   
1013 #ifndef use_aliroot
1014   LOG(AliHLTLog::kError,"AliHLTTransform::ReadInit","Version")
1015     <<"You have to compile with use_aliroot flag in order to read from AliROOT file"<<ENDLOG;
1016   return kFALSE;
1017 #else
1018   Char_t filename[1024];
1019   //first test whether provided path is the rootfile itself
1020   Int_t saveErrIgLevel=gErrorIgnoreLevel;
1021   gErrorIgnoreLevel=kFatal; //dont report errors
1022   TFile *rootfile = TFile::Open(path);
1023   if(!rootfile || rootfile->IsZombie()) 
1024     { //ok assume its path to alirunfile file
1025       sprintf(filename,"%s/alirunfile.root",path); //create rootfile name
1026     } else { //path contains itself the rootfile name
1027       rootfile->Close();
1028       sprintf(filename,"%s",path); 
1029     }
1030   gErrorIgnoreLevel=saveErrIgLevel;
1031
1032   //finally make dummy init file /tmp/$USER/l3transform.config-`date`
1033   Char_t tmppath[1024];
1034   sprintf(tmppath,"/tmp/%s",gSystem->Getenv("USER"));
1035   gSystem->mkdir(tmppath);
1036   TTimeStamp time;
1037   Char_t tmpfile[1024];
1038   sprintf(tmpfile,"%s/l3transform.config-%d",tmppath,(Int_t)time.GetSec());
1039   return MakeInitFile(filename,tmpfile);
1040 #endif  
1041 }
1042
1043 Bool_t AliHLTTransform::MakeInitFile(Char_t *rootfilename,Char_t *filename)
1044 {
1045   //Get the parameters from rootfile, and store it on the file "l3transform.config"
1046   //which is being read by Init. fVersion will be kV_aliroot!
1047   
1048 #ifndef use_aliroot
1049   LOG(AliHLTLog::kError,"AliHLTTransform::MakeInitFile","Version")
1050     <<"You have to compile with use_aliroot flag in order to use this function"<<ENDLOG;
1051   return kFALSE;
1052 #else
1053   TFile *rootfile = TFile::Open(rootfilename);
1054   if(!rootfile)
1055     {
1056       LOG(AliHLTLog::kError,"AliHLTTransform::MakeInitFile","File")
1057         <<"Could not open file: "<<rootfilename<<ENDLOG;
1058       return kFALSE;
1059     }
1060   AliRun *gAlice = (AliRun*)rootfile->Get("gAlice");
1061   if(!gAlice)
1062     {
1063       LOG(AliHLTLog::kError,"AliHLTTransform::MakeInitFile","File")
1064         <<"No gAlice in file: "<<rootfilename<<ENDLOG;
1065       return kFALSE;
1066     }  
1067   AliTPCParamSR *param=(AliTPCParamSR*)rootfile->Get(GetParamName());
1068   if(!param)
1069     {
1070       LOG(AliHLTLog::kWarning,"AliHLTTransform::MakeInitFile","File")
1071         <<"No TPC parameters found in \""<<rootfilename
1072         <<"\", creating standard parameters "
1073         <<"which might not be what you want!"<<ENDLOG;
1074       param=new AliTPCParamSR;
1075     }
1076
1077   AliTPCPRF2D    * prfinner    = new AliTPCPRF2D;
1078   AliTPCPRF2D    * prfouter1   = new AliTPCPRF2D;
1079   AliTPCPRF2D    * prfouter2   = new AliTPCPRF2D;  
1080   AliTPCRF1D     * rf    = new AliTPCRF1D(kTRUE);
1081   rf->SetGauss(param->GetZSigma(),param->GetZWidth(),1.);
1082   rf->SetOffset(3*param->GetZSigma());
1083   rf->Update();
1084   
1085   TDirectory *savedir=gDirectory;
1086   TFile *prf_file = TFile::Open("$ALICE_ROOT/TPC/AliTPCprf2d.root");
1087   if (!prf_file->IsOpen()) 
1088     { 
1089       LOG(AliHLTLog::kError,"AliHLTTransform::MakeInitFile","File")
1090         <<"Can't open $ALICE_ROOT/TPC/AliTPCprf2d.root !"<<ENDLOG;
1091       return kFALSE;
1092     }
1093   prfinner ->Read("prf_07504_Gati_056068_d02");
1094   prfouter1->Read("prf_10006_Gati_047051_d03");
1095   prfouter2->Read("prf_15006_Gati_047051_d03");  
1096   prf_file->Close();
1097   savedir->cd();
1098   
1099   param->SetInnerPRF(prfinner);
1100   param->SetOuter1PRF(prfouter1); 
1101   param->SetOuter2PRF(prfouter2);
1102   param->SetTimeRF(rf);
1103   
1104   fgNTimeBins = param->GetMaxTBin()+1;
1105   fgNRowLow = param->GetNRowLow();
1106   fgNRowUp  = param->GetNRowUp();
1107   fgNRowUp1 = param->GetNRowUp1();
1108   fgNRowUp2 = param->GetNRowUp2();
1109   fgNRow= fgNRowLow + fgNRowUp;
1110   if(fgNRow!=159){
1111     LOG(AliHLTLog::kError,"AliHLTTransform::MakeInitFile","fNRow")
1112       <<"Number of rows have changed in ALIROOT"<<ENDLOG;
1113     return kFALSE;
1114   }
1115   
1116   fgNSectorLow = param->GetNInnerSector();
1117   fgNSectorUp = param->GetNOuterSector();
1118   fgNSector = fgNSectorLow + fgNSectorUp;
1119
1120   //test whether they were changes to the rotation shift
1121   fgNRotShift=0;
1122   Float_t irotshift = param->GetInnerAngleShift(); //shift angle
1123   Float_t orotshift = param->GetOuterAngleShift(); //shift angle
1124   const Float_t kDegtoRad = 0.01745329251994;
1125   Int_t shift1=TMath::Nint(irotshift/kDegtoRad);
1126   Int_t shift2=TMath::Nint(orotshift/kDegtoRad+0.1);
1127   if((shift1!=shift2) || (shift1!=10)){
1128     LOG(AliHLTLog::kError,"AliHLTTransform::MakeInitFile","Rotshiftangle")
1129       <<"Rotation shift angle has changed in ALIROOT"<<ENDLOG;
1130     return kFALSE;
1131   } else {
1132     fgNRotShift=0.5; //our version of the shift angle
1133   }
1134   
1135   fgVersion=kValiroot;
1136   SetBFieldFactor((Double_t)gAlice->Field()->Factor());
1137   SetSolenoidBField(-
1138                     (Double_t)gAlice->Field()->SolenoidField()/
1139                     (Double_t)gAlice->Field()->Factor()
1140                     );
1141   fgPadPitchWidthLow=param->GetInnerPadPitchWidth();
1142   fgPadPitchWidthUp=param->GetOuterPadPitchWidth();
1143   fgZWidth=param->GetZWidth();
1144   fgZSigma=param->GetZSigma();
1145   fgZLength=param->GetZLength();
1146   fgZOffset=param->GetZOffset();
1147   fgDiffT=param->GetDiffT();
1148   fgDiffL=param->GetDiffL();
1149   fgOmegaTau=param->GetOmegaTau();
1150   fgInnerPadLength=param->GetInnerPadLength();
1151   fgOuter1PadLength=param->GetOuter1PadLength();
1152   fgOuter2PadLength=param->GetOuter2PadLength();
1153   fgInnerPRFSigma=param->GetInnerPRF()->GetSigmaX();
1154   fgOuter1PRFSigma=param->GetOuter1PRF()->GetSigmaX();
1155   fgOuter2PRFSigma=param->GetOuter2PRF()->GetSigmaX();
1156   fgTimeSigma=param->GetTimeRF()->GetSigma();
1157   fgADCSat=param->GetADCSat();
1158   fgZeroSup=param->GetZeroSup();
1159   fgNSlice=fgNSectorLow;
1160     
1161   //now do the arrays
1162   for(Int_t i=0;i<fgNRow;i++){
1163     Int_t sec,row;
1164     if( i < fgNRowLow){sec =0;row =i;}
1165     else{sec = fgNSectorLow;row =i-fgNRowLow;}
1166     fgX[i]=param->GetPadRowRadii(sec,row);
1167   } 
1168   for(Int_t i=0;i<fgNRow;i++){
1169     Int_t sec,row;
1170     if( i < fgNRowLow){sec =0;row =i;}
1171     else{sec = fgNSectorLow;row =i-fgNRowLow;}
1172     fgNPads[i]=param->GetNPads(sec,row);
1173   }
1174   for(Int_t i=0;i<fgNSector;i++){
1175     if(i<fgNSectorLow) fgSectorLow[i]=1;
1176     else fgSectorLow[i]=0;
1177   }
1178
1179   delete gAlice;
1180   rootfile->Close();
1181   delete rootfile;
1182
1183   return SaveInitFile(filename);
1184 #endif
1185 }
1186
1187 Bool_t AliHLTTransform::SaveInitFile(Char_t *filenamepath)
1188 {
1189   //store the parameters in the file "filenamepath"
1190   
1191   FILE *f = fopen(filenamepath,"w");
1192   if(!f){
1193     LOG(AliHLTLog::kError,"AliHLTTransform::SaveInitFile","File")
1194         <<"Could not open file: "<<filenamepath<<ENDLOG;
1195     return kFALSE;
1196   }
1197
1198   fprintf(f,"void AliHLTTransform::Init(){\n");
1199   fprintf(f,"  fVersion = %d;\n", fgVersion); 
1200   fprintf(f,"  fBFieldFactor = %.3f;\n",fgBFieldFactor);
1201   fprintf(f,"  fSolenoidBField = %.3f;\n",fgSolenoidBField);
1202   fprintf(f,"  fNTimeBins = %d;\n",fgNTimeBins);
1203   fprintf(f,"  fNRowLow = %d;\n",fgNRowLow);
1204   fprintf(f,"  fNRowUp = %d;\n",fgNRowUp);
1205   fprintf(f,"  fNRowUp1 = %d;\n",fgNRowUp1);
1206   fprintf(f,"  fNRowUp2 = %d;\n",fgNRowUp2);
1207   fprintf(f,"  fNSectorLow = %d;\n",fgNSectorLow);
1208   fprintf(f,"  fNSectorUp = %d;\n",fgNSectorUp);
1209   fprintf(f,"  fNSector = %d;\n",fgNSector);
1210   fprintf(f,"  fPadPitchWidthLow = %.3f;\n",fgPadPitchWidthLow);
1211   fprintf(f,"  fPadPitchWidthUp = %.3f;\n",fgPadPitchWidthUp);
1212   fprintf(f,"  fZWidth = %.4f;\n",fgZWidth);
1213   fprintf(f,"  fZSigma = %.4f;\n",fgZSigma);
1214   fprintf(f,"  fZLength = %.4f;\n",fgZLength);
1215   fprintf(f,"  fZOffset = %.4f;\n",fgZOffset);
1216   fprintf(f,"  fDiffT = %.4f;\n",fgDiffT);
1217   fprintf(f,"  fDiffL = %.4f;\n",fgDiffL);
1218   fprintf(f,"  fOmegaTau = %.4f;\n",fgOmegaTau);
1219   fprintf(f,"  fInnerPadLength = %.3f;\n",fgInnerPadLength);
1220   fprintf(f,"  fOuter1PadLength = %.3f;\n",fgOuter1PadLength);
1221   fprintf(f,"  fOuter2PadLength = %.3f;\n",fgOuter2PadLength);
1222   fprintf(f,"  fInnerPRFSigma = %.6f;\n",fgInnerPRFSigma);
1223   fprintf(f,"  fOuter1PRFSigma = %.6f;\n",fgOuter1PRFSigma);
1224   fprintf(f,"  fOuter2PRFSigma = %.6f;\n",fgOuter2PRFSigma);
1225   fprintf(f,"  fTimeSigma = %.6f;\n",fgTimeSigma);
1226   fprintf(f,"  fADCSat = %d;\n",fgADCSat);
1227   fprintf(f,"  fZeroSup = %d;\n",fgZeroSup);
1228   fprintf(f,"  fNSlice = %d;\n",fgNSlice);
1229   fprintf(f,"  fNRow = %d;\n",fgNRow);
1230   fprintf(f,"  fNRotShift = %.2f;\n",fgNRotShift);
1231   //now do the arrays
1232   for(Int_t i=0;i<fgNRow;i++){
1233     fprintf(f,"  fX[%d] = %3.2f;\n",i,fgX[i]);
1234   } 
1235   for(Int_t i=0;i<fgNRow;i++){
1236     fprintf(f,"  fNPads[%d] = %d;\n",i,fgNPads[i]);
1237   }
1238
1239   //Slice/Sector dont belong to aliroot, but we want to be flexible
1240   for(Int_t i=0;i<fgNSlice;i++){
1241     fprintf(f,"  fSlice2Sector[%d][0] = %d;\n",i,fgSlice2Sector[i][0]);
1242     fprintf(f,"  fSlice2Sector[%d][1] = %d;\n",i,fgSlice2Sector[i][1]);
1243   }  
1244   for(Int_t i=0;i<fgNSector;i++){
1245     fprintf(f,"  fSector2Slice[%d] = %d;\n",i,fgSector2Slice[i]);
1246   }  
1247   for(Int_t i=0;i<fgNSector;i++){
1248     fprintf(f,"  fSectorLow[%d] = %d;\n",i,fgSectorLow[i]);
1249   }  
1250
1251   //Patches also dont really belong to the aliroot settings (but nevermind)
1252   for(Int_t i=0;i<fgNPatches;i++){
1253     fprintf(f,"  fNRows[%d] = %d;\n",i,fgNRows[i]);
1254   }  
1255   for(Int_t i=0;i<fgNPatches;i++){
1256     fprintf(f,"  fRows[%d][0] = %d;\n",i,fgRows[i][0]);
1257     fprintf(f,"  fRows[%d][1] = %d;\n",i,fgRows[i][1]);
1258   }  
1259
1260   //Rotation shift is an addon, too
1261   for(Int_t i=0;i<fgNSlice;i++){
1262     Float_t cs = cos( (2*fgkPi/18) * (i+fgNRotShift) );
1263     fprintf(f,"  fCos[%d] = %.10f;\n",i,cs);
1264   }
1265   for(Int_t i=0;i<fgNSlice;i++){
1266     Float_t sn = sin( (2*fgkPi/18) * (i+fgNRotShift) );
1267     fprintf(f,"  fSin[%d] = %.10f;\n",i,sn);
1268   }
1269
1270   fprintf(f,"}\n");
1271   fclose(f);
1272
1273   LOG(AliHLTLog::kInformational,"AliHLTTransform::SaveInitFile","File created")
1274     <<"Init file \""<<filenamepath<<"\" created"<<ENDLOG;
1275
1276   return kTRUE;
1277 }
1278
1279 Int_t AliHLTTransform::GetNPads(Int_t row)
1280 {
1281   //get number of pads per row
1282   if(row < 0 || row >= fgNRow)
1283     {
1284       LOG(AliHLTLog::kError,"AliHLTTransform::GetNPads","Row")
1285         <<AliHLTLog::kDec<<"Wrong row "<<row<<ENDLOG;
1286       return 0;
1287     }
1288
1289   return fgNPads[row];
1290 }
1291
1292 Int_t AliHLTTransform::GetFirstRow(Int_t patch)
1293 {
1294   //get first row per patch
1295
1296   if(patch==-1)
1297     return 0;
1298   else if(patch < -1 || patch >= 6)
1299     {
1300       LOG(AliHLTLog::kError,"AliHLTTransform::GetFirstRow","Patch")
1301         <<AliHLTLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
1302       return 0;
1303     }
1304   else
1305     return fgRows[patch][0];
1306 }
1307
1308 Int_t AliHLTTransform::GetLastRow(Int_t patch)
1309 {
1310   //get last row per patch
1311   if(patch==-1)
1312     return fgRows[5][1];
1313   else if(patch < -1 || patch >= 6)
1314     {
1315       LOG(AliHLTLog::kError,"AliHLTTransform::GetLastRow","Patch")
1316         <<AliHLTLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
1317       return 0;
1318     }
1319   else
1320     return fgRows[patch][1];
1321 }
1322
1323 Int_t AliHLTTransform::GetFirstRowOnDDL(Int_t patch)
1324 {
1325   //get first row per patch
1326
1327   if(patch==-1)
1328     return 0;
1329   else if(patch < -1 || patch >= 6)
1330     {
1331       LOG(AliHLTLog::kError,"AliHLTTransform::GetFirstRow","Patch")
1332         <<AliHLTLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
1333       return 0;
1334     }
1335   else
1336     {
1337       if(patch==1) return fgRows[patch][0]+1;
1338       return fgRows[patch][0];
1339     }
1340 }
1341
1342 Int_t AliHLTTransform::GetLastRowOnDDL(Int_t patch)
1343 {
1344   //get last row per patch
1345   if(patch==-1)
1346     return fgRows[5][1];
1347   else if(patch < -1 || patch >= 6)
1348     {
1349       LOG(AliHLTLog::kError,"AliHLTTransform::GetLastRow","Patch")
1350         <<AliHLTLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
1351       return 0;
1352     }
1353   else
1354     {
1355       if(patch==2 || patch==4) return fgRows[patch][1]-1;
1356       return fgRows[patch][1];
1357     }
1358 }
1359
1360 Int_t AliHLTTransform::GetNRows(Int_t patch)
1361 {
1362   //get number of rows per patch
1363   if(patch==-1)
1364     return fgNRow;
1365   else if(patch < -1 || patch >= 6)
1366     {
1367       LOG(AliHLTLog::kError,"AliHLTTransform::GetNRows","Patch")
1368         <<AliHLTLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
1369       return 0;
1370     }
1371   else
1372     return fgNRows[patch];
1373 }
1374
1375 Int_t AliHLTTransform::GetPadRow(Float_t xvalue)
1376 {
1377   //Find the padrow number corresponding to cartesian _local_ x value
1378   if(xvalue < 0 || xvalue > 250)
1379     {
1380       LOG(AliHLTLog::kError,"AliHLTTransform::GetPadRow","X-value")
1381         <<AliHLTLog::kDec<<"Suspicious x-value, make sure it is in local coordinate! "
1382         <<xvalue<<ENDLOG;
1383       return -1;
1384     }
1385   
1386   Int_t x = (Int_t)rint(xvalue*10);
1387   if(x < (Int_t)rint(fgX[1]*10))
1388     return 0;
1389   else if(x > (Int_t)rint(fgX[fgNRow-2]*10))
1390     return fgNRow-1;
1391   else
1392     {
1393       Int_t padrow=1; //Of course, a more clever algorithm could help here
1394       while(padrow < fgNRow-2)
1395         {
1396           if(x > (Int_t)rint(fgX[padrow-1]*10) && x < (Int_t)rint(fgX[padrow+1]*10))
1397             break;
1398           padrow++;
1399         }
1400       return padrow;
1401     }
1402 }
1403
1404 Int_t AliHLTTransform::GetPatch(Int_t padrow)
1405 {
1406   //get patch for padrow
1407   if(padrow < 0 || padrow >= fgNRow)
1408     {
1409       LOG(AliHLTLog::kError,"AliHLTTransform::GetPatch","Padrow")
1410         <<AliHLTLog::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1411       return -2;
1412     }
1413   Int_t patch=0;
1414   while(patch < fgNPatches)
1415     {
1416       if(padrow >= fgRows[patch][0] && padrow <= fgRows[patch][1])
1417         break;
1418       patch++;
1419     }
1420   return patch;
1421 }
1422
1423 Double_t AliHLTTransform::GetPadLength(Int_t padrow)
1424 {
1425   //get pad length for padrow
1426   if(padrow >= fgNRow){
1427       LOG(AliHLTLog::kError,"AliHLTTransform::GetPadLength","Padrow")
1428         <<AliHLTLog::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1429       return 0;
1430     }
1431
1432   if(padrow < fgNRowLow)
1433     return fgInnerPadLength;
1434   if(padrow >= fgNRowLow && padrow < fgNRowLow + fgNRowUp1 - 1)
1435     return fgOuter1PadLength;
1436   if(padrow >= fgNRowLow + fgNRowUp1 - 1)
1437     return fgOuter2PadLength;
1438
1439   //should never happen
1440   LOG(AliHLTLog::kError,"AliHLTTransform::GetPadLength","Padrow")
1441     <<AliHLTLog::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1442   return -1.0; 
1443 }
1444
1445 Double_t AliHLTTransform::GetPadPitchWidth(Int_t patch)
1446 {
1447   //get pad patch width for patch
1448   if(patch < 0 || patch > fgNPatches)
1449     {
1450       LOG(AliHLTLog::kError,"AliHLTTransform::GetPadPitchWidth","patct")
1451         <<AliHLTLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
1452       return -1;
1453     }
1454   return patch < 2 ? fgPadPitchWidthLow : fgPadPitchWidthUp;  
1455 }
1456
1457 Double_t AliHLTTransform::GetParSigmaY2(Int_t padrow,Float_t z,Float_t angle)
1458 {
1459   //Calculate the expected transverse cluster width as a function of 
1460   //drift distance and crossing angle.
1461   //z = local z-coordinate of cluster
1462   //angle = track crossing angle with normal to padrow plane
1463   //return value = sigma^2 (cartesian coordinates)
1464
1465   Double_t drift;
1466   if(z > 0)
1467     drift = fgZLength - z;
1468   else
1469     drift = fgZLength + z;
1470   
1471   Double_t t1 = GetPRFSigma(padrow)*GetPRFSigma(padrow);
1472   Double_t t2 = fgDiffT*fgDiffT*drift;
1473   Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tan(angle)*tan(angle)/12;
1474   Double_t t4 = fgkAnodeWireSpacing*fgkAnodeWireSpacing*(tan(angle) - fgOmegaTau)*(tan(angle) - fgOmegaTau)/12;
1475
1476   return (t1 + t2 + t3 + t4);
1477 }
1478
1479 Double_t AliHLTTransform::GetParSigmaZ2(Int_t padrow,Float_t z,Float_t tgl)
1480 {
1481   //Calculate the expected longitudinal cluster width as a function of 
1482   //drift distance and track crossing angle.
1483   //z = local z-coordinate of cluster
1484   //tgl = tan(dipangle) 
1485   //return value = sigma^2 (cartesian coordinates)
1486
1487   Double_t drift;
1488   if(z > 0)
1489     drift = AliHLTTransform::GetZLength() - z;
1490   else
1491     drift = AliHLTTransform::GetZLength() + z;
1492   
1493   Double_t t1 = fgZSigma*fgZSigma;
1494   Double_t t2 = fgDiffL*fgDiffL*drift;
1495   Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tgl*tgl/12;
1496   
1497   return (t1 + t2 + t3);
1498 }
1499
1500 Double_t AliHLTTransform::GetPRFSigma(Int_t padrow)
1501 {
1502   //get sigma of pad response function for padrow
1503
1504   if(padrow >= fgNRow){
1505     LOG(AliHLTLog::kError,"AliHLTTransform::GetPRFSigma","Padrow")
1506       <<AliHLTLog::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1507     return 0;
1508   }
1509   if(padrow < fgNRowLow)
1510     return fgInnerPRFSigma;
1511   if(padrow >= fgNRowLow && padrow < fgNRowLow + fgNRowUp1 - 1)
1512     return fgOuter1PRFSigma;
1513   if(padrow >= fgNRowLow + fgNRowUp1 - 1)
1514     return fgOuter2PRFSigma;
1515
1516   //should never happen
1517   LOG(AliHLTLog::kError,"AliHLTTransform::GetPRFSigma","Padrow")
1518     <<AliHLTLog::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1519   return -1.; 
1520 }
1521
1522 Double_t AliHLTTransform::GetEta(Float_t *xyz)
1523 {
1524   //get eta
1525   Double_t r3 = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1526   Double_t eta = 0.5 * log((r3+xyz[2])/(r3-xyz[2]));
1527   return eta;
1528 }
1529
1530 void AliHLTTransform::XYZtoRPhiEta(Float_t *rpe, Float_t *xyz)
1531 {
1532   //transform xyz into rpe
1533   rpe[0] = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1534   rpe[1] = atan2(xyz[1],xyz[0]);
1535   rpe[2] = 0.5 * log((rpe[0]+xyz[2])/(rpe[0]-xyz[2]));
1536 }
1537
1538 Double_t AliHLTTransform::GetEta(Int_t slice,Int_t padrow,Int_t pad,Int_t time)
1539 {
1540   //get eta
1541   Float_t xyz[3];
1542   Int_t sector,row;
1543   Slice2Sector(slice,padrow,sector,row);
1544   Raw2Local(xyz,sector,row,pad,time);
1545   
1546   return GetEta(xyz);
1547 }
1548
1549 Double_t AliHLTTransform::GetPhi(Float_t *xyz)
1550 {
1551   //get phi
1552   Double_t phi = atan2(xyz[1],xyz[0]);
1553   return phi;
1554 }
1555
1556 Bool_t AliHLTTransform::Slice2Sector(Int_t slice, Int_t slicerow, Int_t & sector, Int_t &row)
1557 {
1558   //slice to sector number
1559   if(slicerow<0&&slicerow>=fgNRow){
1560     LOG(AliHLTLog::kError,"AliHLTTransform::Slice2Sector","Slicerow")
1561       <<AliHLTLog::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1562     return kFALSE;
1563   }
1564   if(slice<0||slice>=fgNSlice){
1565     LOG(AliHLTLog::kError,"AliHLTTransform::Slice2Sector","Slice")
1566       <<AliHLTLog::kDec<<"Wrong slice "<<slice<<ENDLOG;
1567     return kFALSE;
1568   }
1569
1570   if(slicerow<fgNRowLow){
1571     sector = fgSlice2Sector[slice][0];
1572     row    = slicerow;
1573   }
1574   else {
1575     sector = fgSlice2Sector[slice][1];
1576     row    = slicerow-fgNRowLow;
1577   }
1578
1579   return kTRUE;
1580 }
1581
1582 Bool_t AliHLTTransform::Sector2Slice(Int_t & slice, Int_t  sector)
1583 {
1584   //sector to slice
1585   if(sector<0||sector>=fgNSector){
1586     LOG(AliHLTLog::kError,"AliHLTTransform::Sector2Slice","Sector")
1587       <<AliHLTLog::kDec<<"Wrong sector "<<sector<<ENDLOG;
1588     return kFALSE;
1589   }
1590
1591   slice=fgSector2Slice[sector];
1592
1593   return kTRUE;
1594 }
1595
1596 Bool_t AliHLTTransform::Sector2Slice(Int_t & slice, Int_t & slicerow, Int_t sector, Int_t row)
1597 {
1598   //sector to slice
1599   if(sector<0 || sector>=fgNSector){
1600     LOG(AliHLTLog::kError,"AliHLTTransform::Sector2Slice","Sector")
1601       <<AliHLTLog::kDec<<"Wrong sector "<<sector<<ENDLOG;
1602     return kFALSE;
1603   }
1604   if(row<0){
1605     LOG(AliHLTLog::kError,"AliHLTTransform::Sector2Slice","Row")
1606       <<AliHLTLog::kDec<<"Wrong row "<<row<<ENDLOG;
1607     return kFALSE;
1608   }
1609
1610   if(fgSectorLow[sector]){
1611     if(row>=fgNRowLow){
1612       LOG(AliHLTLog::kError,"AliHLTTransform::Sector2Slice","Row")
1613         <<AliHLTLog::kDec<<"Wrong row "<<row<<ENDLOG;
1614       return kFALSE;
1615     }
1616     slice = fgSector2Slice[sector];
1617     slicerow = row;
1618   }
1619   else{
1620     if(row>=fgNRowUp){
1621       LOG(AliHLTLog::kError,"AliHLTTransform::Sector2Slice","Row")
1622         <<AliHLTLog::kDec<<"Wrong row "<<row<<ENDLOG;
1623       return kFALSE;
1624     }
1625     slice = fgSector2Slice[sector];
1626     slicerow = row + fgNRowLow;
1627   }
1628
1629   return kTRUE;
1630 }
1631
1632 Double_t AliHLTTransform::GetMaxY(Int_t slicerow)
1633 {
1634   //get maximum y value (for slice 0)
1635  if(slicerow < fgNRowLow)
1636      return fgPadPitchWidthLow*fgNPads[slicerow]/2; 
1637  
1638  else
1639      return fgPadPitchWidthUp*fgNPads[slicerow]/2;
1640
1641 }
1642
1643 Double_t AliHLTTransform::Row2X(Int_t slicerow)
1644 {
1645   //slicerow to X value (slice 0)
1646   if(slicerow<0||slicerow>=fgNRow){
1647     LOG(AliHLTLog::kError,"AliHLTTransform::Row2X","Slicerow")
1648       <<AliHLTLog::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1649     return 0;
1650   }
1651   return fgX[slicerow];
1652 }
1653
1654 Double_t AliHLTTransform::GetZFast(Int_t slice, Int_t time, Float_t vertex)
1655 {
1656   //get z value
1657   Double_t z=fgZWidth*time-fgZOffset;
1658   if(slice < 18)
1659     z=fgZLength-z-vertex;
1660   else
1661     z=z-fgZLength-vertex;
1662   return z;
1663 }
1664
1665 void AliHLTTransform::Local2Global(Float_t *xyz,Int_t slice)
1666 {
1667   //Transformation to global coordinate system
1668   Float_t x0 = xyz[0];
1669   Float_t y0 = xyz[1];
1670
1671   xyz[0]=x0*fgCos[slice]-y0*fgSin[slice];
1672   xyz[1]=x0*fgSin[slice]+y0*fgCos[slice];
1673   xyz[2]=xyz[2];//global z=local z
1674 }
1675
1676 void AliHLTTransform::Local2GlobalAngle(Float_t *angle,Int_t slice)
1677 {
1678   //get angle global
1679   angle[0] = fmod(angle[0]+(slice+fgNRotShift)*(2*fgkPi/18),2*fgkPi);
1680 }
1681
1682 void AliHLTTransform::Global2LocalAngle(Float_t *angle,Int_t slice)
1683 {
1684   //get angle local
1685   angle[0] = angle[0]-(slice+fgNRotShift)*(2*fgkPi/18);
1686   if(angle[0]<0) angle[0]+=2*fgkPi;
1687 }
1688
1689 void AliHLTTransform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1690 {
1691   //Transformation from rawdata to local coordinate system
1692   
1693   Int_t slice,slicerow;
1694   Sector2Slice(slice, slicerow, sector, row);  
1695
1696   //X-Value
1697   xyz[0]=Row2X(slicerow); 
1698
1699   //Y-Value
1700   Int_t npads= fgNPads[slicerow];
1701
1702   if(fgSectorLow[sector])
1703     xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthLow;
1704   else
1705     xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthUp;
1706
1707   //Z-Value (remember PULSA Delay)
1708   if(slice < 18)
1709     xyz[2]=fgZLength-fgZWidth*time+fgZOffset;
1710   else
1711     xyz[2]=fgZWidth*time-fgZOffset-fgZLength;
1712 }
1713
1714 void AliHLTTransform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Int_t pad,Int_t time)
1715 {
1716   //Transformation from rawdata to local coordinate system
1717   
1718   Int_t slice,slicerow;
1719   Sector2Slice(slice, slicerow, sector, row);  
1720
1721   //X-Value
1722   xyz[0]=Row2X(slicerow); 
1723
1724   //Y-Value
1725   Int_t npads= fgNPads[slicerow];
1726
1727   if(fgSectorLow[sector])
1728     xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthLow;
1729   else
1730     xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthUp;
1731
1732   //Z-Value (remember PULSA Delay)
1733   if(slice < 18)
1734     xyz[2]=fgZLength-fgZWidth*time+fgZOffset;
1735   else
1736     xyz[2]=fgZWidth*time-fgZOffset-fgZLength;
1737 }
1738
1739 void AliHLTTransform::RawHLT2Local(Float_t *xyz,Int_t slice,
1740                                Int_t slicerow,Float_t pad,Float_t time)
1741 {
1742   //Transformation from HLT rawdata to local coordinate system
1743   
1744   //X-Value
1745   xyz[0]=Row2X(slicerow); 
1746
1747   //Y-Value
1748   Int_t npads= fgNPads[slicerow];
1749   if(slicerow<fgNRowLow)
1750     xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthLow;
1751   else
1752     xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthUp;
1753
1754   //Z-Value
1755   if(slice < 18)
1756     xyz[2]=fgZLength-fgZWidth*time+fgZOffset;
1757   else
1758     xyz[2]=fgZWidth*time-fgZOffset-fgZLength;
1759 }
1760
1761 void AliHLTTransform::RawHLT2Local(Float_t *xyz,Int_t slice,
1762                                Int_t slicerow,Int_t pad,Int_t time)
1763 {
1764   //Transformation from HLT rawdata to local coordinate system
1765   
1766   //X-Value
1767   xyz[0]=Row2X(slicerow); 
1768
1769   //Y-Value
1770   Int_t npads= fgNPads[slicerow];
1771   if(slicerow<fgNRowLow)
1772     xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthLow;
1773   else
1774     xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthUp;
1775
1776   //Z-Value
1777   if(slice < 18)
1778     xyz[2]=fgZLength-fgZWidth*time+fgZOffset;
1779   else
1780     xyz[2]=fgZWidth*time-fgZOffset-fgZLength;
1781 }
1782
1783 void AliHLTTransform::Local2Global(Float_t *xyz,Int_t sector,Int_t row)
1784 {
1785   //Transformation to global coordinate system
1786   Int_t slice,slicerow;
1787   Sector2Slice(slice, slicerow, sector, row);  
1788   Float_t r=Row2X(slicerow); //have to get x value first
1789                              
1790   xyz[0]=r*fgCos[slice]-xyz[1]*fgSin[slice];
1791   xyz[1]=r*fgSin[slice]+xyz[1]*fgCos[slice];
1792   xyz[2]=xyz[2];//global z=local z
1793 }
1794
1795 void AliHLTTransform::LocHLT2Global(Float_t *xyz,Int_t slice,Int_t slicerow)
1796 {
1797   //Transformation from HLT to global coordinate system
1798   Float_t r=Row2X(slicerow); //have to get x value first
1799                              
1800   xyz[0]=r*fgCos[slice]-xyz[1]*fgSin[slice];
1801   xyz[1]=r*fgSin[slice]+xyz[1]*fgCos[slice];
1802   xyz[2]=xyz[2];//global z=local z
1803 }
1804
1805 void AliHLTTransform::Global2Local(Float_t *xyz,Int_t sector)
1806 { //check code
1807   Int_t slice;
1808   Sector2Slice(slice, sector);  
1809
1810   Float_t x1 =  xyz[0]*fgCos[slice] + xyz[1]*fgSin[slice];
1811   Float_t y1 = -xyz[0]*fgSin[slice] + xyz[1]*fgCos[slice];
1812   xyz[0] = x1;
1813   xyz[1] = y1;
1814 }
1815
1816 void AliHLTTransform::Global2LocHLT(Float_t *xyz,Int_t slice)
1817 {
1818   Float_t x1 =  xyz[0]*fgCos[slice] + xyz[1]*fgSin[slice];
1819   Float_t y1 = -xyz[0]*fgSin[slice] + xyz[1]*fgCos[slice];
1820   xyz[0] = x1;
1821   xyz[1] = y1;
1822 }
1823
1824 void AliHLTTransform::Raw2Global(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1825 {
1826   //Transformation from raw to global coordinates
1827  
1828   Raw2Local(xyz,sector,row,pad,time);
1829   Local2Global(xyz,sector,row);
1830 }
1831
1832 void AliHLTTransform::Raw2Global(Float_t *xyz,Int_t sector,Int_t row,Int_t pad,Int_t time)
1833 {
1834   //Transformation from raw to global coordinates
1835  
1836   Raw2Local(xyz,sector,row,pad,time);
1837   Local2Global(xyz,sector,row);
1838 }
1839
1840 void AliHLTTransform::RawHLT2Global(Float_t *xyz,Int_t slice,
1841                                    Int_t slicerow,Float_t pad,Float_t time)
1842 {
1843   //Transformation from raw to global coordinates
1844  
1845   RawHLT2Local(xyz,slice,slicerow,pad,time);
1846   LocHLT2Global(xyz,slice,slicerow);
1847 }
1848
1849 void AliHLTTransform::RawHLT2Global(Float_t *xyz,Int_t slice,
1850                                    Int_t slicerow,Int_t pad,Int_t time)
1851 {
1852   //Transformation from raw to global coordinates
1853  
1854   RawHLT2Local(xyz,slice,slicerow,pad,time);
1855   LocHLT2Global(xyz,slice,slicerow);
1856 }
1857
1858 void AliHLTTransform::Local2Raw(Float_t *xyz,Int_t sector,Int_t row)
1859 {
1860   //Transformation from local coordinates to raw
1861
1862   Int_t slice,slicerow;
1863   Sector2Slice(slice, slicerow, sector, row);  
1864    
1865   xyz[0]=slicerow;
1866
1867   if(fgSectorLow[sector])
1868     xyz[1]=xyz[1]/fgPadPitchWidthLow+0.5*(fgNPads[slicerow]-1);
1869   else
1870     xyz[1]=xyz[1]/fgPadPitchWidthUp+0.5*(fgNPads[slicerow]-1);
1871
1872   if(slice < 18)
1873     xyz[2]=(fgZLength-xyz[2]+fgZOffset)/fgZWidth;
1874   else
1875     xyz[2]=(fgZLength+xyz[2]+fgZOffset)/fgZWidth;
1876 }
1877
1878 void AliHLTTransform::LocHLT2Raw(Float_t *xyz,Int_t slice,Int_t slicerow)
1879 {
1880   //Transformation from local coordinates to raw
1881
1882   xyz[0]=slicerow;
1883
1884   if(slicerow<fgNRowLow)
1885     xyz[1]=xyz[1]/fgPadPitchWidthLow+0.5*(fgNPads[slicerow]-1);
1886   else
1887     xyz[1]=xyz[1]/fgPadPitchWidthUp+0.5*(fgNPads[slicerow]-1);
1888
1889   if(slice < 18)
1890     xyz[2]=(fgZLength-xyz[2]+fgZOffset)/fgZWidth;
1891   else
1892     xyz[2]=(fgZLength+xyz[2]+fgZOffset)/fgZWidth;
1893 }
1894
1895 void AliHLTTransform::Global2Raw(Float_t *xyz,Int_t sector,Int_t row)
1896 {
1897   //Transformation from global coordinates to raw. 
1898
1899   Global2Local(xyz,sector);
1900   Local2Raw(xyz,sector,row);
1901 }
1902
1903 void AliHLTTransform::Global2HLT(Float_t *xyz,Int_t slice,Int_t slicerow)
1904 {
1905   //Transformation from global coordinates to raw. 
1906
1907   Global2LocHLT(xyz,slice);
1908   LocHLT2Raw(xyz,slice,slicerow);
1909 }
1910
1911 void AliHLTTransform::PrintCompileOptions()
1912 {
1913   //print compile options
1914 #if defined(__GNUC__)
1915   cout << "Compiler (g++) version used: " << __GNUC__ << endl;
1916 #endif
1917
1918 #ifdef no_root
1919   cout << "STANDALONE version: -Dno_root was given." << endl;
1920 #else
1921   const Char_t *roottest="$ROOTSYS/bin/root -n -b -q  | grep Version | cut -b 17-25 | cut -d\" \" -f1";
1922 #ifdef use_aliroot
1923 #ifdef use_cvs
1924   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";
1925 #else
1926   const Char_t *aliroottest="Unknown";
1927 #endif
1928   cout << "ALIROOT version: -Duse_aliroot and -Duse_root was given." << endl;
1929   cout << "Root Version: " << ROOTVERSION << " found " << flush;
1930   gSystem->Exec(roottest);
1931
1932   cout << "AliRoot Version: " << ALIROOTVERSION << " found " << flush;
1933   gSystem->Exec(aliroottest);
1934 #else
1935   cout << "ROOT version: -Duse_root was given." << endl;
1936   cout << "Root Version: " << ROOTVERSION << " found " << flush;
1937   gSystem->Exec(roottest);
1938 #endif
1939 #endif
1940
1941 #ifdef do_mc
1942   cout << "Using Monte Carlo Info: -Ddo_mc was given." << endl;
1943 #else
1944   cout << "NOT using Monte Carlo Info: -Ddo_mc was not given." << endl;
1945 #endif
1946
1947 #ifdef ROWHOUGHPARAMS
1948   cout << "Using extended AliHLTTrackSegmentData: -DROWHOUGHPARAMS was given." << endl;
1949 #else
1950   cout << "NOT using extended AliHLTTrackSegmentData: -DROWHOUGHPARAMS was not given." << endl;
1951 #endif
1952
1953 #ifdef use_newio
1954   cout << "Using NEWIO version: -Duse_newio was given." << endl;
1955 #else
1956   cout << "NOT using NEWIO version: -Duse_newio was not given." << endl;
1957 #endif
1958
1959 #ifdef use_logging
1960   cout << "Using logging classes (MLUC): -Duse_logging was given." << endl;
1961 #else
1962   cout << "NOT using logging classes (MLUC): -Duse_logging not was given." << endl;
1963 #endif
1964
1965 }