Adding code to patch St1 HV mapping
[u/mrichter/AliRoot.git] / MUON / AliMUONCalibParamNI.cxx
CommitLineData
96fea1fd 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 "AliMUONCalibParamNI.h"
19
20#include "AliLog.h"
21
22#include "Riostream.h"
23#include "TMath.h"
24#include "TString.h"
25
3d1463c8 26//-----------------------------------------------------------------------------
96fea1fd 27/// \class AliMUONCalibParamNI
28///
29/// Handle the case of N integer parameters per channel.
30///
31/// Almost the same class as AliMUONCalibParamNF, but for ints.
32/// We could have played with NF to store both int and float (using casts),
33/// but for the sake of simplicity (e.g. the Print method must know whether
34/// it should print floats or ints), we decided to "duplicate" the class
35/// and use the correct type.
36///
37/// \author Laurent Aphecetche
3d1463c8 38//-----------------------------------------------------------------------------
96fea1fd 39
b80faac0 40using std::cout;
41using std::endl;
96fea1fd 42/// \cond CLASSIMP
43ClassImp(AliMUONCalibParamNI)
44/// \endcond
45
46//_____________________________________________________________________________
47AliMUONCalibParamNI::AliMUONCalibParamNI()
48: AliMUONVCalibParam(),
49 fDimension(0),
50 fSize(0),
51 fN(0),
52 fPackingFactor(0),
53 fValues(0x0)
54{
55/// Default constructor.
a1546c3a 56 AliDebug(1,Form("this=%p default ctor",this));
96fea1fd 57}
58
59//_____________________________________________________________________________
a1546c3a 60AliMUONCalibParamNI::AliMUONCalibParamNI(Int_t dimension, Int_t theSize,
61 Int_t id0, Int_t id1,
96fea1fd 62 Int_t fillWithValue, Int_t packingFactor)
a1546c3a 63: AliMUONVCalibParam(id0,id1),
96fea1fd 64 fDimension(dimension),
65 fSize(theSize),
66 fN(fSize*fDimension),
67 fPackingFactor(packingFactor),
68 fValues(0x0)
69{
70/// Normal constructor, where theSize specifies the number of channels handled
71/// by this object, and fillWithValue the default value assigned to each
72/// channel.
73
4db2bfee 74// AliDebug(1,Form("this=%p dimension=%d theSize=%d fillWithValue=%d packingFactor=%d",
75// this,dimension,theSize,fillWithValue,packingFactor));
a1546c3a 76
96fea1fd 77 if ( fN > 0 )
78 {
79 fValues = new Int_t[fN];
80 for ( Int_t i = 0; i < fN; ++i )
81 {
82 fValues[i] = fillWithValue;
83 }
84 }
85}
86
87
88//_____________________________________________________________________________
89AliMUONCalibParamNI::AliMUONCalibParamNI(const AliMUONCalibParamNI& other)
90: AliMUONVCalibParam(),
91fDimension(0),
92fSize(0),
93fN(0),
94fPackingFactor(0),
95fValues(0x0)
96{
97/// Copy constructor.
98
a1546c3a 99 AliDebug(1,Form("this=%p copy ctor",this));
96fea1fd 100 other.CopyTo(*this);
101}
102
103//_____________________________________________________________________________
104AliMUONCalibParamNI&
105AliMUONCalibParamNI::operator=(const AliMUONCalibParamNI& other)
106{
107/// Assignment operator
108
109 other.CopyTo(*this);
110 return *this;
111}
112
113//_____________________________________________________________________________
114AliMUONCalibParamNI::~AliMUONCalibParamNI()
115{
116/// Destructor
117
a1546c3a 118 AliDebug(1,Form("this=%p",this));
96fea1fd 119 delete[] fValues;
120}
121
122//_____________________________________________________________________________
123void
124AliMUONCalibParamNI::CopyTo(AliMUONCalibParamNI& destination) const
125{
126/// Copy *this to destination
127
a1546c3a 128 const TObject& o = static_cast<const TObject&>(*this);
129 o.Copy(destination);
130
96fea1fd 131 delete[] destination.fValues;
132 destination.fN = fN;
133 destination.fSize = fSize;
134 destination.fDimension = fDimension;
135 destination.fPackingFactor = fPackingFactor;
136
137 if ( fN > 0 )
138 {
139 destination.fValues = new Int_t[fN];
140 for ( Int_t i = 0; i < fN; ++i )
141 {
142 destination.fValues[i] = fValues[i];
143 }
144 }
145}
146
147//_____________________________________________________________________________
148Int_t
149AliMUONCalibParamNI::Index(Int_t i, Int_t j) const
150{
151/// Compute the 1D index of the internal storage from the pair (i,j)
152/// Returns -1 if the (i,j) pair is invalid
153
154 if ( i >= 0 && i < Size() && j >= 0 && j < Dimension() )
155 {
4db2bfee 156 return IndexFast(i,j);
96fea1fd 157 }
158 return -1;
159}
160
161//_____________________________________________________________________________
4db2bfee 162Int_t
163AliMUONCalibParamNI::IndexFast(Int_t i, Int_t j) const
164{
165 /// Compute the 1D index of the internal storage from the pair (i,j)
166
167 return i + Size()*j;
168}
169
170//_____________________________________________________________________________
96fea1fd 171void
172AliMUONCalibParamNI::Print(Option_t* opt) const
173{
174/// Output this object to stdout.
175/// If opt=="full" then all channels are printed,
176/// if opt=="mean#", only the mean and sigma value are printed for j-th dimension
177/// otherwise only the general characteristics are printed.
178
179 TString sopt(opt);
180 sopt.ToUpper();
181 cout << "AliMUONCalibParamNI - Size=" << Size()
a1546c3a 182 << " Dimension=" << Dimension()
183 << " Id=(" << ID0() << "," << ID1() << ")";
184
96fea1fd 185 if ( IsPacked() )
186 {
187 cout << " Packing Factor=" << fPackingFactor;
188 }
189 cout << endl;
190
191 if ( sopt.Contains("FULL") )
192 {
193 for ( Int_t i = 0; i < Size(); ++i )
194 {
195 cout << Form("CH %3d",i);
196 for ( Int_t j = 0; j < Dimension(); ++j )
197 {
198 Int_t v = ValueAsInt(i,j);
199 if ( IsPacked() )
200 {
201 Int_t m,c;
202 UnpackValue(v,m,c);
a1546c3a 203 cout << Form(" (%d,%d) (0x%x,0x%x)",m,c,m,c);
96fea1fd 204 }
205 else
206 {
a1546c3a 207 cout << Form(" %d (0x%x)",v,v);
96fea1fd 208 }
209 }
210 cout << endl;
211 }
212 }
213 if ( sopt.Contains("MEAN") )
214 {
215 Int_t j(0);
216 sscanf(sopt.Data(),"MEAN%d",&j);
217
218 Float_t mean(0);
219 Float_t v2(0);
220
221 Int_t n = Size();
222
223 for ( Int_t i = 0; i < Size(); ++i )
224 {
225 Float_t v = ValueAsFloat(i,j);
226 mean += v;
227 v2 += v*v;
228 }
229 mean /= n;
230 float sigma = 0;
231 if ( n > 1 ) sigma = TMath::Sqrt( (v2-n*mean*mean)/(n-1) );
232 cout << Form(" Mean(j=%d)=%e Sigma(j=%d)=%e",j,mean,j,sigma) << endl;
233 }
234
235}
236
237//_____________________________________________________________________________
238void
239AliMUONCalibParamNI::SetValueAsInt(Int_t i, Int_t j, Int_t value)
240{
241/// Set one value as a float, after checking that the indices are correct.
242
243 Int_t ix = Index(i,j);
244
245 if ( ix < 0 )
246 {
247 AliError(Form("Invalid (i,j)=(%d,%d) max allowed is (%d,%d)",
248 i,j,Size()-1,Dimension()-1));
249 }
250 else
251 {
252 fValues[ix]=value;
253 }
254}
255
256//_____________________________________________________________________________
257void
4db2bfee 258AliMUONCalibParamNI::SetValueAsIntFast(Int_t i, Int_t j, Int_t value)
259{
260 /// Set one value as a float, w/o checking that the indices are correct.
261
262 fValues[IndexFast(i,j)] = value;
263}
264
265//_____________________________________________________________________________
266void
96fea1fd 267AliMUONCalibParamNI::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
268{
269 /// Set one value as an int.
270
271 AliWarning("Float will be rounded to be stored...");
272 SetValueAsInt(i,j,TMath::Nint(value));
273}
274
275//_____________________________________________________________________________
4db2bfee 276void
277AliMUONCalibParamNI::SetValueAsFloatFast(Int_t i, Int_t j, Float_t value)
278{
279 /// Set one value as an int.
280
281 AliWarning("Float will be rounded to be stored...");
282 SetValueAsIntFast(i,j,TMath::Nint(value));
283}
284
285
286//_____________________________________________________________________________
96fea1fd 287Int_t
288AliMUONCalibParamNI::ValueAsInt(Int_t i, Int_t j) const
289{
290/// Return the value as an int (which it is), after checking indices.
291
292 Int_t ix = Index(i,j);
293
294 if ( ix < 0 )
295 {
296 AliError(Form("Invalid (i,j)=(%d,%d) max allowed is (%d,%d)",
297 i,j,Size()-1,Dimension()-1));
298 return 0;
299 }
300 else
301 {
302 return fValues[ix];
303 }
304}
305
306//_____________________________________________________________________________
4db2bfee 307Int_t
308AliMUONCalibParamNI::ValueAsIntFast(Int_t i, Int_t j) const
309{
310 /// Return the value as an int (which it is), w/o checking indices.
311
312 return fValues[IndexFast(i,j)];
313}
314
315//_____________________________________________________________________________
96fea1fd 316Float_t
317AliMUONCalibParamNI::ValueAsFloat(Int_t i, Int_t j) const
318{
319 /// Return the value as a float
320 return static_cast<Float_t>(ValueAsInt(i,j));
321}
322
323//_____________________________________________________________________________
4db2bfee 324Float_t
325AliMUONCalibParamNI::ValueAsFloatFast(Int_t i, Int_t j) const
326{
327 /// Return the value as a float
328 return static_cast<Float_t>(ValueAsIntFast(i,j));
329}
330
331//_____________________________________________________________________________
96fea1fd 332Bool_t
333AliMUONCalibParamNI::UnpackValue(Int_t value, Int_t& a, Int_t& b) const
334{
335 /// Unpack single value into a couple (a,b), using packingFactor
336 /// Returns false if IsPacked()==false
337
338 if ( !IsPacked() ) return kFALSE;
339 a = value / fPackingFactor;
340 b = value % fPackingFactor;
341 return kTRUE;
342}
343
344//_____________________________________________________________________________
345Bool_t
346AliMUONCalibParamNI::PackValues(Int_t a, Int_t b, Int_t& packedValue) const
347{
348 /// Pack a couple (a,b) into a single value, using packingFactor
349 /// Returns false if IsPacked()==false
350
351 if ( !IsPacked() ) return kFALSE;
352 packedValue = a*fPackingFactor + b;
353 return kTRUE;
354}
355
356//_____________________________________________________________________________
357Bool_t
358AliMUONCalibParamNI::IsPacked() const
359{
360 /// Whether the values we store are packed or not.
361 /// If false, Pack and Unpack methods will always return false and do nothing
362 return (fPackingFactor != 0);
363}
364