]>
Commit | Line | Data |
---|---|---|
8741815f | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | // $Id$ | |
17 | ||
18 | #include "AliMUONSparseHisto.h" | |
10eb3d17 | 19 | |
8741815f | 20 | #include <Riostream.h> |
21 | #include <TH1.h> | |
10eb3d17 | 22 | #include <TMath.h> |
23 | #include <TString.h> | |
8741815f | 24 | |
25 | /// \class AliMUONSparseHisto | |
26 | /// | |
10eb3d17 | 27 | /// Tiny histogram-like class to hold some distributions of tracker data. |
8741815f | 28 | /// Only intent of this class is to minimize memory consumption, in |
29 | /// order to fit a maximum number of channel histograms into memory. | |
30 | /// The rest is not supported ;-) | |
31 | /// | |
32 | /// \author Laurent Aphecetche, Subatech | |
33 | ||
34 | /// \cond CLASSIMP | |
35 | ClassImp(AliMUONSparseHisto) | |
36 | /// \endcond | |
37 | ||
38 | //______________________________________________________________________________ | |
10eb3d17 | 39 | AliMUONSparseHisto::AliMUONSparseHisto(Double_t xmin, Double_t xmax) |
8741815f | 40 | : TObject(), |
41 | fNbins(0), | |
10eb3d17 | 42 | fArray(0x0), |
43 | fXmin(xmin), | |
44 | fXmax(xmax), | |
45 | fFactor((1<<Nbits())/(xmax-xmin)) | |
8741815f | 46 | { |
47 | /// ctor | |
10eb3d17 | 48 | SetBit(kOverflow,0); |
49 | SetBit(kUnderflow,0); | |
8741815f | 50 | } |
51 | ||
52 | //______________________________________________________________________________ | |
53 | AliMUONSparseHisto::AliMUONSparseHisto(const AliMUONSparseHisto& rhs) | |
54 | : TObject(rhs), | |
55 | fNbins(0), | |
10eb3d17 | 56 | fArray(0x0), |
57 | fXmin(0.0), | |
58 | fXmax(0.0), | |
59 | fFactor(0.0) | |
8741815f | 60 | { |
61 | /// copy ctor | |
62 | rhs.Copy(*this); | |
63 | } | |
64 | ||
65 | //______________________________________________________________________________ | |
66 | AliMUONSparseHisto& | |
67 | AliMUONSparseHisto::operator=(const AliMUONSparseHisto& rhs) | |
68 | { | |
69 | /// assignment operator | |
70 | if ( this != &rhs ) | |
71 | { | |
72 | rhs.Copy(*this); | |
73 | } | |
74 | return *this; | |
75 | } | |
76 | ||
77 | //______________________________________________________________________________ | |
78 | AliMUONSparseHisto::~AliMUONSparseHisto() | |
79 | { | |
80 | /// dtor | |
81 | delete[] fArray; | |
82 | } | |
83 | ||
84 | //______________________________________________________________________________ | |
85 | void | |
86 | AliMUONSparseHisto::Clear(Option_t*) | |
87 | { | |
88 | /// Reset the content | |
89 | delete[] fArray; | |
90 | fArray = 0x0; | |
91 | fNbins = 0; | |
92 | } | |
93 | ||
94 | //______________________________________________________________________________ | |
95 | void | |
96 | AliMUONSparseHisto::Copy(TObject& object) const | |
97 | { | |
98 | /// Copy this to *object | |
99 | TObject::Copy(object); | |
100 | AliMUONSparseHisto& h = static_cast<AliMUONSparseHisto&>(object); | |
101 | delete[] h.fArray; | |
102 | h.fArray = 0x0; | |
103 | h.fNbins = GetNbins(); | |
10eb3d17 | 104 | h.fXmin = Xmin(); |
105 | h.fXmax = Xmax(); | |
106 | h.fFactor = Factor(); | |
107 | ||
8741815f | 108 | if ( GetNbins() > 0 ) |
109 | { | |
10eb3d17 | 110 | h.fArray = new UInt_t[GetNbins()]; |
8741815f | 111 | for ( Int_t i = 0; i < GetNbins(); ++i ) |
112 | { | |
10eb3d17 | 113 | h.fArray[i] = GetBin(i); |
8741815f | 114 | } |
115 | } | |
116 | } | |
117 | ||
118 | //______________________________________________________________________________ | |
10eb3d17 | 119 | Double_t |
120 | AliMUONSparseHisto::DecodeValue(Int_t value) const | |
8741815f | 121 | { |
10eb3d17 | 122 | /// From internal integer to "original" double |
123 | return value/Factor() + Xmin(); | |
8741815f | 124 | } |
125 | ||
126 | //______________________________________________________________________________ | |
127 | Int_t | |
10eb3d17 | 128 | AliMUONSparseHisto::EncodeValue(Double_t value) const |
129 | { | |
130 | /// From original double value to internal integer | |
131 | return TMath::Nint(Factor()*(value-Xmin())); | |
132 | } | |
133 | ||
134 | //______________________________________________________________________________ | |
135 | Int_t | |
136 | AliMUONSparseHisto::BinCenter(UInt_t x) const | |
137 | { | |
138 | /// Extract binCenter part from x | |
139 | ||
140 | return ( x & 0xFFF00000 ) >> 20; | |
141 | } | |
142 | ||
143 | //______________________________________________________________________________ | |
144 | Int_t | |
145 | AliMUONSparseHisto::BinContent(UInt_t x) const | |
8741815f | 146 | { |
10eb3d17 | 147 | /// Extract binContent part from x |
148 | ||
149 | return (x & 0xFFFFF); | |
150 | } | |
151 | ||
152 | //______________________________________________________________________________ | |
153 | UInt_t | |
154 | AliMUONSparseHisto::Encode(Int_t binCenter, Int_t binContent) const | |
155 | { | |
156 | /// Convert (binCenter,binContent) into a single value | |
157 | ||
158 | return ( ( binCenter & 0xFFF ) ) << 20 | ( ( binContent & 0xFFFFF ) ); | |
8741815f | 159 | } |
160 | ||
161 | //______________________________________________________________________________ | |
162 | void | |
163 | AliMUONSparseHisto::Expand() | |
164 | { | |
165 | /// Make fArray of size n | |
166 | if (!fArray || !fNbins) | |
167 | { | |
168 | delete[] fArray; | |
10eb3d17 | 169 | fArray = new UInt_t[1]; |
8741815f | 170 | fNbins = 1; |
171 | } | |
172 | else | |
173 | { | |
10eb3d17 | 174 | UInt_t* tmp = new UInt_t[fNbins+1]; |
8741815f | 175 | for ( Int_t i = 0; i < fNbins; ++i ) |
176 | { | |
177 | tmp[i] = fArray[i]; | |
178 | } | |
179 | delete[] fArray; | |
180 | fArray = tmp; | |
181 | ++fNbins; | |
182 | } | |
183 | } | |
184 | ||
185 | //______________________________________________________________________________ | |
186 | Int_t | |
10eb3d17 | 187 | AliMUONSparseHisto::Fill(Double_t value) |
8741815f | 188 | { |
189 | /// Fill | |
190 | ||
10eb3d17 | 191 | if ( value < Xmin() ) |
192 | { | |
193 | SetBit(kUnderflow,1); | |
194 | return -1; | |
195 | } | |
196 | ||
197 | if ( value > Xmax() ) | |
198 | { | |
199 | SetBit(kOverflow,1); | |
200 | return -1; | |
201 | } | |
202 | ||
203 | Int_t ivalue = EncodeValue(value); | |
8741815f | 204 | |
10eb3d17 | 205 | Int_t i = Find(ivalue); |
8741815f | 206 | |
207 | if ( i < 0 ) | |
208 | { | |
209 | Int_t n = fNbins; | |
210 | Expand(); | |
10eb3d17 | 211 | fArray[n] = Encode(ivalue,1); |
8741815f | 212 | i = n; |
213 | } | |
214 | else | |
215 | { | |
10eb3d17 | 216 | Int_t bc = GetBinContent(i); |
217 | if ( bc < 0xFFFFF ) | |
218 | { | |
219 | fArray[i] = Encode(ivalue,bc+1); | |
220 | } | |
8741815f | 221 | } |
222 | ||
223 | return i; | |
224 | } | |
225 | ||
226 | //______________________________________________________________________________ | |
227 | Int_t | |
10eb3d17 | 228 | AliMUONSparseHisto::Find(Int_t binCenter) const |
8741815f | 229 | { |
10eb3d17 | 230 | /// Return the index in fArray of value, or -1 if not found |
231 | ||
8741815f | 232 | for ( Int_t i = 0; i < GetNbins(); ++i ) |
233 | { | |
10eb3d17 | 234 | if ( binCenter == GetBinCenter(i) ) return i; |
8741815f | 235 | } |
236 | return -1; | |
237 | } | |
238 | ||
10eb3d17 | 239 | //______________________________________________________________________________ |
240 | UInt_t | |
241 | AliMUONSparseHisto::GetBin(Int_t bin) const | |
242 | { | |
243 | /// Get bin, which is a compacted form of two integers : (binCenter,binContent) | |
244 | /// where binCenter itself might be an integer-fied double value. | |
245 | return fArray[bin]; | |
246 | } | |
247 | ||
248 | //______________________________________________________________________________ | |
249 | Double_t | |
250 | AliMUONSparseHisto::GetBinCenter(Int_t bin) const | |
251 | { | |
252 | /// Get bin center | |
253 | if ( bin < 0 ) return -FLT_MAX; | |
254 | if ( bin >= GetNbins() ) return FLT_MAX; | |
255 | ||
256 | UInt_t i = GetBin(bin); | |
257 | ||
258 | return DecodeValue(BinCenter(i)); | |
259 | } | |
260 | ||
8741815f | 261 | //______________________________________________________________________________ |
262 | Int_t | |
263 | AliMUONSparseHisto::GetBinContent(Int_t bin) const | |
264 | { | |
10eb3d17 | 265 | /// Get bin content |
266 | ||
267 | if ( bin < 0 || bin >= GetNbins() ) return 0xFFFFFFFF; | |
268 | ||
269 | UInt_t i = GetBin(bin); | |
270 | ||
271 | return BinContent(i); | |
8741815f | 272 | } |
273 | ||
274 | //______________________________________________________________________________ | |
275 | void | |
276 | AliMUONSparseHisto::Print(Option_t* opt) const | |
277 | { | |
278 | /// Printout | |
279 | Int_t id1 = ( GetUniqueID() & 0xFFFF0000 ) >> 16; | |
280 | Int_t id2 = GetUniqueID() & 0xFFFF; | |
281 | ||
10eb3d17 | 282 | cout << "ID=(" << id1 << "," << id2 << ") n bins = " << GetNbins(); |
283 | if ( HasUnderflow() ) cout << " has underflow(s)"; | |
284 | if ( HasOverflow() ) cout << " has overflow(s)"; | |
285 | cout << endl; | |
8741815f | 286 | |
287 | TString sopt(opt); | |
288 | sopt.ToUpper(); | |
289 | ||
290 | if ( sopt.Contains("FULL") ) | |
291 | { | |
292 | for ( Int_t i = 0; i < GetNbins(); ++i ) | |
293 | { | |
10eb3d17 | 294 | cout << Form("Bin (%10u) %e = %6d",GetBin(i),GetBinCenter(i),GetBinContent(i)) << endl; |
8741815f | 295 | } |
296 | } | |
297 | } |