ActsTrk Namespace Reference

The AlignStoreProviderAlg loads the rigid alignment corrections and pipes them through the readout geometry to cache the final transformations of the sensor surfaces associated to one particular detector technology (Pixel, Sct, etc.). More...

Namespaces
	Cache
	detail
	details
	ParticleHypothesis

Classes
class	ActsToTrkConverterTool
class	ActsToTrkConvertorAlg
class	AdaptiveMultiPriVtxFinderTool
class	AlignStoreProviderAlg
class	AmbiguityResolutionAlg
struct	ATLASSourceLinkSurfaceAccessor
class	ATLASUncalibSourceLinkSurfaceAccessor
class	CaloBasedRoICreatorTool
class	ClusterizationAlg
class	ConstTrackContainerHandlesHelper
class	CoreStripSpacePointFormationTool
struct	DataLinkHolder
class	DataPreparationAlg
class	DetectorAlignCondAlg
class	DetectorAlignStore
struct	DetectorElementToActsGeometryIdMap
class	DetectorElementToActsGeometryIdMappingAlg
class	DetectorVolumeSvc
class	DummyRDOList
class	EstimatedTrackParamsAnalysisAlg
class	FullScanRoICreatorTool
class	GaussianSumFitter
class	GbtsSeedingTool
class	GeometryContextAlg
struct	has_rdoList
struct	has_rdoList< Object, std::void_t< rdoListFunc_t< Object > > >
class	HgtdClusterAnalysisAlg
class	HgtdClusteringTool
class	HgtdClusterizationAlg
class	HgtdClusterValidationPlots
class	HgtdTimedClusteringTool
class	HitCounterArray
class	HitCountsPerTrack
	Container for hit counts per track Contains hit counts per associated truth particle and the total hit counts As last element in the container. More...
class	IActsToTrkConverterTool
class	IDetectorElement
	Base class interface for the actual readout elements. More...
class	IDetectorElementBase
	base class interface providing the bare minimal interface extension. More...
class	IDetectorVolumeBuilderTool
class	IDetectorVolumeSvc
	Interface of the service providing the Acts::Detector which implements the navigation delegate paradigm and eventually replace the legacy tracking geometry. More...
class	IFitterTool
class	IHGTDClusteringTool
class	IMeasurementSelector
class	IOnBoundStateCalibratorTool
class	IOnTrackCalibratorTool
class	IPixelClusteringTool
class	IPixelSpacePointFormationTool
class	IProtoTrackCreatorTool
class	IRoICreatorTool
class	ISeedingTool
class	IStripClusteringTool
class	IStripSpacePointFormationTool
class	IterativePriVtxFinderTool
class	ITkAnalogueClusteringTool
class	ITrackParamsEstimationTool
class	KalmanFitter
struct	MeasurementCalibrator2
class	MeasurementCalibratorBase
struct	MeasurementParameterMap
class	MeasurementToTrackParticleDecoration
class	MeasurementToTruthAssociationAlg
	Algorithm template to associate measurements of a certain type to a xAOD truth particles using a sim data collection where the sim data collection contains associates RDOs to truth particles and there energy/charge disposition. More...
class	MeasurementToTruthParticleAssociation
class	MultiTrajectory
	Read only version of MTJ The implementation is separate as the details are significantly different and in addition only const methods are ever needed. More...
class	MuonDetectorBuilderTool
class	MuonDetectorNavTest
class	MutableMultiTrajectory
	Athena implementation of ACTS::MultiTrajectory (ReadWrite version) The data is stored in 4 external backends. More...
struct	MutableTrackContainer
class	MutableTrackContainerHandlesHelper
class	MutableTrackSummaryContainer
class	NoDeletePtr
class	OrthogonalSeedingTool
class	PhysValTool
class	PixelCacheClusterizationAlg
class	PixelCacheSpacePointFormationAlg
class	PixelClusterAnalysisAlg
class	PixelClusterCacheDataPreparationAlg
class	PixelClusterDataPreparationAlg
class	PixelClusteringTool
class	PixelClusterizationAlg
class	PixelClusterToTruthAssociationAlg
class	PixelClusterValidationPlots
class	PixelSpacePointFormationAlg
class	PixelSpacePointFormationAlgBase
class	PixelSpacePointFormationTool
class	PixelSpacePointValidationPlots
class	PrdAssociationAlg
struct	PRDSourceLink
struct	PRDSourceLinkCalibrator
struct	PRDSourceLinkSurfaceAccessor
class	PrepRawDataAssociation
struct	ProtoTrack
class	ProtoTrackCreationAndFitAlg
class	ProtoTrackReportingAlg
	Very lightweight algorithm to print out the results of the EF track finding. More...
class	RandomProtoTrackCreator
class	ReFitterAlg
class	RegionsOfInterestCreatorAlg
class	ScoreBasedAmbiguityResolutionAlg
class	SeedAnalysisAlg
class	SeedingAlg
class	SeedingAlgorithmAnalysisAlg
class	SeedingTool
class	SeedToTrackCnvAlg
class	SimpleCylinderDetBuilderTool
class	SiSpacePointsSeedMaker
class	SpacePointAnalysisAlg
class	SpacePointCacheDataPreparationAlg
class	SpacePointCollector
class	SpacePointDataPreparationAlg
class	StripCacheClusterizationAlg
class	StripCacheSpacePointFormationAlg
class	StripClusterAnalysisAlg
class	StripClusterCacheDataPreparationAlg
class	StripClusterDataPreparationAlg
class	StripClusteringTool
class	StripClusterizationAlg
class	StripClusterToTruthAssociationAlg
class	StripClusterValidationPlots
class	StripInformationHelper
struct	StripSP
class	StripSpacePointFormationAlg
class	StripSpacePointFormationAlgBase
class	StripSpacePointFormationTool
class	StripSpacePointValidationPlots
class	SurfaceBoundSet
class	SurfaceCache
	: Helper class to connect the aligned transformations of each active sensor(layer) with the Acts::Surfaces. More...
class	TestRoICreatorTool
class	TrackAnalysisAlg
class	TrackContainer
class	TrackContainerReader
class	TrackExtensionAlg
class	TrackFindingAlg
class	TrackFindingValidationAlg
class	TrackParamsEstimationTool
class	TrackParticleAnalysisAlg
class	TrackParticleTruthDecorationAlg
class	TrackStatePrinter
class	TrackSummaryContainer
class	TrackToTrackParticleCnvAlg
class	TrackToTruthAssociationAlg
class	TrackToTruthParticleAssociation
class	TrackTruthMatchingBaseAlg
class	TransformCache
class	TransformCacheDetEle
class	TrkMeasurementCalibrator
class	TrkToActsConvertorAlg
	Algorithm convert Trk::Track to ACTS multistate objects. More...
class	TruthGuidedProtoTrackCreator
class	TruthParticleHitCountAlg

Typedefs
using	volumePtr = std::shared_ptr< DetectorVolume >
using	surfacePtr = std::shared_ptr< Acts::Surface >
using	StripLayerPtr = GeoModel::TransientConstSharedPtr< MuonGMR4::StripLayer >
using	IndexType = std::uint32_t
using	ParticleVector = boost::container::small_vector< const xAOD::TruthParticle *, NTruthParticlesPerMeasurement >
using	StoredSurface = std::variant< const Acts::Surface *, std::shared_ptr< const Acts::Surface > >
typedef std::vector< ActsTrk::ProtoTrack >	ProtoTrackCollection
typedef Acts::Seed< xAOD::SpacePoint, 3ul >	Seed
typedef DataVector< ActsTrk::Seed >	SeedContainer
using	MutableTrackBackend = ActsTrk::MutableTrackSummaryContainer
using	TrackBackend = ActsTrk::TrackSummaryContainer
using	MutableTrackStateBackend = ActsTrk::MutableMultiTrajectory
using	TrackStateBackend = ActsTrk::MultiTrajectory
using	TrackContainerBase = Acts::TrackContainer< ActsTrk::TrackBackend, ActsTrk::TrackStateBackend, ActsTrk::DataLinkHolder >
typedef DataVector< Acts::BoundTrackParameters >	BoundTrackParametersContainer
using	ConstParameters = Acts::TrackStateTraits< 3 >::Parameters
using	ConstCovariance = Acts::TrackStateTraits< 3 >::Covariance
using	Parameters = Acts::TrackStateTraits< 3, false >::Parameters
using	Covariance = Acts::TrackStateTraits< 3, false >::Covariance
using	TruthParticleHitCounts = std::unordered_map< const xAOD::TruthParticle *, HitCounterArray >
using	ATLASSourceLink = const Trk::MeasurementBase *
using	ATLASUncalibSourceLink = const xAOD::UncalibratedMeasurement *
using	DetectorElementKey = unsigned int
using	TicketCounterArr = DetectorAlignStore::TrackingAlignStore::TicketCounterArr
using	ReturnedTicketArr = DetectorAlignStore::TrackingAlignStore::ReturnedTicketArr
using	ReturnedHintArr = DetectorAlignStore::TrackingAlignStore::ReturnedHintArr
template<class BoundType >
using	SurfaceBoundSetPtr = std::shared_ptr< SurfaceBoundSet< BoundType > >
	Aberivation to create a new SurfaceBoundSetPtr. More...
using	SurfaceCacheSet = std::set< std::unique_ptr< SurfaceCache >, std::less<> >
using	StripRDORawData = SCT_RDORawData
template<typename Object >
using	rdoListFunc_t = decltype(std::declval< Object >().rdoList())

Enumerations
enum	NeighbourIndices {   ThisOne, Opposite, PhiMinus, PhiPlus,   EtaMinus, EtaPlus, nNeighbours }
	Total number of neightbours and indices. More...
enum	DetectorType : unsigned short {   DetectorType::Pixel, DetectorType::Sct, DetectorType::Trt, DetectorType::Hgtd,   DetectorType::Mdt, DetectorType::Rpc, DetectorType::Tgc, DetectorType::Csc,   DetectorType::Mm, DetectorType::sTgc, DetectorType::UnDefined }
	Simple enum to Identify the Type of the ACTS sub detector. More...

Functions
std::string	objFileName (std::string str)
void	clusterAddCell (PixelClusteringTool::Cluster &cl, const PixelClusteringTool::Cell &cell)
template<typename IFACE , typename AUX >
std::unique_ptr< IFACE >	makeInterfaceContainer (const AUX *aux)
	helper to construct interface container for already filled Aux container TODO maybe should be moved to xAOD area More...
void	encodeSurface (xAOD::TrackSurfaceAuxContainer *backend, size_t index, const Acts::Surface *surface, const Acts::GeometryContext &geoContext)
	Prepares persistifiable representation of surface into xAOD::TrackSurface object. More...
void	encodeSurface (xAOD::TrackSurface *backend, const Acts::Surface *surface, const Acts::GeometryContext &geoContext)
	As above, but works on xAOD::TrackSurface object. More...
std::shared_ptr< const Acts::Surface >	decodeSurface (const xAOD::TrackSurface *backend, const Acts::GeometryContext &geoContext)
	Creates transient Acts Surface objects given a surface backend implementation should be exact mirror of encodeSurface. More...
std::shared_ptr< const Acts::Surface >	decodeSurface (const xAOD::TrackSurfaceAuxContainer *backend, size_t i, const Acts::GeometryContext &geoContext)
	As above, but takes data from Aux container at an index i. More...
std::string	prefixFromTrackContainerName (const std::string &tracks)
	Parse TrackContainer name to get the prefix for backends The name has to contain XYZTracks, the XYZ is returned. More...
void	encodeSurface (xAOD::SurfaceType &surfaceType, std::vector< float > &translation, std::vector< float > &rotation, std::vector< float > &boundValues, const Acts::Surface *surface, const Acts::GeometryContext &geoContext)
std::shared_ptr< const Acts::Surface >	decodeSurface (const xAOD::SurfaceType surfaceType, const std::vector< float > &translation, const std::vector< float > &rotation, const std::vector< float > &boundValues, const Acts::GeometryContext &)
template<typename T , typename IFACE , typename AUX >
void	recordxAOD (const SG::WriteHandleKey< T > &key, IFACE &iface, AUX &aux, const EventContext &evtContext)
const xAOD::UncalibratedMeasurement &	getUncalibratedMeasurement (const ATLASUncalibSourceLink &source_link)
ATLASUncalibSourceLink	makeATLASUncalibSourceLink (const xAOD::UncalibratedMeasurementContainer *container, std::size_t index, [[maybe_unused]] const EventContext &ctx)
ATLASUncalibSourceLink	makeATLASUncalibSourceLink ([[maybe_unused]] const xAOD::UncalibratedMeasurementContainer *container, const xAOD::UncalibratedMeasurement *measurement, [[maybe_unused]] const EventContext &ctx)
ATLASUncalibSourceLink	makeATLASUncalibSourceLink (const xAOD::UncalibratedMeasurementContainer *container, std::size_t index)
ATLASUncalibSourceLink	makeATLASUncalibSourceLink (const xAOD::UncalibratedMeasurement *measurement)
float	localXFromSourceLink (const ATLASUncalibSourceLink &source_link)
float	localYFromSourceLink (const ATLASUncalibSourceLink &source_link)
DetectorElementKey	makeDetectorElementKey (xAOD::UncalibMeasType meas_type, unsigned int identifier_hash)
const Acts::Surface *	getSurfaceOfMeasurement (const Acts::TrackingGeometry &tracking_geometry, const DetectorElementToActsGeometryIdMap &detector_element_to_geoid, const xAOD::UncalibratedMeasurement &measurement)
Acts::GeometryIdentifier	getSurfaceGeometryIdOfMeasurement (const DetectorElementToActsGeometryIdMap &detector_element_to_geoid, const xAOD::UncalibratedMeasurement &measurement)
std::string	to_string (const DetectorType &type)
bool	operator< (const std::unique_ptr< SurfaceCache > &a, const std::unique_ptr< SurfaceCache > &b)
	Comparison operators. More...
bool	operator< (const IdentifierHash &a, const std::unique_ptr< SurfaceCache > &b)
bool	operator< (const std::unique_ptr< SurfaceCache > &a, const IdentifierHash &b)
Acts::Logging::Level	actsLevelVector (MSG::Level lvl)
MSG::Level	athLevelVector (Acts::Logging::Level lvl)
template<class T_Cont , class T >
std::vector< SG::WriteDecorHandle< T_Cont, T > >	createDecorators (const std::vector< SG::WriteDecorHandleKey< T_Cont > > &keys, const EventContext &ctx)
template<class T_Parent , class T_Cont >
void	createDecoratorKeys (T_Parent &parent, const SG::ReadHandleKey< T_Cont > &container_key, const std::string &prefix, const std::vector< std::string > &decor_names, std::vector< SG::WriteDecorHandleKey< T_Cont > > &decor_out)
template<class T >
auto	getRDOList (const T &a)
template<class T_TruthEventCollection >
auto	makeDepositToTruthParticleMap (const T_TruthEventCollection *truth_particle_links)
template<class T_TruthEventCollection >
const char *	getInTruthPropertyName ()
template<class T_SimDataCollection , class T_SimDataIterator >
auto	getSimDataDeposits (const T_SimDataCollection &sim_data_collection, T_SimDataIterator sim_data_iter_for_identifier)
template<class T_Deposit >
float	getDepositedEnergy (const T_Deposit &)
MsgStream &	operator<< (MsgStream &out, const ActsUtils::Stat &stat)

Variables
constexpr double	ONE_TWELFTH = 1./12.
constexpr unsigned int	NTruthParticlesPerMeasurement = 5
constexpr unsigned int	NHitCounter = static_cast< std::underlying_type<xAOD::UncalibMeasType>::type >(xAOD::UncalibMeasType::nTypes) - 1u
constexpr unsigned int	NTruthParticlesPerTrack = 5
constexpr unsigned int	DETELEMENT_TYPE_SHIFT = 28
constexpr unsigned int	DETELEMENT_HASH_MASK = ~(1<<31|1<<30|1<<29|1<<28)
constexpr bool	TrackToTruthParticleAssociationDebugHists = false
constexpr bool	TrackFindingValidationDebugHists = false
constexpr bool	TrackFindingValidationDetailedStat = true
constexpr bool	TruthParticleHitCountDebugHists = false

Detailed Description

The AlignStoreProviderAlg loads the rigid alignment corrections and pipes them through the readout geometry to cache the final transformations of the sensor surfaces associated to one particular detector technology (Pixel, Sct, etc.).

copied from InDetPhysValMonitoring/src/safeDecorator.h

: The NoDeletePtr is a shared_ptr with disabled deleter.

Header file to manage the common inlcudes.

Includes the GeoPrimitives.

Load ATLAS Eigen library with custom geometry functions.

Put first the GeoPrimitives.

small non-persistent data class to wrap the output of the EF-tracking development pattern finding placeholder

The DetectorAlignCondAlg loads the rigid alignment corrections and pipes them through the readout geometry to cache the final transformations of the sensor surfaces associated to one particular detector technology (Pixel, Sct, etc.).

The transformations are cached in the DetectorAlignmentStore which is later propagated to the ActsGeometryContext.

The ActsFromGeoAlignStore is an adaptor to go from the GeoModel world caching the rigid transformations of the detector elements to the Acts world where transformations

Then load the Acts TypeDef definitions for Eigen

In AthSimulation, the Acts core library is not available yet

ATLAS extension of the Acts::DetectorElementBase. The extension provides extra methods to identify the element within the ATLAS identifier scheme and also the enum indicating to which tracking subsystem the DetectorElement belongs to. Finally, the detector element provides the interface to optionally precache the aligned transformations in the external AlignmentStore of the geometry context.

forward declarations of the classes defined in the package

Typedef Documentation

ATLASSourceLink

using ActsTrk::ATLASSourceLink = typedef const Trk::MeasurementBase *

Definition at line 23 of file ATLASSourceLink.h.

ATLASUncalibSourceLink

using ActsTrk::ATLASUncalibSourceLink = typedef const xAOD::UncalibratedMeasurement *

Definition at line 24 of file ATLASSourceLink.h.

BoundTrackParametersContainer

typedef DataVector< Acts::BoundTrackParameters > ActsTrk::BoundTrackParametersContainer

Definition at line 12 of file Tracking/Acts/ActsEvent/ActsEvent/TrackParametersContainer.h.

ConstCovariance

using ActsTrk::ConstCovariance = typedef Acts::TrackStateTraits<3>::Covariance

Definition at line 50 of file Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h.

ConstParameters

using ActsTrk::ConstParameters = typedef Acts::TrackStateTraits<3>::Parameters

Definition at line 49 of file Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h.

Covariance

using ActsTrk::Covariance = typedef Acts::TrackStateTraits<3, false>::Covariance

Definition at line 52 of file Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h.

DetectorElementKey

using ActsTrk::DetectorElementKey = typedef unsigned int

Definition at line 19 of file DetectorElementToActsGeometryIdMap.h.

IndexType

typedef std::uint32_t ActsTrk::IndexType

Definition at line 13 of file Decoration.h.

MutableTrackBackend

using ActsTrk::MutableTrackBackend = typedef ActsTrk::MutableTrackSummaryContainer

Definition at line 12 of file TrackContainer.h.

MutableTrackStateBackend

using ActsTrk::MutableTrackStateBackend = typedef ActsTrk::MutableMultiTrajectory

Definition at line 14 of file TrackContainer.h.

Parameters

using ActsTrk::Parameters = typedef Acts::TrackStateTraits<3, false>::Parameters

Definition at line 51 of file Tracking/Acts/ActsEvent/ActsEvent/TrackSummaryContainer.h.

ParticleVector

using ActsTrk::ParticleVector = typedef boost::container::small_vector<const xAOD::TruthParticle *, NTruthParticlesPerMeasurement>

Definition at line 17 of file MeasurementToTruthParticleAssociation.h.

ProtoTrackCollection

typedef std::vector<ActsTrk::ProtoTrack> ActsTrk::ProtoTrackCollection

Definition at line 12 of file ProtoTrackCollection.h.

rdoListFunc_t

template<typename Object >

using ActsTrk::rdoListFunc_t = typedef decltype(std::declval<Object>().rdoList())

Definition at line 94 of file MeasurementToTruthAssociationAlg.h.

ReturnedHintArr

using ActsTrk::ReturnedHintArr = typedef DetectorAlignStore::TrackingAlignStore::ReturnedHintArr

Definition at line 16 of file DetectorAlignStore.cxx.

ReturnedTicketArr

using ActsTrk::ReturnedTicketArr = typedef DetectorAlignStore::TrackingAlignStore::ReturnedTicketArr

Definition at line 15 of file DetectorAlignStore.cxx.

Seed

typedef Acts::Seed<xAOD::SpacePoint, 3ul> ActsTrk::Seed

Definition at line 12 of file Seed.h.

SeedContainer

typedef DataVector<ActsTrk::Seed> ActsTrk::SeedContainer

Definition at line 12 of file SeedContainer.h.

StoredSurface

using ActsTrk::StoredSurface = typedef std::variant<const Acts::Surface*, std::shared_ptr<const Acts::Surface> >

Definition at line 69 of file MultiTrajectory.h.

StripLayerPtr

using ActsTrk::StripLayerPtr = typedef GeoModel::TransientConstSharedPtr<MuonGMR4::StripLayer>

Definition at line 59 of file MuonDetectorBuilderTool.cxx.

StripRDORawData

using ActsTrk::StripRDORawData = typedef SCT_RDORawData

Definition at line 21 of file IStripClusteringTool.h.

SurfaceBoundSetPtr

template<class BoundType >

using ActsTrk::SurfaceBoundSetPtr = typedef std::shared_ptr<SurfaceBoundSet<BoundType> >

Aberivation to create a new SurfaceBoundSetPtr.

Definition at line 19 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/Defs.h.

SurfaceCacheSet

using ActsTrk::SurfaceCacheSet = typedef std::set<std::unique_ptr<SurfaceCache>, std::less<> >

Definition at line 22 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/Defs.h.

surfacePtr

using ActsTrk::surfacePtr = typedef std::shared_ptr<Acts::Surface>

Definition at line 58 of file MuonDetectorBuilderTool.cxx.

TicketCounterArr

using ActsTrk::TicketCounterArr = typedef DetectorAlignStore::TrackingAlignStore::TicketCounterArr

Definition at line 14 of file DetectorAlignStore.cxx.

TrackBackend

using ActsTrk::TrackBackend = typedef ActsTrk::TrackSummaryContainer

Definition at line 13 of file TrackContainer.h.

TrackContainerBase

using ActsTrk::TrackContainerBase = typedef Acts::TrackContainer<ActsTrk::TrackBackend, ActsTrk::TrackStateBackend, ActsTrk::DataLinkHolder>

Definition at line 26 of file TrackContainer.h.

TrackStateBackend

using ActsTrk::TrackStateBackend = typedef ActsTrk::MultiTrajectory

Definition at line 15 of file TrackContainer.h.

TruthParticleHitCounts

using ActsTrk::TruthParticleHitCounts = typedef std::unordered_map<const xAOD::TruthParticle *,HitCounterArray>

Definition at line 19 of file TruthParticleHitCounts.h.

volumePtr

using ActsTrk::volumePtr = typedef std::shared_ptr<DetectorVolume>

Definition at line 57 of file MuonDetectorBuilderTool.cxx.

Enumeration Type Documentation

DetectorType

enum ActsTrk::DetectorType : unsigned short

strong

Simple enum to Identify the Type of the ACTS sub detector.

Enumerator
Pixel	Inner detector legacy.
Sct
Trt	Maybe the Sct / Pixel for Itk become seperate entries?
Hgtd
Mdt	MuonSpectrometer.
Rpc	Monitored Drift Tubes.
Tgc	Resitive Plate Chambers.
Csc	Thin gap champers.
Mm	Maybe not needed in the migration.
sTgc	Micromegas (NSW)
UnDefined	Small Thing Gap chambers (NSW)

Definition at line 17 of file GeometryDefs.h.

                           : unsigned short {
        Pixel,
        Sct,
        Trt,
        Hgtd,
        Mdt,  
        Rpc,  
        Tgc,  
        Csc,  
        Mm,   
        sTgc,  
        UnDefined
    };

NeighbourIndices

enum ActsTrk::NeighbourIndices

Total number of neightbours and indices.

Enumerator
ThisOne
Opposite
PhiMinus
PhiPlus
EtaMinus
EtaPlus
nNeighbours

Definition at line 13 of file StripInformationHelper.h.

{ThisOne, Opposite, PhiMinus, PhiPlus, EtaMinus, EtaPlus, nNeighbours};

Function Documentation

actsLevelVector()

Acts::Logging::Level ActsTrk::actsLevelVector

(

MSG::Level

lvl

)

Definition at line 9 of file LoggerUtils.cxx.

                                                 {
    // MSG::NIL and MSG::ALWAYS are not available in Acts. Need to protect against these
    // For MSG::NIL we can return a Acts::Logging::Level::FATAL;
    // For MSG::ALWAYS we can return a Acts::Logging::Level::VERBOSE
 
    // Gaudi definitions are +1 w.r.t. Acts definitions  
    static const std::array<Acts::Logging::Level, 8> actsLevelVector{
      Acts::Logging::Level::FATAL, // MSG::NIL
      Acts::Logging::Level::VERBOSE,
      Acts::Logging::Level::DEBUG,
      Acts::Logging::Level::INFO,
      Acts::Logging::Level::WARNING,
      Acts::Logging::Level::ERROR,
      Acts::Logging::Level::FATAL,
      Acts::Logging::Level::VERBOSE // MSG::ALWAYS
    };
 
    return actsLevelVector[static_cast<int>(lvl)];
  }

athLevelVector()

MSG::Level ActsTrk::athLevelVector

(

Acts::Logging::Level

lvl

)

Definition at line 29 of file LoggerUtils.cxx.

                                                {
    // All Acts log levels are available in Gaudi, no need for protections
    static const std::array<MSG::Level, 6> athLevelVector{
      MSG::VERBOSE,
      MSG::DEBUG,
      MSG::INFO,
      MSG::WARNING,
      MSG::ERROR,
      MSG::FATAL
    };   
    return athLevelVector[static_cast<int>(lvl)];
  }

clusterAddCell()

void ActsTrk::clusterAddCell	(	PixelClusteringTool::Cluster &	cl,
		const PixelClusteringTool::Cell &	cell
	)

Definition at line 21 of file PixelClusteringTool.cxx.

{
  cl.ids.push_back(cell.ID);
  cl.tots.push_back(cell.TOT);
  if (cell.LVL1 < cl.lvl1min)
    cl.lvl1min = cell.LVL1;
}

createDecoratorKeys()

template<class T_Parent , class T_Cont >

void ActsTrk::createDecoratorKeys	(	T_Parent &	parent,
		const SG::ReadHandleKey< T_Cont > &	container_key,
		const std::string &	prefix,
		const std::vector< std::string > &	decor_names,
		std::vector< SG::WriteDecorHandleKey< T_Cont > > &	decor_out
	)

Definition at line 49 of file decoratorUtils.h.

                                                                                 {
    decor_out.clear();
    decor_out.reserve(decor_names.size());
    for (const std::string &a_decor_name : decor_names) {
      assert( !a_decor_name.empty() );
      decor_out.emplace_back(container_key.key()+"."+prefix+a_decor_name);
      // need to declare handles, otherwise the scheduler would not pick up the data dependencies
      // introduced by the decorations
      parent.declare(decor_out.back());
      decor_out.back().setOwner(&parent);
      decor_out.back().initialize().ignore();
    }
  }

createDecorators()

template<class T_Cont , class T >

std::vector<SG::WriteDecorHandle<T_Cont,T> > ActsTrk::createDecorators	(	const std::vector< SG::WriteDecorHandleKey< T_Cont > > &	keys,
		const EventContext &	ctx
	)

Definition at line 31 of file decoratorUtils.h.

                                              {
    std::vector<SG::WriteDecorHandle<T_Cont,T> > out;
    out.reserve(keys.size());
    for( const SG::WriteDecorHandleKey<T_Cont> &a_key : keys) {
      out.emplace_back(a_key,ctx);
      if (not out.back().isValid()) {
        std::stringstream msg;
        msg << "Failed to create decorator handdle " << a_key.key();
        throw std::runtime_error( msg.str() );
      }
    }
    return out;
  }

decodeSurface() [1/3]

std::shared_ptr<const Acts::Surface> ActsTrk::decodeSurface	(	const xAOD::SurfaceType	surfaceType,
		const std::vector< float > &	translation,
		const std::vector< float > &	rotation,
		const std::vector< float > &	boundValues,
		const Acts::GeometryContext &
	)

Definition at line 74 of file SurfaceEncoding.cxx.

                                {
 
  // Translation and rotation
 
  // create the transformation matrix
  auto transform = Acts::Transform3(
      Acts::Translation3(translation[0], translation[1], translation[2]));
  transform *=
      Acts::AngleAxis3(rotation[0], Acts::Vector3(0., 0., 1.));  // rotZ
  transform *=
      Acts::AngleAxis3(rotation[1], Acts::Vector3(0., 1., 0.));  // rotY
  transform *=
      Acts::AngleAxis3(rotation[2], Acts::Vector3(1., 0., 0.));  // rotX
 
  // cone
  if (surfaceType == xAOD::Cone) {
    auto surface = Acts::Surface::makeShared<Acts::ConeSurface>(
        transform, boundValues[0], boundValues[1], boundValues[2],
        boundValues[3]);
    return surface;
  }
  // Cylinder
  else if (surfaceType == xAOD::Cylinder) {
    // phi/2 must be slightly < Pi to avoid crashing
    float fixedPhi =
        boundValues[2] > M_PI - 0.001 ? M_PI - 0.001 : boundValues[2];
    auto surface = Acts::Surface::makeShared<Acts::CylinderSurface>(
        transform, boundValues[0], boundValues[1], fixedPhi, boundValues[3],
        boundValues[4]);
    return surface;
  }
  // Disc
  else if (surfaceType == xAOD::Disc) {
    auto surface = Acts::Surface::makeShared<Acts::DiscSurface>(
        transform, boundValues[0], boundValues[1], boundValues[2]);
    return surface;
  }
  // Perigee
  else if (surfaceType == xAOD::Perigee) {
    auto surface = Acts::Surface::makeShared<Acts::PerigeeSurface>(transform);
    return surface;
  }
  // Plane
  else if (surfaceType == xAOD::Plane) {
    Acts::Vector2 min(boundValues[0], boundValues[1]),
        max(boundValues[2], boundValues[3]);
    auto rBounds = std::make_shared<const Acts::RectangleBounds>(min, max);
    auto surface =
        Acts::Surface::makeShared<Acts::PlaneSurface>(transform, rBounds);
    return surface;
  }
  // Straw
  else if (surfaceType == xAOD::Straw) {
    auto surface = Acts::Surface::makeShared<Acts::StrawSurface>(
        transform, boundValues[0], boundValues[1]);
    return surface;
  } else {
    throw std::out_of_range(
        "encodeSurface this type " +
        std::to_string(static_cast<int>(surfaceType)) +
        " of Acts Surface can not be saved in xAOD::TrackSurface");
    return nullptr;
  }
  return nullptr;
}

decodeSurface() [2/3]

std::shared_ptr< const Acts::Surface > ActsTrk::decodeSurface	(	const xAOD::TrackSurface *	backend,
		const Acts::GeometryContext &	geoContext
	)

Creates transient Acts Surface objects given a surface backend implementation should be exact mirror of encodeSurface.

Definition at line 143 of file SurfaceEncoding.cxx.

                                                               {
  return decodeSurface(s->surfaceType(), s->translation(), s->rotation(),
                       s->boundValues(), geo);
}

decodeSurface() [3/3]

std::shared_ptr< const Acts::Surface > ActsTrk::decodeSurface	(	const xAOD::TrackSurfaceAuxContainer *	backend,
		size_t	i,
		const Acts::GeometryContext &	geoContext
	)

As above, but takes data from Aux container at an index i.

Definition at line 149 of file SurfaceEncoding.cxx.

                                    {
  return decodeSurface(s->surfaceType[i], s->translation[i], s->rotation[i],
                       s->boundValues[i], geo);
}

encodeSurface() [1/3]

void ActsTrk::encodeSurface	(	xAOD::SurfaceType &	surfaceType,
		std::vector< float > &	translation,
		std::vector< float > &	rotation,
		std::vector< float > &	boundValues,
		const Acts::Surface *	surface,
		const Acts::GeometryContext &	geoContext
	)

Definition at line 7 of file SurfaceEncoding.cxx.

                                                          {
  // return if surf is a nullptr
  if (surface == nullptr) {
    return;
  }
 
  // surface type specifics
  if (surface->type() == Acts::Surface::Cone) {
    surfaceType = xAOD::SurfaceType::Cone;
  } else if (surface->type() == Acts::Surface::Cylinder) {
    surfaceType = xAOD::SurfaceType::Cylinder;
  } else if (surface->type() == Acts::Surface::Disc) {
    surfaceType = xAOD::SurfaceType::Disc;
  } else if (surface->type() == Acts::Surface::Perigee) {
    surfaceType = xAOD::SurfaceType::Perigee;
  } else if (surface->type() == Acts::Surface::Plane) {
    surfaceType = xAOD::SurfaceType::Plane;
  } else if (surface->type() == Acts::Surface::Straw) {
    surfaceType = xAOD::SurfaceType::Straw;
  } else {
    throw std::out_of_range(
        "encodeSurface this type " +
        std::to_string(static_cast<int>(surface->type())) +
        " of Acts Surface can not be saved in xAOD::TrackSurface");
    return;
  }
 
  Acts::RotationMatrix3 lRotation =
      surface->transform(geoContext).rotation();
  Acts::Vector3 eulerAngles = lRotation.eulerAngles(2, 1, 0);
  Acts::Vector3 lTranslation = surface->center(geoContext);
 
  for (int i = 0; i < 3; i++) {
    rotation.push_back(eulerAngles[i]);
    translation.push_back(lTranslation[i]);
  }
 
  // copy and transform double->float
  const std::vector<double>& values = surface->bounds().values();
  for (double v: values)
    boundValues.push_back(v);
}

encodeSurface() [2/3]

void ActsTrk::encodeSurface	(	xAOD::TrackSurface *	backend,
		const Acts::Surface *	surface,
		const Acts::GeometryContext &	geoContext
	)

As above, but works on xAOD::TrackSurface object.

Definition at line 62 of file SurfaceEncoding.cxx.

                                                   {
  xAOD::SurfaceType surfaceType;
  std::vector<float> translation, rotation, bounds;
  encodeSurface(surfaceType, translation, rotation, bounds, surface, geo);
 
  s->setSurfaceType(surfaceType);
  s->setTranslation(translation);
  s->setRotation(rotation);
  s->setBoundValues(bounds);
}

encodeSurface() [3/3]

void ActsTrk::encodeSurface	(	xAOD::TrackSurfaceAuxContainer *	backend,
		size_t	index,
		const Acts::Surface *	surface,
		const Acts::GeometryContext &	geoContext
	)

Prepares persistifiable representation of surface into xAOD::TrackSurface object.

Warning

supports only few types, unhandled surface type results in a exception

• backend - container to store surface data
• index - index under which the data needs to be recorded

Definition at line 55 of file SurfaceEncoding.cxx.

                                                   {
  encodeSurface(s->surfaceType[i], s->translation[i], s->rotation[i],
                s->boundValues[i], surface, geo);
}

getDepositedEnergy()

template<class T_Deposit >

float ActsTrk::getDepositedEnergy

(

const T_Deposit &

)

getInTruthPropertyName()

template<class T_TruthEventCollection >

const char* ActsTrk::getInTruthPropertyName ( )

inline

getRDOList()

template<class T >

auto ActsTrk::getRDOList

(

const T &

a

)

Definition at line 109 of file MeasurementToTruthAssociationAlg.h.

                              {
     if constexpr(has_rdoList<T>::value) {
        return a.rdoList();
     }
     else {
        return DummyRDOList(a);
     }
  }

getSimDataDeposits()

template<class T_SimDataCollection , class T_SimDataIterator >

auto ActsTrk::getSimDataDeposits	(	const T_SimDataCollection &	sim_data_collection,
		T_SimDataIterator	sim_data_iter_for_identifier
	)

getSurfaceGeometryIdOfMeasurement()

Acts::GeometryIdentifier ActsTrk::getSurfaceGeometryIdOfMeasurement ( const DetectorElementToActsGeometryIdMap &  detector_element_to_geoid, const xAOD::UncalibratedMeasurement &  measurement  )

inline

Definition at line 24 of file SurfaceOfMeasurementUtil.h.

  {
     DetectorElementToActsGeometryIdMap::const_iterator
        geoid_iter = detector_element_to_geoid.find( makeDetectorElementKey(measurement.type(), measurement.identifierHash()) );
     return  geoid_iter != detector_element_to_geoid.end()
        ? DetectorElementToActsGeometryIdMap::getValue( *geoid_iter)
        : Acts::GeometryIdentifier{};
  }

getSurfaceOfMeasurement()

const Acts::Surface* ActsTrk::getSurfaceOfMeasurement ( const Acts::TrackingGeometry &  tracking_geometry, const DetectorElementToActsGeometryIdMap &  detector_element_to_geoid, const xAOD::UncalibratedMeasurement &  measurement  )

inline

Definition at line 13 of file SurfaceOfMeasurementUtil.h.

  {
     DetectorElementToActsGeometryIdMap::const_iterator
        geoid_iter = detector_element_to_geoid.find( makeDetectorElementKey(measurement.type(), measurement.identifierHash()) );
     return  (geoid_iter != detector_element_to_geoid.end())
        ?  tracking_geometry.findSurface( DetectorElementToActsGeometryIdMap::getValue(*geoid_iter) )
        : nullptr;
  }

getUncalibratedMeasurement()

const xAOD::UncalibratedMeasurement& ActsTrk::getUncalibratedMeasurement ( const ATLASUncalibSourceLink &  source_link )

inline

Definition at line 26 of file ATLASSourceLink.h.

                                                                                                                   {
      assert(source_link);
      return *source_link;
   }

localXFromSourceLink()

float ActsTrk::localXFromSourceLink ( const ATLASUncalibSourceLink &  source_link )

inline

Definition at line 53 of file ATLASSourceLink.h.

                                                                                {
      const xAOD::UncalibratedMeasurement &uncalib_meas = getUncalibratedMeasurement(source_link);
      return uncalib_meas.type() == xAOD::UncalibMeasType::PixelClusterType
         ? uncalib_meas.localPosition<2>()[Trk::locX]
         : uncalib_meas.localPosition<1>()[Trk::locX];
   }

localYFromSourceLink()

float ActsTrk::localYFromSourceLink ( const ATLASUncalibSourceLink &  source_link )

inline

Definition at line 60 of file ATLASSourceLink.h.

                                                                                {
      const xAOD::UncalibratedMeasurement &uncalib_meas = getUncalibratedMeasurement(source_link);
      assert(uncalib_meas.type() == xAOD::UncalibMeasType::PixelClusterType );
      return uncalib_meas.localPosition<2>()[Trk::locY];
   }

makeATLASUncalibSourceLink() [1/4]

ATLASUncalibSourceLink ActsTrk::makeATLASUncalibSourceLink ( [[maybe_unused] ] const xAOD::UncalibratedMeasurementContainer *  container, const xAOD::UncalibratedMeasurement *  measurement, [[maybe_unused] ] const EventContext &  ctx  )

inline

Definition at line 36 of file ATLASSourceLink.h.

                                                                                                      {
      assert( container == measurement->container());
      assert( container && measurement->index() < container->size() );
      return measurement;
   }

makeATLASUncalibSourceLink() [2/4]

ATLASUncalibSourceLink ActsTrk::makeATLASUncalibSourceLink ( const xAOD::UncalibratedMeasurement *  measurement )

inline

Definition at line 49 of file ATLASSourceLink.h.

                                                                                                            {
      assert(measurement && measurement->container() && measurement->index() < measurement->container()->size_v());
      return measurement;
   }

makeATLASUncalibSourceLink() [3/4]

ATLASUncalibSourceLink ActsTrk::makeATLASUncalibSourceLink ( const xAOD::UncalibratedMeasurementContainer *  container, std::size_t  index  )

inline

Definition at line 43 of file ATLASSourceLink.h.

                                                                             {
      assert(container && index < container->size());
      return container->at(index);
   }

makeATLASUncalibSourceLink() [4/4]

ATLASUncalibSourceLink ActsTrk::makeATLASUncalibSourceLink ( const xAOD::UncalibratedMeasurementContainer *  container, std::size_t  index, [[maybe_unused] ] const EventContext &  ctx  )

inline

Definition at line 30 of file ATLASSourceLink.h.

                                                                                                      {
      assert(container && index < container->size());
      return container->at(index);
   }

makeDepositToTruthParticleMap()

template<class T_TruthEventCollection >

auto ActsTrk::makeDepositToTruthParticleMap

(

const T_TruthEventCollection *

truth_particle_links

)

makeDetectorElementKey()

DetectorElementKey ActsTrk::makeDetectorElementKey ( xAOD::UncalibMeasType  meas_type, unsigned int  identifier_hash  )

inline

Definition at line 23 of file DetectorElementToActsGeometryIdMap.h.

                                                                                                          {
      assert( sizeof(xAOD::UncalibMeasType) <= sizeof(std::size_t) );
      assert( static_cast<std::size_t>( to_underlying(meas_type)&((~DETELEMENT_HASH_MASK)>>DETELEMENT_TYPE_SHIFT)) == static_cast<std::size_t>(meas_type));
      assert( (identifier_hash & DETELEMENT_HASH_MASK) == identifier_hash);
      return (to_underlying(meas_type) << DETELEMENT_TYPE_SHIFT) | (identifier_hash & DETELEMENT_HASH_MASK);
   }

makeInterfaceContainer()

template<typename IFACE , typename AUX >

std::unique_ptr<IFACE> ActsTrk::makeInterfaceContainer

(

const AUX *

aux

)

helper to construct interface container for already filled Aux container TODO maybe should be moved to xAOD area

Definition at line 498 of file MultiTrajectory.h.

                                                            {
  auto interface = std::make_unique<IFACE>();
  for ( size_t i = 0, sz = aux->size(); i < sz; ++i) {
    interface->emplace_back( new std::remove_pointer_t<typename IFACE::value_type>() );
  }
  interface->setStore(aux);
  return interface;
}

objFileName()

std::string ActsTrk::objFileName ( std::string  str )

inline

Definition at line 51 of file MuonDetectorBuilderTool.cxx.

                                                {
        str = GeoStrUtils::replaceExpInString(str, " ", "_");
        str = GeoStrUtils::replaceExpInString(str, "-", "M");
        return std::format("{:}.obj", str);
    }

operator<() [1/3]

bool ActsTrk::operator< ( const IdentifierHash &  a, const std::unique_ptr< SurfaceCache > &  b  )

inline

Definition at line 63 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/SurfaceCache.h.

                                                                                       {
      return a < b->hash();
  }

operator<() [2/3]

bool ActsTrk::operator< ( const std::unique_ptr< SurfaceCache > &  a, const IdentifierHash &  b  )

inline

Definition at line 66 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/SurfaceCache.h.

                                                                                       {
      return a->hash() < b;
  }  

operator<() [3/3]

bool ActsTrk::operator< ( const std::unique_ptr< SurfaceCache > &  a, const std::unique_ptr< SurfaceCache > &  b  )

inline

Comparison operators.

Definition at line 59 of file Tracking/Acts/ActsGeoUtils/ActsGeoUtils/SurfaceCache.h.

                                                              {
      return a->hash() < b->hash();
  }

operator<<()

MsgStream & ActsTrk::operator<< ( MsgStream &  out, const ActsUtils::Stat &  stat  )

inline

Definition at line 25 of file TrackToTruthAssociationAlg.cxx.

                                                                          {
     ActsUtils::dumpStat(out, stat);
     return out;
  }

prefixFromTrackContainerName()

std::string ActsTrk::prefixFromTrackContainerName

(

const std::string &

tracks

)

Parse TrackContainer name to get the prefix for backends The name has to contain XYZTracks, the XYZ is returned.

Definition at line 18 of file TrackContainerHandlesHelper.cxx.

                                                                {
  std::regex word_regex("(.*)Tracks$");
  std::smatch match_regex;
  
  if ( not std::regex_search(tracks, match_regex, word_regex) or match_regex.size() < 2) {
    throw std::runtime_error(
       std::string("prefixFromTrackContainerName: key does not contain "
           "Tracks in the name ") + tracks);
  }
 
  return match_regex[1].str();
}

recordxAOD()

template<typename T , typename IFACE , typename AUX >

void ActsTrk::recordxAOD	(	const SG::WriteHandleKey< T > &	key,
		IFACE &	iface,
		AUX &	aux,
		const EventContext &	evtContext
	)

Definition at line 32 of file TrackContainerHandlesHelper.cxx.

                                                {
  SG::WriteHandle<T> handle = SG::makeHandle(key, evtContext);
  if (handle.record(std::move(iface), std::move(aux)).isFailure()) {
    throw std::runtime_error(
        std::string("MutableTrackContainerHandlesHelper::recordxAOD, can't record ") + key.key() + " backend");
  }
}

to_string()

std::string ActsTrk::to_string ( const DetectorType &  type )

inline

Definition at line 34 of file GeometryDefs.h.

                                                         {
        if (type == DetectorType::Pixel)
            return "Pixel";
        else if (type == DetectorType::Sct)
            return "Sct";
        else if (type == DetectorType::Trt)
            return "Trt";
        else if (type == DetectorType::Hgtd)
            return "Hgtd";
        else if (type == DetectorType::Mdt)
            return "Mdt";
        else if (type == DetectorType::Rpc)
            return "Rpc";
        else if (type == DetectorType::Tgc)
            return "Tgc";
        else if (type == DetectorType::Csc)
            return "Csc";
        else if (type == DetectorType::Mm)
            return "Mm";
        else if (type == DetectorType::sTgc)
            return "sTgc";
        return "Unknown";
    }

Variable Documentation

DETELEMENT_HASH_MASK

constexpr unsigned int ActsTrk::DETELEMENT_HASH_MASK = ~(1<<31|1<<30|1<<29|1<<28)

constexpr

Definition at line 21 of file DetectorElementToActsGeometryIdMap.h.

DETELEMENT_TYPE_SHIFT

constexpr unsigned int ActsTrk::DETELEMENT_TYPE_SHIFT = 28

constexpr

Definition at line 20 of file DetectorElementToActsGeometryIdMap.h.

NHitCounter

constexpr unsigned int ActsTrk::NHitCounter = static_cast< std::underlying_type<xAOD::UncalibMeasType>::type >(xAOD::UncalibMeasType::nTypes) - 1u

constexpr

Definition at line 19 of file TrackToTruthParticleAssociation.h.

NTruthParticlesPerMeasurement

constexpr unsigned int ActsTrk::NTruthParticlesPerMeasurement = 5

constexpr

Definition at line 14 of file MeasurementToTruthParticleAssociation.h.

NTruthParticlesPerTrack

constexpr unsigned int ActsTrk::NTruthParticlesPerTrack = 5

constexpr

Definition at line 20 of file TrackToTruthParticleAssociation.h.

ONE_TWELFTH

constexpr double ActsTrk::ONE_TWELFTH = 1./12.

constexpr

Definition at line 17 of file StripClusteringTool.cxx.

TrackFindingValidationDebugHists

constexpr bool ActsTrk::TrackFindingValidationDebugHists = false

constexpr

Definition at line 41 of file TrackTruthMatchingBaseAlg.h.

TrackFindingValidationDetailedStat

constexpr bool ActsTrk::TrackFindingValidationDetailedStat = true

constexpr

Definition at line 42 of file TrackTruthMatchingBaseAlg.h.

TrackToTruthParticleAssociationDebugHists

constexpr bool ActsTrk::TrackToTruthParticleAssociationDebugHists = false

constexpr

Definition at line 42 of file TrackToTruthAssociationAlg.h.

TruthParticleHitCountDebugHists

constexpr bool ActsTrk::TruthParticleHitCountDebugHists = false

constexpr

Definition at line 42 of file TruthParticleHitCountAlg.h.