MuonGMR4::TrapezoidBoundsExpander Class Reference

#include <TrapezoidBoundsExpander.h>

Inheritance diagram for MuonGMR4::TrapezoidBoundsExpander:

Collaboration diagram for MuonGMR4::TrapezoidBoundsExpander:

Classes
struct	TrapezoidPatch
	Helper struct to describe a sub trapezoid that is not aligned with the center of the coordinate system. More...

Public Types
enum class	Side : std::int8_t { left = -1 , right = 1 }
	Enum to select the left / right corners of a trapezoid. More...
enum class	Level : std::int8_t { bottom = -1 , top = 1 }
	Enum to select the top / bottom corners of a trapezoid. More...
using	VolumeAligner_t = std::function<Acts::Transform3(const Acts::GeometryContext& tgContext)>
	Abrivation of the transform getter.

Public Member Functions
virtual void	expand (const Acts::GeometryContext &tgContext, const Acts::Volume &volume) override final
virtual std::shared_ptr< Acts::VolumeBounds >	makeBounds (Acts::VolumeBoundFactory &factory) override final
void	setMargin (const double margin)
	Apply an extra margin to all four bound dimensions.
void	setMargin (const double marginXlow, const double marginXhigh, const double marginY, const double marginZ)
	Apply an extra margin to each individual bound side.
	BoundsExpander ()=default
	Use the constructor from the base class.
	BoundsExpander (const Acts::Transform3 &toVolume, std::unique_ptr< const Acts::Logger > loggerObj=nullptr)
	Use the constructor from the base class.
void	expand (const Acts::GeometryContext &tgContext, const MuonGMR4::Chamber &chamber)
	Use the expand overloads w.r.t.
void	expand (const Acts::GeometryContext &tgContext, const MuonGMR4::SpectrometerSector &sector)
	Use the expand overloads w.r.t.
void	expand (const Acts::GeometryContext &tgContext, const MuonGMR4::MuonReadoutElement &readoutElement, Acts::VolumeBoundFactory &boundFactory)
	Use the expand overloads w.r.t.
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 Amg::Vector3D	makeVertex (const TrapezoidPatch &trapezoid, const Side side, const Level lvl)
	Returns the vertex point from a trapezoid.
static double	distanceToTrapezoid (const Amg::Vector3D &vertex, const Amg::Vector3D &edge, const Amg::Vector3D &testMe, const Side side)
	Returns the distance to the inclided trapezoidal side Positive values imply that the test point is outside of the trapezoid edge.
static std::uint8_t	toIndex (const Side side, const Level lvl)
	Construct an index from [0;3] from the side and level.
static std::shared_ptr< Acts::VolumeBounds >	makeBounds (const MuonGMR4::MuonReadoutElement &readoutElement, Acts::VolumeBoundFactory &boundFactory)
	Use the makeBounds overload for the readout element.
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.

Private Member Functions
void	findTrapezoidEdge (Amg::Vector3D &botCorner, Amg::Vector3D &topCorner, const Side side, const std::size_t lowPatch, const std::size_t highPatch) const
	Moves the position of the bottom and top corner of a trapezoid side such that all vertices are enclosed.

Private Attributes
std::vector< TrapezoidPatch >	m_constituents {}
std::shared_ptr< Acts::VolumeBounds >	m_finalBounds {}
std::array< double, 4 >	m_margin {Acts::filledArray<double, 4>(0.)}
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.

Friends
std::ostream &	operator<< (std::ostream &ostr, const Side side)
	Pipe the Side to an ostream.
std::ostream &	operator<< (std::ostream &ostr, const Level lvl)
	Pipe the Level to an ostream.

Detailed Description

Definition at line 13 of file TrapezoidBoundsExpander.h.

Member Typedef Documentation

VolumeAligner_t

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

inherited

Abrivation of the transform getter.

Definition at line 62 of file BoundsExpander.h.

Member Enumeration Documentation

Level

enum class MuonGMR4::TrapezoidBoundsExpander::Level : std::int8_t

strong

Enum to select the top / bottom corners of a trapezoid.

Enumerator
bottom
top

Definition at line 38 of file TrapezoidBoundsExpander.h.

: std::int8_t { bottom= -1, top = 1 };

Side

enum class MuonGMR4::TrapezoidBoundsExpander::Side : std::int8_t

strong

Enum to select the left / right corners of a trapezoid.

Enumerator
left
right

Definition at line 36 of file TrapezoidBoundsExpander.h.

: std::int8_t{left = -1, right = 1};

Member Function Documentation

BoundsExpander() [1/2]

MuonGMR4::BoundsExpander::BoundsExpander ( )

explicitdefault

Use the constructor from the base class.

BoundsExpander() [2/2]

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

explicit

Use the constructor from the base class.

Definition at line 69 of file BoundsExpander.cxx.

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

boxMidPoint()

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

inherited

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 )

staticinherited

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 )

staticinherited

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;
    }

distanceToTrapezoid()

double MuonGMR4::TrapezoidBoundsExpander::distanceToTrapezoid ( const Amg::Vector3D & vertex, const Amg::Vector3D & edge, const Amg::Vector3D & testMe, const Side side )

static

Returns the distance to the inclided trapezoidal side Positive values imply that the test point is outside of the trapezoid edge.

Parameters

vertex	The side vertex of the trapezoid
edge	The direction vector describing the inclined edge
testMe	The external point to test
side	Flag to toggle whether the edge is on the left or right

Definition at line 62 of file TrapezoidBoundsExpander.cxx.

                                                                     {
    const Amg::Vector3D closest = intersectPlane(vertex, edge, 
                                                 Amg::Vector3D::UnitY(), testMe).position();
   return (testMe.x() - closest.x()) *Acts::toUnderlying(side);                        
}

expand() [1/4]

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

finaloverridevirtual

Implements MuonGMR4::BoundsExpander.

Definition at line 50 of file TrapezoidBoundsExpander.cxx.

                                                              {
    ACTS_DEBUG(__func__<<"() "<<__LINE__<<" - Bounds "<<volume.volumeBounds());
    reCenter(cornerPoints(tgContext, volume));
    m_constituents.emplace_back(volume.localToGlobalTransform(tgContext), 
                                volume.volumeBoundsPtr());
}

expand() [2/4]

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

Use the expand overloads w.r.t.

chamber, sector

Definition at line 74 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 )

Use the expand overloads w.r.t.

chamber, sector

Definition at line 86 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 )

Use the expand overloads w.r.t.

chamber, sector

Definition at line 79 of file BoundsExpander.cxx.

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

findTrapezoidEdge()

void MuonGMR4::TrapezoidBoundsExpander::findTrapezoidEdge ( Amg::Vector3D & botCorner, Amg::Vector3D & topCorner, const Side side, const std::size_t lowPatch, const std::size_t highPatch ) const

private

Moves the position of the bottom and top corner of a trapezoid side such that all vertices are enclosed.

The parallel lines are assumed to be at +-halfY. The inclined edge is tilted to enclose all vertices

Parameters

botCorner	The bottom corner to be moved
topCOrner	The top corner to be moved
side	Is the left or the right side of the trapezoid considered
lowPatch	First trapezoid patch to consider
highPatch	Last trapezoid patch to consider

Update the slope of the tilted trapezoid edge to find the steepest one

If the point is outwards update the outer vertex and the slope

Try to decrease

Definition at line 183 of file TrapezoidBoundsExpander.cxx.

                                                                                 {
    const double halfY = 0.5*(maxima()[Amg::y] - minima()[Amg::y]);
    botCorner = makeVertex(m_constituents.at(lowPatch), side, Level::bottom);
    topCorner = makeVertex(m_constituents.at(highPatch), side, Level::top);
    Amg::Vector3D edge = Amg::projectDirOntoPlane((botCorner - topCorner).unit(), 
                                                      Amg::Vector3D::UnitZ());
    botCorner = intersectPlane(botCorner, edge, Amg::Vector3D::UnitY(), -halfY).position();
    topCorner = intersectPlane(topCorner, edge, Amg::Vector3D::UnitY(), halfY).position();
    
    double steepM{0.}; 
    auto updateSlope = [&]( const Amg::Vector3D& v) {
         if (v.y() <= botCorner.y()) {
            return;
         }
         const double m = (v.x() - botCorner.x()) / (v.y() - botCorner.y());
         if(std::abs(m)> std::abs(steepM)) {
            steepM = m;
         }
    };
    updateSlope(topCorner);
    ACTS_DEBUG(__func__<<"() "<<__LINE__<<" - Identified "<<Amg::toString(botCorner)
                <<", "<<Amg::toString(topCorner)<<" as vertices. Edge: "<<Amg::toString(edge));
    Amg::Vector3D farestVtx{botCorner};
    double area{0.};
    for (const TrapezoidPatch& patch : m_constituents) {
        area += patch.area();
        for (auto  lvl : {Level::bottom, Level::top}) {
            const Amg::Vector3D vtx = makeVertex(patch, side, lvl);
            const double d = distanceToTrapezoid(botCorner, edge, vtx, side);
            ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - Vertex at "<<lvl
                        <<" edge "<<Amg::toString(vtx)<<" distance: "<<d);
            if (d > 0. &&  d > distanceToTrapezoid(botCorner, edge, farestVtx, side)) {
                updateSlope(vtx);
                farestVtx = vtx;
                ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - Shift the trapezoid.");
            }
        }
    }
    ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - The farest "<<Amg::toString(farestVtx)<<" with distance "
        <<distanceToTrapezoid(botCorner, edge, farestVtx, side)<<", steepest m: "<<steepM
        <<", start M: "<<(topCorner.x() - botCorner.x()) / (topCorner.y() - botCorner.y()));
 
    edge = Amg::Vector3D{steepM, 1., 0.}.unit();
    botCorner = intersectPlane(farestVtx, edge, Amg::Vector3D::UnitY(), -halfY).position();
    topCorner = intersectPlane(farestVtx, edge, Amg::Vector3D::UnitY(), halfY).position();
    const double envArea = (std::abs(botCorner.x()) + std::abs(topCorner.x()))* 2.*halfY;
    ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - Update corners to "<<Amg::toString(botCorner)
        <<" (bottom) and "<<Amg::toString(topCorner)<<" (top) New area: "<<envArea
    <<", old area: "<<area<<", diff: "<<(area/ envArea));
}

logger()

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

inherited

Returns the ACTS logegr object.

Definition at line 36 of file BoundsExpander.cxx.

{ return *m_logger; }

makeBounds() [1/2]

std::shared_ptr< Acts::VolumeBounds > MuonGMR4::TrapezoidBoundsExpander::makeBounds ( Acts::VolumeBoundFactory & factory )

finaloverridevirtual

shift first the constituents by the centering transform

Hack to cope with the RPCs which may be rotated by 180 degrees around the x or z-axis in cases, they're upside down.

Find the first envelope which is a trapezoid (Needed to keep the opening angle low in EIL4/5

Implements MuonGMR4::BoundsExpander.

Definition at line 87 of file TrapezoidBoundsExpander.cxx.

                                                                       {
    if (m_finalBounds) {
        return m_finalBounds;
    }
    const auto boxMin = minima();
    const auto boxMax = maxima();
  
    const double halfZ = 0.5*(boxMax[Amg::z] - boxMin[Amg::z]);
    const double halfY = 0.5*(boxMax[Amg::y] - boxMin[Amg::y]);
 
    if (std::ranges::all_of(m_constituents, [](const TrapezoidPatch& patch) {
        return patch.bounds->type() == Acts::VolumeBounds::BoundsType::eCuboid;
        })) {
        ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" Only cuboids have been passed. Construct a cuboid");
        m_finalBounds = factory.makeBounds<Acts::CuboidVolumeBounds>(0.5*(boxMax[Amg::x] - boxMin[Amg::x]+ 
                                                                     std::max(m_margin[0], m_margin[1])), 
                                                                     halfY + 0.5*m_margin[2], 
                                                                     halfZ + 0.5* m_margin[3]);
        m_constituents.clear();
        return m_finalBounds;
    }
    for (TrapezoidPatch &trapezoid : m_constituents) {
        trapezoid.toCenter = toVertexCenter() * trapezoid.toCenter;
        ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - Trapezoid after shift: "<<trapezoid);
        GeoTrf::CoordEulerAngles rotAngles = GeoTrf::getCoordRotationAngles(trapezoid.toCenter);
        if (std::abs(rotAngles.gamma - 180._degree)< Acts::s_epsilon) {
            trapezoid.toCenter = trapezoid.toCenter *Amg::getRotateZ3D(180._degree);
            ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - Flip trapezoid around Z: "
                    <<Amg::toString(trapezoid.toCenter));
        }
        if (std::abs(rotAngles.alpha - 180._degree)< Acts::s_epsilon) {
            trapezoid.toCenter = trapezoid.toCenter *Amg::getRotateX3D(180._degree);
            ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - Flip trapezoid around X: "
                    <<Amg::toString(trapezoid.toCenter));
        }
    }
 
    std::array<Amg::Vector3D, 4> expandedCorners{Acts::filledArray<Amg::Vector3D, 4>(Amg::Vector3D::Zero())};
    for (const Side side : {Side::left, Side::right}) {
        std::ranges::sort(m_constituents, [side](const auto& a, const auto& b){
            const Amg::Vector3D botA = makeVertex(a, side, Level::bottom);
            const Amg::Vector3D botB = makeVertex(b, side, Level::bottom);
            if (std::abs(botA.y() - botB.y()) > Acts::s_onSurfaceTolerance) {
                return botA.y() < botB.y();
            }
            return (botA.x()  - botB.x()) * Acts::toUnderlying(side) > 0.;
        });
        std::size_t highPatch{0ul};
        std::optional<std::size_t> lowPatch{};
        for (std::size_t patch = 0ul; patch < m_constituents.size(); ++ patch) {
            if (!lowPatch.has_value() && m_constituents.at(patch).bounds->type() == Acts::VolumeBounds::eTrapezoid) {
                lowPatch = patch;
            }
            const Amg::Vector3D botA = makeVertex(m_constituents.at(highPatch),
                                                  side, Level::bottom);
            const Amg::Vector3D botB = makeVertex(m_constituents.at(patch),
                                                  side, Level::bottom);
            ACTS_VERBOSE(__func__<<"() "<<__LINE__<<" - Test: "<<patch<<" position: "
                    <<Amg::toString(botB)<<" --- best: "<<highPatch<<" position: "
                    <<Amg::toString(botA)<<", distance: "<<(botB.x()  - botA.x())<<", side: "<<side);
            if ((botB.x()  - botA.x()) * Acts::toUnderlying(side) > 0.) {
                highPatch = patch;
            }
        }
        ACTS_DEBUG(__func__<<"() "<<__LINE__<<" - Expand corners at "<<side
                 <<" side. Resorted trapezoids:\n"<<toString(m_constituents)
                 <<"\n   ---- Selected upper trapezoid:\n"
                 <<m_constituents.at(highPatch));
      
        findTrapezoidEdge(expandedCorners[toIndex(side, Level::bottom)],
                          expandedCorners[toIndex(side, Level::top)], side, 
                          lowPatch.value_or(0), highPatch);
    }
    const double halfXhighY = std::max(std::abs(expandedCorners[toIndex(Side::left, Level::top)].x()),
                                       std::abs(expandedCorners[toIndex(Side::right, Level::top)].x())); 
    const double halfXlowY = std::max(std::abs(expandedCorners[toIndex(Side::left, Level::bottom)].x()),
                                      std::abs(expandedCorners[toIndex(Side::right, Level::bottom)].x())); 
    if (std::abs(halfXhighY - halfXlowY) > Acts::s_onSurfaceTolerance) {
        m_finalBounds = factory.makeBounds<Acts::TrapezoidVolumeBounds>(halfXlowY + 0.5*m_margin[0], 
                                                                        halfXhighY + 0.5*m_margin[1],
                                                                        halfY + 0.5*m_margin[2], 
                                                                        halfZ + 0.5* m_margin[3]);
    } else {
        m_finalBounds = factory.makeBounds<Acts::CuboidVolumeBounds>(halfXlowY + 0.5*std::max(m_margin[0], m_margin[1]), 
                                                                     halfY + 0.5*m_margin[2], 
                                                                     halfZ + 0.5* m_margin[3]);
    }
    ACTS_DEBUG(__func__<<"() "<<__LINE__<<" - Created new bounds "<<(*m_finalBounds));
    m_constituents.clear();
    return m_finalBounds;
}

makeBounds() [2/2]

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

static

Use the makeBounds overload for the readout element.

Definition at line 59 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 )

inherited

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;
    }

makeVertex()

Amg::Vector3D MuonGMR4::TrapezoidBoundsExpander::makeVertex ( const TrapezoidPatch & trapezoid, const Side side, const Level lvl )

static

Returns the vertex point from a trapezoid.

Parameters

trapezoid	Reference to the trapezoid of interest
side	Is the vertex on the left [-x] or positive side of the trapezoid
lvl	Is the vertex on the upper or the bottom edge of the trapezoid

Definition at line 42 of file TrapezoidBoundsExpander.cxx.

                                                                                    {
    const double halfX = lvl == Level::top ? MuonGMR4::halfXhighY(*trapezoid.bounds)
                                           : MuonGMR4::halfXlowY(*trapezoid.bounds);
    return trapezoid.toCenter * Amg::Vector3D{Acts::copySign(halfX, side),
                                              Acts::copySign(MuonGMR4::halfY(*trapezoid.bounds), lvl), 0.};
}

maxima()

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

inherited

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

inherited

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 )

inherited

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));
    }

setMargin() [1/2]

void MuonGMR4::TrapezoidBoundsExpander::setMargin

(

const double

margin

)

Apply an extra margin to all four bound dimensions.

Parameters

margin

The extra margin to apply to the bounds

Definition at line 71 of file TrapezoidBoundsExpander.cxx.

                                                           {
    ACTS_DEBUG(__func__<<"() "<<__LINE__<<" - Assign "<<margin<<" to all vertices");
    m_margin.fill(margin);
}

setMargin() [2/2]

void MuonGMR4::TrapezoidBoundsExpander::setMargin	(	const double	marginXlow,
		const double	marginXhigh,
		const double	marginY,
		const double	marginZ )

Apply an extra margin to each individual bound side.

Parameters

marginXLow	The extra margin to apply to the halfX at low Y
marginXhigh	The extra margin to aplpy to the halfX at high Y
marginY	The extra margin to apply to the halfY
marginZ	The extgra margin to apply to the halfZ

Definition at line 76 of file TrapezoidBoundsExpander.cxx.

                                                                                    {
    m_margin[0] = marginXlow;
    m_margin[1] = marginXhigh;
    m_margin[2] = marginY;
    m_margin[3] = marginZ;
    ACTS_DEBUG(__func__<<"() "<<__LINE__<<" - Assign "<<marginXlow<<"/"<<marginXhigh
        <<" to  x-edges , "<<marginY<<" to the y-edge, "<<marginZ<<" to the z-edge as extra margin");
}

toIndex()

std::uint8_t MuonGMR4::TrapezoidBoundsExpander::toIndex ( const Side side, const Level lvl )

static

Construct an index from [0;3] from the side and level.

Definition at line 58 of file TrapezoidBoundsExpander.cxx.

                                                                            {
    return (side == Side::left) + 2*(lvl == Level::top); 
}

toVertexCenter()

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

inherited

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;
    }

Friends And Related Symbol Documentation

operator<< [1/2]

std::ostream & operator<< ( std::ostream & ostr, const Level lvl )

friend

Pipe the Level to an ostream.

Definition at line 48 of file TrapezoidBoundsExpander.h.

                                                                             {
                switch (lvl) {
                    case Level::bottom: return ostr<<"bottom";
                    case Level::top: return ostr<<"top";
                }
                return ostr;
            }

operator<< [2/2]

std::ostream & operator<< ( std::ostream & ostr, const Side side )

friend

Pipe the Side to an ostream.

Definition at line 40 of file TrapezoidBoundsExpander.h.

                                                                            {
                switch (side) {
                    case Side::left: return ostr<<"left";
                    case Side::right: return ostr<<"right";
                }
                return ostr;
            }

Member Data Documentation

m_constituents

std::vector<TrapezoidPatch> MuonGMR4::TrapezoidBoundsExpander::m_constituents {}

private

Definition at line 115 of file TrapezoidBoundsExpander.h.

{};

m_finalBounds

std::shared_ptr<Acts::VolumeBounds> MuonGMR4::TrapezoidBoundsExpander::m_finalBounds {}

private

Definition at line 116 of file TrapezoidBoundsExpander.h.

{};

m_locMax

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

privateinherited

Maximum value seen by the recenter method.

Definition at line 132 of file BoundsExpander.h.

{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)}

privateinherited

Minimum value seen by the recenter method.

Definition at line 134 of file BoundsExpander.h.

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

m_logger

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

privateinherited

Initial value:

{Acts::getDefaultLogger("BoundsExpander",
                                                                                Acts::Logging::Level::INFO)}

Definition at line 125 of file BoundsExpander.h.

                                                    {Acts::getDefaultLogger("BoundsExpander",
                                                                                Acts::Logging::Level::INFO)};

m_margin

std::array<double, 4> MuonGMR4::TrapezoidBoundsExpander::m_margin {Acts::filledArray<double, 4>(0.)}

private

Definition at line 117 of file TrapezoidBoundsExpander.h.

{Acts::filledArray<double, 4>(0.)};

m_shiftTrf

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

privateinherited

Extra shift to center all the vertices.

Definition at line 130 of file BoundsExpander.h.

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

m_toVolume

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

privateinherited

External method to go from ATLAS to the reference frame.

Definition at line 128 of file BoundsExpander.h.

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

---

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

• TrapezoidBoundsExpander.h
• TrapezoidBoundsExpander.cxx