ROOT logo
// 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.                                //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////


#ifndef ALICHEB3D_H
#define ALICHEB3D_H

#include <TNamed.h>
#include <TObjArray.h>
#include "AliCheb3DCalc.h"

class TString;
class TSystem;
class TRandom;
class TH1;
class TMethodCall;
class TRandom;
class TROOT;
class stdio;



class AliCheb3D: public TNamed 
{
 public:
  AliCheb3D();
  AliCheb3D(const AliCheb3D& src);
  AliCheb3D(const char* inpFile);
  AliCheb3D(FILE* stream);
  //
#ifdef _INC_CREATION_ALICHEB3D_
  AliCheb3D(const char* funName, Int_t DimOut, const Float_t  *bmin, const Float_t  *bmax, Int_t *npoints, Float_t  prec=1E-6, const Float_t* precD=0);
  AliCheb3D(void (*ptr)(float*,float*), Int_t DimOut, Float_t  *bmin,Float_t  *bmax, Int_t *npoints, Float_t  prec=1E-6, const Float_t* precD=0);
  AliCheb3D(void (*ptr)(float*,float*), int DimOut, Float_t  *bmin,Float_t  *bmax, Int_t *npX,Int_t *npY,Int_t *npZ, Float_t prec=1E-6, const Float_t* precD=0);
  AliCheb3D(void (*ptr)(float*,float*), int DimOut, Float_t  *bmin,Float_t  *bmax, Float_t prec=1E-6, Bool_t run=kTRUE, const Float_t* precD=0);
#endif
  //
  ~AliCheb3D()                                                                 {Clear();}
  //
  AliCheb3D&   operator=(const AliCheb3D& rhs);
  void         Eval(const Float_t  *par, Float_t *res);
  Float_t      Eval(const Float_t  *par,int idim);
  void         Eval(const Double_t  *par, Double_t *res);
  Double_t     Eval(const Double_t  *par,int idim);
  //
  void         EvalDeriv(int dimd, const Float_t  *par, Float_t  *res);
  void         EvalDeriv2(int dimd1, int dimd2, const Float_t  *par,Float_t  *res);
  Float_t      EvalDeriv(int dimd, const Float_t  *par, int idim);
  Float_t      EvalDeriv2(int dimd1,int dimd2, const Float_t  *par, int idim);
  void         EvalDeriv3D(const Float_t *par, Float_t dbdr[3][3]); 
  void         EvalDeriv3D2(const Float_t *par, Float_t dbdrdr[3][3][3]); 
  void         Print(const Option_t* opt="")                             const;
  Bool_t       IsInside(const Float_t  *par)                             const;
  Bool_t       IsInside(const Double_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*     GetBoundMin()                                             const {return (float*)fBMin;}
  Float_t*     GetBoundMax()                                             const {return (float*)fBMax;}
  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         InvertSign();
  int*         GetNCNeeded(float xyz[3],int DimVar, float mn,float mx, float prec, Int_t npCheck=30);
  void         EstimateNPoints(float prec, int gridBC[3][3],Int_t npd1=30,Int_t npd2=30,Int_t npd3=30);
  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(const Float_t  *x, Float_t  *res);
  TH1*         TestRMS(int idim,int npoints = 1000,TH1* histo=0);
  static Int_t CalcChebCoefs(const Float_t  *funval,int np, Float_t  *outCoefs, Float_t  prec=-1);
#endif
  //
 protected:
  void         Clear(const Option_t* option = "");
  void         SetDimOut(const int d, const float* prec=0);
  void         PrepareBoundaries(const Float_t  *bmin,const 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);
  void         SetPrecision(float prec)                      {fPrec = prec;}
#endif
  //
  Float_t      MapToInternal(Float_t  x,Int_t d)       const; // 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
  Double_t     MapToInternal(Double_t  x,Int_t d)      const; // map x to [-1:1]
  Double_t     MapToExternal(Double_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 *    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 
  //
  static const Float_t fgkMinPrec;         // smallest precision
  //
  ClassDef(AliCheb3D,2)  // Chebyshev parametrization for 3D->N function
};

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

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

//__________________________________________________________________________________________
inline void AliCheb3D::Eval(const 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 void AliCheb3D::Eval(const Double_t  *par, Double_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 Double_t AliCheb3D::Eval(const Double_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 Float_t AliCheb3D::Eval(const 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::EvalDeriv3D(const Float_t *par, Float_t dbdr[3][3])
{
  // return gradient matrix
  for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
  for (int ib=3;ib--;) for (int id=3;id--;) dbdr[ib][id] = GetChebCalc(ib)->EvalDeriv(id,fArgsTmp)*fBScale[id];
}

//__________________________________________________________________________________________
inline void AliCheb3D::EvalDeriv3D2(const Float_t *par, Float_t dbdrdr[3][3][3])
{
  // return gradient matrix
  for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
  for (int ib=3;ib--;) for (int id=3;id--;)for (int id1=3;id1--;) 
    dbdrdr[ib][id][id1] = GetChebCalc(ib)->EvalDeriv2(id,id1,fArgsTmp)*fBScale[id]*fBScale[id1];
}

//__________________________________________________________________________________________
inline void AliCheb3D::EvalDeriv(int dimd, const Float_t  *par, Float_t  *res)
{
  // evaluate Chebyshev parameterization derivative for 3d->DimOut function
  for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
  for (int i=fDimOut;i--;) res[i] = GetChebCalc(i)->EvalDeriv(dimd,fArgsTmp)*fBScale[dimd];;
  //
}

//__________________________________________________________________________________________
inline void AliCheb3D::EvalDeriv2(int dimd1,int dimd2, const Float_t  *par, Float_t  *res)
{
  // evaluate Chebyshev parameterization 2nd derivative over dimd1 and dimd2 dimensions for 3d->DimOut function
  for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
  for (int i=fDimOut;i--;) res[i] = GetChebCalc(i)->EvalDeriv2(dimd1,dimd2,fArgsTmp)*fBScale[dimd1]*fBScale[dimd2];
  //
}

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

//__________________________________________________________________________________________
inline Float_t AliCheb3D::EvalDeriv2(int dimd1,int dimd2, const Float_t  *par, int idim)
{
  // evaluate Chebyshev parameterization 2ns derivative over dimd1 and dimd2 dimensions for idim-th output dimension of 3d->DimOut function
  for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
  return GetChebCalc(idim)->EvalDeriv2(dimd1,dimd2,fArgsTmp)*fBScale[dimd1]*fBScale[dimd2];
  //
}

//__________________________________________________________________________________________
inline Float_t AliCheb3D::MapToInternal(Float_t  x,Int_t d) const
{
  // map x to [-1:1]
#ifdef _BRING_TO_BOUNDARY_
  T res = (x-fBOffset[d])*fBScale[d];
  if (res<-1) return -1;
  if (res> 1) return 1;
  return res;
#else
  return (x-fBOffset[d])*fBScale[d];
#endif
}

//__________________________________________________________________________________________
inline Double_t AliCheb3D::MapToInternal(Double_t  x,Int_t d) const
{
  // map x to [-1:1]
#ifdef _BRING_TO_BOUNDARY_
  T res = (x-fBOffset[d])*fBScale[d];
  if (res<-1) return -1;
  if (res> 1) return 1;
  return res;
#else
  return (x-fBOffset[d])*fBScale[d];
#endif
}

#endif
 AliCheb3D.h:1
 AliCheb3D.h:2
 AliCheb3D.h:3
 AliCheb3D.h:4
 AliCheb3D.h:5
 AliCheb3D.h:6
 AliCheb3D.h:7
 AliCheb3D.h:8
 AliCheb3D.h:9
 AliCheb3D.h:10
 AliCheb3D.h:11
 AliCheb3D.h:12
 AliCheb3D.h:13
 AliCheb3D.h:14
 AliCheb3D.h:15
 AliCheb3D.h:16
 AliCheb3D.h:17
 AliCheb3D.h:18
 AliCheb3D.h:19
 AliCheb3D.h:20
 AliCheb3D.h:21
 AliCheb3D.h:22
 AliCheb3D.h:23
 AliCheb3D.h:24
 AliCheb3D.h:25
 AliCheb3D.h:26
 AliCheb3D.h:27
 AliCheb3D.h:28
 AliCheb3D.h:29
 AliCheb3D.h:30
 AliCheb3D.h:31
 AliCheb3D.h:32
 AliCheb3D.h:33
 AliCheb3D.h:34
 AliCheb3D.h:35
 AliCheb3D.h:36
 AliCheb3D.h:37
 AliCheb3D.h:38
 AliCheb3D.h:39
 AliCheb3D.h:40
 AliCheb3D.h:41
 AliCheb3D.h:42
 AliCheb3D.h:43
 AliCheb3D.h:44
 AliCheb3D.h:45
 AliCheb3D.h:46
 AliCheb3D.h:47
 AliCheb3D.h:48
 AliCheb3D.h:49
 AliCheb3D.h:50
 AliCheb3D.h:51
 AliCheb3D.h:52
 AliCheb3D.h:53
 AliCheb3D.h:54
 AliCheb3D.h:55
 AliCheb3D.h:56
 AliCheb3D.h:57
 AliCheb3D.h:58
 AliCheb3D.h:59
 AliCheb3D.h:60
 AliCheb3D.h:61
 AliCheb3D.h:62
 AliCheb3D.h:63
 AliCheb3D.h:64
 AliCheb3D.h:65
 AliCheb3D.h:66
 AliCheb3D.h:67
 AliCheb3D.h:68
 AliCheb3D.h:69
 AliCheb3D.h:70
 AliCheb3D.h:71
 AliCheb3D.h:72
 AliCheb3D.h:73
 AliCheb3D.h:74
 AliCheb3D.h:75
 AliCheb3D.h:76
 AliCheb3D.h:77
 AliCheb3D.h:78
 AliCheb3D.h:79
 AliCheb3D.h:80
 AliCheb3D.h:81
 AliCheb3D.h:82
 AliCheb3D.h:83
 AliCheb3D.h:84
 AliCheb3D.h:85
 AliCheb3D.h:86
 AliCheb3D.h:87
 AliCheb3D.h:88
 AliCheb3D.h:89
 AliCheb3D.h:90
 AliCheb3D.h:91
 AliCheb3D.h:92
 AliCheb3D.h:93
 AliCheb3D.h:94
 AliCheb3D.h:95
 AliCheb3D.h:96
 AliCheb3D.h:97
 AliCheb3D.h:98
 AliCheb3D.h:99
 AliCheb3D.h:100
 AliCheb3D.h:101
 AliCheb3D.h:102
 AliCheb3D.h:103
 AliCheb3D.h:104
 AliCheb3D.h:105
 AliCheb3D.h:106
 AliCheb3D.h:107
 AliCheb3D.h:108
 AliCheb3D.h:109
 AliCheb3D.h:110
 AliCheb3D.h:111
 AliCheb3D.h:112
 AliCheb3D.h:113
 AliCheb3D.h:114
 AliCheb3D.h:115
 AliCheb3D.h:116
 AliCheb3D.h:117
 AliCheb3D.h:118
 AliCheb3D.h:119
 AliCheb3D.h:120
 AliCheb3D.h:121
 AliCheb3D.h:122
 AliCheb3D.h:123
 AliCheb3D.h:124
 AliCheb3D.h:125
 AliCheb3D.h:126
 AliCheb3D.h:127
 AliCheb3D.h:128
 AliCheb3D.h:129
 AliCheb3D.h:130
 AliCheb3D.h:131
 AliCheb3D.h:132
 AliCheb3D.h:133
 AliCheb3D.h:134
 AliCheb3D.h:135
 AliCheb3D.h:136
 AliCheb3D.h:137
 AliCheb3D.h:138
 AliCheb3D.h:139
 AliCheb3D.h:140
 AliCheb3D.h:141
 AliCheb3D.h:142
 AliCheb3D.h:143
 AliCheb3D.h:144
 AliCheb3D.h:145
 AliCheb3D.h:146
 AliCheb3D.h:147
 AliCheb3D.h:148
 AliCheb3D.h:149
 AliCheb3D.h:150
 AliCheb3D.h:151
 AliCheb3D.h:152
 AliCheb3D.h:153
 AliCheb3D.h:154
 AliCheb3D.h:155
 AliCheb3D.h:156
 AliCheb3D.h:157
 AliCheb3D.h:158
 AliCheb3D.h:159
 AliCheb3D.h:160
 AliCheb3D.h:161
 AliCheb3D.h:162
 AliCheb3D.h:163
 AliCheb3D.h:164
 AliCheb3D.h:165
 AliCheb3D.h:166
 AliCheb3D.h:167
 AliCheb3D.h:168
 AliCheb3D.h:169
 AliCheb3D.h:170
 AliCheb3D.h:171
 AliCheb3D.h:172
 AliCheb3D.h:173
 AliCheb3D.h:174
 AliCheb3D.h:175
 AliCheb3D.h:176
 AliCheb3D.h:177
 AliCheb3D.h:178
 AliCheb3D.h:179
 AliCheb3D.h:180
 AliCheb3D.h:181
 AliCheb3D.h:182
 AliCheb3D.h:183
 AliCheb3D.h:184
 AliCheb3D.h:185
 AliCheb3D.h:186
 AliCheb3D.h:187
 AliCheb3D.h:188
 AliCheb3D.h:189
 AliCheb3D.h:190
 AliCheb3D.h:191
 AliCheb3D.h:192
 AliCheb3D.h:193
 AliCheb3D.h:194
 AliCheb3D.h:195
 AliCheb3D.h:196
 AliCheb3D.h:197
 AliCheb3D.h:198
 AliCheb3D.h:199
 AliCheb3D.h:200
 AliCheb3D.h:201
 AliCheb3D.h:202
 AliCheb3D.h:203
 AliCheb3D.h:204
 AliCheb3D.h:205
 AliCheb3D.h:206
 AliCheb3D.h:207
 AliCheb3D.h:208
 AliCheb3D.h:209
 AliCheb3D.h:210
 AliCheb3D.h:211
 AliCheb3D.h:212
 AliCheb3D.h:213
 AliCheb3D.h:214
 AliCheb3D.h:215
 AliCheb3D.h:216
 AliCheb3D.h:217
 AliCheb3D.h:218
 AliCheb3D.h:219
 AliCheb3D.h:220
 AliCheb3D.h:221
 AliCheb3D.h:222
 AliCheb3D.h:223
 AliCheb3D.h:224
 AliCheb3D.h:225
 AliCheb3D.h:226
 AliCheb3D.h:227
 AliCheb3D.h:228
 AliCheb3D.h:229
 AliCheb3D.h:230
 AliCheb3D.h:231
 AliCheb3D.h:232
 AliCheb3D.h:233
 AliCheb3D.h:234
 AliCheb3D.h:235
 AliCheb3D.h:236
 AliCheb3D.h:237
 AliCheb3D.h:238
 AliCheb3D.h:239
 AliCheb3D.h:240
 AliCheb3D.h:241
 AliCheb3D.h:242
 AliCheb3D.h:243
 AliCheb3D.h:244
 AliCheb3D.h:245
 AliCheb3D.h:246
 AliCheb3D.h:247
 AliCheb3D.h:248
 AliCheb3D.h:249
 AliCheb3D.h:250
 AliCheb3D.h:251
 AliCheb3D.h:252
 AliCheb3D.h:253
 AliCheb3D.h:254
 AliCheb3D.h:255
 AliCheb3D.h:256
 AliCheb3D.h:257
 AliCheb3D.h:258
 AliCheb3D.h:259
 AliCheb3D.h:260
 AliCheb3D.h:261
 AliCheb3D.h:262
 AliCheb3D.h:263
 AliCheb3D.h:264
 AliCheb3D.h:265
 AliCheb3D.h:266
 AliCheb3D.h:267
 AliCheb3D.h:268
 AliCheb3D.h:269
 AliCheb3D.h:270
 AliCheb3D.h:271
 AliCheb3D.h:272
 AliCheb3D.h:273
 AliCheb3D.h:274
 AliCheb3D.h:275
 AliCheb3D.h:276
 AliCheb3D.h:277
 AliCheb3D.h:278
 AliCheb3D.h:279
 AliCheb3D.h:280
 AliCheb3D.h:281
 AliCheb3D.h:282
 AliCheb3D.h:283
 AliCheb3D.h:284
 AliCheb3D.h:285
 AliCheb3D.h:286
 AliCheb3D.h:287
 AliCheb3D.h:288
 AliCheb3D.h:289
 AliCheb3D.h:290
 AliCheb3D.h:291
 AliCheb3D.h:292
 AliCheb3D.h:293
 AliCheb3D.h:294
 AliCheb3D.h:295
 AliCheb3D.h:296
 AliCheb3D.h:297
 AliCheb3D.h:298
 AliCheb3D.h:299
 AliCheb3D.h:300
 AliCheb3D.h:301
 AliCheb3D.h:302
 AliCheb3D.h:303
 AliCheb3D.h:304
 AliCheb3D.h:305
 AliCheb3D.h:306
 AliCheb3D.h:307
 AliCheb3D.h:308
 AliCheb3D.h:309
 AliCheb3D.h:310
 AliCheb3D.h:311
 AliCheb3D.h:312
 AliCheb3D.h:313