AliRoot Core  v5-06-15 (45dab64)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliMUONSparseHisto.cxx
Go to the documentation of this file.
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"
19 
20 #include "AliLog.h"
21 #include <Riostream.h>
22 #include <TH1.h>
23 #include <TMath.h>
24 #include <TString.h>
25 
34 
35 using std::cout;
36 using std::endl;
40 
41 //______________________________________________________________________________
42 AliMUONSparseHisto::AliMUONSparseHisto(Double_t xmin, Double_t xmax)
43 : TObject(),
44 fNbins(0),
45 fArray(0x0),
46 fXmin(xmin),
47 fXmax(xmax),
48 fFactor((1<<Nbits())/(xmax-xmin))
49 {
51  SetBit(kOverflow,0);
52  SetBit(kUnderflow,0);
53 }
54 
55 //______________________________________________________________________________
57 : TObject(rhs),
58 fNbins(0),
59 fArray(0x0),
60 fXmin(0.0),
61 fXmax(0.0),
62 fFactor(0.0)
63 {
65  rhs.Copy(*this);
66 }
67 
68 //______________________________________________________________________________
71 {
73  if ( this != &rhs )
74  {
75  rhs.Copy(*this);
76  }
77  return *this;
78 }
79 
80 //______________________________________________________________________________
82 {
84  delete[] fArray;
85 }
86 
87 //______________________________________________________________________________
88 Bool_t
90 {
92 
93  if ( fXmin != h.Xmin() || fXmax != h.Xmax() )
94  {
95  AliError("Cannot add sparse histograms with different limits !");
96  return kFALSE;
97  }
98 
99  for ( Int_t i = 0; i < h.GetNbins(); ++i )
100  {
101  Fill(h.GetBinContent(i));
102  }
103 
104  return kTRUE;
105 }
106 
107 //______________________________________________________________________________
108 void
110 {
112  delete[] fArray;
113  fArray = 0x0;
114  fNbins = 0;
115 }
116 
117 //______________________________________________________________________________
118 void
119 AliMUONSparseHisto::Copy(TObject& object) const
120 {
122  TObject::Copy(object);
123  AliMUONSparseHisto& h = static_cast<AliMUONSparseHisto&>(object);
124  delete[] h.fArray;
125  h.fArray = 0x0;
126  h.fNbins = GetNbins();
127  h.fXmin = Xmin();
128  h.fXmax = Xmax();
129  h.fFactor = Factor();
130 
131  if ( GetNbins() > 0 )
132  {
133  h.fArray = new UInt_t[GetNbins()];
134  for ( Int_t i = 0; i < GetNbins(); ++i )
135  {
136  h.fArray[i] = GetBin(i);
137  }
138  }
139 }
140 
141 //______________________________________________________________________________
142 Double_t
144 {
146  return value/Factor() + Xmin();
147 }
148 
149 //______________________________________________________________________________
150 Int_t
151 AliMUONSparseHisto::EncodeValue(Double_t value) const
152 {
154  return TMath::Nint(Factor()*(value-Xmin()));
155 }
156 
157 //______________________________________________________________________________
158 Int_t
160 {
162 
163  return ( x & 0xFFF00000 ) >> 20;
164 }
165 
166 //______________________________________________________________________________
167 Int_t
169 {
171 
172  return (x & 0xFFFFF);
173 }
174 
175 //______________________________________________________________________________
176 UInt_t
177 AliMUONSparseHisto::Encode(Int_t binCenter, Int_t binContent) const
178 {
180 
181  return ( ( binCenter & 0xFFF ) ) << 20 | ( ( binContent & 0xFFFFF ) );
182 }
183 
184 //______________________________________________________________________________
185 void
187 {
189  if (!fArray || !fNbins)
190  {
191  delete[] fArray;
192  fArray = new UInt_t[1];
193  fNbins = 1;
194  }
195  else
196  {
197  UInt_t* tmp = new UInt_t[fNbins+1];
198  for ( Int_t i = 0; i < fNbins; ++i )
199  {
200  tmp[i] = fArray[i];
201  }
202  delete[] fArray;
203  fArray = tmp;
204  ++fNbins;
205  }
206 }
207 
208 //______________________________________________________________________________
209 Int_t
211 {
213 
214  if ( value < Xmin() )
215  {
216  SetBit(kUnderflow,1);
217  return -1;
218  }
219 
220  if ( value > Xmax() )
221  {
222  SetBit(kOverflow,1);
223  return -1;
224  }
225 
226  Int_t ivalue = EncodeValue(value);
227 
228  Int_t i = Find(ivalue);
229 
230  if ( i < 0 )
231  {
232  Int_t n = fNbins;
233  Expand();
234  fArray[n] = Encode(ivalue,1);
235  i = n;
236  }
237  else
238  {
239  Int_t bc = GetBinContent(i);
240  if ( bc < 0xFFFFF )
241  {
242  fArray[i] = Encode(ivalue,bc+1);
243  }
244  }
245 
246  return i;
247 }
248 
249 //______________________________________________________________________________
250 Int_t
251 AliMUONSparseHisto::Find(Int_t binCenter) const
252 {
254 
255  for ( Int_t i = 0; i < GetNbins(); ++i )
256  {
257  if ( binCenter == GetBinCenter(i) ) return i;
258  }
259  return -1;
260 }
261 
262 //______________________________________________________________________________
263 UInt_t
265 {
268  return fArray[bin];
269 }
270 
271 //______________________________________________________________________________
272 Double_t
274 {
276  if ( bin < 0 ) return -FLT_MAX;
277  if ( bin >= GetNbins() ) return FLT_MAX;
278 
279  UInt_t i = GetBin(bin);
280 
281  return DecodeValue(BinCenter(i));
282 }
283 
284 //______________________________________________________________________________
285 Int_t
287 {
289 
290  if ( bin < 0 || bin >= GetNbins() ) return 0xFFFFFFFF;
291 
292  UInt_t i = GetBin(bin);
293 
294  return BinContent(i);
295 }
296 
297 //______________________________________________________________________________
298 void
299 AliMUONSparseHisto::Print(Option_t* opt) const
300 {
302  Int_t id1 = ( GetUniqueID() & 0xFFFF0000 ) >> 16;
303  Int_t id2 = GetUniqueID() & 0xFFFF;
304 
305  cout << "ID=(" << id1 << "," << id2 << ") n bins = " << GetNbins();
306  if ( HasUnderflow() ) cout << " has underflow(s)";
307  if ( HasOverflow() ) cout << " has overflow(s)";
308  cout << endl;
309 
310  TString sopt(opt);
311  sopt.ToUpper();
312 
313  if ( sopt.Contains("FULL") )
314  {
315  for ( Int_t i = 0; i < GetNbins(); ++i )
316  {
317  cout << Form("Bin (%10u) %e = %6d",GetBin(i),GetBinCenter(i),GetBinContent(i)) << endl;
318  }
319  }
320 }
AliMUONSparseHisto & operator=(const AliMUONSparseHisto &rhs)
virtual void Print(Option_t *opt="") const
Bool_t HasOverflow() const
Int_t EncodeValue(Double_t value) const
Int_t GetNbins() const
Return number of bins we hold.
AliMUONSparseHisto(Double_t xmin=0.0, Double_t xmax=4096.0)
Double_t DecodeValue(Int_t value) const
UInt_t * fArray
compacted content = (bin,value)
Double_t Xmax() const
Return max value of bincenter.
Double_t GetBinCenter(Int_t bin) const
Int_t fNbins
number of bins we hold
Double_t fFactor
to go from double to int
Bool_t HasUnderflow() const
virtual void Copy(TObject &object) const
Double_t Factor() const
Conversion factor to go from float to int value (for bin content)
ClassImp(TPCGenInfo)
Definition: AliTPCCmpNG.C:254
Int_t GetBinContent(Int_t bin) const
Int_t Find(Int_t binCenter) const
Int_t BinContent(UInt_t x) const
Int_t BinCenter(UInt_t x) const
A very memory compact histogram to hold some tracker distributions.
Double_t fXmin
min value of bincenter
Int_t Fill(Double_t value)
UInt_t GetBin(Int_t i) const
UInt_t Encode(Int_t binCenter, Int_t binContent) const
Double_t fXmax
max value of bincenter
Double_t Xmin() const
Return min value of bincenter.
Bool_t Add(const AliMUONSparseHisto &h)
virtual void Clear(Option_t *opt="")