BLCoil Class Reference

#include <BLCoil.hh>

Inheritance diagram for BLCoil:

List of all members.

---

Detailed Description

BLCoil creates and implements a coil (part of a solenoid).

A BLCoil consists only of the parameters describing the coil geometry and a field map for unit current density. It is not a BLElement, and cannot be placed geometrically -- see BLSolenoid for that.

Cylindrical symmetry around z is assumed. The field is approximated by computing the field from nSheets infinitesimally-thin current sheets interpolating from innerRadius to OuterRadius, each length long. The solution to Maxwell's Equations for each sheet is used.

The field has been verified to be correct within 0.2% for both a long solenoid and for a pair of Helmholtz coils.

Effect of nSheets on accuracy: consider the coil innerRadius=330.0*mm, outerRadius=505.0*mm, length=167.0*mm. Compute the maximum error for 1000 random points, excluding the region within 2 cm of the coils; use 99 sheets as the "correct" value. In the region 0<=r<2*outerRadius, 0<z<10*outerRadius, for 0.1% accuracy one needs 11 sheets, and for 1% one needs 4 sheets. In the region 0<=r<innerRadius/2, same z, for 0.1% accuracy one needs 5 sheets, and for 1% one needs 2 sheets. Note that inside the coils this approximation of using thin sheets is not very good; but interpolating on a grid and coordinating sheet positions with the grid is probably about as good as one can do -- at least the values will be smooth (which is not true for the bare computation -- there's a singularity at every sheet, and Bz jumps from +infinity to -infinity across the sheet).

Note that Bz does not decrease to 0.1% of its central value until z>10*(innerRadius+outerRadius)/2; it decreases to 1% at ~5 times that average radius.

BLCoil can also read a mapFile defining the field (rather than doing the above computation). For instance, it could be from opera-2d. The mapFile gives tables of Bz and Br on a grid in the z-r plane. mapFile format: lines beginning with # are comments, and are ignored. The first line contains the parameters in name=value form: z0 initial value of z (mm) dz grid interval along z (mm) nz number of grid points along z dr grid interval along r (mm) nr number of grid points along r reflectZ set nonzero to reflect in the z=0 plane (inverting Br) current the current for this field (A/mm^2) All parameters are required. If reflectZ is nonzero then z0 must be 0.0 (only z>=0 is contained in the file). The point with local coordinates (z=0,r=0) is what gets placed.

Then follow the two maps in any order. Each map begins with a line giving its name (Bz or Br) in column 1, followed by nz lines each containing nr floats (Tesla). The first value in each line is for r=0. Values are separated by one or more spaces (the first value on each line may but need not be preceeded by spaces). The main reason to use a mapFile is to accurately include the effects of iron. That implies that the map may not be accurate for values of current other than that for which the map was generated.

See BLCMDfieldmap for a more general EM field read from a map-file.

BLCoil was separated from BLSolenoid so multiple solenoids with the same geometry (coil) could share a single (large) field map for the coil -- the B field is scaled by current/currentOfMap, where currentOfMap is 1.0 for the computed field, and is the current parameter from a mapFile.

This class does not use BLFieldMap becuase it predates it, and because the map must include the parameters so construct() will know whether or not the map corresponds to the current values. You can, of course, build a solenoid out of a BLTubs and a BLFieldMap.

Public Member Functions
	BLCoil ()
	Default constructor.
	BLCoil (G4String _name, G4double _innerRadius, G4double _outerRadius, G4double _length, G4int _nSheets=0, G4double _tolerance=0.0, G4double _maxR=0.0, G4double _maxZ=0.0, G4double _dR=0.0, G4double _dZ=0.0, G4int _nR=0, G4int _nZ=0, G4String _filename="")
	Complex Constructor. All arguments that default to 0 are related to generating the field map; those that are 0 will be determined by tolerance. To construct the map the minimum info is tolerance and maxR; if either of them is 0, no map will be generated or used. NOTE: without a map, field values inside the coils will fluctuate wildly, because points on the sheets are singular; map construction is designed to minimize this. Without a map, nSheets must be given. tolerance is a fraction of the best value at r=0,z=0; values smaller than about 0.001 are unrealistic (and expensive!).
virtual	~BLCoil ()
	Destructor.
	BLCoil (const BLCoil &r)
	Copy constructor.
void	printCoil ()
	printCoil() will print a description
void	addField (const G4double point[4], G4double field[6], G4double currentAmpPerMm2) const
	addField() adds the field value for the given point[] into field[]. Note that point[] is relative to the center of the coil. Units for current are Amp/mm^2.
void	generateFieldMap ()
	generateFieldMap() will generate the field map (for execution speedup). If just maxR and tolerance were given, all other map parameters will be automatically determined so that the estimated error is less than the specified tolerance. The field map is cached in a disk file which is automatically recreated if anything changes (may take several minutes).
void	readMapFile ()
	readMapFile() will read the mapFile.
void	displayMapValues (G4double r, G4double z)
	displayMapValues() will display the 4 map values around a point.
Static Public Member Functions
static BLCoil *	find (G4String name)
	find() returns a pointer to the named BLCoil.
Private Member Functions
void	getUnitField (G4double r, G4double z, G4double &Br, G4double &Bz)
	getUnitField() will return Br and Bz for unit current.
void	determineMaxR ()
	determineMaxR() will determine maxR based on tolerance. Uses nSheets=99 to determine center field, and walks out far enough so (Bz/Bz0)<0.5*tolerance.
void	determineMaxZ ()
	determineMaxZ() will determine maxZ based on tolerance. Uses nSheets=99 to determine on-axis field, and walks out far enough so (Bz/Bz0)<0.5*tolerance.
void	determineNsheets ()
	determineNsheets() will determine nSheets, given maxZ and tolerance. Increases nSheets until maxError < tolerance/4 (the other 3/4 of tolerance is for mapping errors). Checks just a handful of points selected to be representative.
G4double	estimateMapError ()
	estimateMapError() will estimate the maximum error in mapping, given maxZ, nSheets, dR, dZ, nR, nZ, and an allocated but uninitialized fieldMap. It generates 1000 random points and returns the maximum error; quits early if tolerance is exceeded. Error is (currentMap - best)/best(r=0,z=0), where best is computed with no map and nSheets=99. For each point it generates the 4 surrounding values of fieldMap (this is faster than generating the entire map first). Returns the maximum error of either Bz or Br, normalized to Bz(r=0,z=0,nSheets=99).
G4double	computeError (G4double r, G4double z, BLCoil &best, G4bool makeMap)
	computeError() computes the error for a single point. Error is (currentMap - best)/best(r=0,z=0), where best should be an identical BLCoil with no map and nSheets=99. If makeMap is true, it generates the 4 surrounding values of the fieldMap.
void	getSheetField (G4double r, G4double z, G4double &Br, G4double &Bz, G4double sheetR, G4double sheetLen, G4double currentAmpPerMm) const
	getSheetField() returns the B field from an infinitesimally-thin sheet of current. Arguments: r and z are the cylindrical coordinates of the point in question relative to center of the coil (axis along z), mm. Br and Bz return the computed B field at that point (geant4 units) sheetR is the radius of the current sheet (mm) sheetLen is the length of the current sheet (mm) currentAmpPerMm is the current of the sheet (Amp per linear mm)
Private Attributes
G4String	name
G4double	innerRadius
G4double	outerRadius
G4double	length
G4int	nSheets
G4String	material
G4double	tolerance
G4double	maxR
G4double	minZ
G4double	maxZ
G4double	dR
G4double	dZ
G4int	nR
G4int	nZ
G4String	filename
G4String	mapFile
G4int	exactComputation
float *	mapBr
float *	mapBz
G4double	sheetR0
G4double	sheetDR
G4double	norm
G4bool	goodMap
G4bool	reflectZ
G4double	currentOfMap
Static Private Attributes
static std::map< G4String, BLCoil * >	mapCoil
Friends
class	BLCMDcoil
class	BLCMDsolenoid
class	SolenoidField

---

Constructor & Destructor Documentation

BLCoil::BLCoil

(

)

Default constructor.

References currentOfMap, dR, dZ, exactComputation, filename, goodMap, innerRadius, length, mapBr, mapBz, mapFile, material, maxR, maxZ, minZ, name, norm, nR, nSheets, nZ, outerRadius, reflectZ, sheetDR, sheetR0, and tolerance.

{
        // provide initial values for fields
        name = "";
        innerRadius = 0.0;
        outerRadius = 0.0;
        length = 0.0;
        nSheets = 0;
        material = "Cu";
        tolerance = 0.002;
        maxR = 0.0;
        minZ = 0.0;
        maxZ = 0.0;
        dR = 0.0;
        dZ = 0.0;
        nR = 0;
        nZ = 0;
        filename = "";
        exactComputation = 0;
        mapFile = "";
        mapBr = 0;
        mapBz = 0;
        sheetR0 = 0.0;
        sheetDR = 0.0;
        norm = 0.0;
        goodMap = false;
        reflectZ = true;
        currentOfMap = 1.0;
}

BLCoil::BLCoil	(	G4String	_name,
		G4double	_innerRadius,
		G4double	_outerRadius,
		G4double	_length,
		G4int	_nSheets = 0,
		G4double	_tolerance = 0.0,
		G4double	_maxR = 0.0,
		G4double	_maxZ = 0.0,
		G4double	_dR = 0.0,
		G4double	_dZ = 0.0,
		G4int	_nR = 0,
		G4int	_nZ = 0,
		G4String	_filename = ""
	)			[inline]

Complex Constructor. All arguments that default to 0 are related to generating the field map; those that are 0 will be determined by tolerance. To construct the map the minimum info is tolerance and maxR; if either of them is 0, no map will be generated or used. NOTE: without a map, field values inside the coils will fluctuate wildly, because points on the sheets are singular; map construction is designed to minimize this. Without a map, nSheets must be given. tolerance is a fraction of the best value at r=0,z=0; values smaller than about 0.001 are unrealistic (and expensive!).

References dR, dZ, exactComputation, filename, goodMap, innerRadius, length, mapBr, mapBz, maxR, maxZ, name, norm, nR, nSheets, nZ, outerRadius, sheetDR, sheetR0, and tolerance.

                                       {
                        name=_name; innerRadius=_innerRadius;
                        outerRadius=_outerRadius; length=_length;
                        nSheets=_nSheets; tolerance=_tolerance; maxR=_maxR;
                        maxZ=_maxZ; dR=_dR; dZ=_dZ; nR=_nR; nZ=_nZ; 
                        filename = _filename;
                        exactComputation = 0;
                        mapBr=0; mapBz=0; sheetR0=0.0; sheetDR=0.0; norm=0.0; 
                        goodMap=false; 
                        if(nSheets > 0) { 
                                sheetDR=(outerRadius-innerRadius)/nSheets;
                                sheetR0=innerRadius + sheetDR/2.0;
                        }
                        if(filename == "") filename = name + ".dat";
                }

BLCoil::~BLCoil

(

)

[virtual]

Destructor.

References mapBr, and mapBz.

{
        if(mapBr) delete[] mapBr;
        mapBr = 0;
        if(mapBz) delete[] mapBz;
        mapBz = 0;
}

BLCoil::BLCoil

(

const BLCoil &

r

)

Copy constructor.

References currentOfMap, dR, dZ, exactComputation, filename, goodMap, innerRadius, length, mapBr, mapBz, mapFile, material, maxR, maxZ, minZ, name, norm, nR, nSheets, nZ, outerRadius, reflectZ, sheetDR, sheetR0, and tolerance.

{
        name = "";
        innerRadius = r.innerRadius;
        outerRadius = r.outerRadius;
        length = r.length;
        nSheets = r.nSheets;
        material = r.material;
        tolerance = r.tolerance;
        maxR = r.maxR;
        minZ = r.minZ;
        maxZ = r.maxZ;
        dR = r.dR;
        dZ = r.dZ;
        nR = r.nR;
        nZ = r.nZ;
        filename = r.filename;
        exactComputation = r.exactComputation;
        mapFile = r.mapFile;
        mapBr = 0;
        mapBz = 0;
        sheetR0 = r.sheetR0;
        sheetDR = r.sheetDR;
        norm = 0.0;
        goodMap = false;
        reflectZ = r.reflectZ;
        currentOfMap = r.currentOfMap;
}

---

Member Function Documentation

void BLCoil::printCoil

(

)

printCoil() will print a description

References dR, dZ, filename, innerRadius, length, mapFile, material, maxR, maxZ, name, nSheets, outerRadius, and tolerance.

Referenced by BLCMDcoil::command().

{
        printf("coil    %-7s ",name.c_str());
        printf("innerRadius=%.1f ",innerRadius);
        printf("outerRadius=%.1f ",outerRadius);
        printf("length=%.1f ",length);
        printf("material=%s ",material.c_str());
        printf("\n\t\t");
        if(mapFile == "") {
                printf("tolerance=%.3f ",tolerance);
                printf("nSheets=%d ",nSheets);
                printf("\n\t\t");
                printf("maxR=%.1f ",maxR);
                printf("maxZ=%.1f ",maxZ);
                printf("dR=%.1f ",dR);
                printf("dZ=%.1f ",dZ);
                printf("filename=%s ",filename.c_str());
                printf("\n");
        } else {
                printf("mapFile=%s\n",mapFile.c_str());
        }
}

BLCoil * BLCoil::find

(

G4String

name

)

[static]

find() returns a pointer to the named BLCoil.

References mapCoil.

Referenced by BLCMDsolenoid::command().

{
        if(mapCoil.count(name) > 0)
                return mapCoil[name];
        return 0;
}

void BLCoil::addField	(	const G4double	point[4],
		G4double	field[6],
		G4double	currentAmpPerMm2
	)			const

addField() adds the field value for the given point[] into field[]. Note that point[] is relative to the center of the coil. Units for current are Amp/mm^2.

References BLAssert, currentOfMap, dR, dZ, exactComputation, getSheetField(), goodMap, innerRadius, length, mapBr, mapBz, maxR, maxZ, minZ, name, nR, nSheets, nZ, outerRadius, reflectZ, sheetDR, and sheetR0.

Referenced by SolenoidField::addFieldValue(), and getUnitField().

{
        G4double z = point[2];
        G4double r = sqrt(point[0]*point[0] + point[1]*point[1]);

        if(goodMap && exactComputation == 0) {
                BLAssert(mapBr != 0 && mapBz != 0 && dR > 0.0 && dZ > 0.0);
                BLAssert(nR > 0 && nZ > 0);
                if(z < minZ+0.002*mm || z > maxZ-0.002*mm || r > maxR-0.002*mm)
                        return;
                G4double sign = 1.0;
                if(reflectZ) {
                        // map covers only z >= 0
                        if(z < 0.0) {
                                sign = -sign;
                                z = -z;
                        }
                } else {
                        z -= minZ;
                }
                // 2-d linear average of the 4 surrounding points
                int i = (int)(r/dR);
                int j = (int)(z/dZ);
if(i >= 0 && i < nR-1 && j >= 0 && j < nZ-1) {
  ;
} else {
  printf("\ni=%d j=%d nR=%d nZ=%d r=%.3f z=%.3f dR=%.3f dZ=%.3f\n",i,j,nR,nZ,r,z,dR,dZ);
  printf("z=%.6f maxZ=%.6f r=%.6f maxR=%.5f\n",z,maxZ,r,maxR);
  fflush(stdout);
}
                BLAssert(i >= 0 && i < nR-1 && j >= 0 && j < nZ-1);
                float fr = 1.0 - (r - i*dR) / dR;
                BLAssert(fr >= 0.0 && fr <= 1.0);
                float fz = 1.0 - (z - j*dZ) / dZ;
                BLAssert(fz >= 0.0 && fz <= 1.0);
        
                G4double Bz = mapBz[j*nR+i]*fr*fz +
                        mapBz[j*nR+i+1]*(1.0-fr)*fz +
                        mapBz[(j+1)*nR+i]*fr*(1.0-fz) +
                        mapBz[(j+1)*nR+i+1]*(1.0-fr)*(1.0-fz);
                G4double Br = mapBr[j*nR+i]*fr*fz +
                        mapBr[j*nR+i+1]*(1.0-fr)*fz +
                        mapBr[(j+1)*nR+i]*fr*(1.0-fz) +
                        mapBr[(j+1)*nR+i+1]*(1.0-fr)*(1.0-fz);
                G4double phi = atan2(point[1], point[0]);
                currentAmpPerMm2 /= currentOfMap;
                field[0] += sign * currentAmpPerMm2 * Br * cos(phi);
                field[1] += sign * currentAmpPerMm2 * Br * sin(phi);
                field[2] += currentAmpPerMm2 * Bz;
                return;
        }

        // Computation for no map
if(nSheets > 0 && sheetDR > 0.0 && sheetR0 > 0.0); else printf("%s: nSheets=%d sheetR0=%.3f sheetDR=%.3f innerRadius=%.3f outerRadius=%.3f length=%.3f\n",name.c_str(),nSheets,sheetR0,sheetDR,innerRadius,outerRadius,length);
        BLAssert(nSheets > 0 && sheetDR > 0.0 && sheetR0 > 0.0);
        G4double Br=0.0, Bz=0.0;
        G4double rSheet = sheetR0;
        G4double currentAmpPerMm = currentAmpPerMm2 * sheetDR;
        for(int i=0; i<nSheets; ++i) {
                G4double br, bz;
                // avoid singularity when r==rSheet
                if(fabs(r-rSheet) < sheetDR/8.0) {
                    getSheetField(r+sheetDR/4.0,z,br,bz,rSheet,length,
                                                        currentAmpPerMm);
                    G4double br1, bz1;
                    getSheetField(r-sheetDR/4.0,z,br1,bz1,rSheet,length,
                                                        currentAmpPerMm);
                    br = (br+br1)/2.0;
                    bz = (bz+bz1)/2.0;
                } else {
                    getSheetField(r,z,br,bz,rSheet,length,currentAmpPerMm);
                }
                Br += br;
                Bz += bz;
                rSheet += sheetDR;
        }
        G4double phi = atan2(point[1], point[0]);
        field[0] += Br * cos(phi);
        field[1] += Br * sin(phi);
        field[2] += Bz;
}

void BLCoil::generateFieldMap

(

)

generateFieldMap() will generate the field map (for execution speedup). If just maxR and tolerance were given, all other map parameters will be automatically determined so that the estimated error is less than the specified tolerance. The field map is cached in a disk file which is automatically recreated if anything changes (may take several minutes).

References BLAssert, currentOfMap, determineMaxR(), determineMaxZ(), determineNsheets(), dR, dZ, estimateMapError(), exactComputation, filename, getUnitField(), goodMap, innerRadius, length, mapBr, mapBz, mapFile, maxR, maxZ, minZ, name, norm, nR, nSheets, nZ, outerRadius, readMapFile(), reflectZ, sheetDR, sheetR0, BLTime::time(), and tolerance.

Referenced by BLCMDcoil::command().

{
        if(exactComputation != 0) {
                minZ = -DBL_MAX;
                maxZ = DBL_MAX;
                maxR = DBL_MAX;
                if(nSheets <= 0) nSheets = 1;
                sheetDR = (outerRadius-innerRadius) / nSheets;
                sheetR0 = innerRadius + sheetDR/2.0;
                return;
        }

        if(mapFile != "") {
                readMapFile();
                return;
        }

        struct FileHeader {
                long magic, nR, nZ, nSheets;
                double innerRadius, outerRadius, length, dR, dZ, error;
                // followed by nR*nZ  float-s of mapBr
                // followed by nR*nZ  float-s of mapBz
        };
        // Had serious problems with files written on a different OS that
        // passed the check but generated gross tracking errors and/or
        // exceptions in malloc/free. Probably different compilers padding
        // FileHeader differently.
#ifdef __linux
        const int MAGIC = 0x544A5232;   // 'TJR2'
#endif
#ifdef WIN32
        const int MAGIC = 0x544A5235;   // 'TJR5'
#endif
#ifdef __APPLE__
        const int MAGIC = 0x544A5234;   // 'TJR4'
#endif
#ifdef __CYGWIN__
        const int MAGIC = 0x544A5235;   // 'TJR5'
#endif

        printf("coilmap %-7s tolerance=%.5f [fraction of "
                                "Bz(r=0,z=0)]\n",name.c_str(),tolerance);
        fflush(stdout);
        goodMap = false;

        // read FileHeader from filename (if it exists), and check for 
        // consistency with this coil
#ifdef WIN32
        FILE *in = fopen(filename.c_str(),"rb");
#else
        FILE *in = fopen(filename.c_str(),"r");
#endif
        FileHeader fh;
        if(in) {
                if(fread(&fh,sizeof(fh),1,in) != 1) {
                        printf("BLCoil::generateFieldMap Cannot read header\n");
                        if(in) fclose(in);
                        in = 0;
                }
                if(fh.magic != MAGIC) {
                        printf("BLCoil::generateFieldMap wrong magic\n");
                        if(in) fclose(in);
                        in = 0;
                }
                if(fh.error > tolerance) {
                        printf("BLCoil::generateFieldMap error > tolerance\n");
                        if(in) fclose(in);
                        in = 0;
                }
                if(fabs(fh.innerRadius-innerRadius) > 0.001*mm) {
                        printf("BLCoil::generateFieldMap wrong innerRadius\n");
                        if(in) fclose(in);
                        in = 0;
                }
                if(fabs(fh.outerRadius-outerRadius) > 0.001*mm) {
                        printf("BLCoil::generateFieldMap wrong outerRadius\n");
                        if(in) fclose(in);
                        in = 0;
                }
                if(fabs(fh.length-length) > 0.001*mm) {
                        printf("BLCoil::generateFieldMap wrong length\n");
                        if(in) fclose(in);
                        in = 0;
                }
                if((dR > 0.001*mm && fabs(fh.dR-dR) > 0.001*mm)) {
                        printf("BLCoil::generateFieldMap wrong dR\n");
                        if(in) fclose(in);
                        in = 0;
                }
                if((dZ > 0.001*mm && fabs(fh.dZ-dZ) > 0.001*mm)) {
                        printf("BLCoil::generateFieldMap wrong dZ\n");
                        if(in) fclose(in);
                        in = 0;
                }
                if((fh.nR-1)*fh.dR < maxR || (fh.nZ-1)*fh.dZ < maxZ) {
                        printf("BLCoil::generateFieldMap wrong maxR or maxZ\n");
                        if(in) fclose(in);
                        in = 0;
                }
        }
        // setup data from file and read the maps from file
        if(in) {
                G4double orgMaxZ = maxZ;
                G4double orgMaxR = maxR;
                G4int orgNsheets = nSheets;
                nR = fh.nR;
                nZ = fh.nZ;
                dR = fh.dR;
                dZ = fh.dZ;
                nSheets = fh.nSheets;
                sheetDR=(outerRadius-innerRadius)/nSheets;
                sheetR0=innerRadius + sheetDR/2.0;
                norm = 0.0;
                maxR = (nR-1)*dR;
                maxZ = (nZ-1)*dZ;
                minZ = -maxZ;
                if(mapBr) delete[] mapBr;
                if(mapBz) delete[] mapBz;
                mapBr = new float[nZ*nR];
                mapBz = new float[nZ*nR];
                if(!mapBr || !mapBz) {
                        G4Exception("coil","Out of memory",FatalException,"");
                }
                if(fread(mapBr,sizeof(float),nR*nZ,in) != (size_t)nR*nZ ||
                   fread(mapBz,sizeof(float),nR*nZ,in) != (size_t)nR*nZ) {
                        fclose(in);
                        in = 0;
                        printf("BLCoil::generateFieldMap cannot read data\n");
                        // restore invalid data that came from file
                        maxZ = orgMaxZ;
                        minZ = -maxZ;
                        reflectZ = true;
                        maxR = orgMaxR;
                        nSheets = orgNsheets;
                }
        }
        // if file is correct, use it.
        if(in) {
                fclose(in);
                in = 0;
                goodMap = true;
                printf("coilmap %-7s read file '%s'  "
                    "dR=%.1f dZ=%.1f\n",name.c_str(),filename.c_str(),dR,dZ);
                minZ = -maxZ;
                reflectZ = true;
                currentOfMap = 1.0;
                return;
        }

        // file is not correct - generate map

        if(maxR <= 0.0)
                determineMaxR();
        if(maxZ <= 0.0)
                determineMaxZ();
        if(nSheets <= 0) {
                determineNsheets();
        } else {
                sheetDR = (outerRadius-innerRadius) / nSheets;
                sheetR0 = innerRadius + sheetDR/2.0;
        }

        // initial estimate of dR,dZ,nR,nZ
        if(dR <= 0.0)
                dR = maxR/10;
        nR = (int)floor(maxR/dR) + 2;
        //@@ for now, assume dZ = dR....
        if(dZ <= 0.0)
                dZ = dR;
        nZ = (int)floor(maxZ/dZ) + 2;

        // loop until we achieve the required tolerance. Limit to 8 doublings.
        const int MAX_ITER=8;
        int iter;
        G4double err = 1.0;
        for(iter=0; iter<MAX_ITER; ++iter) {
                // for simplicity, discard all previous computations
                if(mapBr) delete[] mapBr;
                if(mapBz) delete[] mapBz;
                mapBr = new float[nZ*nR];
                mapBz = new float[nZ*nR];
                if(!mapBr || !mapBz) {
                        G4Exception("coil","Out of memory",FatalException,"");
                }
                err = estimateMapError();
                if(err < tolerance)
                        break;
                dR /= 2.0;
                dZ /= 2.0;
                nR = (int)floor(maxR/dR) + 2;
                nZ = (int)floor(maxZ/dZ) + 2;
        }
        if(iter >= MAX_ITER) {
                G4Exception("coilmap","Failed to achieve required accuracy",
                                                        FatalException, "");
        }
        printf("coilmap %-7s nR=%d nZ=%d dR=%.1f dZ=%.1f "
                        "error=%.6f\n",name.c_str(),nR,nZ,dR,dZ,err);

        // fill the maps
        //@@ for simplicity, ignore all previous computations
        goodMap = false;
        time_t start = BLTime::time();
        for(int i=0; i<nR; ++i) {
                G4double r = i * dR;
                for(int j=0; j<nZ; ++j) {
                        G4double z = j * dZ;
                        int k = j * nR + i;
                        BLAssert( k >= 0 && k < nZ*nR);
                        G4double Br,Bz;
                        getUnitField(r,z,Br,Bz);
                        mapBr[k] = Br;
                        mapBz[k] = Bz;
                }
//              printf("coilmap %-7s  %d%% %ld seconds\r",
//                      name.c_str(),(100*(i+1))/nR,(long)(BLTime::time()-start));
//              fflush(stdout);
        }
        printf("coilmap %-7s  DONE %ld seconds\n",
                name.c_str(),(long)(BLTime::time()-start)); 
        fflush(stdout);

        // write the map
        if(filename != "") {
#ifdef WIN32
                FILE *out = fopen(filename.c_str(),"wb");
#else
                FILE *out = fopen(filename.c_str(),"w");
#endif
                if(out) {
                        FileHeader fh;
                        fh.magic = MAGIC;
                        fh.nR = nR;
                        fh.nZ = nZ;
                        fh.nSheets = nSheets;
                        fh.innerRadius = innerRadius;
                        fh.outerRadius = outerRadius;
                        fh.length = length;
                        fh.dR = dR;
                        fh.dZ = dZ;
                        fh.error = err;
                        if(fwrite(&fh,sizeof(fh),1,out) != 1 ||
                           fwrite(mapBr,sizeof(float),nR*nZ,out) != (size_t)nR*nZ ||
                           fwrite(mapBz,sizeof(float),nR*nZ,out) != (size_t)nR*nZ) {
                                printf("coilmap %-7s ERROR "
                                        "writing file '%s'\n",
                                        name.c_str(),filename.c_str());
                        }
                        fclose(out);
                        printf("coilmap %-7s wrote file '%s'   %lu bytes\n",
                                name.c_str(),filename.c_str(),
                                (long)(sizeof(fh)+sizeof(float)*2*nR*nZ));
                }
        }

        goodMap = true;
        minZ = -maxZ;
        reflectZ = true;
        currentOfMap = 1.0;
}

void BLCoil::readMapFile

(

)

readMapFile() will read the mapFile.

References currentOfMap, dR, dZ, goodMap, mapBr, mapBz, mapFile, maxR, maxZ, minZ, nR, nZ, BLCommand::parseArgs(), BLCommand::printError(), and reflectZ.

Referenced by generateFieldMap().

{
        FILE *in = fopen(mapFile.c_str(),"r");
        if(!in) {
                BLCommand::printError("Cannot open mapFile '%s'\n",mapFile.c_str());
                return;
error:
                BLCommand::printError("Syntax error in mapFile '%s'\n",mapFile.c_str());
                return;
        }

        char line[512];

        // read first line (parameters of the map)
        // units are millimeters, Tesla, and Amperes/mm^2.
        do {
                if(!fgets(line,sizeof(line),in)) goto error;
        } while(line[0] == '#');

        BLArgumentVector argv;
        BLArgumentMap argm;
        if(BLCommand::parseArgs(line,argv,argm)) goto error;

        // sample parameter line:
        // z0=0.0 dz=2.0 nz=1501 dr=5.0 nr=13 reflectZ=1 current=-101.1
        G4double z0 = atof(argm["z0"].c_str())*mm;
        dZ = atof(argm["dz"].c_str())*mm;
        nZ = atoi(argm["nz"].c_str());
        dR = atof(argm["dr"].c_str())*mm;
        nR = atoi(argm["nr"].c_str());
        reflectZ = (atoi(argm["reflectZ"].c_str()) != 0);
        currentOfMap = atof(argm["current"].c_str());
        maxR = (nR-1)*dR;
        maxZ = z0 + (nZ-1)*dZ;
        if(reflectZ) {
                minZ = -maxZ;
                if(z0 != 0.0) goto error;
        } else {
                minZ = z0;
        }
        if(argv.size() > 0 || nZ <= 0 || nR <= 0 || maxR <= 0.0 ||
                                        maxZ <= 0.0 || currentOfMap == 0.0)
                goto error;
        if(mapBr) delete[] mapBr;
        if(mapBz) delete[] mapBz;
        mapBr = new float[nZ*nR];
        mapBz = new float[nZ*nR];
        if(!mapBr || !mapBz) {
                G4Exception("coil","Out of memory",FatalException,"");
        }

        // read the map -- there are two maps, Bz and Br, each introduced
        // by a line with its name in column 1. Each map consists of nZ
        // lines of nR floats.
        int i=-1;
        float *map=0;
        while(fgets(line,sizeof(line),in)) {
                if(line[0] == '#') continue;
                if(strncmp(line,"Bz",2) == 0) {
                        if(i != -1 && i != nZ) goto error;
                        i = 0;
                        map = mapBz;
                        continue;
                } else if(strncmp(line,"Br",2) == 0) {
                        if(i != -1 && i != nZ) goto error;
                        i = 0;
                        map = mapBr;
                        continue;
                }
                if(i < 0 || i >= nZ || !map) goto error;
                char *p = line;
                for(int j=0; j<nR; ++j) {
                        char *q=0;
                        if(*p == '\0') goto error;
                        *map++ = strtod(p,&q)*tesla;
                        if(q == 0 || p == q) goto error;
                        p = q;
                }
                ++i;
        }
        if(i != nZ) goto error;
        fclose(in);
        goodMap = true; 
}

void BLCoil::displayMapValues	(	G4double	r,
		G4double	z
	)

displayMapValues() will display the 4 map values around a point.

References computeError(), dR, dZ, getUnitField(), goodMap, innerRadius, length, mapBr, mapBz, maxR, name, norm, nR, nZ, and outerRadius.

{
        if(!goodMap) {
                printf("BLCoil '%s' has no good map\n",name.c_str());
                return;
        }
        if(z < 0.0) {
                printf("z must be >= 0\n");
                return;
        }

        BLCoil best("temp",innerRadius,outerRadius,length,99,0.0,maxR,maxZ);
        G4double Br,Bz;
        getUnitField(r,z,Br,Bz);

        int ii = (int)(r/dR);
        int jj = (int)(z/dZ);
        if(ii+1 >= nR || jj+1 >= nZ) {
                printf("out of range\n");
                return;
        }
        printf("r=%.3f z=%.3f Bz=%.6f T  Br=%.6f T  Berr=%.6f T\n",
                        r,z,Bz/tesla,Bz/tesla,
                        computeError(r,z,best,false)/norm/tesla);
        G4double bzmin=Bz, bzmax=Bz, bzavg=0.0;
        G4double brmin=Br, brmax=Br, bravg=0.0;
        for(int i=ii; i<=ii+1; ++i) {
            for(int j=jj; j<=jj+1; ++j) {
                if(bzmin > mapBz[j*nR+i]) bzmin = mapBz[j*nR+i];
                if(bzmax < mapBz[j*nR+i]) bzmax = mapBz[j*nR+i];
                if(brmin > mapBr[j*nR+i]) brmin = mapBr[j*nR+i];
                if(brmax < mapBr[j*nR+i]) brmax = mapBr[j*nR+i];
                bzavg += mapBz[j*nR+i]/4.0;
                bravg += mapBr[j*nR+i]/4.0;
                printf("Grid: r=%.3f z=%.3f Bz=%.6f T  Br=%.6f T\n",
                        dR*i,dZ*j,mapBz[j*nR+i]/tesla,mapBr[j*nR+i]/tesla);
            }
        }
        printf("BzVariation=%.4f BrVariation=%.4f (fractions of avg)\n",
                (bzmax-bzmin)/bzavg,(brmax-brmin)/bravg);
}

void BLCoil::getUnitField	(	G4double	r,
		G4double	z,
		G4double &	Br,
		G4double &	Bz
	)			[private]

getUnitField() will return Br and Bz for unit current.

References addField().

Referenced by computeError(), determineMaxR(), determineMaxZ(), displayMapValues(), and generateFieldMap().

{
        G4double point[4];
        point[0] = point[1] = point[2] = point[3] = 0.0;
        G4double f[6];
        f[0]=f[1]=f[2]=f[3]=f[4]=f[5]=f[6]=0.0;
        point[0] = r;
        point[2] = z;
        addField(point,f,1.0);
        Br = f[0];
        Bz = f[2];
}

void BLCoil::determineMaxR

(

)

[private]

determineMaxR() will determine maxR based on tolerance. Uses nSheets=99 to determine center field, and walks out far enough so (Bz/Bz0)<0.5*tolerance.

References getUnitField(), innerRadius, length, maxR, name, norm, outerRadius, and tolerance.

Referenced by generateFieldMap().

{
        G4double Br,Bz;
        BLCoil best("temp",innerRadius,outerRadius,length,99,0.0,
                                        10.0*outerRadius,100.0*outerRadius);
        if(norm == 0.0) {
                best.getUnitField(0.0,0.0,Br,Bz);
                norm = 1.0/Bz;
        }

        // step out in maxR until 0.5*tolerance is achieved
        for(maxR=outerRadius+2.0*innerRadius;
            maxR<=outerRadius+32.0*innerRadius;
            maxR+=innerRadius) {
                best.getUnitField(maxR,0.0,Br,Bz);
                Bz = fabs(Bz);
                if(Bz*norm < 0.5*tolerance) break;
        }
        if(maxR <= outerRadius+32.0*innerRadius) {
                printf("BLCoil::determineMaxR '%s'  maxR=%.1f err=%.6f\n",
                                        name.c_str(),maxR,Bz*norm);
        } else {
                G4Exception("coilmap determineMaxR",
                                        "Failed to achieve required accuracy",
                                        FatalException, "");
        }
}

void BLCoil::determineMaxZ

(

)

[private]

determineMaxZ() will determine maxZ based on tolerance. Uses nSheets=99 to determine on-axis field, and walks out far enough so (Bz/Bz0)<0.5*tolerance.

References getUnitField(), innerRadius, length, maxR, name, norm, outerRadius, and tolerance.

Referenced by generateFieldMap().

{
        G4double Br,Bz;
        BLCoil best("temp",innerRadius,outerRadius,length,99,0.0,maxR,
                                                        100.0*outerRadius);
        if(norm == 0.0) {
                best.getUnitField(0.0,0.0,Br,Bz);
                norm = 1.0/Bz;
        }

        // step out in maxZ until 0.5*tolerance is achieved
        for(maxZ=length/2.0+4.0*innerRadius; maxZ<=length/2.0+32.0*innerRadius;
                                                        maxZ+=innerRadius) {
                best.getUnitField(0.0,maxZ,Br,Bz);
                if(Bz*norm < 0.5*tolerance) break;
        }
        if(maxZ <= length/2.0+32.0*innerRadius) {
                printf("BLCoil::determineMaxZ '%s'  maxZ=%.1f err=%.6f\n",
                                        name.c_str(),maxZ,Bz*norm);
        } else {
                G4Exception("coilmap determineMaxZ",
                                        "Failed to achieve required accuracy",
                                        FatalException, "");
        }
}

void BLCoil::determineNsheets

(

)

[private]

determineNsheets() will determine nSheets, given maxZ and tolerance. Increases nSheets until maxError < tolerance/4 (the other 3/4 of tolerance is for mapping errors). Checks just a handful of points selected to be representative.

References computeError(), exclude, innerRadius, length, maxR, name, nSheets, outerRadius, sheetDR, sheetR0, and tolerance.

Referenced by generateFieldMap().

{
        BLCoil best("temp",innerRadius,outerRadius,length,99,0.0,maxR,maxZ);

        G4double exclude = 0.1 * innerRadius;
        G4double err = 0.0;
        const int MAX_SHEETS=40;
        for(nSheets=2; nSheets<=MAX_SHEETS; nSheets+=2) {
                sheetDR = (outerRadius-innerRadius) / nSheets;
                sheetR0 = innerRadius + sheetDR/2.0;
                err = 0.0;
                for(int i=0; i<50; ++i) {
                        G4double r = innerRadius - exclude;
                        G4double z = G4UniformRand() * length/2.0;
                        if(r >= maxR) r = maxR;
                        G4double e = computeError(r,z,best,false);
                        if(e > err) err = e;
                        r = innerRadius + (outerRadius-innerRadius)*G4UniformRand();
                        if(r >= maxR) continue;
                        z = length/2.0 + exclude;
                        e = computeError(r,z,best,false);
                        if(e > err) err = e;
                        if(err > tolerance/4.0) break;
                }
                if(err <= tolerance/4.0) break;
        }

        if(nSheets <= MAX_SHEETS) {
                printf("BLCoil::determineNsheets '%s'  nSheets=%d err=%.6f\n",
                                        name.c_str(),nSheets,err);
        } else {
                G4Exception("coilmap determineNsheets",
                                        "Failed to achieve required accuracy",
                                        FatalException, "");
        }
}

G4double BLCoil::estimateMapError

(

)

[private]

estimateMapError() will estimate the maximum error in mapping, given maxZ, nSheets, dR, dZ, nR, nZ, and an allocated but uninitialized fieldMap. It generates 1000 random points and returns the maximum error; quits early if tolerance is exceeded. Error is (currentMap - best)/best(r=0,z=0), where best is computed with no map and nSheets=99. For each point it generates the 4 surrounding values of fieldMap (this is faster than generating the entire map first). Returns the maximum error of either Bz or Br, normalized to Bz(r=0,z=0,nSheets=99).

References computeError(), exclude, innerRadius, length, maxR, outerRadius, and tolerance.

Referenced by generateFieldMap().

{
        BLCoil best("temp",innerRadius,outerRadius,length,99,0.0,maxR,maxZ);

        // generate 1000 random positions, "close"
        // to the coil in z, but exclude the coil (and nearby).
        G4double exclude = 0.1 * innerRadius;
        G4double err = 0.0;
        G4double genZ = length;
        if(length/2.0+exclude+10.0*mm > genZ) genZ = length/2.0+exclude+10.0*mm;
        for(int i=0; i<1000; ++i) {
                G4double r, z;
                do {
                        r = G4UniformRand() * maxR;
                        z = G4UniformRand() * genZ;
                } while(z < length/2+exclude &&
                        r > innerRadius-exclude &&
                        r < outerRadius+exclude);
                G4double e = computeError(r,z,best,true);
                if(e > err) err = e;
                if(err > tolerance) {
                        break;
                }
//              if(i%10 == 0)
//                      printf("BLCoil::estimateMapError nR=%d nZ=%d %d%%\r",
//                              nR,nZ,(100*i)/1000), fflush(stdout);
        }

        return err;
}

G4double BLCoil::computeError	(	G4double	r,
		G4double	z,
		BLCoil &	best,
		G4bool	makeMap
	)			[private]

computeError() computes the error for a single point. Error is (currentMap - best)/best(r=0,z=0), where best should be an identical BLCoil with no map and nSheets=99. If makeMap is true, it generates the 4 surrounding values of the fieldMap.

References BLAssert, dR, dZ, getUnitField(), goodMap, mapBr, mapBz, maxR, norm, nR, and nZ.

Referenced by determineNsheets(), displayMapValues(), and estimateMapError().

{
        G4double Br,Bz;
        if(z < -maxZ || z > maxZ || r > maxR) return 0.0;
        G4bool originalGoodMap = goodMap;

        if(norm == 0.0) {
                best.getUnitField(0.0,0.0,Br,Bz);
                norm = 1.0/Bz;
        }

        if(makeMap) {
                // generate fieldMap for the 4 surrounding grid points
                BLAssert(mapBz != 0 && mapBr != 0 && nR > 0 && nZ > 0);
                BLAssert(z >= 0.0);
                goodMap = false;
                int i = (int)(r/dR);
                int j = (int)(z/dZ);
                BLAssert(i >= 0 && i < nR-1 && j >= 0 && j < nZ-1);
        
                getUnitField(i*dR,j*dZ,Br,Bz);
                mapBz[j*nR+i] = Bz;
                mapBr[j*nR+i] = Br;

                getUnitField((i+1)*dR,j*dZ,Br,Bz);
                mapBz[j*nR+(i+1)] = Bz;
                mapBr[j*nR+(i+1)] = Br;
        
                getUnitField(i*dR,(j+1)*dZ,Br,Bz);
                mapBz[(j+1)*nR+i] = Bz;
                mapBr[(j+1)*nR+i] = Br;

                getUnitField((i+1)*dR,(j+1)*dZ,Br,Bz);
                mapBz[(j+1)*nR+(i+1)] = Bz;
                mapBr[(j+1)*nR+(i+1)] = Br;

                goodMap = true;
        }

        G4double bestBr,bestBz;
        best.getUnitField(r,z,bestBr,bestBz);
        getUnitField(r,z,Br,Bz);
        G4double eBr = fabs(Br-bestBr)*norm;
        G4double eBz = fabs(Bz-bestBz)*norm;

        goodMap = originalGoodMap;
        return (eBr>eBz ? eBr : eBz);
}

void BLCoil::getSheetField	(	G4double	r,
		G4double	z,
		G4double &	Br,
		G4double &	Bz,
		G4double	sheetR,
		G4double	sheetLen,
		G4double	currentAmpPerMm
	)			const [private]

getSheetField() returns the B field from an infinitesimally-thin sheet of current. Arguments: r and z are the cylindrical coordinates of the point in question relative to center of the coil (axis along z), mm. Br and Bz return the computed B field at that point (geant4 units) sheetR is the radius of the current sheet (mm) sheetLen is the length of the current sheet (mm) currentAmpPerMm is the current of the sheet (Amp per linear mm)

Referenced by addField().

{
  // TJR: within this routine the sheet extends from z=0 to z=sheetLen,
  //      externally it is centered at z=0.
  z += sheetLen/2.0;

//printf("BLCoil::getSheetField r=%.6g z=%.6g sheetR=%.6g sheetLen=%.6g\n",r,z,sheetR,sheetLen); fflush(stdout);
  G4double k; 

  G4double rposition = r/meter;
  G4double zposition = z/meter;

  G4double rad = sheetR/meter;
  G4double len = sheetLen/meter;
  G4double cur = currentAmpPerMm;

  //  Left-end of sheet

  G4double rho = rposition;
  z = -zposition;
  
  G4double r1 = sqrt( pow(rad + rho,2) + z*z );
  k = 2.0 / r1 * sqrt( rad * rho );
  G4double c2 = -4.0 * rad*rho / pow(rad+rho,2);

  G4double f1 = z * rad / ((rad + rho) * r1);
  G4double f2 = (rad - rho) / (2.0 * rad);

//printf("gsl_sf_ellint_E k=%.6g\n",k); fflush(stdout);
  G4double elle = gsl_sf_ellint_E(pi/2.0,k,GSL_PREC_DOUBLE);
//printf("gsl_sf_ellint_F k=%.6g\n",k); fflush(stdout);
  G4double ellf = gsl_sf_ellint_F(pi/2.0,k,GSL_PREC_DOUBLE);
//printf("gsl_sf_ellint_P k=%.6g c2=%.6g\n",k,c2); fflush(stdout);
  G4double ellpi = gsl_sf_ellint_P(pi/2.0,k,c2,GSL_PREC_DOUBLE);

  G4double bz1 = f1 * ( ellf + f2 * ( ellpi - ellf ) );

  G4double br1;

  if( rho != 0.0 ) {
    f1 = r1 / (4.*rho);
    br1 = f1 * ( 2. * ( ellf - elle ) - k * k * ellf );
  }
  else {
    br1 = 0.0;
  }

  G4double bz = -bz1;
  G4double br = -br1;      

  //  Right-end of sheet
      
  z = z + len;
  r1 = sqrt( pow(rad + rho,2) + z*z );
  k = 2.0 / r1 * sqrt( rad * rho );
  c2 = -4.0 * rad * rho / pow(rad + rho,2);

  f1 = z * rad / ( (rad + rho) * r1);
  f2 = (rad - rho) / (2.0 * rad);

//printf("gsl_sf_ellint_E k=%.6g\n",k); fflush(stdout);
  elle = gsl_sf_ellint_E(pi/2.0,k,GSL_PREC_DOUBLE);
//printf("gsl_sf_ellint_F k=%.6g\n",k); fflush(stdout);
  ellf = gsl_sf_ellint_F(pi/2.0,k,GSL_PREC_DOUBLE);
//printf("gsl_sf_ellint_P k=%.6g c2=%.6g\n",k,c2); fflush(stdout);
  ellpi = gsl_sf_ellint_P(pi/2.0,k,c2,GSL_PREC_DOUBLE);

  bz1 = f1 * ( ellf + f2 * ( ellpi - ellf ) );

  if ( rho != 0.0 ) {
    f1 = r1 / (4.0 * rho);
    br1 = f1 * ( 2.0 * ( ellf - elle ) - k * k * ellf );
  }      
  else {
    br1 = 0.0;
  }

  bz = bz + bz1;       // note change of sign
  br = br + br1;

  G4double permfactor = 4.0e-7;

  Br = permfactor * cur * br;
  Bz = permfactor * cur * bz;

 }

---

Friends And Related Function Documentation

friend class BLCMDcoil [friend]

friend class BLCMDsolenoid [friend]

friend class SolenoidField [friend]

---

Member Data Documentation

std::map< G4String, BLCoil * > BLCoil::mapCoil [static, private]

Referenced by BLCMDcoil::command(), and find().

G4String BLCoil::name [private]

Referenced by addField(), BLCoil(), determineMaxR(), determineMaxZ(), determineNsheets(), displayMapValues(), generateFieldMap(), and printCoil().

G4double BLCoil::innerRadius [private]

Referenced by addField(), BLCoil(), BLCMDsolenoid::construct(), BLCMDcoil::defineNamedArgs(), determineMaxR(), determineMaxZ(), determineNsheets(), displayMapValues(), estimateMapError(), generateFieldMap(), BLCMDsolenoid::generatePoints(), BLCMDsolenoid::isOutside(), and printCoil().

G4double BLCoil::outerRadius [private]

Referenced by addField(), BLCoil(), BLCMDsolenoid::construct(), BLCMDcoil::defineNamedArgs(), determineMaxR(), determineMaxZ(), determineNsheets(), displayMapValues(), estimateMapError(), generateFieldMap(), BLCMDsolenoid::generatePoints(), BLCMDsolenoid::getHeight(), BLCMDsolenoid::getWidth(), BLCMDsolenoid::isOutside(), and printCoil().

G4double BLCoil::length [private]

Referenced by addField(), BLCoil(), BLCMDsolenoid::construct(), BLCMDcoil::defineNamedArgs(), determineMaxR(), determineMaxZ(), determineNsheets(), displayMapValues(), estimateMapError(), generateFieldMap(), BLCMDsolenoid::generatePoints(), BLCMDsolenoid::getLength(), BLCMDsolenoid::isOutside(), and printCoil().

G4int BLCoil::nSheets [private]

Referenced by addField(), BLCoil(), BLCMDcoil::defineNamedArgs(), determineNsheets(), generateFieldMap(), and printCoil().

G4String BLCoil::material [private]

Referenced by BLCoil(), BLCMDsolenoid::construct(), BLCMDcoil::defineNamedArgs(), and printCoil().

G4double BLCoil::tolerance [private]

Referenced by BLCoil(), BLCMDcoil::defineNamedArgs(), determineMaxR(), determineMaxZ(), determineNsheets(), estimateMapError(), generateFieldMap(), and printCoil().

G4double BLCoil::maxR [private]

Referenced by addField(), BLCoil(), computeError(), BLCMDcoil::defineNamedArgs(), determineMaxR(), determineMaxZ(), determineNsheets(), displayMapValues(), estimateMapError(), generateFieldMap(), printCoil(), readMapFile(), and SolenoidField::SolenoidField().

G4double BLCoil::minZ [private]

Referenced by addField(), BLCoil(), generateFieldMap(), readMapFile(), and SolenoidField::SolenoidField().

G4double BLCoil::maxZ [private]

Referenced by addField(), BLCoil(), BLCMDcoil::defineNamedArgs(), generateFieldMap(), printCoil(), readMapFile(), and SolenoidField::SolenoidField().

G4double BLCoil::dR [private]

Referenced by addField(), BLCoil(), computeError(), BLCMDcoil::defineNamedArgs(), displayMapValues(), generateFieldMap(), printCoil(), and readMapFile().

G4double BLCoil::dZ [private]

Referenced by addField(), BLCoil(), computeError(), BLCMDcoil::defineNamedArgs(), displayMapValues(), generateFieldMap(), printCoil(), and readMapFile().

G4int BLCoil::nR [private]

Referenced by addField(), BLCoil(), computeError(), displayMapValues(), generateFieldMap(), and readMapFile().

G4int BLCoil::nZ [private]

Referenced by addField(), BLCoil(), computeError(), displayMapValues(), generateFieldMap(), and readMapFile().

G4String BLCoil::filename [private]

Referenced by BLCoil(), BLCMDcoil::defineNamedArgs(), generateFieldMap(), and printCoil().

G4String BLCoil::mapFile [private]

Referenced by BLCoil(), BLCMDcoil::defineNamedArgs(), generateFieldMap(), printCoil(), and readMapFile().

G4int BLCoil::exactComputation [private]

Referenced by addField(), BLCoil(), BLCMDcoil::defineNamedArgs(), and generateFieldMap().

float* BLCoil::mapBr [private]

Referenced by addField(), BLCoil(), computeError(), displayMapValues(), generateFieldMap(), readMapFile(), and ~BLCoil().

float* BLCoil::mapBz [private]

Referenced by addField(), BLCoil(), computeError(), displayMapValues(), generateFieldMap(), readMapFile(), and ~BLCoil().

G4double BLCoil::sheetR0 [private]

Referenced by addField(), BLCoil(), determineNsheets(), and generateFieldMap().

G4double BLCoil::sheetDR [private]

Referenced by addField(), BLCoil(), determineNsheets(), and generateFieldMap().

G4double BLCoil::norm [private]

Referenced by BLCoil(), computeError(), determineMaxR(), determineMaxZ(), displayMapValues(), and generateFieldMap().

G4bool BLCoil::goodMap [private]

Referenced by addField(), BLCoil(), computeError(), displayMapValues(), generateFieldMap(), and readMapFile().

G4bool BLCoil::reflectZ [private]

Referenced by addField(), BLCoil(), generateFieldMap(), and readMapFile().

G4double BLCoil::currentOfMap [private]

Referenced by addField(), BLCoil(), generateFieldMap(), and readMapFile().

---

The documentation for this class was generated from the following files:

• BLCoil.hh
• BLCoil.cc