[u/mrichter/AliRoot.git] / STEER / AliCheb3D.h

#ifndef ALICHEB3D_H
#define ALICHEB3D_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

// Author: ruben.shahoyan@cern.ch   09/09/2006
//
////////////////////////////////////////////////////////////////////////////////
//                                                                            //
// AliCheb3D produces the interpolation of the user 3D->NDimOut arbitrary     //
// function supplied in "void (*fcn)(float* inp,float* out)" format           //
// either in a separate macro file or as a function pointer.                  //
// Only coefficients needed to guarantee the requested precision are kept.    //
//                                                                            //
// The user-callable methods are:                                             //
// To create the interpolation use:                                           //
// AliCheb3D(const char* funName,  // name of the file with user function     //
//          or                                                                //
// AliCheb3D(void (*ptr)(float*,float*),// pointer on the  user function      //
//        Int_t     DimOut,     // dimensionality of the function's output    // 
//        Float_t  *bmin,       // lower 3D bounds of interpolation domain    // 
//        Float_t  *bmax,       // upper 3D bounds of interpolation domain    // 
//        Int_t    *npoints,    // number of points in each of 3 input        //
//                              // dimension, defining the interpolation grid //
//        Float_t   prec=1E-6); // requested max.absolute difference between  //
//                              // the interpolation and any point on grid    //
//                                                                            //
// To test obtained parameterization use the method                           //
// TH1* TestRMS(int idim,int npoints = 1000,TH1* histo=0);                    // 
// it will compare the user output of the user function and interpolation     //
// for idim-th output dimension and fill the difference in the supplied       //
// histogram. If no histogram is supplied, it will be created.                //
//                                                                            //
// To save the interpolation data:                                            //
// SaveData(const char* filename, Bool_t append )                             //
// write text file with data. If append is kTRUE and the output file already  //
// exists, data will be added in the end of the file.                         //
// Alternatively, SaveData(FILE* stream) will write the data to               //
// already existing stream.                                                   //
//                                                                            //
// To read back already stored interpolation use either the constructor       // 
// AliCheb3D(const char* inpFile);                                            //
// or the default constructor AliCheb3D() followed by                         //
// AliCheb3D::LoadData(const char* inpFile);                                  //
//                                                                            //
// To compute the interpolation use Eval(float* par,float *res) method, with  //
// par being 3D vector of arguments (inside the validity region) and res is   //
// the array of DimOut elements for the output.                               //
//                                                                            //
// If only one component (say, idim-th) of the output is needed, use faster   //
// Float_t Eval(Float_t *par,int idim) method.                                //
//                                                                            //
// void Print(option="") will print the name, the ranges of validity and      //
// the absolute precision of the parameterization. Option "l" will also print //
// the information about the number of coefficients for each output           //
// dimension.                                                                 //
//                                                                            //
// NOTE: during the evaluation no check is done for parameter vector being    //
// outside the interpolation region. If there is such a risk, use             //
// Bool_t IsInside(float *par) method. Chebyshev parameterization is not      //
// good for extrapolation!                                                    //
//                                                                            //
// For the properties of Chebyshev parameterization see:                      //
// H.Wind, CERN EP Internal Report, 81-12/Rev.                                //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////


#include <stdio.h>
#include <TNamed.h>
#include <TMethodCall.h>
#include <TMath.h>
#include <TH1.h>
#include <TObjArray.h>

class TString;
class TSystem;
class TRandom;


// 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_

class AliCheb3DCalc: public TNamed
{
 public:
  AliCheb3DCalc();
  AliCheb3DCalc(FILE* stream); // read coefs from text file
  AliCheb3DCalc(const AliCheb3DCalc &src);
  AliCheb3DCalc& operator= (const AliCheb3DCalc &rhs);
  ~AliCheb3DCalc() {Clear();}
  //
  void       Print(Option_t* opt="")                                   const;
  void       LoadData(FILE* stream);
  Float_t    Eval(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
  //
  static void ReadLine(TString& str,FILE* stream);
  //
 protected:
  //
  void       Clear(Option_t* option = "");
  void       Init0();
  Float_t    ChebEval1D(Float_t  x, const Float_t * array, int ncf)     const;  
  void       InitRows(int nr);
  void       InitCols(int nc);
  void       InitElemBound2D(int ne);
  void       InitCoefs(int nc);
  Int_t*     GetNColsAtRow()                                            const {return fNColsAtRow;}
  Int_t*     GetColAtRowBg()                                            const {return fColAtRowBg;}
  Int_t*     GetCoefBound2D0()                                          const {return fCoefBound2D0;}
  Int_t*     GetCoefBound2D1()                                          const {return fCoefBound2D1;}
  Float_t *  GetCoefs()                                                 const {return fCoefs;}
  //
 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
  Int_t*     fNColsAtRow;        //[fNRows] number of sighificant columns (2nd dim) at each row of 3D coefs matrix
  Int_t*     fColAtRowBg;        //[fNRows] beginnig of significant columns (2nd dim) for row in the 2D boundary matrix
  Int_t*     fCoefBound2D0;      //[fNElemBound2D] 2D matrix defining the boundary of significance for 3D coeffs.matrix (Ncoefs for col/row)
  Int_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
  //
  ClassDef(AliCheb3DCalc,1)  // Class for interpolation of 3D->1 function by Chebyshev parametrization 
};


class AliCheb3D: public TNamed 
{
 public:
    AliCheb3D();
    AliCheb3D(const char* inpFile); // read coefs from text file
    AliCheb3D(FILE*);               // read coefs from stream
    AliCheb3D(const AliCheb3D &src);
    AliCheb3D& operator= (const AliCheb3D &rhs);
  
  //
#ifdef _INC_CREATION_ALICHEB3D_
  AliCheb3D(const char* funName, Int_t DimOut, Float_t  *bmin,Float_t  *bmax, Int_t *npoints, Float_t  prec=1E-6);
  AliCheb3D(void (*ptr)(float*,float*), Int_t DimOut, Float_t  *bmin,Float_t  *bmax, Int_t *npoints, Float_t  prec=1E-6);
#endif
  //
  ~AliCheb3D()                                                                 {Clear();}
  //
  void         Eval(Float_t  *par,Float_t  *res);
  Float_t      Eval(Float_t  *par,int idim);
  void         Print(Option_t* opt="")                                   const;
  Bool_t       IsInside(Float_t  *par)                                   const;
  AliCheb3DCalc*  GetChebCalc(int i)                                     const {return (AliCheb3DCalc*)fChebCalc.UncheckedAt(i);}
  Float_t      GetBoundMin(int i)                                        const {return fBMin[i];}
  Float_t      GetBoundMax(int i)                                        const {return fBMax[i];}
  Float_t      GetPrecision()                                            const {return fPrec;}
  void         ShiftBound(int id,float dif);
  //
  void         LoadData(const char* inpFile);
  void         LoadData(FILE* stream);
  //
#ifdef _INC_CREATION_ALICHEB3D_
  void         SaveData(const char* outfile,Bool_t append=kFALSE)        const;
  void         SaveData(FILE* stream=stdout)                             const;
  //
  void         SetUsrFunction(const char* name);
  void         SetUsrFunction(void (*ptr)(float*,float*));
  void         EvalUsrFunction(Float_t  *x, Float_t  *res);
  TH1*         TestRMS(int idim,int npoints = 1000,TH1* histo=0);
#endif
  //
 protected:
  void         Init0();
  void         Clear(Option_t* option = "");
  void         SetDimOut(int d);
  void         PrepareBoundaries(Float_t  *bmin,Float_t  *bmax);
  //
#ifdef _INC_CREATION_ALICHEB3D_
  void         EvalUsrFunction();
  void         DefineGrid(Int_t* npoints);
  Int_t        ChebFit();                                                                 // fit all output dimensions
  Int_t        ChebFit(int dmOut);
  Int_t        CalcChebCoefs(Float_t  *funval,int np, Float_t  *outCoefs, Float_t  prec=-1);
#endif
  //
  void         Cyl2CartCyl(float *rphiz, float *b) const;
  void         Cart2Cyl(float *xyz,float *rphiz) const;
  //
  Float_t      MapToInternal(Float_t  x,Int_t d) const {return (x-fBOffset[d])*fBScale[d];} // map x to [-1:1]
  Float_t      MapToExternal(Float_t  x,Int_t d) const {return x/fBScale[d]+fBOffset[d];}   // map from [-1:1] to x
  //
 protected:
  Int_t        fDimOut;            // dimension of the ouput array
  Float_t      fPrec;              // requested precision
  Float_t      fBMin[3];           // min boundaries in each dimension
  Float_t      fBMax[3];           // max boundaries in each dimension  
  Float_t      fBScale[3];         // scale for boundary mapping to [-1:1] interval
  Float_t      fBOffset[3];        // offset for boundary mapping to [-1:1] interval
  TObjArray    fChebCalc;          // Chebyshev parameterization for each output dimension
  //
  Int_t        fMaxCoefs;          //! max possible number of coefs per parameterization
  Int_t        fNPoints[3];        //! number of used points in each dimension
  Float_t      fArgsTmp[3];        //! temporary vector for coefs caluclation
  Float_t      fBuff[6];           //! buffer for coordinate transformations
  Float_t *    fResTmp;            //! temporary vector for results of user function caluclation
  Float_t *    fGrid;              //! temporary buffer for Chebyshef roots grid
  Int_t        fGridOffs[3];       //! start of grid for each dimension
  TString      fUsrFunName;        //! name of user macro containing the function of  "void (*fcn)(float*,float*)" format
  TMethodCall* fUsrMacro;          //! Pointer to MethodCall for function from user macro 
  //
  ClassDef(AliCheb3D,1)  // Chebyshev parametrization for 3D->N function
};

// Pointer on user function (faster altrnative to TMethodCall)
#ifdef _INC_CREATION_ALICHEB3D_
void (*gUsrFunAliCheb3D) (float* ,float* );
#endif

//__________________________________________________________________________________________
#ifdef _INC_CREATION_ALICHEB3D_
inline void AliCheb3D::EvalUsrFunction() 
{
  // call user supplied function
  if   (gUsrFunAliCheb3D) gUsrFunAliCheb3D(fArgsTmp,fResTmp);
  else fUsrMacro->Execute(); 
}
#endif

//__________________________________________________________________________________________
inline Bool_t  AliCheb3D::IsInside(Float_t  *par) const 
{
  // check if the point is inside of the fitted box
  for (int i=3;i--;) if(par[i]<fBMin[i]||par[i]>fBMax[i]) return kFALSE;
  return kTRUE;
}

//__________________________________________________________________________________________
inline Float_t AliCheb3DCalc::ChebEval1D(Float_t  x, const Float_t * array, int ncf ) const
{
  // evaluate 1D Chebyshev parameterization. x is the argument mapped to [-1:1] interval
  Float_t b0, b1, b2;
  Float_t 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 void AliCheb3D::Eval(Float_t  *par, Float_t  *res)
{
  // evaluate Chebyshev parameterization for 3d->DimOut function
  for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
  for (int i=fDimOut;i--;) res[i] = GetChebCalc(i)->Eval(fArgsTmp);
  //
}

//__________________________________________________________________________________________
inline Float_t AliCheb3D::Eval(Float_t  *par, int idim)
{
  // evaluate Chebyshev parameterization for idim-th output dimension of 3d->DimOut function
  for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
  return GetChebCalc(idim)->Eval(fArgsTmp);
  //
}

//__________________________________________________________________________________________________
inline void AliCheb3D::Cyl2CartCyl(float *rphiz, float *b) const
{
  // convert field in cylindrical coordinates to cartesian system, point is in cyl.system
  float btr = TMath::Sqrt(b[0]*b[0]+b[1]*b[1]);
  float ang = TMath::ATan2(b[1],b[0]) + rphiz[1];
  b[0] = btr*TMath::Cos(ang);
  b[1] = btr*TMath::Sin(ang);
  //
}

//__________________________________________________________________________________________________
inline void AliCheb3D::Cart2Cyl(float *xyz,float *rphiz) const
{
  // convert cartesian coordinate to cylindrical one
  rphiz[0] = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
  rphiz[1] = TMath::ATan2(xyz[1],xyz[0]);
  rphiz[2] = xyz[2];
}

#endif
Commit	Line	Data
0eea9d4d	1	#ifndef ALICHEB3D_H
	2	#define ALICHEB3D_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	// Author: ruben.shahoyan@cern.ch 09/09/2006
	9	//
	10	////////////////////////////////////////////////////////////////////////////////
	11	// //
	12	// AliCheb3D produces the interpolation of the user 3D->NDimOut arbitrary //
	13	// function supplied in "void (fcn)(float inp,float* out)" format //
	14	// either in a separate macro file or as a function pointer. //
	15	// Only coefficients needed to guarantee the requested precision are kept. //
	16	// //
	17	// The user-callable methods are: //
	18	// To create the interpolation use: //
	19	// AliCheb3D(const char* funName, // name of the file with user function //
	20	// or //
	21	// AliCheb3D(void (ptr)(float,float*),// pointer on the user function //
	22	// Int_t DimOut, // dimensionality of the function's output //
	23	// Float_t *bmin, // lower 3D bounds of interpolation domain //
	24	// Float_t *bmax, // upper 3D bounds of interpolation domain //
	25	// Int_t *npoints, // number of points in each of 3 input //
	26	// // dimension, defining the interpolation grid //
	27	// Float_t prec=1E-6); // requested max.absolute difference between //
	28	// // the interpolation and any point on grid //
	29	// //
	30	// To test obtained parameterization use the method //
	31	// TH1* TestRMS(int idim,int npoints = 1000,TH1* histo=0); //
	32	// it will compare the user output of the user function and interpolation //
	33	// for idim-th output dimension and fill the difference in the supplied //
	34	// histogram. If no histogram is supplied, it will be created. //
	35	// //
	36	// To save the interpolation data: //
	37	// SaveData(const char* filename, Bool_t append ) //
	38	// write text file with data. If append is kTRUE and the output file already //
	39	// exists, data will be added in the end of the file. //
	40	// Alternatively, SaveData(FILE* stream) will write the data to //
	41	// already existing stream. //
	42	// //
	43	// To read back already stored interpolation use either the constructor //
	44	// AliCheb3D(const char* inpFile); //
	45	// or the default constructor AliCheb3D() followed by //
	46	// AliCheb3D::LoadData(const char* inpFile); //
	47	// //
	48	// To compute the interpolation use Eval(float* par,float *res) method, with //
	49	// par being 3D vector of arguments (inside the validity region) and res is //
	50	// the array of DimOut elements for the output. //
	51	// //
	52	// If only one component (say, idim-th) of the output is needed, use faster //
	53	// Float_t Eval(Float_t *par,int idim) method. //
	54	// //
	55	// void Print(option="") will print the name, the ranges of validity and //
	56	// the absolute precision of the parameterization. Option "l" will also print //
	57	// the information about the number of coefficients for each output //
	58	// dimension. //
	59	// //
	60	// NOTE: during the evaluation no check is done for parameter vector being //
	61	// outside the interpolation region. If there is such a risk, use //
	62	// Bool_t IsInside(float *par) method. Chebyshev parameterization is not //
	63	// good for extrapolation! //
	64	// //
65	// For the properties of Chebyshev parameterization see: //
66	// H.Wind, CERN EP Internal Report, 81-12/Rev. //
67	// //
68	////////////////////////////////////////////////////////////////////////////////
69
70
71	#include <stdio.h>
72	#include <TNamed.h>
73	#include <TMethodCall.h>
74	#include <TMath.h>
75	#include <TH1.h>
76	#include <TObjArray.h>
77
78	class TString;
79	class TSystem;
80	class TRandom;
81
82
83	// to decrease the compilable code size comment this define. This will exclude the routines
84	// used for the calculation and saving of the coefficients.
85	// #define _INC_CREATION_ALICHEB3D_
86
87	class AliCheb3DCalc: public TNamed
88	{
89	public:
90	AliCheb3DCalc();
91	AliCheb3DCalc(FILE* stream); // read coefs from text file
c437b1a5	92	AliCheb3DCalc(const AliCheb3DCalc &src);
c437b1a5	93	AliCheb3DCalc& operator= (const AliCheb3DCalc &rhs);
0eea9d4d	94	~AliCheb3DCalc() {Clear();}
	95	//
	96	void Print(Option_t* opt="") const;
	97	void LoadData(FILE* stream);
	98	Float_t Eval(Float_t *par) const;
	99	//
	100	#ifdef _INC_CREATION_ALICHEB3D_
	101	void SaveData(const char* outfile,Bool_t append=kFALSE) const;
	102	void SaveData(FILE* stream=stdout) const;
	103	#endif
	104	//
	105	static void ReadLine(TString& str,FILE* stream);
	106	//
	107	protected:
	108	//
	109	void Clear(Option_t* option = "");
	110	void Init0();
	111	Float_t ChebEval1D(Float_t x, const Float_t * array, int ncf) const;
	112	void InitRows(int nr);
	113	void InitCols(int nc);
	114	void InitElemBound2D(int ne);
	115	void InitCoefs(int nc);
	116	Int_t* GetNColsAtRow() const {return fNColsAtRow;}
	117	Int_t* GetColAtRowBg() const {return fColAtRowBg;}
	118	Int_t* GetCoefBound2D0() const {return fCoefBound2D0;}
	119	Int_t* GetCoefBound2D1() const {return fCoefBound2D1;}
	120	Float_t * GetCoefs() const {return fCoefs;}
	121	//
	122	protected:
	123	Int_t fNCoefs; // total number of coeeficients
	124	Int_t fNRows; // number of significant rows in the 3D coeffs matrix
	125	Int_t fNCols; // max number of significant cols in the 3D coeffs matrix
	126	Int_t fNElemBound2D; // number of elements (fNRows*fNCols) to store for the 2D boundary of significant coeffs
	127	Int_t* fNColsAtRow; //[fNRows] number of sighificant columns (2nd dim) at each row of 3D coefs matrix
	128	Int_t* fColAtRowBg; //[fNRows] beginnig of significant columns (2nd dim) for row in the 2D boundary matrix
	129	Int_t* fCoefBound2D0; //[fNElemBound2D] 2D matrix defining the boundary of significance for 3D coeffs.matrix (Ncoefs for col/row)
	130	Int_t* fCoefBound2D1; //[fNElemBound2D] 2D matrix defining the start beginnig of significant coeffs for col/row
	131	Float_t * fCoefs; //[fNCoefs] array of Chebyshev coefficients
	132	//
	133	Float_t * fTmpCf1; //[fNCols] temp. coeffs for 2d summation
	134	Float_t * fTmpCf0; //[fNRows] temp. coeffs for 1d summation
	135	//
	136	ClassDef(AliCheb3DCalc,1) // Class for interpolation of 3D->1 function by Chebyshev parametrization
	137	};
	138
	139
	140	class AliCheb3D: public TNamed
	141	{
	142	public:
	143	AliCheb3D();
	144	AliCheb3D(const char* inpFile); // read coefs from text file
	145	AliCheb3D(FILE*); // read coefs from stream
c437b1a5	146	AliCheb3D(const AliCheb3D &src);
c437b1a5	147	AliCheb3D& operator= (const AliCheb3D &rhs);
0bc7b414	148
0eea9d4d	149	//
	150	#ifdef _INC_CREATION_ALICHEB3D_
	151	AliCheb3D(const char* funName, Int_t DimOut, Float_t bmin,Float_t bmax, Int_t *npoints, Float_t prec=1E-6);
	152	AliCheb3D(void (ptr)(float,float), Int_t DimOut, Float_t bmin,Float_t bmax, Int_t npoints, Float_t prec=1E-6);
	153	#endif
	154	//
	155	~AliCheb3D() {Clear();}
	156	//
	157	void Eval(Float_t par,Float_t res);
	158	Float_t Eval(Float_t *par,int idim);
	159	void Print(Option_t* opt="") const;
	160	Bool_t IsInside(Float_t *par) const;
	161	AliCheb3DCalc* GetChebCalc(int i) const {return (AliCheb3DCalc*)fChebCalc.UncheckedAt(i);}
	162	Float_t GetBoundMin(int i) const {return fBMin[i];}
	163	Float_t GetBoundMax(int i) const {return fBMax[i];}
	164	Float_t GetPrecision() const {return fPrec;}
	165	void ShiftBound(int id,float dif);
	166	//
	167	void LoadData(const char* inpFile);
	168	void LoadData(FILE* stream);
	169	//
	170	#ifdef _INC_CREATION_ALICHEB3D_
	171	void SaveData(const char* outfile,Bool_t append=kFALSE) const;
	172	void SaveData(FILE* stream=stdout) const;
	173	//
	174	void SetUsrFunction(const char* name);
	175	void SetUsrFunction(void (ptr)(float,float*));
	176	void EvalUsrFunction(Float_t x, Float_t res);
	177	TH1* TestRMS(int idim,int npoints = 1000,TH1* histo=0);
	178	#endif
	179	//
	180	protected:
	181	void Init0();
	182	void Clear(Option_t* option = "");
	183	void SetDimOut(int d);
	184	void PrepareBoundaries(Float_t bmin,Float_t bmax);
	185	//
	186	#ifdef _INC_CREATION_ALICHEB3D_
	187	void EvalUsrFunction();
	188	void DefineGrid(Int_t* npoints);
	189	Int_t ChebFit(); // fit all output dimensions
	190	Int_t ChebFit(int dmOut);
	191	Int_t CalcChebCoefs(Float_t funval,int np, Float_t outCoefs, Float_t prec=-1);
	192	#endif
	193	//
	194	void Cyl2CartCyl(float rphiz, float b) const;
	195	void Cart2Cyl(float xyz,float rphiz) const;
	196	//
	197	Float_t MapToInternal(Float_t x,Int_t d) const {return (x-fBOffset[d])*fBScale[d];} // map x to [-1:1]
	198	Float_t MapToExternal(Float_t x,Int_t d) const {return x/fBScale[d]+fBOffset[d];} // map from [-1:1] to x
0bc7b414	199	//
0eea9d4d	200	protected:
	201	Int_t fDimOut; // dimension of the ouput array
	202	Float_t fPrec; // requested precision
	203	Float_t fBMin[3]; // min boundaries in each dimension
	204	Float_t fBMax[3]; // max boundaries in each dimension
	205	Float_t fBScale[3]; // scale for boundary mapping to [-1:1] interval
	206	Float_t fBOffset[3]; // offset for boundary mapping to [-1:1] interval
	207	TObjArray fChebCalc; // Chebyshev parameterization for each output dimension
	208	//
	209	Int_t fMaxCoefs; //! max possible number of coefs per parameterization
	210	Int_t fNPoints[3]; //! number of used points in each dimension
	211	Float_t fArgsTmp[3]; //! temporary vector for coefs caluclation
	212	Float_t fBuff[6]; //! buffer for coordinate transformations
	213	Float_t * fResTmp; //! temporary vector for results of user function caluclation
	214	Float_t * fGrid; //! temporary buffer for Chebyshef roots grid
	215	Int_t fGridOffs[3]; //! start of grid for each dimension
	216	TString fUsrFunName; //! name of user macro containing the function of "void (fcn)(float,float*)" format
	217	TMethodCall* fUsrMacro; //! Pointer to MethodCall for function from user macro
	218	//
	219	ClassDef(AliCheb3D,1) // Chebyshev parametrization for 3D->N function
	220	};
	221
	222	// Pointer on user function (faster altrnative to TMethodCall)
	223	#ifdef _INC_CREATION_ALICHEB3D_
	224	void (gUsrFunAliCheb3D) (float ,float* );
	225	#endif
	226
	227	//__________________________________________________________________________________________
	228	#ifdef _INC_CREATION_ALICHEB3D_
	229	inline void AliCheb3D::EvalUsrFunction()
	230	{
	231	// call user supplied function
	232	if (gUsrFunAliCheb3D) gUsrFunAliCheb3D(fArgsTmp,fResTmp);
	233	else fUsrMacro->Execute();
	234	}
	235	#endif
	236
	237	//__________________________________________________________________________________________
	238	inline Bool_t AliCheb3D::IsInside(Float_t *par) const
	239	{
	240	// check if the point is inside of the fitted box
	241	for (int i=3;i--;) if(par[i]<fBMin[i]\|\|par[i]>fBMax[i]) return kFALSE;
	242	return kTRUE;
	243	}
	244
	245	//__________________________________________________________________________________________
	246	inline Float_t AliCheb3DCalc::ChebEval1D(Float_t x, const Float_t * array, int ncf ) const
	247	{
	248	// evaluate 1D Chebyshev parameterization. x is the argument mapped to [-1:1] interval
	249	Float_t b0, b1, b2;
	250	Float_t x2 = x+x;
	251	b0 = array[--ncf];
	252	b1 = b2 = 0;
	253	for (int i=ncf;i--;) {
	254	b2 = b1;
	255	b1 = b0;
	256	b0 = array[i] + x2*b1 -b2;
	257	}
	258	return b0 - x*b1;
	259	}
	260
	261	//__________________________________________________________________________________________
	262	inline void AliCheb3D::Eval(Float_t par, Float_t res)
	263	{
264	// evaluate Chebyshev parameterization for 3d->DimOut function
265	for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
266	for (int i=fDimOut;i--;) res[i] = GetChebCalc(i)->Eval(fArgsTmp);
267	//
268	}
269
270	//__________________________________________________________________________________________
271	inline Float_t AliCheb3D::Eval(Float_t *par, int idim)
272	{
273	// evaluate Chebyshev parameterization for idim-th output dimension of 3d->DimOut function
274	for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
275	return GetChebCalc(idim)->Eval(fArgsTmp);
276	//
277	}
278
279	//__________________________________________________________________________________________________
280	inline void AliCheb3D::Cyl2CartCyl(float rphiz, float b) const
281	{
282	// convert field in cylindrical coordinates to cartesian system, point is in cyl.system
283	float btr = TMath::Sqrt(b[0]b[0]+b[1]b[1]);
284	float ang = TMath::ATan2(b[1],b[0]) + rphiz[1];
285	b[0] = btr*TMath::Cos(ang);
286	b[1] = btr*TMath::Sin(ang);
287	//
288	}
289
290	//__________________________________________________________________________________________________
291	inline void AliCheb3D::Cart2Cyl(float xyz,float rphiz) const
292	{
293	// convert cartesian coordinate to cylindrical one
294	rphiz[0] = TMath::Sqrt(xyz[0]xyz[0]+xyz[1]xyz[1]);
295	rphiz[1] = TMath::ATan2(xyz[1],xyz[0]);
296	rphiz[2] = xyz[2];
297	}
298
299	#endif