ActsTrk::VolumePlacement Class Reference

Implementation to make a (tracking) volume alignable. More...

#include <VolumePlacement.h>

Inheritance diagram for ActsTrk::VolumePlacement:

Collaboration diagram for ActsTrk::VolumePlacement:

Classes
class	AlignedCache
	Auxiliary class to store the aligned transforms of the volume and of the associated portals. More...

Public Types
using	AlignableNode_t = GeoIntrusivePtr<GeoAlignableTransform>
	Abrivation of an alignable GeoTransform.
using	Parent_t
	Abrivation of the parent input types that are connected to the alignment system --> A direct alignable transform --> A detector element base following the alignment --> Another alignable volume element.

Public Member Functions
	VolumePlacement (const DetectorType detType, const AlignableNode_t parentNode, std::optional< Amg::Transform3D > addShift=std::nullopt)
	Constructor taking an Alignable transform from the geometry tree.
	VolumePlacement (const IDetectorElementBase &parentElement, std::optional< Amg::Transform3D > addShift=std::nullopt)
	Constructor taking the reference to a Detector element.
	VolumePlacement (const VolumePlacement &parentPlacement, std::optional< Amg::Transform3D > addShift=std::nullopt)
	Constructor taking the reference to another placement The life time of the object must be ensured to exceed the Placement's lifetime.
void	addChild (std::unique_ptr< VolumePlacement > &&child)
	Add a child volume placement to this placement.
void	connectCenterSurface (std::shared_ptr< Acts::RegularSurface > surface)
	Connect an external surface and place it into the volume center.
DetectorType	detectorType () const override final
unsigned	storeAlignedTransforms (const DetectorAlignStore &store) const override final
void	makePortalsAlignable (const Acts::GeometryContext &gctx, const std::vector< std::shared_ptr< Acts::RegularSurface > > &portalsToAlign) override final
const Acts::Transform3 &	localToGlobalTransform (const Acts::GeometryContext &gctx) const override final
const Amg::Transform3D &	localToGlobalTransform (const GeometryContext &gctx) const
const Acts::Transform3 &	globalToLocalTransform (const Acts::GeometryContext &gctx) const override final
const Amg::Transform3D &	globalToLocalTransform (const GeometryContext &gctx) const
const Acts::Transform3 &	portalLocalToGlobal (const Acts::GeometryContext &gctx, const std::size_t portalIdx) const override final

Private Member Functions
Amg::Transform3D	localToGlobalTransform (const DetectorAlignStore *store) const
	Constructs the local -> global transform of the volume.

Private Attributes
Parent_t	m_parent {}
	Parent element which is following the alignment.
GeoIntrusivePtr< GeoTransform >	m_refShift {}
	Additional shift on top of the parent position.
std::unique_ptr< AlignedCache >	m_locToGlobCache {}
	Cache to handle the local -> global transform of the volume.
std::unique_ptr< AlignedCache >	m_globToLocCache {}
	Cache to handle the global -> local transform of the volume.
std::vector< std::unique_ptr< AlignedCache > >	m_portalCaches {}
	Cache to handle the local -> global transforms of the associated portals.
std::vector< std::unique_ptr< VolumePlacement > >	m_children {}
	Children spawning from this VolumePlacement.
std::unique_ptr< Acts::detail::PortalPlacement >	m_surfacePlacement {}
	Pipe the local -> global transform to a surface.

Detailed Description

Implementation to make a (tracking) volume alignable.

The placement is coupled to the alignment system either via a reference IDetectorElement, an alignable node in the geometry tree or another VolumePlacement.

Definition at line 22 of file VolumePlacement.h.

Member Typedef Documentation

AlignableNode_t

using ActsTrk::VolumePlacement::AlignableNode_t = GeoIntrusivePtr<GeoAlignableTransform>

Abrivation of an alignable GeoTransform.

Definition at line 25 of file VolumePlacement.h.

Parent_t

using ActsTrk::VolumePlacement::Parent_t

Initial value:

 std::variant<AlignableNode_t, 
                                          const IDetectorElementBase*,
                                          const VolumePlacement*>

Abrivation of the parent input types that are connected to the alignment system --> A direct alignable transform --> A detector element base following the alignment --> Another alignable volume element.

Definition at line 31 of file VolumePlacement.h.

Constructor & Destructor Documentation

VolumePlacement() [1/3]

ActsTrk::VolumePlacement::VolumePlacement ( const DetectorType detType, const AlignableNode_t parentNode, std::optional< Amg::Transform3D > addShift = std::nullopt )

explicit

Constructor taking an Alignable transform from the geometry tree.

Parameters

detType	Detectortype of the alignment store into which the transforms are written
parentNode	Pointer to the alignable transform
addShift	Additional optional shift to be applied on top of the alignable reference

Definition at line 39 of file VolumePlacement.cxx.

                                                                          :
        m_parent{parentNode},
        m_locToGlobCache{std::make_unique<AlignedCache>(AlignedCache::CacheFlags::volumeLocToGlob, detType, this)},
        m_globToLocCache{std::make_unique<AlignedCache>(AlignedCache::CacheFlags::volumeGlobToLoc, detType, this)} {
        if (!addShift) {
            return;
        }       
        m_refShift = GeoDeDuplicator{}.makeTransform(*addShift);
    }

VolumePlacement() [2/3]

ActsTrk::VolumePlacement::VolumePlacement ( const IDetectorElementBase & parentElement, std::optional< Amg::Transform3D > addShift = std::nullopt )

explicit

Constructor taking the reference to a Detector element.

The life time of the detector element must be ensured to exceed the Placement's lifetime

Parameters

parentElement	The detector element which alignment the volume is following
addShift	Additional optional shift to be applied on top of the alignable reference

Definition at line 55 of file VolumePlacement.cxx.

                                                                          :
        m_parent{&parentElement},
        m_globToLocCache{std::make_unique<AlignedCache>(AlignedCache::CacheFlags::volumeGlobToLoc, 
                                                        parentElement.detectorType(), this)} {
        if (!addShift) {
            return;
        }
        m_locToGlobCache = std::make_unique<AlignedCache>(AlignedCache::CacheFlags::volumeLocToGlob,
                                                          parentElement.detectorType(), this);
        m_refShift = GeoDeDuplicator{}.makeTransform(*addShift);
 
    }

VolumePlacement() [3/3]

ActsTrk::VolumePlacement::VolumePlacement ( const VolumePlacement & parentPlacement, std::optional< Amg::Transform3D > addShift = std::nullopt )

explicit

Constructor taking the reference to another placement The life time of the object must be ensured to exceed the Placement's lifetime.

Parameters

parentPlacement	The parent placement moving according to the alignment
addShift	Additional optional shift to be applied on top of the alignable reference

Definition at line 69 of file VolumePlacement.cxx.

                                                                          :
        m_parent{&parentPlacement}{
        if (!addShift) {
            return;
        }
        m_locToGlobCache = std::make_unique<AlignedCache>(AlignedCache::CacheFlags::volumeLocToGlob, 
                                                         parentPlacement.detectorType(), this);
        m_globToLocCache = std::make_unique<AlignedCache>(AlignedCache::CacheFlags::volumeGlobToLoc, 
                                                          parentPlacement.detectorType(), this);
        m_refShift = GeoDeDuplicator{}.makeTransform(*addShift);
 
    }

Member Function Documentation

addChild()

void ActsTrk::VolumePlacement::addChild

(

std::unique_ptr< VolumePlacement > &&

child

)

Add a child volume placement to this placement.

The object takes ownership and fills the alignment cache

Parameters

child

The child to be appended

Definition at line 50 of file VolumePlacement.cxx.

                                                                        {
        assert(child.get() != this);
        assert(child != nullptr);
        m_children.push_back(std::move(child));
    }

connectCenterSurface()

void ActsTrk::VolumePlacement::connectCenterSurface

(

std::shared_ptr< Acts::RegularSurface >

surface

)

Connect an external surface and place it into the volume center.

Parameters

surface

pointer to the surface that is connected to the placement

Definition at line 122 of file VolumePlacement.cxx.

                                                                                        {
        if (m_surfacePlacement) {
            THROW_EXCEPTION("Center surface already defined");
        }
        m_surfacePlacement = std::make_unique<Acts::detail::PortalPlacement>(std::numeric_limits<std::size_t>::max(),
                                                                             Amg::Transform3D::Identity(), this,
                                                                             surface);
   }

detectorType()

DetectorType ActsTrk::VolumePlacement::detectorType ( ) const

finaloverridevirtual

Implements ActsTrk::IVolumePlacement.

Definition at line 130 of file VolumePlacement.cxx.

                                                    { 
       if (m_locToGlobCache){
            return m_locToGlobCache->detectorType();
       }
       return std::visit([](const auto& parent) {
            using visit_t = std::decay_t<decltype(parent)>;
            if constexpr(!std::is_same_v<visit_t, AlignableNode_t>) {
                return parent->detectorType();
            }
            return DetectorType::UnDefined;
       }, m_parent);
    }

globalToLocalTransform() [1/2]

const Acts::Transform3 & ActsTrk::VolumePlacement::globalToLocalTransform ( const Acts::GeometryContext & gctx ) const

finaloverride

Definition at line 106 of file VolumePlacement.cxx.

                                                                                                      {
        // The only configuration without glob -> loc cache is a parent volume placement
        if (!m_globToLocCache) {
            return std::get<const VolumePlacement*>(m_parent)->globalToLocalTransform(gctx);
        }
        return m_globToLocCache->getTransform(gctx);
    }

globalToLocalTransform() [2/2]

const Amg::Transform3D & ActsTrk::VolumePlacement::globalToLocalTransform

(

const GeometryContext &

gctx

)

const

Definition at line 113 of file VolumePlacement.cxx.

                                                                                                   {
        return globalToLocalTransform(gctx.context());
    }

localToGlobalTransform() [1/3]

const Acts::Transform3 & ActsTrk::VolumePlacement::localToGlobalTransform ( const Acts::GeometryContext & gctx ) const

finaloverride

Definition at line 91 of file VolumePlacement.cxx.

                                                                                                       {
        if (!m_locToGlobCache) {
            if (std::holds_alternative<const IDetectorElementBase*>(m_parent)){
                return std::get<const IDetectorElementBase*>(m_parent)->localToGlobalTransform(gctx);
            } else if (std::holds_alternative<const VolumePlacement*>(m_parent)) {
                return std::get<const VolumePlacement*>(m_parent)->localToGlobalTransform(gctx);
            } else {
                THROW_EXCEPTION("A VolumePlacement without cache && alignable trf should never happen");
            }
        }
        return m_locToGlobCache->getTransform(gctx);
    }

localToGlobalTransform() [2/3]

Amg::Transform3D ActsTrk::VolumePlacement::localToGlobalTransform ( const DetectorAlignStore * store ) const

private

Constructs the local -> global transform of the volume.

The request is forwarded to the parent and an optional shift is applied on top

Parameters

store

From which the alignment information is grepped and to which the final transform is written

Definition at line 143 of file VolumePlacement.cxx.

                                                                                                {
        return std::visit([&](const auto& parent) -> Amg::Transform3D {
            using visit_t = std::decay_t<decltype(parent)>;
            if constexpr(std::is_same_v<visit_t, AlignableNode_t>) {
                return parent->getTransform(store ? store->geoModelAlignment.get() : nullptr);
            } else {
                return parent->localToGlobalTransform(store);
            }
            return Amg::Transform3D::Identity(); 
        }, m_parent) * (m_refShift ? m_refShift->getDefTransform() 
                                   : Amg::Transform3D::Identity());
    }

localToGlobalTransform() [3/3]

const Amg::Transform3D & ActsTrk::VolumePlacement::localToGlobalTransform

(

const GeometryContext &

gctx

)

const

Definition at line 103 of file VolumePlacement.cxx.

                                                                                                   {
        return localToGlobalTransform(gctx.context());
    }

makePortalsAlignable()

void ActsTrk::VolumePlacement::makePortalsAlignable ( const Acts::GeometryContext & gctx, const std::vector< std::shared_ptr< Acts::RegularSurface > > & portalsToAlign )

finaloverride

Definition at line 83 of file VolumePlacement.cxx.

                                                                                                                   {
        Acts::VolumePlacementBase::makePortalsAlignable(gctx, portalsToAlign);
        for (std::size_t p = 0ul; p < portalsToAlign.size(); ++p) {
            m_portalCaches.emplace_back(std::make_unique<AlignedCache>(this, p));
        }
    }

portalLocalToGlobal()

const Acts::Transform3 & ActsTrk::VolumePlacement::portalLocalToGlobal ( const Acts::GeometryContext & gctx, const std::size_t portalIdx ) const

finaloverride

Definition at line 117 of file VolumePlacement.cxx.

                                                                                                  {
        return portalIdx < m_portalCaches.size() ? 
               m_portalCaches.at(portalIdx)->getTransform(gctx) : localToGlobalTransform(gctx);
    }

storeAlignedTransforms()

unsigned ActsTrk::VolumePlacement::storeAlignedTransforms ( const DetectorAlignStore & store ) const

finaloverridevirtual

Implements ActsTrk::IVolumePlacement.

Definition at line 156 of file VolumePlacement.cxx.

                                                                                          {
        unsigned n{0};
        for (const std::unique_ptr<VolumePlacement>& child : m_children) {
            n+=child->storeAlignedTransforms(store);
        }
        if (store.detType != detectorType()) {
            return n;
        }
        for (const AlignedCache* volCache : {m_locToGlobCache.get(), m_globToLocCache.get()}) {
            if (!volCache) {
                continue;
            }
            volCache->getTransform(&store);
            ++n;
        }
        for (const std::unique_ptr<AlignedCache>& cache: m_portalCaches) {
            cache->getTransform(&store);
            ++n;
        }
        return n;
    }

Member Data Documentation

m_children

std::vector<std::unique_ptr<VolumePlacement> > ActsTrk::VolumePlacement::m_children {}

private

Children spawning from this VolumePlacement.

Definition at line 128 of file VolumePlacement.h.

{};

m_globToLocCache

std::unique_ptr<AlignedCache> ActsTrk::VolumePlacement::m_globToLocCache {}

private

Cache to handle the global -> local transform of the volume.

Definition at line 124 of file VolumePlacement.h.

{};

m_locToGlobCache

std::unique_ptr<AlignedCache> ActsTrk::VolumePlacement::m_locToGlobCache {}

private

Cache to handle the local -> global transform of the volume.

Definition at line 122 of file VolumePlacement.h.

{};

m_parent

Parent_t ActsTrk::VolumePlacement::m_parent {}

private

Parent element which is following the alignment.

Definition at line 118 of file VolumePlacement.h.

{};

m_portalCaches

std::vector<std::unique_ptr<AlignedCache> > ActsTrk::VolumePlacement::m_portalCaches {}

private

Cache to handle the local -> global transforms of the associated portals.

Definition at line 126 of file VolumePlacement.h.

{};

m_refShift

GeoIntrusivePtr<GeoTransform> ActsTrk::VolumePlacement::m_refShift {}

private

Additional shift on top of the parent position.

Definition at line 120 of file VolumePlacement.h.

{}; 

m_surfacePlacement

std::unique_ptr<Acts::detail::PortalPlacement> ActsTrk::VolumePlacement::m_surfacePlacement {}

private

Pipe the local -> global transform to a surface.

Definition at line 130 of file VolumePlacement.h.

{};

---

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

• VolumePlacement.h
• VolumePlacement.cxx