2 /**************************************************************************
3 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5 * Author: The ALICE Off-line Project. *
6 * Contributors are mentioned in the code where appropriate. *
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 //--------------------------------------------------------------------//
18 // AliCFEffGrid Class //
19 // Class to handle efficiency grids //
21 // -- Author : S.Arcelli //
25 //--------------------------------------------------------------------//
30 #include "AliCFEffGrid.h"
35 //____________________________________________________________________
36 ClassImp(AliCFEffGrid)
38 //____________________________________________________________________
39 AliCFEffGrid::AliCFEffGrid() :
46 // default constructor
50 //____________________________________________________________________
51 AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn) :
52 AliCFGridSparse(name,title,nVarIn,nBinIn),
62 //____________________________________________________________________
63 AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const AliCFContainer &c) :
64 AliCFGridSparse(name,title,c.GetNVar(),c.GetNBins()),
73 //assign the container;
75 for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
76 SetBinLimits(iVar,GetBinLimits(iVar));
78 for (Int_t iVar=0; iVar<GetNVar(); iVar++) SetVarTitle(iVar,c.GetVarTitle(iVar));
80 //____________________________________________________________________
81 AliCFEffGrid::AliCFEffGrid(const AliCFEffGrid& eff) :
90 ((AliCFEffGrid &)eff).Copy(*this);
93 //____________________________________________________________________
94 AliCFEffGrid::~AliCFEffGrid()
101 //____________________________________________________________________
102 AliCFEffGrid &AliCFEffGrid::operator=(const AliCFEffGrid &eff)
105 // assigment operator
107 if (this != &eff) eff.Copy(*this);
111 //____________________________________________________________________
112 void AliCFEffGrid::CalculateEfficiency(Int_t istep1,Int_t istep2, Option_t *option)
115 // Calculate the efficiency matrix and its error between selection
116 // Steps istep1 and istep2
118 // 'option' is used as an argument for THnSparse::Divide
119 // default is "B" : binomial error calculation
124 AliCFGridSparse *num=GetNum();
125 AliCFGridSparse *den=GetDen();
129 this->Divide(num,den,1.,1.,option);
130 SetTitle(Form("Efficiency: %s / %s",fContainer->GetStepTitle(istep1),fContainer->GetStepTitle(istep2)));
132 AliInfo(Form("Efficiency calculated for steps %i and %i.",fSelNum,fSelDen));
134 //_____________________________________________________________________
135 Double_t AliCFEffGrid::GetAverage() const
138 // Get the average efficiency
145 THnSparse* num = ((AliCFGridSparse*)GetNum())->GetGrid() ;
146 THnSparse* den = ((AliCFGridSparse*)GetDen())->GetGrid() ;
148 for (Long_t iBin=0; iBin<num->GetNbins(); iBin++) valnum+=num->GetBinContent(iBin);
149 for (Long_t iBin=0; iBin<den->GetNbins(); iBin++) valden+=den->GetBinContent(iBin);
150 if (valden>0) val=valnum/valden;
151 AliInfo(Form(" The Average Efficiency = %f ",val));
154 //_____________________________________________________________________
155 // Double_t AliCFEffGrid::GetAverage(const Double_t *varMin, const Double_t* varMax ) const
158 // // Get ave efficiency in a range
159 // // (may not work properly, should be modified)
162 // Int_t *indexMin = new Int_t[GetNVar()];
163 // Int_t *indexMax = new Int_t[GetNVar()];
164 // Int_t *index = new Int_t[GetNVar()];
166 // //Find out the min and max bins
168 // for(Int_t i=0;i<GetNVar();i++){
169 // Double_t xmin=varMin[i]; // the min values
170 // Double_t xmax=varMax[i]; // the max values
171 // Int_t nbins = GetNBins(i)+1;
172 // // Double_t *bins = new Double_t[nbins];
173 // // for (Int_t ibin =0; ibin<nbins; ibin++) {
174 // // bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
176 // bins = GetBinLimits(i);
177 // indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
178 // indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
179 // if(xmax>=bins[nbins-1]){
180 // indexMax[i]=indexMax[i]-1;
185 // Double_t valnum=0;
186 // Double_t valden=0;
187 // for (Int_t i=0; i<fNDim; i++) {
188 // for (Int_t j=0; j<GetNVar(); j++) index[j]=GetBinIndex(j,i);
189 // Bool_t isIn=kTRUE;
190 // for (Int_t j=0;j<GetNVar();j++) {
191 // if(!(index[j]>=indexMin[j] && index[j]<=indexMax[j]))isIn=kFALSE;
194 // valnum+=GetNum()->GetElement(i);
195 // valden+=GetDen()->GetElement(i);
199 // delete [] indexMin;
200 // delete [] indexMax;
201 // if(valden>0)val=valnum/valden;
202 // AliInfo(Form(" the Average Efficiency = %f ",val));
205 //____________________________________________________________________
206 // void AliCFEffGrid::Copy(TObject& eff) const
212 // AliCFEffGrid& target = (AliCFEffGrid &) eff;
214 // target.fSelNum=fSelNum;
215 // target.fSelDen=fSelDen;
217 // target.fContainer=fContainer;
219 //___________________________________________________________________
220 TH1D *AliCFEffGrid::Project(Int_t ivar) const
223 // Make a 1D projection along variable ivar
226 if (fSelNum<0 || fSelDen<0) {
227 AliError("You must call CalculateEfficiency() first !");
230 const Int_t nDim = 1 ;
231 Int_t dim[nDim] = {ivar} ;
232 THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
233 THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
234 THnSparse* ratio = (THnSparse*)hNum->Clone();
235 ratio->Divide(hNum,hDen,1.,1.,"B");
236 delete hNum; delete hDen;
237 TH1D* h = ratio->Projection(0);
238 h->SetXTitle(GetVarTitle(ivar));
239 h->SetTitle(Form("%s projected on %s",GetTitle(),GetVarTitle(ivar)));
242 //___________________________________________________________________
243 TH2D *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
246 // Make a 2D projection along variable ivar1,ivar2
249 if (fSelNum<0 || fSelDen<0) {
250 AliError("You must call CalculateEfficiency() first !");
253 const Int_t nDim = 2 ;
254 Int_t dim[nDim] = {ivar1,ivar2} ;
255 THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
256 THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
257 THnSparse* ratio = (THnSparse*)hNum->Clone();
258 ratio->Divide(hNum,hDen,1.,1.,"B");
259 delete hNum; delete hDen;
260 TH2D* h = ratio->Projection(0,1);
261 h->SetXTitle(GetVarTitle(ivar1));
262 h->SetYTitle(GetVarTitle(ivar2));
263 h->SetTitle(Form("%s projected on %s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
266 //___________________________________________________________________
267 TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
270 // Make a 3D projection along variable ivar1,ivar2,ivar3
273 if (fSelNum<0 || fSelDen<0) {
274 AliError("You must call CalculateEfficiency() first !");
277 const Int_t nDim = 3 ;
278 Int_t dim[nDim] = {ivar1,ivar2,ivar3} ;
279 THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
280 THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
281 THnSparse* ratio = (THnSparse*)hNum->Clone();
282 ratio->Divide(hNum,hDen,1.,1.,"B");
283 delete hNum; delete hDen;
284 TH3D* h = ratio->Projection(0,1,2);
285 h->SetXTitle(GetVarTitle(ivar1));
286 h->SetYTitle(GetVarTitle(ivar2));
287 h->SetZTitle(GetVarTitle(ivar3));
288 h->SetTitle(Form("%s projected on %s-%s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
291 //___________________________________________________________________
292 AliCFEffGrid* AliCFEffGrid::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t numStep, Int_t denStep) const {
294 // Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for all the container steps.
295 // The ranges of ALL the container variables must be defined in the array varMin[fNVar] and varMax[fNVar].
296 // This function returns the effiency relative to this new 'sliced' container, between steps defined in numStep and denStep
299 AliCFContainer* cont = fContainer->MakeSlice(nVars,vars,varMin,varMax);
300 AliCFEffGrid * eff = new AliCFEffGrid(Form("%s_sliced",GetName()), Form("%s_sliced",GetTitle()), *cont);
301 eff->CalculateEfficiency(numStep,denStep);