Box with a cylindrical hole. More...

#include <SolidHole.hh>

Inheritance diagram for Garfield::SolidHole:

Public Member Functions
	SolidHole (const double cx, const double cy, const double cz, const double rup, const double rlow, const double lx, const double ly, const double lz)
	Constructor from centre, upper/lower radii, half-lengths of the box.

	SolidHole (const double cx, const double cy, const double cz, const double rup, const double rlow, const double lx, const double ly, const double lz, const double dx, const double dy, const double dz)

	~SolidHole ()
	Destructor.

bool	IsInside (const double x, const double y, const double z) const override
	Check whether a given point is inside the solid.

bool	GetBoundingBox (double &xmin, double &ymin, double &zmin, double &xmax, double &ymax, double &zmax) const override
	Return the bounding box of the solid.

bool	IsHole () const override
	Return true if the solid is a hole.

void	SetHalfLengthX (const double lx)
	Set the half-length of the box along x.

void	SetHalfLengthY (const double ly)
	Set the half-length of the box along y.

void	SetHalfLengthZ (const double lz)
	Set the half-length of the box along z.

void	SetUpperRadius (const double r)
	Set the radius at z = +lz.

void	SetLowerRadius (const double r)
	Set the radius at z = -lz.

double	GetHalfLengthX () const override
	Return the half-length along x.

double	GetHalfLengthY () const override
	Return the half-length along y.

double	GetHalfLengthZ () const override
	Return the half-length along z.

double	GetUpperRadius () const override
	Return the upper radius (of a hole).

double	GetLowerRadius () const override
	Return the lower radius (of a hole).

void	SetSectors (const unsigned int n)

void	SetAverageRadius (const bool average)

unsigned int	GetSectors () const
	Return the order of the approximating polygon.

bool	GetAverage () const
	Return the state of the "average-radius" flag.

bool	SolidPanels (std::vector< Panel > &panels) override
	Retrieve the surface panels of the solid.

double	GetDiscretisationLevel (const Panel &panel) override
	Retrieve the discretization level of a panel.

Public Member Functions inherited from Garfield::Solid
	Solid ()=delete
	Default constructor.

	Solid (const double cx, const double cy, const double cz, const std::string &name)
	Constructor.

virtual	~Solid ()
	Destructor.

virtual bool	IsInside (const double x, const double y, const double z) const =0
	Check whether a given point is inside the solid.

virtual bool	GetBoundingBox (double &xmin, double &ymin, double &zmin, double &xmax, double &ymax, double &zmax) const =0
	Return the bounding box of the solid.

virtual bool	IsBox () const
	Return true if the solid is a box.

virtual bool	IsTube () const
	Return true if the solid is a tube.

virtual bool	IsSphere () const
	Return true if the solid is a sphere.

virtual bool	IsHole () const
	Return true if the solid is a hole.

virtual bool	IsRidge () const
	Return true if the solid is a ridge.

bool	GetCentre (double &x, double &y, double &z) const
	Retrieve the centre point of the solid.

bool	GetOrientation (double &ctheta, double &stheta, double &cphi, double &sphi) const
	Retrieve the orientation (azimuthal and polar angles) of the solid.

virtual double	GetHalfLengthX () const
	Return the half-length along x.

virtual double	GetHalfLengthY () const
	Return the half-length along y.

virtual double	GetHalfLengthZ () const
	Return the half-length along z.

virtual double	GetInnerRadius () const
	Return the inner radius.

virtual double	GetOuterRadius () const
	Return the outer radius.

virtual double	GetRadius () const
	Return the radius.

virtual double	GetLowerRadius () const
	Return the lower radius (of a hole).

virtual double	GetUpperRadius () const
	Return the upper radius (of a hole).

virtual double	GetRidgeOffset () const
	Return the x-offset of a ridge.

virtual double	GetRidgeHeight () const
	Return the height of a ridge.

unsigned int	GetId () const
	Get the ID of the solid.

virtual bool	SolidPanels (std::vector< Panel > &panels)=0
	Retrieve the surface panels of the solid.

virtual double	GetDiscretisationLevel (const Panel &panel)=0
	Retrieve the discretization level of a panel.

void	SetBoundaryPotential (const double v)
	Apply Dirichlet boundary conditions (fixed voltage).

void	SetBoundaryChargeDensity (const double q)
	Apply fixed-charge boundary conditions.

void	SetBoundaryFloat ()
	Make the potential at the surface of the solid floating.

void	SetBoundaryDielectric ()
	Make the surfaces of the solid dielectric-dielectric interfaces.

void	SetBoundaryParallelField ()

void	SetBoundaryPerpendicularField ()

BoundaryCondition	GetBoundaryConditionType () const
	Retrieve the type of boundary condition.

double	GetBoundaryPotential () const
	Retrieve the potential.

double	GetBoundaryChargeDensity () const
	Retrieve the surface charge density.

void	EnableDebugging (const bool on=true)
	Switch debugging messages on/off.

Additional Inherited Members
Public Types inherited from Garfield::Solid
enum	BoundaryCondition { Voltage = 1 , Charge , Float , Dielectric , DielectricCharge , ParallelField , PerpendicularField }

Protected Member Functions inherited from Garfield::Solid
void	ToLocal (const double x, const double y, const double z, double &u, double &v, double &w) const

void	ToGlobal (const double u, const double v, const double w, double &x, double &y, double &z) const

void	VectorToLocal (const double x, const double y, const double z, double &u, double &v, double &w)
	Transform a vector from global to local coordinates.

void	SetDirection (const double dx, const double dy, const double dz)

Protected Attributes inherited from Garfield::Solid
double	m_cX = 0.
	Centre of the solid.

double	m_cY = 0.

double	m_cZ = 0.

double	m_dX = 0.
	Direction vector.

double	m_dY = 0.

double	m_dZ = 1.

double	m_cPhi = 1.
	Azimuthal angle.

double	m_sPhi = 0.

double	m_cTheta = 1.
	Polar angle.

double	m_sTheta = 0.

std::string	m_className = "Solid"
	Class name.

bool	m_debug = false
	Debug flag.

BoundaryCondition	m_bctype = Voltage
	Type of boundary condition.

double	m_volt = 0.
	Potential at the surface.

double	m_charge = 0.
	Surface charge density.

double	m_eps = 0.
	Dielectric constant.

Detailed Description

Box with a cylindrical hole.

Definition at line 10 of file SolidHole.hh.

Constructor & Destructor Documentation

◆ SolidHole() [1/2]

Garfield::SolidHole::SolidHole	(	const double	cx,
		const double	cy,
		const double	cz,
		const double	rup,
		const double	rlow,
		const double	lx,
		const double	ly,
		const double	lz
	)

Constructor from centre, upper/lower radii, half-lengths of the box.

Definition at line 9 of file SolidHole.cc.

    : Solid(cx, cy, cz, "SolidHole"),
      m_rUp(rup),
      m_rLow(rlow),
      m_lX(lx), 
      m_lY(ly),
      m_lZ(lz) {}

◆ SolidHole() [2/2]

Garfield::SolidHole::SolidHole	(	const double	cx,
		const double	cy,
		const double	cz,
		const double	rup,
		const double	rlow,
		const double	lx,
		const double	ly,
		const double	lz,
		const double	dx,
		const double	dy,
		const double	dz
	)

Constructor from centre, upper/lower radii, half-lengths of the box and orientation.

Definition at line 19 of file SolidHole.cc.

    : SolidHole(cx, cy, cz, rup, rlow, lx, ly, lz) {
  SetDirection(dx, dy, dz);
}

◆ ~SolidHole()

Garfield::SolidHole::~SolidHole ( )

inline

Destructor.

Definition at line 23 of file SolidHole.hh.

23{}

Member Function Documentation

◆ GetAverage()

bool Garfield::SolidHole::GetAverage ( ) const

inline

Return the state of the "average-radius" flag.

Definition at line 62 of file SolidHole.hh.

62{ return m_average; }

◆ GetBoundingBox()

bool Garfield::SolidHole::GetBoundingBox	(	double &	xmin,
		double &	ymin,
		double &	zmin,
		double &	xmax,
		double &	ymax,
		double &	zmax
	)		const

overridevirtual

Return the bounding box of the solid.

Implements Garfield::Solid.

Definition at line 56 of file SolidHole.cc.

                                                                               {
  if (m_cTheta == 1. && m_cPhi == 1.) {
    xmin = m_cX - m_lX;
    xmax = m_cX + m_lX;
    ymin = m_cY - m_lY;
    ymax = m_cY + m_lY;
    zmin = m_cZ - m_lZ;
    zmax = m_cZ + m_lZ;
    return true;
  }
 
  const double dd = sqrt(m_lX * m_lX + m_lY * m_lY + m_lZ * m_lZ);
  xmin = m_cX - dd;
  xmax = m_cX + dd;
  ymin = m_cY - dd;
  ymax = m_cY + dd;
  zmin = m_cZ - dd;
  zmax = m_cZ + dd;
  return true;
}

◆ GetDiscretisationLevel()

double Garfield::SolidHole::GetDiscretisationLevel ( const Panel & panel )

overridevirtual

Retrieve the discretization level of a panel.

Implements Garfield::Solid.

Definition at line 327 of file SolidHole.cc.

                                                           {
  
  // Transform the normal vector to local coordinates.
  double un = 0., vn = 0., wn = 0.;
  VectorToLocal(panel.a, panel.b, panel.c, un, vn, wn);
  // Transform one of the points (first).
  double u1 = 0., v1 = 0., w1 = 0.;
  ToLocal(panel.xv[0], panel.yv[0], panel.zv[0], u1, v1, w1);
  // Identify the vector.
  if (wn > std::max(std::abs(un), std::abs(vn))) {
    return m_dis[0];
  } else if (wn < -std::max(std::abs(un), std::abs(vn))) {
    return m_dis[1];
  } else if (un * u1 + vn * v1 + wn * w1 < 0) {
    return m_dis[2];
  } else if (un > std::max(std::abs(vn), std::abs(wn))) {
    return m_dis[3];
  } else if (un < -std::max(std::abs(vn), std::abs(wn))) {
    return m_dis[4];
  } else if (vn > std::max(std::abs(un), std::abs(wn))) {
    return m_dis[5];
  } else if (vn < -std::max(std::abs(un), std::abs(wn))) {
    return m_dis[6];
  }
  if (m_debug) {
    std::cout << m_className << "::GetDiscretisationLevel:\n"
              << "    Found no match for the panel; returning first value.\n";
  }
  return m_dis[0];
}

◆ GetHalfLengthX()

double Garfield::SolidHole::GetHalfLengthX ( ) const

inlineoverridevirtual

Return the half-length along x.

Reimplemented from Garfield::Solid.

Definition at line 41 of file SolidHole.hh.

41{ return m_lX; }

◆ GetHalfLengthY()

double Garfield::SolidHole::GetHalfLengthY ( ) const

inlineoverridevirtual

Return the half-length along y.

Reimplemented from Garfield::Solid.

Definition at line 42 of file SolidHole.hh.

42{ return m_lY; }

◆ GetHalfLengthZ()

double Garfield::SolidHole::GetHalfLengthZ ( ) const

inlineoverridevirtual

Return the half-length along z.

Reimplemented from Garfield::Solid.

Definition at line 43 of file SolidHole.hh.

43{ return m_lZ; }

◆ GetLowerRadius()

double Garfield::SolidHole::GetLowerRadius ( ) const

inlineoverridevirtual

Return the lower radius (of a hole).

Reimplemented from Garfield::Solid.

Definition at line 45 of file SolidHole.hh.

45{ return m_rLow; }

◆ GetSectors()

unsigned int Garfield::SolidHole::GetSectors ( ) const

inline

Return the order of the approximating polygon.

Definition at line 60 of file SolidHole.hh.

60{ return m_n; }

◆ GetUpperRadius()

double Garfield::SolidHole::GetUpperRadius ( ) const

inlineoverridevirtual

Return the upper radius (of a hole).

Reimplemented from Garfield::Solid.

Definition at line 44 of file SolidHole.hh.

44{ return m_rUp; }

◆ IsHole()

bool Garfield::SolidHole::IsHole ( ) const

inlineoverridevirtual

Return true if the solid is a hole.

Reimplemented from Garfield::Solid.

Definition at line 28 of file SolidHole.hh.

28{ return true; }

◆ IsInside()

bool Garfield::SolidHole::IsInside	(	const double	x,
		const double	y,
		const double	z
	)		const

overridevirtual

Check whether a given point is inside the solid.

Implements Garfield::Solid.

Definition at line 27 of file SolidHole.cc.

                                                                             {
  // Transform the point to local coordinates.
  double u = x, v = y, w = z;
  ToLocal(x, y, z, u, v, w);
 
  if (fabs(u) > m_lX || fabs(v) > m_lY || fabs(w) > m_lZ) {
    if (m_debug) {
      std::cout << "SolidHole::IsInside: (" << x << ", " << y << ", " << z
                << ") is outside.\n";
    }
    return false;
  }
 
  const double r = m_rLow + (w + m_lZ) * (m_rUp - m_rLow) / (2 * m_lZ);
  if (u * u + v * v < r * r) {
    if (m_debug) {
      std::cout << "SolidHole::IsInside: (" << x << ", " << y << ", " << z
                << ") is outside.\n";
    }
    return false;
  }
 
  if (m_debug) {
    std::cout << "SolidHole::IsInside: (" << x << ", " << y << ", " << z
              << ") is inside.\n";
  }
  return false;
}

◆ SetAverageRadius()

void Garfield::SolidHole::SetAverageRadius ( const bool average )

inline

By default, the polygon used for approximating the hole when calculating surface panels is inscribed in a circle of the specified radius. If the "average-radius" flag is activated, then the radius will be interpreted as the mean radius of the polygon that approximates the cylinder.

Definition at line 57 of file SolidHole.hh.

57{ m_average = average; }

◆ SetHalfLengthX()

void Garfield::SolidHole::SetHalfLengthX ( const double lx )

Set the half-length of the box along x.

Definition at line 94 of file SolidHole.cc.

                                              {
  if (lx <= 0.) {
    std::cerr << "SolidHole::SetHalfLengthX: Half-length must be > 0.\n";
    return;
  }
  m_lX = lx;
}

◆ SetHalfLengthY()

void Garfield::SolidHole::SetHalfLengthY ( const double ly )

Set the half-length of the box along y.

Definition at line 102 of file SolidHole.cc.

                                              {
  if (ly <= 0.) {
    std::cerr << "SolidHole::SetHalfLengthY: Half-length must be > 0.\n";
    return;
  }
  m_lY = ly;
}

◆ SetHalfLengthZ()

void Garfield::SolidHole::SetHalfLengthZ ( const double lz )

Set the half-length of the box along z.

Definition at line 110 of file SolidHole.cc.

                                              {
  if (lz <= 0.) {
    std::cerr << "SolidHole::SetHalfLengthZ: Half-length must be > 0.\n";
    return;
  }
  m_lZ = lz;
}

◆ SetLowerRadius()

void Garfield::SolidHole::SetLowerRadius ( const double r )

Set the radius at z = -lz.

Definition at line 86 of file SolidHole.cc.

                                             {
  if (r <= 0.) {
    std::cerr << "SolidHole::SetLowerRadius: Radius must be > 0.\n";
    return;
  }
  m_rLow = r;
}

◆ SetSectors()

void Garfield::SolidHole::SetSectors ( const unsigned int n )

When calculating the surface panels, the hole is approximated as a polygon with a finite number of panels. The number of corners of the polygon equals $4(n - 1)$ . Thus, $n = 2$ will produce a square, $n = 3$ an octagon etc.

Definition at line 118 of file SolidHole.cc.

                                               {
  if (n < 1) {
    std::cerr << "SolidHole::SetSectors: Number must be > 0.\n";
    return;
  }
  m_n = n;
}

◆ SetUpperRadius()

void Garfield::SolidHole::SetUpperRadius ( const double r )

Set the radius at z = +lz.

Definition at line 78 of file SolidHole.cc.

                                             {
  if (r <= 0.) {
    std::cerr << "SolidHole::SetUpperRadius: Radius must be > 0.\n";
    return;
  }
  m_rUp = r;
}

◆ SolidPanels()

bool Garfield::SolidHole::SolidPanels ( std::vector< Panel > & panels )

overridevirtual

Retrieve the surface panels of the solid.

Implements Garfield::Solid.

Definition at line 126 of file SolidHole.cc.

                                                    {
  const auto id = GetId();
  const unsigned int nPanels = panels.size();
  // Direction vector.
  const double fnorm = sqrt(m_dX * m_dX + m_dY * m_dY + m_dZ * m_dZ);
  if (fnorm <= 0) {
    std::cerr << "SolidHole::SolidPanels:\n"
              << "    Zero norm direction vector; no panels generated.\n";
    return false;
  }
 
  // Set the mean or the outer radius.
  double r1 = m_rLow;
  double r2 = m_rUp;
  if (m_average) {
    const double alpha = Pi / (4. * (m_n - 1.));
    const double f = 2. / (1. + asinh(tan(alpha)) * cos(alpha) / tan(alpha));
    r1 *= f;
    r2 *= f;
  }
 
  double xv0, yv0, zv0;
  double xv1, yv1, zv1;
  double xv2, yv2, zv2;
  double xv3, yv3, zv3;
  // Draw the 6 sides of the box, start with the x=xmin face.
  if (m_lY > 0 && m_lZ > 0) {
    ToGlobal(-m_lX, -m_lY, -m_lZ, xv0, yv0, zv0);
    ToGlobal(-m_lX, +m_lY, -m_lZ, xv1, yv1, zv1);
    ToGlobal(-m_lX, +m_lY, +m_lZ, xv2, yv2, zv2);
    ToGlobal(-m_lX, -m_lY, +m_lZ, xv3, yv3, zv3);
    Panel newpanel;
    newpanel.a = -m_cPhi * m_cTheta;
    newpanel.b = -m_sPhi * m_cTheta;
    newpanel.c = +m_sTheta;
    newpanel.xv = {xv0, xv1, xv2, xv3};
    newpanel.yv = {yv0, yv1, yv2, yv3};
    newpanel.zv = {zv0, zv1, zv2, zv3};
    newpanel.colour = 0;
    newpanel.volume = id;
    panels.push_back(std::move(newpanel));
  }
  // The x=xmax face.
  if (m_lX > 0 && m_lY > 0 && m_lZ > 0) {
    ToGlobal(+m_lX, -m_lY, -m_lZ, xv0, yv0, zv0);
    ToGlobal(+m_lX, +m_lY, -m_lZ, xv1, yv1, zv1);
    ToGlobal(+m_lX, +m_lY, +m_lZ, xv2, yv2, zv2);
    ToGlobal(+m_lX, -m_lY, +m_lZ, xv3, yv3, zv3);
    Panel newpanel;
    newpanel.a = m_cPhi * m_cTheta;
    newpanel.b = m_sPhi * m_cTheta;
    newpanel.c = -m_sTheta;
    newpanel.xv = {xv0, xv1, xv2, xv3};
    newpanel.yv = {yv0, yv1, yv2, yv3};
    newpanel.zv = {zv0, zv1, zv2, zv3};
    newpanel.colour = 0;
    newpanel.volume = id;
    panels.push_back(std::move(newpanel));
  }
  // The y=ymin face.
  if (m_lX > 0 && m_lZ > 0) {
    ToGlobal(-m_lX, -m_lY, -m_lZ, xv0, yv0, zv0);
    ToGlobal(+m_lX, -m_lY, -m_lZ, xv1, yv1, zv1);
    ToGlobal(+m_lX, -m_lY, +m_lZ, xv2, yv2, zv2);
    ToGlobal(-m_lX, -m_lY, +m_lZ, xv3, yv3, zv3);
    Panel newpanel;
    newpanel.a = m_sPhi;
    newpanel.b = -m_cPhi;
    newpanel.c = 0;
    newpanel.xv = {xv0, xv1, xv2, xv3};
    newpanel.yv = {yv0, yv1, yv2, yv3};
    newpanel.zv = {zv0, zv1, zv2, zv3};
    newpanel.colour = 0;
    newpanel.volume = id;
    panels.push_back(std::move(newpanel));
  }
  // The y=ymax face.
  if (m_lX > 0 && m_lY > 0 && m_lZ > 0) {
    ToGlobal(-m_lX, +m_lY, -m_lZ, xv0, yv0, zv0);
    ToGlobal(+m_lX, +m_lY, -m_lZ, xv1, yv1, zv1);
    ToGlobal(+m_lX, +m_lY, +m_lZ, xv2, yv2, zv2);
    ToGlobal(-m_lX, +m_lY, +m_lZ, xv3, yv3, zv3);
    Panel newpanel;
    newpanel.a = -m_sPhi;
    newpanel.b = m_cPhi;
    newpanel.c = 0;
    newpanel.xv = {xv0, xv1, xv2, xv3};
    newpanel.yv = {yv0, yv1, yv2, yv3};
    newpanel.zv = {zv0, zv1, zv2, zv3};
    newpanel.colour = 0;
    newpanel.volume = id;
    panels.push_back(std::move(newpanel));
  }
  const double phi0 = -0.5 * HalfPi;
  const double dphi = HalfPi / double(m_n - 1);
  // The faces at constant z have a hole, and are drawn in parts.
  for (int iside = -1; iside <= 1; iside += 2) {
    const double r = iside == -1 ? r1 : r2;
    const double w = m_lZ * iside;
    Panel newpanel;
    newpanel.a = iside * m_cPhi * m_sTheta;
    newpanel.b = iside * m_sPhi * m_sTheta;
    newpanel.c = iside * m_cTheta;
    newpanel.colour = 0;
    newpanel.volume = id;
    // Loop over the panels.
    for (unsigned int i = 0; i < m_n - 1; ++i) {
      // The panels for x=xmax.
      const double phi1 = phi0 + dphi * i;
      const double phi2 = phi1 + dphi;
      const double t1 = tan(phi1);
      const double t2 = tan(phi2);
      ToGlobal(r * cos(phi1), r * sin(phi1), w, xv0, yv0, zv0);
      ToGlobal(r * cos(phi2), r * sin(phi2), w, xv3, yv3, zv3);
      ToGlobal(m_lX, m_lY * t1, w, xv1, yv1, zv1);
      ToGlobal(m_lX, m_lY * t2, w, xv2, yv2, zv2);
      newpanel.xv = {xv0, xv1, xv2, xv3};
      newpanel.yv = {yv0, yv1, yv2, yv3};
      newpanel.zv = {zv0, zv1, zv2, zv3};
      panels.push_back(newpanel);
      // The panels for y=ymax.
      const double phi3 = phi1 + HalfPi;
      const double phi4 = phi3 + dphi;
      ToGlobal(r * cos(phi3), r * sin(phi3), w, xv0, yv0, zv0);
      ToGlobal(r * cos(phi4), r * sin(phi4), w, xv3, yv3, zv3);
      ToGlobal(-m_lX * t1, m_lY, w, xv1, yv1, zv1);
      ToGlobal(-m_lX * t2, m_lY, w, xv2, yv2, zv2);
      newpanel.xv = {xv0, xv1, xv2, xv3};
      newpanel.yv = {yv0, yv1, yv2, yv3};
      newpanel.zv = {zv0, zv1, zv2, zv3};
      panels.push_back(newpanel);
      // The panels for x=xmin.
      const double phi5 = phi3 + HalfPi;
      const double phi6 = phi5 + dphi;
      ToGlobal(r * cos(phi5), r * sin(phi5), w, xv0, yv0, zv0);
      ToGlobal(r * cos(phi6), r * sin(phi6), w, xv3, yv3, zv3);
      ToGlobal(-m_lX, -m_lY * t1, w, xv1, yv1, zv1);
      ToGlobal(-m_lX, -m_lY * t2, w, xv2, yv2, zv2);
      newpanel.xv = {xv0, xv1, xv2, xv3};
      newpanel.yv = {yv0, yv1, yv2, yv3};
      newpanel.zv = {zv0, zv1, zv2, zv3};
      panels.push_back(newpanel);
      // The panels for y=ymin.
      const double phi7 = phi5 + HalfPi;
      const double phi8 = phi7 + dphi;
      ToGlobal(r * cos(phi7), r * sin(phi7), w, xv0, yv0, zv0);
      ToGlobal(r * cos(phi8), r * sin(phi8), w, xv3, yv3, zv3);
      ToGlobal(m_lX * t1, -m_lY, w, xv1, yv1, zv1);
      ToGlobal(m_lX * t2, -m_lY, w, xv2, yv2, zv2);
      newpanel.xv = {xv0, xv1, xv2, xv3};
      newpanel.yv = {yv0, yv1, yv2, yv3};
      newpanel.zv = {zv0, zv1, zv2, zv3};
      panels.push_back(newpanel);
    }
  }
  // The panels of the central cylinder, compute the projection angles.
  const double alpha = atan2((r1 - r2) * cos(Pi / (4 * (m_n - 1))), 
                             2 * m_lZ);
  const double ci = cos(alpha);
  const double si = sin(alpha);
  // Initialise loop.
  ToGlobal(r1 * cos(phi0), r1 * sin(phi0), -m_lZ, xv0, yv0, zv0);
  ToGlobal(r2 * cos(phi0), r2 * sin(phi0), +m_lZ, xv1, yv1, zv1);
  // Go around the cylinder.
  const unsigned int nPoints = 4 * m_n - 3;
  for (unsigned int i = 1; i < nPoints; ++i) {
    // Bottom and top of the line along the axis of the cylinder.
    const double phi = phi0 + dphi * i;
    ToGlobal(r2 * cos(phi), r2 * sin(phi), +m_lZ, xv2, yv2, zv2);
    ToGlobal(r1 * cos(phi), r1 * sin(phi), -m_lZ, xv3, yv3, zv3);
    // Store the plane.
    Panel newpanel;
    const double phim = phi0 + dphi * (i - 0.5);
    const double cm = cos(phim);
    const double sm = sin(phim);
    newpanel.a = -m_cPhi * m_cTheta * cm * ci +
                  m_sPhi *            sm * ci -
                  m_cPhi * m_sTheta      * si;
    newpanel.b = -m_sPhi * m_cTheta * cm * ci -
                  m_cPhi *            sm * ci -
                  m_sPhi * m_sTheta      * si;
    newpanel.c = m_sTheta * cm * ci - m_cTheta * si;
    newpanel.xv = {xv0, xv1, xv2, xv3};
    newpanel.yv = {yv0, yv1, yv2, yv3};
    newpanel.zv = {zv0, zv1, zv2, zv3};
    newpanel.colour = 0;
    newpanel.volume = id;
    panels.push_back(std::move(newpanel));
    // Shift the points.
    xv0 = xv3;
    yv0 = yv3;
    zv0 = zv3;
    xv1 = xv2;
    yv1 = yv2;
    zv1 = zv2;
  }
  std::cout << "SolidHole::SolidPanels: " << panels.size() - nPanels
            << " panels.\n";
  return true;
}

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SolidHole() [1/2]

◆ SolidHole() [2/2]

◆ ~SolidHole()

Member Function Documentation

◆ GetAverage()

◆ GetBoundingBox()

◆ GetDiscretisationLevel()

◆ GetHalfLengthX()

◆ GetHalfLengthY()

◆ GetHalfLengthZ()

◆ GetLowerRadius()

◆ GetSectors()

◆ GetUpperRadius()

◆ IsHole()

◆ IsInside()

◆ SetAverageRadius()

◆ SetHalfLengthX()

◆ SetHalfLengthY()

◆ SetHalfLengthZ()

◆ SetLowerRadius()

◆ SetSectors()

◆ SetUpperRadius()

◆ SolidPanels()