#include <BoundsExpander.h>

Inheritance diagram for MuonGMR4::BoundsExpander:

Collaboration diagram for MuonGMR4::BoundsExpander:

Public Types
using	VolumeAligner_t = std::function<Acts::Transform3(const Acts::GeometryContext& tgContext)>
	Abrivation of the transform getter.

Public Member Functions
	BoundsExpander ()=default
	Default constructor.
	BoundsExpander (const Acts::Transform3 &toVolume, std::unique_ptr< const Acts::Logger > loggerObj=nullptr)
	Constructor with a transform from the global -> local frame of the volume.
void	expand (const Acts::GeometryContext &tgContext, const MuonGMR4::Chamber &chamber)
	Expand the bounds from a chamber.
void	expand (const Acts::GeometryContext &tgContext, const MuonGMR4::SpectrometerSector &sector)
	Expand the bounds from a sector.
void	expand (const Acts::GeometryContext &tgContext, const MuonGMR4::MuonReadoutElement &readoutElement, Acts::VolumeBoundFactory &boundFactory)
	Expand the bounds from a readout element.
virtual void	expand (const Acts::GeometryContext &tgContext, const Acts::Volume &volume)=0
	Expand the bound definition from a generic volume.
virtual std::shared_ptr< Acts::VolumeBounds >	makeBounds (Acts::VolumeBoundFactory &boundFactory)=0
	Make the final bounds after all volumes are passed via the expand method.
std::unique_ptr< Acts::TrackingVolume >	makeEnvelope (Acts::VolumeBoundFactory &factory, std::string_view volName)
	Creates an empty tracking volume.
Acts::Transform3	toVertexCenter () const
	Returns the transform from the ATLAS frame to the center of all seen vertices.
const Acts::Transform3 &	boxMidPoint () const
	Returns the transform from the nominal volume center to the middle point to all seen vertices.
void	reCenter (std::span< const Amg::Vector3D > vertices)
	Update the center point from a list of global vertices.
std::span< const double >	minima () const
	Returns the triplet of the minimum coordinates from the ensemble of all seen vertices.
std::span< const double >	maxima () const
	Returns the triplet of the maximum coordinates from the ensemble of all seen vertices.
const Acts::Logger &	logger () const
	Returns the ACTS logegr object.

Static Public Member Functions
static std::vector< Amg::Vector3D >	cornerPoints (const Acts::GeometryContext &tgContext, const Acts::Volume &volume, const std::size_t nSegments=3)
	Returns the vertices from a volume.
static std::vector< Amg::Vector3D >	cornerPoints (const Acts::GeometryContext &tgContext, const Acts::Surface &surface, const std::size_t nSegments=3)
	Returns the vertices from a surface.
static std::shared_ptr< Acts::VolumeBounds >	makeBounds (const MuonGMR4::MuonReadoutElement &readoutElement, Acts::VolumeBoundFactory &boundFactory)
	Crate volume bounds that enclose the readout element from the central localToGlobalTransform.

Private Attributes
std::unique_ptr< const Acts::Logger >	m_logger
Acts::Transform3	m_toVolume {Acts::Transform3::Identity()}
	External method to go from ATLAS to the reference frame.
Acts::Transform3	m_shiftTrf {Acts::Transform3::Identity()}
	Extra shift to center all the vertices.
std::array< double, 3 >	m_locMax {Acts::filledArray<double, 3>(-2.*Acts::UnitConstants::km)}
	Maximum value seen by the recenter method.
std::array< double, 3 >	m_locMin {Acts::filledArray<double, 3>(2.*Acts::UnitConstants::km)}
	Minimum value seen by the recenter method.

Detailed Description

Definition at line 38 of file BoundsExpander.h.

Member Typedef Documentation

◆ VolumeAligner_t

using MuonGMR4::BoundsExpander::VolumeAligner_t = std::function<Acts::Transform3(const Acts::GeometryContext& tgContext)>

Abrivation of the transform getter.

Definition at line 62 of file BoundsExpander.h.

Constructor & Destructor Documentation

◆ BoundsExpander() [1/2]

MuonGMR4::BoundsExpander::BoundsExpander ( )

explicitdefault

Default constructor.

◆ BoundsExpander() [2/2]

MuonGMR4::BoundsExpander::BoundsExpander	(	const Acts::Transform3 &	toVolume,
		std::unique_ptr< const Acts::Logger >	loggerObj = nullptr )

explicit

Constructor with a transform from the global -> local frame of the volume.

Parameters

toVolume	The Transform to the volume
loggerObj	The logger instance

Definition at line 25 of file BoundsExpander.cxx.

                                                                             : 
        m_toVolume{toVolume} {
        if (loggerObj) {
            m_logger = std::move(loggerObj);
        }
    }

Member Function Documentation

◆ boxMidPoint()

const Acts::Transform3 & MuonGMR4::BoundsExpander::boxMidPoint ( ) const

Returns the transform from the nominal volume center to the middle point to all seen vertices.

Definition at line 42 of file BoundsExpander.cxx.

                                                            {
        return m_shiftTrf;
    }

◆ cornerPoints() [1/2]

std::vector< Amg::Vector3D > MuonGMR4::BoundsExpander::cornerPoints	(	const Acts::GeometryContext &	tgContext,
		const Acts::Surface &	surface,
		const std::size_t	nSegments = 3 )

static

Returns the vertices from a surface.

Parameters

tgContext	The geometry context to align the surface
volume	The surface from which the vertices shall be retrieved
nSegments	Number of segments to be generated

Don't use the polyhedron representation for rectangles and trapezoids as we need the central point on the edge to properly constrain the radius of a surrounding cylinder

Definition at line 131 of file BoundsExpander.cxx.

                                                                                       {
        constexpr std::array signs{-1., 1.};
        std::vector<Amg::Vector3D> vertices{}; //vertices has size zero
        //calculate transform once, outside of loops
        const Acts::Transform3& transform = surface.localToGlobalTransform(tgContext);
        switch (surface.bounds().type()) {
            using enum Acts::SurfaceBounds::BoundsType;
            case eRectangle: {
                const auto& bounds{static_cast<const Acts::RectangleBounds&>(surface.bounds())};
                using enum Acts::RectangleBounds::BoundValues;
                const double stepX = 2.*bounds.get(eMaxX) / nSegments;
                const double stepY = 2.*bounds.get(eMaxY) / nSegments;
                for (const double sign : signs) {
                    for (unsigned seg = 0; seg <= nSegments ; ++seg) {
                        vertices.push_back(transform *
                            Amg::Vector3D{-bounds.get(eMaxX) + stepX * seg,
                                          sign*bounds.get(eMaxY), 0.});
                        vertices.push_back(transform *
                            Amg::Vector3D{sign*bounds.get(eMaxX),
                                          -bounds.get(eMaxY) + stepY * seg, 0.});
                    }
                }
                break;
            } case eTrapezoid: {
                const auto& bounds{static_cast<const Acts::TrapezoidBounds&>(surface.bounds())};
                using enum Acts::TrapezoidBounds::BoundValues;
                const double hY = bounds.get(eHalfLengthY);
                const double xS = bounds.get(eHalfLengthXnegY);
                const double xL = bounds.get(eHalfLengthXposY);
                const double m = (xL - xS) / (2.*hY);
                Amg::Vector3D locPos{Amg::Vector3D::Zero()};
                auto pushVertex = [&](const double x, const double y) {
                    locPos.block<2,1>(0,0) = Eigen::Rotation2D{-bounds.get(eRotationAngle)} *
                                             Amg::Vector2D{x,y};
                    vertices.push_back(transform *locPos);                        
                };
                const double stepY =  2.*hY / nSegments;
                for (const double sign : signs) {
                    const double x = (sign > 0 ? xL : xS);
                    const double stepX = 2.*x / nSegments;
                    for (unsigned seg = 0; seg <= nSegments ; ++seg){
                        pushVertex(-x + stepX*seg, sign*hY);
                        const double y = -hY + stepY*seg;
                        pushVertex(sign*(xS + (y+hY)*m), y);
                    }
                }
                break;
            }  default: {
                vertices = surface.polyhedronRepresentation(tgContext, nSegments).vertices;
                break;
            }
        }
        return vertices;
    }

◆ cornerPoints() [2/2]

std::vector< Amg::Vector3D > MuonGMR4::BoundsExpander::cornerPoints	(	const Acts::GeometryContext &	tgContext,
		const Acts::Volume &	volume,
		const std::size_t	nSegments = 3 )

static

Returns the vertices from a volume.

Parameters

tgContext	The geometry context to align the volume
volume	The volume from which the vertices shall be retrieved
nSegments	Number of segments to be generated

Definition at line 114 of file BoundsExpander.cxx.

                                                                                       {
        std::vector<Amg::Vector3D> edges{};
        const Acts::VolumeBounds& bounds{volume.volumeBounds()};
        const Acts::Transform3& trf{volume.localToGlobalTransform(tgContext)};
        for (const Acts::OrientedSurface& boundary : bounds.orientedSurfaces(trf)) {
            std::vector<Amg::Vector3D> corners = cornerPoints(tgContext, *boundary.surface, nSegments);
            edges.insert(edges.end(), std::make_move_iterator(corners.begin()), 
                                      std::make_move_iterator(corners.end()));
        }
        auto [begin, end] = std::ranges::unique(edges, [](const Amg::Vector3D& a, const Amg::Vector3D& b) {
                                                        return (a - b).mag2() < Acts::s_onSurfaceTolerance;
        });
        edges.erase(begin, end);
        return edges;
    }

◆ expand() [1/4]

virtual void MuonGMR4::BoundsExpander::expand	(	const Acts::GeometryContext &	tgContext,
		const Acts::Volume &	volume )

pure virtual

Expand the bound definition from a generic volume.

Parameters

tgContext	The geometry context to align the volume in space
volume	The volume of interest

Implemented in MuonGMR4::CylinderBoundsExpander, and MuonGMR4::TrapezoidBoundsExpander.

◆ expand() [2/4]

void MuonGMR4::BoundsExpander::expand	(	const Acts::GeometryContext &	tgContext,
		const MuonGMR4::Chamber &	chamber )

Expand the bounds from a chamber.

Parameters

tgContext	The goemetry contex to position the chamber in space
chamber	Reference to the chamber from which the vertices are extracted

Definition at line 32 of file BoundsExpander.cxx.

                                                                {
        expand(tgContext, *chamber.boundingVolume());
    }

◆ expand() [3/4]

void MuonGMR4::BoundsExpander::expand	(	const Acts::GeometryContext &	tgContext,
		const MuonGMR4::MuonReadoutElement &	readoutElement,
		Acts::VolumeBoundFactory &	boundFactory )

Expand the bounds from a readout element.

Parameters

tgContext	The geometry context to align the readout element in space
readoutElement	The readout element of interest
boundFactory	To create the temporary volume bounds enclosing the readout element

Definition at line 81 of file BoundsExpander.cxx.

                                                                      {
        expand(tgContext, Acts::Volume{readoutElement.localToGlobalTransform(tgContext),
                                       makeBounds(readoutElement, boundFactory)});
    }

◆ expand() [4/4]

void MuonGMR4::BoundsExpander::expand	(	const Acts::GeometryContext &	tgContext,
		const MuonGMR4::SpectrometerSector &	sector )

Expand the bounds from a sector.

Parameters

tgContext	The goemetry contex to position the sector in space
sector	Reference to the sector from which the vertices are extracted

Definition at line 38 of file BoundsExpander.cxx.

                                                                          {
        expand(tgContext, *sector.boundingVolume());
    }

◆ logger()

const Acts::Logger & MuonGMR4::BoundsExpander::logger ( ) const

Returns the ACTS logegr object.

Definition at line 36 of file BoundsExpander.cxx.

36{ return *m_logger; }

◆ makeBounds() [1/2]

virtual std::shared_ptr< Acts::VolumeBounds > MuonGMR4::BoundsExpander::makeBounds ( Acts::VolumeBoundFactory & boundFactory )

pure virtual

Make the final bounds after all volumes are passed via the expand method.

Parameters

boundFactory The factory object used to create the final bounds

Implemented in MuonGMR4::CylinderBoundsExpander, and MuonGMR4::TrapezoidBoundsExpander.

◆ makeBounds() [2/2]

std::shared_ptr< Acts::VolumeBounds > MuonGMR4::BoundsExpander::makeBounds	(	const MuonGMR4::MuonReadoutElement &	readoutElement,
		Acts::VolumeBoundFactory &	boundFactory )

static

Crate volume bounds that enclose the readout element from the central localToGlobalTransform.

Parameters

readoutElement	The readout element of interest
boundFactory	The factory used to create the bounds

Definition at line 46 of file BoundsExpander.cxx.

                                                                         {
        switch(readoutElement.detectorType()) {
          case ActsTrk::DetectorType::Mdt: {
             const auto& techEle = static_cast<const MdtReadoutElement&>(readoutElement);
             const auto& pars = techEle.getParameters();
             if (std::abs(pars.shortHalfX - pars.longHalfX) < Acts::s_epsilon) {
                return boundFactory.makeBounds<Acts::CuboidVolumeBounds>(pars.shortHalfX, pars.halfY, pars.halfHeight);
             }
             return boundFactory.makeBounds<Acts::TrapezoidVolumeBounds>(pars.shortHalfX, pars.longHalfX, 
                                                                        pars.halfY, pars.halfHeight);
          } case ActsTrk::DetectorType::Rpc: {
            const auto& techEle = static_cast<const RpcReadoutElement&>(readoutElement);
            const auto& pars = techEle.getParameters();
            return boundFactory.makeBounds<Acts::CuboidVolumeBounds>(pars.halfWidth, pars.halfLength, pars.halfThickness);
          } case ActsTrk::DetectorType::Tgc: {
            const auto& techEle = static_cast<const TgcReadoutElement&>(readoutElement);
            const auto& pars = techEle.getParameters();
            return boundFactory.makeBounds<Acts::TrapezoidVolumeBounds>(pars.halfWidthShort, pars.halfWidthLong, 
                                                                        pars.halfHeight, pars.halfThickness );
          } case ActsTrk::DetectorType::sTgc: {
            const auto& techEle = static_cast<const sTgcReadoutElement&>(readoutElement);
            const auto& pars = techEle.getParameters();
            return boundFactory.makeBounds<Acts::TrapezoidVolumeBounds>(pars.sHalfChamberLength, pars.lHalfChamberLength, 
                                                                        pars.halfChamberHeight, pars.halfChamberTck );
          } case ActsTrk::DetectorType::Mm: {
             const auto& techEle = static_cast<const MmReadoutElement&>(readoutElement);
             const auto& pars = techEle.getParameters();
             return boundFactory.makeBounds<Acts::TrapezoidVolumeBounds>(pars.halfShortWidth, pars.halfLongWidth, 
                                                                        pars.halfHeight, pars.halfThickness );
          } default: 
              THROW_EXCEPTION("Unsupported detector type "<<readoutElement.detectorType());
        }
        return nullptr;
    }

◆ makeEnvelope()

std::unique_ptr< Acts::TrackingVolume > MuonGMR4::BoundsExpander::makeEnvelope	(	Acts::VolumeBoundFactory &	factory,
		std::string_view	volName )

Creates an empty tracking volume.

The volume will be positioned at the vertex center

Parameters

factory	The bound factory to create the bounds
volName	The name of the tracking volume

Definition at line 190 of file BoundsExpander.cxx.

                                                                                               {
        auto volume = std::make_unique<Acts::TrackingVolume>(toVertexCenter().inverse(),
                                                             makeBounds(factory), std::string{volName});
        ACTS_DEBUG(__func__<<"() "<<__LINE__<<" - Created new volume envelope "
                <<volName<<" located at @"<<Amg::toString(toVertexCenter().inverse())
                <<" with bounds: "<<volume->volumeBounds());
        return volume;
    }

◆ maxima()

std::span< const double > MuonGMR4::BoundsExpander::maxima ( ) const

Returns the triplet of the maximum coordinates from the ensemble of all seen vertices.

Definition at line 111 of file BoundsExpander.cxx.

                                                       {
        return m_locMax;
    }

◆ minima()

std::span< const double > MuonGMR4::BoundsExpander::minima ( ) const

Returns the triplet of the minimum coordinates from the ensemble of all seen vertices.

Definition at line 108 of file BoundsExpander.cxx.

                                                       {
        return m_locMin;
    }

◆ reCenter()

void MuonGMR4::BoundsExpander::reCenter ( std::span< const Amg::Vector3D > vertices )

Update the center point from a list of global vertices.

Parameters

vertices List of vertices expressed in th ATLAS frame

Definition at line 91 of file BoundsExpander.cxx.

                                                                     {
        ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - User defined center system: "
                    <<Amg::toString(m_toVolume));
        for (const Amg::Vector3D& vert : vertices) {
            const Amg::Vector3D locVert = m_toVolume* vert;
            for (std::size_t k = 0; k < m_locMax.size(); ++k) {
                m_locMax[k] = std::max(m_locMax[k], locVert[k]);
                m_locMin[k] = std::min(m_locMin[k], locVert[k]);
            }
        }
        Amg::Vector3D shiftVec{Amg::Vector3D::Zero()};
        for (std::size_t k =0 ; k < m_locMax.size(); ++k) {
            shiftVec[k] = 0.5*(m_locMax[k] + m_locMin[k]);
        }
        m_shiftTrf = Amg::getTranslate3D(shiftVec);
        ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - New transform: "<<Amg::toString(m_shiftTrf));
    }

◆ toVertexCenter()

Acts::Transform3 MuonGMR4::BoundsExpander::toVertexCenter ( ) const

Returns the transform from the ATLAS frame to the center of all seen vertices.

Definition at line 88 of file BoundsExpander.cxx.

                                                        {
        return  m_shiftTrf.inverse() * m_toVolume;
    }

Member Data Documentation

◆ m_locMax

std::array<double, 3> MuonGMR4::BoundsExpander::m_locMax {Acts::filledArray<double, 3>(-2.*Acts::UnitConstants::km)}

private

Maximum value seen by the recenter method.

Definition at line 132 of file BoundsExpander.h.

132{Acts::filledArray<double, 3>(-2.*Acts::UnitConstants::km)};

◆ m_locMin

std::array<double, 3> MuonGMR4::BoundsExpander::m_locMin {Acts::filledArray<double, 3>(2.*Acts::UnitConstants::km)}

private

Minimum value seen by the recenter method.

Definition at line 134 of file BoundsExpander.h.

134{Acts::filledArray<double, 3>(2.*Acts::UnitConstants::km)};

◆ m_logger

std::unique_ptr<const Acts::Logger> MuonGMR4::BoundsExpander::m_logger

private

Initial value:

{Acts::getDefaultLogger("BoundsExpander",

Acts::Logging::Level::INFO)}

Definition at line 125 of file BoundsExpander.h.

125 {Acts::getDefaultLogger("BoundsExpander",

126 Acts::Logging::Level::INFO)};

◆ m_shiftTrf

Acts::Transform3 MuonGMR4::BoundsExpander::m_shiftTrf {Acts::Transform3::Identity()}

private

Extra shift to center all the vertices.

Definition at line 130 of file BoundsExpander.h.

130{Acts::Transform3::Identity()};

◆ m_toVolume

Acts::Transform3 MuonGMR4::BoundsExpander::m_toVolume {Acts::Transform3::Identity()}

private

External method to go from ATLAS to the reference frame.

Definition at line 128 of file BoundsExpander.h.

128{Acts::Transform3::Identity()};

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

Public Types

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ VolumeAligner_t

Constructor & Destructor Documentation

◆ BoundsExpander() [1/2]

◆ BoundsExpander() [2/2]

Member Function Documentation

◆ boxMidPoint()

◆ cornerPoints() [1/2]

◆ cornerPoints() [2/2]

◆ expand() [1/4]

◆ expand() [2/4]

◆ expand() [3/4]

◆ expand() [4/4]

◆ logger()

◆ makeBounds() [1/2]

◆ makeBounds() [2/2]

◆ makeEnvelope()

◆ maxima()

◆ minima()

◆ reCenter()

◆ toVertexCenter()

Member Data Documentation

◆ m_locMax

◆ m_locMin

◆ m_logger

◆ m_shiftTrf

◆ m_toVolume