Using a conservative 3% estimate for the K0s signal extraction systematics. Using...
[u/mrichter/AliRoot.git] / MUON / AliMUONCalibParamNI.cxx
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
26 //-----------------------------------------------------------------------------
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
38 //-----------------------------------------------------------------------------
39
40 using std::cout;
41 using std::endl;
42 /// \cond CLASSIMP
43 ClassImp(AliMUONCalibParamNI)
44 /// \endcond
45
46 //_____________________________________________________________________________
47 AliMUONCalibParamNI::AliMUONCalibParamNI() 
48 : AliMUONVCalibParam(),
49   fDimension(0),
50   fSize(0),
51   fN(0),
52   fPackingFactor(0),
53   fValues(0x0)
54 {
55 /// Default constructor.
56     AliDebug(1,Form("this=%p default ctor",this));
57 }
58
59 //_____________________________________________________________________________
60 AliMUONCalibParamNI::AliMUONCalibParamNI(Int_t dimension, Int_t theSize,
61                                          Int_t id0, Int_t id1,
62                                          Int_t fillWithValue, Int_t packingFactor) 
63 : AliMUONVCalibParam(id0,id1),
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
74 //    AliDebug(1,Form("this=%p dimension=%d theSize=%d fillWithValue=%d packingFactor=%d",
75 //                    this,dimension,theSize,fillWithValue,packingFactor));
76
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 //_____________________________________________________________________________
89 AliMUONCalibParamNI::AliMUONCalibParamNI(const AliMUONCalibParamNI& other) 
90 : AliMUONVCalibParam(),
91 fDimension(0),
92 fSize(0),
93 fN(0),
94 fPackingFactor(0),
95 fValues(0x0)
96 {
97 /// Copy constructor.
98
99   AliDebug(1,Form("this=%p copy ctor",this));
100   other.CopyTo(*this);
101 }
102
103 //_____________________________________________________________________________
104 AliMUONCalibParamNI&
105 AliMUONCalibParamNI::operator=(const AliMUONCalibParamNI& other) 
106 {
107 /// Assignment operator
108
109   other.CopyTo(*this);
110   return *this;
111 }
112
113 //_____________________________________________________________________________
114 AliMUONCalibParamNI::~AliMUONCalibParamNI()
115 {
116 /// Destructor
117
118   AliDebug(1,Form("this=%p",this));
119   delete[] fValues;
120 }
121
122 //_____________________________________________________________________________
123 void
124 AliMUONCalibParamNI::CopyTo(AliMUONCalibParamNI& destination) const
125 {
126 /// Copy *this to destination
127
128   const TObject& o = static_cast<const TObject&>(*this);
129   o.Copy(destination);
130   
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 //_____________________________________________________________________________
148 Int_t
149 AliMUONCalibParamNI::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   {
156     return IndexFast(i,j);
157   }
158   return -1;
159 }
160
161 //_____________________________________________________________________________
162 Int_t
163 AliMUONCalibParamNI::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 //_____________________________________________________________________________
171 void
172 AliMUONCalibParamNI::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()
182     << " Dimension=" << Dimension()
183     << " Id=(" << ID0() << "," << ID1() << ")";
184   
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);
203           cout << Form(" (%d,%d) (0x%x,0x%x)",m,c,m,c);
204         }
205         else
206         {
207           cout << Form(" %d (0x%x)",v,v);
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 //_____________________________________________________________________________
238 void
239 AliMUONCalibParamNI::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 //_____________________________________________________________________________
257 void
258 AliMUONCalibParamNI::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 //_____________________________________________________________________________
266 void
267 AliMUONCalibParamNI::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 //_____________________________________________________________________________
276 void
277 AliMUONCalibParamNI::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 //_____________________________________________________________________________
287 Int_t
288 AliMUONCalibParamNI::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 //_____________________________________________________________________________
307 Int_t
308 AliMUONCalibParamNI::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 //_____________________________________________________________________________
316 Float_t
317 AliMUONCalibParamNI::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 //_____________________________________________________________________________
324 Float_t
325 AliMUONCalibParamNI::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 //_____________________________________________________________________________
332 Bool_t 
333 AliMUONCalibParamNI::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 //_____________________________________________________________________________
345 Bool_t 
346 AliMUONCalibParamNI::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 //_____________________________________________________________________________
357 Bool_t 
358 AliMUONCalibParamNI::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