Athena definition of the Eigen plugin. More...

Namespaces
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...
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	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	SharedHitCounter
class	StripCalibrator
class	StripCalibratorToolImpl
class	TrackFindingMeasurements

Typedefs
using	SetterType
using	GetterType
using	CopierType
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)
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)
	Helper to gather track summary information from the track states of the specified track.
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::IPixelOnBoundStateCalibratorTool pixelOnTrackCalibratorTool, const ActsTrk::IStripOnBoundStateCalibratorTool stripOnTrackCalibratorTool, const ActsTrk::IHGTDOnBoundStateCalibratorTool *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)

Detailed Description

Athena definition of the Eigen plugin.

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:16

SG::auxid_t

size_t auxid_t

Identifier for a particular aux data item.

Definition AuxTypes.h:27

Definition at line 22 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 20 of file Decoration.h.

◆ MeasurementRangeList

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

Definition at line 252 of file AtlasUncalibSourceLinkAccessor.h.

◆ MeasurementRangeListFlat

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

Definition at line 253 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.

◆ SetterType

using ActsTrk::detail::SetterType

Initial value:

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

Definition at line 18 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.

◆ UncalibSourceLinkAccessor

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

Definition at line 254 of file AtlasUncalibSourceLinkAccessor.h.

Enumeration Type Documentation

◆ HitCategory

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

strong

Enumerator
DeadSensor
Hole
N

Definition at line 21 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 11 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 42 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 26 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 51 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 85 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 78 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 59 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 69 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()) {
      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()) {
          if (step.surface && step.surface->surfacePlacement()) {
            const ActsDetectorElement *
              actsDetEl = dynamic_cast<const ActsDetectorElement *>(step.surface->surfacePlacement());
            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 )

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.

Definition at line 17 of file HitSummaryDataUtils.cxx.

  {
     chi2_stat_out.reset();
 
     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
           ](const typename ActsTrk::TrackStateBackend::ConstTrackStateProxy &state) -> void
          {
 
            auto flag = state.typeFlags();
            if (!state.hasReferenceSurface()) {
               return;
            }
            xAOD::UncalibMeasType det_type = xAOD::UncalibMeasType::Other;
            const auto* detEl = dynamic_cast<const IDetectorElementBase*>(state.referenceSurface().surfacePlacement());
            if (detEl != nullptr) {
               det_type = toMeasType(detEl->detectorType());
            }
 
            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);
               }
               const InDetDD::SiDetectorElement* siDet{nullptr};
               if (const auto* idDetEl = dynamic_cast<const ActsDetectorElement*>(detEl); idDetEl != nullptr) {
                  siDet = dynamic_cast<const InDetDD::SiDetectorElement*>(idDetEl->upstreamDetectorElement());
               }
               hit_info_out.addHit(siDet, hit_selection);
                   
                
               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();
  }

◆ getMeasurementSelector()

std::unique_ptr< ActsTrk::IMeasurementSelector > ActsTrk::detail::getMeasurementSelector	(	const EventContext &	ctx,
		const ActsTrk::IPixelOnBoundStateCalibratorTool *	pixelOnTrackCalibratorTool,
		const ActsTrk::IStripOnBoundStateCalibratorTool *	stripOnTrackCalibratorTool,
		const ActsTrk::IHGTDOnBoundStateCalibratorTool *	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 406 of file AtlasMeasurementSelector.cxx.

                                                                                                      {
 
    // set calibrators per measurement container type (order does not matter);
    ActsTrk::MeasurementCalibrator atl_measurement_calibrator(ctx,
                                                              pixelOnTrackCalibratorTool,
                                                              stripOnTrackCalibratorTool,
                                                              hgtdOnTrackCalibratorTool);
    using AtlMeasurementSelectorCuts = AtlasMeasurementSelectorCuts;
 
    using AtlMeasurementSelector = AtlasActsMeasurmentSelector<RecoTrackContainer>;
    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 17 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 37 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;
}

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ CKF

◆ CopierType

◆ Extrapolator

◆ GetterType

◆ MeasurementRangeList

◆ MeasurementRangeListFlat

◆ Navigator

◆ Propagator

◆ RecoConstTrackStateContainerProxy

◆ RecoTrackContainer

◆ RecoTrackContainerProxy

◆ RecoTrackStateContainer

◆ RecoTrackStateContainerProxy

◆ SetterType

◆ Stepper

◆ 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()