]> git.uio.no Git - u/mrichter/AliRoot.git/blame - HLT/TPCLib/AliHLTTPCTransform.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bugfix: lowercase b should be upper case B for component id: TPCClusterFinder32Bit
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCTransform.cxx
CommitLineData
f7561f8d 1
a6c02c85 2// @(#) $Id$
4aa41877 3// Original: AliHLTTransform.cxx,v 1.53 2005/06/14 10:55:21 cvetan
a6c02c85 4
5// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>, Constantin Loizides <mailto:loizides@ikf.uni-frankfurt.de>
6//*-- Copyright &copy ALICE HLT Group
7
8
a6c02c85 9#include "dirent.h"
10
11#ifdef use_aliroot
12#include <AliRun.h>
13#include <AliMagF.h>
14#include <AliTPCParamSR.h>
15#include <AliTPCPRF2D.h>
16#include <AliTPCRF1D.h>
17#endif
18#ifdef use_root
f7a1cc68 19#include <TError.h>
a6c02c85 20#include <TFile.h>
a6c02c85 21#include <TTimeStamp.h>
f7a1cc68 22#include <TUnixSystem.h>
a6c02c85 23#endif
24
25#include "AliHLTTPCLogging.h"
26#include "AliHLTTPCTransform.h"
27
28#if defined(__GNUC__) && __GNUC__ >= 3
29using namespace std;
30#endif
31
32/** \class AliHLTTPCTransform
33<pre>
34//_____________________________________________________________
35// AliHLTTPCTransform
36//
37// Transformation class for ALICE TPC.
38//
39// Class which contains all detector specific parameters for the TPC,
40// and different useful functions for coordinate transforms.
41//
42// The class is completely static, which means that no object needs
43// to be instantiated. Function calls should then be done like, e.g.:
44//
45// Double_t eta = AliHLTTPCTransform::GetEta(xyz);
46//
47// IMPORTANT: If used as is, default detector parameters will be used,
48// and you really have to make sure that these correspond to
49// the AliROOT version you are currently working on!!
50// You should therefore always initialize the parameters by
51//
52// AliHLTTPCTransform::Init(path);
53//
54// where path is a char*, giving the path to where file containing
55// the detector parameter is located. This file should be called
56// "l3transform.config", and can be created with the function MakeInitFile.
57//
58// You can also force reading the parameters from a AliTPCParam object
59// by setting the flag;
60//
61// AliHLTTPCTransform::Init(path,kTRUE);
62//
63// where path is a char*
64// either providing the rootfile name containing the geometry or
65// the path to the rootfile which should then be called alirunfile.root.
66// Note that for both of these cases you have to
67// compile with USEPACKAGE=ALIROOT set (see level3code/Makefile.conf).
68//
69// Currently, there are 4 versions of the Transformer:
70// fVersion==kValiroot: ALIROOT-head compatible
71// fVersion==kVcosmics: Cosmics data run (2003) compatible
72// fVersion==kVdefault: means no config file has been loaded
73// fVersion==kVdeprecated: dont use old (before July 2003) style of transformer
74//
75</pre>
297174de 76* @ingroup alihlt_tpc
a6c02c85 77*/
78
79ClassImp(AliHLTTPCTransform)
80
600e6a1b 81AliHLTTPCTransform::AliHLTTPCTransform()
82{
83}
84
a6c02c85 85const Double_t AliHLTTPCTransform::fgkAnodeWireSpacing = 0.25; //Taken from the TDR
86const Double_t AliHLTTPCTransform::fgkBFACT = 0.0029980; //Conversion Factor
87const Double_t AliHLTTPCTransform::fgkPi = 3.141592653589793;
88const Double_t AliHLTTPCTransform::fgk2Pi = 2*3.141592653589793;
89const Double_t AliHLTTPCTransform::fgkPi2 = 0.5*3.141592653589793;
90const Double_t AliHLTTPCTransform::fgkToDeg = 180/3.141592653589793;
91
92//Defined by HLT and GSI
93Int_t AliHLTTPCTransform::fgNPatches = 6;
94#if 0
95// Old format, corresponding to IntegrTest-5 code and data
96Int_t AliHLTTPCTransform::fgRows[6][2] = {{0,29},{30,62},{63,90},{91,116},{117,139},{140,158}};
97Int_t AliHLTTPCTransform::fgNRows[6] = {30,33,28,26,23,19};
98#else
99// New data corresponding to simulated raw data 2004-08-20, provided by Thomas Kuhr
100Int_t AliHLTTPCTransform::fgRows[6][2] = {{0,30},{30,62},{63,90},{90,116},{117,139},{139,158}};
101Int_t AliHLTTPCTransform::fgNRows[6] = {31,33,28,27,23,20};
102#endif
103
104// The following definition is generated by MakeInitFile function
8252a538 105Double_t AliHLTTPCTransform::fgBField = 0.5;
106Double_t AliHLTTPCTransform::fgSolenoidBField = 5;
a6c02c85 107Double_t AliHLTTPCTransform::fgBFieldFactor = 1;
108Int_t AliHLTTPCTransform::fgVersion = kVdefault;
5235c3e9 109Int_t AliHLTTPCTransform::fgNTimeBins = 1024; // = 1024; //446
a6c02c85 110Int_t AliHLTTPCTransform::fgNRowLow = 63;
111Int_t AliHLTTPCTransform::fgNRowUp = 96;
112Int_t AliHLTTPCTransform::fgNRowUp1 = 64;
113Int_t AliHLTTPCTransform::fgNRowUp2 = 32;
114Int_t AliHLTTPCTransform::fgNSectorLow = 36;
115Int_t AliHLTTPCTransform::fgNSectorUp = 36;
116Int_t AliHLTTPCTransform::fgNSector = 72;
117Double_t AliHLTTPCTransform::fgPadPitchWidthLow = 0.4;
118Double_t AliHLTTPCTransform::fgPadPitchWidthUp = 0.6;
a6c02c85 119Double_t AliHLTTPCTransform::fgZSigma = 0.2288;
120Double_t AliHLTTPCTransform::fgZLength = 250.0000;
5235c3e9 121Double_t AliHLTTPCTransform::fgZWidth = AliHLTTPCTransform::fgZLength / (Double_t)AliHLTTPCTransform::fgNTimeBins ;//0.5660; // 0.2435; // 0.5660 // Width of time bins
a6c02c85 122Double_t AliHLTTPCTransform::fgZOffset = 0.6864;
123Double_t AliHLTTPCTransform::fgDiffT = 0.0220;
124Double_t AliHLTTPCTransform::fgDiffL = 0.0220;
125Double_t AliHLTTPCTransform::fgOmegaTau = 0.1450;
126Double_t AliHLTTPCTransform::fgInnerPadLength = 0.75;
127Double_t AliHLTTPCTransform::fgOuter1PadLength = 1.00;
128Double_t AliHLTTPCTransform::fgOuter2PadLength = 1.50;
129Double_t AliHLTTPCTransform::fgInnerPRFSigma = 0.203811;
130Double_t AliHLTTPCTransform::fgOuter1PRFSigma = 0.299325;
131Double_t AliHLTTPCTransform::fgOuter2PRFSigma = 0.299323;
132Double_t AliHLTTPCTransform::fgTimeSigma = 0.228809;
133Int_t AliHLTTPCTransform::fgADCSat = 1024;
134Int_t AliHLTTPCTransform::fgZeroSup = 0;
135Int_t AliHLTTPCTransform::fgNSlice = 36;
136Int_t AliHLTTPCTransform::fgNRow = 159;
137Double_t AliHLTTPCTransform::fgNRotShift = 0.5;
138Int_t AliHLTTPCTransform::fgSlice2Sector[36][2] = { { 0, 36},
139 { 1, 37},
140 { 2, 38},
141 { 3, 39},
142 { 4, 40},
143 { 5, 41},
144 { 6, 42},
145 { 7, 43},
146 { 8, 44},
147 { 9, 45},
148 {10, 46},
149 {11, 47},
150 {12, 48},
151 {13, 49},
152 {14, 50},
153 {15, 51},
154 {16, 52},
155 {17, 53},
156 {18, 54},
157 {19, 55},
158 {20, 56},
159 {21, 57},
160 {22, 58},
161 {23, 59},
162 {24, 60},
163 {25, 61},
164 {26, 62},
165 {27, 63},
166 {28, 64},
167 {29, 65},
168 {30, 66},
169 {31, 67},
170 {32, 68},
171 {33, 69},
172 {34, 70},
173 {35, 71}
174};
175
176Int_t AliHLTTPCTransform::fgSector2Slice[72] = { 0,
177 1,
178 2,
179 3,
180 4,
181 5,
182 6,
183 7,
184 8,
185 9,
186 10,
187 11,
188 12,
189 13,
190 14,
191 15,
192 16,
193 17,
194 18,
195 19,
196 20,
197 21,
198 22,
199 23,
200 24,
201 25,
202 26,
203 27,
204 28,
205 29,
206 30,
207 31,
208 32,
209 33,
210 34,
211 35,
212 0,
213 1,
214 2,
215 3,
216 4,
217 5,
218 6,
219 7,
220 8,
221 9,
222 10,
223 11,
224 12,
225 13,
226 14,
227 15,
228 16,
229 17,
230 18,
231 19,
232 20,
233 21,
234 22,
235 23,
236 24,
237 25,
238 26,
239 27,
240 28,
241 29,
242 30,
243 31,
244 32,
245 33,
246 34,
247 35
248};
249
250Int_t AliHLTTPCTransform::fgSectorLow[72] = { 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 1,
274 1,
275 1,
276 1,
277 1,
278 1,
279 1,
280 1,
281 1,
282 1,
283 1,
284 1,
285 1,
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 0,
310 0,
311 0,
312 0,
313 0,
314 0,
315 0,
316 0,
317 0,
318 0,
319 0,
320 0,
321 0
322};
323
324Double_t AliHLTTPCTransform::fgX[159] = { 85.195,
325 85.945,
326 86.695,
327 87.445,
328 88.195,
329 88.945,
330 89.695,
331 90.445,
332 91.195,
333 91.945,
334 92.695,
335 93.445,
336 94.195,
337 94.945,
338 95.695,
339 96.445,
340 97.195,
341 97.945,
342 98.695,
343 99.445,
344 100.195,
345 100.945,
346 101.695,
347 102.445,
348 103.195,
349 103.945,
350 104.695,
351 105.445,
352 106.195,
353 106.945,
354 107.695,
355 108.445,
356 109.195,
357 109.945,
358 110.695,
359 111.445,
360 112.195,
361 112.945,
362 113.695,
363 114.445,
364 115.195,
365 115.945,
366 116.695,
367 117.445,
368 118.195,
369 118.945,
370 119.695,
371 120.445,
372 121.195,
373 121.945,
374 122.695,
375 123.445,
376 124.195,
377 124.945,
378 125.695,
379 126.445,
380 127.195,
381 127.945,
382 128.695,
383 129.445,
384 130.195,
385 130.945,
386 131.695,
387 135.180,
388 136.180,
389 137.180,
390 138.180,
391 139.180,
392 140.180,
393 141.180,
394 142.180,
395 143.180,
396 144.180,
397 145.180,
398 146.180,
399 147.180,
400 148.180,
401 149.180,
402 150.180,
403 151.180,
404 152.180,
405 153.180,
406 154.180,
407 155.180,
408 156.180,
409 157.180,
410 158.180,
411 159.180,
412 160.180,
413 161.180,
414 162.180,
415 163.180,
416 164.180,
417 165.180,
418 166.180,
419 167.180,
420 168.180,
421 169.180,
422 170.180,
423 171.180,
424 172.180,
425 173.180,
426 174.180,
427 175.180,
428 176.180,
429 177.180,
430 178.180,
431 179.180,
432 180.180,
433 181.180,
434 182.180,
435 183.180,
436 184.180,
437 185.180,
438 186.180,
439 187.180,
440 188.180,
441 189.180,
442 190.180,
443 191.180,
444 192.180,
445 193.180,
446 194.180,
447 195.180,
448 196.180,
449 197.180,
450 198.180,
451 199.430,
452 200.930,
453 202.430,
454 203.930,
455 205.430,
456 206.930,
457 208.430,
458 209.930,
459 211.430,
460 212.930,
461 214.430,
462 215.930,
463 217.430,
464 218.930,
465 220.430,
466 221.930,
467 223.430,
468 224.930,
469 226.430,
470 227.930,
471 229.430,
472 230.930,
473 232.430,
474 233.930,
475 235.430,
476 236.930,
477 238.430,
478 239.930,
479 241.430,
480 242.930,
481 244.430,
482 245.930
483};
484
84645eb0 485#if 1
db16520a 486// New number of pads changed 2006-04-15 Jochen Thaeder
487// changed according to formula in AliTPCROC.cxx
488// according to real Pad Distribution on build TPC
489Int_t AliHLTTPCTransform::fgNPads[159] = {68,
490 68,
491 68,
492 68,
493 70,
494 70,
495 70,
496 72,
497 72,
498 72,
499 74,
500 74,
501 74,
502 76,
503 76,
504 76,
505 78,
506 78,
507 78,
508 80,
509 80,
510 80,
511 82,
512 82,
513 82,
514 84,
515 84,
516 84,
517 86,
518 86,
519 86,
520 88,
521 88,
522 88,
523 90,
524 90,
525 90,
526 92,
527 92,
528 92,
529 94,
530 94,
531 94,
532 96,
533 96,
534 96,
535 98,
536 98,
537 98,
538 100,
539 100,
540 100,
541 102,
542 102,
543 102,
544 104,
545 104,
546 104,
547 106,
548 106,
549 106,
550 108,
551 108,
552 74,
553 76,
554 76,
555 76,
556 76,
557 78,
558 78,
559 78,
560 80,
561 80,
562 80,
563 80,
564 82,
565 82,
566 82,
567 84,
568 84,
569 84,
570 86,
571 86,
572 86,
573 86,
574 88,
575 88,
576 88,
577 90,
578 90,
579 90,
580 90,
581 92,
582 92,
583 92,
584 94,
585 94,
586 94,
587 96,
588 96,
589 96,
590 96,
591 98,
592 98,
593 98,
594 100,
595 100,
596 100,
597 100,
598 102,
599 102,
600 102,
601 104,
602 104,
603 104,
604 106,
605 106,
606 106,
607 106,
608 108,
609 108,
610 108,
611 110,
612 110,
613 110,
614 110,
615 112,
616 112,
617 114,
618 114,
619 114,
620 116,
621 116,
622 118,
623 118,
624 120,
625 120,
626 122,
627 122,
628 122,
629 124,
630 124,
631 126,
632 126,
633 128,
634 128,
635 130,
636 130,
637 130,
638 132,
639 132,
640 134,
641 134,
642 136,
643 136,
644 138,
645 138,
646 138,
647 140
648};
649
650#else
651// OLD number of pads changed 2006-04-15 Jochen Thaeder
a6c02c85 652Int_t AliHLTTPCTransform::fgNPads[159] = {67,
653 67,
654 69,
655 69,
656 69,
657 71,
658 71,
659 71,
660 73,
661 73,
662 73,
663 75,
664 75,
665 75,
666 77,
667 77,
668 77,
669 79,
670 79,
671 79,
672 81,
673 81,
674 81,
675 83,
676 83,
677 83,
678 85,
679 85,
680 85,
681 87,
682 87,
683 87,
684 89,
685 89,
686 89,
687 91,
688 91,
689 91,
690 93,
691 93,
692 93,
693 95,
694 95,
695 95,
696 97,
697 97,
698 97,
699 99,
700 99,
701 99,
702 99,
703 101,
704 101,
705 101,
706 103,
707 103,
708 103,
709 105,
710 105,
711 105,
712 107,
713 107,
714 107,
715 73,
716 75,
717 75,
718 75,
719 75,
720 77,
721 77,
722 77,
723 79,
724 79,
725 79,
726 81,
727 81,
728 81,
729 81,
730 83,
731 83,
732 83,
733 85,
734 85,
735 85,
736 85,
737 87,
738 87,
739 87,
740 89,
741 89,
742 89,
743 91,
744 91,
745 91,
746 91,
747 93,
748 93,
749 93,
750 95,
751 95,
752 95,
753 95,
754 97,
755 97,
756 97,
757 99,
758 99,
759 99,
760 101,
761 101,
762 101,
763 101,
764 103,
765 103,
766 103,
767 105,
768 105,
769 105,
770 105,
771 107,
772 107,
773 107,
774 109,
775 109,
776 109,
777 111,
778 111,
779 111,
780 113,
781 113,
782 113,
783 115,
784 115,
785 117,
786 117,
787 119,
788 119,
789 121,
790 121,
791 121,
792 123,
793 123,
794 125,
795 125,
796 127,
797 127,
798 127,
799 129,
800 129,
801 131,
802 131,
803 133,
804 133,
805 135,
806 135,
807 135,
808 137,
809 137,
810 139
811};
db16520a 812#endif
a6c02c85 813
814Double_t AliHLTTPCTransform::fgCos[36] = { 0.9848077297,
815 0.8660253882,
816 0.6427876353,
817 0.3420201540,
818 0.0000000000,
819 -0.3420201540,
820 -0.6427876353,
821 -0.8660253882,
822 -0.9848077297,
823 -0.9848077297,
824 -0.8660253882,
825 -0.6427876353,
826 -0.3420201540,
827 -0.0000000000,
828 0.3420201540,
829 0.6427876353,
830 0.8660253882,
831 0.9848077297,
832 0.9848077297,
833 0.8660253882,
834 0.6427876353,
835 0.3420201540,
836 0.0000000000,
837 -0.3420201540,
838 -0.6427876353,
839 -0.8660253882,
840 -0.9848077297,
841 -0.9848077297,
842 -0.8660253882,
843 -0.6427876353,
844 -0.3420201540,
845 -0.0000000000,
846 0.3420201540,
847 0.6427876353,
848 0.8660253882,
849 0.9848077297
850};
851
852Double_t AliHLTTPCTransform::fgSin[36] = { 0.1736481786,
853 0.5000000000,
854 0.7660444379,
855 0.9396926165,
856 1.0000000000,
857 0.9396926165,
858 0.7660444379,
859 0.5000000000,
860 0.1736481786,
861 -0.1736481786,
862 -0.5000000000,
863 -0.7660444379,
864 -0.9396926165,
865 -1.0000000000,
866 -0.9396926165,
867 -0.7660444379,
868 -0.5000000000,
869 -0.1736481786,
870 0.1736481786,
871 0.5000000000,
872 0.7660444379,
873 0.9396926165,
874 1.0000000000,
875 0.9396926165,
876 0.7660444379,
877 0.5000000000,
878 0.1736481786,
879 -0.1736481786,
880 -0.5000000000,
881 -0.7660444379,
882 -0.9396926165,
883 -1.0000000000,
884 -0.9396926165,
885 -0.7660444379,
886 -0.5000000000,
887 -0.1736481786
888};
889
a6c02c85 890Int_t AliHLTTPCTransform::GetNPads(Int_t row)
891{
892 //get number of pads per row
893 if(row < 0 || row >= fgNRow)
894 {
895 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetNPads","Row")
896 <<AliHLTTPCLog::kDec<<"Wrong row "<<row<<ENDLOG;
897 return 0;
898 }
899
900 return fgNPads[row];
901}
902
84645eb0 903Int_t AliHLTTPCTransform::GetNumberOfPatches() {
904 return fgNPatches;
905}
906
a6c02c85 907Int_t AliHLTTPCTransform::GetFirstRow(Int_t patch)
908{
909 //get first row per patch
910
911 if(patch==-1)
912 return 0;
913 else if(patch < -1 || patch >= 6)
914 {
915 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetFirstRow","Patch")
916 <<AliHLTTPCLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
917 return 0;
918 }
919 else
920 return fgRows[patch][0];
921}
922
923Int_t AliHLTTPCTransform::GetLastRow(Int_t patch)
924{
925 //get last row per patch
926 if(patch==-1)
927 return fgRows[5][1];
928 else if(patch < -1 || patch >= 6)
929 {
930 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetLastRow","Patch")
931 <<AliHLTTPCLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
932 return 0;
933 }
934 else
935 return fgRows[patch][1];
936}
937
938Int_t AliHLTTPCTransform::GetFirstRowOnDDL(Int_t patch)
939{
940 //get first row per patch
941
942 if(patch==-1)
943 return 0;
944 else if(patch < -1 || patch >= 6)
945 {
946 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetFirstRow","Patch")
947 <<AliHLTTPCLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
948 return 0;
949 }
950 else
951 {
952 if(patch==1) return fgRows[patch][0]+1;
953 return fgRows[patch][0];
954 }
955}
956
957Int_t AliHLTTPCTransform::GetLastRowOnDDL(Int_t patch)
958{
959 //get last row per patch
960 if(patch==-1)
961 return fgRows[5][1];
962 else if(patch < -1 || patch >= 6)
963 {
964 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetLastRow","Patch")
965 <<AliHLTTPCLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
966 return 0;
967 }
968 else
969 {
970 if(patch==2 || patch==4) return fgRows[patch][1]-1;
971 return fgRows[patch][1];
972 }
973}
974
975Int_t AliHLTTPCTransform::GetNRows(Int_t patch)
976{
977 //get number of rows per patch
978 if(patch==-1)
979 return fgNRow;
980 else if(patch < -1 || patch >= 6)
981 {
982 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetNRows","Patch")
983 <<AliHLTTPCLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
984 return 0;
985 }
986 else
987 return fgNRows[patch];
988}
989
990Int_t AliHLTTPCTransform::GetPadRow(Float_t xvalue)
991{
992 //Find the padrow number corresponding to cartesian _local_ x value
993 if(xvalue < 0 || xvalue > 250)
994 {
995 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetPadRow","X-value")
996 <<AliHLTTPCLog::kDec<<"Suspicious x-value, make sure it is in local coordinate! "
997 <<xvalue<<ENDLOG;
998 return -1;
999 }
1000
1001 Int_t x = (Int_t)rint(xvalue*10);
1002 if(x < (Int_t)rint(fgX[1]*10))
1003 return 0;
1004 else if(x > (Int_t)rint(fgX[fgNRow-2]*10))
1005 return fgNRow-1;
1006 else
1007 {
1008 Int_t padrow=1; //Of course, a more clever algorithm could help here
1009 while(padrow < fgNRow-2)
1010 {
1011 if(x > (Int_t)rint(fgX[padrow-1]*10) && x < (Int_t)rint(fgX[padrow+1]*10))
1012 break;
1013 padrow++;
1014 }
1015 return padrow;
1016 }
1017}
1018
1019Int_t AliHLTTPCTransform::GetPatch(Int_t padrow)
1020{
1021 //get patch for padrow
1022 if(padrow < 0 || padrow >= fgNRow)
1023 {
1024 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetPatch","Padrow")
1025 <<AliHLTTPCLog::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1026 return -2;
1027 }
1028 Int_t patch=0;
1029 while(patch < fgNPatches)
1030 {
1031 if(padrow >= fgRows[patch][0] && padrow <= fgRows[patch][1])
1032 break;
1033 patch++;
1034 }
1035 return patch;
1036}
1037
1038Double_t AliHLTTPCTransform::GetPadLength(Int_t padrow)
1039{
1040 //get pad length for padrow
1041 if(padrow >= fgNRow){
1042 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetPadLength","Padrow")
1043 <<AliHLTTPCLog::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1044 return 0;
1045 }
1046
1047 if(padrow < fgNRowLow)
1048 return fgInnerPadLength;
1049 if(padrow >= fgNRowLow && padrow < fgNRowLow + fgNRowUp1 - 1)
1050 return fgOuter1PadLength;
1051 if(padrow >= fgNRowLow + fgNRowUp1 - 1)
1052 return fgOuter2PadLength;
1053
1054 //should never happen
1055 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetPadLength","Padrow")
1056 <<AliHLTTPCLog::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1057 return -1.0;
1058}
1059
1060Double_t AliHLTTPCTransform::GetPadPitchWidth(Int_t patch)
1061{
1062 //get pad patch width for patch
1063 if(patch < 0 || patch > fgNPatches)
1064 {
1065 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetPadPitchWidth","patct")
1066 <<AliHLTTPCLog::kDec<<"Wrong patch "<<patch<<ENDLOG;
1067 return -1;
1068 }
1069 return patch < 2 ? fgPadPitchWidthLow : fgPadPitchWidthUp;
1070}
1071
1072Double_t AliHLTTPCTransform::GetParSigmaY2(Int_t padrow,Float_t z,Float_t angle)
1073{
1074 //Calculate the expected transverse cluster width as a function of
1075 //drift distance and crossing angle.
1076 //z = local z-coordinate of cluster
1077 //angle = track crossing angle with normal to padrow plane
1078 //return value = sigma^2 (cartesian coordinates)
1079
1080 Double_t drift;
1081 if(z > 0)
1082 drift = fgZLength - z;
1083 else
1084 drift = fgZLength + z;
1085
1086 Double_t t1 = GetPRFSigma(padrow)*GetPRFSigma(padrow);
1087 Double_t t2 = fgDiffT*fgDiffT*drift;
1088 Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tan(angle)*tan(angle)/12;
1089 Double_t t4 = fgkAnodeWireSpacing*fgkAnodeWireSpacing*(tan(angle) - fgOmegaTau)*(tan(angle) - fgOmegaTau)/12;
1090
1091 return (t1 + t2 + t3 + t4);
1092}
1093
1094Double_t AliHLTTPCTransform::GetParSigmaZ2(Int_t padrow,Float_t z,Float_t tgl)
1095{
1096 //Calculate the expected longitudinal cluster width as a function of
1097 //drift distance and track crossing angle.
1098 //z = local z-coordinate of cluster
1099 //tgl = tan(dipangle)
1100 //return value = sigma^2 (cartesian coordinates)
1101
1102 Double_t drift;
1103 if(z > 0)
a1ec4d07 1104 drift = AliHLTTPCTransform::GetZLength()-0.275 - z;
a6c02c85 1105 else
a1ec4d07 1106 drift = AliHLTTPCTransform::GetZLength()-0.302 + z;
a6c02c85 1107
1108 Double_t t1 = fgZSigma*fgZSigma;
1109 Double_t t2 = fgDiffL*fgDiffL*drift;
1110 Double_t t3 = GetPadLength(padrow)*GetPadLength(padrow)*tgl*tgl/12;
1111
1112 return (t1 + t2 + t3);
1113}
1114
1115Double_t AliHLTTPCTransform::GetPRFSigma(Int_t padrow)
1116{
1117 //get sigma of pad response function for padrow
1118
1119 if(padrow >= fgNRow){
1120 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetPRFSigma","Padrow")
1121 <<AliHLTTPCLog::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1122 return 0;
1123 }
1124 if(padrow < fgNRowLow)
1125 return fgInnerPRFSigma;
1126 if(padrow >= fgNRowLow && padrow < fgNRowLow + fgNRowUp1 - 1)
1127 return fgOuter1PRFSigma;
1128 if(padrow >= fgNRowLow + fgNRowUp1 - 1)
1129 return fgOuter2PRFSigma;
1130
1131 //should never happen
1132 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetPRFSigma","Padrow")
1133 <<AliHLTTPCLog::kDec<<"Wrong padrow "<<padrow<<ENDLOG;
1134 return -1.;
1135}
1136
1137Double_t AliHLTTPCTransform::GetEta(Float_t *xyz)
1138{
1139 //get eta
1140 Double_t r3 = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1141 Double_t eta = 0.5 * log((r3+xyz[2])/(r3-xyz[2]));
1142 return eta;
1143}
1144
1145void AliHLTTPCTransform::XYZtoRPhiEta(Float_t *rpe, Float_t *xyz)
1146{
1147 //transform xyz into rpe
1148 rpe[0] = sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]+xyz[2]*xyz[2]);
1149 rpe[1] = atan2(xyz[1],xyz[0]);
1150 rpe[2] = 0.5 * log((rpe[0]+xyz[2])/(rpe[0]-xyz[2]));
1151}
1152
1153Double_t AliHLTTPCTransform::GetEta(Int_t slice,Int_t padrow,Int_t pad,Int_t time)
1154{
1155 //get eta
1156 Float_t xyz[3];
1157 Int_t sector,row;
1158 Slice2Sector(slice,padrow,sector,row);
1159 Raw2Local(xyz,sector,row,pad,time);
1160
1161 return GetEta(xyz);
1162}
1163
1164Double_t AliHLTTPCTransform::GetPhi(Float_t *xyz)
1165{
1166 //get phi
1167 Double_t phi = atan2(xyz[1],xyz[0]);
1168 return phi;
1169}
1170
1171Bool_t AliHLTTPCTransform::Slice2Sector(Int_t slice, Int_t slicerow, Int_t & sector, Int_t &row)
1172{
055fed30 1173 //slice no to sector number
1174 //row no to local sector row no
a6c02c85 1175 if(slicerow<0&&slicerow>=fgNRow){
1176 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::Slice2Sector","Slicerow")
1177 <<AliHLTTPCLog::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1178 return kFALSE;
1179 }
1180 if(slice<0||slice>=fgNSlice){
1181 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::Slice2Sector","Slice")
1182 <<AliHLTTPCLog::kDec<<"Wrong slice "<<slice<<ENDLOG;
1183 return kFALSE;
1184 }
1185
1186 if(slicerow<fgNRowLow){
1187 sector = fgSlice2Sector[slice][0];
1188 row = slicerow;
1189 }
1190 else {
1191 sector = fgSlice2Sector[slice][1];
1192 row = slicerow-fgNRowLow;
1193 }
1194
1195 return kTRUE;
1196}
1197
1198Bool_t AliHLTTPCTransform::Sector2Slice(Int_t & slice, Int_t sector)
1199{
1200 //sector to slice
1201 if(sector<0||sector>=fgNSector){
1202 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::Sector2Slice","Sector")
1203 <<AliHLTTPCLog::kDec<<"Wrong sector "<<sector<<ENDLOG;
1204 return kFALSE;
1205 }
1206
1207 slice=fgSector2Slice[sector];
1208
1209 return kTRUE;
1210}
1211
1212Bool_t AliHLTTPCTransform::Sector2Slice(Int_t & slice, Int_t & slicerow, Int_t sector, Int_t row)
1213{
1214 //sector to slice
1215 if(sector<0 || sector>=fgNSector){
1216 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::Sector2Slice","Sector")
1217 <<AliHLTTPCLog::kDec<<"Wrong sector "<<sector<<ENDLOG;
1218 return kFALSE;
1219 }
1220 if(row<0){
1221 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::Sector2Slice","Row")
1222 <<AliHLTTPCLog::kDec<<"Wrong row "<<row<<ENDLOG;
1223 return kFALSE;
1224 }
1225
1226 if(fgSectorLow[sector]){
1227 if(row>=fgNRowLow){
1228 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::Sector2Slice","Row")
1229 <<AliHLTTPCLog::kDec<<"Wrong row "<<row<<ENDLOG;
1230 return kFALSE;
1231 }
1232 slice = fgSector2Slice[sector];
1233 slicerow = row;
1234 }
1235 else{
1236 if(row>=fgNRowUp){
1237 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::Sector2Slice","Row")
1238 <<AliHLTTPCLog::kDec<<"Wrong row "<<row<<ENDLOG;
1239 return kFALSE;
1240 }
1241 slice = fgSector2Slice[sector];
1242 slicerow = row + fgNRowLow;
1243 }
1244
1245 return kTRUE;
1246}
1247
1248Double_t AliHLTTPCTransform::GetMaxY(Int_t slicerow)
1249{
1250 //get maximum y value (for slice 0)
42a3bb88 1251 if (slicerow>=fgNRow) {
1252 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetMaxY","Slicerow")
1253 <<AliHLTTPCLog::kDec<<"slicerow out of range"<<slicerow<<ENDLOG;
1254 }
a6c02c85 1255 if(slicerow < fgNRowLow)
1256 return fgPadPitchWidthLow*fgNPads[slicerow]/2;
1257
1258 else
1259 return fgPadPitchWidthUp*fgNPads[slicerow]/2;
1260
1261}
1262
1263Double_t AliHLTTPCTransform::Row2X(Int_t slicerow)
1264{
1265 //slicerow to X value (slice 0)
1266 if(slicerow<0||slicerow>=fgNRow){
1267 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::Row2X","Slicerow")
1268 <<AliHLTTPCLog::kDec<<"Wrong slicerow "<<slicerow<<ENDLOG;
1269 return 0;
1270 }
1271 return fgX[slicerow];
1272}
1273
1274Double_t AliHLTTPCTransform::GetZFast(Int_t slice, Int_t time, Float_t vertex)
1275{
1276 //get z value
1277 Double_t z=fgZWidth*time-fgZOffset;
1278 if(slice < 18)
1279 z=fgZLength-z-vertex;
1280 else
1281 z=z-fgZLength-vertex;
1282 return z;
1283}
1284
1285void AliHLTTPCTransform::Local2Global(Float_t *xyz,Int_t slice)
1286{
1287 //Transformation to global coordinate system
1288 Float_t x0 = xyz[0];
1289 Float_t y0 = xyz[1];
1290
1291 xyz[0]=x0*fgCos[slice]-y0*fgSin[slice];
1292 xyz[1]=x0*fgSin[slice]+y0*fgCos[slice];
1293 xyz[2]=xyz[2];//global z=local z
1294}
1295
1296void AliHLTTPCTransform::Local2GlobalAngle(Float_t *angle,Int_t slice)
1297{
1298 //get angle global
1299 angle[0] = fmod(angle[0]+(slice+fgNRotShift)*(2*fgkPi/18),2*fgkPi);
1300}
1301
1302void AliHLTTPCTransform::Global2LocalAngle(Float_t *angle,Int_t slice)
1303{
1304 //get angle local
1305 angle[0] = angle[0]-(slice+fgNRotShift)*(2*fgkPi/18);
1306 if(angle[0]<0) angle[0]+=2*fgkPi;
1307}
1308
1309void AliHLTTPCTransform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1310{
1311 //Transformation from rawdata to local coordinate system
1312
1313 Int_t slice,slicerow;
42a3bb88 1314 if (Sector2Slice(slice, slicerow, sector, row)==kFALSE) return;
a6c02c85 1315
1316 //X-Value
1317 xyz[0]=Row2X(slicerow);
1318
1319 //Y-Value
42a3bb88 1320 if (slicerow>=fgNRow) {
1321 LOG(AliHLTTPCLog::kError,"AliHLTTPCTransform::GetMaxY","Slicerow")
1322 <<AliHLTTPCLog::kDec<<"slicerow out of range"<<slicerow<<ENDLOG;
1323 return;
1324 }
a6c02c85 1325 Int_t npads= fgNPads[slicerow];
1326
1327 if(fgSectorLow[sector])
1328 xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthLow;
1329 else
1330 xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthUp;
1331
1332 //Z-Value (remember PULSA Delay)
1333 if(slice < 18)
42a3bb88 1334 xyz[2]=GetZLength()-GetZWidth()*time+GetZOffset();
a6c02c85 1335 else
42a3bb88 1336 xyz[2]=GetZWidth()*time-GetZOffset()-GetZLength();
a6c02c85 1337}
1338
1339void AliHLTTPCTransform::Raw2Local(Float_t *xyz,Int_t sector,Int_t row,Int_t pad,Int_t time)
1340{
1341 //Transformation from rawdata to local coordinate system
1342
1343 Int_t slice,slicerow;
1344 Sector2Slice(slice, slicerow, sector, row);
1345
1346 //X-Value
1347 xyz[0]=Row2X(slicerow);
1348
1349 //Y-Value
1350 Int_t npads= fgNPads[slicerow];
1351
1352 if(fgSectorLow[sector])
1353 xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthLow;
1354 else
1355 xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthUp;
1356
1357 //Z-Value (remember PULSA Delay)
1358 if(slice < 18)
42a3bb88 1359 xyz[2]=GetZLength()-GetZWidth()*time+GetZOffset();
a6c02c85 1360 else
42a3bb88 1361 xyz[2]=GetZWidth()*time-GetZOffset()-GetZLength();
a6c02c85 1362}
1363
1364void AliHLTTPCTransform::RawHLT2Local(Float_t *xyz,Int_t slice,
1365 Int_t slicerow,Float_t pad,Float_t time)
1366{
1367 //Transformation from HLT rawdata to local coordinate system
1368
1369 //X-Value
1370 xyz[0]=Row2X(slicerow);
1371
1372 //Y-Value
1373 Int_t npads= fgNPads[slicerow];
1374 if(slicerow<fgNRowLow)
1375 xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthLow;
1376 else
1377 xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthUp;
1378
1379 //Z-Value
1380 if(slice < 18)
42a3bb88 1381 xyz[2]=GetZLength()-GetZWidth()*time+GetZOffset();
a6c02c85 1382 else
42a3bb88 1383 xyz[2]=GetZWidth()*time-GetZOffset()-GetZLength();
a6c02c85 1384}
1385
1386void AliHLTTPCTransform::RawHLT2Local(Float_t *xyz,Int_t slice,
1387 Int_t slicerow,Int_t pad,Int_t time)
1388{
1389 //Transformation from HLT rawdata to local coordinate system
1390
1391 //X-Value
1392 xyz[0]=Row2X(slicerow);
1393
1394 //Y-Value
1395 Int_t npads= fgNPads[slicerow];
1396 if(slicerow<fgNRowLow)
1397 xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthLow;
1398 else
1399 xyz[1]=(pad-0.5*(npads-1))*fgPadPitchWidthUp;
1400
1401 //Z-Value
1402 if(slice < 18)
42a3bb88 1403 xyz[2]=GetZLength()-GetZWidth()*time+GetZOffset();
a6c02c85 1404 else
42a3bb88 1405 xyz[2]=GetZWidth()*time-GetZOffset()-GetZLength();
a6c02c85 1406}
1407
1408void AliHLTTPCTransform::Local2Global(Float_t *xyz,Int_t sector,Int_t row)
1409{
1410 //Transformation to global coordinate system
1411 Int_t slice,slicerow;
1412 Sector2Slice(slice, slicerow, sector, row);
1413 Float_t r=Row2X(slicerow); //have to get x value first
1414
1415 xyz[0]=r*fgCos[slice]-xyz[1]*fgSin[slice];
1416 xyz[1]=r*fgSin[slice]+xyz[1]*fgCos[slice];
1417 xyz[2]=xyz[2];//global z=local z
1418}
1419
1420void AliHLTTPCTransform::LocHLT2Global(Float_t *xyz,Int_t slice,Int_t slicerow)
1421{
1422 //Transformation from HLT to global coordinate system
1423 Float_t r=Row2X(slicerow); //have to get x value first
1424
1425 xyz[0]=r*fgCos[slice]-xyz[1]*fgSin[slice];
1426 xyz[1]=r*fgSin[slice]+xyz[1]*fgCos[slice];
1427 xyz[2]=xyz[2];//global z=local z
1428}
1429
1430void AliHLTTPCTransform::Global2Local(Float_t *xyz,Int_t sector)
1431{ //check code
1432 Int_t slice;
1433 Sector2Slice(slice, sector);
1434
1435 Float_t x1 = xyz[0]*fgCos[slice] + xyz[1]*fgSin[slice];
1436 Float_t y1 = -xyz[0]*fgSin[slice] + xyz[1]*fgCos[slice];
1437 xyz[0] = x1;
1438 xyz[1] = y1;
1439}
1440
1441void AliHLTTPCTransform::Global2LocHLT(Float_t *xyz,Int_t slice)
1442{
1443 Float_t x1 = xyz[0]*fgCos[slice] + xyz[1]*fgSin[slice];
1444 Float_t y1 = -xyz[0]*fgSin[slice] + xyz[1]*fgCos[slice];
1445 xyz[0] = x1;
1446 xyz[1] = y1;
1447}
1448
1449void AliHLTTPCTransform::Raw2Global(Float_t *xyz,Int_t sector,Int_t row,Float_t pad,Float_t time)
1450{
1451 //Transformation from raw to global coordinates
1452
1453 Raw2Local(xyz,sector,row,pad,time);
1454 Local2Global(xyz,sector,row);
1455}
1456
1457void AliHLTTPCTransform::Raw2Global(Float_t *xyz,Int_t sector,Int_t row,Int_t pad,Int_t time)
1458{
1459 //Transformation from raw to global coordinates
1460
1461 Raw2Local(xyz,sector,row,pad,time);
1462 Local2Global(xyz,sector,row);
1463}
1464
1465void AliHLTTPCTransform::RawHLT2Global(Float_t *xyz,Int_t slice,
1466 Int_t slicerow,Float_t pad,Float_t time)
1467{
1468 //Transformation from raw to global coordinates
1469
1470 RawHLT2Local(xyz,slice,slicerow,pad,time);
1471 LocHLT2Global(xyz,slice,slicerow);
1472}
1473
1474void AliHLTTPCTransform::RawHLT2Global(Float_t *xyz,Int_t slice,
1475 Int_t slicerow,Int_t pad,Int_t time)
1476{
1477 //Transformation from raw to global coordinates
1478
1479 RawHLT2Local(xyz,slice,slicerow,pad,time);
1480 LocHLT2Global(xyz,slice,slicerow);
1481}
1482
1483void AliHLTTPCTransform::Local2Raw(Float_t *xyz,Int_t sector,Int_t row)
1484{
1485 //Transformation from local coordinates to raw
1486
1487 Int_t slice,slicerow;
1488 Sector2Slice(slice, slicerow, sector, row);
1489
1490 xyz[0]=slicerow;
1491
1492 if(fgSectorLow[sector])
1493 xyz[1]=xyz[1]/fgPadPitchWidthLow+0.5*(fgNPads[slicerow]-1);
1494 else
1495 xyz[1]=xyz[1]/fgPadPitchWidthUp+0.5*(fgNPads[slicerow]-1);
1496
1497 if(slice < 18)
42a3bb88 1498 xyz[2]=(GetZLength()-xyz[2]+GetZOffset())/GetZWidth();
a6c02c85 1499 else
42a3bb88 1500 xyz[2]=(GetZLength()+xyz[2]+GetZOffset())/GetZWidth();
a6c02c85 1501}
1502
1503void AliHLTTPCTransform::LocHLT2Raw(Float_t *xyz,Int_t slice,Int_t slicerow)
1504{
1505 //Transformation from local coordinates to raw
1506
1507 xyz[0]=slicerow;
1508
1509 if(slicerow<fgNRowLow)
1510 xyz[1]=xyz[1]/fgPadPitchWidthLow+0.5*(fgNPads[slicerow]-1);
1511 else
1512 xyz[1]=xyz[1]/fgPadPitchWidthUp+0.5*(fgNPads[slicerow]-1);
1513
1514 if(slice < 18)
42a3bb88 1515 xyz[2]=(GetZLength()-xyz[2]+GetZOffset())/GetZWidth();
a6c02c85 1516 else
42a3bb88 1517 xyz[2]=(GetZLength()+xyz[2]+GetZOffset())/GetZWidth();
a6c02c85 1518}
1519
1520void AliHLTTPCTransform::Global2Raw(Float_t *xyz,Int_t sector,Int_t row)
1521{
1522 //Transformation from global coordinates to raw.
1523
1524 Global2Local(xyz,sector);
1525 Local2Raw(xyz,sector,row);
1526}
1527
1528void AliHLTTPCTransform::Global2HLT(Float_t *xyz,Int_t slice,Int_t slicerow)
1529{
1530 //Transformation from global coordinates to raw.
1531
1532 Global2LocHLT(xyz,slice);
1533 LocHLT2Raw(xyz,slice,slicerow);
1534}
1535
1536void AliHLTTPCTransform::PrintCompileOptions()
1537{
1538 //print compile options
1539#if defined(__GNUC__)
1540 cout << "Compiler (g++) version used: " << __GNUC__ << endl;
1541#endif
1542
1543#ifdef no_root
1544 cout << "STANDALONE version: -Dno_root was given." << endl;
1545#else
1546 const Char_t *roottest="$ROOTSYS/bin/root -n -b -q | grep Version | cut -b 17-25 | cut -d\" \" -f1";
1547#ifdef use_aliroot
1548#ifdef use_cvs
1549 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";
1550#else
1551 const Char_t *aliroottest="Unknown";
1552#endif
1553 cout << "ALIROOT version: -Duse_aliroot and -Duse_root was given." << endl;
1554 cout << "Root Version: " << ROOTVERSION << " found " << flush;
1555 gSystem->Exec(roottest);
1556
1557 cout << "AliRoot Version: " << ALIROOTVERSION << " found " << flush;
1558 gSystem->Exec(aliroottest);
1559#else
1560 cout << "ROOT version: -Duse_root was given." << endl;
1561 cout << "Root Version: " << ROOTVERSION << " found " << flush;
1562 gSystem->Exec(roottest);
1563#endif
1564#endif
1565
1566#ifdef do_mc
1567 cout << "Using Monte Carlo Info: -Ddo_mc was given." << endl;
1568#else
1569 cout << "NOT using Monte Carlo Info: -Ddo_mc was not given." << endl;
1570#endif
1571
1572#ifdef INCLUDE_TPC_HOUGH
1573 cout << "Including support for TPC Hough transformations." << endl;
1574#ifdef ROWHOUGHPARAMS
1575 cout << "Using extended AliHLTTPCTrackSegmentData: -DROWHOUGHPARAMS was given." << endl;
1576#else
1577 cout << "NOT using extended AliHLTTPCTrackSegmentData: -DROWHOUGHPARAMS was not given." << endl;
1578#endif
1579#else
1580 cout << "NOT including any support for TPC Hough transformations." << endl;
1581#endif // INCLUDE_TPC_HOUGH
1582
a6c02c85 1583}