- adjusting binning of pad histograms to make single pad cluster contribution and...
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCDataCompressorHelper.cxx
1 // @(#) $Id$
2 // Original: AliHLTDataCompressorHelper.cxx,v 1.5 2004/06/15 10:26:57 hristov Exp $
3
4 //**************************************************************************
5 //* This file is property of and copyright by the ALICE HLT Project        * 
6 //* ALICE Experiment at CERN, All rights reserved.                         *
7 //*                                                                        *
8 //* Primary Authors: Anders Vestbo                                         *
9 //*                  for The ALICE HLT Project.                            *
10 //*                                                                        *
11 //* Permission to use, copy, modify and distribute this software and its   *
12 //* documentation strictly for non-commercial purposes is hereby granted   *
13 //* without fee, provided that the above copyright notice appears in all   *
14 //* copies and that both the copyright notice and this permission notice   *
15 //* appear in the supporting documentation. The authors make no claims     *
16 //* about the suitability of this software for any purpose. It is          *
17 //* provided "as is" without express or implied warranty.                  *
18 //**************************************************************************
19
20 #include "AliHLTStdIncludes.h"
21 #include "AliHLTTPCRootTypes.h"
22 #include "AliHLTTPCTransform.h"
23
24 #include "AliHLTTPCDataCompressorHelper.h"
25
26 #if __GNUC__ >= 3
27 using namespace std;
28 #endif
29
30 //_____________________________________________________________
31 //
32 //  AliHLTTPCDataCompression
33 //
34 // Interface class; binary <-> AliROOT handling of TPC data compression classes.
35 //
36
37
38 ClassImp(AliHLTTPCDataCompressorHelper)
39
40 AliHLTTPCDataCompressorHelper::AliHLTTPCDataCompressorHelper() 
41 {
42 }
43
44 AliHLTTPCDataCompressorHelper::~AliHLTTPCDataCompressorHelper() 
45 {
46 }
47
48 Int_t AliHLTTPCDataCompressorHelper::fgNumTimeBits = 12;
49 Int_t AliHLTTPCDataCompressorHelper::fgNumPadBits = 12;
50 Int_t AliHLTTPCDataCompressorHelper::fgNumChargeBits = 14;
51 Int_t AliHLTTPCDataCompressorHelper::fgNumShapeBits = 14;
52 Float_t AliHLTTPCDataCompressorHelper::fgXYResidualStep1 = 0.03;
53 Float_t AliHLTTPCDataCompressorHelper::fgXYResidualStep2 = 0.03;
54 Float_t AliHLTTPCDataCompressorHelper::fgXYResidualStep3 = 0.03;
55 Float_t AliHLTTPCDataCompressorHelper::fgZResidualStep1 = 0.05;
56 Float_t AliHLTTPCDataCompressorHelper::fgZResidualStep2 = 0.05;
57 Float_t AliHLTTPCDataCompressorHelper::fgZResidualStep3 = 0.05;
58 Float_t AliHLTTPCDataCompressorHelper::fgXYWidthStep = 0.005;
59 Float_t AliHLTTPCDataCompressorHelper::fgZWidthStep = 0.005;
60 Int_t AliHLTTPCDataCompressorHelper::fgClusterCharge = 100;
61 Int_t AliHLTTPCDataCompressorHelper::fgNumPadBitsRemaining = 18;
62 Int_t AliHLTTPCDataCompressorHelper::fgNumTimeBitsRemaining = 19;
63 Int_t AliHLTTPCDataCompressorHelper::fgNumShapeBitsRemaining = 11;
64
65 void AliHLTTPCDataCompressorHelper::SetBitNumbers(Int_t pad,Int_t time,Int_t charge,Int_t shape)
66 {
67   // sets the numbers of bits
68   fgNumPadBits = pad;
69   fgNumTimeBits = time;
70   fgNumChargeBits = charge;
71   fgNumShapeBits = shape;
72 }
73
74 void AliHLTTPCDataCompressorHelper::SetTransverseResolutions(Float_t res1,Float_t res2,Float_t res3,Float_t width)
75 {
76   // sets the transverse resolution
77   fgXYResidualStep1 = res1;
78   fgXYResidualStep2 = res2;
79   fgXYResidualStep3 = res3;
80   fgXYWidthStep = width;
81 }
82
83 void AliHLTTPCDataCompressorHelper::SetLongitudinalResolutions(Float_t res1,Float_t res2,Float_t res3,Float_t width)
84 {
85   // sets the longitudinal resolution
86   fgZResidualStep1 = res1;
87   fgZResidualStep2 = res2;
88   fgZResidualStep3 = res3;
89   fgZWidthStep = width;
90 }
91
92 void AliHLTTPCDataCompressorHelper::SetRemainingBitNumbers(Int_t pad,Int_t time,Int_t shape)
93 {
94   // sets the numbers of remaining bits
95   fgNumPadBitsRemaining = pad;
96   fgNumTimeBitsRemaining = time;
97   fgNumShapeBitsRemaining = shape;
98 }
99
100 Float_t AliHLTTPCDataCompressorHelper::GetXYResidualStep(Int_t row) 
101 {
102   // gets the XY residual step
103   if(row < AliHLTTPCTransform::GetNRowLow())
104     return fgXYResidualStep1;
105   else if(row < AliHLTTPCTransform::GetNRowLow() + AliHLTTPCTransform::GetNRowUp1())
106     return fgXYResidualStep2;
107   else if(row < AliHLTTPCTransform::GetNRowLow() + AliHLTTPCTransform::GetNRowUp1() + AliHLTTPCTransform::GetNRowUp2())
108     return fgXYResidualStep3;
109   else
110     {
111       cerr<<"AliHLTTPCDataCompressorHelper::GetXYResidualStep : Wrong row number "<<row<<endl;
112       return -1;
113     }
114 }
115
116 Float_t AliHLTTPCDataCompressorHelper::GetZResidualStep(Int_t row) 
117 {
118   // gets the Z residual step
119   if(row < AliHLTTPCTransform::GetNRowLow())
120     return fgZResidualStep1;
121   else if(row < AliHLTTPCTransform::GetNRowLow() + AliHLTTPCTransform::GetNRowUp1())
122     return fgZResidualStep2;
123   else if(row < AliHLTTPCTransform::GetNRowLow() + AliHLTTPCTransform::GetNRowUp1() + AliHLTTPCTransform::GetNRowUp2())
124     return fgZResidualStep3;
125   else
126     {
127       cerr<<"AliHLTTPCDataCompressorHelper::GetXYResidualStep : Wrong row number "<<row<<endl;
128       return -1;
129     }
130 }
131
132 Float_t AliHLTTPCDataCompressorHelper::GetPadPrecisionFactor()
133 {
134   // gets pad precision factor
135   Int_t nbits = fgNumPadBitsRemaining;
136   if(nbits >=21)
137     return 10000;
138   if(nbits >= 18)
139     return 1000;
140   if(nbits >= 14) 
141     return 100;
142   if(nbits >= 11)
143     return 10;
144   if(nbits >= 8)
145     return 1;
146   else 
147     {
148       cerr<<"AliHLTTPCDataCompressorHelper::GetRemainingPadFactor : Too few bits for the pad direction: "<<nbits<<endl;
149       return 1;
150     }
151 }
152
153 Float_t AliHLTTPCDataCompressorHelper::GetTimePrecisionFactor()
154 {
155   // gest time precision factor
156   Int_t nbits = fgNumTimeBitsRemaining;
157   if(nbits >=23)
158     return 10000;
159   if(nbits >= 19)
160     return 1000;
161   if(nbits >= 16) 
162     return 100;
163   if(nbits >= 13)
164     return 10;
165   if(nbits >= 9)
166     return 1;
167   else 
168     {
169       cerr<<"AliHLTTPCDataCompressorHelper::GetRemainingPadFactor : Too few bits for the pad direction: "<<nbits<<endl;
170       return 1;
171     }
172 }
173
174
175 Int_t AliHLTTPCDataCompressorHelper::Nint(Double_t x)
176 {
177    // Round to nearest integer. Rounds half integers 
178    // to the nearest even integer.
179
180    Int_t i=0;
181    if (x >= 0) {
182       i = Int_t(x + 0.5);
183       if (x + 0.5 == Double_t(i) && i & 1) i--;
184    } else {
185       i = Int_t(x - 0.5);
186       if (x - 0.5 == Double_t(i) && i & 1) i++;
187
188    }
189    return i;
190 }