CORRFW/AliCFFrame.cxx

   1 /* $Id$ */
   2 /**************************************************************************
   3  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  *                                                                        *
   5  * Author: The ALICE Off-line Project.                                    *
   6  * Contributors are mentioned in the code where appropriate.              *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16 //--------------------------------------------------------------------//
  17 //                                                                    //
  18 // AliCFFrame Class                                                 //
  19 // Class to accumulate data on an N-dimensional grid, to be used      //
  20 // as input to get corrections for Reconstruction & Trigger efficiency//
  21 //                                                                    //
  22 // -- Author : S.Arcelli                                              //
  23 // Still to be done:                                                  //
  24 // --Implement methods to merge cells                                 //
  25 // --Interpolate among bins in a range                                //
  26 //--------------------------------------------------------------------//
  27 //
  28 //
  29
  30 #include "TSystem.h"
  31 #include "TFile.h"
  32 #include "AliLog.h"
  33 #include "AliCFFrame.h"
  34
  35 //____________________________________________________________________
  36 ClassImp(AliCFFrame)
  37
  38 //____________________________________________________________________
  39 AliCFFrame::AliCFFrame() :
  40   TNamed(),
  41   fNVar(0),
  42   fNDim(0),
  43   fNVarBinLimits(0),
  44   fNVarBins(0x0),
  45   fIndex(0x0),
  46   fProduct(0x0),
  47   fOffset(0x0),
  48   fVarBinLimits(0x0)
  49 {
  50   // default constructor
  51 }
  52 //____________________________________________________________________
  53 AliCFFrame::AliCFFrame(const Char_t* name, const Char_t* title) :
  54   TNamed(name,title),
  55   fNVar(0),
  56   fNDim(0),
  57   fNVarBinLimits(0),
  58   fNVarBins(0x0),
  59   fIndex(0x0),
  60   fProduct(0x0),
  61   fOffset(0x0),
  62   fVarBinLimits(0x0)
  63 {
  64   // named constructor
  65 }
  66 //____________________________________________________________________
  67 AliCFFrame::AliCFFrame(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :
  68   TNamed(name,title),
  69   fNVar(0),
  70   fNDim(0),
  71   fNVarBinLimits(0),
  72   fNVarBins(0x0),
  73   fIndex(0x0),
  74   fProduct(0x0),
  75   fOffset(0x0),
  76   fVarBinLimits(0x0)
  77 {
  78   //
  79   // main constructor
  80   //
  81
  82   //the number of variables on the grid
  83   fNVar=nVarIn;
  84
  85   // the binning in each variable
  86   fNVarBins= new Int_t[fNVar];
  87
  88   fIndex= new Int_t[fNVar];
  89
  90   Int_t ndimTot=1;
  91   Int_t nbinTot=0;
  92
  93
  94   //Calculate total number of elements and bins...
  95
  96   for(Int_t i=0;i<fNVar;i++){
  97     fNVarBins[i]=nBinIn[i];
  98     ndimTot*=nBinIn[i];
  99     nbinTot+=(nBinIn[i]+1);
 100   }
 101
 102
 103   //total number of elements
 104
 105   fNDim=ndimTot;
 106
 107   fOffset= new Int_t[fNVar];
 108   fProduct= new Int_t[fNVar];
 109
 110   for(Int_t ivar=0;ivar<fNVar;ivar++){
 111     Int_t offset=0;
 112     for(Int_t i =0;i<ivar;i++)offset+=(fNVarBins[i]+1);
 113     fOffset[ivar]=offset;
 114     Int_t prod=1;
 115     for(Int_t i=0;i<ivar;i++)prod*=fNVarBins[i];
 116     fProduct[ivar]=prod;
 117   }
 118
 119   //The bin limits
 120
 121   fNVarBinLimits=nbinTot;
 122   fVarBinLimits=new Double_t[fNVarBinLimits];
 123   if(binLimitsIn){
 124     for(Int_t i=0;i<fNVarBinLimits;i++){
 125       fVarBinLimits[i] =binLimitsIn[i];
 126     }
 127   }
 128 }
 129 //____________________________________________________________________
 130 AliCFFrame::AliCFFrame(const AliCFFrame& c) :
 131   TNamed(),
 132   fNVar(0),
 133   fNDim(0),
 134   fNVarBinLimits(0),
 135   fNVarBins(0x0),
 136   fIndex(0x0),
 137   fProduct(0x0),
 138   fOffset(0x0),
 139   fVarBinLimits(0x0)
 140 {
 141   //
 142   // copy constructor
 143   //
 144   ((AliCFFrame &)c).Copy(*this);
 145 }
 146 //____________________________________________________________________
 147 AliCFFrame::~AliCFFrame()
 148 {
 149   //
 150   // destructor
 151   //
 152   if(fNVarBins)delete [] fNVarBins;
 153   if(fVarBinLimits)delete [] fVarBinLimits;
 154   if(fIndex)delete [] fIndex;
 155   if(fProduct)delete [] fProduct;
 156   if(fOffset)delete [] fOffset;
 157
 158 }
 159 //____________________________________________________________________
 160 AliCFFrame &AliCFFrame::operator=(const AliCFFrame &c)
 161 {
 162   //
 163   // assigment operator
 164   //
 165   if (this != &c)
 166     ((AliCFFrame &) c).Copy(*this);
 167   return *this;
 168 }
 169 //____________________________________________________________________
 170 void AliCFFrame::SetBinLimits(Int_t ivar, Double_t *array)
 171 {
 172   //
 173   // setting the arrays containing the bin limits
 174   //
 175   Int_t nbins=fNVarBins[ivar]+1;
 176   for(Int_t i=0;i<nbins;i++){
 177     fVarBinLimits[fOffset[ivar]+i] =array[i];
 178   }
 179 }
 180 //____________________________________________________________________
 181 void AliCFFrame::GetBinLimits(Int_t ivar, Double_t *array) const
 182 {
 183   //
 184   // getting the arrays containing the bin limits
 185   //
 186   Int_t nbins=fNVarBins[ivar]+1;
 187   for(Int_t i=0;i<nbins;i++){
 188     array[i]=fVarBinLimits[fOffset[ivar]+i];
 189   }
 190 }
 191 //____________________________________________________________________
 192 Int_t AliCFFrame::GetBinIndex(Int_t *ibin) const
 193 {
 194   //
 195   // getting the element number on the grid for a given set of bin indeces
 196   //(here the numbering of bin indeces ranges from 0 to N-1)
 197   //
 198   Int_t ind=ibin[fNVar-1];
 199   for(Int_t i=fNVar-1;i>0;i--){
 200     ind=ibin[i-1]+ind*fNVarBins[i-1];
 201   }
 202   return ind;
 203 }
 204 //____________________________________________________________________
 205 Int_t AliCFFrame::GetBinIndex(Int_t ivar, Int_t ind) const
 206 {
 207   //
 208   // getting the bin index on a given dim. ivar for a given element ind
 209   // on the grid
 210   //(here the numbering of bin indeces ranges from 0 to N-1)
 211   //
 212   Int_t index=-1;
 213   for(Int_t i=fNVar-1;i>=0;i--){
 214     index=ind/fProduct[i];
 215     fIndex[i]=index;
 216     ind-=index*fProduct[i];
 217   }
 218
 219   index=fIndex[ivar];
 220   return index;
 221 }
 222 //____________________________________________________________________
 223 void AliCFFrame::GetBinIndex(Int_t ind, Int_t *bins ) const
 224 {
 225   //
 226   // getting the set of bin indeces for a given element ind on the grid
 227   // (here the numbering of bin indeces ranges from 0 to N-1)
 228   //
 229   Int_t index=-1;
 230   for(Int_t i=fNVar-1;i>=0;i--){
 231     index=ind/fProduct[i];
 232     bins[i]=index;
 233     ind-=index*fProduct[i];
 234   }
 235   return;
 236 }
 237 //____________________________________________________________________
 238 Double_t AliCFFrame::GetBinCenter(Int_t ivar, Int_t ibin) const
 239 {
 240   //
 241   // getting the bin center of a given bin ibin along variable ivar
 242   // (here the numbering of bin indeces in input
 243   //  ranges from 1 to N, TH1/2/3 and THnSparse convention)
 244   //
 245
 246   if(ibin>fNVarBins[ivar] || ibin==0){
 247     AliWarning(Form("bin index out of range, number of bins in variable %i ranges from 1 to %i", ivar,fNVarBins[ivar]));
 248     return -1;
 249   }
 250   Double_t binMin=fVarBinLimits[fOffset[ivar]+ibin-1];
 251   Double_t binMax=fVarBinLimits[fOffset[ivar]+ibin];
 252   Double_t val=0.5*(binMin+binMax);
 253   return val;
 254 }
 255 //____________________________________________________________________
 256 void AliCFFrame::GetBinCenters(Int_t *ibin, Double_t *binCenter) const
 257 {
 258   //
 259   // gives the centers of the N-dim bin identified by a set of bin indeces
 260   // invar
 261   // (here the numbering of bin indeces in input
 262   //  ranges from 1 to N, TH1/2/3 and THnSparse convention)
 263   //
 264   for(Int_t i=0;i<fNVar;i++){
 265     binCenter[i]=GetBinCenter(i,ibin[i]);
 266   }
 267 } //____________________________________________________________________
 268 Double_t AliCFFrame::GetBinSize(Int_t ivar, Int_t ibin) const
 269 {
 270   //
 271   // getting the bin size on axis ivar of a given bin ibin
 272   // (here the numbering of bin indeces in input
 273   //  ranges from 1 to N, TH1/2/3 and THnSparse convention)
 274   //
 275
 276   if(ibin>fNVarBins[ivar] || ibin==0){
 277     AliWarning(Form("bin index out of range, number of bins in variable %i ranges from 1 to %i", ivar,fNVarBins[ivar]));
 278     return -1;
 279   }
 280
 281   Double_t binMin=fVarBinLimits[fOffset[ivar]+ibin-1];
 282   Double_t binMax=fVarBinLimits[fOffset[ivar]+ibin];
 283   Double_t val=binMax-binMin;
 284   return val;
 285 }
 286 //____________________________________________________________________
 287 void AliCFFrame::GetBinSizes(Int_t *ibin, Double_t *binSizes) const
 288 {
 289   //
 290   // gives the sizes of the N-dim bin identified by a set of bin indeces
 291   // ibin
 292   // (here the numbering of bin indeces in input
 293   //  ranges from 1 to N, TH1/2/3 and THnSparse convention)
 294   //
 295   for(Int_t i=0;i<fNVar;i++){
 296     binSizes[i]=GetBinSize(i,ibin[i]);
 297   }
 298 }
 299
 300 //____________________________________________________________________
 301 void AliCFFrame::Copy(TObject& c) const
 302 {
 303   //
 304   // copy function
 305   //
 306   AliCFFrame& target = (AliCFFrame &) c;
 307
 308   target.fNVar=fNVar;
 309   target.fNDim=fNDim;
 310   target.fNVarBinLimits=fNVarBinLimits;
 311   if (fNVarBins)
 312     target.fNVarBins = fNVarBins;
 313   if (fVarBinLimits)
 314     target.fVarBinLimits = fVarBinLimits;
 315   if (fProduct)
 316     target.fProduct = fProduct;
 317   if (fOffset)
 318     target.fOffset = fOffset;
 319 }
 320 //____________________________________________________________________
 321 void AliCFFrame::PrintBinLimits()
 322 {
 323   //
 324   // printing the array containing the bin limits
 325   //
 326   for(Int_t i=0;i<fNVarBinLimits;i++){
 327     AliInfo(Form("bin limit index %i is: %f",i, fVarBinLimits[i]));
 328   }
 329 }
 330 //____________________________________________________________________
 331 void AliCFFrame::PrintNBins()
 332 {
 333   //
 334   // printing the array containing the # of bins
 335   //
 336   for(Int_t i=0;i<fNVar;i++){
 337     AliInfo(Form("bins in var %i are: %i",i, fNVarBins[i]));
 338   }
 339 }
 340 //____________________________________________________________________
 341 void AliCFFrame::Save(const Char_t *outfile) const
 342 {
 343   //
 344   // Save the grid to a root file
 345   //
 346
 347   const char *dirname = "./";
 348   TString filename = outfile;
 349   TFile *file=0x0;
 350   if((gSystem->FindFile(dirname,filename))!=NULL){
 351       file = new TFile( outfile,"UPDATE");
 352   }
 353   else{
 354     file = new TFile( outfile,"RECREATE");
 355   }
 356   file->cd();
 357   //write the object to a file
 358   this->Write(GetName(),TObject::kSingleKey);
 359   file->Close();
 360   delete file;
 361 }