CORRFW/AliCFEffGrid.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 // AliCFEffGrid Class                                              //
  19 // Class to handle efficiency grids                                   //
  20 //                                                                    //
  21 // -- Author : S.Arcelli                                              //
  22 //                                                                    //
  23 //                                                                    //
  24 //                                                                    //
  25 //--------------------------------------------------------------------//
  26 //
  27 //
  28 #include "TMath.h"
  29 #include "AliLog.h"
  30 #include "AliCFEffGrid.h"
  31 #include "TH1D.h"
  32 #include "TH2D.h"
  33 #include "TH3D.h"
  34
  35 //____________________________________________________________________
  36 ClassImp(AliCFEffGrid)
  37
  38 //____________________________________________________________________
  39 AliCFEffGrid::AliCFEffGrid() :
  40   AliCFGridSparse(),
  41   fContainer(0x0),
  42   fSelNum(-1),
  43   fSelDen(-1)
  44 {
  45   //
  46   // default constructor
  47   //
  48 }
  49
  50 //____________________________________________________________________
  51 AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :
  52   AliCFGridSparse(name,title,nVarIn,nBinIn,binLimitsIn),
  53   fContainer(0x0),
  54   fSelNum(-1),
  55   fSelDen(-1)
  56 {
  57   //
  58   // ctor
  59   //
  60   SumW2();
  61 }
  62 //____________________________________________________________________
  63 AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const AliCFContainer &c) :
  64   AliCFGridSparse(name,title,c.GetNVar(),c.GetNBins(),c.GetBinLimits()),
  65   fContainer(0x0),
  66   fSelNum(-1),
  67   fSelDen(-1)
  68 {
  69   //
  70   // main constructor
  71   //
  72   SumW2();
  73   //assign the container;
  74   fContainer=&c;
  75 }
  76 //____________________________________________________________________
  77 AliCFEffGrid::AliCFEffGrid(const AliCFEffGrid& eff) : AliCFGridSparse(),
  78   fContainer(0x0),
  79   fSelNum(-1),
  80   fSelDen(-1)
  81 {
  82   //
  83   // copy constructor
  84   //
  85   ((AliCFEffGrid &)eff).Copy(*this);
  86 }
  87
  88 //____________________________________________________________________
  89 AliCFEffGrid::~AliCFEffGrid()
  90 {
  91   //
  92   // destructor
  93   //
  94 }
  95
  96 //____________________________________________________________________
  97 AliCFEffGrid &AliCFEffGrid::operator=(const AliCFEffGrid &eff)
  98 {
  99   //
 100   // assigment operator
 101   //
 102   if (this != &eff)
 103     ((AliCFEffGrid &) eff).Copy(*this);
 104   return *this;
 105 }
 106 //____________________________________________________________________
 107
 108 void AliCFEffGrid::CalculateEfficiency(Int_t istep1,Int_t istep2)
 109 {
 110   //
 111   // Calculate the efficiency matrix and its error between selection
 112   // Steps istep1 and istep2
 113   //
 114
 115   fSelNum=istep1;
 116   fSelDen=istep2;
 117   AliCFVGrid *num=fContainer->GetGrid(fSelNum);
 118   AliCFVGrid *den=fContainer->GetGrid(fSelDen);
 119   num->SumW2();
 120   den->SumW2();
 121   this->SumW2();
 122   this->Divide(num,den,1.,1.,"B");
 123
 124   Int_t nEmptyBinsNum=0;
 125   Int_t nEmptyBinsNumAndDen=0;
 126   for(Int_t iel=0;iel<fNDim;iel++){
 127     if(den->GetElement(iel)>0){
 128       if(num->GetElement(iel)==0)nEmptyBinsNum++; //num==0,den!=0
 129     }
 130     else{
 131       nEmptyBinsNumAndDen++;
 132     }
 133   }
 134   // Some monitoring printout:
 135   AliInfo(Form("Efficiency calculated for steps %i and %i: %i empty bins in the numerator && !denominator and %i empty bins in numerator && denominator were found.",fSelNum,fSelDen,nEmptyBinsNumAndDen,nEmptyBinsNum));
 136   AliInfo(Form("The correction map contains %i empty bins ",nEmptyBinsNum+nEmptyBinsNumAndDen));
 137 }
 138 //_____________________________________________________________________
 139 Double_t AliCFEffGrid::GetAverage() const
 140 {
 141   //
 142   // Get the average efficiency
 143   //
 144
 145   Double_t val=0;
 146   Double_t valnum=0;
 147   Double_t valden=0;
 148   for(Int_t i=0;i<fNDim;i++){
 149     valnum+=fContainer->GetGrid(fSelNum)->GetElement(i);
 150     valden+=fContainer->GetGrid(fSelDen)->GetElement(i);
 151   }
 152   if(valden>0)val=valnum/valden;
 153   AliInfo(Form(" The Average Efficiency = %f ",val));
 154
 155   return val;
 156 }
 157 //_____________________________________________________________________
 158 Double_t AliCFEffGrid::GetAverage(Double_t *varMin, Double_t* varMax ) const
 159 {
 160   //
 161   // Get ave efficiency in a range
 162   //
 163
 164
 165   Double_t val=0;
 166   Int_t *indexMin = new Int_t[fNVar];
 167   Int_t *indexMax = new Int_t[fNVar];
 168   Int_t *index    = new Int_t[fNVar];
 169
 170   //Find out the min and max bins
 171
 172   for(Int_t i=0;i<fNVar;i++){
 173     Double_t xmin=varMin[i]; // the min values
 174     Double_t xmax=varMax[i]; // the max values
 175     Int_t nbins=fNVarBins[i]+1;
 176     Double_t *bins=new Double_t[nbins];
 177     for(Int_t ibin =0;ibin<nbins;ibin++){
 178       bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
 179     }
 180     indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
 181     indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
 182     if(xmax>=bins[nbins-1]){
 183       indexMax[i]=indexMax[i]-1;
 184     }
 185     delete [] bins;
 186   }
 187
 188   Double_t valnum=0;
 189   Double_t valden=0;
 190   for(Int_t i=0;i<fNDim;i++){
 191     for (Int_t j=0;j<fNVar;j++)index[j]=GetBinIndex(j,i);
 192     Bool_t isIn=kTRUE;
 193     for (Int_t j=0;j<fNVar;j++){
 194       if(!(index[j]>=indexMin[j] && index[j]<=indexMax[j]))isIn=kFALSE;
 195     }
 196     if(isIn){
 197       valnum+=fContainer->GetGrid(fSelNum)->GetElement(i);
 198       valden+=fContainer->GetGrid(fSelDen)->GetElement(i);
 199     }
 200   }
 201   delete [] index;
 202   delete [] indexMin;
 203   delete [] indexMax;
 204   if(valden>0)val=valnum/valden;
 205   AliInfo(Form(" the Average Efficiency = %f ",val));
 206   return val;
 207 }
 208 //____________________________________________________________________
 209 void AliCFEffGrid::Copy(TObject& eff) const
 210 {
 211   //
 212   // copy function
 213   //
 214   Copy(eff);
 215   AliCFEffGrid& target = (AliCFEffGrid &) eff;
 216
 217   target.fSelNum=fSelNum;
 218   target.fSelDen=fSelDen;
 219   if(fContainer)
 220     target.fContainer=fContainer;
 221 }
 222 //___________________________________________________________________
 223 TH1D *AliCFEffGrid::Project(Int_t ivar) const
 224 {
 225   //
 226   // Make a 1D projection along variable ivar
 227   //
 228
 229   TH1D *proj1D=0;
 230   Int_t nbins =fNVarBins[ivar];
 231   Float_t *bins = new Float_t[nbins+1];
 232   for(Int_t ibin =0;ibin<nbins+1;ibin++){
 233     bins[ibin] = fVarBinLimits[ibin+fOffset[ivar]];
 234   }
 235
 236   char pname[30];
 237   sprintf(pname,"%s%s%i%i%s%i",GetName(),"_SelStep",fSelNum,fSelDen,"_proj1D_var", ivar);
 238   char htitle[30];
 239   sprintf(htitle,"%s%s%i%i%s%i",GetName(),"_SelStep",fSelNum,fSelDen,"_proj1D_var", ivar);
 240
 241   if(!proj1D){
 242     proj1D =new TH1D(pname,htitle, nbins, bins);
 243   }
 244
 245   proj1D->Sumw2();
 246   proj1D->Divide(fContainer->GetGrid(fSelNum)->Project(ivar),fContainer->GetGrid(fSelDen)->Project(ivar),1.,1.,"B");
 247
 248   delete [] bins;
 249   return proj1D;
 250 }
 251 //___________________________________________________________________
 252 TH2D *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
 253 {
 254   //
 255   // Make a 2D projection along variable ivar1,ivar2
 256   //
 257
 258   TH2D *proj2D=0;
 259
 260   Int_t nbins1 =fNVarBins[ivar1];
 261   Float_t *bins1 = new Float_t[nbins1+1];
 262   Int_t nbins2 =fNVarBins[ivar2];
 263   Float_t *bins2 = new Float_t[nbins2+1];
 264   for(Int_t ibin1 =0;ibin1<nbins1+1;ibin1++){
 265     bins1[ibin1] = fVarBinLimits[ibin1+fOffset[ivar1]];
 266   }
 267   for(Int_t ibin2 =0;ibin2<nbins2+1;ibin2++){
 268     bins2[ibin2] = fVarBinLimits[ibin2+fOffset[ivar2]];
 269   }
 270
 271   char pname[30];
 272   sprintf(pname,"%s%s%i%i%s%i%i",GetName(),"_SelStep",fSelNum,fSelDen,"_proj2D_var", ivar1,ivar2);
 273   char htitle[30];
 274   sprintf(htitle,"%s%s%i%i%s%i%i",GetName(),"_SelStep",fSelNum,fSelDen,"_proj2D_var",ivar1,ivar2);
 275
 276   if(!proj2D){
 277     proj2D =new TH2D(pname,htitle, nbins1,bins1,nbins2,bins2);
 278   }
 279
 280   proj2D->Sumw2();
 281   proj2D->Divide(fContainer->GetGrid(fSelNum)->Project(ivar1,ivar2),fContainer->GetGrid(fSelDen)->Project(ivar1,ivar2),1.,1.,"B");
 282
 283   delete [] bins1;
 284   delete [] bins2;
 285   return proj2D;
 286 }
 287 //___________________________________________________________________
 288 TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
 289 {
 290   //
 291   // Make a 3D projection along variable ivar1,ivar2,ivar3
 292   //
 293
 294   TH3D *proj3D=0;
 295
 296   Int_t nbins1 =fNVarBins[ivar1];
 297   Int_t nbins2 =fNVarBins[ivar2];
 298   Int_t nbins3 =fNVarBins[ivar3];
 299
 300   Float_t *bins1 = new Float_t[nbins1+1];
 301   Float_t *bins2 = new Float_t[nbins2+1];
 302   Float_t *bins3 = new Float_t[nbins3+1];
 303
 304   for(Int_t ibin =0;ibin<nbins1+1;ibin++){
 305     bins1[ibin] = fVarBinLimits[ibin+fOffset[ivar1]];
 306   }
 307   for(Int_t ibin =0;ibin<nbins2+1;ibin++){
 308     bins2[ibin] = fVarBinLimits[ibin+fOffset[ivar2]];
 309   }
 310   for(Int_t ibin =0;ibin<nbins3+1;ibin++){
 311     bins3[ibin] = fVarBinLimits[ibin+fOffset[ivar3]];
 312   }
 313
 314   char pname[30];
 315   sprintf(pname,"%s%s%i%i%s%i%i%i",GetName(),"_SelStep",fSelNum,fSelDen,"_proj3D_var",ivar1,ivar2,ivar3);
 316   char htitle[30];
 317   sprintf(htitle,"%s%s%i%i%s%i%i%i",GetName(),"_SelStep",fSelNum,fSelDen,"_proj3D_var",ivar1,ivar2,ivar3);
 318
 319
 320   if(!proj3D){
 321     proj3D =new TH3D(pname,htitle, nbins1, bins1,nbins2,bins2,nbins3,bins3);
 322   }
 323
 324   proj3D->Sumw2();
 325   proj3D->Divide(fContainer->GetGrid(fSelNum)->Project(ivar1,ivar2,ivar3),fContainer->GetGrid(fSelDen)->Project(ivar1,ivar2,ivar3),1.,1.,"B");
 326
 327   delete [] bins1;
 328   delete [] bins2;
 329   delete [] bins3;
 330
 331   return proj3D;
 332 }