Hash functions to pack the source link into unordered_maps / unordered_sets. More...

Namespaces
namespace	GeoVolIds
	Define the volume parts of the GeometryIdentifier for each ATLAS subsystem centrally.
namespace	FitterHelperFunctions
namespace	MakeDerivedVariant

Classes
class	MeasurementCalibratorBase
	Base class providing the boiler code to fill the Acts multi trajectory track states. More...
class	TrkMeasSurfaceAccessor
	Helper class to access the Acts::Surface for a given Acts::SourceLink which is poiniting to a Trk::MeasurementBase. More...
class	TrkMeasurementCalibrator
	Calibrator class that links the legacy Trk::MeasurementBase objects with the Acts MultiTrajectory track state proxies without applying any further calibrating the measurement. More...
class	TrkPrepRawDataCalibrator
	Class to calibrate the Acts track states with uncalibrated Trk::PrepRaw data objects. More...
class	TrkPrepRawDataSurfaceAcc
	Helper class to access the Acts::surface associated with a Trk::PrepRawData measurement. More...
class	xAODUncalibMeasCalibrator
	Source link calibrator implementation for xAOD::Uncalibrated measurements. More...
class	xAODUncalibMeasSurfAcc
	Helper class to access the Acts::surface associated with an Uncalibrated xAOD measurement. More...
struct	Decoration
struct	accepted_decoration_types
struct	ExpectedLayerPatternHelper
	Helper functions to encode the expected layer patterns in separate columns. More...
class	HitSummaryData
	Helper class to gather hit summary information for e.g. More...
class	SumOfValues
	Helper class to gather statistics and compute the biased variance. More...
struct	TimeInfo
class	TransformStore
	The TransformStore provides a central place to outsource the alignable transforms of the sensitive detector elements and the alignable volumes. More...
class	TrfStoreTicketCounter
	In order that the TransformStore is able to provide enough memory to store the transform centrally, it needs to know how many clients are instantiated for a certain detector type. More...
class	AnalogueClusteringCalibrator
	the Analogue clustering calibrator More...
struct	AnalogueClusteringCalibratorOptions
	Options for the analogue clustering calibrator. More...
class	AnalogueClusteringToolImpl
	the tool to create the analogue clustering calibrator. More...
struct	MeasurementRange
class	GenMeasurementRangeList
class	GenMeasurementRangeListFlat
class	GenUncalibSourceLinkAccessor
	Accessor for the above source link container. More...
class	AtlasMeasurementContainerList
struct	CKF_config
class	DuplicateSeedDetector
class	MeasurementIndex
class	NNClusterCalibrator
	the NN clustering calibrator More...
struct	NNClusterCalibratorOptions
	Options for the NN clustering calibrator that is kind of Analogue calibrator. More...
class	NNClusterCalibratorToolImpl
	the tool to create NN calibrator. More...
class	OnTrackCalibrator
	Inner detector / ITk calibrator implementation used in the KalmanFilterTool. More...
struct	PixelClusterCalibratorOptionsBase
	the base options the options of the options of every PixelClusterCalibrator must be based on More...
class	PixelClusterCalibratorCommon
	the common base class of a PixelClusterCalibrator. More...
class	PixelClusterCalibratorBase
class	PixelClusterCalibrationToolBase
	base class of a Pixel cluster calibration tool In addition to some common functionality provied by PixelClusterCalibrationCommon this class implements the methods to connect the calibrator to the calibrator delegates, and the OnTrack and OnBoundState interfaces which will call a single calibrate method. More...
class	RefittingCalibrator
class	RefittingSurfaceAccesor
class	SharedHitCounter
class	StripCalibrator
class	StripCalibratorToolImpl
class	TrackFindingMeasurements

Typedefs
using	SetterType
using	GetterType
using	CopierType
using	TicketCounterArr = TrfStoreTicketCounter::TicketCounterArr
using	ReturnedTicketArr = TrfStoreTicketCounter::ReturnedTicketArr
using	ReturnedHintArr = TrfStoreTicketCounter::ReturnedHintArr
using	MeasurementRangeList = GenMeasurementRangeList< AtlasMeasurementContainerList >
using	MeasurementRangeListFlat = GenMeasurementRangeListFlat< AtlasMeasurementContainerList >
using	UncalibSourceLinkAccessor = GenUncalibSourceLinkAccessor< MeasurementRangeList >
using	RecoTrackContainer
using	RecoTrackContainerProxy = RecoTrackContainer::TrackProxy
using	RecoTrackStateContainer = Acts::VectorMultiTrajectory
using	RecoTrackStateContainerProxy = RecoTrackStateContainer::TrackStateProxy
using	RecoConstTrackStateContainerProxy = RecoTrackStateContainer::ConstTrackStateProxy
using	Stepper = Acts::SympyStepper
	Adapted from Acts Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithmFunction.cpp.
using	Navigator = Acts::Navigator
using	Propagator = Acts::Propagator<Stepper, Navigator>
using	CKF = Acts::CombinatorialKalmanFilter<Propagator, RecoTrackContainer>
using	Extrapolator = Propagator

Enumerations
enum class	SourceLinkType { TrkMeasurement , TrkPrepRawData , xAODUnCalibMeas , nTypes }
	Enumeration to distinguish between the ATLAS EDM -> Acts::SourceLink variants. More...
enum class	HitCategory : std::uint8_t { DeadSensor , Hole , N }

Functions
std::ostream &	operator<< (std::ostream &ostr, const SourceLinkType sl)
std::size_t	sourceLinkHash (const Acts::SourceLink &sl)
	Calculates the source link hash which is evaluated to be the identifier of the underlying sourcelink.
bool	sourceLinkEquality (const Acts::SourceLink &a, const Acts::SourceLink &b)
	Returns whether two source links are equal.
template<typename T>
const std::any	constDecorationGetter (const SG::IConstAuxStore *container, ActsTrk::IndexType idx, SG::auxid_t decorationId)
template<typename T>
const std::any	decorationGetter (const SG::IAuxStore *container, ActsTrk::IndexType idx, SG::auxid_t decorationId)
template<typename T>
std::any	decorationSetter (SG::IAuxStore *container, ActsTrk::IndexType idx, SG::auxid_t decorationId)
template<typename T>
void	decorationCopier (SG::IAuxStore *dst, ActsTrk::IndexType dst_idx, SG::auxid_t decorationId, const std::any &src_ptr)
template<typename T>
static Decoration	decoration (std::string_view n, GetterType g, CopierType c, SetterType s=static_cast< SetterType >(nullptr))
std::vector< Decoration >	restoreDecorations (const SG::IConstAuxStore *container, const std::set< std::string > &staticVariables)
std::array< unsigned int, 4 >	expectedLayerPattern (const EventContext &ctx, const ActsTrk::IExtrapolationTool &extrapolator, const Acts::BoundTrackParameters &perigee_parameters, double pathLimit)
	Extrapolate from the perigee outwards and gather information which detector layers should have hits.
std::array< unsigned int, 4 >	expectedLayerPattern (std::span< const ActsDetectorElement * > detectorElements)
	From a pre-computed set of detector elements, determine what the hit pattern is and which detector layers should have hits.
void	addToExpectedLayerPattern (std::array< unsigned int, 4 > &pattern, const ActsDetectorElement &detElement)
template<typename T>
bool	build (const std::type_info *typeInfo, const std::string &name, std::vector< Decoration > &decorations)
double	computeDtDs (const Acts::ParticleHypothesis &hypothesis, double qop)
	Helper function to compute dt/ds Helper function to compute the derivative of the time as function of the path length.
Acts::FreeToPathMatrix	computeFreeToPathDerivatives (const Acts::Vector3 &direction, double qop, const Acts::Vector3 &bfield, const Acts::ParticleHypothesis &particle_hypothesis)
	Compute the path length derivatives for the free/bound to curvilinear paramter transform.
std::optional< Acts::BoundMatrix >	convertActsBoundCovToCurvilinearParam (const Acts::GeometryContext &tgContext, const Acts::BoundTrackParameters &param, const Acts::Vector3 &magnFieldVect, const Acts::ParticleHypothesis &particle_hypothesis)
	Convert the covariance of the given Acts track parameters into curvilinear parameterisation.
void	gatherTrackSummaryData (const typename ActsTrk::TrackContainer::ConstTrackProxy &track, const std::array< unsigned short, Acts::toUnderlying(xAOD::UncalibMeasType::nTypes)> &measurement_to_summary_type, SumOfValues &chi2_stat_out, HitSummaryData &hit_info_out, std::vector< ActsTrk::TrackStateBackend::ConstTrackStateProxy::IndexType > &param_state_idx_out, std::array< std::array< uint8_t, Acts::toUnderlying(HitCategory::N)>, Acts::toUnderlying(xAOD::UncalibMeasType::nTypes)> &special_hit_counts_out, TimeInfo &time_info)
	Helper to gather track summary information from the track states of the specified track.
std::string	toString (const DetectorType type)
std::string	toString (const SystemEnvelope type)
std::tuple< std::vector< int >, std::vector< std::vector< int > >, std::vector< std::vector< float > > >	getSDOInformation (const std::vector< Identifier > &rdoList, const InDetSimDataCollection &sdoCollection)
std::tuple< std::vector< float >, std::vector< float >, std::vector< int >, std::vector< int >, std::vector< float >, std::vector< float >, std::vector< float >, std::vector< float >, std::vector< float >, std::vector< float > >	getSiHitInformation (const InDetDD::SiDetectorElement &element, const std::vector< SiHit > &matchingHits)
std::unique_ptr< ActsTrk::IMeasurementSelector >	getMeasurementSelector (const EventContext &ctx, const ActsTrk::IPixelOnTrackCalibratorTool< detail::RecoTrackStateContainer > pixelOnTrackCalibratorTool, const ActsTrk::IStripOnTrackCalibratorTool< detail::RecoTrackStateContainer > stripOnTrackCalibratorTool, const ActsTrk::IHGTDOnTrackCalibratorTool< detail::RecoTrackStateContainer > *hgtdOnTrackCalibratorTool, const ActsTrk::detail::MeasurementRangeList &measurementRanges, const std::vector< float > &etaBinsf, const std::vector< std::pair< float, float > > &chi2CutOffOutlier, const std::vector< size_t > &numMeasurementsCutOff, double edge_hole_border_width)
constexpr unsigned int	setTrackStateFlag (Acts::TrackStateFlag flag)
constexpr bool	testTrackStateFlag (Acts::TrackStateFlag flag, unsigned int flags)

Detailed Description

Hash functions to pack the source link into unordered_maps / unordered_sets.

Put first the GeoPrimitives.

Typedef Documentation

◆ CKF

using ActsTrk::detail::CKF = Acts::CombinatorialKalmanFilter<Propagator, RecoTrackContainer>

Definition at line 33 of file Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h.

◆ CopierType

using ActsTrk::detail::CopierType

Initial value:

std::function<void(SG::IAuxStore*, ActsTrk::IndexType, SG::auxid_t, const std::any&)>

SG::IAuxStore

Interface for non-const operations on an auxiliary store.

Definition IAuxStore.h:51

ActsTrk::IndexType

std::uint32_t IndexType

Definition Decoration.h:18

SG::auxid_t

size_t auxid_t

Identifier for a particular aux data item.

Definition AuxTypes.h:27

Definition at line 24 of file Decoration.h.

◆ Extrapolator

using ActsTrk::detail::Extrapolator = Propagator

Definition at line 34 of file Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h.

◆ GetterType

using ActsTrk::detail::GetterType

Initial value:

std::function<const std::any(

const SG::IConstAuxStore*, ActsTrk::IndexType, SG::auxid_t)>

Definition at line 22 of file Decoration.h.

◆ MeasurementRangeList

using ActsTrk::detail::MeasurementRangeList = GenMeasurementRangeList< AtlasMeasurementContainerList >

Definition at line 255 of file AtlasUncalibSourceLinkAccessor.h.

◆ MeasurementRangeListFlat

using ActsTrk::detail::MeasurementRangeListFlat = GenMeasurementRangeListFlat< AtlasMeasurementContainerList >

Definition at line 256 of file AtlasUncalibSourceLinkAccessor.h.

◆ Navigator

using ActsTrk::detail::Navigator = Acts::Navigator

Definition at line 31 of file Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h.

◆ Propagator

using ActsTrk::detail::Propagator = Acts::Propagator<Stepper, Navigator>

Definition at line 32 of file Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h.

◆ RecoConstTrackStateContainerProxy

using ActsTrk::detail::RecoConstTrackStateContainerProxy = RecoTrackStateContainer::ConstTrackStateProxy

Definition at line 26 of file Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h.

◆ RecoTrackContainer

using ActsTrk::detail::RecoTrackContainer

Initial value:

Acts::TrackContainer<Acts::VectorTrackContainer,

Acts::VectorMultiTrajectory>

Definition at line 21 of file Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h.

◆ RecoTrackContainerProxy

using ActsTrk::detail::RecoTrackContainerProxy = RecoTrackContainer::TrackProxy

Definition at line 23 of file Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h.

◆ RecoTrackStateContainer

using ActsTrk::detail::RecoTrackStateContainer = Acts::VectorMultiTrajectory

Definition at line 24 of file Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h.

◆ RecoTrackStateContainerProxy

using ActsTrk::detail::RecoTrackStateContainerProxy = RecoTrackStateContainer::TrackStateProxy

Definition at line 25 of file Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h.

◆ ReturnedHintArr

using ActsTrk::detail::ReturnedHintArr = TrfStoreTicketCounter::ReturnedHintArr

Definition at line 150 of file TransformStore.cxx.

◆ ReturnedTicketArr

using ActsTrk::detail::ReturnedTicketArr = TrfStoreTicketCounter::ReturnedTicketArr

Definition at line 149 of file TransformStore.cxx.

◆ SetterType

using ActsTrk::detail::SetterType

Initial value:

std::function<std::any(SG::IAuxStore*, ActsTrk::IndexType, SG::auxid_t)>

Definition at line 20 of file Decoration.h.

◆ Stepper

using ActsTrk::detail::Stepper = Acts::SympyStepper

Adapted from Acts Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithmFunction.cpp.

Definition at line 30 of file Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h.

◆ TicketCounterArr

using ActsTrk::detail::TicketCounterArr = TrfStoreTicketCounter::TicketCounterArr

Definition at line 148 of file TransformStore.cxx.

◆ UncalibSourceLinkAccessor

using ActsTrk::detail::UncalibSourceLinkAccessor = GenUncalibSourceLinkAccessor< MeasurementRangeList >

Definition at line 257 of file AtlasUncalibSourceLinkAccessor.h.

Enumeration Type Documentation

◆ HitCategory

enum class ActsTrk::detail::HitCategory : std::uint8_t

strong

Enumerator
DeadSensor
Hole
N

Definition at line 20 of file HitSummaryDataUtils.h.

                         : std::uint8_t {
         DeadSensor,
         Hole,
         N
   };

◆ SourceLinkType

enum class ActsTrk::detail::SourceLinkType

strong

Enumeration to distinguish between the ATLAS EDM -> Acts::SourceLink variants.

Enumerator
TrkMeasurement
TrkPrepRawData	Calibrated Trk::MeasurementBase objects.
xAODUnCalibMeas	UnCalibrated Trk::PrepRawData objects.
nTypes	Uncalbirated xAOD::UnCalibratedMeasurement objects. Number of source link types

Definition at line 12 of file SourceLinkType.h.

                              {
        TrkMeasurement, 
        TrkPrepRawData, 
        xAODUnCalibMeas, 
        nTypes 
    };

Function Documentation

◆ addToExpectedLayerPattern()

void ActsTrk::detail::addToExpectedLayerPattern	(	std::array< unsigned int, 4 > &	pattern,
		const ActsDetectorElement &	detElement )

Definition at line 43 of file ExpectedHitUtils.cxx.

                                                                                                           {
    const InDetDD::SiDetectorElement *
      detEl = dynamic_cast<const InDetDD::SiDetectorElement *>(detElement.upstreamDetectorElement());
    if (detEl) {
      if (detEl->isPixel()) {
        InDetDD::DetectorType type = detEl->design().type();
        unsigned int pattern_idx = type==InDetDD::PixelBarrel ? 0 : 1;
        const PixelID* pixel_id = static_cast<const PixelID *>(detEl->getIdHelper());
        pattern[pattern_idx] |= (1<< pixel_id->layer_disk(detEl->identify()) );
      }
      else if (detEl->isSCT()) {
        // @TODO SCT/strip layer number should be shifted by total number of pixel layers ...
        const SCT_ID* sct_id = static_cast<const SCT_ID *>(detEl->getIdHelper());
        unsigned int pattern_idx = detEl->isBarrel() ? 2 : 3;
        pattern[pattern_idx] |= (1<< sct_id->layer_disk(detEl->identify()) );
      }
    }
  }

◆ build()

template<typename T>

bool ActsTrk::detail::build	(	const std::type_info *	typeInfo,
		const std::string &	name,
		std::vector< Decoration > &	decorations )

Definition at line 78 of file Decoration.cxx.

                                                                                                    {
  if (*typeInfo == typeid(T)) {
    decorations.emplace_back(
        decoration<T>(name, ActsTrk::detail::constDecorationGetter<T>,
                          ActsTrk::detail::decorationCopier<T>));
    return true;
  }
  return false;
}  

◆ computeDtDs()

double ActsTrk::detail::computeDtDs	(	const Acts::ParticleHypothesis &	hypothesis,
		double	qop )

inline

Helper function to compute dt/ds Helper function to compute the derivative of the time as function of the path length.

Definition at line 16 of file CurvilinearCovarianceHelper.h.

                                                                                   {
      return std::hypot(1.,hypothesis.mass() / hypothesis.extractMomentum(qop));
   }

◆ computeFreeToPathDerivatives()

Acts::FreeToPathMatrix ActsTrk::detail::computeFreeToPathDerivatives	(	const Acts::Vector3 &	direction,
		double	qop,
		const Acts::Vector3 &	bfield,
		const Acts::ParticleHypothesis &	particle_hypothesis )

inline

Compute the path length derivatives for the free/bound to curvilinear paramter transform.

Parameters

direction	the direction of trajectory at the location in question
qop	q/p of the particle at the location in question in Acts units
bfield	the magnetic field at the location in question in Acts units
particle_hypothesis	the particle hypothesis e.g. Acts::ParticleHypothesis::pion()

Returns: path length derivatives ( dr(...)/ds, dt/ds, dr(...)/ds2, d qop/ds [== 0] )

Definition at line 27 of file CurvilinearCovarianceHelper.h.

   {
      Acts::FreeToPathMatrix path_length_deriv;
      static_assert(path_length_deriv.cols() == 8);  // ensure that all elements are initialized
      path_length_deriv.segment<3>(Acts::eFreePos0) = direction;
      path_length_deriv(0,Acts::eFreeTime) =  computeDtDs(particle_hypothesis,qop);
      path_length_deriv.segment<3>(Acts::eFreeDir0) = (qop  * direction.cross(bfield)).transpose();
      path_length_deriv(0,Acts::eFreeQOverP) = 0.;
      return path_length_deriv;
   }

◆ constDecorationGetter()

template<typename T>

const std::any ActsTrk::detail::constDecorationGetter	(	const SG::IConstAuxStore *	container,
		ActsTrk::IndexType	idx,
		SG::auxid_t	decorationId )

Definition at line 53 of file Decoration.h.

                                                             {
  const void* data = container->getData(decorationId);
  return &(static_cast<const T*>(data)[idx]);
}

◆ convertActsBoundCovToCurvilinearParam()

std::optional< Acts::BoundMatrix > ActsTrk::detail::convertActsBoundCovToCurvilinearParam	(	const Acts::GeometryContext &	tgContext,
		const Acts::BoundTrackParameters &	param,
		const Acts::Vector3 &	magnFieldVect,
		const Acts::ParticleHypothesis &	particle_hypothesis )

inline

Convert the covariance of the given Acts track parameters into curvilinear parameterisation.

Parameters

tgContext	the current geometry context
param	the Acts track parameters
magnFieldVect	the vector of the magnetic field at the position of the track parameters in Acts units
particle_hypothesis	the particle hypothesis e.g. Acts::ParticleHypothesis::pion() Usage: `using namespace Acts::UnitLiterals; MagField::AtlasFieldCache fieldCache; ... Amg::Vector3D magnFieldVect; fieldCache.getField(param.position(tgContext).data(), magnFieldVect.data()); magnFieldVect *= 1000_T; auto cov = convertActsBoundCovToCurvilinearParam(tgContext, param, magnFieldVect); if (cov.has_value()) { ... }`

Definition at line 61 of file CurvilinearCovarianceHelper.h.

   {
      if (param.covariance().has_value()) {
         Acts::FreeVector freeParams = Acts::transformBoundToFreeParameters(
            param.referenceSurface(), tgContext, param.parameters());
         Acts::Vector3 position = freeParams.segment<3>(Acts::eFreePos0);
         Acts::Vector3 direction = freeParams.segment<3>(Acts::eFreeDir0);
 
         Acts::BoundToFreeMatrix boundToFreeJacobian = param.referenceSurface().boundToFreeJacobian(tgContext, position, direction);
         Acts::FreeMatrix freeTransportJacobian = Acts::FreeMatrix::Identity();
         Acts::FreeToBoundMatrix freeToBoundJacobian;
         Acts::FreeVector freeToPathDerivatives = computeFreeToPathDerivatives(direction,
                                                                               param.parameters()[Acts::eBoundQOverP],
                                                                               magnFieldVect,
                                                                               particle_hypothesis);
         Acts::BoundMatrix fullTransportJacobian;
         Acts::detail::boundToCurvilinearTransportJacobian(direction,
                                                           boundToFreeJacobian,
                                                           freeTransportJacobian,
                                                           freeToBoundJacobian,
                                                           freeToPathDerivatives,
                                                           fullTransportJacobian);
 
         return fullTransportJacobian * param.covariance().value() * fullTransportJacobian.transpose();
      }
      else {
         return {};
      }
   }

◆ decoration()

template<typename T>

Decoration ActsTrk::detail::decoration	(	std::string_view	n,
		GetterType	g,
		CopierType	c,
		SetterType	s = static_cast<SetterType>(nullptr) )

static

Definition at line 87 of file Decoration.h.

                                                                         {
  Decoration dec;
  dec.name = n;
  dec.hash = Acts::hashStringDynamic(n);
  dec.auxid = SG::AuxTypeRegistry::instance().getAuxID<T>(dec.name);
  if (dec.auxid == SG::null_auxid)
    throw std::runtime_error("ActsTrk::Decoration Aux ID for " + dec.name +
                             " could not be found");
  dec.getter = std::move(g);
  dec.copier = std::move(c);
  dec.setter = std::move(s);
  return dec;
}

◆ decorationCopier()

template<typename T>

void ActsTrk::detail::decorationCopier	(	SG::IAuxStore *	dst,
		ActsTrk::IndexType	dst_idx,
		SG::auxid_t	decorationId,
		const std::any &	src_ptr )

Definition at line 80 of file Decoration.h.

                                                                     {
  *std::any_cast<T*>(decorationSetter<T>(dst, dst_idx, decorationId)) =
      *std::any_cast<const T*>(src_ptr);
}

◆ decorationGetter()

template<typename T>

const std::any ActsTrk::detail::decorationGetter	(	const SG::IAuxStore *	container,
		ActsTrk::IndexType	idx,
		SG::auxid_t	decorationId )

Definition at line 61 of file Decoration.h.

                                                        {
  const void* data = container->getData(decorationId);
  return &(static_cast<T*>(data)[idx]);
}

◆ decorationSetter()

template<typename T>

std::any ActsTrk::detail::decorationSetter	(	SG::IAuxStore *	container,
		ActsTrk::IndexType	idx,
		SG::auxid_t	decorationId )

Definition at line 71 of file Decoration.h.

                                                  {
  assert (idx < container->size());
  // The size requested for the decoration must match the size of the container.
  void* data = container->getData(decorationId, container->size(), container->size());
  return &(static_cast<T*>(data)[idx]);
}

◆ expectedLayerPattern() [1/2]

std::array< unsigned int, 4 > ActsTrk::detail::expectedLayerPattern	(	const EventContext &	ctx,
		const ActsTrk::IExtrapolationTool &	extrapolator,
		const Acts::BoundTrackParameters &	perigee_parameters,
		double	pathLimit )

Extrapolate from the perigee outwards and gather information which detector layers should have hits.

Parameters

ctx	the current athena EvetContext @paran extrapolator referece to the Acts extrapolation tool
perigee_parameters	the Acts defining track parameters (parameters at the perigee).
pathLimit	the maximum path length to extrapolate to.

Returns: array of layer pattern words: two pairs for pixel and strips containing the barrel and end caps bit pattern with one bit per detector layer. Will extrapolate from the perigee to the given cylinder volume surface and gather the layers which are crossed and on which hits are expected.

Definition at line 14 of file ExpectedHitUtils.cxx.

                                                                    {
    std::array<unsigned int,4> expected_layer_pattern {0u,0u,0u,0u};
    auto result = extrapolator.propagationSteps(ctx,
                                                perigee_parameters,
                                                Acts::Direction::Forward(),
                                                pathLimit);
    if (!result.ok()) {
        return expected_layer_pattern;
    }
    for (const Acts::detail::Step &step : result->first ) {
        // @TODO boundary check ?, does layer number match layer numbering in athena ?
        // @TODO filter out dead modules
        if (!step.geoID.sensitive()) {
            continue;
        }
        const auto* actsDetEl = getActsDetectorElement(step.surface);
        if (actsDetEl) {
          addToExpectedLayerPattern(expected_layer_pattern, *actsDetEl);
        }
        
    }
    
 
    return expected_layer_pattern;
  }

◆ expectedLayerPattern() [2/2]

std::array< unsigned int, 4 > ActsTrk::detail::expectedLayerPattern ( std::span< const ActsDetectorElement * > detectorElements )

From a pre-computed set of detector elements, determine what the hit pattern is and which detector layers should have hits.

Parameters

detectorElements A set of detector elements to consider

◆ gatherTrackSummaryData()

void ActsTrk::detail::gatherTrackSummaryData	(	const typename ActsTrk::TrackContainer::ConstTrackProxy &	track,
		const std::array< unsigned short, Acts::toUnderlying(xAOD::UncalibMeasType::nTypes)> &	measurement_to_summary_type,
		SumOfValues &	chi2_stat_out,
		HitSummaryData &	hit_info_out,
		std::vector< ActsTrk::TrackStateBackend::ConstTrackStateProxy::IndexType > &	param_state_idx_out,
		std::array< std::array< uint8_t, Acts::toUnderlying(HitCategory::N)>, Acts::toUnderlying(xAOD::UncalibMeasType::nTypes)> &	special_hit_counts_out,
		TimeInfo &	time_info )

Helper to gather track summary information from the track states of the specified track.

Parameters

track	a track of the given acts track container for which the summary information is to be gathered
measurement_to_summary_type	a LUT to map measurement types to the corresponding summary type for the measurement counts
chi2_stat_out	output of the per track state chi-squared sums and squared sums to compute the per state chi2 variance.
hit_info_out	output of the gathered measurement statistics per detector region, layer, ... .
param_state_idx_out	output vector to be filled with the state index of all track states which are not holes.
special_hit_counts_out	arrays to count holes (and @TODO dead sensors) per measurement type.
time_info	will be filled with the mean time and the time resolution, provided at least one hit provides time information.

Definition at line 14 of file HitSummaryDataUtils.cxx.

  {
     chi2_stat_out.reset();
 
     struct TimeInfoHelper { double sum{}; double sumInv2{}; double chi2{}; unsigned int n=0u;};
     TimeInfoHelper time_info_helper;
 
     hit_info_out.reset();
     param_state_idx_out.clear();
 
     const auto lastMeasurementIndex = track.tipIndex();
     track.container().trackStateContainer().visitBackwards(
          lastMeasurementIndex,
          [&measurement_to_summary_type,
           &chi2_stat_out,
           &hit_info_out,
           &param_state_idx_out,
           &special_hit_counts_out,
           &time_info_helper
           ](const typename ActsTrk::TrackStateBackend::ConstTrackStateProxy &state) -> void
          {
 
            auto flag = state.typeFlags();
            if (!state.hasReferenceSurface()) {
               return;
            }
            xAOD::UncalibMeasType det_type = xAOD::UncalibMeasType::Other;
            const auto* placement = dynamic_cast<const ISurfacePlacement*>(state.referenceSurface().surfacePlacement());
            if (placement != nullptr) {
               det_type = toMeasType(placement->detectorType());
            }
 
            if (flag.hasNoExpectedHit()) {
               // @TODO includes holes at sensor edges
               ++special_hit_counts_out.at(Acts::toUnderlying(det_type)).at(Acts::toUnderlying(HitCategory::DeadSensor));
               return;
 
            }
            if (flag.isHole()) {
               const Amg::Vector2D localPos{state.parameters()[Acts::eBoundLoc0],
                                            state.parameters()[Acts::eBoundLoc1]};
               if (state.referenceSurface().insideBounds(localPos)) {
                  // @TODO check whether detector element is dead..
                  ++special_hit_counts_out.at(Acts::toUnderlying(det_type)).at(Acts::toUnderlying(HitCategory::Hole));
               }
               return;
 
            }
            // do not consider material states       
            if (!flag.hasMeasurement() || !state.hasUncalibratedSourceLink()) {
               return;
            }
            param_state_idx_out.push_back(state.index());
       
            // @TODO dead elements
            auto uncalibMeas = detail::xAODUncalibMeasCalibrator::unpack(state.getUncalibratedSourceLink());
            assert( uncalibMeas != nullptr );
            assert( det_type == uncalibMeas->type());
 
            if (measurement_to_summary_type.at(Acts::toUnderlying(uncalibMeas->type())) <  
                xAOD::numberOfTrackSummaryTypes ) {
               HitSummaryData::EHitSelection hit_selection = (flag.isOutlier()
                                                           ? HitSummaryData::Outlier
                                                           : HitSummaryData::Hit);
               if (flag.isSharedHit()) {
                  hit_selection = HitSummaryData::EHitSelection(hit_selection | HitSummaryData::SharedHit);
               }
               if (const auto* idDetEl = getActsDetectorElement(state.referenceSurface()); idDetEl != nullptr) {
                  const auto* siDet = dynamic_cast<const InDetDD::SolidStateDetectorElementBase*>(idDetEl->upstreamDetectorElement());
                  hit_info_out.addHit(det_type, siDet, hit_selection);
               }
 
               if (det_type == xAOD::UncalibMeasType::HGTDClusterType) {
                  if (!flag.isOutlier() && state.hasCalibrated()) {
                     // compute HGTD calibrated
                     assert( state.calibratedSize()==3);
                     auto pos = state.calibrated<3>();
                     auto cov = state.calibratedCovariance<3>();
                     time_info_helper.sum += pos[2]; // Acts time
                     time_info_helper.sumInv2 += 1./cov(2,2);  // Acts time
                     time_info_helper.chi2 += state.chi2();
                     ++time_info_helper.n;
                  }
               }
 
               if (state.calibratedSize()>0 && !flag.isOutlier()) {
                   // from Tracking/TrkTools/TrkTrackSummaryTool/src/TrackSummaryTool.cxx
                   //       processTrackState
                   double chi2add = std::min(state.chi2(),1e5f) / state.calibratedSize();
                   chi2_stat_out.add(chi2add );
                }
             }
 
          });
     hit_info_out.computeSummaries();
     if (time_info_helper.n>1) {
        time_info.mean = static_cast<float>(ActsTrk::timeToAthena( time_info_helper.sum / time_info_helper.n));
        time_info.resolution = static_cast<float>(ActsTrk::timeToAthena(std::sqrt(1./time_info_helper.sumInv2)));
        time_info.chi2 = time_info_helper.chi2;
     }
     else {
        time_info.mean = static_cast<float>(ActsTrk::timeToAthena(time_info_helper.sum));
        time_info.resolution = time_info_helper.n>0 ? static_cast<float>(ActsTrk::timeToAthena(std::sqrt(1./time_info_helper.sumInv2))) : 0.f;
        time_info.chi2 = time_info_helper.chi2;
     }
  }

◆ getMeasurementSelector()

std::unique_ptr< ActsTrk::IMeasurementSelector > ActsTrk::detail::getMeasurementSelector	(	const EventContext &	ctx,
		const ActsTrk::IPixelOnTrackCalibratorTool< detail::RecoTrackStateContainer > *	pixelOnTrackCalibratorTool,
		const ActsTrk::IStripOnTrackCalibratorTool< detail::RecoTrackStateContainer > *	stripOnTrackCalibratorTool,
		const ActsTrk::IHGTDOnTrackCalibratorTool< detail::RecoTrackStateContainer > *	hgtdOnTrackCalibratorTool,
		const ActsTrk::detail::MeasurementRangeList &	measurementRanges,
		const std::vector< float > &	etaBinsf,
		const std::vector< std::pair< float, float > > &	chi2CutOffOutlier,
		const std::vector< size_t > &	numMeasurementsCutOff,
		double	edge_hole_border_width )

Definition at line 397 of file AtlasMeasurementSelector.cxx.

                                      {
 
    // set calibrators per measurement container type (order does not matter);
    ActsTrk::MeasurementCalibrator<detail::RecoTrackStateContainer> atl_measurement_calibrator(ctx,
                                                                                  pixelOnTrackCalibratorTool,
                                                                                  stripOnTrackCalibratorTool,
                                                                                  hgtdOnTrackCalibratorTool);
    using AtlMeasurementSelectorCuts = AtlasMeasurementSelectorCuts;
 
    using AtlMeasurementSelector = AtlasActsMeasurmentSelector<detail::RecoTrackStateContainer>;
    using AtlMeasurementSelectorConfig = AtlMeasurementSelector::TheAtlasMeasurementSelector::Config;
 
    std::unique_ptr<ActsTrk::IMeasurementSelector>
       selector(new AtlMeasurementSelector(
                           std::move(atl_measurement_calibrator),
                           measurementRanges,
                           AtlMeasurementSelectorConfig{
                              {Acts::GeometryIdentifier(),
                                    AtlMeasurementSelectorCuts{ etaBinsf,
                                       chi2CutOffOutlier,
                                       numMeasurementsCutOff,
                                       edge_hole_border_width==0.
                                         ? std::optional<Acts::BoundaryTolerance>{}
                                         : std::optional{Acts::BoundaryTolerance::AbsoluteEuclidean(-std::abs(edge_hole_border_width))}
                                    }
                              }}));
    return selector;
}

◆ getSDOInformation()

std::tuple< std::vector< int >, std::vector< std::vector< int > >, std::vector< std::vector< float > > > ActsTrk::detail::getSDOInformation	(	const std::vector< Identifier > &	rdoList,
		const InDetSimDataCollection &	sdoCollection )

Definition at line 13 of file Tracking/Acts/ActsObjectDecoration/src/detail/Utilities.cxx.

  {
    std::vector<int> sdo_word {};
    std::vector< std::vector< int > > sdo_depositsUniqueID {};
    std::vector< std::vector< float > > sdo_depositsEnergy {};
 
    for (const Identifier hitIdentifier : rdoList) {
      auto pos = sdoCollection.find(hitIdentifier);
      if( pos == sdoCollection.end() ) continue;
 
      sdo_word.push_back( pos->second.word() ) ;
 
      std::vector<int> sdoDepUID(pos->second.getdeposits().size(), HepMC::INVALID_PARTICLE_ID);
      std::vector<float> sdoDepEnergy(pos->second.getdeposits().size());
 
      unsigned int nDepos {0};
      for (const auto& deposit: pos->second.getdeposits()) {
    if (deposit.first) sdoDepUID[nDepos] = HepMC::uniqueID(deposit.first);
    sdoDepEnergy[nDepos] = deposit.second;
    ++nDepos;
      }
 
      sdo_depositsUniqueID.push_back( std::move(sdoDepUID) );
      sdo_depositsEnergy.push_back( std::move(sdoDepEnergy) );
    }
    
    return std::make_tuple(std::move(sdo_word),
                           std::move(sdo_depositsUniqueID),
                           std::move(sdo_depositsEnergy));
  }

◆ getSiHitInformation()

std::tuple< std::vector< float >, std::vector< float >, std::vector< int >, std::vector< int >, std::vector< float >, std::vector< float >, std::vector< float >, std::vector< float >, std::vector< float >, std::vector< float > > ActsTrk::detail::getSiHitInformation	(	const InDetDD::SiDetectorElement &	element,
		const std::vector< SiHit > &	matchingHits )

Definition at line 57 of file Tracking/Acts/ActsObjectDecoration/src/detail/Utilities.cxx.

  {
    int numHits = matchingHits.size();
    
    std::vector<float> sihit_energyDeposit(numHits, 0);
    std::vector<float> sihit_meanTime(numHits, 0);
    std::vector<int>   sihit_uniqueID(numHits, 0);
    std::vector<int>   sihit_pdgid(numHits, 0);
 
    std::vector<float> sihit_startPosX(numHits, 0);
    std::vector<float> sihit_startPosY(numHits, 0);
    std::vector<float> sihit_startPosZ(numHits, 0);
 
    std::vector<float> sihit_endPosX(numHits, 0);
    std::vector<float> sihit_endPosY(numHits, 0);
    std::vector<float> sihit_endPosZ(numHits, 0);
 
    int hitNumber {0};
    for ( const SiHit& sihit : matchingHits ) {
      sihit_energyDeposit[hitNumber] =  sihit.energyLoss() ;
      sihit_meanTime[hitNumber] =  sihit.meanTime() ;
 
      const HepMcParticleLink& HMPL = sihit.particleLink();
      sihit_uniqueID[hitNumber] = HepMC::uniqueID(HMPL);
      if( HMPL.isValid() ){
        sihit_pdgid[hitNumber] = HMPL->pdg_id();
      }
 
      // Convert Simulation frame into reco frame
      const HepGeom::Point3D<double>& startPos=sihit.localStartPosition();
 
      Amg::Vector2D pos = element.hitLocalToLocal( startPos.z(), startPos.y() );
      sihit_startPosX[hitNumber] =  pos[0];
      sihit_startPosY[hitNumber] =  pos[1];
      sihit_startPosZ[hitNumber] =  startPos.x();
 
      const HepGeom::Point3D<double>& endPos=sihit.localEndPosition();
      pos = element.hitLocalToLocal( endPos.z(), endPos.y() );
      sihit_endPosX[hitNumber] =  pos[0];
      sihit_endPosY[hitNumber] =  pos[1];
      sihit_endPosZ[hitNumber] =  endPos.x();
      ++hitNumber;
    }
 
    return std::make_tuple(std::move(sihit_energyDeposit), std::move(sihit_meanTime), std::move(sihit_uniqueID), std::move(sihit_pdgid),
                           std::move(sihit_startPosX), std::move(sihit_startPosY), std::move(sihit_startPosZ),
                           std::move(sihit_endPosX), std::move(sihit_endPosY), std::move(sihit_endPosZ));
  }

◆ operator<<()

std::ostream & ActsTrk::detail::operator<<	(	std::ostream &	ostr,
		const SourceLinkType	sl )

inline

Definition at line 18 of file SourceLinkType.h.

                                                                             {
        switch (sl) {
            using enum SourceLinkType;
            case TrkMeasurement: 
                ostr<<"TrkMeasurement";
                break;
            case TrkPrepRawData: 
                ostr<<"TrkPrepRawData";
                break;
            case xAODUnCalibMeas:
                ostr<<"xAODUnCalibMeas";
                break;
            case nTypes: 
                ostr<<"nTypes";
                break;
        }
        return ostr;
    }

◆ restoreDecorations()

std::vector< Decoration > ActsTrk::detail::restoreDecorations	(	const SG::IConstAuxStore *	container,
		const std::set< std::string > &	staticVariables )

container - source container to look for decorations
staticVariables - set of names of predefined variables for this container

Definition at line 89 of file Decoration.cxx.

                                              {
  std::vector<Decoration> decorations;
  for (auto id : container->getAuxIDs()) {
    const std::string name = SG::AuxTypeRegistry::instance().getName(id);
    const std::type_info* typeInfo =
        SG::AuxTypeRegistry::instance().getType(id);
    if (staticVariables.count(name) == 1) {
      continue;
    }
 
    // try making decoration accessor of matching type
    // there is a fixed set of supported types (as there is a fixed set
    // available in MutableMTJ) setters are not needed so replaced by a
    if ( build<float>(typeInfo, name, decorations) ||
         build<double>(typeInfo, name, decorations) ||
         build<short>(typeInfo, name, decorations) ||
         build<int>(typeInfo, name, decorations) ||
         build<uint8_t>(typeInfo, name, decorations) ||
         build<uint16_t>(typeInfo, name, decorations) ||
         build<uint32_t>(typeInfo, name, decorations) ||
         build<uint64_t>(typeInfo, name, decorations) ||
         build<int8_t>(typeInfo, name, decorations) ||
         build<int16_t>(typeInfo, name, decorations) ||
         build<int32_t>(typeInfo, name, decorations) ||
         build<int64_t>(typeInfo, name, decorations)
        ) {
      continue;
    } 
    throw std::runtime_error("Can't restore decoration of  " + name +
        " because it is of an unsupported type");
  }
  return decorations;
}

◆ setTrackStateFlag()

unsigned int ActsTrk::detail::setTrackStateFlag ( Acts::TrackStateFlag flag )

constexpr

Definition at line 10 of file TrackStateFlagHelper.h.

                                                                     {
      return 1u<<static_cast<unsigned int>(flag);
   }

◆ sourceLinkEquality()

bool ActsTrk::detail::sourceLinkEquality	(	const Acts::SourceLink &	a,
		const Acts::SourceLink &	b )

Returns whether two source links are equal.

Definition at line 31 of file SourceLinkHash.cxx.

                                                                          {
    return sourceLinkHash(a) == sourceLinkHash(b);
}

◆ sourceLinkHash()

std::size_t ActsTrk::detail::sourceLinkHash ( const Acts::SourceLink & sl )

Calculates the source link hash which is evaluated to be the identifier of the underlying sourcelink.

Definition at line 13 of file SourceLinkHash.cxx.

                                                      {
    using namespace ActsTrk::detail;
    switch(MeasurementCalibratorBase::getType(slink)) {
        using enum SourceLinkType;
        case xAODUnCalibMeas:
            return xAODUncalibMeasCalibrator::unpack(slink)->identifier();
        case TrkMeasurement: {
            const auto* rio = dynamic_cast<const Trk::RIO_OnTrack*>(TrkMeasurementCalibrator::unpack(slink));
            assert(rio != nullptr);
            return rio->identify().get_compact();
        } case TrkPrepRawData: {
            return TrkPrepRawDataCalibrator::unpack(slink)->identify().get_compact();
        } default:
            break;
    }
    return 0ul;
}

◆ testTrackStateFlag()

bool ActsTrk::detail::testTrackStateFlag	(	Acts::TrackStateFlag	flag,
		unsigned int	flags )

constexpr

Definition at line 13 of file TrackStateFlagHelper.h.

                                                                                  {
      return flags & setTrackStateFlag(flag);
   }

◆ toString() [1/2]

std::string ActsTrk::detail::toString ( const DetectorType type )

inline

Definition at line 69 of file GeometryDefs.h.

                                                           {
            switch (type) {
                using enum DetectorType;
                ENUM_ITEM_STR(Pixel);
                ENUM_ITEM_STR(Sct);
                ENUM_ITEM_STR(Trt);
                ENUM_ITEM_STR(Hgtd);
                ENUM_ITEM_STR(Mdt);
                ENUM_ITEM_STR(Rpc);
                ENUM_ITEM_STR(Tgc);
                ENUM_ITEM_STR(Csc);
                ENUM_ITEM_STR(Mm);
                ENUM_ITEM_STR(sTgc);
                ENUM_ITEM_STR(UnDefined);
            }
            return "Unknown";
        }

◆ toString() [2/2]

std::string ActsTrk::detail::toString ( const SystemEnvelope type )

inline

Definition at line 86 of file GeometryDefs.h.

                                                             {
            switch (type) {
                using enum SystemEnvelope;
                ENUM_ITEM_STR(ITkExit);
                ENUM_ITEM_STR(CaloExit);
                ENUM_ITEM_STR(MsExit);
            }
            return "Unknown";
        }

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ CKF

◆ CopierType

◆ Extrapolator

◆ GetterType

◆ MeasurementRangeList

◆ MeasurementRangeListFlat

◆ Navigator

◆ Propagator

◆ RecoConstTrackStateContainerProxy

◆ RecoTrackContainer

◆ RecoTrackContainerProxy

◆ RecoTrackStateContainer

◆ RecoTrackStateContainerProxy

◆ ReturnedHintArr

◆ ReturnedTicketArr

◆ SetterType

◆ Stepper

◆ TicketCounterArr

◆ UncalibSourceLinkAccessor

Enumeration Type Documentation

◆ HitCategory

◆ SourceLinkType

Function Documentation

◆ addToExpectedLayerPattern()

◆ build()

◆ computeDtDs()

◆ computeFreeToPathDerivatives()

◆ constDecorationGetter()

◆ convertActsBoundCovToCurvilinearParam()

◆ decoration()

◆ decorationCopier()

◆ decorationGetter()

◆ decorationSetter()

◆ expectedLayerPattern() [1/2]

◆ expectedLayerPattern() [2/2]

◆ gatherTrackSummaryData()

◆ getMeasurementSelector()

◆ getSDOInformation()

◆ getSiHitInformation()

◆ operator<<()

◆ restoreDecorations()

◆ setTrackStateFlag()

◆ sourceLinkEquality()

◆ sourceLinkHash()

◆ testTrackStateFlag()

◆ toString() [1/2]

◆ toString() [2/2]