[u/mrichter/AliRoot.git] / STEER / AliMagFCM.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/*
$Log$
Revision 1.9  2001/09/04 15:05:13  hristov
Pointer fB is initialised to 0 in the default constructor

Revision 1.8  2001/05/28 14:10:35  morsch
SetSolenoidField method to set the L3 field strength. 2 kG is default.

Revision 1.7  2001/05/16 14:57:22  alibrary
New files for folders and Stack

Revision 1.6  2000/12/18 10:44:01  morsch
Possibility to set field map by passing pointer to objet of type AliMagF via
SetField().
Example:
gAlice->SetField(new AliMagFCM("Map2", "$(ALICE_ROOT)/data/field01.dat",2,1.,10.));

Revision 1.5  2000/12/01 11:20:27  alibrary
Corrector dipole removed from ZDC

Revision 1.4  2000/11/30 07:12:49  alibrary
Introducing new Rndm and QA classes

Revision 1.3  2000/11/10 18:09:55  fca
New field map for the ZDC

Revision 1.2  2000/07/12 08:56:25  fca
Coding convention correction and warning removal

Revision 1.1  2000/07/11 18:24:59  fca
Coding convention corrections + few minor bug fixes

*/
#include "TVector.h"

#include "AliMagFCM.h"
#include "TSystem.h"

ClassImp(AliMagFCM)

//_______________________________________________________________________
AliMagFCM::AliMagFCM():
  fXbeg(0),
  fYbeg(0),
  fZbeg(0),
  fXdel(0),
  fYdel(0),
  fZdel(0),
  fSolenoid(0),
  fXdeli(0),
  fYdeli(0),
  fZdeli(0),
  fXn(0),
  fYn(0),
  fZn(0),
  fB(0)
{
  //
  // Standard constructor
  //
  fType = kConMesh;
  fMap  = 2;
  SetSolenoidField();
}

//_______________________________________________________________________
AliMagFCM::AliMagFCM(const char *name, const char *title, const Int_t integ, 
                     const Float_t factor, const Float_t fmax):
  AliMagF(name,title,integ,factor,fmax),
  fXbeg(0),
  fYbeg(0),
  fZbeg(0),
  fXdel(0),
  fYdel(0),
  fZdel(0),
  fSolenoid(0),
  fXdeli(0),
  fYdeli(0),
  fZdeli(0),
  fXn(0),
  fYn(0),
  fZn(0),
  fB(0)
{
  //
  // Standard constructor
  //
  fType = kConMesh;
  fMap  = 2;
  SetSolenoidField();

  if(fDebug>-1) Info("ctor",
     "%s: Constant Mesh Field %s created: map= %d, factor= %f, file= %s\n",
	 ClassName(),fName.Data(), fMap, factor,fTitle.Data());
}

//_______________________________________________________________________
AliMagFCM::AliMagFCM(const AliMagFCM &magf):
  AliMagF(magf),
  fXbeg(0),
  fYbeg(0),
  fZbeg(0),
  fXdel(0),
  fYdel(0),
  fZdel(0),
  fSolenoid(0),
  fXdeli(0),
  fYdeli(0),
  fZdeli(0),
  fXn(0),
  fYn(0),
  fZn(0),
  fB(0)
{
  //
  // Copy constructor
  //
  magf.Copy(*this);
}

//_______________________________________________________________________
void AliMagFCM::Field(Float_t *x, Float_t *b)
{
  //
  // Method to calculate the magnetic field
  //
  Double_t ratx, raty, ratz, hix, hiy, hiz, ratx1, raty1, ratz1, 
    bhyhz, bhylz, blyhz, blylz, bhz, blz, xl[3];
  const Double_t kone=1;
  Int_t ix, iy, iz;
  
  // --- find the position in the grid ---
  
  b[0]=b[1]=b[2]=0;
  if(-700<x[2] && x[2]<fZbeg && x[0]*x[0]+(x[1]+30)*(x[1]+30) < 560*560) {
    b[2]= fSolenoid;
  } else  {
    Bool_t infield=(fZbeg<=x[2] && x[2]<fZbeg+fZdel*(fZn-1)
		    &&  ( fXbeg <= TMath::Abs(x[0]) && TMath::Abs(x[0]) < fXbeg+fXdel*(fXn-1) )
		    &&  ( fYbeg <= TMath::Abs(x[1]) && TMath::Abs(x[1]) < fYbeg+fYdel*(fYn-1) ));
    if(infield) {
      xl[0]=TMath::Abs(x[0])-fXbeg;
      xl[1]=TMath::Abs(x[1])-fYbeg;
      xl[2]=x[2]-fZbeg;
      
      // --- start with x
      
      hix=xl[0]*fXdeli;
      ratx=hix-int(hix);
      ix=int(hix);
      
      hiy=xl[1]*fYdeli;
      raty=hiy-int(hiy);
      iy=int(hiy);
      
      hiz=xl[2]*fZdeli;
      ratz=hiz-int(hiz);
      iz=int(hiz);
      
      if(fMap==2) {
	// ... simple interpolation
	ratx1=kone-ratx;
	raty1=kone-raty;
	ratz1=kone-ratz;
	bhyhz = Bx(ix  ,iy+1,iz+1)*ratx1+Bx(ix+1,iy+1,iz+1)*ratx;
	bhylz = Bx(ix  ,iy+1,iz  )*ratx1+Bx(ix+1,iy+1,iz  )*ratx;
	blyhz = Bx(ix  ,iy  ,iz+1)*ratx1+Bx(ix+1,iy  ,iz+1)*ratx;
	blylz = Bx(ix  ,iy  ,iz  )*ratx1+Bx(ix+1,iy  ,iz  )*ratx;
	bhz   = blyhz             *raty1+bhyhz             *raty;
	blz   = blylz             *raty1+bhylz             *raty;
	b[0]  = blz               *ratz1+bhz               *ratz;
	//
	bhyhz = By(ix  ,iy+1,iz+1)*ratx1+By(ix+1,iy+1,iz+1)*ratx;
	bhylz = By(ix  ,iy+1,iz  )*ratx1+By(ix+1,iy+1,iz  )*ratx;
	blyhz = By(ix  ,iy  ,iz+1)*ratx1+By(ix+1,iy  ,iz+1)*ratx;
	blylz = By(ix  ,iy  ,iz  )*ratx1+By(ix+1,iy  ,iz  )*ratx;
	bhz   = blyhz             *raty1+bhyhz             *raty;
	blz   = blylz             *raty1+bhylz             *raty;
	b[1]  = blz               *ratz1+bhz               *ratz;
	//
	bhyhz = Bz(ix  ,iy+1,iz+1)*ratx1+Bz(ix+1,iy+1,iz+1)*ratx;
	bhylz = Bz(ix  ,iy+1,iz  )*ratx1+Bz(ix+1,iy+1,iz  )*ratx;
	blyhz = Bz(ix  ,iy  ,iz+1)*ratx1+Bz(ix+1,iy  ,iz+1)*ratx;
	blylz = Bz(ix  ,iy  ,iz  )*ratx1+Bz(ix+1,iy  ,iz  )*ratx;
	bhz   = blyhz             *raty1+bhyhz             *raty;
	blz   = blylz             *raty1+bhylz             *raty;
	b[2]  = blz               *ratz1+bhz               *ratz;
	//printf("ratx,raty,ratz,b[0],b[1],b[2] %f %f %f %f %f %f\n",
	//ratx,raty,ratz,b[0],b[1],b[2]);
	//
	// ... use the dipole symmetry
	if (x[0]*x[1] < 0) b[1]=-b[1];
	if (x[0]<0) b[2]=-b[2];
      } else {
	printf("Invalid field map for constant mesh %d\n",fMap);
      }
    } else {
//This is the ZDC part
    Float_t rad2=x[0]*x[0]+x[1]*x[1];
    if(x[2]>kCORBEG2 && x[2]<kCOREND2){
      if(rad2<kCOR2RA2){
        b[0] = kFCORN2;
      }
    }
    else if(x[2]>kZ1BEG && x[2]<kZ1END){  
      if(rad2<kZ1RA2){
        b[0] = -kG1*x[1];
        b[1] = -kG1*x[0];
      }
    }
    else if(x[2]>kZ2BEG && x[2]<kZ2END){  
      if(rad2<kZ2RA2){
        b[0] = kG1*x[1];
        b[1] = kG1*x[0];
      }
    }
    else if(x[2]>kZ3BEG && x[2]<kZ3END){  
      if(rad2<kZ3RA2){
        b[0] = kG1*x[1];
        b[1] = kG1*x[0];
      }
    }
    else if(x[2]>kZ4BEG && x[2]<kZ4END){  
      if(rad2<kZ4RA2){
        b[0] = -kG1*x[1];
        b[1] = -kG1*x[0];
      }
    }
    else if(x[2]>kD1BEG && x[2]<kD1END){ 
      if(rad2<kD1RA2){
        b[1] = -kFDIP;
      }
    }
    else if(x[2]>kD2BEG && x[2]<kD2END){
      if(((x[0]-kXCEN1D2)*(x[0]-kXCEN1D2)+(x[1]-kYCEN1D2)*(x[1]-kYCEN1D2))<kD2RA2
        || ((x[0]-kXCEN2D2)*(x[0]-kXCEN2D2)+(x[1]-kYCEN2D2)*(x[1]-kYCEN2D2))<kD2RA2){
	b[1] = kFDIP;
      }
    }
    
    }
  }
  if(fFactor!=1) {
    b[0]*=fFactor;
    b[1]*=fFactor;
    b[2]*=fFactor;
  }
}

//_______________________________________________________________________
void AliMagFCM::ReadField()
{
  // 
  // Method to read the magnetic field map from file
  //
  FILE *magfile;
  Int_t ix, iy, iz, ipx, ipy, ipz;
  Float_t bx, by, bz;
  char *fname;
  if(fDebug) printf("%s: Reading Magnetic Field %s from file %s\n",ClassName(),fName.Data(),fTitle.Data());
  fname = gSystem->ExpandPathName(fTitle.Data());
  magfile=fopen(fname,"r");
  delete [] fname;
  if (magfile) {
    fscanf(magfile,"%d %d %d %f %f %f %f %f %f",
    	   &fXn, &fYn, &fZn, &fXdel, &fYdel, &fZdel, &fXbeg, &fYbeg, &fZbeg);
    if(fDebug>1) printf("%s: fXn %d, fYn %d, fZn %d, fXdel %f, fYdel %f, fZdel %f, fXbeg %f, fYbeg %f, fZbeg %f\n",
			ClassName(),fXn, fYn, fZn, fXdel, fYdel, fZdel, fXbeg, fYbeg, fZbeg);
    fXdeli=1./fXdel;
    fYdeli=1./fYdel;
    fZdeli=1./fZdel;
    fB = new TVector(3*fXn*fYn*fZn);
    for (iz=0; iz<fZn; iz++) {
      ipz=iz*3*(fXn*fYn);
      for (iy=0; iy<fYn; iy++) {
	ipy=ipz+iy*3*fXn;
	for (ix=0; ix<fXn; ix++) {
	  ipx=ipy+ix*3;
	  fscanf(magfile,"%f %f %f",&bz,&by,&bx);
	  (*fB)(ipx+2)=bz;
	  (*fB)(ipx+1)=by;
	  (*fB)(ipx  )=bx;
	}
      }
    }
  } else { 
    printf("%s: File %s not found !\n",ClassName(),fTitle.Data());
    exit(1);
  }
}

//_______________________________________________________________________
void AliMagFCM::Copy(AliMagFCM & /* magf */) const
{
  //
  // Copy *this onto magf -- Not implemented
  //
  Fatal("Copy","Not implemented!\n");
}
Commit	Line	Data
aee8290b	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	/*
	17	$Log$
e2afb3b6	18	Revision 1.9 2001/09/04 15:05:13 hristov
	19	Pointer fB is initialised to 0 in the default constructor
	20
cf6abd21	21	Revision 1.8 2001/05/28 14:10:35 morsch
	22	SetSolenoidField method to set the L3 field strength. 2 kG is default.
	23
4cc8933f	24	Revision 1.7 2001/05/16 14:57:22 alibrary
	25	New files for folders and Stack
	26
9e1a0ddb	27	Revision 1.6 2000/12/18 10:44:01 morsch
	28	Possibility to set field map by passing pointer to objet of type AliMagF via
	29	SetField().
	30	Example:
	31	gAlice->SetField(new AliMagFCM("Map2", "$(ALICE_ROOT)/data/field01.dat",2,1.,10.));
	32
d8408e76	33	Revision 1.5 2000/12/01 11:20:27 alibrary
	34	Corrector dipole removed from ZDC
	35
006cb30c	36	Revision 1.4 2000/11/30 07:12:49 alibrary
	37	Introducing new Rndm and QA classes
	38
65fb704d	39	Revision 1.3 2000/11/10 18:09:55 fca
	40	New field map for the ZDC
	41
d95ea23f	42	Revision 1.2 2000/07/12 08:56:25 fca
	43	Coding convention correction and warning removal
	44
8918e700	45	Revision 1.1 2000/07/11 18:24:59 fca
	46	Coding convention corrections + few minor bug fixes
	47
aee8290b	48	*/
65fb704d	49	#include "TVector.h"
aee8290b	50
	51	#include "AliMagFCM.h"
	52	#include "TSystem.h"
	53
	54	ClassImp(AliMagFCM)
	55
e2afb3b6	56	//_______________________________________________________________________
	57	AliMagFCM::AliMagFCM():
	58	fXbeg(0),
	59	fYbeg(0),
	60	fZbeg(0),
	61	fXdel(0),
	62	fYdel(0),
	63	fZdel(0),
	64	fSolenoid(0),
	65	fXdeli(0),
	66	fYdeli(0),
	67	fZdeli(0),
	68	fXn(0),
	69	fYn(0),
	70	fZn(0),
	71	fB(0)
	72	{
	73	//
	74	// Standard constructor
	75	//
	76	fType = kConMesh;
	77	fMap = 2;
	78	SetSolenoidField();
	79	}
	80
	81	//_______________________________________________________________________
aee8290b	82	AliMagFCM::AliMagFCM(const char name, const char title, const Int_t integ,
e2afb3b6	83	const Float_t factor, const Float_t fmax):
	84	AliMagF(name,title,integ,factor,fmax),
	85	fXbeg(0),
	86	fYbeg(0),
	87	fZbeg(0),
	88	fXdel(0),
	89	fYdel(0),
	90	fZdel(0),
	91	fSolenoid(0),
	92	fXdeli(0),
	93	fYdeli(0),
	94	fZdeli(0),
	95	fXn(0),
	96	fYn(0),
	97	fZn(0),
	98	fB(0)
aee8290b	99	{
	100	//
	101	// Standard constructor
	102	//
	103	fType = kConMesh;
d8408e76	104	fMap = 2;
4cc8933f	105	SetSolenoidField();
4cc8933f	106
e2afb3b6	107	if(fDebug>-1) Info("ctor",
e2afb3b6	108	"%s: Constant Mesh Field %s created: map= %d, factor= %f, file= %s\n",
9e1a0ddb	109	ClassName(),fName.Data(), fMap, factor,fTitle.Data());
aee8290b	110	}
aee8290b	111
e2afb3b6	112	//_______________________________________________________________________
	113	AliMagFCM::AliMagFCM(const AliMagFCM &magf):
	114	AliMagF(magf),
	115	fXbeg(0),
	116	fYbeg(0),
	117	fZbeg(0),
	118	fXdel(0),
	119	fYdel(0),
	120	fZdel(0),
	121	fSolenoid(0),
	122	fXdeli(0),
	123	fYdeli(0),
	124	fZdeli(0),
	125	fXn(0),
	126	fYn(0),
	127	fZn(0),
	128	fB(0)
aee8290b	129	{
	130	//
	131	// Copy constructor
	132	//
	133	magf.Copy(*this);
	134	}
	135
e2afb3b6	136	//_______________________________________________________________________
aee8290b	137	void AliMagFCM::Field(Float_t x, Float_t b)
	138	{
	139	//
	140	// Method to calculate the magnetic field
	141	//
	142	Double_t ratx, raty, ratz, hix, hiy, hiz, ratx1, raty1, ratz1,
	143	bhyhz, bhylz, blyhz, blylz, bhz, blz, xl[3];
	144	const Double_t kone=1;
	145	Int_t ix, iy, iz;
	146
	147	// --- find the position in the grid ---
	148
	149	b[0]=b[1]=b[2]=0;
	150	if(-700<x[2] && x[2]<fZbeg && x[0]x[0]+(x[1]+30)(x[1]+30) < 560*560) {
4cc8933f	151	b[2]= fSolenoid;
aee8290b	152	} else {
	153	Bool_t infield=(fZbeg<=x[2] && x[2]<fZbeg+fZdel*(fZn-1)
	154	&& ( fXbeg <= TMath::Abs(x[0]) && TMath::Abs(x[0]) < fXbeg+fXdel*(fXn-1) )
	155	&& ( fYbeg <= TMath::Abs(x[1]) && TMath::Abs(x[1]) < fYbeg+fYdel*(fYn-1) ));
	156	if(infield) {
	157	xl[0]=TMath::Abs(x[0])-fXbeg;
	158	xl[1]=TMath::Abs(x[1])-fYbeg;
	159	xl[2]=x[2]-fZbeg;
	160
	161	// --- start with x
	162
	163	hix=xl[0]*fXdeli;
	164	ratx=hix-int(hix);
	165	ix=int(hix);
	166
	167	hiy=xl[1]*fYdeli;
	168	raty=hiy-int(hiy);
	169	iy=int(hiy);
	170
	171	hiz=xl[2]*fZdeli;
	172	ratz=hiz-int(hiz);
	173	iz=int(hiz);
	174
	175	if(fMap==2) {
	176	// ... simple interpolation
	177	ratx1=kone-ratx;
	178	raty1=kone-raty;
	179	ratz1=kone-ratz;
	180	bhyhz = Bx(ix ,iy+1,iz+1)ratx1+Bx(ix+1,iy+1,iz+1)ratx;
	181	bhylz = Bx(ix ,iy+1,iz )ratx1+Bx(ix+1,iy+1,iz )ratx;
	182	blyhz = Bx(ix ,iy ,iz+1)ratx1+Bx(ix+1,iy ,iz+1)ratx;
	183	blylz = Bx(ix ,iy ,iz )ratx1+Bx(ix+1,iy ,iz )ratx;
	184	bhz = blyhz raty1+bhyhz raty;
	185	blz = blylz raty1+bhylz raty;
	186	b[0] = blz ratz1+bhz ratz;
	187	//
	188	bhyhz = By(ix ,iy+1,iz+1)ratx1+By(ix+1,iy+1,iz+1)ratx;
	189	bhylz = By(ix ,iy+1,iz )ratx1+By(ix+1,iy+1,iz )ratx;
	190	blyhz = By(ix ,iy ,iz+1)ratx1+By(ix+1,iy ,iz+1)ratx;
	191	blylz = By(ix ,iy ,iz )ratx1+By(ix+1,iy ,iz )ratx;
	192	bhz = blyhz raty1+bhyhz raty;
	193	blz = blylz raty1+bhylz raty;
	194	b[1] = blz ratz1+bhz ratz;
	195	//
	196	bhyhz = Bz(ix ,iy+1,iz+1)ratx1+Bz(ix+1,iy+1,iz+1)ratx;
	197	bhylz = Bz(ix ,iy+1,iz )ratx1+Bz(ix+1,iy+1,iz )ratx;
	198	blyhz = Bz(ix ,iy ,iz+1)ratx1+Bz(ix+1,iy ,iz+1)ratx;
	199	blylz = Bz(ix ,iy ,iz )ratx1+Bz(ix+1,iy ,iz )ratx;
	200	bhz = blyhz raty1+bhyhz raty;
	201	blz = blylz raty1+bhylz raty;
	202	b[2] = blz ratz1+bhz ratz;
	203	//printf("ratx,raty,ratz,b[0],b[1],b[2] %f %f %f %f %f %f\n",
	204	//ratx,raty,ratz,b[0],b[1],b[2]);
	205	//
	206	// ... use the dipole symmetry
	207	if (x[0]*x[1] < 0) b[1]=-b[1];
	208	if (x[0]<0) b[2]=-b[2];
	209	} else {
	210	printf("Invalid field map for constant mesh %d\n",fMap);
	211	}
	212	} else {
d95ea23f	213	//This is the ZDC part
d95ea23f	214	Float_t rad2=x[0]x[0]+x[1]x[1];
006cb30c	215	if(x[2]>kCORBEG2 && x[2]<kCOREND2){
d95ea23f	216	if(rad2<kCOR2RA2){
	217	b[0] = kFCORN2;
	218	}
	219	}
	220	else if(x[2]>kZ1BEG && x[2]<kZ1END){
	221	if(rad2<kZ1RA2){
	222	b[0] = -kG1*x[1];
	223	b[1] = -kG1*x[0];
	224	}
	225	}
	226	else if(x[2]>kZ2BEG && x[2]<kZ2END){
	227	if(rad2<kZ2RA2){
	228	b[0] = kG1*x[1];
	229	b[1] = kG1*x[0];
	230	}
	231	}
	232	else if(x[2]>kZ3BEG && x[2]<kZ3END){
	233	if(rad2<kZ3RA2){
	234	b[0] = kG1*x[1];
	235	b[1] = kG1*x[0];
	236	}
	237	}
	238	else if(x[2]>kZ4BEG && x[2]<kZ4END){
	239	if(rad2<kZ4RA2){
	240	b[0] = -kG1*x[1];
	241	b[1] = -kG1*x[0];
	242	}
	243	}
	244	else if(x[2]>kD1BEG && x[2]<kD1END){
	245	if(rad2<kD1RA2){
	246	b[1] = -kFDIP;
	247	}
	248	}
	249	else if(x[2]>kD2BEG && x[2]<kD2END){
	250	if(((x[0]-kXCEN1D2)(x[0]-kXCEN1D2)+(x[1]-kYCEN1D2)(x[1]-kYCEN1D2))<kD2RA2
	251	\|\| ((x[0]-kXCEN2D2)(x[0]-kXCEN2D2)+(x[1]-kYCEN2D2)(x[1]-kYCEN2D2))<kD2RA2){
	252	b[1] = kFDIP;
aee8290b	253	}
aee8290b	254	}
d95ea23f	255
d95ea23f	256	}
aee8290b	257	}
	258	if(fFactor!=1) {
	259	b[0]*=fFactor;
	260	b[1]*=fFactor;
	261	b[2]*=fFactor;
	262	}
	263	}
	264
e2afb3b6	265	//_______________________________________________________________________
aee8290b	266	void AliMagFCM::ReadField()
	267	{
	268	//
	269	// Method to read the magnetic field map from file
	270	//
	271	FILE *magfile;
	272	Int_t ix, iy, iz, ipx, ipy, ipz;
	273	Float_t bx, by, bz;
	274	char *fname;
9e1a0ddb	275	if(fDebug) printf("%s: Reading Magnetic Field %s from file %s\n",ClassName(),fName.Data(),fTitle.Data());
aee8290b	276	fname = gSystem->ExpandPathName(fTitle.Data());
	277	magfile=fopen(fname,"r");
	278	delete [] fname;
	279	if (magfile) {
	280	fscanf(magfile,"%d %d %d %f %f %f %f %f %f",
	281	&fXn, &fYn, &fZn, &fXdel, &fYdel, &fZdel, &fXbeg, &fYbeg, &fZbeg);
9e1a0ddb	282	if(fDebug>1) printf("%s: fXn %d, fYn %d, fZn %d, fXdel %f, fYdel %f, fZdel %f, fXbeg %f, fYbeg %f, fZbeg %f\n",
9e1a0ddb	283	ClassName(),fXn, fYn, fZn, fXdel, fYdel, fZdel, fXbeg, fYbeg, fZbeg);
aee8290b	284	fXdeli=1./fXdel;
	285	fYdeli=1./fYdel;
	286	fZdeli=1./fZdel;
	287	fB = new TVector(3fXnfYn*fZn);
	288	for (iz=0; iz<fZn; iz++) {
	289	ipz=iz3(fXn*fYn);
	290	for (iy=0; iy<fYn; iy++) {
	291	ipy=ipz+iy3fXn;
	292	for (ix=0; ix<fXn; ix++) {
	293	ipx=ipy+ix*3;
	294	fscanf(magfile,"%f %f %f",&bz,&by,&bx);
	295	(*fB)(ipx+2)=bz;
	296	(*fB)(ipx+1)=by;
	297	(*fB)(ipx )=bx;
	298	}
	299	}
	300	}
	301	} else {
9e1a0ddb	302	printf("%s: File %s not found !\n",ClassName(),fTitle.Data());
aee8290b	303	exit(1);
	304	}
	305	}
	306
e2afb3b6	307	//_______________________________________________________________________
8918e700	308	void AliMagFCM::Copy(AliMagFCM & /* magf */) const
aee8290b	309	{
aee8290b	310	//
8918e700	311	// Copy *this onto magf -- Not implemented
aee8290b	312	//
	313	Fatal("Copy","Not implemented!\n");
	314	}
	315