Introduce new class AliMagFDM - Galina Chabratova
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 9 Jun 2000 19:55:18 +0000 (19:55 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 9 Jun 2000 19:55:18 +0000 (19:55 +0000)
STEER/AliMagF.cxx
STEER/AliMagF.h

index 1dd9ed0..0e790ca 100644 (file)
 
 /*
 $Log$
+
+Revision 1.4  2000/03/28 12:40:24  fca
+Introduce factor for magnetic field
+
+
 Revision 1.3  1999/09/29 09:24:29  fca
 Introduction of the Copyright and cvs Log
 
@@ -23,6 +28,7 @@ Introduction of the Copyright and cvs Log
 
 #include "AliMagF.h"
 #include "TSystem.h"
+
 #include <stdlib.h>
 #include <stdio.h>
 
@@ -344,6 +350,654 @@ void AliMagFCM::ReadField()
     exit(1);
   }
 }
+// ------------------------------------------------------- 
+
+ClassImp(AliMagFDM)
 
+//________________________________________
+AliMagFDM::AliMagFDM(const char *name, const char *title, const Int_t integ,
+const Int_t map, const Float_t factor, const Float_t fmax)
+  : AliMagF(name,title,integ,map,factor,fmax)
+  
+{
+  fType = DipoMap;
+
+  printf("Field Map for Muon Arm from IP till muon filter %s created: map= %d, factor= %f, file=%s\n",fName.Data(),map,factor,fTitle.Data());
+  
+}
+
+//________________________________________
+
+void AliMagFDM::Field(Float_t *xfi, Float_t *b)
+{
+  static  const Double_t eps=0.1E-06;
+  static  const Double_t pi2=.6283185E+01;
+  static  const Double_t one=1;
+  static  const Double_t fdYaxi = 0.3;
+
+  static  const    Int_t  kiip=33; 
+  static  const    Int_t  miip=0;    
+  static  const    Int_t  liip=0;
+
+  static  const    Int_t  kiic=0;
+  static  const    Int_t  miic=0;    
+  static  const    Int_t  liic=0;       
+
+  static  const Double_t    fdZbg=502.92;  // Start of Map using in z
+  static  const Double_t    fdZL3=600;  // Beginning of L3 door in z
+
+  Double_t   x[3];   
+  Double_t   xL3[3]; 
+  Double_t   bint[3]; 
+  
+  Double_t r0;
   
+  Double_t bbj;
+  Int_t Kvar,jb;
+
+  Double_t Zp1, Zp2,Xp1,Xp2,Yp1,Yp2; 
+  Double_t Zz1, Zz2,Yy1,Yy2,X2,X1; 
+     
+// --- start the map fiel from z = 502.92 cm ---
+
+  x[0] = xfi[0];
+  x[1] = xfi[1];
+  x[2] = xfi[2];
+  b[0]=b[1]=b[2]=0;
+  //       printf("x[0]  %f,x[1] %f,x[2]  %f\n",x[0],x[1],x[2]); 
+
+  Double_t rr=TMath::Sqrt(x[0]*x[0]+x[1]*x[1]);
+           r0=rr/100;
+  Double_t Rpmax;
+  Rpmax=fdRmax; 
+  if ( (-700<x[2] && x[2]<=fdZbg && 
+        (x[0]*x[0]+(x[1]+30)*(x[1]+30))< 560*560)
+       || (fdZbg<x[2] && x[2]<=fdZL3 && rr>=Rpmax*100) )
+       {
+        b[2]=2;
+       }
+
+  xL3[0]=x[0]/100;
+  xL3[1]=(x[1]+30)/100;
+  xL3[2]=x[2]/100; 
+  Double_t xminn=xL3[2]*fdAx1+fdCx1;
+  Double_t xmaxx=xL3[2]*fdAx2+fdCx2;
+  Double_t Zcmin,Zcmax,Ycmin,Ycmax;
+
+  Zcmin=fdZmin;
+  Zcmax=fdZmax;
+  Ycmin=fdYmin;
+  Ycmax=fdYmax;
+          
+if ((fdZbg/100<xL3[2] && xL3[2]<Zcmin && r0<Rpmax) || ((Zcmin<=xL3[2] && xL3[2] <= Zcmax ) && (Ycmin<=xL3[1] && xL3[1]<= Ycmax) &&  (xminn <= xL3[0] && xL3[0] <= xmaxx)))
+    {
+     if(fMap==3) 
+      { 
+       if (xL3[2]<Zcmin && r0<Rpmax)   
+       {
+       //---------------------  Polar part ----------------------
+       
+       Double_t yyp,ph0;
+       Int_t  kp0, lp0, mp0;
+       Int_t kpi,lpi,mpi;
+       Double_t alp1,alp2,alp3;
+       Double_t zpz,rp,fip,cphi; 
+
+       kpi=kiip; 
+       lpi=liip;
+       mpi=miip;
+   
+       zpz=xL3[2];
+
+       FZ(&zpz, fdZp ,&fdZpdl,&kpi,&kp0,&Zp1 ,&Zp2,&fdZpl) ;
+
+       yyp=xL3[1]- 0.3;
+       cphi=yyp/r0;
+       ph0=TMath::ACos(cphi);
+       if (xL3[0]< 0) {ph0=pi2 - ph0;}  
+                                  
+       fip=ph0;
+       FZ(&fip,fdPhi,&fdPhid ,&mpi,&mp0, &Xp1,&Xp2,&fdPhin); 
+
+       Double_t Rdel;
+       Rdel=fdRdel;
+
+       if (r0<= fdRdel)
+        {
+
+         if(r0< eps) 
+         {
+
+          bint[0]=(Zp1*fdBpx[kp0][0][0] + Zp2*fdBpx[kp0+1][0][0])*10;     
+          bint[1]=(Zp1*fdBpy[kp0][0][0] + Zp2*fdBpy[kp0+1][0][0])*10;      
+          bint[2]=(Zp1*fdBpz[kp0][0][0] + Zp2*fdBpz[kp0+1][0][0])*10; 
+
+         }  
+      
+        alp2= fdB[0][0][mp0]*yyp + fdB[0][1][mp0]*xL3[0]; 
+        alp3= fdB[1][0][mp0]*yyp + fdB[1][1][mp0]*xL3[0];      
+        alp1= one - alp2 - alp3;
+     
+        for (jb=0; jb<3 ; jb++) 
+        {
+         Kvar=jb;     
+         FRfuncBi(&Kvar,&Zp1,&Zp2,&alp1,&alp2,&alp3, &kp0,&mp0, &bbj);
+         bint[jb] = bbj*10 ;
+        }  
+       }
+        else
+       {
+        rp=r0;
+
+        FZ(&rp,fdR ,&fdRdel,&lpi,&lp0,&Yp1,&Yp2,&fdRn);
+
+        for (jb=0; jb<3 ; jb++) 
+        {
+         Kvar=jb;
+         FGfuncBi(&Zp1,&Zp2,&Yp1,&Yp2,&Xp1,&Xp2,&Kvar,&kp0,&lp0,&mp0,&bbj); 
+
+         bint[jb] = bbj*10 ;
+        }
+       }
+
+       b[0]=bint[0];
+       b[1]=bint[1];
+       b[2]=bint[2];
+
+//    fprintf(fitest,"-------------   Freg2 run -------------\n");       
+  
+   }  
+   else 
+   {
+   //-------------- Cartensian part ------------------
+          
+   Double_t zzc,yyc; 
+   Int_t k0, l0,m0;
+   Double_t  xx1, xx2,dx, xxx ,xXl; 
+   Int_t kci,mci,lci;
+
+   kci=kiic;
+   lci=liic;
+   mci=miic;
+
+   xx1 = fdAx1*xL3[2] + fdCx1;
+   xx2 = fdAx2*xL3[2] + fdCx2;
+
+   zzc=xL3[2];
+   FZ(&zzc, fdZc ,&fdZdel, &kci,&k0, &Zz1, &Zz2, &fdZl);     
+
+   yyc=xL3[1];
+   FZ(&yyc, fdY , &fdYdel,&lci, &l0, &Yy1, &Yy2,&fdYl);  
+
+   xXl = fdXl-one; 
+   dx = (xx2-xx1)/xXl;
+   xxx= xL3[0]-xx1;
+   //     xm = xxx/dx; 
+   m0 = int(xxx/dx);   
+
+   if(xL3[0]<(xx1+m0*dx) || xL3[0] >(xx1+(m0+1)*dx)) 
+    {
+      m0=m0+1;   
+      printf(" m0 %d, m0+1 %d\n",m0,m0+1);  
+    }
+
+   X2=(xL3[0]-( xx1+m0*dx))/dx;
+   X1=one-X2;
+   m0=m0-1;
+   for (jb=3; jb<6; jb++) 
+     {
+       Kvar=jb;     
+       FGfuncBi(&Zz1,&Zz2,&Yy1,&Yy2,&X1,&X2,&Kvar,&k0, &l0, &m0, &bbj); 
+       bint[jb-3] = bbj*10 ; 
+     }    
+   b[0]=bint[0];
+   b[1]=bint[1];
+   b[2]=bint[2]; 
+
+//   fprintf(fitest,"------------   Freg1 run -----------------\n");            
+   } 
+
+  } else {
+        printf("Unknown map of Dipole region %d\n",fMap);
+ }
+           
+} else {
+
+//This is the ZDC part
+      Float_t rad2=x[0]*x[0]+x[1]*x[1];
+      if(rad2<D2RA2) {
+        if(x[2]>D2BEG) {
+          
+//    Separator Dipole D2
+          if(x[2]<D2END) b[1]=FDIP;
+        } else if(x[2]>D1BEG) {
+
+//    Separator Dipole D1
+          if(x[2]<D1END) b[1]=-FDIP;
+        }
+        if(rad2<CORRA2) {
+
+//    First quadrupole of inner triplet de-focussing in x-direction
+//    Inner triplet
+          if(x[2]>Z4BEG) {
+            if(x[2]<Z4END) {
+              
+//    2430 <-> 3060
+              b[0]=-G1*x[1];
+              b[1]=-G1*x[0];
+            }
+          } else if(x[2]>Z3BEG) {
+            if(x[2]<Z3END) {
+
+//    1530 <-> 2080
+              b[0]=G1*x[1];
+              b[1]=G1*x[0];
+            }
+          } else if(x[2]>Z2BEG) {
+            if(x[2]<Z2END) {
+
+//    890 <-> 1430
+              b[0]=G1*x[1];
+              b[1]=G1*x[0];
+            }
+          } else if(x[2]>Z1BEG) {
+            if(x[2]<Z1END) {
+
+//    0 <->  630
+              b[0]=-G1*x[1];
+              b[1]=-G1*x[0];
+            }
+          } else if(x[2]>CORBEG) {
+            if(x[2]<COREND) {
+//    Corrector dipole (because of dimuon arm)
+//            b[0]=FCORN;
+              b[0]=-FCORN;
+            }
+          }
+        }
+      }
+    }
+
+  if(fFactor!=1) {
+    b[0]*=fFactor;
+    b[1]*=fFactor;
+    b[2]*=fFactor;
+  }
+}
+
+//_________________________________________
+
+void AliMagFDM::FZ(Double_t *u, Float_t  *Ar, Float_t *du,Int_t *ki,Int_t *kf,Double_t *a1,Double_t *a2 ,Int_t *nu)
+
+ {
+  static  const Double_t one=1;
+  Int_t l,ik,ikj;
+  Double_t temp;
+  Double_t ddu,delu,ar;
+
+  Int_t nk,ku;
+  temp=*u;
+  nk=*nu;
+  ik=*ki;
+  delu=*du; 
+
+  ar=Ar[ik];
+  ddu=temp-ar;
+
+  ku=int(ddu/delu);
+  ikj=ik+ku;
+  if (ddu<=0) ikj=0;
+
+   for(l=ikj; l<nk; l++)
+   {
+
+    if(temp < Ar[l])
+     {
+      *kf=l;
+      *a2=(temp-Ar[l])/(Ar[l+1]-Ar[l]);
+      *a1= one - *a2;
+      break;     
+     }
+    }
+  }
+
+/*-------------FRfuncBi----------------*/
+
+void AliMagFDM::FRfuncBi(Int_t *kai,Double_t *za1, Double_t *za2, Double_t *al1, Double_t *al2, Double_t *al3, Int_t *ka, Int_t *ma, Double_t *ba)
+  
+{
+Double_t fa11,fa12,fa13;
+Double_t fa21,fa22,fa23;
+Double_t faY1,faY2;
+Double_t bba;
+
+Double_t zaa1,zaa2,alf1,alf2,alf3;
+Int_t kaai,kaa,maa;
+kaai=*kai;
+kaa=*ka;
+maa=*ma;
+zaa1=*za1;
+zaa2=*za2;
+alf1=*al1;  
+alf2=*al2;
+alf3=*al3; 
+
+ if (kaai==0 ) {
+              fa11 = fdBpx[kaa][0][0];
+              fa12 = fdBpx[kaa][0][maa];
+              fa13 = fdBpx[kaa][0][maa+1];
+              fa21 = fdBpx[kaa+1][0][0];
+              fa22 = fdBpx[kaa+1][0][maa];               
+              fa23 = fdBpx[kaa+1][0][maa+1]; 
+              }
+ if (kaai==1 ) {
+              fa11 = fdBpy[kaa][0][0];
+              fa12 = fdBpy[kaa][0][maa];
+              fa13 = fdBpy[kaa][0][maa+1];
+              fa21 = fdBpy[kaa+1][0][0];
+              fa22 = fdBpy[kaa+1][0][maa];               
+              fa23 = fdBpy[kaa+1][0][maa+1]; 
+              }
+ if (kaai==2 ) {
+              fa11 = fdBpz[kaa][0][0];
+              fa12 = fdBpz[kaa][0][maa];
+              fa13 = fdBpz[kaa][0][maa+1];
+              fa21 = fdBpz[kaa+1][0][0];
+              fa22 = fdBpz[kaa+1][0][maa];               
+              fa23 = fdBpz[kaa+1][0][maa+1]; 
+              }                            
+    faY1=alf1*fa11+alf2*fa12+alf3*fa13;
+    faY2=alf1*fa21+alf2*fa22+alf3*fa23;
+    bba =  zaa1*faY1+zaa2*faY2;    
+    *ba=bba;
+
+}
+
+  
+/*----------- FGfuncBi------------*/
+
+void AliMagFDM::FGfuncBi(Double_t *zz1,Double_t *zz2, Double_t *yy1,Double_t *yy2, Double_t *xx1,Double_t *xx2, Int_t *kvr, Int_t *kk, Int_t *ll, Int_t *mm, Double_t *bb)
+
+{  
+Double_t fy1, fy2, ffy;
+Double_t gy1,gy2,ggy;
+Double_t z1,z2,y1,y2,x1,x2;
+
+Int_t k,l,m,kv;
+Double_t bbi;
+
+Double_t bf11,bf12,bf21,bf22;
+Double_t bg11,bg12,bg21,bg22;
+k=*kk;
+l=*ll;
+m=*mm;
+
+kv=*kvr;
+
+z1=*zz1;
+z2=*zz2;
+y1=*yy1;
+y2=*yy2;
+x1=*xx1;
+x2=*xx2; 
+/*-----------------Polar part ------------------*/
+
+if(kv==0) {
+           bf11=fdBpx[k][l][m];
+           bf12=fdBpx[k+1][l][m];
+           bf21=fdBpx[k+1][l+1][m];
+           bf22=fdBpx[k][l+1][m];
+           
+           bg11=fdBpx[k][l][m+1];
+           bg12=fdBpx[k+1][l][m+1];
+           bg21=fdBpx[k+1][l+1][m+1];
+           bg22=fdBpx[k][l+1][m+1];
+           }
+ if(kv==1) {
+           bf11=fdBpy[k][l][m];
+           bf12=fdBpy[k+1][l][m];
+           bf21=fdBpy[k+1][l+1][m];
+           bf22=fdBpy[k][l+1][m];
+           
+           bg11=fdBpy[k][l][m+1];
+           bg12=fdBpy[k+1][l][m+1];
+           bg21=fdBpy[k+1][l+1][m+1];
+           bg22=fdBpy[k][l+1][m+1];
+           }  
+                   
+ if(kv==2) {
+           bf11=fdBpz[k][l][m];
+           bf12=fdBpz[k+1][l][m];
+           bf21=fdBpz[k+1][l+1][m];
+           bf22=fdBpz[k][l+1][m];
+           
+           bg11=fdBpz[k][l][m+1];
+           bg12=fdBpz[k+1][l][m+1];
+           bg21=fdBpz[k+1][l+1][m+1];
+           bg22=fdBpz[k][l+1][m+1];           
+           } 
+/*-----------------Cartensian part ---------------*/ 
+                   
+ if(kv==3) {
+           bf11=fdBcx[k][l][m];
+           bf12=fdBcx[k+1][l][m];
+           bf21=fdBcx[k+1][l+1][m];
+           bf22=fdBcx[k][l+1][m];
+           
+           bg11=fdBcx[k][l][m+1];
+           bg12=fdBcx[k+1][l][m+1];
+           bg21=fdBcx[k+1][l+1][m+1];
+           bg22=fdBcx[k][l+1][m+1];
+           }          
+                      
+ if(kv==4) {
+           bf11=fdBcy[k][l][m];
+           bf12=fdBcy[k+1][l][m];
+           bf21=fdBcy[k+1][l+1][m];
+           bf22=fdBcy[k][l+1][m];
+           
+           bg11=fdBcy[k][l][m+1];
+           bg12=fdBcy[k+1][l][m+1];
+           bg21=fdBcy[k+1][l+1][m+1];
+           bg22=fdBcy[k][l+1][m+1];
+           }          
+ if(kv==5) {
+           bf11=fdBcz[k][l][m];
+           bf12=fdBcz[k+1][l][m];
+           bf21=fdBcz[k+1][l+1][m];
+           bf22=fdBcz[k][l+1][m];
+           
+           bg11=fdBcz[k][l][m+1];
+           bg12=fdBcz[k+1][l][m+1];
+           bg21=fdBcz[k+1][l+1][m+1];
+           bg22=fdBcz[k][l+1][m+1];
+           }  
+
+                                       
+     fy1=z1*bf11+z2*bf12;
+     fy2=z2*bf21+z1* bf22;
+     ffy=y1*fy1+ y2*fy2; 
+     
+
+     gy1 = z1*bg11+z2*bg12;
+     gy2 = z2*bg21+z1*bg22;
+     ggy= y1*gy1 +  y2*gy2;
+
+     bbi =  x1*ffy+x2*ggy;
+   
+     *bb=bbi; 
+     
+}     
+//____________________________________________
+
+void AliMagFDM::ReadField()
+{
+  FILE *magfile;
+
+  Int_t ik, il, im;
+  Float_t zzp, rr,phii;
+  Float_t zz, yy, bx,by,bz,bb;
+
+  char *fname;
+  printf("Reading Magnetic Field %s from file %s\n",fName.Data(),fTitle.Data());
+  fname = gSystem->ExpandPathName(fTitle.Data());
+  magfile=fopen(fname,"r");
+  delete [] fname;
+
+  printf("Cartensian part\n");
+  if (magfile) {
+  
+//  Cartensian part 
+    fscanf(magfile,"%d %d %d ",&fdYl, &fdXl, &fdZl); 
+    
+    printf("fdYl %d, fdXl %d, fdZl %d\n",fdYl, fdXl, fdZl);     
+    
+    for (ik=0; ik<fdZl; ik++)
+    { 
+   
+      fscanf(magfile, " %e ", &zz);
+      fdZc[ik]=zz; 
+
+    } 
+   
+    for (ik=0; ik<fdYl; ik++)
+    {    
+       fscanf(magfile, " %e ", &yy); 
+       fdY[ik]=yy;
+    } 
+    for (ik=0; ik<81; ik++)
+    {    
+           printf("fdZc %e,fdY %e\n", fdZc[ik],fdY[ik]); 
+    }   
+             
+    fscanf(magfile," %e %e %e %e %e %e %e %e %e %e %e ", &fdYdel,&fdXdel,&fdZdel,&fdZmax,&fdZmin,&fdYmax,&fdYmin,&fdAx1,&fdCx1,&fdAx2,&fdCx2); 
+
+printf("fdYdel %e, fdXdel %e, fdZdel %e\n",fdYdel,fdXdel,fdZdel);
+printf("fdZmax %e, fdZmin %e, fdYmax %e,fdYmin %e\n",fdZmax,fdZmin,fdYmax,fdYmin);
+printf("fdAx1 %e, fdCx1 %e, fdAx2 %e, fdCx %e\n",fdAx1,fdCx1,fdAx2,fdCx2);
+
+    for (il=0; il<44; il++)  { 
+     for (im=0; im<81; im++)  {      
+      for (ik=0; ik<81; ik++)  {      
+      
+      fscanf(magfile, " %e ", &by); 
+      fdBcy[ik][im][il]=by;        
+      }
+     }
+    } 
+
+    for (il=0; il<44; il++)  { 
+     for (im=0; im<81; im++)  {      
+      for (ik=0; ik<81; ik++)  {      
+      
+      fscanf(magfile, " %e ", &bx); 
+      fdBcx[ik][im][il]=bx;        
+      }    
+     }     
+    }
+    
+   for (il=0; il<44; il++)  { 
+     for (im=0; im<81; im++)  {      
+      for (ik=0; ik<81; ik++)  {      
+      
+      fscanf(magfile, " %e ", &bz); 
+      fdBcz[ik][im][il]=bz;          
+      }              
+     }     
+    } 
+//----------------------   Polar part ---------------------------------
+
+    printf("Polar part\n");
+    fscanf(magfile,"%d %d %d ", &fdZpl, &fdRn, &fdPhin); 
+    printf("fdZpl %d, fdRn %d, fdPhin %d\n",fdZpl,fdRn,fdPhin);   
+
+    printf(" fdZp array\n"); 
+     
+    for (ik=0; ik<51; ik++) 
+    {    
+     fscanf(magfile, " %e ", &zzp);
+     fdZp[ik]=zzp; 
+     printf(" %e\n",fdZp[ik]);      
+    } 
+  
+    printf(" fdR array\n"); 
+         
+    for (ik=0; ik<10; ik++) 
+    {    
+     fscanf(magfile, " %e ", &rr); 
+     fdR[ik]=rr;
+     printf(" %e\n",fdR[ik]);
+    } 
+    
+//    printf("fdPhi array\n"); 
+     
+     for (il=0; il<33; il++)  
+     {
+       fscanf(magfile, " %e ", &phii); 
+       fdPhi[il]=phii; 
+//        printf(" %e\n",fdPhi[il]);          
+     }
+
+    fscanf(magfile," %e %e %e %e %e %e %e ",&fdZpdl,&fdPhid,&fdRdel,&fdZpmx,&fdZpmn,&fdRmax, &fdRmin); 
+
+printf("fdZpdl %e, fdPhid %e, fdRdel %e, fdZpmx %e, fdZpmn %e,fdRmax %e,fdRmin %e \n", fdZpdl,fdPhid, fdRdel,fdZpmx, fdZpmn,fdRmax, fdRmin);
+
+                      
+    for (il=0; il<33; il++)  { 
+     for (im=0; im<10; im++)  {      
+      for (ik=0; ik<51; ik++)  {
+      fscanf(magfile, " %e ", &by); 
+        fdBpy[ik][im][il]=by;        
+      }
+     }
+    } 
+    
+    for (il=0; il<33; il++)  { 
+     for (im=0; im<10; im++)  {      
+      for (ik=0; ik<51; ik++)  {
+      fscanf(magfile, " %e ", &bx); 
+        fdBpx[ik][im][il]=bx;                     
+      }    
+     }     
+    }      
+
+
+    for (il=0; il<33; il++)  { 
+     for (im=0; im<10; im++)  {      
+      for (ik=0; ik<51; ik++)  {
+      fscanf(magfile, " %e ", &bz); 
+        fdBpz[ik][im][il]=bz;                      
+      }              
+     }     
+    } 
+    
+    
+    for (il=0; il<32; il++) { 
+     for (im=0; im<2; im++)  {      
+      for (ik=0; ik<2; ik++)  {
+      fscanf(magfile, " %e ", &bb);    
+        fdB[ik][im][il]=bb;  
+      }              
+     } 
+    }
+//
+  } else { 
+    printf("File %s not found !\n",fTitle.Data());
+    exit(1);
+  }
+}
+//________________________________  
+
+
+  
+
+
+
 
index 7319a37..cb7416b 100644 (file)
@@ -8,7 +8,7 @@
 #include "TNamed.h"
 #include "TVector.h"
 
-enum Field_t {Undef=1, Const=1, ConMesh=2};
+enum Field_t {Undef=1, Const=1, ConMesh=2, DipoMap=3};
 
 class AliMagF : public TNamed {
 
@@ -89,5 +89,80 @@ public:
   
   ClassDef(AliMagFCM,1)  //Class for all Alice MagField with Constant Mesh
 };
+//************************************
+//
+class AliMagFDM : public AliMagF
+{
+//Alice Magnetic Field:Magnetic field map from IP to muon filter for Muon arm
+
+protected:
+
+//
+
+  Int_t      fdInd;   // Character number of validity Map region
+
+  Float_t fdZmin;  // Start of the cartesian  part  of MAP in z
+  Float_t fdZmax;  // End of Map in z   
+  Float_t fdYmax;  // Start of the cartesian  part  of MAP in y
+  Float_t fdYmin;  // End  of the cartesian  part  of MAP in y
+  Float_t fdZpmx;  // End of the polar  part  of MAP in z
+  Float_t fdZpmn;  // Start of the polar  part  of MAP in z
+  Float_t fdRmax;  // Maximal radius of the polar  part  of MAP 
+  Float_t fdRmin;  // Minimal radius of the polar  part  of MAP  
+              
+
+  Float_t    fdXdel;  //  step in x - cartesian  part  of MAP
+  Float_t    fdYdel;  //  step in y - cartesian  part  of MAP
+  Float_t    fdZdel;  //  step in z - cartesian  part  of MAP
+  
+  Float_t    fdRdel;  //  step in r - polar  part  of MAP
+  Float_t    fdPhid;  //  step in Phi - polar  part  of MAP
+  Float_t    fdZpdl;  //  step in z - polar  part  of MAP 
+  
+  Float_t    fdCx1, fdCx2;
+  Float_t    fdAx1, fdAx2; 
+   
+  Float_t fdZc[81];  // z coordinates in cartesian  part
+  Float_t fdY[81];   // y coordinates in cartesian  part 
+  Float_t fdBcx[81][81][44]; // Bx array for cartesian  part
+  Float_t fdBcy[81][81][44]; // By array for cartesian  part
+  Float_t fdBcz[81][81][44]; // Bz array for cartesian  part
+
+  Float_t  fdZp[51];  // z coordinates in polar  part
+  Float_t  fdR[10];   // r coordinates in polar  part  
+  Float_t  fdPhi[33]; // Phi coordinates in polar  part
+
+  Float_t  fdBpx[51][10][33]; // Bx array for polar  part
+  Float_t  fdBpy[51][10][33]; // By array for polar  part
+  Float_t  fdBpz[51][10][33]; // Bx array for polar  part 
+  Float_t  fdB[2][2][32]; 
+  
+  Int_t      fdXl;    // Number steps in x for cartesian  part
+  Int_t      fdYl;    // Number steps in y  for cartesian  par
+  Int_t      fdZl;    // Number steps in z  for cartesian  part
+    
+  Int_t      fdRn;    // Number steps in r for polar  part
+  Int_t      fdPhin;  // Number steps in Phi for polar  part
+  Int_t      fdZpl;   // Number steps in z for polar  part 
+  
+  Float_t  rrtes;
+
+public:
+  AliMagFDM(){}
+  AliMagFDM(const char *name, const char *title, const Int_t integ, const Int_t
+  map, const Float_t factor, const Float_t fmax);
+  virtual ~AliMagFDM(){} 
+  virtual void Field(Float_t *x, Float_t *b);
+  virtual void ReadField(); 
+  
+
+  void FZ(Double_t *u, Float_t *Ar, Float_t *du, Int_t *ki, Int_t *kf, Double_t *a1, Double_t *a2 , Int_t *nu);
+  void FRfuncBi(Int_t *kai, Double_t *za1, Double_t *za2, Double_t *al1, Double_t *al2, Double_t *al3, Int_t *ka, Int_t *ma,Double_t  *ba);
+  void FGfuncBi(Double_t *z1, Double_t *z2, Double_t *y1, Double_t *y2, Double_t *x1, Double_t *x2, Int_t *kvr, Int_t *k, Int_t *l, Int_t *m, Double_t *bb); 
+//_________________________________________
+
+  ClassDef(AliMagFDM,1) //Class Magnetic field map from IP till muon filter
+};
+
 
 #endif