STEER/AliCheb3D.cxx

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