ActsTrackingGeometryTool Class Reference

#include <ActsTrackingGeometryTool.h>

Inheritance diagram for ActsTrackingGeometryTool:

Collaboration diagram for ActsTrackingGeometryTool:

Public Member Functions
StatusCode	initialize () override
virtual std::shared_ptr< const Acts::TrackingGeometry >	trackingGeometry () const override
virtual const ActsGeometryContext &	getGeometryContext (const EventContext &ctx) const override
virtual const ActsGeometryContext &	getNominalGeometryContext () const override
virtual const ActsTrk::DetectorElementToActsGeometryIdMap *	surfaceIdMap () const override

Private Member Functions
std::unique_ptr< ActsTrk::DetectorElementToActsGeometryIdMap >	createDetectorElementToGeoIdMap () const
	Creates and popules the DetectorElement -> Acts::Surface geo identifier map from the geometry service. More...

Private Attributes
ServiceHandle< IActsTrackingGeometrySvc >	m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
SG::ReadHandleKey< ActsGeometryContext >	m_rchk {this, "ActsAlignmentKey", "ActsAlignment", "cond read key for the alignment"}
std::unique_ptr< const ActsTrk::DetectorElementToActsGeometryIdMap >	m_detIdMap {}

Detailed Description

Definition at line 27 of file ActsTrackingGeometryTool.h.

Member Function Documentation

createDetectorElementToGeoIdMap()

std::unique_ptr< ActsTrk::DetectorElementToActsGeometryIdMap > ActsTrackingGeometryTool::createDetectorElementToGeoIdMap ( ) const

private

Creates and popules the DetectorElement -> Acts::Surface geo identifier map from the geometry service.

Muon system

Definition at line 51 of file ActsTrackingGeometryTool.cxx.

                                                                    {
    // create map from
    auto detector_element_to_geoid = std::make_unique<DetectorElementToActsGeometryIdMap>();
 
    struct Counter{ 
        unsigned n_detector_elements{0};
        unsigned n_missing_detector_elements{0};
        unsigned n_wrong_type{0};
    };
    Counter counter {};
    trackingGeometry()->visitSurfaces([this, &counter, &detector_element_to_geoid](const Acts::Surface *surface) {
        if (!surface || !surface->associatedDetectorElement()) {
            ++counter.n_wrong_type;
            return;
        }
        const auto* detEl = dynamic_cast<const IDetectorElementBase*>(surface->associatedDetectorElement());
        if (!detEl) {
            ++counter.n_missing_detector_elements;
            return;
        }
        auto insert_id = [&detector_element_to_geoid, &surface, &counter](const xAOD::UncalibMeasType type,
                                                                          const IdentifierHash& hash) {
            detector_element_to_geoid->insert(std::make_pair(makeDetectorElementKey(type, hash),
                                                             DetectorElementToActsGeometryIdMap::makeValue(surface->geometryId())));
            ++counter.n_detector_elements;
        };
        switch(detEl->detectorType()) {
            using enum DetectorType;
            case Pixel:
                insert_id(xAOD::UncalibMeasType::PixelClusterType,
                          dynamic_cast<const ActsDetectorElement*>(detEl)->identifyHash());
                break;
            case Sct:
                insert_id(xAOD::UncalibMeasType::StripClusterType,
                          dynamic_cast<const ActsDetectorElement*>(detEl)->identifyHash());
                break;
            case Hgtd:
                insert_id(xAOD::UncalibMeasType::HGTDClusterType,
                         dynamic_cast<const ActsDetectorElement*>(detEl)->identifyHash());
                break;
            case Trt: {
                break;
            }
            case Mdt:
            case Rpc:
            case Tgc:
            case Csc:
            case Mm:
            case sTgc:{
                // surface map not needed for the muon detectors
               ++counter.n_detector_elements; 
               break;
            }
            case UnDefined:
                ATH_MSG_ERROR("Undefined element encountered");
                counter.n_detector_elements = 0;
                return;
        }
    }, true /*sensitive surfaces*/);
    ATH_MSG_INFO( "Surfaces without associated detector elements " << counter.n_missing_detector_elements
                << " (with " << counter.n_detector_elements << ")" );
    if (counter.n_detector_elements==0) {
        ATH_MSG_ERROR( "No surface with associated detector element" );
        return nullptr;
    }
    if (counter.n_wrong_type>0) {
        ATH_MSG_WARNING( "Surfaces associated to detector elements not of type Trk::TrkDetElementBase :" << counter.n_wrong_type);
    }
    return detector_element_to_geoid;
}

getGeometryContext()

const ActsGeometryContext & ActsTrackingGeometryTool::getGeometryContext ( const EventContext &  ctx ) const

overridevirtual

Definition at line 36 of file ActsTrackingGeometryTool.cxx.

                                                                                                     {
    ATH_MSG_DEBUG("Creating alignment context for event");
    const ActsGeometryContext* geoCtx{nullptr};
    if (!SG::get(geoCtx, m_rchk, ctx).isSuccess()) {
        ATH_MSG_ERROR("Creating alignment context failed: read cond handle invalid!");
    }
    return *geoCtx;
}

getNominalGeometryContext()

const ActsGeometryContext & ActsTrackingGeometryTool::getNominalGeometryContext ( ) const

overridevirtual

Definition at line 45 of file ActsTrackingGeometryTool.cxx.

                                                                                     {
     return m_trackingGeometrySvc->getNominalContext();
}

initialize()

StatusCode ActsTrackingGeometryTool::initialize ( )

override

Definition at line 14 of file ActsTrackingGeometryTool.cxx.

                                                {
    ATH_MSG_DEBUG(name() << " initializing");
    if (parent() != toolSvc()) {
        ATH_MSG_ERROR("The tool is initialized as a private tool but should be public");
        return StatusCode::FAILURE;
    }
    ATH_CHECK(m_trackingGeometrySvc.retrieve());
    ATH_CHECK(m_rchk.initialize());
    m_detIdMap = createDetectorElementToGeoIdMap();
    if (!m_detIdMap) {
        return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
}

surfaceIdMap()

const ActsTrk::DetectorElementToActsGeometryIdMap * ActsTrackingGeometryTool::surfaceIdMap ( ) const

overridevirtual

Definition at line 32 of file ActsTrackingGeometryTool.cxx.

                                                                                              {
    return m_detIdMap.get();
}

trackingGeometry()

std::shared_ptr< const Acts::TrackingGeometry > ActsTrackingGeometryTool::trackingGeometry ( ) const

overridevirtual

Definition at line 29 of file ActsTrackingGeometryTool.cxx.

                                                                                           {
    return m_trackingGeometrySvc->trackingGeometry();
}

Member Data Documentation

m_detIdMap

std::unique_ptr<const ActsTrk::DetectorElementToActsGeometryIdMap> ActsTrackingGeometryTool::m_detIdMap {}

private

Definition at line 49 of file ActsTrackingGeometryTool.h.

m_rchk

SG::ReadHandleKey<ActsGeometryContext> ActsTrackingGeometryTool::m_rchk {this, "ActsAlignmentKey", "ActsAlignment", "cond read key for the alignment"}

private

Definition at line 47 of file ActsTrackingGeometryTool.h.

m_trackingGeometrySvc

ServiceHandle<IActsTrackingGeometrySvc> ActsTrackingGeometryTool::m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}

private

Definition at line 45 of file ActsTrackingGeometryTool.h.

---

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

• ActsTrackingGeometryTool.h
• ActsTrackingGeometryTool.cxx