[u/mrichter/AliRoot.git] / CORRFW / AliCFEffGrid.cxx

/* $Id$ */
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
//--------------------------------------------------------------------//
//                                                                    //
// AliCFEffGrid Class                                                 //
// Class to handle efficiency grids                                   // 
//                                                                    //
// -- Author : S.Arcelli                                              //
//                                                                    //
//                                                                    //
//                                                                    //
//--------------------------------------------------------------------//
//
//
#include "TMath.h"
#include "AliLog.h"
#include "AliCFEffGrid.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TH3D.h"

//____________________________________________________________________
ClassImp(AliCFEffGrid)

//____________________________________________________________________
AliCFEffGrid::AliCFEffGrid() : 
  AliCFGridSparse(),
  fContainer(0x0),
  fSelNum(-1),
  fSelDen(-1)
{
  //
  // default constructor
  //
}

//____________________________________________________________________
AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn) :
  AliCFGridSparse(name,title,nVarIn,nBinIn),
  fContainer(0x0),
  fSelNum(-1),
  fSelDen(-1)
{
  //
  // ctor
  //
  SumW2();
}
//____________________________________________________________________
AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const AliCFContainer &c) :  
  AliCFGridSparse(name,title,c.GetNVar(),c.GetNBins()),
  fContainer(NULL),
  fSelNum(-1),
  fSelDen(-1)
{
  //
  // main constructor
  //
  SumW2();
  //assign the container;
  fContainer=&c;
  for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
    Int_t nbins = c.GetNBins(iVar);
    Double_t* array=new Double_t[nbins+1] ;
    c.GetBinLimits(iVar,array);
    SetBinLimits(iVar,array);
    delete array ;
  }
  for (Int_t iVar=0; iVar<GetNVar(); iVar++) SetVarTitle(iVar,c.GetVarTitle(iVar));
}
//____________________________________________________________________
AliCFEffGrid::AliCFEffGrid(const AliCFEffGrid& eff) : 
  AliCFGridSparse(eff),
  fContainer(0x0),
  fSelNum(-1),
  fSelDen(-1)
{
  //
  // copy constructor
  //
  ((AliCFEffGrid &)eff).Copy(*this);
}

//____________________________________________________________________
AliCFEffGrid::~AliCFEffGrid()
{
  //
  // destructor
  //
}

//____________________________________________________________________
AliCFEffGrid &AliCFEffGrid::operator=(const AliCFEffGrid &eff)
{
  //
  // assigment operator
  //
  if (this != &eff) eff.Copy(*this);
  return *this;
} 

//____________________________________________________________________
void AliCFEffGrid::CalculateEfficiency(Int_t istep1,Int_t istep2, Option_t *option)
{
  //
  // Calculate the efficiency matrix and its error between selection
  // Steps istep1 and istep2
  //
  // 'option' is used as an argument for THnSparse::Divide
  // default is "B" : binomial error calculation
  //

  fSelNum=istep1;
  fSelDen=istep2;
  AliCFGridSparse *num=GetNum();
  AliCFGridSparse *den=GetDen();
  num->SumW2();
  den->SumW2();
  this->SumW2();
  this->Divide(num,den,1.,1.,option);
  SetTitle(Form("Efficiency: %s / %s",fContainer->GetStepTitle(istep1),fContainer->GetStepTitle(istep2)));

  AliInfo(Form("Efficiency calculated for steps %i and %i.",fSelNum,fSelDen));
} 
//_____________________________________________________________________
Double_t AliCFEffGrid::GetAverage() const 
{
  //
  // Get the average efficiency 
  //

  Double_t val=0;
  Double_t valnum=0;
  Double_t valden=0;

  THnSparse* num = ((AliCFGridSparse*)GetNum())->GetGrid() ;
  THnSparse* den = ((AliCFGridSparse*)GetDen())->GetGrid() ;

  for (Long_t iBin=0; iBin<num->GetNbins(); iBin++) valnum+=num->GetBinContent(iBin);
  for (Long_t iBin=0; iBin<den->GetNbins(); iBin++) valden+=den->GetBinContent(iBin);
  if (valden>0) val=valnum/valden;
  AliInfo(Form(" The Average Efficiency = %f ",val)); 
  return val;
} 
//_____________________________________________________________________
// Double_t AliCFEffGrid::GetAverage(const Double_t *varMin, const Double_t* varMax ) const 
// {
//   //
//   // Get ave efficiency in a range
//   // (may not work properly, should be modified)

//   Double_t val=0;
//   Int_t *indexMin = new Int_t[GetNVar()];
//   Int_t *indexMax = new Int_t[GetNVar()];
//   Int_t *index    = new Int_t[GetNVar()];
  
//   //Find out the min and max bins
  
//   for(Int_t i=0;i<GetNVar();i++){
//     Double_t xmin=varMin[i]; // the min values  
//     Double_t xmax=varMax[i]; // the max values  
//     Int_t nbins = GetNBins(i)+1;
// //     Double_t *bins = new Double_t[nbins];
// //     for (Int_t ibin =0; ibin<nbins; ibin++) {
// //       bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
// //     }
//     bins = GetBinLimits(i);
//     indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
//     indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
//     if(xmax>=bins[nbins-1]){
//       indexMax[i]=indexMax[i]-1;
//     }  
//     delete [] bins;
//   }
  
//   Double_t valnum=0;
//   Double_t valden=0;
//   for (Int_t i=0; i<fNDim; i++) {
//     for (Int_t j=0; j<GetNVar(); j++) index[j]=GetBinIndex(j,i);
//     Bool_t isIn=kTRUE;
//     for (Int_t j=0;j<GetNVar();j++) {
//       if(!(index[j]>=indexMin[j] && index[j]<=indexMax[j]))isIn=kFALSE;   
//     }
//     if(isIn){
//       valnum+=GetNum()->GetElement(i);
//       valden+=GetDen()->GetElement(i);
//     }
//   } 
//   delete [] index;
//   delete [] indexMin;
//   delete [] indexMax;
//   if(valden>0)val=valnum/valden;
//   AliInfo(Form(" the Average Efficiency = %f ",val)); 
//   return val;
// } 
//____________________________________________________________________
// void AliCFEffGrid::Copy(TObject& eff) const
// {
//   //
//   // copy function
//   //
//   Copy(eff);
//   AliCFEffGrid& target = (AliCFEffGrid &) eff;
  
//   target.fSelNum=fSelNum; 
//   target.fSelDen=fSelDen; 
//   if(fContainer)
//     target.fContainer=fContainer;
// }
//___________________________________________________________________
TH1D *AliCFEffGrid::Project(Int_t ivar) const
{
  //
  // Make a 1D projection along variable ivar 
  //
  
  if (fSelNum<0 || fSelDen<0) {
    AliError("You must call CalculateEfficiency() first !");
    return 0x0;
  }
  const Int_t nDim = 1 ;
  Int_t dim[nDim] = {ivar} ;
  THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
  THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
  THnSparse* ratio = (THnSparse*)hNum->Clone();
  ratio->Divide(hNum,hDen,1.,1.,"B");
  delete hNum; delete hDen;
  TH1D* h = ratio->Projection(0);
  h->SetXTitle(GetVarTitle(ivar));
  h->SetName(Form("%s_proj-%s",GetName(),GetVarTitle(ivar)));
  h->SetTitle(Form("%s projected on %s",GetTitle(),GetVarTitle(ivar)));
  return h ;
} 
//___________________________________________________________________
TH2D *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
{
  //
  // Make a 2D projection along variable ivar1,ivar2 
  //
  
  if (fSelNum<0 || fSelDen<0) {
    AliError("You must call CalculateEfficiency() first !");
    return 0x0;
  }
  const Int_t nDim = 2 ;
  Int_t dim[nDim] = {ivar1,ivar2} ;
  THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
  THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
  THnSparse* ratio = (THnSparse*)hNum->Clone();
  ratio->Divide(hNum,hDen,1.,1.,"B");
  delete hNum; delete hDen;
  TH2D* h = ratio->Projection(1,0);
  h->SetXTitle(GetVarTitle(ivar1));
  h->SetYTitle(GetVarTitle(ivar2));
  h->SetName(Form("%s_proj-%s,%s",GetName(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
  h->SetTitle(Form("%s projected on %s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
  return h;
} 
//___________________________________________________________________
TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
{
  //
  // Make a 3D projection along variable ivar1,ivar2,ivar3 
  //

  if (fSelNum<0 || fSelDen<0) {
    AliError("You must call CalculateEfficiency() first !");
    return 0x0;
  }
  const Int_t nDim = 3 ;
  Int_t dim[nDim] = {ivar1,ivar2,ivar3} ;
  THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
  THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
  THnSparse* ratio = (THnSparse*)hNum->Clone();
  ratio->Divide(hNum,hDen,1.,1.,"B");
  delete hNum; delete hDen;
  TH3D* h = ratio->Projection(0,1,2);
  h->SetXTitle(GetVarTitle(ivar1));
  h->SetYTitle(GetVarTitle(ivar2));
  h->SetZTitle(GetVarTitle(ivar3));
  h->SetName(Form("%s_proj-%s,%s,%s",GetName(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
  h->SetTitle(Form("%s projected on %s-%s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
  return h;
} 
//___________________________________________________________________
AliCFEffGrid* AliCFEffGrid::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t numStep, Int_t denStep, Bool_t useBins) const {
  //
  // Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for all the container steps.
  // The ranges of ALL the container variables must be defined in the array varMin[fNVar] and varMax[fNVar].
  // This function returns the efficiency relative to this new 'sliced' container, between steps defined in numStep and denStep
  // If useBins=true, varMin and varMax are taken as bin numbers
  //
  
  AliCFContainer* cont = fContainer->MakeSlice(nVars,vars,varMin,varMax,useBins);
  AliCFEffGrid  * eff  = new AliCFEffGrid(Form("%s_sliced",GetName()), Form("%s_sliced",GetTitle()), *cont);
  eff->CalculateEfficiency(numStep,denStep);
  return eff;
}
Commit	Line	Data
563113d0	1	/* $Id$ */
1e9dad92	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	**************************************************************************/
563113d0	16	//--------------------------------------------------------------------//
563113d0	17	// //
fb494025	18	// AliCFEffGrid Class //
563113d0	19	// Class to handle efficiency grids //
	20	// //
	21	// -- Author : S.Arcelli //
	22	// //
	23	// //
	24	// //
	25	//--------------------------------------------------------------------//
	26	//
	27	//
9f6be3a2	28	#include "TMath.h"
9f6be3a2	29	#include "AliLog.h"
563113d0	30	#include "AliCFEffGrid.h"
9f6be3a2	31	#include "TH1D.h"
	32	#include "TH2D.h"
	33	#include "TH3D.h"
563113d0	34
	35	//____________________________________________________________________
	36	ClassImp(AliCFEffGrid)
	37
	38	//____________________________________________________________________
	39	AliCFEffGrid::AliCFEffGrid() :
25488e18	40	AliCFGridSparse(),
563113d0	41	fContainer(0x0),
	42	fSelNum(-1),
	43	fSelDen(-1)
	44	{
	45	//
	46	// default constructor
	47	//
	48	}
	49
	50	//____________________________________________________________________
fb494025	51	AliCFEffGrid::AliCFEffGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn) :
fb494025	52	AliCFGridSparse(name,title,nVarIn,nBinIn),
563113d0	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) :
fb494025	64	AliCFGridSparse(name,title,c.GetNVar(),c.GetNBins()),
5188c2a7	65	fContainer(NULL),
563113d0	66	fSelNum(-1),
	67	fSelDen(-1)
	68	{
	69	//
	70	// main constructor
	71	//
	72	SumW2();
	73	//assign the container;
	74	fContainer=&c;
fb494025	75	for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
91e32eeb	76	Int_t nbins = c.GetNBins(iVar);
	77	Double_t* array=new Double_t[nbins+1] ;
	78	c.GetBinLimits(iVar,array);
	79	SetBinLimits(iVar,array);
	80	delete array ;
fb494025	81	}
fb494025	82	for (Int_t iVar=0; iVar<GetNVar(); iVar++) SetVarTitle(iVar,c.GetVarTitle(iVar));
563113d0	83	}
563113d0	84	//____________________________________________________________________
fb494025	85	AliCFEffGrid::AliCFEffGrid(const AliCFEffGrid& eff) :
fb494025	86	AliCFGridSparse(eff),
563113d0	87	fContainer(0x0),
	88	fSelNum(-1),
	89	fSelDen(-1)
	90	{
	91	//
	92	// copy constructor
	93	//
	94	((AliCFEffGrid &)eff).Copy(*this);
	95	}
	96
	97	//____________________________________________________________________
	98	AliCFEffGrid::~AliCFEffGrid()
	99	{
	100	//
	101	// destructor
	102	//
	103	}
	104
	105	//____________________________________________________________________
	106	AliCFEffGrid &AliCFEffGrid::operator=(const AliCFEffGrid &eff)
	107	{
	108	//
	109	// assigment operator
	110	//
fb494025	111	if (this != &eff) eff.Copy(*this);
563113d0	112	return *this;
563113d0	113	}
563113d0	114
fb494025	115	//____________________________________________________________________
5d14ed73	116	void AliCFEffGrid::CalculateEfficiency(Int_t istep1,Int_t istep2, Option_t *option)
563113d0	117	{
	118	//
	119	// Calculate the efficiency matrix and its error between selection
	120	// Steps istep1 and istep2
	121	//
9be0fa4e	122	// 'option' is used as an argument for THnSparse::Divide
	123	// default is "B" : binomial error calculation
	124	//
563113d0	125
	126	fSelNum=istep1;
	127	fSelDen=istep2;
fb494025	128	AliCFGridSparse *num=GetNum();
fb494025	129	AliCFGridSparse *den=GetDen();
563113d0	130	num->SumW2();
563113d0	131	den->SumW2();
1e9dad92	132	this->SumW2();
5d14ed73	133	this->Divide(num,den,1.,1.,option);
fb494025	134	SetTitle(Form("Efficiency: %s / %s",fContainer->GetStepTitle(istep1),fContainer->GetStepTitle(istep2)));
563113d0	135
9be0fa4e	136	AliInfo(Form("Efficiency calculated for steps %i and %i.",fSelNum,fSelDen));
563113d0	137	}
563113d0	138	//_____________________________________________________________________
1e9dad92	139	Double_t AliCFEffGrid::GetAverage() const
563113d0	140	{
	141	//
	142	// Get the average efficiency
	143	//
	144
1e9dad92	145	Double_t val=0;
	146	Double_t valnum=0;
	147	Double_t valden=0;
563113d0	148
9be0fa4e	149	THnSparse* num = ((AliCFGridSparse*)GetNum())->GetGrid() ;
	150	THnSparse* den = ((AliCFGridSparse*)GetDen())->GetGrid() ;
	151
	152	for (Long_t iBin=0; iBin<num->GetNbins(); iBin++) valnum+=num->GetBinContent(iBin);
	153	for (Long_t iBin=0; iBin<den->GetNbins(); iBin++) valden+=den->GetBinContent(iBin);
	154	if (valden>0) val=valnum/valden;
	155	AliInfo(Form(" The Average Efficiency = %f ",val));
563113d0	156	return val;
	157	}
	158	//_____________________________________________________________________
fb494025	159	// Double_t AliCFEffGrid::GetAverage(const Double_t varMin, const Double_t varMax ) const
	160	// {
	161	// //
	162	// // Get ave efficiency in a range
	163	// // (may not work properly, should be modified)
563113d0	164
fb494025	165	// Double_t val=0;
	166	// Int_t *indexMin = new Int_t[GetNVar()];
	167	// Int_t *indexMax = new Int_t[GetNVar()];
	168	// Int_t *index = new Int_t[GetNVar()];
563113d0	169
fb494025	170	// //Find out the min and max bins
563113d0	171
fb494025	172	// for(Int_t i=0;i<GetNVar();i++){
	173	// Double_t xmin=varMin[i]; // the min values
	174	// Double_t xmax=varMax[i]; // the max values
	175	// Int_t nbins = GetNBins(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	// bins = GetBinLimits(i);
	181	// indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
	182	// indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
	183	// if(xmax>=bins[nbins-1]){
	184	// indexMax[i]=indexMax[i]-1;
	185	// }
	186	// delete [] bins;
	187	// }
563113d0	188
fb494025	189	// Double_t valnum=0;
	190	// Double_t valden=0;
	191	// for (Int_t i=0; i<fNDim; i++) {
	192	// for (Int_t j=0; j<GetNVar(); j++) index[j]=GetBinIndex(j,i);
	193	// Bool_t isIn=kTRUE;
	194	// for (Int_t j=0;j<GetNVar();j++) {
	195	// if(!(index[j]>=indexMin[j] && index[j]<=indexMax[j]))isIn=kFALSE;
	196	// }
	197	// if(isIn){
	198	// valnum+=GetNum()->GetElement(i);
	199	// valden+=GetDen()->GetElement(i);
	200	// }
	201	// }
	202	// delete [] index;
	203	// delete [] indexMin;
	204	// delete [] indexMax;
	205	// if(valden>0)val=valnum/valden;
	206	// AliInfo(Form(" the Average Efficiency = %f ",val));
	207	// return val;
	208	// }
563113d0	209	//____________________________________________________________________
fb494025	210	// void AliCFEffGrid::Copy(TObject& eff) const
	211	// {
	212	// //
	213	// // copy function
	214	// //
	215	// Copy(eff);
	216	// AliCFEffGrid& target = (AliCFEffGrid &) eff;
563113d0	217
fb494025	218	// target.fSelNum=fSelNum;
	219	// target.fSelDen=fSelDen;
	220	// if(fContainer)
	221	// target.fContainer=fContainer;
	222	// }
563113d0	223	//___________________________________________________________________
1e9dad92	224	TH1D *AliCFEffGrid::Project(Int_t ivar) const
563113d0	225	{
	226	//
	227	// Make a 1D projection along variable ivar
	228	//
fb494025	229
	230	if (fSelNum<0 \|\| fSelDen<0) {
	231	AliError("You must call CalculateEfficiency() first !");
	232	return 0x0;
	233	}
a757643f	234	const Int_t nDim = 1 ;
	235	Int_t dim[nDim] = {ivar} ;
	236	THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
	237	THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
ac6b9aed	238	THnSparse* ratio = (THnSparse*)hNum->Clone();
ac6b9aed	239	ratio->Divide(hNum,hDen,1.,1.,"B");
a757643f	240	delete hNum; delete hDen;
fb494025	241	TH1D* h = ratio->Projection(0);
fb494025	242	h->SetXTitle(GetVarTitle(ivar));
91e32eeb	243	h->SetName(Form("%s_proj-%s",GetName(),GetVarTitle(ivar)));
fb494025	244	h->SetTitle(Form("%s projected on %s",GetTitle(),GetVarTitle(ivar)));
fb494025	245	return h ;
563113d0	246	}
563113d0	247	//___________________________________________________________________
1e9dad92	248	TH2D *AliCFEffGrid::Project(Int_t ivar1,Int_t ivar2) const
563113d0	249	{
	250	//
	251	// Make a 2D projection along variable ivar1,ivar2
	252	//
a757643f	253
fb494025	254	if (fSelNum<0 \|\| fSelDen<0) {
	255	AliError("You must call CalculateEfficiency() first !");
	256	return 0x0;
	257	}
a757643f	258	const Int_t nDim = 2 ;
	259	Int_t dim[nDim] = {ivar1,ivar2} ;
	260	THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
	261	THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
ac6b9aed	262	THnSparse* ratio = (THnSparse*)hNum->Clone();
ac6b9aed	263	ratio->Divide(hNum,hDen,1.,1.,"B");
a757643f	264	delete hNum; delete hDen;
91e32eeb	265	TH2D* h = ratio->Projection(1,0);
fb494025	266	h->SetXTitle(GetVarTitle(ivar1));
fb494025	267	h->SetYTitle(GetVarTitle(ivar2));
91e32eeb	268	h->SetName(Form("%s_proj-%s,%s",GetName(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
fb494025	269	h->SetTitle(Form("%s projected on %s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2)));
fb494025	270	return h;
563113d0	271	}
563113d0	272	//___________________________________________________________________
1e9dad92	273	TH3D *AliCFEffGrid::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3) const
563113d0	274	{
	275	//
	276	// Make a 3D projection along variable ivar1,ivar2,ivar3
	277	//
	278
fb494025	279	if (fSelNum<0 \|\| fSelDen<0) {
	280	AliError("You must call CalculateEfficiency() first !");
	281	return 0x0;
	282	}
a757643f	283	const Int_t nDim = 3 ;
	284	Int_t dim[nDim] = {ivar1,ivar2,ivar3} ;
	285	THnSparse* hNum = ((AliCFGridSparse*)GetNum())->GetGrid()->Projection(nDim,dim);
	286	THnSparse* hDen = ((AliCFGridSparse*)GetDen())->GetGrid()->Projection(nDim,dim);
ac6b9aed	287	THnSparse* ratio = (THnSparse*)hNum->Clone();
ac6b9aed	288	ratio->Divide(hNum,hDen,1.,1.,"B");
a757643f	289	delete hNum; delete hDen;
fb494025	290	TH3D* h = ratio->Projection(0,1,2);
	291	h->SetXTitle(GetVarTitle(ivar1));
	292	h->SetYTitle(GetVarTitle(ivar2));
	293	h->SetZTitle(GetVarTitle(ivar3));
91e32eeb	294	h->SetName(Form("%s_proj-%s,%s,%s",GetName(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
fb494025	295	h->SetTitle(Form("%s projected on %s-%s-%s",GetTitle(),GetVarTitle(ivar1),GetVarTitle(ivar2),GetVarTitle(ivar3)));
fb494025	296	return h;
563113d0	297	}
a757643f	298	//___________________________________________________________________
98a5f772	299	AliCFEffGrid* AliCFEffGrid::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t numStep, Int_t denStep, Bool_t useBins) const {
a757643f	300	//
	301	// Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for all the container steps.
	302	// The ranges of ALL the container variables must be defined in the array varMin[fNVar] and varMax[fNVar].
98a5f772	303	// This function returns the efficiency relative to this new 'sliced' container, between steps defined in numStep and denStep
98a5f772	304	// If useBins=true, varMin and varMax are taken as bin numbers
a757643f	305	//
fb494025	306
98a5f772	307	AliCFContainer* cont = fContainer->MakeSlice(nVars,vars,varMin,varMax,useBins);
a757643f	308	AliCFEffGrid * eff = new AliCFEffGrid(Form("%s_sliced",GetName()), Form("%s_sliced",GetTitle()), *cont);
	309	eff->CalculateEfficiency(numStep,denStep);
	310	return eff;
	311	}