Map update. (R. Shahoyan)
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 23 Apr 2008 19:12:23 +0000 (19:12 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 23 Apr 2008 19:12:23 +0000 (19:12 +0000)
STEER/AliCheb3D.h
STEER/AliCheb3DCalc.cxx
STEER/AliCheb3DCalc.h
STEER/AliMagFCheb.cxx
STEER/AliMagFCheb.h

index 8ccc74a97a3b79389cec1cb799aaf67dd24adfdd..512b81dbe413b527526c8c46a60835006d069e0b 100644 (file)
@@ -98,8 +98,11 @@ class AliCheb3D: public TNamed
   Float_t      Eval(Float_t  *par,int idim);
   //
   void         EvalDeriv(int dimd, Float_t  *par,Float_t  *res);
+  void         EvalDeriv2(int dimd1, int dimd2,Float_t  *par,Float_t  *res);
   Float_t      EvalDeriv(int dimd,Float_t  *par, int idim);
+  Float_t      EvalDeriv2(int dimd1,int dimd2, Float_t  *par, int idim);
   void         EvalDeriv3D(Float_t *par, Float_t dbdr[3][3]); 
+  void         EvalDeriv3D2(Float_t *par, Float_t dbdrdr[3][3][3]); 
   void         Print(Option_t* opt="")                                   const;
   Bool_t       IsInside(Float_t  *par)                                   const;
   Bool_t       IsInside(Double_t  *par)                                  const;
@@ -210,6 +213,15 @@ inline void AliCheb3D::EvalDeriv3D(Float_t *par, Float_t dbdr[3][3])
   for (int ib=3;ib--;) for (int id=3;id--;) dbdr[ib][id] = GetChebCalc(ib)->EvalDeriv(id,fArgsTmp)*fBScale[id];
 }
 
+//__________________________________________________________________________________________
+inline void AliCheb3D::EvalDeriv3D2(Float_t *par, Float_t dbdrdr[3][3][3])
+{
+  // return gradient matrix
+  for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
+  for (int ib=3;ib--;) for (int id=3;id--;)for (int id1=3;id1--;) 
+    dbdrdr[ib][id][id1] = GetChebCalc(ib)->EvalDeriv2(id,id1,fArgsTmp)*fBScale[id]*fBScale[id1];
+}
+
 //__________________________________________________________________________________________
 inline void AliCheb3D::EvalDeriv(int dimd,Float_t  *par, Float_t  *res)
 {
@@ -219,6 +231,15 @@ inline void AliCheb3D::EvalDeriv(int dimd,Float_t  *par, Float_t  *res)
   //
 }
 
+//__________________________________________________________________________________________
+inline void AliCheb3D::EvalDeriv2(int dimd1,int dimd2,Float_t  *par, Float_t  *res)
+{
+  // evaluate Chebyshev parameterization 2nd derivative over dimd1 and dimd2 dimensions for 3d->DimOut function
+  for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
+  for (int i=fDimOut;i--;) res[i] = GetChebCalc(i)->EvalDeriv2(dimd1,dimd2,fArgsTmp)*fBScale[dimd1]*fBScale[dimd2];
+  //
+}
+
 //__________________________________________________________________________________________
 inline Float_t AliCheb3D::EvalDeriv(int dimd,Float_t  *par, int idim)
 {
@@ -228,6 +249,15 @@ inline Float_t AliCheb3D::EvalDeriv(int dimd,Float_t  *par, int idim)
   //
 }
 
+//__________________________________________________________________________________________
+inline Float_t AliCheb3D::EvalDeriv2(int dimd1,int dimd2,Float_t  *par, int idim)
+{
+  // evaluate Chebyshev parameterization 2ns derivative over dimd1 and dimd2 dimensions for idim-th output dimension of 3d->DimOut function
+  for (int i=3;i--;) fArgsTmp[i] = MapToInternal(par[i],i);
+  return GetChebCalc(idim)->EvalDeriv2(dimd1,dimd2,fArgsTmp)*fBScale[dimd1]*fBScale[dimd2];
+  //
+}
+
 //__________________________________________________________________________________________
 inline Float_t AliCheb3D::MapToInternal(Float_t  x,Int_t d) const
 {
index 43ff533f28e4e48aad6be707aae824729ea8ae02..16e4aac97def351cd10b339971293b1a8acdcb4b 100644 (file)
@@ -186,19 +186,52 @@ Float_t  AliCheb3DCalc::EvalDeriv(int dim, Float_t  *par) const
   int ncfRC;
   for (int id0=fNRows;id0--;) {
     int nCLoc = fNColsAtRow[id0];                   // number of significant coefs on this row
+    if (!nCLoc) {fTmpCf0[id0]=0; continue;}
+    // 
     int Col0  = fColAtRowBg[id0];                   // beginning of local column in the 2D boundary matrix
     for (int id1=nCLoc;id1--;) {
       int id = id1+Col0;
-      if (dim==2) fTmpCf1[id1] = (ncfRC=fCoefBound2D0[id]) ? ChebEval1Deriv(z,fCoefs + fCoefBound2D1[id], ncfRC) : 0.0;
-      else        fTmpCf1[id1] = (ncfRC=fCoefBound2D0[id]) ? ChebEval1D(z,fCoefs + fCoefBound2D1[id], ncfRC) : 0.0;
+      if (!(ncfRC=fCoefBound2D0[id])) { fTmpCf1[id1]=0; continue;}
+      if (dim==2) fTmpCf1[id1] = ChebEval1Deriv(z,fCoefs + fCoefBound2D1[id], ncfRC);
+      else        fTmpCf1[id1] = ChebEval1D(z,fCoefs + fCoefBound2D1[id], ncfRC);
     }
-    if (dim==1)   fTmpCf0[id0] = nCLoc>0 ? ChebEval1Deriv(y,fTmpCf1,nCLoc):0.0;
-    else          fTmpCf0[id0] = nCLoc>0 ? ChebEval1D(y,fTmpCf1,nCLoc):0.0;
+    if (dim==1)   fTmpCf0[id0] = ChebEval1Deriv(y,fTmpCf1,nCLoc);
+    else          fTmpCf0[id0] = ChebEval1D(y,fTmpCf1,nCLoc);
   }
   return (dim==0) ? ChebEval1Deriv(x,fTmpCf0,fNRows) : ChebEval1D(x,fTmpCf0,fNRows);
   //
 }
 
+//__________________________________________________________________________________________
+Float_t  AliCheb3DCalc::EvalDeriv2(int dim1,int dim2, Float_t  *par) const
+{
+  // evaluate Chebyshev parameterization 2n derivative in given dimensions  for 3D function.
+  // VERY IMPORTANT: par must contain the function arguments ALREADY MAPPED to [-1:1] interval
+  Float_t  &z = par[2];
+  Float_t  &y = par[1];
+  Float_t  &x = par[0];
+  //
+  Bool_t same = dim1==dim2;
+  int ncfRC;
+  for (int id0=fNRows;id0--;) {
+    int nCLoc = fNColsAtRow[id0];                   // number of significant coefs on this row
+    if (!nCLoc) {fTmpCf0[id0]=0; continue;}
+    //
+    int Col0  = fColAtRowBg[id0];                   // beginning of local column in the 2D boundary matrix
+    for (int id1=nCLoc;id1--;) {
+      int id = id1+Col0;
+      if (!(ncfRC=fCoefBound2D0[id])) { fTmpCf1[id1]=0; continue;}
+      if (dim1==2||dim2==2) fTmpCf1[id1] = same ? ChebEval1Deriv2(z,fCoefs + fCoefBound2D1[id], ncfRC) 
+                             :                   ChebEval1Deriv(z,fCoefs + fCoefBound2D1[id], ncfRC);
+      else        fTmpCf1[id1] = ChebEval1D(z,fCoefs + fCoefBound2D1[id], ncfRC);
+    }
+    if (dim1==1||dim2==1) fTmpCf0[id0] = same ? ChebEval1Deriv2(y,fTmpCf1,nCLoc):ChebEval1Deriv(y,fTmpCf1,nCLoc);
+    else                  fTmpCf0[id0] = ChebEval1D(y,fTmpCf1,nCLoc);
+  }
+  return (dim1==0||dim2==0) ? (same ? ChebEval1Deriv2(x,fTmpCf0,fNRows):ChebEval1Deriv(x,fTmpCf0,fNRows)) : ChebEval1D(x,fTmpCf0,fNRows);
+  //
+}
+
 //_______________________________________________
 #ifdef _INC_CREATION_ALICHEB3D_
 void AliCheb3DCalc::SaveData(const char* outfile,Bool_t append) const
@@ -350,13 +383,13 @@ void AliCheb3DCalc::InitCoefs(int nc)
 Float_t AliCheb3DCalc::ChebEval1Deriv(Float_t  x, const Float_t * array, int ncf )
 {
   // evaluate 1D Chebyshev parameterization's derivative. x is the argument mapped to [-1:1] interval
-  if (--ncf<2) return 0;
+  if (--ncf<1) return 0;
   Float_t b0, b1, b2;
   Float_t x2 = x+x;
   b1 = b2 = 0;
   float dcf0=0,dcf1,dcf2=0;
   b0 = dcf1 = 2*ncf*array[ncf];
-  if (!(--ncf)) dcf0 = dcf1;
+  if (!(--ncf)) return b0/2;
   //
   for (int i=ncf;i--;) {
     b2 = b1;      
@@ -369,3 +402,41 @@ Float_t AliCheb3DCalc::ChebEval1Deriv(Float_t  x, const Float_t * array, int ncf
   //
   return b0 - x*b1 - dcf0/2;
 }
+
+//__________________________________________________________________________________________
+Float_t AliCheb3DCalc::ChebEval1Deriv2(Float_t  x, const Float_t * array, int ncf )
+{
+  // evaluate 1D Chebyshev parameterization's 2nd derivative. x is the argument mapped to [-1:1] interval
+  if (--ncf<2) return 0;
+  Float_t b0, b1, b2;
+  Float_t x2 = x+x;
+  b1 = b2 = 0;
+  float dcf0=0,dcf1=0,dcf2=0;
+  float ddcf0=0,ddcf1,ddcf2=0;
+  //
+  dcf2 = 2*ncf*array[ncf]; 
+  --ncf; 
+
+  dcf1 = 2*ncf*array[ncf]; 
+  b0 = ddcf1 = 2*ncf*dcf2; 
+  //
+  if (!(--ncf)) return b0/2;
+  //
+  for (int i=ncf;i--;) {
+    b2 = b1;                        
+    b1 = b0;
+    dcf0  = dcf2 + 2*(i+1)*array[i+1];
+    ddcf0 = ddcf2 + 2*(i+1)*dcf1; 
+    b0 = ddcf0 + x2*b1 -b2;
+    //
+    ddcf2 = ddcf1;  
+    ddcf1 = ddcf0;
+    //
+    dcf2 = dcf1;
+    dcf1 = dcf0;
+    //
+  }
+  //
+  return b0 - x*b1 - ddcf0/2;
+}
+
index a9653ab6c70928b27bde46c319169c000f2207d1..0809743aaa42278ce84f5c58fb5c44dd3fac8878 100644 (file)
@@ -13,7 +13,7 @@
 
 // to decrease the compilable code size comment this define. This will exclude the routines 
 // used for the calculation and saving of the coefficients. 
-#define _INC_CREATION_ALICHEB3D_
+//#define _INC_CREATION_ALICHEB3D_
 
 // when _BRING_TO_BOUNDARY_ is defined, the point outside of the fitted folume is assumed
 // to be on the surface 
@@ -34,6 +34,7 @@ class AliCheb3DCalc: public TNamed
   void       LoadData(FILE* stream);
   Float_t    Eval(Float_t  *par)                                       const;
   Float_t    EvalDeriv(int dim, Float_t  *par)                         const;
+  Float_t    EvalDeriv2(int dim1,int dim2, Float_t  *par)                         const;
   //
 #ifdef _INC_CREATION_ALICHEB3D_
   void       SaveData(const char* outfile,Bool_t append=kFALSE)        const;
@@ -48,8 +49,9 @@ class AliCheb3DCalc: public TNamed
   Int_t*     GetCoefBound2D0()                                          const {return fCoefBound2D0;}
   Int_t*     GetCoefBound2D1()                                          const {return fCoefBound2D1;}
   void       Clear(Option_t* option = "");
-  static Float_t    ChebEval1D(Float_t  x, const Float_t * array, int ncf);//     const;  
-  static Float_t    ChebEval1Deriv(Float_t  x, const Float_t * array, int ncf);// const;  
+  static Float_t    ChebEval1D(Float_t  x, const Float_t * array, int ncf);
+  static Float_t    ChebEval1Deriv(Float_t  x, const Float_t * array, int ncf);
+  static Float_t    ChebEval1Deriv2(Float_t  x, const Float_t * array, int ncf);
   void       InitCoefs(int nc);
   Float_t *  GetCoefs()                                                 const {return fCoefs;}
   //
index b486249b70269c4a37513a1b2faed9e6dd783c01..e874f8bfa09e7c1b4e71228682298348d381b305 100644 (file)
@@ -378,7 +378,7 @@ void AliMagFCheb::Print(Option_t *) const
   
 
 }
-
+#ifdef  _INC_CREATION_ALICHEB3D_
 //_______________________________________________
 void AliMagFCheb::LoadData(const char* inpfile)
 {
@@ -477,6 +477,7 @@ void AliMagFCheb::LoadData(const char* inpfile)
   printf("Loaded magnetic field \"%s\" from %s\n",GetName(),strf.Data());
   //
 }
+#endif
 
 //_________________________________________________________________________
 Int_t AliMagFCheb::FindDipSegment(float *xyz) const
index 3d6b9188be98814bb441327f8fee777b09199d51..6b381d4e16ddab345836a0055cd6205c1862e360 100644 (file)
@@ -72,8 +72,6 @@ class AliMagFCheb: public TNamed
   AliCheb3D* GetParamTPCInt(Int_t ipar)                   const {return (AliCheb3D*)fParamsTPCInt->UncheckedAt(ipar);}
   AliCheb3D* GetParamDip(Int_t ipar)                      const {return (AliCheb3D*)fParamsDip->UncheckedAt(ipar);}
   //
-  void         LoadData(const char* inpfile);
-  //
   virtual void Print(Option_t * = "")                     const;
   //
   virtual void Field(Float_t *xyz, Float_t *b)            const;
@@ -90,6 +88,8 @@ class AliMagFCheb: public TNamed
   static void CylToCart(float *rphiz,float *xyz);
   //
 #ifdef  _INC_CREATION_ALICHEB3D_                          // see AliCheb3D.h for explanation
+  void         LoadData(const char* inpfile);
+  //
   AliMagFCheb(const char* inputFile);
   void       SaveData(const char* outfile)              const;
   Int_t      SegmentDipDimension(float** seg,const TObjArray* par,int npar, int dim,