Athena definition of the Eigen plugin. More...

Namespaces
namespace	FitterHelperFunctions
namespace	HitCategory
namespace	MakeDerivedVariant

Classes
struct	accepted_decoration_types
class	AnalogueClusteringToolImpl
class	AtlasMeasurementContainerList
struct	CKF_config
struct	Decoration
class	DuplicateSeedDetector
struct	ExpectedLayerPatternHelper
	Helper functions to encode the expected layer patterns in separate columns. More...
class	GenMeasurementRangeList
class	GenMeasurementRangeListFlat
class	GenUncalibSourceLinkAccessor
	Accessor for the above source link container. More...
class	HitSummaryData
	Helper class to gather hit summary information for e.g. More...
class	MeasurementCalibratorBase
	Base class providing the boiler code to fill the Acts multi trajectory track states. More...
class	MeasurementIndex
struct	MeasurementRange
class	OnTrackCalibrator
	Inner detector / ITk calibrator implementation used in the KalmanFilterTool. More...
class	RefittingCalibrator
class	SharedHitCounter
class	StripCalibratorImpl
class	SumOfValues
	Helper class to gather statistics and compute the biased variance. More...
class	TrackFindingMeasurements
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...

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...

Functions
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)
template<typename T>
bool	build (const std::type_info *typeInfo, const std::string &name, std::vector< Decoration > &decorations)
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 ActsTrk::IOnBoundStateCalibratorTool pixelOnTrackCalibratorTool, const ActsTrk::IOnBoundStateCalibratorTool stripOnTrackCalibratorTool, const ActsTrk::IOnBoundStateCalibratorTool *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	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.
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.
void	addToExpectedLayerPattern (std::array< unsigned int, 4 > &pattern, const ActsDetectorElement &detElement)
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	gatherTrackSummaryData (const ActsTrk::TrackContainer &tracksContainer, const typename ActsTrk::TrackContainer::ConstTrackProxy &track, const std::array< const InDetDD::SiDetectorElementCollection *, to_underlying(xAOD::UncalibMeasType::nTypes)> &siDetEleColl, const std::array< unsigned short, to_underlying(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, to_underlying(HitCategory::N)>, to_underlying(xAOD::UncalibMeasType::nTypes)> &special_hit_counts_out)
	Helper to gather track summary information from the track states of the specified track.
template<typename T_EnumClass>
constexpr std::underlying_type< T_EnumClass >::type	to_underlying (T_EnumClass an_enum)
	Helper to convert class enum into an integer.

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

ActsTrk::IndexType

std::uint32_t IndexType

Definition Decoration.h:14

SG::auxid_t

size_t auxid_t

Identifier for a particular aux data item.

Definition AuxTypes.h:27

Definition at line 20 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)>

SG::IConstAuxStore

Interface for const operations on an auxiliary store.

Definition IConstAuxStore.h:64

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

◆ 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::UnCalibratedMEeasurement objects. Number of source link types

Definition at line 9 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 40 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 11 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 49 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 83 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 76 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 57 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 67 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);
    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->associatedDetectorElement()) {
          const ActsDetectorElement *
            actsDetEl = dynamic_cast<const ActsDetectorElement *>(step.surface->associatedDetectorElement());
          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 ActsTrk::TrackContainer &	tracksContainer,
		const typename ActsTrk::TrackContainer::ConstTrackProxy &	track,
		const std::array< const InDetDD::SiDetectorElementCollection *, to_underlying(xAOD::UncalibMeasType::nTypes)> &	siDetEleColl,
		const std::array< unsigned short, to_underlying(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, to_underlying(HitCategory::N)>, to_underlying(xAOD::UncalibMeasType::nTypes)> &	special_hit_counts_out )

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

Parameters

tracksContainer	the Acts track container
track	a track of the given acts track container for which the summary information is to be gathered
siDetEleColl	array of SiDetectorElement collections per measurement type.
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 15 of file HitSummaryDataUtils.cxx.

  {
     chi2_stat_out.reset();
 
     hit_info_out.reset();
     param_state_idx_out.clear();
 
     const auto lastMeasurementIndex = track.tipIndex();
     tracksContainer.trackStateContainer().visitBackwards(
          lastMeasurementIndex,
          [&siDetEleColl,
           &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 (flag.test(Acts::TrackStateFlag::HoleFlag)) {
                xAOD::UncalibMeasType det_type = xAOD::UncalibMeasType::Other;
                if (state.hasReferenceSurface()) {
                   if (state.referenceSurface().associatedDetectorElement()) {
                      const ActsDetectorElement *
                         actsDetEl = dynamic_cast<const ActsDetectorElement *>(state.referenceSurface().associatedDetectorElement());
                      if (actsDetEl) {
                         const InDetDD::SiDetectorElement *
                            detEl = dynamic_cast<const InDetDD::SiDetectorElement *>(actsDetEl->upstreamDetectorElement());
                         if (detEl) {
                            if (detEl->isPixel()) {
                               det_type = xAOD::UncalibMeasType::PixelClusterType;
                            }
                            else if (detEl->isSCT()) {
                               det_type = xAOD::UncalibMeasType::StripClusterType;
                         }
                         }
                      }
                   }
                }
 
                Acts::Vector2 localPos(state.predicted()[Acts::eBoundLoc0],state.predicted()[Acts::eBoundLoc1]);
                if (state.referenceSurface().insideBounds(localPos)) {
                   // @TODO check whether detector element is dead..
                   // if (dead) {
                   // ++specialHitCounts.at(to_underlying(det_type)).at(HitCategory::DeadSensor);
                   // } else {
                   ++special_hit_counts_out.at(to_underlying(det_type)).at(HitCategory::Hole);
                }
 
             }
             else if (flag.test(Acts::TrackStateFlag::MeasurementFlag)) {
                // do not consider material states
                param_state_idx_out.push_back(state.index());
             }
             // @TODO dead elements
 
             if (state.hasUncalibratedSourceLink()) {
                auto sl = state.getUncalibratedSourceLink().template get<ActsTrk::ATLASUncalibSourceLink>();
                assert( sl != nullptr );
                const xAOD::UncalibratedMeasurement &uncalibMeas = getUncalibratedMeasurement(sl);
                if (measurement_to_summary_type.at(to_underlying(uncalibMeas.type())) <  xAOD::numberOfTrackSummaryTypes ) {
                   if (static_cast<unsigned int>(to_underlying(uncalibMeas.type())) < siDetEleColl.size()) {
                     HitSummaryData::EHitSelection hit_selection = (flag.test(Acts::TrackStateFlag::OutlierFlag)
                                                                        ? HitSummaryData::Outlier
                                                                        : HitSummaryData::Hit);
                     if (flag.test(Acts::TrackStateFlag::SharedHitFlag)) {
                        hit_selection = HitSummaryData::EHitSelection(hit_selection | HitSummaryData::SharedHit);
                     }
                     hit_info_out.addHit(siDetEleColl[to_underlying(uncalibMeas.type())],
                                         uncalibMeas.identifierHash(),
                                         hit_selection);
                   }
                }
                if (state.calibratedSize()>0 && !flag.test(Acts::TrackStateFlag::OutlierFlag)) {
                   // 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 ActsTrk::IOnBoundStateCalibratorTool *	pixelOnTrackCalibratorTool,
		const ActsTrk::IOnBoundStateCalibratorTool *	stripOnTrackCalibratorTool,
		const ActsTrk::IOnBoundStateCalibratorTool *	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 )

Definition at line 404 of file AtlasMeasurementSelector.cxx.

                                                                                                                       {
 
    // set calibrators per measurement container type (order does not matter);
    ActsTrk::MeasurementCalibrator atl_measurement_calibrator(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} }}));
    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));
  }

◆ 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 21 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;
}

◆ to_underlying()

template<typename T_EnumClass>

std::underlying_type< T_EnumClass >::type ActsTrk::detail::to_underlying ( T_EnumClass an_enum )

constexpr

Helper to convert class enum into an integer.

Definition at line 24 of file HitSummaryDataUtils.h.

                                                                                             {
      return static_cast<typename std::underlying_type<T_EnumClass>::type>(an_enum);
   }

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

◆ SourceLinkType

Function Documentation

◆ addToExpectedLayerPattern()

◆ build()

◆ computeDtDs()

◆ computeFreeToPathDerivatives()

◆ constDecorationGetter()

◆ convertActsBoundCovToCurvilinearParam()

◆ decoration()

◆ decorationCopier()

◆ decorationGetter()

◆ decorationSetter()

◆ expectedLayerPattern() [1/2]

◆ expectedLayerPattern() [2/2]

◆ gatherTrackSummaryData()

◆ getMeasurementSelector()

◆ getSDOInformation()

◆ getSiHitInformation()

◆ restoreDecorations()

◆ to_underlying()