#include <BFieldComponentQuad.h>

Inheritance diagram for BFieldComponentQuad:

Classes
struct	ApertPoint
	Aperture data structure. More...

struct	irange_t
	start and stop indices to narrow search in array More...

struct	ParamPoint3
	Quadrupole lense data structure. More...

struct	range_t
	Range data structure. More...

Public Types
typedef std::vector< range_t >	ranges_t
	vector of Range data structure.

Public Member Functions
	BFieldComponentQuad ()=default
	The BFieldComponentQuad constructor.

virtual	~BFieldComponentQuad ()=default
	The BFieldComponentQuad destructor.

virtual void	initialize () override
	Initializes the magnetic field component.

virtual ROOT::Math::XYZVector	calculate (const ROOT::Math::XYZVector &point) const override
	Calculates the magnetic field vector at the specified space point.

double	getApertureHER (double s) const
	Returns the HER beam pipe aperture at given position.

double	getApertureLER (double s) const
	Returns the LER beam pipe aperture at given position.

void	setMapFilename (const std::string &filenameHER, const std::string &filenameLER, const std::string &filenameHERleak)
	Sets the filename of the magnetic field map.

void	setApertFilename (const std::string &filenameHER, const std::string &filenameLER)
	Sets the filename of aperture definition file.

void	setMapSize (int sizeHER, int sizeLER, int sizeHERleak)
	Sets the size of the magnetic field map.

void	setApertSize (int sizeHER, int sizeLER)
	Sets the size of the aperture map.

virtual void	terminate ()
	Terminates the magnetic field component.

Private Member Functions
int	getRange (double a, const ranges_t &b) const
	Search for range occupied by optics since now only for ranges are present use linear search.

double	getAperture (double s, std::vector< ApertPoint >::const_iterator hint) const
	Returns the beam pipe aperture at given position.

Private Attributes
std::string	m_mapFilenameHER {""}
	Magnetic field map of HER.

std::string	m_mapFilenameLER {""}
	Magnetic field map of LER.

std::string	m_mapFilenameHERleak {""}
	The filename of the magnetic field map.

std::string	m_apertFilenameHER {""}
	Filename of the aperture for HER.

std::string	m_apertFilenameLER {""}
	The filename of the aperture for LER.

int	m_mapSizeHER {0}
	The size of the map for HER.

int	m_mapSizeLER {0}
	The size of the map for LER.

int	m_mapSizeHERleak {0}
	The size of the map.

int	m_apertSizeHER {0}
	The size of the aperture for HER.

int	m_apertSizeLER {0}
	The size of the aperture for LER.

double	m_maxr2 {0}
	The square of maximal aperture for fast rejection.

ranges_t	m_ranges_her
	ranges vector for HER

ranges_t	m_ranges_ler
	ranges vector for LER

std::vector< ApertPoint >	m_ah
	The the aperture parameters for HER.

std::vector< ApertPoint >	m_al
	The the aperture parameters for LER.

std::vector< ParamPoint3 >	m_h3
	The map for HER.

std::vector< ParamPoint3 >	m_l3
	The map for LER.

std::vector< std::vector< ParamPoint3 >::const_iterator >	m_offset_pp_her
	The vector of pointer to accelerate search in maps for her.

std::vector< std::vector< ParamPoint3 >::const_iterator >	m_offset_pp_ler
	The vector of pointer to accelerate search in maps for ler.

std::vector< std::vector< ApertPoint >::const_iterator >	m_offset_ap_her
	The vector of pointer to accelerate search in aperture for her.

std::vector< std::vector< ApertPoint >::const_iterator >	m_offset_ap_ler
	The vector of pointer to accelerate search in aperture for ler.

Detailed Description

The BFieldComponentQuad class.

This class represents a magnetic field map from quadrupole magnets QC[1/2]*. Only the field from QC[1/2]* inside beam pipes is described. Leak field inside the beam pipe from the quadruple magnet on the other beam line is also included, however, leak field outside both beam pipe are not described. Therefore, we should turn on this field component only when we use TouschekTURTLEReader and Synchrotron radiation study, which needs accurate propagation of beam particles. Field strength are calculated from the magnet parameters (K0,K1,SK0,SK1) used in accelerator simulation. These parameters are provided for each 4cm slice in the beam direction.

Definition at line 35 of file BFieldComponentQuad.h.

Member Typedef Documentation

◆ ranges_t

typedef std::vector<range_t> ranges_t

vector of Range data structure.

Definition at line 44 of file BFieldComponentQuad.h.

Member Function Documentation

◆ calculate()

ROOT::Math::XYZVector calculate ( const ROOT::Math::XYZVector & point ) const

overridevirtual

Calculates the magnetic field vector at the specified space point.

Parameters

point The space point in Cartesian coordinates (x,y,z) in [cm] at which the magnetic field vector should be calculated.

Returns: The magnetic field vector at the given space point in [T]. Returns a zero vector XYZVector(0,0,0) if the space point lies outside the region described by the component.

Implements BFieldComponentAbs.

Definition at line 347 of file BFieldComponentQuad.cc.

{
  const double sa = sin(0.0415), ca = cos(0.0415);
  //assume point is given in [cm]
  ROOT::Math::XYZVector B(0, 0, 0);
 
  const ROOT::Math::XYZVector& v{point};
  double xc = v.X() * ca, zs = v.Z() * sa, zc = v.Z() * ca, xs = v.X() * sa;
  ROOT::Math::XYZVector vh{(xc - zs), -v.Y(), -(zc + xs)}; // to the HER beamline frame
  ROOT::Math::XYZVector vl{(xc + zs), -v.Y(), -(zc - xs)}; // to the LER beamline frame
 
  double r2h = vh.Perp2(), r2l = vl.Perp2();
 
  if (r2h < r2l) { /* the point is closer to HER*/
    if (r2h < m_maxr2) { /* within max radius */
      double s = vh.Z();
      int i = getRange(s, m_ranges_her);
      if (i < 0) return B;
      double r = getAperture(s, m_offset_ap_her[i]);
      if (r2h < r * r) {
        auto kt = m_offset_pp_her[i] + static_cast<unsigned int>(s - m_ranges_her[i + 1].r0);
        double Bx = kt->getBx(vh.X(), vh.Y());
        double By = kt->getBy(vh.X(), vh.Y());
        B.SetXYZ(Bx * ca, -By, -Bx * sa); // to the detector frame
      }
    }
  } else {      /* the point is closer to LER*/
    if (r2l < m_maxr2) { /* within max radius */
      double s = vl.Z();
      int i = getRange(s, m_ranges_ler);
      if (i < 0) return B;
      double r = getAperture(s, m_offset_ap_ler[i]);
      if (r2l < r * r) {
        auto kt = m_offset_pp_ler[i] + static_cast<unsigned int>(s - m_ranges_ler[i + 1].r0);
        double Bx = kt->getBx(vl.X(), vl.Y());
        double By = kt->getBy(vl.X(), vl.Y());
        B.SetXYZ(Bx * ca, -By, Bx * sa); // to the detector frame
      }
    }
  }
  return B;
}

◆ getAperture()

double getAperture	(	double	s,
		std::vector< ApertPoint >::const_iterator	hint ) const

inlineprivate

Returns the beam pipe aperture at given position.

Small number of points again linear search.

Parameters

s	The position in beam-axis coordinate.
hint	Start search from this position

Returns: The beam pipe aperture at given position.

Definition at line 340 of file BFieldComponentQuad.cc.

{
  auto jt = linear_sentinel(jt0, s, [](double s_, const ApertPoint & r) {return s_ <= r.s;});
  const ApertPoint& p1 = *(jt - 1), &p2 = *jt;
  return p1.r + (p2.r - p1.r) / (p2.s - p1.s) * (s - p1.s);
}

◆ getApertureHER()

double getApertureHER ( double s ) const

Returns the HER beam pipe aperture at given position.

Parameters

s	The position in HER beam-axis coordinate.

Returns: The beam pipe aperture at given position.

Definition at line 318 of file BFieldComponentQuad.cc.

{
  int i = getRange(s, m_ranges_her);
  if (i < 0) return 0;
  return getAperture(s, m_offset_ap_her[i]);
}

◆ getApertureLER()

double getApertureLER ( double s ) const

Returns the LER beam pipe aperture at given position.

Parameters

s	The position in LER beam-axis coordinate.

Returns: The beam pipe aperture at given position.

Definition at line 325 of file BFieldComponentQuad.cc.

{
  int i = getRange(s, m_ranges_ler);
  if (i < 0) return 0;
  return getAperture(s, m_offset_ap_ler[i]);
}

◆ getRange()

int getRange	(	double	a,
		const ranges_t &	b ) const

inlineprivate

Search for range occupied by optics since now only for ranges are present use linear search.

Parameters

a	coordinate along beamline
b	vector with ranges with sentinel at the beginning and the end

Returns: the range number if out of ranges return -1

Definition at line 332 of file BFieldComponentQuad.cc.

{
  auto it0 = r.begin() + 1;
  auto it = linear_sentinel(it0, s, [](double s_, const range_t& r_) {return s_ <= r_.r0;});
  if (s > (--it)->r1) return -1;
  return it - it0;
}

◆ initialize()

void initialize ( )

overridevirtual

Initializes the magnetic field component.

This method opens the magnetic field map file.

Magnetic field data structure.

< s in [m]

< element length in [m]

< dipole component in [dimensionless]

< quadrupole component in [1/m]

< skew dipole component in [dimensionless]

< skew quadrupole component in [1/m]

< rotation in [radian]

< horizontal displacement in [m]

< vertical displacement in [m]

fold rotation to/from lense frame to a single matrix multiplicaton and vector addition

Parameters

in	map with angle inside
p0	normalization constant

Returns: structure where rotations are in the matrix form

In case several maps in the same position we can simply sum up all matrices since magnetic field has superposition properties as well as keep only one vector of parameters for each beamline

Parameters

v	first map
a	map to add to the first map

Returns: merged field map

calculate ranges where quadrupole lenses continuously fill the beamline

Parameters

v	lense vector

Returns: vector of ranges

associate ranges with the vector of aperture points

Parameters

ap	the vector of aperture points
v	the vector of ranges

Returns: the vector of iterators for more effective search

associate ranges with the vector of lenses

Parameters

ap	the vector of lenses
v	the vector of ranges

Returns: the vector of iterators which points to the beginning of the continuous area of lenses

Reimplemented from BFieldComponentAbs.

Definition at line 43 of file BFieldComponentQuad.cc.

{
  // check if input name is not empty
  if (m_mapFilenameHER.empty()) {
    B2FATAL("The filename for the HER quadrupole magnetic field component is empty !");
    return;
  }
  if (m_mapFilenameLER.empty()) {
    B2FATAL("The filename for the LER quadrupole magnetic field component is empty !");
    return;
  }
  if (m_apertFilenameHER.empty()) {
    B2FATAL("The filename for the HER beam pipe aperture is empty !");
    return;
  }
  if (m_apertFilenameLER.empty()) {
    B2FATAL("The filename for the LER beam pipe aperture is empty !");
    return;
  }
 
  // check if input files exist
  string fullPathMapHER = FileSystem::findFile("/data/" + m_mapFilenameHER);
  if (!FileSystem::fileExists(fullPathMapHER)) {
    B2FATAL("The HER quadrupole magnetic field map file '" << m_mapFilenameHER << "' could not be found !");
    return;
  }
  string fullPathMapLER = FileSystem::findFile("/data/" + m_mapFilenameLER);
  if (!FileSystem::fileExists(fullPathMapLER)) {
    B2FATAL("The LER quadrupole magnetic field map file '" << m_mapFilenameLER << "' could not be found !");
    return;
  }
  string fullPathMapHERleak = FileSystem::findFile("/data/" + m_mapFilenameHERleak);
  if (!FileSystem::fileExists(fullPathMapHERleak)) {
    B2FATAL("The HERleak quadrupole magnetic field map file '" << m_mapFilenameHERleak << "' could not be found !");
    return;
  }
  string fullPathApertHER = FileSystem::findFile("/data/" + m_apertFilenameHER);
  if (!FileSystem::fileExists(fullPathApertHER)) {
    B2FATAL("The HER aperture file '" << m_apertFilenameHER << "' could not be found !");
    return;
  }
  string fullPathApertLER = FileSystem::findFile("/data/" + m_apertFilenameLER);
  if (!FileSystem::fileExists(fullPathApertLER)) {
    B2FATAL("The LER aperture file '" << m_apertFilenameLER << "' could not be found !");
    return;
  }
 
  //--------------------------------------------------------------
  // Load the field map files
  //--------------------------------------------------------------
  struct ParamPoint {
    double s{0};   
    double L{0};   
    double K0{0};  
    double K1{0};  
    double SK0{0}; 
    double SK1{0}; 
    double ROTATE{0}; 
    double DX{0};   
    double DY{0};   
    /* Note that K parameters used in SAD is multiplied by the element length.
     * Popular definitions are:  K0,SK0[1/m] and K1,SK1[1/m^2]
     */
  };
 
  io::filtering_istream fieldMapFileHER, fieldMapFileLER, fieldMapFileHERleak;
  fieldMapFileHER.push(io::file_source(fullPathMapHER));
  fieldMapFileLER.push(io::file_source(fullPathMapLER));
  fieldMapFileHERleak.push(io::file_source(fullPathMapHERleak));
 
  //Create the parameter map and read the data from the file
  auto readLenseParameters = [](istream & IN) -> vector<ParamPoint> {
    vector<ParamPoint> r;
    string name;
    ParamPoint t;
    while (IN >> name >> t.s >> t.L >> t.K0 >> t.K1 >> t.SK0 >> t.SK1 >> t.ROTATE >> t.DX >> t.DY)
    {
      /* Convert parameters in basf2 default unit [cm].*/
      t.s *= 100;
      t.L *= 100;
      t.DX *= 100;
      t.DY *= 100;
      t.K1 /= 100;
      t.SK1 /= 100;
      r.push_back(t);
    }
    return r;
  };
 
  std::vector<ParamPoint> params_her, params_ler, params_herl;
  params_her = readLenseParameters(fieldMapFileHER);
  params_ler = readLenseParameters(fieldMapFileLER);
  params_herl = readLenseParameters(fieldMapFileHERleak);
 
  //--------------------------------------------------------------
  // Load the aperture map files
  //--------------------------------------------------------------
  auto readAperturePoints = [this](istream & IN) -> vector<ApertPoint> {
    vector<ApertPoint> r;
    ApertPoint t;
    while (IN >> t.s >> t.r)
    {
      /* s and r are in [mm] in Apert?ER.dat. */
      /* Transform parameters in basf2 default unit [cm].*/
      t.s /= 10; t.r /= 10;
      r.push_back(t);
      m_maxr2 = max(m_maxr2, t.r);
    }
    r.push_back({numeric_limits<double>::infinity(), m_maxr2});
    return r;
  };
 
  io::filtering_istream apertFileHER, apertFileLER;
  apertFileHER.push(io::file_source(fullPathApertHER));
  apertFileLER.push(io::file_source(fullPathApertLER));
 
  m_ah = readAperturePoints(apertFileHER);
  m_al = readAperturePoints(apertFileLER);
 
  m_maxr2 *= m_maxr2;
  auto proc3 = [](const vector<ParamPoint>& in, double p0) -> vector<ParamPoint3> {
    vector<ParamPoint3> out;
    out.resize(in.size());
    auto it = out.begin();
    for (auto b = in.begin(); b != in.end(); ++b, ++it)
    {
      ParamPoint3& t = *it;
      t.s = b->s;
      t.L = b->L;
 
      double K0  = b->K0;
      double K1  = b->K1;
      double SK0 = b->SK0;
      double SK1 = b->SK1;
      double DX  = b->DX;
      double DY  = b->DY;
      double k = p0 / t.L;
      K0  *= k;
      K1  *= k;
      SK0 *= k;
      SK1 *= k;
 
#define ROTATE_DIRECTION 1 // 1: default, 0: rotate-off, -1: inversely rotate
#if ROTATE_DIRECTION==0
      double sphi = 0, cphi = 1;
#else
      double sphi, cphi;
      sincos(-b->ROTATE * (M_PI / 180), &sphi, &cphi);
#if ROTATE_DIRECTION==-1
      sphi = -sphi;
#endif
#endif
      double s2phi = 2 * cphi * sphi;
      double c2phi = cphi * cphi - sphi * sphi;
      double tp = DX * SK1 + DY * K1;
      double tm = DY * SK1 - DX * K1;
 
      t.mxx =  K1 * s2phi + SK1 * c2phi;
      t.mxy = -SK1 * s2phi +  K1 * c2phi;
      t.mx0 =  tm * s2phi -  tp * c2phi + SK0 * cphi +  K0 * sphi;
 
      t.myx = -SK1 * s2phi +  K1 * c2phi;
      t.myy = -K1 * s2phi - SK1 * c2phi;
      t.my0 =  tp * s2phi +  tm * c2phi +  K0 * cphi - SK0 * sphi;
    }
    return out;
  };
 
  const double c = Const::speedOfLight / (Unit::m / Unit::s) / 100;
  const double p0_HER = 7.0e+9 / c, p0_LER = 4.0e+9 / c;
 
  m_h3 = proc3(params_her, p0_HER);
  vector<ParamPoint3> hleak3 = proc3(params_herl, p0_HER);
  m_l3 = proc3(params_ler, p0_LER);
  auto merge = [](vector<ParamPoint3>& v, const vector<ParamPoint3>& a) {
    for (const auto& t : a) {
      auto i = upper_bound(v.begin(), v.end(), t.s, [](double s, const ParamPoint3 & b) {return s < b.s;});
      if (i == v.end()) continue;
      ParamPoint3& p = *(i - 1);
      if (p.s == t.s && p.L == t.L)
        p += t;
      else
        v.insert(i, t);
    }
  };
  merge(m_h3, hleak3);
  auto getranges = [](const vector<ParamPoint3>& v) {
    ranges_t r;
    double s0 = v[0].s, smax = v.back().s + v.back().L;
    for (int i = 0, N = v.size(); i < N - 1; i++) {
      const ParamPoint3& t0 = v[i], t1 = v[i + 1];
      double sn = t0.s + t0.L;
      if (abs(sn - t1.s) > 1e-10) {
        r.push_back({s0, sn});
        s0 = t1.s;
      }
    }
    r.push_back({s0, smax});
    return r;
  };
 
  m_ranges_her  = getranges(m_h3);
  m_ranges_ler  = getranges(m_l3);
 
  const double inf = numeric_limits<double>::infinity();
  // add sentinels
  m_ranges_her.insert(m_ranges_her.begin(), { -inf, -inf});
  m_ranges_her.insert(m_ranges_her.end(), {inf, inf});
  m_ranges_ler.insert(m_ranges_ler.begin(), { -inf, -inf});
  m_ranges_ler.insert(m_ranges_ler.end(), {inf, inf});
  auto associate_aperture = [](const vector<ApertPoint>& ap, const ranges_t& v) {
    auto less = [](double s, const ApertPoint & b) {return s < b.s;};
    vector<std::vector<ApertPoint>::const_iterator> res;
    for (auto r : v) {
      auto i0 = upper_bound(ap.begin(), ap.end(), r.r0, less);
      if (i0 == ap.begin() || i0 == ap.end()) continue;
      res.push_back(i0 - 1);
    }
    return res;
  };
  m_offset_ap_her = associate_aperture(m_ah, m_ranges_her);
  m_offset_ap_ler = associate_aperture(m_al, m_ranges_ler);
  auto associate_lenses = [](const vector<ParamPoint3>& ap, const ranges_t& v) {
    vector<std::vector<ParamPoint3>::const_iterator> res;
    for (auto r : v) {
      auto i0 = find_if(ap.begin(), ap.end(), [r](const ParamPoint3 & b) {return abs(b.s - r.r0) < 1e-10;});
      if (i0 == ap.end()) continue;
      res.push_back(i0);
    }
    return res;
  };
  m_offset_pp_her = associate_lenses(m_h3, m_ranges_her);
  m_offset_pp_ler = associate_lenses(m_l3, m_ranges_ler);
}

◆ setApertFilename()

void setApertFilename	(	const std::string &	filenameHER,
		const std::string &	filenameLER )

inline

Sets the filename of aperture definition file.

Parameters

filenameHER	The filename of the aperture definition for HER.
filenameLER	The filename of the aperture definition for LER.

Definition at line 153 of file BFieldComponentQuad.h.

153{ m_apertFilenameHER = filenameHER; m_apertFilenameLER = filenameLER; }

◆ setApertSize()

void setApertSize	(	int	sizeHER,
		int	sizeLER )

inline

Sets the size of the aperture map.

Parameters

sizeHER	The number of points in the HER aperture file.
sizeLER	The number of points in the LER aperture file.

Definition at line 168 of file BFieldComponentQuad.h.

168{ m_apertSizeHER = sizeHER; m_apertSizeLER = sizeLER; }

◆ setMapFilename()

void setMapFilename	(	const std::string &	filenameHER,
		const std::string &	filenameLER,
		const std::string &	filenameHERleak )

inline

Sets the filename of the magnetic field map.

Parameters

filenameHER	The filename of the magnetic field map for HER.
filenameLER	The filename of the magnetic field map for LER.
filenameHERleak	The filename of the magnetic field map for HER (leak field from LER).

Definition at line 146 of file BFieldComponentQuad.h.

146{ m_mapFilenameHER = filenameHER; m_mapFilenameLER = filenameLER; m_mapFilenameHERleak = filenameHERleak; }

◆ setMapSize()

void setMapSize	(	int	sizeHER,
		int	sizeLER,
		int	sizeHERleak )

inline

Sets the size of the magnetic field map.

Parameters

sizeHER	The number of points in the HER field parameters.
sizeLER	The number of points in the LER field parameters.
sizeHERleak	The number of points in the HER field parameters (leak field from LER).

Definition at line 161 of file BFieldComponentQuad.h.

161{ m_mapSizeHER = sizeHER; m_mapSizeLER = sizeLER; m_mapSizeHERleak = sizeHERleak;}

◆ terminate()

virtual void terminate ( )

inlinevirtualinherited

Terminates the magnetic field component.

This method should be used to close files that have been opened in the initialize() method.

Reimplemented in BFieldComponent3d, BFieldComponentBeamline, BFieldComponentKlm1, and BFieldComponentRadial.

Definition at line 66 of file BFieldComponentAbs.h.

66{};

Member Data Documentation

◆ m_ah

std::vector<ApertPoint> m_ah

private

The the aperture parameters for HER.

Definition at line 214 of file BFieldComponentQuad.h.

◆ m_al

std::vector<ApertPoint> m_al

private

The the aperture parameters for LER.

Definition at line 216 of file BFieldComponentQuad.h.

◆ m_apertFilenameHER

std::string m_apertFilenameHER {""}

private

Filename of the aperture for HER.

Definition at line 194 of file BFieldComponentQuad.h.

194{""};

◆ m_apertFilenameLER

std::string m_apertFilenameLER {""}

private

The filename of the aperture for LER.

Definition at line 196 of file BFieldComponentQuad.h.

196{""};

◆ m_apertSizeHER

int m_apertSizeHER {0}

private

The size of the aperture for HER.

Definition at line 204 of file BFieldComponentQuad.h.

204{0};

◆ m_apertSizeLER

int m_apertSizeLER {0}

private

The size of the aperture for LER.

Definition at line 206 of file BFieldComponentQuad.h.

206{0};

◆ m_h3

std::vector<ParamPoint3> m_h3

private

The map for HER.

Definition at line 219 of file BFieldComponentQuad.h.

◆ m_l3

std::vector<ParamPoint3 > m_l3

private

The map for LER.

Definition at line 221 of file BFieldComponentQuad.h.

◆ m_mapFilenameHER

std::string m_mapFilenameHER {""}

private

Magnetic field map of HER.

Definition at line 188 of file BFieldComponentQuad.h.

188{""};

◆ m_mapFilenameHERleak

std::string m_mapFilenameHERleak {""}

private

The filename of the magnetic field map.

Definition at line 192 of file BFieldComponentQuad.h.

192{""};

◆ m_mapFilenameLER

std::string m_mapFilenameLER {""}

private

Magnetic field map of LER.

Definition at line 190 of file BFieldComponentQuad.h.

190{""};

◆ m_mapSizeHER

int m_mapSizeHER {0}

private

The size of the map for HER.

Definition at line 198 of file BFieldComponentQuad.h.

198{0};

◆ m_mapSizeHERleak

int m_mapSizeHERleak {0}

private

The size of the map.

Definition at line 202 of file BFieldComponentQuad.h.

202{0};

◆ m_mapSizeLER

int m_mapSizeLER {0}

private

The size of the map for LER.

Definition at line 200 of file BFieldComponentQuad.h.

200{0};

◆ m_maxr2

double m_maxr2 {0}

private

The square of maximal aperture for fast rejection.

Definition at line 208 of file BFieldComponentQuad.h.

208{0};

◆ m_offset_ap_her

std::vector<std::vector<ApertPoint>::const_iterator> m_offset_ap_her

private

The vector of pointer to accelerate search in aperture for her.

Definition at line 228 of file BFieldComponentQuad.h.

◆ m_offset_ap_ler

std::vector<std::vector<ApertPoint>::const_iterator> m_offset_ap_ler

private

The vector of pointer to accelerate search in aperture for ler.

Definition at line 230 of file BFieldComponentQuad.h.

◆ m_offset_pp_her

std::vector<std::vector<ParamPoint3>::const_iterator> m_offset_pp_her

private

The vector of pointer to accelerate search in maps for her.

Definition at line 224 of file BFieldComponentQuad.h.

◆ m_offset_pp_ler

std::vector<std::vector<ParamPoint3>::const_iterator> m_offset_pp_ler

private

The vector of pointer to accelerate search in maps for ler.

Definition at line 226 of file BFieldComponentQuad.h.

◆ m_ranges_her

ranges_t m_ranges_her

private

ranges vector for HER

Definition at line 210 of file BFieldComponentQuad.h.

◆ m_ranges_ler

ranges_t m_ranges_ler

private

ranges vector for LER

Definition at line 211 of file BFieldComponentQuad.h.

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

geometry/bfieldmap/include/BFieldComponentQuad.h
geometry/bfieldmap/src/BFieldComponentQuad.cc

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ranges_t

Member Function Documentation

◆ calculate()

◆ getAperture()

◆ getApertureHER()

◆ getApertureLER()

◆ getRange()

◆ initialize()

◆ setApertFilename()

◆ setApertSize()

◆ setMapFilename()

◆ setMapSize()

◆ terminate()

Member Data Documentation

◆ m_ah

◆ m_al

◆ m_apertFilenameHER

◆ m_apertFilenameLER

◆ m_apertSizeHER

◆ m_apertSizeLER

◆ m_h3

◆ m_l3

◆ m_mapFilenameHER

◆ m_mapFilenameHERleak

◆ m_mapFilenameLER

◆ m_mapSizeHER

◆ m_mapSizeHERleak

◆ m_mapSizeLER

◆ m_maxr2

◆ m_offset_ap_her

◆ m_offset_ap_ler

◆ m_offset_pp_her

◆ m_offset_pp_ler

◆ m_ranges_her

◆ m_ranges_ler