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