STEER/AliCheb3D.cxx

   1 // Author: ruben.shahoyan@cern.ch   09/09/2006
   2
   3 ////////////////////////////////////////////////////////////////////////////////
   4 //                                                                            //
   5 // AliCheb3D produces the interpolation of the user 3D->NDimOut arbitrary     //
   6 // function supplied in "void (*fcn)(float* inp,float* out)" format           //
   7 // either in a separate macro file or as a function pointer.                  //
   8 // Only coefficients needed to guarantee the requested precision are kept.    //
   9 //                                                                            //
  10 // The user-callable methods are:                                             //
  11 // To create the interpolation use:                                           //
  12 // AliCheb3D(const char* funName,  // name of the file with user function     //
  13 //          or                                                                //
  14 // AliCheb3D(void (*ptr)(float*,float*),// pointer on the  user function      //
  15 //        Int_t     DimOut,     // dimensionality of the function's output    //
  16 //        Float_t  *bmin,       // lower 3D bounds of interpolation domain    //
  17 //        Float_t  *bmax,       // upper 3D bounds of interpolation domain    //
  18 //        Int_t    *npoints,    // number of points in each of 3 input        //
  19 //                              // dimension, defining the interpolation grid //
  20 //        Float_t   prec=1E-6); // requested max.absolute difference between  //
  21 //                              // the interpolation and any point on grid    //
  22 //                                                                            //
  23 // To test obtained parameterization use the method                           //
  24 // TH1* TestRMS(int idim,int npoints = 1000,TH1* histo=0);                    //
  25 // it will compare the user output of the user function and interpolation     //
  26 // for idim-th output dimension and fill the difference in the supplied       //
  27 // histogram. If no histogram is supplied, it will be created.                //
  28 //                                                                            //
  29 // To save the interpolation data:                                            //
  30 // SaveData(const char* filename, Bool_t append )                             //
  31 // write text file with data. If append is kTRUE and the output file already  //
  32 // exists, data will be added in the end of the file.                         //
  33 // Alternatively, SaveData(FILE* stream) will write the data to               //
  34 // already existing stream.                                                   //
  35 //                                                                            //
  36 // To read back already stored interpolation use either the constructor       //
  37 // AliCheb3D(const char* inpFile);                                            //
  38 // or the default constructor AliCheb3D() followed by                         //
  39 // AliCheb3D::LoadData(const char* inpFile);                                  //
  40 //                                                                            //
  41 // To compute the interpolation use Eval(float* par,float *res) method, with  //
  42 // par being 3D vector of arguments (inside the validity region) and res is   //
  43 // the array of DimOut elements for the output.                               //
  44 //                                                                            //
  45 // If only one component (say, idim-th) of the output is needed, use faster   //
  46 // Float_t Eval(Float_t *par,int idim) method.                                //
  47 //                                                                            //
  48 // void Print(option="") will print the name, the ranges of validity and      //
  49 // the absolute precision of the parameterization. Option "l" will also print //
  50 // the information about the number of coefficients for each output           //
  51 // dimension.                                                                 //
  52 //                                                                            //
  53 // NOTE: during the evaluation no check is done for parameter vector being    //
  54 // outside the interpolation region. If there is such a risk, use             //
  55 // Bool_t IsInside(float *par) method. Chebyshev parameterization is not      //
  56 // good for extrapolation!                                                    //
  57 //                                                                            //
  58 // For the properties of Chebyshev parameterization see:                      //
  59 // H.Wind, CERN EP Internal Report, 81-12/Rev.                                //
  60 //                                                                            //
  61 ////////////////////////////////////////////////////////////////////////////////
  62
  63 #include <TString.h>
  64 #include <TSystem.h>
  65 #include <TROOT.h>
  66 #include <TRandom.h>
  67 #include "AliCheb3D.h"
  68
  69
  70
  71 ClassImp(AliCheb3D)
  72
  73 //__________________________________________________________________________________________
  74 AliCheb3D::AliCheb3D() :
  75   fDimOut(0),
  76   fPrec(0),
  77   fChebCalc(1),
  78   fMaxCoefs(0),
  79   fResTmp(0),
  80   fGrid(0),
  81   fUsrFunName(""),
  82   fUsrMacro(0)
  83 {
  84   for (int i=3;i--;) fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
  85 }
  86
  87 //__________________________________________________________________________________________
  88 AliCheb3D::AliCheb3D(const AliCheb3D& src) :
  89   TNamed(src),
  90   fDimOut(src.fDimOut),
  91   fPrec(src.fPrec),
  92   fChebCalc(1),
  93   fMaxCoefs(src.fMaxCoefs),
  94   fResTmp(0),
  95   fGrid(0),
  96   fUsrFunName(src.fUsrFunName),
  97   fUsrMacro(0)
  98 {
  99   // read coefs from text file
 100   for (int i=3;i--;) {
 101     fBMin[i]    = src.fBMin[i];
 102     fBMax[i]    = src.fBMax[i];
 103     fBScale[i]  = src.fBScale[i];
 104     fBOffset[i] = src.fBOffset[i];
 105     fNPoints[i] = src.fNPoints[i];
 106   }
 107   for (int i=0;i<fDimOut;i++) {
 108     AliCheb3DCalc* cbc = src.GetChebCalc(i);
 109     if (cbc) fChebCalc.AddAtAndExpand(new AliCheb3DCalc(*cbc),i);
 110   }
 111 }
 112
 113 //__________________________________________________________________________________________
 114 AliCheb3D::AliCheb3D(const char* inpFile) :
 115   fDimOut(0),
 116   fPrec(0),
 117   fChebCalc(1),
 118   fMaxCoefs(0),
 119   fResTmp(0),
 120   fGrid(0),
 121   fUsrFunName(""),
 122   fUsrMacro(0)
 123 {
 124   // read coefs from text file
 125   for (int i=3;i--;) fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
 126   LoadData(inpFile);
 127 }
 128
 129 //__________________________________________________________________________________________
 130 AliCheb3D::AliCheb3D(FILE* stream) :
 131   fDimOut(0),
 132   fPrec(0),
 133   fChebCalc(1),
 134   fMaxCoefs(0),
 135   fResTmp(0),
 136   fGrid(0),
 137   fUsrFunName(""),
 138   fUsrMacro(0)
 139 {
 140   // read coefs from stream
 141   for (int i=3;i--;) fBMin[i] = fBMax[i] = fBScale[i] = fBOffset[i] = 0;
 142   LoadData(stream);
 143 }
 144
 145 //__________________________________________________________________________________________
 146 #ifdef _INC_CREATION_ALICHEB3D_
 147 AliCheb3D::AliCheb3D(const char* funName, int DimOut, Float_t  *bmin,Float_t  *bmax, Int_t *npoints, Float_t prec) :
 148   TNamed(funName,funName),
 149   fDimOut(0),
 150   fPrec(TMath::Max(1.E-12f,prec)),
 151   fChebCalc(1),
 152   fMaxCoefs(0),
 153   fResTmp(0),
 154   fGrid(0),
 155   fUsrFunName("") ,
 156   fUsrMacro(0)
 157 {
 158   // Construct the parameterization for the function
 159   // funName : name of the file containing the function: void funName(Float_t * inp,Float_t * out)
 160   // DimOut  : dimension of the vector computed by the user function
 161   // bmin    : array of 3 elements with the lower boundaries of the region where the function is defined
 162   // bmax    : array of 3 elements with the upper boundaries of the region where the function is defined
 163   // npoints : array of 3 elements with the number of points to compute in each of 3 dimension
 164   // prec    : max allowed absolute difference between the user function and computed parameterization on the requested grid
 165   //
 166   if (DimOut<1) {Error("AliCheb3D","Requested output dimension is %d\nStop\n",fDimOut); exit(1);}
 167   SetDimOut(DimOut);
 168   PrepareBoundaries(bmin,bmax);
 169   DefineGrid(npoints);
 170   SetUsrFunction(funName);
 171   ChebFit();
 172   //
 173 }
 174 #endif
 175
 176 //__________________________________________________________________________________________
 177 #ifdef _INC_CREATION_ALICHEB3D_
 178 AliCheb3D::AliCheb3D(void (*ptr)(float*,float*), int DimOut, Float_t  *bmin,Float_t  *bmax, Int_t *npoints, Float_t prec) :
 179   fDimOut(0),
 180   fPrec(TMath::Max(1.E-12f,prec)),
 181   fChebCalc(1),
 182   fMaxCoefs(0),
 183   fResTmp(0),
 184   fGrid(0),
 185   fUsrFunName(""),
 186   fUsrMacro(0)
 187 {
 188   // Construct the parameterization for the function
 189   // ptr     : pointer on the function: void fun(Float_t * inp,Float_t * out)
 190   // DimOut  : dimension of the vector computed by the user function
 191   // bmin    : array of 3 elements with the lower boundaries of the region where the function is defined
 192   // bmax    : array of 3 elements with the upper boundaries of the region where the function is defined
 193   // npoints : array of 3 elements with the number of points to compute in each of 3 dimension
 194   // prec    : max allowed absolute difference between the user function and computed parameterization on the requested grid
 195   //
 196   if (DimOut<1) {Error("AliCheb3D","Requested output dimension is %d\nStop\n",fDimOut); exit(1);}
 197   SetDimOut(DimOut);
 198   PrepareBoundaries(bmin,bmax);
 199   DefineGrid(npoints);
 200   SetUsrFunction(ptr);
 201   ChebFit();
 202   //
 203 }
 204 #endif
 205
 206 //__________________________________________________________________________________________
 207 #ifdef _INC_CREATION_ALICHEB3D_
 208 AliCheb3D::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) :
 209   fDimOut(0),
 210   fPrec(TMath::Max(1.E-12f,prec)),
 211   fChebCalc(1),
 212   fMaxCoefs(0),
 213   fResTmp(0),
 214   fGrid(0),
 215   fUsrFunName(""),
 216   fUsrMacro(0)
 217 {
 218   // Construct very economic  parameterization for the function
 219   // ptr     : pointer on the function: void fun(Float_t * inp,Float_t * out)
 220   // DimOut  : dimension of the vector computed by the user function
 221   // bmin    : array of 3 elements with the lower boundaries of the region where the function is defined
 222   // bmax    : array of 3 elements with the upper boundaries of the region where the function is defined
 223   // npX     : array of 3 elements with the number of points to compute in each dimension for 1st component
 224   // npY     : array of 3 elements with the number of points to compute in each dimension for 2nd component
 225   // npZ     : array of 3 elements with the number of points to compute in each dimension for 3d  component
 226   // prec    : max allowed absolute difference between the user function and computed parameterization on the requested grid
 227   //
 228   if (DimOut<1) {Error("AliCheb3D","Requested output dimension is %d\nStop\n",fDimOut); exit(1);}
 229   SetDimOut(DimOut);
 230   PrepareBoundaries(bmin,bmax);
 231   SetUsrFunction(ptr);
 232   //
 233   DefineGrid(npX);
 234   ChebFit(0);
 235   DefineGrid(npY);
 236   ChebFit(1);
 237   DefineGrid(npZ);
 238   ChebFit(2);
 239   //
 240 }
 241 #endif
 242
 243
 244 //__________________________________________________________________________________________
 245 #ifdef _INC_CREATION_ALICHEB3D_
 246 AliCheb3D::AliCheb3D(void (*ptr)(float*,float*), int DimOut, Float_t  *bmin,Float_t  *bmax, Float_t prec) :
 247   fDimOut(0),
 248   fPrec(TMath::Max(1.E-12f,prec)),
 249   fChebCalc(1),
 250   fMaxCoefs(0),
 251   fResTmp(0),
 252   fGrid(0),
 253   fUsrFunName(""),
 254   fUsrMacro(0)
 255 {
 256   // Construct very economic  parameterization for the function with automatic calculation of the root's grid
 257   // ptr     : pointer on the function: void fun(Float_t * inp,Float_t * out)
 258   // DimOut  : dimension of the vector computed by the user function
 259   // bmin    : array of 3 elements with the lower boundaries of the region where the function is defined
 260   // bmax    : array of 3 elements with the upper boundaries of the region where the function is defined
 261   // prec    : max allowed absolute difference between the user function and computed parameterization on the requested grid
 262   //
 263   if (DimOut!=3) {Error("AliCheb3D","This constructor works only for 3D fits, %dD fit was requested\n",fDimOut); exit(1);}
 264   SetDimOut(DimOut);
 265   PrepareBoundaries(bmin,bmax);
 266   SetUsrFunction(ptr);
 267   //
 268   int gridNC[3][3];
 269   EstimateNPoints(prec,gridNC);
 270   DefineGrid(gridNC[0]);
 271   ChebFit(0);
 272   DefineGrid(gridNC[1]);
 273   ChebFit(1);
 274   DefineGrid(gridNC[2]);
 275   ChebFit(2);
 276   //
 277 }
 278 #endif
 279
 280
 281 //__________________________________________________________________________________________
 282 AliCheb3D& AliCheb3D::operator=(const AliCheb3D& rhs)
 283 {
 284   if (this != &rhs) {
 285     Clear();
 286     fDimOut   = rhs.fDimOut;
 287     fPrec     = rhs.fPrec;
 288     fMaxCoefs = rhs.fMaxCoefs;
 289     fUsrFunName = rhs.fUsrFunName;
 290     fUsrMacro   = 0;
 291     for (int i=3;i--;) {
 292       fBMin[i]    = rhs.fBMin[i];
 293       fBMax[i]    = rhs.fBMax[i];
 294       fBScale[i]  = rhs.fBScale[i];
 295       fBOffset[i] = rhs.fBOffset[i];
 296       fNPoints[i] = rhs.fNPoints[i];
 297     }
 298     for (int i=0;i<fDimOut;i++) {
 299       AliCheb3DCalc* cbc = rhs.GetChebCalc(i);
 300       if (cbc) fChebCalc.AddAtAndExpand(new AliCheb3DCalc(*cbc),i);
 301     }
 302   }
 303   return *this;
 304   //
 305 }
 306
 307 //__________________________________________________________________________________________
 308 void AliCheb3D::Clear(Option_t*)
 309 {
 310   if (fResTmp)        { delete[] fResTmp; fResTmp = 0; }
 311   if (fGrid)          { delete[] fGrid;   fGrid   = 0; }
 312   if (fUsrMacro)      { delete fUsrMacro; fUsrMacro = 0;}
 313   fChebCalc.Delete();
 314   //
 315 }
 316
 317 //__________________________________________________________________________________________
 318 void AliCheb3D::Print(Option_t* opt) const
 319 {
 320   printf("%s: Chebyshev parameterization for 3D->%dD function. Precision: %e\n",GetName(),fDimOut,fPrec);
 321   printf("Region of validity: [%+.5e:%+.5e] [%+.5e:%+.5e] [%+.5e:%+.5e]\n",fBMin[0],fBMax[0],fBMin[1],fBMax[1],fBMin[2],fBMax[2]);
 322   TString opts = opt; opts.ToLower();
 323   if (opts.Contains("l")) for (int i=0;i<fDimOut;i++) {printf("Output dimension %d:\n",i+1); GetChebCalc(i)->Print();}
 324   //
 325 }
 326
 327 //__________________________________________________________________________________________
 328 void AliCheb3D::PrepareBoundaries(Float_t  *bmin,Float_t  *bmax)
 329 {
 330   // Set and check boundaries defined by user, prepare coefficients for their conversion to [-1:1] interval
 331   //
 332   for (int i=3;i--;) {
 333     fBMin[i]   = bmin[i];
 334     fBMax[i]   = bmax[i];
 335     fBScale[i] = bmax[i]-bmin[i];
 336     if (fBScale[i]<=0) {
 337       Error("PrepareBoundaries","Boundaries for %d-th dimension are not increasing: %+.4e %+.4e\nStop\n",i,fBMin[i],fBMax[i]);
 338       exit(1);
 339     }
 340     fBOffset[i] = bmin[i] + fBScale[i]/2.0;
 341     fBScale[i] = 2./fBScale[i];
 342   }
 343   //
 344 }
 345
 346
 347 //__________________________________________________________________________________________
 348 #ifdef _INC_CREATION_ALICHEB3D_
 349
 350 // Pointer on user function (faster altrnative to TMethodCall)
 351 void (*gUsrFunAliCheb3D) (float* ,float* );
 352
 353 void AliCheb3D::EvalUsrFunction()
 354 {
 355   // call user supplied function
 356   if   (gUsrFunAliCheb3D) gUsrFunAliCheb3D(fArgsTmp,fResTmp);
 357   else fUsrMacro->Execute();
 358 }
 359
 360 void AliCheb3D::SetUsrFunction(const char* name)
 361 {
 362   // load user macro with function definition and compile it
 363   gUsrFunAliCheb3D = 0;
 364   fUsrFunName = name;
 365   gSystem->ExpandPathName(fUsrFunName);
 366   if (fUsrMacro) delete fUsrMacro;
 367   TString tmpst = fUsrFunName;
 368   tmpst += "+"; // prepare filename to compile
 369   if (gROOT->LoadMacro(tmpst.Data())) {Error("SetUsrFunction","Failed to load user function from %s\nStop\n",name); exit(1);}
 370   fUsrMacro = new TMethodCall();
 371   tmpst = tmpst.Data() + tmpst.Last('/')+1; //Strip away any path preceding the macro file name
 372   int dot = tmpst.Last('.');
 373   if (dot>0) tmpst.Resize(dot);
 374   fUsrMacro->InitWithPrototype(tmpst.Data(),"Float_t *,Float_t *");
 375   long args[2];
 376   args[0] = (long)fArgsTmp;
 377   args[1] = (long)fResTmp;
 378   fUsrMacro->SetParamPtrs(args);
 379   //
 380 }
 381 #endif
 382
 383 //__________________________________________________________________________________________
 384 #ifdef _INC_CREATION_ALICHEB3D_
 385 void AliCheb3D::SetUsrFunction(void (*ptr)(float*,float*))
 386 {
 387   if (fUsrMacro) delete fUsrMacro;
 388   fUsrMacro = 0;
 389   fUsrFunName = "";
 390   gUsrFunAliCheb3D = ptr;
 391 }
 392 #endif
 393
 394 //__________________________________________________________________________________________
 395 #ifdef _INC_CREATION_ALICHEB3D_
 396 void AliCheb3D::EvalUsrFunction(Float_t  *x, Float_t  *res) {
 397   for (int i=3;i--;) fArgsTmp[i] = x[i];
 398   if   (gUsrFunAliCheb3D) gUsrFunAliCheb3D(fArgsTmp,fResTmp);
 399   else fUsrMacro->Execute();
 400   for (int i=fDimOut;i--;) res[i] = fResTmp[i];
 401 }
 402 #endif
 403
 404 //__________________________________________________________________________________________
 405 #ifdef _INC_CREATION_ALICHEB3D_
 406 Int_t AliCheb3D::CalcChebCoefs(Float_t  *funval,int np, Float_t  *outCoefs, Float_t  prec)
 407 {
 408   // Calculate Chebyshev coeffs using precomputed function values at np roots.
 409   // If prec>0, estimate the highest coeff number providing the needed precision
 410   //
 411   double sm;                 // do summations in double to minimize the roundoff error
 412   for (int ic=0;ic<np;ic++) { // compute coeffs
 413     sm = 0;
 414     for (int ir=0;ir<np;ir++) {
 415       float  rt = TMath::Cos( ic*(ir+0.5)*TMath::Pi()/np);
 416       sm += funval[ir]*rt;
 417     }
 418     outCoefs[ic] = Float_t( sm * ((ic==0) ? 1./np : 2./np) );
 419   }
 420   //
 421   if (prec<=0) return np;
 422   //
 423   sm = 0;
 424   int cfMax = 0;
 425   for (cfMax=np;cfMax--;) {
 426     sm += TMath::Abs(outCoefs[cfMax]);
 427     if (sm>=prec) break;
 428   }
 429   if (++cfMax==0) cfMax=1;
 430   return cfMax;
 431   //
 432 }
 433 #endif
 434
 435 //__________________________________________________________________________________________
 436 #ifdef _INC_CREATION_ALICHEB3D_
 437 void AliCheb3D::DefineGrid(Int_t* npoints)
 438 {
 439   // prepare the grid of Chebyshev roots in each dimension
 440   const int kMinPoints = 1;
 441   int ntot = 0;
 442   fMaxCoefs = 1;
 443   for (int id=3;id--;) {
 444     fNPoints[id] = npoints[id];
 445     if (fNPoints[id]<kMinPoints) {
 446       Error("DefineGrid","at %d-th dimension %d point is requested, at least %d is needed\nStop\n",id,fNPoints[id],kMinPoints);
 447       exit(1);
 448     }
 449     ntot += fNPoints[id];
 450     fMaxCoefs *= fNPoints[id];
 451   }
 452   printf("Computing Chebyshev nodes on [%2d/%2d/%2d] grid\n",npoints[0],npoints[1],npoints[2]);
 453   if (fGrid) delete[] fGrid;
 454   fGrid = new Float_t [ntot];
 455   //
 456   int curp = 0;
 457   for (int id=3;id--;) {
 458     int np = fNPoints[id];
 459     fGridOffs[id] = curp;
 460     for (int ip=0;ip<np;ip++) {
 461       Float_t x = TMath::Cos( TMath::Pi()*(ip+0.5)/np );
 462       fGrid[curp++] = MapToExternal(x,id);
 463     }
 464   }
 465   //
 466 }
 467 #endif
 468
 469 //__________________________________________________________________________________________
 470 #ifdef _INC_CREATION_ALICHEB3D_
 471 Int_t AliCheb3D::ChebFit()
 472 {
 473   // prepare parameterization for all output dimensions
 474   int ir=0;
 475   for (int i=fDimOut;i--;) ir+=ChebFit(i);
 476   return ir;
 477 }
 478 #endif
 479
 480 //__________________________________________________________________________________________
 481 #ifdef _INC_CREATION_ALICHEB3D_
 482 Int_t AliCheb3D::ChebFit(int dmOut)
 483 {
 484   // prepare paramaterization of 3D function for dmOut-th dimension
 485   int maxDim = 0;
 486   for (int i=0;i<3;i++) if (maxDim<fNPoints[i]) maxDim = fNPoints[i];
 487   Float_t  *fvals      = new Float_t [ fNPoints[0] ];
 488   Float_t  *tmpCoef3D  = new Float_t [ fNPoints[0]*fNPoints[1]*fNPoints[2] ];
 489   Float_t  *tmpCoef2D  = new Float_t [ fNPoints[0]*fNPoints[1] ];
 490   Float_t  *tmpCoef1D  = new Float_t [ maxDim ];
 491   //
 492   Float_t RTiny = fPrec/Float_t(maxDim); // neglect coefficient below this threshold
 493   //
 494   // 1D Cheb.fit for 0-th dimension at current steps of remaining dimensions
 495   int ncmax = 0;
 496   //
 497   printf("Dim%d : 00.00%% Done",dmOut);fflush(stdout);
 498   AliCheb3DCalc* cheb =  GetChebCalc(dmOut);
 499   //
 500   float ncals2count = fNPoints[2]*fNPoints[1]*fNPoints[0];
 501   float ncals = 0;
 502   float frac = 0;
 503   float fracStep = 0.001;
 504   //
 505   for (int id2=fNPoints[2];id2--;) {
 506     fArgsTmp[2] = fGrid[ fGridOffs[2]+id2 ];
 507     //
 508     for (int id1=fNPoints[1];id1--;) {
 509       fArgsTmp[1] = fGrid[ fGridOffs[1]+id1 ];
 510       //
 511       for (int id0=fNPoints[0];id0--;) {
 512         fArgsTmp[0] = fGrid[ fGridOffs[0]+id0 ];
 513         EvalUsrFunction();     // compute function values at Chebyshev roots of 0-th dimension
 514         fvals[id0] =  fResTmp[dmOut];
 515         float fr = (++ncals)/ncals2count;
 516         if (fr-frac>=fracStep) {
 517           frac = fr;
 518           printf("\b\b\b\b\b\b\b\b\b\b\b");
 519           printf("%05.2f%% Done",fr*100);
 520           fflush(stdout);
 521         }
 522         //
 523       }
 524       int nc = CalcChebCoefs(fvals,fNPoints[0], tmpCoef1D, fPrec);
 525       for (int id0=fNPoints[0];id0--;) tmpCoef2D[id1 + id0*fNPoints[1]] = tmpCoef1D[id0];
 526       if (ncmax<nc) ncmax = nc;              // max coefs to be kept in dim0 to guarantee needed precision
 527     }
 528     //
 529     // once each 1d slice of given 2d slice is parametrized, parametrize the Cheb.coeffs
 530     for (int id0=fNPoints[0];id0--;) {
 531       CalcChebCoefs( tmpCoef2D+id0*fNPoints[1], fNPoints[1], tmpCoef1D, -1);
 532       for (int id1=fNPoints[1];id1--;) tmpCoef3D[id2 + fNPoints[2]*(id1+id0*fNPoints[1])] = tmpCoef1D[id1];
 533     }
 534   }
 535   //
 536   // now fit the last dimensions Cheb.coefs
 537   for (int id0=fNPoints[0];id0--;) {
 538     for (int id1=fNPoints[1];id1--;) {
 539       CalcChebCoefs( tmpCoef3D+ fNPoints[2]*(id1+id0*fNPoints[1]), fNPoints[2], tmpCoef1D, -1);
 540       for (int id2=fNPoints[2];id2--;) tmpCoef3D[id2+ fNPoints[2]*(id1+id0*fNPoints[1])] = tmpCoef1D[id2]; // store on place
 541     }
 542   }
 543   //
 544   // now find 2D surface which separates significant coefficients of 3D matrix from nonsignificant ones (up to fPrec)
 545   int *tmpCoefSurf = new Int_t[ fNPoints[0]*fNPoints[1] ];
 546   for (int id0=fNPoints[0];id0--;) for (int id1=fNPoints[1];id1--;) tmpCoefSurf[id1+id0*fNPoints[1]]=0;
 547   Double_t resid = 0;
 548   for (int id0=fNPoints[0];id0--;) {
 549     for (int id1=fNPoints[1];id1--;) {
 550       for (int id2=fNPoints[2];id2--;) {
 551         int id = id2 + fNPoints[2]*(id1+id0*fNPoints[1]);
 552         Float_t  cfa = TMath::Abs(tmpCoef3D[id]);
 553         if (cfa < RTiny) {tmpCoef3D[id] = 0; continue;} // neglect coefs below the threshold
 554         resid += cfa;
 555         if (resid<fPrec) continue; // this coeff is negligible
 556         // otherwise go back 1 step
 557         resid -= cfa;
 558         tmpCoefSurf[id1+id0*fNPoints[1]] = id2+1; // how many coefs to keep
 559         break;
 560       }
 561     }
 562   }
 563   /*
 564   printf("\n\nCoeffs\n");
 565   int cnt = 0;
 566   for (int id0=0;id0<fNPoints[0];id0++) {
 567     for (int id1=0;id1<fNPoints[1];id1++) {
 568       for (int id2=0;id2<fNPoints[2];id2++) {
 569         printf("%2d%2d%2d %+.4e |",id0,id1,id2,tmpCoef3D[cnt++]);
 570       }
 571       printf("\n");
 572     }
 573     printf("\n");
 574   }
 575   */
 576   // see if there are rows to reject, find max.significant column at each row
 577   int NRows = fNPoints[0];
 578   int *tmpCols = new int[NRows];
 579   for (int id0=fNPoints[0];id0--;) {
 580     int id1 = fNPoints[1];
 581     while (id1>0 && tmpCoefSurf[(id1-1)+id0*fNPoints[1]]==0) id1--;
 582     tmpCols[id0] = id1;
 583   }
 584   // find max significant row
 585   for (int id0=NRows;id0--;) {if (tmpCols[id0]>0) break; NRows--;}
 586   // find max significant column and fill the permanent storage for the max sigificant column of each row
 587   cheb->InitRows(NRows);                  // create needed arrays;
 588   int *NColsAtRow = cheb->GetNColsAtRow();
 589   int *ColAtRowBg = cheb->GetColAtRowBg();
 590   int NCols = 0;
 591   int NElemBound2D = 0;
 592   for (int id0=0;id0<NRows;id0++) {
 593     NColsAtRow[id0] = tmpCols[id0];     // number of columns to store for this row
 594     ColAtRowBg[id0] = NElemBound2D;     // begining of this row in 2D boundary surface
 595     NElemBound2D += tmpCols[id0];
 596     if (NCols<NColsAtRow[id0]) NCols = NColsAtRow[id0];
 597   }
 598   cheb->InitCols(NCols);
 599   delete[] tmpCols;
 600   //
 601   // create the 2D matrix defining the boundary of significance for 3D coeffs.matrix
 602   // and count the number of siginifacnt coefficients
 603   //
 604   cheb->InitElemBound2D(NElemBound2D);
 605   int *CoefBound2D0 = cheb->GetCoefBound2D0();
 606   int *CoefBound2D1 = cheb->GetCoefBound2D1();
 607   fMaxCoefs = 0; // redefine number of coeffs
 608   for (int id0=0;id0<NRows;id0++) {
 609     int nCLoc = NColsAtRow[id0];
 610     int Col0  = ColAtRowBg[id0];
 611     for (int id1=0;id1<nCLoc;id1++) {
 612       CoefBound2D0[Col0 + id1] = tmpCoefSurf[id1+id0*fNPoints[1]];  // number of coefs to store for 3-d dimension
 613       CoefBound2D1[Col0 + id1] = fMaxCoefs;
 614       fMaxCoefs += CoefBound2D0[Col0 + id1];
 615     }
 616   }
 617   //
 618   // create final compressed 3D matrix for significant coeffs
 619   cheb->InitCoefs(fMaxCoefs);
 620   Float_t  *Coefs = cheb->GetCoefs();
 621   int count = 0;
 622   for (int id0=0;id0<NRows;id0++) {
 623     int ncLoc = NColsAtRow[id0];
 624     int Col0  = ColAtRowBg[id0];
 625     for (int id1=0;id1<ncLoc;id1++) {
 626       int ncf2 = CoefBound2D0[Col0 + id1];
 627       for (int id2=0;id2<ncf2;id2++) {
 628         Coefs[count++] = tmpCoef3D[id2 + fNPoints[2]*(id1+id0*fNPoints[1])];
 629       }
 630     }
 631   }
 632   /*
 633   printf("\n\nNewSurf\n");
 634   for (int id0=0;id0<fNPoints[0];id0++) {
 635     for (int id1=0;id1<fNPoints[1];id1++) {
 636       printf("(%2d %2d) %2d |",id0,id1,tmpCoefSurf[id1+id0*fNPoints[1]]);
 637     }
 638     printf("\n");
 639   }
 640   */
 641   //
 642   delete[] tmpCoefSurf;
 643   delete[] tmpCoef1D;
 644   delete[] tmpCoef2D;
 645   delete[] tmpCoef3D;
 646   delete[] fvals;
 647   //
 648   printf("\b\b\b\b\b\b\b\b\b\b\b\b");
 649   printf("100.00%% Done\n");
 650   return 1;
 651 }
 652 #endif
 653
 654 //_______________________________________________
 655 #ifdef _INC_CREATION_ALICHEB3D_
 656 void AliCheb3D::SaveData(const char* outfile,Bool_t append) const
 657 {
 658   // writes coefficients data to output text file, optionallt appending on the end of existing file
 659   TString strf = outfile;
 660   gSystem->ExpandPathName(strf);
 661   FILE* stream = fopen(strf,append ? "a":"w");
 662   SaveData(stream);
 663   fclose(stream);
 664   //
 665 }
 666 #endif
 667
 668 //_______________________________________________
 669 #ifdef _INC_CREATION_ALICHEB3D_
 670 void AliCheb3D::SaveData(FILE* stream) const
 671 {
 672   // writes coefficients data to existing output stream
 673   //
 674   fprintf(stream,"\n# These are automatically generated data for the Chebyshev interpolation of 3D->%dD function\n",fDimOut);
 675   fprintf(stream,"#\nSTART %s\n",GetName());
 676   fprintf(stream,"# Dimensionality of the output\n%d\n",fDimOut);
 677   fprintf(stream,"# Interpolation abs. precision\n%+.8e\n",fPrec);
 678   //
 679   fprintf(stream,"# Lower boundaries of interpolation region\n");
 680   for (int i=0;i<3;i++) fprintf(stream,"%+.8e\n",fBMin[i]);
 681   fprintf(stream,"# Upper boundaries of interpolation region\n");
 682   for (int i=0;i<3;i++) fprintf(stream,"%+.8e\n",fBMax[i]);
 683   fprintf(stream,"# Parameterization for each output dimension follows:\n");
 684   //
 685   for (int i=0;i<fDimOut;i++) GetChebCalc(i)->SaveData(stream);
 686   fprintf(stream,"#\nEND %s\n#\n",GetName());
 687   //
 688 }
 689 #endif
 690
 691 //_______________________________________________
 692 void AliCheb3D::LoadData(const char* inpFile)
 693 {
 694   TString strf = inpFile;
 695   gSystem->ExpandPathName(strf);
 696   FILE* stream = fopen(strf.Data(),"r");
 697   LoadData(stream);
 698   fclose(stream);
 699   //
 700 }
 701
 702 //_______________________________________________
 703 void AliCheb3D::LoadData(FILE* stream)
 704 {
 705   if (!stream) {Error("LoadData","No stream provided.\nStop"); exit(1);}
 706   TString buffs;
 707   Clear();
 708   AliCheb3DCalc::ReadLine(buffs,stream);
 709   if (!buffs.BeginsWith("START")) {Error("LoadData","Expected: \"START <fit_name>\", found \"%s\"\nStop\n",buffs.Data());exit(1);}
 710   SetName(buffs.Data()+buffs.First(' ')+1);
 711   //
 712   AliCheb3DCalc::ReadLine(buffs,stream); // N output dimensions
 713   fDimOut = buffs.Atoi();
 714   if (fDimOut<1) {Error("LoadData","Expected: '<number_of_output_dimensions>', found \"%s\"\nStop\n",buffs.Data());exit(1);}
 715   //
 716   SetDimOut(fDimOut);
 717   //
 718   AliCheb3DCalc::ReadLine(buffs,stream); // Interpolation abs. precision
 719   fPrec = buffs.Atof();
 720   if (fPrec<=0) {Error("LoadData","Expected: '<abs.precision>', found \"%s\"\nStop\n",buffs.Data());exit(1);}
 721   //
 722   for (int i=0;i<3;i++) { // Lower boundaries of interpolation region
 723     AliCheb3DCalc::ReadLine(buffs,stream);
 724     fBMin[i] = buffs.Atof();
 725   }
 726   for (int i=0;i<3;i++) { // Upper boundaries of interpolation region
 727     AliCheb3DCalc::ReadLine(buffs,stream);
 728     fBMax[i] = buffs.Atof();
 729   }
 730   PrepareBoundaries(fBMin,fBMax);
 731   //
 732   // data for each output dimension
 733   for (int i=0;i<fDimOut;i++) GetChebCalc(i)->LoadData(stream);
 734   //
 735   // check end_of_data record
 736   AliCheb3DCalc::ReadLine(buffs,stream);
 737   if (!buffs.BeginsWith("END") || !buffs.Contains(GetName())) {
 738     Error("LoadData","Expected \"END %s\", found \"%s\".\nStop\n",GetName(),buffs.Data());
 739     exit(1);
 740   }
 741   //
 742 }
 743
 744 //_______________________________________________
 745 void AliCheb3D::SetDimOut(int d)
 746 {
 747   fDimOut = d;
 748   if (fResTmp) delete fResTmp;
 749   fResTmp = new Float_t[fDimOut];
 750   fChebCalc.Delete();
 751   for (int i=0;i<d;i++) fChebCalc.AddAtAndExpand(new AliCheb3DCalc(),i);
 752 }
 753
 754 //_______________________________________________
 755 void AliCheb3D::ShiftBound(int id,float dif)
 756 {
 757   if (id<0||id>2) {printf("Maximum 3 dimensions are supported\n"); return;}
 758   fBMin[id] += dif;
 759   fBMax[id] += dif;
 760   fBOffset[id] += dif;
 761 }
 762
 763 //_______________________________________________
 764 #ifdef _INC_CREATION_ALICHEB3D_
 765 TH1* AliCheb3D::TestRMS(int idim,int npoints,TH1* histo)
 766 {
 767   // fills the difference between the original function and parameterization (for idim-th component of the output)
 768   // to supplied histogram. Calculations are done in npoints random points.
 769   // If the hostgram was not supplied, it will be created. It is up to the user to delete it!
 770   if (!fUsrMacro) {
 771     printf("No user function is set\n");
 772     return 0;
 773   }
 774   if (!histo) histo = new TH1D(GetName(),"Control: Function - Parametrization",100,-2*fPrec,2*fPrec);
 775   for (int ip=npoints;ip--;) {
 776     gRandom->RndmArray(3,(Float_t *)fArgsTmp);
 777     for (int i=3;i--;) fArgsTmp[i] = fBMin[i] + fArgsTmp[i]*(fBMax[i]-fBMin[i]);
 778     EvalUsrFunction();
 779     Float_t valFun = fResTmp[idim];
 780     Eval(fArgsTmp,fResTmp);
 781     Float_t valPar = fResTmp[idim];
 782     histo->Fill(valFun - valPar);
 783   }
 784   return histo;
 785   //
 786 }
 787 #endif
 788
 789 //_______________________________________________
 790 #ifdef _INC_CREATION_ALICHEB3D_
 791 void AliCheb3D::EstimateNPoints(float Prec, int gridBC[3][3])
 792 {
 793   const float sclA[9] = {0.1, 0.5, 0.9, 0.1, 0.5, 0.9, 0.1, 0.5, 0.9} ;
 794   const float sclB[9] = {0.1, 0.1, 0.1, 0.5, 0.5, 0.5, 0.9, 0.9, 0.9} ;
 795   const float sclDim[2] = {0.01,0.99};
 796   const int   compDim[3][2] = { {1,2}, {2,0}, {0,1} };
 797   static float xyz[3];
 798   //
 799   for (int i=3;i--;)for (int j=3;j--;) gridBC[i][j] = -1;
 800   //
 801   for (int idim=0;idim<3;idim++) {
 802     float dimMN = fBMin[idim] + sclDim[0]*(fBMax[idim]-fBMin[idim]);
 803     float dimMX = fBMin[idim] + sclDim[1]*(fBMax[idim]-fBMin[idim]);
 804     //
 805     for (int it=0;it<9;it++) { // test in 9 points
 806       int id1 = compDim[idim][0]; // 1st fixed dim
 807       int id2 = compDim[idim][1]; // 2nd fixed dim
 808       xyz[ id1 ] = fBMin[id1] + sclA[it]*( fBMax[id1]-fBMin[id1] );
 809       xyz[ id2 ] = fBMin[id2] + sclB[it]*( fBMax[id2]-fBMin[id2] );
 810       //
 811       int* npt = GetNCNeeded(xyz,idim, dimMN,dimMX, Prec); // npoints for Bx,By,Bz
 812       for (int ib=0;ib<3;ib++) if (npt[ib]>gridBC[ib][idim]) gridBC[ib][idim] = npt[ib]+2;
 813       //
 814     }
 815   }
 816 }
 817
 818
 819 int* AliCheb3D::GetNCNeeded(float xyz[3],int DimVar, float mn,float mx, float prec)
 820 {
 821   // estimate needed number of chebyshev coefs for given function desctiption in DimVar dimension
 822   // The values for two other dimensions must be set beforehand
 823   //
 824   static int curNC[3];
 825   static int retNC[3];
 826   const int kMaxPoint = 400;
 827   float* gridVal = new float[3*kMaxPoint];
 828   float* coefs   = new float[3*kMaxPoint];
 829   //
 830   float scale = mx-mn;
 831   float offs  = mn + scale/2.0;
 832   scale = 2./scale;
 833   //
 834   int curNP;
 835   int maxNC=-1;
 836   int maxNCPrev=-1;
 837   for (int i=0;i<3;i++) retNC[i] = -1;
 838   for (int i=0;i<3;i++) fArgsTmp[i] = xyz[i];
 839   //
 840   for (curNP=5; curNP<kMaxPoint; curNP+=5) {
 841     maxNCPrev = maxNC;
 842     //
 843     for (int i=0;i<curNP;i++) { // get function values on Cheb. nodes
 844       float x = TMath::Cos( TMath::Pi()*(i+0.5)/curNP );
 845       fArgsTmp[DimVar] =  x/scale+offs; // map to requested interval
 846       EvalUsrFunction();
 847       for (int ib=3;ib--;) gridVal[ib*kMaxPoint + i] = fResTmp[ib];
 848     }
 849     //
 850     for (int ib=0;ib<3;ib++) {
 851       curNC[ib] = AliCheb3D::CalcChebCoefs(&gridVal[ib*kMaxPoint], curNP, &coefs[ib*kMaxPoint],prec);
 852       if (maxNC < curNC[ib]) maxNC = curNC[ib];
 853       if (retNC[ib] < curNC[ib]) retNC[ib] = curNC[ib];
 854     }
 855     if ( (curNP-maxNC)>3 &&  (maxNC-maxNCPrev)<1 ) break;
 856     maxNCPrev = maxNC;
 857     //
 858   }
 859   delete[] gridVal;
 860   delete[] coefs;
 861   return retNC;
 862   //
 863 }
 864 #endif