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