[u/mrichter/AliRoot.git] / CORRFW / AliCFGridSparse.h

#ifndef ALICFGRIDSPARSE_H
#define ALICFGRIDSPARSE_H
//--------------------------------------------------------------------//
//                                                                    //
// AliCFGridSparse.cxx Class                                          //
// Class to handle N-dim maps for the correction Framework            // 
// uses a THnSparse to store the grid                                 //
// Author:S.Arcelli, silvia.arcelli@cern.ch
//--------------------------------------------------------------------//

#include "AliCFFrame.h"
#include "THnSparse.h"
#include "AliLog.h"
#include "TAxis.h"

class TH1D;
class TH2D;
class TH3D;

class AliCFGridSparse : public AliCFFrame
{
 public:
  AliCFGridSparse();
  AliCFGridSparse(const Char_t* name, const Char_t* title);
  AliCFGridSparse(const Char_t* name, const Char_t* title, Int_t nVarIn, const Int_t* nBinIn);
  AliCFGridSparse(const AliCFGridSparse& c);
  virtual ~AliCFGridSparse();
  AliCFGridSparse& operator=(const AliCFGridSparse& c);
  virtual void Copy(TObject& c) const;

  // AliCFFrame functions
  virtual Int_t      GetNVar() const {return fData->GetNdimensions();}
  virtual void       PrintBinLimits() const ;
  virtual void       PrintNBins() const ; 
  virtual void       SetBinLimits(Int_t ivar, Double_t min, Double_t max); // for uniform bin width only
  virtual void       SetBinLimits(Int_t ivar, const Double_t * array);     // for variable or uniform bin width
  virtual void       GetBinLimits(Int_t ivar, Double_t * array) const ;
  virtual Double_t * GetBinLimits(Int_t ivar) const ;
  virtual Long_t     GetNBinsTotal() const ;
  virtual Long_t     GetNFilledBins() const {return fData->GetNbins();}
  virtual Int_t      GetNBins(Int_t ivar) const {return fData->GetAxis(ivar)->GetNbins();}
  virtual Int_t *    GetNBins() const ;
  virtual Float_t    GetBinCenter(Int_t ivar,Int_t ibin) const ;
  virtual Float_t    GetBinSize  (Int_t ivar,Int_t ibin) const ;
  //virtual void       GetBinCenters(const Int_t *ibin, Float_t *binCenter) const ;
  //virtual void       GetBinSizes  (const Int_t *ibin, Float_t *binSizes)  const ;
  virtual TAxis    * GetAxis(Int_t ivar) const {return fData->GetAxis(ivar);}

  virtual void          SetVarTitle(Int_t ivar, const Char_t* lab) {fData->GetAxis(ivar)->SetTitle(lab);}
  virtual const Char_t* GetVarTitle(Int_t ivar) const {return GetAxis(ivar)->GetTitle();}
  virtual Int_t         GetVar(const Char_t* title) const ; // returns the variable corresponding to the given title

  // probably not needed anymore
  //virtual Int_t      GetBinIndex(const Int_t *ibin) const ;
  //virtual void       GetBinIndex(Int_t iel, const Int_t *ibin) const ;
  //virtual Int_t      GetBinIndex(Int_t ivar, Int_t ind) const ;

  virtual void    Fill(const Double_t *var, Double_t weight=1.);
  virtual Float_t GetEntries()const;
  virtual Float_t GetElement(Long_t iel)               const; 
  virtual Float_t GetElement(const Int_t *bin)         const; 
  virtual Float_t GetElement(const Double_t *var)      const; 
  virtual Float_t GetElementError(Long_t iel)          const;  
  virtual Float_t GetElementError(const Int_t *bin)    const; 
  virtual Float_t GetElementError(const Double_t *var) const; 
  virtual void    SetElement(Long_t iel, Float_t val); 
  virtual void    SetElement(const Int_t *bin, Float_t val); 
  virtual void    SetElement(const Double_t *var, Float_t val); 
  virtual void    SetElementError(Long_t iel, Float_t val); 
  virtual void    SetElementError(const Int_t *bin, Float_t val) ; 
  virtual void    SetElementError(const Double_t *var, Float_t val); 

  virtual TH1D*            Project( Int_t ivar) const;
  virtual TH2D*            Project( Int_t ivar1, Int_t ivar2) const;
  virtual TH3D*            Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
  virtual AliCFGridSparse* Project(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Bool_t useBins=0) const ;
  virtual TH1D*            Slice(Int_t ivar, const Double_t* varMin, const Double_t* varMax, Bool_t useBins=0) const ; 
  virtual TH2D*            Slice(Int_t ivar1, Int_t ivar2, const Double_t *varMin, const Double_t *varMax, Bool_t useBins=0) const ;
  virtual TH3D*            Slice(Int_t ivar1, Int_t ivar2, Int_t ivar3, const Double_t *varMin, const Double_t *varMax, Bool_t useBins=0) const ;
  virtual void             SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax) ;
  virtual void             SetRangeUser(const Double_t* varMin, const Double_t* varMax) ;
  virtual void             UseAxisRange(Bool_t b) const ;

  //basic operations
  virtual void     SumW2();
  virtual void     Add(const AliCFGridSparse* aGrid, Double_t c=1.);
  virtual void     Add(const AliCFGridSparse* aGrid1 ,const AliCFGridSparse* aGrid2, Double_t c1=1.,Double_t c2=1.);
  virtual void     Multiply(const AliCFGridSparse* aGrid, Double_t c=1.);
  virtual void     Multiply(const AliCFGridSparse* aGrid1,const AliCFGridSparse* aGrid2, Double_t c1=1.,Double_t c2=1.);
  virtual void     Divide(const AliCFGridSparse* aGrid, Double_t c=1.);
  virtual void     Divide(const AliCFGridSparse* aGrid1, const AliCFGridSparse* aGrid2, Double_t c1=1., Double_t c2=1.,Option_t *option=0);
  virtual void     Rebin(const Int_t* group);
  virtual void     Scale(Long_t iel, const Double_t *fact); 
  virtual void     Scale(const Int_t* bin, const Double_t *fact); 
  virtual void     Scale(const Double_t* var, const Double_t *fact); 
  virtual void     Scale(const Double_t *fact); // To normalize MC to int lumi, for ex. 
  virtual Int_t    CheckStats(Double_t thr) const;
  virtual Int_t    GetSumW2() const {return fSumW2;};
  virtual Double_t GetIntegral() const;
  //virtual Double_t GetIntegral(const Double_t *varMin, const Double_t *varMax) const;
  virtual Long64_t Merge(TCollection* list);

  virtual void     SetGrid(THnSparse* grid) {fData=grid;}
  THnSparse   *    GetGrid() const {return fData;}

  virtual Float_t GetOverFlows (Int_t var, Bool_t excl=kFALSE) const;
  virtual Float_t GetUnderFlows(Int_t var, Bool_t excl=kFALSE) const;
  virtual Long_t  GetEmptyBins() const;

  // to be implemented
  //------------------
  //virtual Int_t    GetEmptyBins(Double_t *varMin,Double_t *varMax) const;
  //virtual Double_t GetIntegral(Int_t *binMin,Int_t *binMax) const;

 protected:

  //protected functions
  //Float_t  GetSum(Int_t ivar, const Int_t *binMin, const Int_t* binMax) const; 
  void     GetScaledValues(const Double_t *fact, const Double_t *in, Double_t *out) const;

  // data members:
  Bool_t      fSumW2    ; // Flag to check if calculation of squared weights enabled
  THnSparse  *fData     ; // The data Container: a THnSparse  

  ClassDef(AliCFGridSparse,3);
};


//inline functions :

inline Long_t AliCFGridSparse::GetNBinsTotal() const {
  Long_t n=1;
  for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
    n *= fData->GetAxis(iVar)->GetNbins();
  }
  return n ;
}

inline void AliCFGridSparse::PrintNBins() const
{
  //
  // printing the array containing the # of bins  
  //
  for (Int_t i=0;i<GetNVar();i++) {
    AliInfo(Form("bins in axis %i are: %i",i,fData->GetAxis(i)->GetNbins()));
  }
} 

inline void AliCFGridSparse::PrintBinLimits() const
{
  //
  // printing the bin limits for each variable  
  //
  for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
    AliInfo(Form("variable %d :",iVar));
    const Int_t nBins = GetNBins(iVar) ;
    Double_t *array = new Double_t[nBins+1];
    GetBinLimits(iVar,array);
    for (Int_t iBin=0; iBin<nBins; iBin++) {
      AliInfo(Form("    bin limit index %i is: %e",iBin,array[iBin]));
    }
    delete [] array ;
  }
}

inline void AliCFGridSparse::GetBinLimits(Int_t ivar, Double_t * array) const {
  TAxis * axis = fData->GetAxis(ivar) ;
  Int_t nBins = axis->GetNbins();
  for (Int_t iBin=0; iBin<nBins; iBin++) array[iBin] = axis->GetBinLowEdge(iBin+1);
  array[nBins] = axis->GetBinUpEdge(nBins);
}

inline Int_t* AliCFGridSparse::GetNBins() const {
  Int_t *bins = new Int_t[GetNVar()];
  for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
    bins[iVar] = GetNBins(iVar) ;
  }
  return bins;
}

inline Double_t* AliCFGridSparse::GetBinLimits(Int_t ivar) const {
  Double_t * binLimits = new Double_t[GetNBins(ivar)+1] ;
  GetBinLimits(ivar,binLimits);
  return binLimits;
}

inline Int_t AliCFGridSparse::GetVar(const Char_t* title) const {
  TString str(title);
  for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
    if (!str.CompareTo(GetVarTitle(iVar))) return iVar;
  }
  AliError("Variable not found");
  return -1;
}

#endif
Commit	Line	Data
db6722a5	1	#ifndef ALICFGRIDSPARSE_H
	2	#define ALICFGRIDSPARSE_H
	3	//--------------------------------------------------------------------//
	4	// //
	5	// AliCFGridSparse.cxx Class //
	6	// Class to handle N-dim maps for the correction Framework //
	7	// uses a THnSparse to store the grid //
	8	// Author:S.Arcelli, silvia.arcelli@cern.ch
	9	//--------------------------------------------------------------------//
	10
fb494025	11	#include "AliCFFrame.h"
db6722a5	12	#include "THnSparse.h"
db6722a5	13	#include "AliLog.h"
fb494025	14	#include "TAxis.h"
fb494025	15
db6722a5	16	class TH1D;
	17	class TH2D;
	18	class TH3D;
	19
fb494025	20	class AliCFGridSparse : public AliCFFrame
db6722a5	21	{
	22	public:
	23	AliCFGridSparse();
fb494025	24	AliCFGridSparse(const Char_t* name, const Char_t* title);
	25	AliCFGridSparse(const Char_t* name, const Char_t* title, Int_t nVarIn, const Int_t* nBinIn);
	26	AliCFGridSparse(const AliCFGridSparse& c);
db6722a5	27	virtual ~AliCFGridSparse();
fb494025	28	AliCFGridSparse& operator=(const AliCFGridSparse& c);
fb494025	29	virtual void Copy(TObject& c) const;
db6722a5	30
fb494025	31	// AliCFFrame functions
	32	virtual Int_t GetNVar() const {return fData->GetNdimensions();}
	33	virtual void PrintBinLimits() const ;
	34	virtual void PrintNBins() const ;
aa29aca9	35	virtual void SetBinLimits(Int_t ivar, Double_t min, Double_t max); // for uniform bin width only
aa29aca9	36	virtual void SetBinLimits(Int_t ivar, const Double_t * array); // for variable or uniform bin width
fb494025	37	virtual void GetBinLimits(Int_t ivar, Double_t * array) const ;
	38	virtual Double_t * GetBinLimits(Int_t ivar) const ;
	39	virtual Long_t GetNBinsTotal() const ;
	40	virtual Long_t GetNFilledBins() const {return fData->GetNbins();}
	41	virtual Int_t GetNBins(Int_t ivar) const {return fData->GetAxis(ivar)->GetNbins();}
	42	virtual Int_t * GetNBins() const ;
	43	virtual Float_t GetBinCenter(Int_t ivar,Int_t ibin) const ;
	44	virtual Float_t GetBinSize (Int_t ivar,Int_t ibin) const ;
	45	//virtual void GetBinCenters(const Int_t ibin, Float_t binCenter) const ;
	46	//virtual void GetBinSizes (const Int_t ibin, Float_t binSizes) const ;
	47	virtual TAxis * GetAxis(Int_t ivar) const {return fData->GetAxis(ivar);}
db6722a5	48
fb494025	49	virtual void SetVarTitle(Int_t ivar, const Char_t* lab) {fData->GetAxis(ivar)->SetTitle(lab);}
	50	virtual const Char_t* GetVarTitle(Int_t ivar) const {return GetAxis(ivar)->GetTitle();}
	51	virtual Int_t GetVar(const Char_t* title) const ; // returns the variable corresponding to the given title
db6722a5	52
fb494025	53	// probably not needed anymore
	54	//virtual Int_t GetBinIndex(const Int_t *ibin) const ;
	55	//virtual void GetBinIndex(Int_t iel, const Int_t *ibin) const ;
	56	//virtual Int_t GetBinIndex(Int_t ivar, Int_t ind) const ;
db6722a5	57
fb494025	58	virtual void Fill(const Double_t *var, Double_t weight=1.);
	59	virtual Float_t GetEntries()const;
	60	virtual Float_t GetElement(Long_t iel) const;
	61	virtual Float_t GetElement(const Int_t *bin) const;
	62	virtual Float_t GetElement(const Double_t *var) const;
	63	virtual Float_t GetElementError(Long_t iel) const;
	64	virtual Float_t GetElementError(const Int_t *bin) const;
	65	virtual Float_t GetElementError(const Double_t *var) const;
	66	virtual void SetElement(Long_t iel, Float_t val);
	67	virtual void SetElement(const Int_t *bin, Float_t val);
	68	virtual void SetElement(const Double_t *var, Float_t val);
	69	virtual void SetElementError(Long_t iel, Float_t val);
	70	virtual void SetElementError(const Int_t *bin, Float_t val) ;
	71	virtual void SetElementError(const Double_t *var, Float_t val);
db6722a5	72
9105291d	73	virtual TH1D* Project( Int_t ivar) const;
	74	virtual TH2D* Project( Int_t ivar1, Int_t ivar2) const;
	75	virtual TH3D* Project( Int_t ivar1, Int_t ivar2,Int_t ivar3) const;
98a5f772	76	virtual AliCFGridSparse* Project(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Bool_t useBins=0) const ;
	77	virtual TH1D* Slice(Int_t ivar, const Double_t* varMin, const Double_t* varMax, Bool_t useBins=0) const ;
	78	virtual TH2D* Slice(Int_t ivar1, Int_t ivar2, const Double_t varMin, const Double_t varMax, Bool_t useBins=0) const ;
	79	virtual TH3D* Slice(Int_t ivar1, Int_t ivar2, Int_t ivar3, const Double_t varMin, const Double_t varMax, Bool_t useBins=0) const ;
fb494025	80	virtual void SetRangeUser(Int_t iVar, Double_t varMin, Double_t varMax) ;
	81	virtual void SetRangeUser(const Double_t* varMin, const Double_t* varMax) ;
	82	virtual void UseAxisRange(Bool_t b) const ;
db6722a5	83
db6722a5	84	//basic operations
fb494025	85	virtual void SumW2();
	86	virtual void Add(const AliCFGridSparse* aGrid, Double_t c=1.);
	87	virtual void Add(const AliCFGridSparse* aGrid1 ,const AliCFGridSparse* aGrid2, Double_t c1=1.,Double_t c2=1.);
	88	virtual void Multiply(const AliCFGridSparse* aGrid, Double_t c=1.);
	89	virtual void Multiply(const AliCFGridSparse* aGrid1,const AliCFGridSparse* aGrid2, Double_t c1=1.,Double_t c2=1.);
	90	virtual void Divide(const AliCFGridSparse* aGrid, Double_t c=1.);
	91	virtual void Divide(const AliCFGridSparse* aGrid1, const AliCFGridSparse* aGrid2, Double_t c1=1., Double_t c2=1.,Option_t *option=0);
	92	virtual void Rebin(const Int_t* group);
	93	virtual void Scale(Long_t iel, const Double_t *fact);
	94	virtual void Scale(const Int_t* bin, const Double_t *fact);
	95	virtual void Scale(const Double_t* var, const Double_t *fact);
	96	virtual void Scale(const Double_t *fact); // To normalize MC to int lumi, for ex.
	97	virtual Int_t CheckStats(Double_t thr) const;
	98	virtual Int_t GetSumW2() const {return fSumW2;};
	99	virtual Double_t GetIntegral() const;
	100	//virtual Double_t GetIntegral(const Double_t varMin, const Double_t varMax) const;
	101	virtual Long64_t Merge(TCollection* list);
db6722a5	102
fb494025	103	virtual void SetGrid(THnSparse* grid) {fData=grid;}
fb494025	104	THnSparse * GetGrid() const {return fData;}
db6722a5	105
fb494025	106	virtual Float_t GetOverFlows (Int_t var, Bool_t excl=kFALSE) const;
	107	virtual Float_t GetUnderFlows(Int_t var, Bool_t excl=kFALSE) const;
	108	virtual Long_t GetEmptyBins() const;
db6722a5	109
fb494025	110	// to be implemented
	111	//------------------
	112	//virtual Int_t GetEmptyBins(Double_t varMin,Double_t varMax) const;
	113	//virtual Double_t GetIntegral(Int_t binMin,Int_t binMax) const;
db6722a5	114
db6722a5	115	protected:
db6722a5	116
fb494025	117	//protected functions
	118	//Float_t GetSum(Int_t ivar, const Int_t binMin, const Int_t binMax) const;
	119	void GetScaledValues(const Double_t fact, const Double_t in, Double_t *out) const;
	120
	121	// data members:
	122	Bool_t fSumW2 ; // Flag to check if calculation of squared weights enabled
	123	THnSparse *fData ; // The data Container: a THnSparse
	124
	125	ClassDef(AliCFGridSparse,3);
db6722a5	126	};
fb494025	127
	128
	129	//inline functions :
	130
	131	inline Long_t AliCFGridSparse::GetNBinsTotal() const {
	132	Long_t n=1;
	133	for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
	134	n *= fData->GetAxis(iVar)->GetNbins();
	135	}
	136	return n ;
	137	}
	138
	139	inline void AliCFGridSparse::PrintNBins() const
	140	{
	141	//
	142	// printing the array containing the # of bins
	143	//
	144	for (Int_t i=0;i<GetNVar();i++) {
	145	AliInfo(Form("bins in axis %i are: %i",i,fData->GetAxis(i)->GetNbins()));
	146	}
	147	}
	148
	149	inline void AliCFGridSparse::PrintBinLimits() const
	150	{
	151	//
	152	// printing the bin limits for each variable
	153	//
	154	for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
	155	AliInfo(Form("variable %d :",iVar));
	156	const Int_t nBins = GetNBins(iVar) ;
	157	Double_t *array = new Double_t[nBins+1];
	158	GetBinLimits(iVar,array);
	159	for (Int_t iBin=0; iBin<nBins; iBin++) {
	160	AliInfo(Form(" bin limit index %i is: %e",iBin,array[iBin]));
	161	}
	162	delete [] array ;
	163	}
	164	}
	165
	166	inline void AliCFGridSparse::GetBinLimits(Int_t ivar, Double_t * array) const {
	167	TAxis * axis = fData->GetAxis(ivar) ;
	168	Int_t nBins = axis->GetNbins();
	169	for (Int_t iBin=0; iBin<nBins; iBin++) array[iBin] = axis->GetBinLowEdge(iBin+1);
	170	array[nBins] = axis->GetBinUpEdge(nBins);
	171	}
	172
	173	inline Int_t* AliCFGridSparse::GetNBins() const {
89ed7ae9	174	Int_t *bins = new Int_t[GetNVar()];
fb494025	175	for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
	176	bins[iVar] = GetNBins(iVar) ;
	177	}
	178	return bins;
	179	}
	180
	181	inline Double_t* AliCFGridSparse::GetBinLimits(Int_t ivar) const {
	182	Double_t * binLimits = new Double_t[GetNBins(ivar)+1] ;
	183	GetBinLimits(ivar,binLimits);
	184	return binLimits;
	185	}
	186
	187	inline Int_t AliCFGridSparse::GetVar(const Char_t* title) const {
	188	TString str(title);
	189	for (Int_t iVar=0; iVar<GetNVar(); iVar++) {
	190	if (!str.CompareTo(GetVarTitle(iVar))) return iVar;
	191	}
	192	AliError("Variable not found");
	193	return -1;
	194	}
	195
db6722a5	196	#endif
db6722a5	197