Trk::BevelledCylinderVolumeBounds Class Reference

Bounds for a cylindrical Volume, the decomposeToSurfaces method creates a vector of up to 6 surfaces: More...

#include <BevelledCylinderVolumeBounds.h>

Inheritance diagram for Trk::BevelledCylinderVolumeBounds:

Collaboration diagram for Trk::BevelledCylinderVolumeBounds:

Public Member Functions
	BevelledCylinderVolumeBounds ()
	Default Constructor.
	BevelledCylinderVolumeBounds (double rinner, double router, double halfPhiSector, double halez, int type)
	Constructor - cylinder segment bevelled in R.
	BevelledCylinderVolumeBounds (const BevelledCylinderVolumeBounds &cylbo)
	Copy Constructor.
virtual	~BevelledCylinderVolumeBounds ()
	Destructor.
BevelledCylinderVolumeBounds &	operator= (const BevelledCylinderVolumeBounds &cylbo)
	Assignment operator.
BevelledCylinderVolumeBounds *	clone () const override
	Virtual constructor.
bool	inside (const Amg::Vector3D &, double tol=0.) const override
	This method checks if position in the 3D volume frame is inside the cylinder.
virtual std::vector< std::unique_ptr< Trk::Surface > >	decomposeToSurfaces (const Amg::Transform3D &transform) override
	Method to decompose the Bounds into boundarySurfaces.
ObjectAccessor	boundarySurfaceAccessor (const Amg::Vector3D &gp, const Amg::Vector3D &dir, bool forceInside=false) const override
	Provide accessor for BoundarySurfaces.
double	innerRadius () const
	This method returns the inner radius.
double	outerRadius () const
	This method returns the outer radius.
double	mediumRadius () const
	This method returns the medium radius.
double	deltaRadius () const
	This method returns the delta radius.
double	halfPhiSector () const
	This method returns the halfPhiSector angle.
double	halflengthZ () const
	This method returns the halflengthZ.
double	thetaMinus () const
	This method returns the thetaMinus.
double	thetaPlus () const
	This method returns the thetaPlus.
int	type () const
	This method returns the type.
MsgStream &	dump (MsgStream &sl) const override
	Output Method for MsgStream.
std::ostream &	dump (std::ostream &sl) const override
	Output Method for std::ostream.

Private Member Functions
std::shared_ptr< CylinderBounds >	innerBevelledCylinderBounds () const
	This method returns the associated BevelledCylinderBounds of the inner BevelledCylinderSurfaces.
std::shared_ptr< CylinderBounds >	outerBevelledCylinderBounds () const
	This method returns the associated BevelledCylinderBounds of the outer BevelledCylinderSurfaces.
std::shared_ptr< RectangleBounds >	innerBevelledPlaneBounds () const
	This method returns the associated plane surface bounds of the inner bevelled surface.
std::shared_ptr< RectangleBounds >	outerBevelledPlaneBounds () const
	This method returns the associated BevelledCylinderBounds of the outer BevelledCylinderSurfaces.
std::shared_ptr< EllipseBounds >	bottomEllipseBounds () const
	This method returns the associated EllipseBounds for the bottom/top EllipseSurface.
std::shared_ptr< EllipseBounds >	topEllipseBounds () const
	This method returns the associated EllipseBounds for the bottom/top EllipseSurface.
std::shared_ptr< CylinderBounds >	innerCylinderBounds () const
	This method returns the associated CylinderBounds of the inner CylinderSurfaces.
std::shared_ptr< CylinderBounds >	outerCylinderBounds () const
	This method returns the associated CylinderBounds of the outer CylinderSurfaces.
std::shared_ptr< DiscBounds >	discBounds () const
	This method returns the associated DiscBounds for the bottom/top DiscSurface.
Volume *	subtractedVolume () const
	This method returns the bevelled area volume.
std::shared_ptr< TrapezoidBounds >	sectorTrdBounds () const
	This method returns the associated PlaneBounds limiting a sectoral BevelledCylinderVolume.
std::shared_ptr< RectangleBounds >	sectorPlaneBounds () const
void	createBoundarySurfaceAccessors ()
	Private method to construct the accessors.

Private Attributes
double	m_innerRadius
double	m_outerRadius
double	m_halfPhiSector
double	m_halfZ
double	m_thetaMinus
double	m_thetaPlus
int	m_type
BevelledCylinderVolumeBoundaryAccessors	m_boundaryAccessors
	Accessors for Boundary surface access - static is not possible due to mismatched delete() / free () with TrkMagFieldUtils.
CxxUtils::CachedUniquePtr< Trk::Volume >	m_subtractedVolume

Static Private Attributes
static const double	s_numericalStable
	numerical stability

Detailed Description

Bounds for a cylindrical Volume, the decomposeToSurfaces method creates a vector of up to 6 surfaces:

case A) 3 Surfaces (full cylindrical tube): BoundarySurfaceFace [index]:

• negativeFaceXY [0] : Trk::DiscSurface with \( r_{inner}=0 \), parallel to \( xy \) plane at negative \( z \)
• positiveFaceXY [1] : Trk::DiscSurface with \( r_{inner}=0 \), parallel to \( xy \) plane at positive \( z \)
• cylinderCover [2] : Trk::CylinderSurface confining the Trk::Volume

case B) 4 Surfaces (tube with inner and outer radius): BoundarySurfaceFace [index]:

• negativeFaceXY [0] : Trk::DiscSurface with \( r_{inner}>0 \), parallel to \( xy \) plane at negative \( z \)
• positiveFaceXY [1] : Trk::DiscSurface with \( r_{inner}>0 \), parallel to \( xy \) plane at positive \( z \)
• tubeOuterCover [2] : Trk::CylinderSurface with \( r = r_{outer} \)
• tubeInnerCover [3] : Trk::CylinderSurface with \( r = r_{inner} \)

case C) 6 Surfaces (sectoral tube with inner and outer radius): BoundarySurfaceFace [index]:

• negativeFaceXY [0] : Trk::DiscSurface with \( r_{inner}>0 \) and \( \phi < \pi \), parallel to \( xy \) plane at negative \( z \)
• positiveFaceXY [1] : Trk::DiscSurface with \( r_{inner}>0 \) and \( \phi < \pi \), parallel to \( xy \) plane at positive \( z \)
• tubeSectorOuterCover [2] : Trk::CylinderSurface with \( r = r_{outer} \)
• tubeSectorInnerCover [3] : Trk::CylinderSurface with \( r = r_{inner} \)
• tubeSectorNegativePhi [4] : Rectangular Trk::PlaneSurface attached to [0] and [1] at negative \( \phi \)
• tubeSectorNegativePhi [5] : Rectangular Trk::PlaneSurface attached to [0] and [1] at positive \( \phi \)

case D) 6 Surfaces (sectoral bevelled tube with inner and/or outer radius replaced by plane surface): BoundarySurfaceFace [index]:

• negativeFaceXY [0] : Trk::DiscSurface with \( r_{inner}>0 \) and \( \phi < \pi \), parallel to \( xy \) plane at negative \( z \)
• positiveFaceXY [1] : Trk::DiscSurface with \( r_{inner}>0 \) and \( \phi < \pi \), parallel to \( xy \) plane at positive \( z \)
• tubeSectorOuterCover [2] : Trk::CylinderSurface with \( r = r_{outer} \) OR rectangular plane surface
• tubeSectorInnerCover [3] : Trk::CylinderSurface with \( r = r_{inner} \) OR rectangular plane surface
• tubeSectorNegativePhi [4] : Rectangular Trk::PlaneSurface attached to [0] and [1] at negative \( \phi \)
• tubeSectorNegativePhi [5] : Rectangular Trk::PlaneSurface attached to [0] and [1] at positive \( \phi \)

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Definition at line 100 of file BevelledCylinderVolumeBounds.h.

Constructor & Destructor Documentation

BevelledCylinderVolumeBounds() [1/3]

Trk::BevelledCylinderVolumeBounds::BevelledCylinderVolumeBounds

(

)

Default Constructor.

Definition at line 34 of file BevelledCylinderVolumeBounds.cxx.

  : VolumeBounds()
  , m_innerRadius(0.)
  , m_outerRadius(0.)
  , m_halfPhiSector(0.)
  , m_halfZ(0.)
  , m_thetaMinus(0.)
  , m_thetaPlus(0.)
  , m_type(-1)
  , m_boundaryAccessors()
  , m_subtractedVolume(nullptr)
{}

BevelledCylinderVolumeBounds() [2/3]

Trk::BevelledCylinderVolumeBounds::BevelledCylinderVolumeBounds	(	double	rinner,
		double	router,
		double	halfPhiSector,
		double	halez,
		int	type )

Constructor - cylinder segment bevelled in R.

Definition at line 47 of file BevelledCylinderVolumeBounds.cxx.

  : VolumeBounds()
  , m_innerRadius(std::abs(rinner))
  , m_outerRadius(std::abs(router))
  , m_halfPhiSector(haphi)
  , m_halfZ(std::abs(halez))
  , m_thetaMinus(0.)
  , m_thetaPlus(0.)
  , m_type(type)
  , m_boundaryAccessors()
  , m_subtractedVolume(nullptr)
{}

BevelledCylinderVolumeBounds() [3/3]

Trk::BevelledCylinderVolumeBounds::BevelledCylinderVolumeBounds

(

const BevelledCylinderVolumeBounds &

cylbo

)

Copy Constructor.

Definition at line 65 of file BevelledCylinderVolumeBounds.cxx.

  : VolumeBounds()
  , m_innerRadius(cylbo.m_innerRadius)
  , m_outerRadius(cylbo.m_outerRadius)
  , m_halfPhiSector(cylbo.m_halfPhiSector)
  , m_halfZ(cylbo.m_halfZ)
  , m_thetaMinus(cylbo.m_thetaMinus)
  , m_thetaPlus(cylbo.m_thetaPlus)
  , m_type(cylbo.m_type)
  , m_boundaryAccessors()
  , m_subtractedVolume(nullptr)
{}

~BevelledCylinderVolumeBounds()

Trk::BevelledCylinderVolumeBounds::~BevelledCylinderVolumeBounds ( )

virtualdefault

Destructor.

Member Function Documentation

bottomEllipseBounds()

std::shared_ptr< Trk::EllipseBounds > Trk::BevelledCylinderVolumeBounds::bottomEllipseBounds ( ) const

private

This method returns the associated EllipseBounds for the bottom/top EllipseSurface.

Definition at line 457 of file BevelledCylinderVolumeBounds.cxx.

{
  return std::make_shared<Trk::EllipseBounds>(
    m_innerRadius / cos(m_thetaMinus),
    m_innerRadius,
    m_outerRadius / cos(m_thetaMinus),
    m_outerRadius,
    m_halfPhiSector);
}

boundarySurfaceAccessor()

Trk::ObjectAccessor Trk::BevelledCylinderVolumeBounds::boundarySurfaceAccessor ( const Amg::Vector3D & gp, const Amg::Vector3D & dir, bool forceInside = false ) const

overridevirtual

Provide accessor for BoundarySurfaces.

Implements Trk::VolumeBounds.

Definition at line 249 of file BevelledCylinderVolumeBounds.cxx.

{
  // the tube case - most likely
  if (m_innerRadius != 0. && std::abs(m_halfPhiSector - M_PI) < s_numericalStable) {
    // prepare the data
    double posZ = gp.z();
    double posR = gp.perp();
    // difference Vector
    Amg::Vector3D diff(gp + dir);
    // differences
    double deltaZ = diff.z() - posZ;
    double deltaR = diff.perp() - posR;
 
    // the isOnSurface cases + switchers (that change with the cases)
    bool isOnFace = false;
    bool intersectionIndicator = (deltaR > 0.);
    bool choiceIndicator = false;
 
    // on surface or look-a-likes
    // on zMin or slightly outside
    if (
      std::abs(posZ + m_halfZ) < s_numericalStable ||
      (posZ < (-m_halfZ) && deltaZ > 0.)) {
      isOnFace = true;
    } else if (
      std::abs(posZ - m_halfZ) < s_numericalStable ||
      (posZ > m_halfZ && deltaZ < 0.)) {
      // on zMax or slighly outside
      isOnFace = true;
    } else if (
      std::abs(posR - m_innerRadius) < s_numericalStable ||
      (posR < m_innerRadius && deltaR > 0.)) {
      // on innerRadius or slightly outside
      isOnFace = true;
      choiceIndicator =
        (deltaZ > 0.); // the side choice indicator <========== WRONG ==========
    } else if (
      std::abs(posR - m_outerRadius) < s_numericalStable ||
      (posR > m_outerRadius && deltaR < 0.)) {
      // on outRadius or slightly outside
      isOnFace = true;
      choiceIndicator =
        (deltaZ > 0.); // the side choice indicator <========== WRONG ==========
    }
 
    // the onSurface case
    // =================================================================================
    if (isOnFace) {
      if (intersectionIndicator) {
        // intersect the Rmax
        Trk::BevelledBoundaryIntersector intersectRmax(
          posR, posZ, deltaZ / deltaR, m_outerRadius);
        double zOfIntersect = intersectRmax.yOfX;
        // now check if the intersect is inside m_halfZ
        if (std::abs(zOfIntersect) <= m_halfZ)
          return {(choiceIndicator || zOfIntersect > 0.)
                      ? m_boundaryAccessors.bevelledtubeAccessor(
                            Trk::BevelledTubeRincreaseZincrease)
                      : m_boundaryAccessors.bevelledtubeAccessor(
                            Trk::BevelledTubeRincreaseZdecrease)};
        // if the intersect is outside
        return {(choiceIndicator || zOfIntersect > 0.)
                    ? m_boundaryAccessors.bevelledtubeAccessor(
                          Trk::BevelledTubeZincreaseRincrease)
                    : m_boundaryAccessors.bevelledtubeAccessor(
                          Trk::BevelledTubeZdecreaseRincrease)};
      }
      // intersect the Rmin
      Trk::BevelledBoundaryIntersector intersectRmin(
        posR, posZ, deltaZ / deltaR, m_innerRadius);
      double zOfIntersect = intersectRmin.yOfX;
      // now check if the intersect is inside m_halfZ
      if (std::abs(zOfIntersect) <= m_halfZ)
        return {(choiceIndicator || zOfIntersect > 0.)
                    ? m_boundaryAccessors.bevelledtubeAccessor(
                          Trk::BevelledTubeRdecreaseZincrease)
                    : m_boundaryAccessors.bevelledtubeAccessor(
                          Trk::BevelledTubeRdecreaseZdecrease)};
      // if the intersect is outside
      return {(choiceIndicator || zOfIntersect > 0.)
                  ? m_boundaryAccessors.bevelledtubeAccessor(
                        Trk::BevelledTubeZincreaseRdecrease)
                  : m_boundaryAccessors.bevelledtubeAccessor(
                        Trk::BevelledTubeZdecreaseRdecrease)};
    }
    // =================================================================================================
 
    // ======================= the inside/outside part remains
    // =========================================
    //  (a) outside cases
    if (posR < m_innerRadius && deltaR < 0.)
      return {m_boundaryAccessors.bevelledtubeAccessor(
          Trk::BevelledTubeOutsideRminRdecrease)};
    if (posR > m_outerRadius && deltaR > 0.)
      return {m_boundaryAccessors.bevelledtubeAccessor(
          Trk::BevelledTubeOutsideRmaxRincrease)};
    if (posZ < -m_halfZ && deltaZ < 0.)
      return {m_boundaryAccessors.bevelledtubeAccessor(
          Trk::BevelledTubeOutsideZminZdecrease)};
    if (posZ > m_halfZ && deltaZ > 0.)
      return {m_boundaryAccessors.bevelledtubeAccessor(
          Trk::BevelledTubeOutsideZmaxZincrease)};
    // (b) inside cases
    // the increase R case
    if (deltaR > 0.) {
      // solve the linear equation for the outer Radius
      Trk::BevelledBoundaryIntersector intersectRmax(
        posR, posZ, deltaZ / deltaR, m_outerRadius);
      double zOfIntersect = intersectRmax.yOfX;
 
      if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect > 0.)
        return {m_boundaryAccessors.bevelledtubeAccessor(
            Trk::BevelledTubeRincreaseZincrease)};
      if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect < 0.)
        return {m_boundaryAccessors.bevelledtubeAccessor(
            Trk::BevelledTubeRincreaseZdecrease)};
      if (std::abs(zOfIntersect) > m_halfZ && zOfIntersect < 0.)
        return {m_boundaryAccessors.bevelledtubeAccessor(
            Trk::BevelledTubeZdecreaseRincrease)};
      if (std::abs(zOfIntersect) > m_halfZ && zOfIntersect > 0.)
        return {m_boundaryAccessors.bevelledtubeAccessor(
            Trk::BevelledTubeZincreaseRincrease)};
 
    } else {
      // solve the linear equation for the inner Radius
      Trk::BevelledBoundaryIntersector intersectRmin(
        posR, posZ, deltaZ / deltaR, m_innerRadius);
      double zOfIntersect = intersectRmin.yOfX;
 
      if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect > 0.)
        return {m_boundaryAccessors.bevelledtubeAccessor(
            Trk::BevelledTubeRdecreaseZincrease)};
      if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect < 0.)
        return {m_boundaryAccessors.bevelledtubeAccessor(
            Trk::BevelledTubeRdecreaseZdecrease)};
      if (std::abs(zOfIntersect) > m_halfZ && zOfIntersect > 0.)
        return {m_boundaryAccessors.bevelledtubeAccessor(
            Trk::BevelledTubeZincreaseRdecrease)};
      return {m_boundaryAccessors.bevelledtubeAccessor(
          Trk::BevelledTubeZdecreaseRdecrease)};
    }
  }
  // the cylinder case
  if (m_innerRadius == 0. && std::abs(m_halfPhiSector - M_PI) < 10e-3) {
 
    double posZ = gp.z();
    double posR = gp.perp();
    // difference Vector
    Amg::Vector3D diff(gp + dir);
    // differences
    double deltaZ = diff.z() - posZ;
    double deltaR = diff.perp() - posR;
 
    // solve the linear equation for the cylinder Radius
    Trk::BevelledBoundaryIntersector intersectR(
      posR, posZ, deltaZ / deltaR, m_outerRadius);
    //  the intersection point
    double zOfIntersect = intersectR.yOfX;
 
    if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect > 0.)
      return {m_boundaryAccessors.bevelledcylinderAccessor(
          Trk::BevelledCylinderZincrease)};
    if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect < 0.)
      return {m_boundaryAccessors.bevelledcylinderAccessor(
          Trk::BevelledCylinderZdecrease)};
    if (std::abs(zOfIntersect) > m_halfZ && zOfIntersect > 0.)
      return {m_boundaryAccessors.bevelledcylinderAccessor(
          Trk::BevelledCylinderPositiveFace)};
    return {m_boundaryAccessors.bevelledcylinderAccessor(
        Trk::BevelledCylinderNegativeFace)};
  }
  // the sectoral cylinder case
  if (m_innerRadius != 0. && std::abs(m_halfPhiSector - M_PI) > 10e-3)
    return {m_boundaryAccessors.sectoralBevelledCylinderAccessor(
        Trk::StandardSectoralBevelledCylinder)};
  // it remains the sectoral tube case
  return {m_boundaryAccessors.sectoralBevelledTubeAccessor(
      Trk::StandardSectoralBevelledTube)};
}

clone()

BevelledCylinderVolumeBounds * Trk::BevelledCylinderVolumeBounds::clone ( ) const

inlineoverridevirtual

Virtual constructor.

Implements Trk::VolumeBounds.

Definition at line 217 of file BevelledCylinderVolumeBounds.h.

 { return new BevelledCylinderVolumeBounds(*this); }

createBoundarySurfaceAccessors()

void Trk::BevelledCylinderVolumeBounds::createBoundarySurfaceAccessors ( )

private

Private method to construct the accessors.

decomposeToSurfaces()

std::vector< std::unique_ptr< Trk::Surface > > Trk::BevelledCylinderVolumeBounds::decomposeToSurfaces ( const Amg::Transform3D & transform )

overridevirtual

Method to decompose the Bounds into boundarySurfaces.

Implements Trk::VolumeBounds.

Definition at line 99 of file BevelledCylinderVolumeBounds.cxx.

{
  auto retsf = std::vector<std::unique_ptr<Trk::Surface>>();
  // memory optimisation (reserve a save number of 20)
  retsf.reserve(6);
 
  Amg::RotationMatrix3D discRot(transform.rotation());
  Amg::Vector3D cylCenter(transform.translation());
 
  // Lazy init m_m_subtractedVolume
  if (m_type > -1 && !m_subtractedVolume) {
    m_subtractedVolume.set(std::unique_ptr<Trk::Volume>(subtractedVolume()));
  }
 
  // bottom Ellipse/Disc (negative z)
  if (m_type < 0)
    retsf.push_back(std::make_unique<Trk::PlaneSurface>(
      Amg::Transform3D(
        (discRot *
         Amg::AngleAxis3D(-m_thetaMinus + M_PI, Amg::Vector3D(0., 1., 0.))) *
        Amg::Translation3D(
          cylCenter - (halflengthZ() - m_outerRadius * tan(m_thetaMinus)) *
                        discRot.col(2))),
      bottomEllipseBounds()));
  else {
    if (m_subtractedVolume) {
      auto subtrVol = std::make_unique<Trk::Volume>(*m_subtractedVolume);
      Trk::DiscSurface bottomDisc(
          Amg::Transform3D(
              transform * Amg::AngleAxis3D(M_PI, Amg::Vector3D(1., 0., 0.)) *
              Amg::Translation3D(Amg::Vector3D(0., 0., halflengthZ()))),
          discBounds());
      retsf.push_back(std::make_unique<Trk::SubtractedDiscSurface>(
          bottomDisc, std::make_shared<Trk::VolumeExcluder>(std::move(subtrVol)), false));
    } else
      retsf.push_back(std::make_unique<Trk::DiscSurface>(
          Amg::Transform3D(
              transform * Amg::AngleAxis3D(M_PI, Amg::Vector3D(1., 0., 0.)) *
              Amg::Translation3D(Amg::Vector3D(0., 0., halflengthZ()))),
          discBounds()));
  }
 
  // top Ellipse/Disc (positive z)
  if (m_type < 0)
    retsf.push_back(std::make_unique<Trk::PlaneSurface>(
      Amg::Transform3D(
        discRot * Amg::AngleAxis3D(m_thetaPlus, Amg::Vector3D(0., 1., 0.)) *
        Amg::Translation3D(
          cylCenter +
          (halflengthZ() - m_outerRadius * tan(m_thetaPlus)) * discRot.col(2))),
      topEllipseBounds()));
  else {
    if (m_subtractedVolume) {
      auto subtrVol = std::make_unique<Trk::Volume>(*m_subtractedVolume);
      Trk::DiscSurface topDisc(
        Amg::Transform3D(
          transform * Amg::Translation3D(Amg::Vector3D(0., 0., halflengthZ()))),
        discBounds());
      retsf.push_back(std::make_unique<Trk::SubtractedDiscSurface>(
        topDisc, std::make_shared<Trk::VolumeExcluder>(std::move(subtrVol)), false));
    } else
      retsf.push_back(std::make_unique<Trk::DiscSurface>(
        Amg::Transform3D(
          transform * Amg::Translation3D(Amg::Vector3D(0., 0., halflengthZ()))),
        discBounds()));
  }
 
  // outer BevelledCylinder/Plane
  if (m_type < 0)
    retsf.push_back(std::make_unique<Trk::CylinderSurface>(
      Amg::Transform3D(transform), outerBevelledCylinderBounds()));
  else if (m_type < 2)
    retsf.push_back(std::make_unique<Trk::CylinderSurface>(
      Amg::Transform3D(transform), outerCylinderBounds()));
  else
    retsf.push_back(std::make_unique<Trk::PlaneSurface>(
      Amg::Transform3D(
        transform *
        Amg::Translation3D(Amg::Vector3D(this->outerRadius(), 0., 0.)) *
        Amg::AngleAxis3D(-90 * Gaudi::Units::deg, Amg::Vector3D(0., 0., 1.)) *
        Amg::AngleAxis3D(-90. * Gaudi::Units::deg, Amg::Vector3D(1., 0., 0.))),
      outerBevelledPlaneBounds()));
 
  // inner BevelledCylinder/Plane
  if (innerRadius() > s_numericalStable) {
    if (m_type < 1)
      retsf.push_back(std::make_unique<Trk::CylinderSurface>(
        Amg::Transform3D(transform), innerBevelledCylinderBounds()));
    else if (m_type == 2)
      retsf.push_back(std::make_unique<Trk::CylinderSurface>(
        Amg::Transform3D(transform), innerCylinderBounds()));
    else
      retsf.push_back(std::make_unique<Trk::PlaneSurface>(
        Amg::Transform3D(
          transform *
          Amg::Translation3D(Amg::Vector3D(this->innerRadius(), 0., 0.)) *
          Amg::AngleAxis3D(+90 * Gaudi::Units::deg, Amg::Vector3D(0., 0., 1.)) *
          Amg::AngleAxis3D(
            -90. * Gaudi::Units::deg, Amg::Vector3D(1., 0., 0.))),
        innerBevelledPlaneBounds()));
  }
 
  if (std::abs(halfPhiSector() - M_PI) > s_numericalStable) {
    if (m_type < 0) {
      // sectorPlane 1 (negative phi)
      retsf.push_back(std::make_unique<Trk::PlaneSurface>(
        Amg::Transform3D(
          transform *
          Amg::AngleAxis3D(-halfPhiSector(), Amg::Vector3D(0., 0., 1.)) *
          Amg::Translation3D(Amg::Vector3D(mediumRadius(), 0., 0.)) *
          Amg::AngleAxis3D(M_PI / 2, Amg::Vector3D(1., 0., 0.))),
        sectorTrdBounds()));
      // sectorPlane 2 (positive phi)
      retsf.push_back(std::make_unique<Trk::PlaneSurface>(
        Amg::Transform3D(
          transform *
          Amg::AngleAxis3D(halfPhiSector(), Amg::Vector3D(0., 0., 1.)) *
          Amg::Translation3D(Amg::Vector3D(mediumRadius(), 0., 0.)) *
          Amg::AngleAxis3D(-M_PI / 2, Amg::Vector3D(1., 0., 0.))),
        sectorTrdBounds()));
    } else {
      // sectorPlane 1 (negative phi)
      double ri = innerRadius();
      double ro = outerRadius();
      if (m_type == 1 || m_type == 3)
        ri *= 1. / cos(halfPhiSector());
      if (m_type > 1)
        ro *= 1. / cos(halfPhiSector());
      retsf.push_back(std::make_unique<Trk::PlaneSurface>(
        Amg::Transform3D(
          transform *
          Amg::AngleAxis3D(-halfPhiSector(), Amg::Vector3D(0., 0., 1.)) *
          Amg::Translation3D(Amg::Vector3D(0.5 * (ri + ro), 0., 0.)) *
          Amg::AngleAxis3D(M_PI / 2, Amg::Vector3D(1., 0., 0.))),
        sectorPlaneBounds()));
      // sectorPlane 2 (positive phi)
      retsf.push_back(std::make_unique<Trk::PlaneSurface>(
        Amg::Transform3D(
          transform *
          Amg::AngleAxis3D(halfPhiSector(), Amg::Vector3D(0., 0., 1.)) *
          Amg::Translation3D(Amg::Vector3D(0.5 * (ri + ro), 0., 0.)) *
          Amg::AngleAxis3D(-M_PI / 2, Amg::Vector3D(1., 0., 0.))),
        sectorPlaneBounds()));
    }
  }
  return retsf;
}

deltaRadius()

double Trk::BevelledCylinderVolumeBounds::deltaRadius ( ) const

inline

This method returns the delta radius.

Definition at line 240 of file BevelledCylinderVolumeBounds.h.

{ return (m_outerRadius-m_innerRadius); }

discBounds()

std::shared_ptr< Trk::DiscBounds > Trk::BevelledCylinderVolumeBounds::discBounds ( ) const

private

This method returns the associated DiscBounds for the bottom/top DiscSurface.

Definition at line 491 of file BevelledCylinderVolumeBounds.cxx.

{
  // adjust radius to make sure all surface covered
  double outerRadius =
    (m_type > 1) ? m_outerRadius / cos(m_halfPhiSector) : m_outerRadius;
  return std::make_shared<Trk::DiscBounds>(m_innerRadius, outerRadius, m_halfPhiSector);
}

dump() [1/2]

MsgStream & Trk::BevelledCylinderVolumeBounds::dump ( MsgStream & sl ) const

overridevirtual

Output Method for MsgStream.

Implements Trk::VolumeBounds.

Definition at line 553 of file BevelledCylinderVolumeBounds.cxx.

{
  std::stringstream sl_temp;
  sl_temp << std::setiosflags(std::ios::fixed);
  sl_temp << std::setprecision(7);
  sl_temp << "Trk::BevelledCylinderVolumeBounds: (innerR, outerR, "
             "halfPhiSector, halflengthInZ, thetaMinus, thetaPlus) = ";
  sl_temp << "(" << m_innerRadius << ", " << m_outerRadius << ", "
          << m_halfPhiSector << ", " << m_halfZ << ", " << m_thetaMinus << ", "
          << m_thetaPlus << ")";
  sl << sl_temp.str();
  return sl;
}

dump() [2/2]

std::ostream & Trk::BevelledCylinderVolumeBounds::dump ( std::ostream & sl ) const

overridevirtual

Output Method for std::ostream.

Implements Trk::VolumeBounds.

Definition at line 568 of file BevelledCylinderVolumeBounds.cxx.

{
  std::stringstream sl_temp;
  sl_temp << std::setiosflags(std::ios::fixed);
  sl_temp << std::setprecision(7);
  sl_temp << "Trk::BevelledCylinderVolumeBounds: (innerR, outerR, "
             "halfPhiSector, halflengthInZ, thetaMinus, thetaPlus) = ";
  sl_temp << "(" << m_innerRadius << ", " << m_outerRadius << ", "
          << m_halfPhiSector << ", " << m_halfZ << m_thetaMinus << ", "
          << m_thetaPlus << ")";
  sl << sl_temp.str();
  return sl;
}

halflengthZ()

double Trk::BevelledCylinderVolumeBounds::halflengthZ ( ) const

inline

This method returns the halflengthZ.

Definition at line 242 of file BevelledCylinderVolumeBounds.h.

{ return m_halfZ; }

halfPhiSector()

double Trk::BevelledCylinderVolumeBounds::halfPhiSector ( ) const

inline

This method returns the halfPhiSector angle.

Definition at line 241 of file BevelledCylinderVolumeBounds.h.

{ return m_halfPhiSector; }

innerBevelledCylinderBounds()

std::shared_ptr< Trk::CylinderBounds > Trk::BevelledCylinderVolumeBounds::innerBevelledCylinderBounds ( ) const

private

This method returns the associated BevelledCylinderBounds of the inner BevelledCylinderSurfaces.

Definition at line 433 of file BevelledCylinderVolumeBounds.cxx.

{
  return std::make_shared<Trk::CylinderBounds>(m_innerRadius, m_halfPhiSector, m_halfZ);
}

innerBevelledPlaneBounds()

std::shared_ptr< Trk::RectangleBounds > Trk::BevelledCylinderVolumeBounds::innerBevelledPlaneBounds ( ) const

private

This method returns the associated plane surface bounds of the inner bevelled surface.

Definition at line 451 of file BevelledCylinderVolumeBounds.cxx.

{
  return std::make_shared<Trk::RectangleBounds>(m_innerRadius * tan(m_halfPhiSector), m_halfZ);
}

innerCylinderBounds()

std::shared_ptr< Trk::CylinderBounds > Trk::BevelledCylinderVolumeBounds::innerCylinderBounds ( ) const

private

This method returns the associated CylinderBounds of the inner CylinderSurfaces.

Definition at line 479 of file BevelledCylinderVolumeBounds.cxx.

{
  return std::make_shared<Trk::CylinderBounds>(m_innerRadius, m_halfPhiSector, m_halfZ);
}

innerRadius()

double Trk::BevelledCylinderVolumeBounds::innerRadius ( ) const

inline

This method returns the inner radius.

Definition at line 237 of file BevelledCylinderVolumeBounds.h.

{ return m_innerRadius; }

inside()

bool Trk::BevelledCylinderVolumeBounds::inside ( const Amg::Vector3D & pos, double tol = 0. ) const

inlineoverridevirtual

This method checks if position in the 3D volume frame is inside the cylinder.

Implements Trk::VolumeBounds.

Definition at line 220 of file BevelledCylinderVolumeBounds.h.

 {
   double ros = pos.perp();
   bool insidePhi =  fabs(pos.phi()) <= m_halfPhiSector + tol;
   double cphi = cos(pos.phi());
   bool insideR = insidePhi;
   if (m_type < 1)  insideR  = insidePhi ? ((ros >=  m_innerRadius - tol ) && (ros <= m_outerRadius + tol)) : false;
   else if (m_type == 1 ) insideR = insidePhi ? ((ros>= m_innerRadius/cphi-tol)&&(ros<=m_outerRadius+tol)):false;
   else if (m_type == 2 ) insideR = insidePhi ? ((ros>= m_innerRadius-tol)&&(ros<=m_outerRadius/cphi+tol)):false;
   else if (m_type == 3 ) insideR = insidePhi ? ((ros>= m_innerRadius/cphi-tol)&&(ros<=m_outerRadius/cphi+tol)):false;
//   bool insideZ = insideR ? (fabs(pos.z()) <= m_halfZ + tol ) : false ;
   bool insideZ = insideR ? ((pos.z()<=m_halfZ-(pos.x()+m_outerRadius)*tan(m_thetaPlus) + tol)
                 && ( pos.z()>=-m_halfZ+(pos.x()+m_outerRadius)*tan(m_thetaMinus) - tol)) : false ;
 
   return insideZ;
 }

mediumRadius()

double Trk::BevelledCylinderVolumeBounds::mediumRadius ( ) const

inline

This method returns the medium radius.

Definition at line 239 of file BevelledCylinderVolumeBounds.h.

{ return 0.5*(m_innerRadius+m_outerRadius); }

operator=()

Trk::BevelledCylinderVolumeBounds & Trk::BevelledCylinderVolumeBounds::operator=

(

const BevelledCylinderVolumeBounds &

cylbo

)

Assignment operator.

Definition at line 82 of file BevelledCylinderVolumeBounds.cxx.

{
  if (this != &cylbo) {
    m_innerRadius = cylbo.m_innerRadius;
    m_outerRadius = cylbo.m_outerRadius;
    m_halfPhiSector = cylbo.m_halfPhiSector;
    m_halfZ = cylbo.m_halfZ;
    m_thetaMinus = cylbo.m_thetaMinus;
    m_thetaPlus = cylbo.m_thetaPlus;
    m_type = cylbo.m_type;
    m_subtractedVolume.store(nullptr);
  }
  return *this;
}

outerBevelledCylinderBounds()

std::shared_ptr< Trk::CylinderBounds > Trk::BevelledCylinderVolumeBounds::outerBevelledCylinderBounds ( ) const

private

This method returns the associated BevelledCylinderBounds of the outer BevelledCylinderSurfaces.

Definition at line 439 of file BevelledCylinderVolumeBounds.cxx.

{
  return std::make_shared<Trk::CylinderBounds>(m_outerRadius, m_halfPhiSector, m_halfZ);
}

outerBevelledPlaneBounds()

std::shared_ptr< Trk::RectangleBounds > Trk::BevelledCylinderVolumeBounds::outerBevelledPlaneBounds ( ) const

private

This method returns the associated BevelledCylinderBounds of the outer BevelledCylinderSurfaces.

Definition at line 445 of file BevelledCylinderVolumeBounds.cxx.

{
  return std::make_shared<Trk::RectangleBounds>(m_outerRadius * tan(m_halfPhiSector), m_halfZ);
}

outerCylinderBounds()

std::shared_ptr< Trk::CylinderBounds > Trk::BevelledCylinderVolumeBounds::outerCylinderBounds ( ) const

private

This method returns the associated CylinderBounds of the outer CylinderSurfaces.

Definition at line 485 of file BevelledCylinderVolumeBounds.cxx.

{
  return std::make_shared<Trk::CylinderBounds>(m_outerRadius, m_halfPhiSector, m_halfZ);
}

outerRadius()

double Trk::BevelledCylinderVolumeBounds::outerRadius ( ) const

inline

This method returns the outer radius.

Definition at line 238 of file BevelledCylinderVolumeBounds.h.

{ return m_outerRadius; }

sectorPlaneBounds()

std::shared_ptr< Trk::RectangleBounds > Trk::BevelledCylinderVolumeBounds::sectorPlaneBounds ( ) const

private

Definition at line 508 of file BevelledCylinderVolumeBounds.cxx.

{
  double ri = innerRadius();
  double ro = outerRadius();
  if (m_type == 1 || m_type == 3)
    ri *= 1. / cos(halfPhiSector());
  if (m_type > 1)
    ro *= 1. / cos(halfPhiSector());
  return std::make_shared<Trk::RectangleBounds>(0.5 * (ro - ri), m_halfZ);
}

sectorTrdBounds()

std::shared_ptr< Trk::TrapezoidBounds > Trk::BevelledCylinderVolumeBounds::sectorTrdBounds ( ) const

private

This method returns the associated PlaneBounds limiting a sectoral BevelledCylinderVolume.

Definition at line 500 of file BevelledCylinderVolumeBounds.cxx.

{
  return std::make_shared<Trk::TrapezoidBounds>(
      0.5 * (outerRadius() - innerRadius()), m_halfZ, m_thetaMinus,
      m_thetaPlus);
}

subtractedVolume()

Trk::Volume * Trk::BevelledCylinderVolumeBounds::subtractedVolume ( ) const

private

This method returns the bevelled area volume.

Definition at line 520 of file BevelledCylinderVolumeBounds.cxx.

{
  if (m_type < 1)
    return nullptr;
 
  double tp = tan(m_halfPhiSector);
  std::unique_ptr<Trk::Volume> volIn;
  std::unique_ptr<Trk::Volume> volOut;
  if (m_type == 1 || m_type == 3) { // cut inner cylinder
    volIn = std::make_unique<Trk::Volume>(
        nullptr,
        std::make_shared<Trk::CuboidVolumeBounds>(m_innerRadius, m_innerRadius * tp + 0.1, m_halfZ + 0.1));
  }
  if (m_type > 1) {
    double hz = m_outerRadius * (1. / cos(m_halfPhiSector) - 1.);
    volOut = std::make_unique<Trk::Volume>(
        std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(m_outerRadius + hz, 0., 0.))),
        std::make_shared<Trk::CuboidVolumeBounds>(hz, m_outerRadius * tp + 0.1, m_halfZ + 0.1));
  }
 
  if (!volIn){
    return volOut.release();
  }
  else if (!volOut){
    return volIn.release();
  }
  return new Trk::Volume(
    nullptr, std::make_shared<Trk::CombinedVolumeBounds>(std::move(volIn), std::move(volOut), false));
}

thetaMinus()

double Trk::BevelledCylinderVolumeBounds::thetaMinus ( ) const

inline

This method returns the thetaMinus.

Definition at line 243 of file BevelledCylinderVolumeBounds.h.

{ return m_thetaMinus; }

thetaPlus()

double Trk::BevelledCylinderVolumeBounds::thetaPlus ( ) const

inline

This method returns the thetaPlus.

Definition at line 244 of file BevelledCylinderVolumeBounds.h.

{ return m_thetaPlus; }

topEllipseBounds()

std::shared_ptr< Trk::EllipseBounds > Trk::BevelledCylinderVolumeBounds::topEllipseBounds ( ) const

private

This method returns the associated EllipseBounds for the bottom/top EllipseSurface.

Definition at line 468 of file BevelledCylinderVolumeBounds.cxx.

{
  return std::make_shared<Trk::EllipseBounds>(
    m_innerRadius / cos(m_thetaPlus),
    m_innerRadius,
    m_outerRadius / cos(m_thetaPlus),
    m_outerRadius,
    m_halfPhiSector);
}

type()

int Trk::BevelledCylinderVolumeBounds::type ( ) const

inline

This method returns the type.

Definition at line 245 of file BevelledCylinderVolumeBounds.h.

{ return m_type; }

Member Data Documentation

m_boundaryAccessors

BevelledCylinderVolumeBoundaryAccessors Trk::BevelledCylinderVolumeBounds::m_boundaryAccessors

private

Accessors for Boundary surface access - static is not possible due to mismatched delete() / free () with TrkMagFieldUtils.

Definition at line 209 of file BevelledCylinderVolumeBounds.h.

m_halfPhiSector

double Trk::BevelledCylinderVolumeBounds::m_halfPhiSector

private

Definition at line 197 of file BevelledCylinderVolumeBounds.h.

m_halfZ

double Trk::BevelledCylinderVolumeBounds::m_halfZ

private

Definition at line 198 of file BevelledCylinderVolumeBounds.h.

m_innerRadius

double Trk::BevelledCylinderVolumeBounds::m_innerRadius

private

Definition at line 195 of file BevelledCylinderVolumeBounds.h.

m_outerRadius

double Trk::BevelledCylinderVolumeBounds::m_outerRadius

private

Definition at line 196 of file BevelledCylinderVolumeBounds.h.

m_subtractedVolume

CxxUtils::CachedUniquePtr<Trk::Volume> Trk::BevelledCylinderVolumeBounds::m_subtractedVolume

private

Definition at line 214 of file BevelledCylinderVolumeBounds.h.

m_thetaMinus

double Trk::BevelledCylinderVolumeBounds::m_thetaMinus

private

Definition at line 199 of file BevelledCylinderVolumeBounds.h.

m_thetaPlus

double Trk::BevelledCylinderVolumeBounds::m_thetaPlus

private

Definition at line 200 of file BevelledCylinderVolumeBounds.h.

m_type

int Trk::BevelledCylinderVolumeBounds::m_type

private

Definition at line 201 of file BevelledCylinderVolumeBounds.h.

s_numericalStable

const double Trk::BevelledCylinderVolumeBounds::s_numericalStable

staticprivate

Initial value:

=
  10e-2 * Gaudi::Units::millimeter

numerical stability

Definition at line 212 of file BevelledCylinderVolumeBounds.h.

---

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

• BevelledCylinderVolumeBounds.h
• BevelledCylinderVolumeBounds.cxx