[u/mrichter/AliRoot.git] / STEER / STEERBase / AliCheb3DCalc.h

#ifndef ALICHEB3DCALC_H
#define ALICHEB3DCALC_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */
#include <TNamed.h>
class TSystem;
//
// Author: Ruben Shahoyan
// ruben.shahoyan@cern.ch   09/09/2006
// See Comments in AliCheb3D.h
//


// to decrease the compilable code size comment this define. This will exclude the routines 
// used for the calculation and saving of the coefficients. 
//#define _INC_CREATION_ALICHEB3D_

// when _BRING_TO_BOUNDARY_ is defined, the point outside of the fitted folume is assumed
// to be on the surface 
// #define _BRING_TO_BOUNDARY_
//


class AliCheb3DCalc: public TNamed
{
 public:
  AliCheb3DCalc();
  AliCheb3DCalc(const AliCheb3DCalc& src);
  AliCheb3DCalc(FILE* stream);
  ~AliCheb3DCalc()                                                           {Clear();}
  //
  AliCheb3DCalc& operator=(const AliCheb3DCalc& rhs);
  void       Print(const Option_t* opt="")                              const;
  void       LoadData(FILE* stream);
  Float_t    EvalDeriv(int dim, const Float_t  *par)                    const;
  Float_t    EvalDeriv2(int dim1,int dim2, const Float_t  *par)         const;
  //
#ifdef _INC_CREATION_ALICHEB3D_
  void       SaveData(const char* outfile,Bool_t append=kFALSE)         const;
  void       SaveData(FILE* stream=stdout)                              const;
#endif
  //
  void       InitRows(int nr);
  void       InitCols(int nc);
  void       SetPrecision(Float_t prc=1e-6)                                   {fPrec = prc;}
  Float_t    GetPrecision()                                             const {return fPrec;}
  Int_t      GetNCoefs()                                                const {return fNCoefs;}
  Int_t      GetNCols()                                                 const {return (Int_t)fNCols;}
  Int_t      GetNRows()                                                 const {return (Int_t)fNRows;}
  Int_t      GetNElemBound2D()                                          const {return (Int_t)fNElemBound2D;}  
  Int_t      GetMaxColsAtRow()                                          const;
  UShort_t*  GetNColsAtRow()                                            const {return fNColsAtRow;}
  UShort_t*  GetColAtRowBg()                                            const {return fColAtRowBg;}
  void       InitElemBound2D(int ne);
  UShort_t*  GetCoefBound2D0()                                          const {return fCoefBound2D0;}
  UShort_t*  GetCoefBound2D1()                                          const {return fCoefBound2D1;}
  void       Clear(const Option_t* option = "");
  static Float_t    ChebEval1D(Float_t  x, const Float_t * array, int ncf);
  static Float_t    ChebEval1Deriv(Float_t  x, const Float_t * array, int ncf);
  static Float_t    ChebEval1Deriv2(Float_t  x, const Float_t * array, int ncf);
  void       InitCoefs(int nc);
  Float_t *  GetCoefs()                                                 const {return fCoefs;}
  //
  static void ReadLine(TString& str,FILE* stream);
  //
  Float_t    Eval(const Float_t  *par)                                  const;
  Double_t   Eval(const Double_t *par)                                  const;
  //
 protected:
  Int_t      fNCoefs;            // total number of coeeficients
  Int_t      fNRows;             // number of significant rows in the 3D coeffs matrix
  Int_t      fNCols;             // max number of significant cols in the 3D coeffs matrix
  Int_t      fNElemBound2D;      // number of elements (fNRows*fNCols) to store for the 2D boundary of significant coeffs
  UShort_t*  fNColsAtRow;        //[fNRows] number of sighificant columns (2nd dim) at each row of 3D coefs matrix
  UShort_t*  fColAtRowBg;        //[fNRows] beginnig of significant columns (2nd dim) for row in the 2D boundary matrix
  UShort_t*  fCoefBound2D0;      //[fNElemBound2D] 2D matrix defining the boundary of significance for 3D coeffs.matrix (Ncoefs for col/row)
  UShort_t*  fCoefBound2D1;      //[fNElemBound2D] 2D matrix defining the start beginnig of significant coeffs for col/row
  Float_t *  fCoefs;             //[fNCoefs] array of Chebyshev coefficients
  //
  Float_t *  fTmpCf1;            //[fNCols] temp. coeffs for 2d summation
  Float_t *  fTmpCf0;            //[fNRows] temp. coeffs for 1d summation
  //
  Float_t    fPrec;              // Requested precision
  ClassDef(AliCheb3DCalc,4)      // Class for interpolation of 3D->1 function by Chebyshev parametrization 
};

//__________________________________________________________________________________________
inline Float_t AliCheb3DCalc::ChebEval1D(Float_t  x, const Float_t * array, int ncf ) 
{
  // evaluate 1D Chebyshev parameterization. x is the argument mapped to [-1:1] interval
  if (ncf<=0) return 0;
  Float_t b0, b1, b2, x2 = x+x;
  b0 = array[--ncf]; 
  b1 = b2 = 0;
  for (int i=ncf;i--;) {
    b2 = b1;
    b1 = b0;
    b0 = array[i] + x2*b1 -b2;
  }
  return b0 - x*b1;
  //
}

//__________________________________________________________________________________________
inline Float_t AliCheb3DCalc::Eval(const Float_t  *par) const 
{
  // evaluate Chebyshev parameterization for 3D function.
  // VERY IMPORTANT: par must contain the function arguments ALREADY MAPPED to [-1:1] interval
  if (!fNRows) return 0.;
  int ncfRC;
  for (int id0=fNRows;id0--;) {
    int nCLoc = fNColsAtRow[id0];                   // number of significant coefs on this row
    int col0  = fColAtRowBg[id0];                   // beginning of local column in the 2D boundary matrix
    for (int id1=nCLoc;id1--;) {
      int id = id1+col0;
      fTmpCf1[id1] = (ncfRC=fCoefBound2D0[id]) ? ChebEval1D(par[2],fCoefs + fCoefBound2D1[id], ncfRC) : 0.0;
    }
    fTmpCf0[id0] = nCLoc>0 ? ChebEval1D(par[1],fTmpCf1,nCLoc):0.0;
  }
  return ChebEval1D(par[0],fTmpCf0,fNRows);
}

//__________________________________________________________________________________________
inline Double_t AliCheb3DCalc::Eval(const Double_t  *par) const 
{
  // evaluate Chebyshev parameterization for 3D function.
  // VERY IMPORTANT: par must contain the function arguments ALREADY MAPPED to [-1:1] interval
  if (!fNRows) return 0.;
  int ncfRC;
  for (int id0=fNRows;id0--;) {
    int nCLoc = fNColsAtRow[id0];                   // number of significant coefs on this row
    int col0  = fColAtRowBg[id0];                   // beginning of local column in the 2D boundary matrix
    for (int id1=nCLoc;id1--;) {
      int id = id1+col0;
      fTmpCf1[id1] = (ncfRC=fCoefBound2D0[id]) ? ChebEval1D(par[2],fCoefs + fCoefBound2D1[id], ncfRC) : 0.0;
    }
    fTmpCf0[id0] = nCLoc>0 ? ChebEval1D(par[1],fTmpCf1,nCLoc):0.0;
  }
  return ChebEval1D(par[0],fTmpCf0,fNRows);
}

#endif
Commit	Line	Data
99adacae	1	#ifndef ALICHEB3DCALC_H
	2	#define ALICHEB3DCALC_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
40389866	5	#include <TNamed.h>
5406439e	6	class TSystem;
99adacae	7	//
	8	// Author: Ruben Shahoyan
	9	// ruben.shahoyan@cern.ch 09/09/2006
	10	// See Comments in AliCheb3D.h
	11	//
40389866	12
	13
	14	// to decrease the compilable code size comment this define. This will exclude the routines
	15	// used for the calculation and saving of the coefficients.
1d18ebe0	16	//#define _INC_CREATION_ALICHEB3D_
40389866	17
	18	// when _BRING_TO_BOUNDARY_ is defined, the point outside of the fitted folume is assumed
	19	// to be on the surface
5de97576	20	// #define _BRING_TO_BOUNDARY_
40389866	21	//
40389866	22
99adacae	23
	24	class AliCheb3DCalc: public TNamed
	25	{
	26	public:
	27	AliCheb3DCalc();
40389866	28	AliCheb3DCalc(const AliCheb3DCalc& src);
	29	AliCheb3DCalc(FILE* stream);
	30	~AliCheb3DCalc() {Clear();}
99adacae	31	//
40389866	32	AliCheb3DCalc& operator=(const AliCheb3DCalc& rhs);
5406439e	33	void Print(const Option_t* opt="") const;
99adacae	34	void LoadData(FILE* stream);
5406439e	35	Float_t EvalDeriv(int dim, const Float_t *par) const;
5406439e	36	Float_t EvalDeriv2(int dim1,int dim2, const Float_t *par) const;
99adacae	37	//
99adacae	38	#ifdef _INC_CREATION_ALICHEB3D_
5406439e	39	void SaveData(const char* outfile,Bool_t append=kFALSE) const;
5406439e	40	void SaveData(FILE* stream=stdout) const;
99adacae	41	#endif
99adacae	42	//
99adacae	43	void InitRows(int nr);
99adacae	44	void InitCols(int nc);
f69ec3f4	45	void SetPrecision(Float_t prc=1e-6) {fPrec = prc;}
f69ec3f4	46	Float_t GetPrecision() const {return fPrec;}
2572efdf	47	Int_t GetNCoefs() const {return fNCoefs;}
1d18ebe0	48	Int_t GetNCols() const {return (Int_t)fNCols;}
	49	Int_t GetNRows() const {return (Int_t)fNRows;}
	50	Int_t GetNElemBound2D() const {return (Int_t)fNElemBound2D;}
2572efdf	51	Int_t GetMaxColsAtRow() const;
1d18ebe0	52	UShort_t* GetNColsAtRow() const {return fNColsAtRow;}
1d18ebe0	53	UShort_t* GetColAtRowBg() const {return fColAtRowBg;}
40389866	54	void InitElemBound2D(int ne);
1d18ebe0	55	UShort_t* GetCoefBound2D0() const {return fCoefBound2D0;}
1d18ebe0	56	UShort_t* GetCoefBound2D1() const {return fCoefBound2D1;}
5406439e	57	void Clear(const Option_t* option = "");
1cf34ee8	58	static Float_t ChebEval1D(Float_t x, const Float_t * array, int ncf);
	59	static Float_t ChebEval1Deriv(Float_t x, const Float_t * array, int ncf);
	60	static Float_t ChebEval1Deriv2(Float_t x, const Float_t * array, int ncf);
40389866	61	void InitCoefs(int nc);
99adacae	62	Float_t * GetCoefs() const {return fCoefs;}
99adacae	63	//
40389866	64	static void ReadLine(TString& str,FILE* stream);
40389866	65	//
1d18ebe0	66	Float_t Eval(const Float_t *par) const;
1d18ebe0	67	Double_t Eval(const Double_t *par) const;
ff66b122	68	//
99adacae	69	protected:
	70	Int_t fNCoefs; // total number of coeeficients
	71	Int_t fNRows; // number of significant rows in the 3D coeffs matrix
	72	Int_t fNCols; // max number of significant cols in the 3D coeffs matrix
	73	Int_t fNElemBound2D; // number of elements (fNRows*fNCols) to store for the 2D boundary of significant coeffs
1d18ebe0	74	UShort_t* fNColsAtRow; //[fNRows] number of sighificant columns (2nd dim) at each row of 3D coefs matrix
	75	UShort_t* fColAtRowBg; //[fNRows] beginnig of significant columns (2nd dim) for row in the 2D boundary matrix
	76	UShort_t* fCoefBound2D0; //[fNElemBound2D] 2D matrix defining the boundary of significance for 3D coeffs.matrix (Ncoefs for col/row)
	77	UShort_t* fCoefBound2D1; //[fNElemBound2D] 2D matrix defining the start beginnig of significant coeffs for col/row
99adacae	78	Float_t * fCoefs; //[fNCoefs] array of Chebyshev coefficients
	79	//
	80	Float_t * fTmpCf1; //[fNCols] temp. coeffs for 2d summation
	81	Float_t * fTmpCf0; //[fNRows] temp. coeffs for 1d summation
	82	//
f69ec3f4	83	Float_t fPrec; // Requested precision
f69ec3f4	84	ClassDef(AliCheb3DCalc,4) // Class for interpolation of 3D->1 function by Chebyshev parametrization
99adacae	85	};
99adacae	86
40389866	87	//__________________________________________________________________________________________
40389866	88	inline Float_t AliCheb3DCalc::ChebEval1D(Float_t x, const Float_t * array, int ncf )
99adacae	89	{
99adacae	90	// evaluate 1D Chebyshev parameterization. x is the argument mapped to [-1:1] interval
db83d72f	91	if (ncf<=0) return 0;
40389866	92	Float_t b0, b1, b2, x2 = x+x;
99adacae	93	b0 = array[--ncf];
	94	b1 = b2 = 0;
	95	for (int i=ncf;i--;) {
	96	b2 = b1;
	97	b1 = b0;
	98	b0 = array[i] + x2*b1 -b2;
	99	}
	100	return b0 - x*b1;
40389866	101	//
99adacae	102	}
99adacae	103
1d18ebe0	104	//__________________________________________________________________________________________
	105	inline Float_t AliCheb3DCalc::Eval(const Float_t *par) const
	106	{
	107	// evaluate Chebyshev parameterization for 3D function.
	108	// VERY IMPORTANT: par must contain the function arguments ALREADY MAPPED to [-1:1] interval
	109	if (!fNRows) return 0.;
	110	int ncfRC;
	111	for (int id0=fNRows;id0--;) {
	112	int nCLoc = fNColsAtRow[id0]; // number of significant coefs on this row
	113	int col0 = fColAtRowBg[id0]; // beginning of local column in the 2D boundary matrix
	114	for (int id1=nCLoc;id1--;) {
	115	int id = id1+col0;
	116	fTmpCf1[id1] = (ncfRC=fCoefBound2D0[id]) ? ChebEval1D(par[2],fCoefs + fCoefBound2D1[id], ncfRC) : 0.0;
	117	}
	118	fTmpCf0[id0] = nCLoc>0 ? ChebEval1D(par[1],fTmpCf1,nCLoc):0.0;
	119	}
	120	return ChebEval1D(par[0],fTmpCf0,fNRows);
	121	}
	122
	123	//__________________________________________________________________________________________
	124	inline Double_t AliCheb3DCalc::Eval(const Double_t *par) const
	125	{
	126	// evaluate Chebyshev parameterization for 3D function.
	127	// VERY IMPORTANT: par must contain the function arguments ALREADY MAPPED to [-1:1] interval
	128	if (!fNRows) return 0.;
	129	int ncfRC;
	130	for (int id0=fNRows;id0--;) {
	131	int nCLoc = fNColsAtRow[id0]; // number of significant coefs on this row
	132	int col0 = fColAtRowBg[id0]; // beginning of local column in the 2D boundary matrix
	133	for (int id1=nCLoc;id1--;) {
	134	int id = id1+col0;
	135	fTmpCf1[id1] = (ncfRC=fCoefBound2D0[id]) ? ChebEval1D(par[2],fCoefs + fCoefBound2D1[id], ncfRC) : 0.0;
	136	}
	137	fTmpCf0[id0] = nCLoc>0 ? ChebEval1D(par[1],fTmpCf1,nCLoc):0.0;
	138	}
	139	return ChebEval1D(par[0],fTmpCf0,fNRows);
	140	}
	141
99adacae	142	#endif