 |
ACTS
Experiment-independent tracking
|
|
ACTS
Experiment-independent tracking
|
| NActs | The main namespace encompassing all ACTS code |
| NAngleHelpers | |
| CEtaThetaConversionTraits | |
| CEtaThetaConversionTraits< double > | Conversion limits for double eta/theta calculations |
| CEtaThetaConversionTraits< float > | Conversion limits for float eta/theta calculations |
| NCcl | |
| CClusteringData | Collection of mutable data used by clustering utilities |
| CConnect1D | Default connection type for 1-D grids with 2-cell connectivity |
| CConnect2D | Default connection type for 2-D grids with 4- or 8-cell connectivity |
| CDefaultConnect | |
| CDefaultConnect< Cell, 1 > | Default connection type for 1-D grids |
| CDefaultConnect< Cell, 2 > | Default connection type for 2-D grids |
| CDisjointSets | Wrapper around boost::disjoint_sets used by the clustering helpers |
| CTimedConnect | Connection type with an added time compatibility requirement |
| NExperimental | Contains code that is not considered stable yet and might change |
| CBarrelEndcapAssembler | Fluent builder that assembles a combined barrel + endcap subdetector into a CylinderContainerBlueprintNode arranged along the Z axis |
| CBlueprint | This class is the top-level entry point to build a tracking geometry using the blueprint building mechanism |
| CConfig | Configuration for building a blueprint tracking geometry |
| CBlueprintBuilder | High-level builder that converts a backend detector element hierarchy into a blueprint node tree |
| CBlueprintNode | Base class for all nodes in the blueprint tree |
| CBlueprintOptions | Options controlling blueprint navigation policies |
| CBoundParameterVariationGenerator | Base class for generating bound parameter variations |
| CCompositeSpacePointLineFitter | Generic Implementation to fit a straight line to set of composite space point measurements |
| CConfig | Fitter configuration object |
| CDoFcounts | Struct counting the different types of degrees of freedom |
| CFitOptions | Configuration object parsed per each fit |
| CFitParameters | Auxiliary object to store the fitted parameters, covariance, the chi2 / nDoF & the number of required iterations |
| CFitResult | Fit parameters together with the calibrated measurements |
| CCompositeSpacePointLineSeeder | Initial line parameters from a pattern recognition like the Hough transform are often not suitable for a line fit as the resolution of the hough bins usually exceeds the size of the straws |
| CConfig | Configuration of the cuts to sort out generated seeds with poor quality |
| CSeedingState | Central auxiliary struct to steer the seeding process |
| CSegmentSeed | Helper struct to pack the parameters and the associated measurements into a common object |
| CTwoCircleTangentPars | Helper struct describing the line parameters that are tangential to a pair of straw measurements |
| CContainerBlueprintNode | A blueprint node that can contain multiple child volumes |
| CCovarianceBoundParameterVariationGenerator | Generator for bound parameter variations based on the covariance |
| CCuboidContainerBlueprintNode | Container blueprint node stacking cuboid volumes |
| CCylinderContainerBlueprintNode | Container blueprint node stacking cylindrical volumes |
| CCylindricalSpacePointKDTree | A cylindrical space point KD-tree used for seeding in a cylindrical detector geometry |
| CCandidates | Candidate space point indices grouped by z ordering |
| COptions | Configuration options for cylindrical space point selection |
| CCylindricalSpacePointKDTreeBuilder | Builder for cylindrical space point KD-trees |
| CDeltaBoundParameterVariationGenerator | Generator for bound parameter variations based on fixed deltas |
| CEfficiency | Multi-dimensional efficiency histogram using boost::histogram |
| CElementLayerAssembler | Fluent builder that assembles a flat collection of cylindrical or disc-like detector layers from layer-representative detector elements into a CylinderContainerBlueprintNode |
| CFrustumNavigationPolicy | A navigation policy that uses frustum-octree intersections to find portals |
| CConfig | Configuration for the frustum navigation policy |
| CState | Frustum navigation policy state, which holds the frustum |
| CGbtsAdaptiveTauRatioCuts | Tau ratio tolerances for assignAdaptiveTauRatioCuts |
| CGbtsBinGroup | The outer eta bins reachable from one inner eta bin |
| CGbtsBinLink | One outer eta bin reachable from an inner one, with the cuts the layer pair they belong to carries |
| CGbtsGeometry | Geometry helper built from layers and connectors |
| CGbtsGraph | The doublet graph of the GBTS workflow, as built by GbtsGraphBuilder |
| CGbtsGraphBuilder | Builds the doublet graph of the GBTS workflow |
| CConfig | Config for the prompt graph |
| CGbtsLayerBinning | The eta binning GbtsGeometry gave one layer |
| CGbtsLayerConfig | A GBTS layer and the detector surfaces it is made of |
| CGbtsLayerConnection | A pair of layers the seeder may build a graph edge between |
| CGbtsLayerConnectionTool | Builds the GBTS layer connection table from observed track hits |
| CConfig | Configuration for the layer connection tool |
| CLayerDescription | Struct to hold r and z bounds for a given detector layer |
| CLayerIdPairHash | Hash id used for unordered sets and maps |
| CGbtsLayerDescription | Lightweight layer description for GBTS geometry |
| CGbtsNodeStorage | Storage for the GBTS graph nodes |
| CGbtsRoiDescriptor | GBTS region of interest, as the eta and z bounds the seeder cuts on |
| CGbtsSeedFit | Fit of the GBTS tracking filter to a seed, at its innermost space point |
| CGbtsTauBounds | Accepted |cot(theta)| range for one cluster width bin |
| CGbtsTrackingFilter | Tracking filter operating on the GBTS edge graph |
| CConfig | Configuration for the tracking filter |
| CGbtsZ0Range | Z0 range two eta bins must share a trajectory within, which fixes the bin table |
| CGeometryIdentifierBlueprintNode | Blueprint node for configuring and applying geometry identifiers to volumes |
| CGraphBasedTrackSeeder | Seed finder implementing the GBTS seeding workflow |
| CConfig | Configuration struct for the GBTS seeding algorithm |
| CDerivedConfig | Derived configuration struct that contains calculated parameters based on the configuration |
| COptions | Optional inputs for variables passed in or derived during runtime |
| CGx2Fitter | Global Chi Square fitter (GX2F) implementation |
| CGx2FitterExtensions | Extension struct which holds delegates to customise the GX2F behaviour |
| CGx2FitterOptions | Combined options for the Global-Chi-Square fitter |
| CGx2FitterResult | Result container for a global chi-square fit |
| CGx2fSystem | A container to manage all properties of a gx2f system |
| CHistogram | Multi-dimensional histogram wrapper using boost::histogram for data collection |
| CHoughAccumulatorSection | Helper class for adaptive traversal of HT space |
| CHoughExplorationOptions | Structure that keeps HT space traversal options |
| CLayerBlueprintNode | The layer node is essentially an auto-sizing wrapper around a set of surfaces |
| CMaterialDesignatorBlueprintNode | This node type registers material proxies into its child volume during the blueprint construction |
| CMultiLayerNavigationPolicy | A navigation policy that uses grid based navigation for indexed surfaces Navigate through a multilayer structure by creating an artificial path on the grid |
| CConfig | Configuration for multilayer navigation behavior |
| CMultiWireVolumeBuilder | A class to build multiwire tracking volumes (e.g wire chambers) |
| CConfig | Configuration Struct |
| CPadBlueprintNode | Wraps a single child blueprint node and pads it into a larger volume whose dimensions are evaluated at construction time using the child's extent plus a configurable envelope |
| CPortalDesignatorBlueprintNode | This node type assigns string tags to specific portal faces of its child volume during the blueprint construction |
| CProfileHistogram | Multi-dimensional profile histogram using boost::histogram |
| CReferenceTrajectoryBuilder | Reference trajectory implementation |
| CReferenceTrajectoryBuilderOptions | |
| CReferenceTrajectoryBuilderResult | The result struct for the reference trajectory builder actor |
| CRiddersStepper | RiddersStepper implements the Ridders method for numerical differentiation to compute the Jacobian of the bound to bound transformation |
| CConfig | Configuration struct for the RiddersStepper |
| CState | The state struct for the RiddersStepper |
| CScatteringProperties | A container to store scattering properties for each material surface |
| CSensorLayer | Fluent builder that assembles a single cylindrical or disc-like detector layer directly from sensor elements, returning a LayerBlueprintNode (no container wrapper) |
| CSensorLayerAssembler | Fluent builder that assembles multiple cylindrical or disc-like detector layers directly from sensor elements into a CylinderContainerBlueprintNode |
| CSphericalSpacePointGrid | A spherical space point grid for seeding, binned in (phi, eta, r) |
| CConfig | Configuration parameters for the spherical space point grid |
| CStaticBlueprintNode | The static blueprint node wraps a single already-constructred TrackingVolume |
| CTryAllNavigator | Alternative Navigator which tries all possible intersections |
| CConfig | Configuration for this Navigator |
| COptions | Options for this Navigator |
| CState | Nested state struct |
| NGraphViz | |
| CEdge | GraphViz edge descriptor |
| CNode | GraphViz node descriptor |
| NGridAxisGenerators | Axis generators are used to allow defining different grid types for indexed geometry objects |
| CEq | Templated base generator for equidistant axis as a tuple - 1D |
| CEqEq | Templated base generator for two equidistant axes as a tuple - 2D |
| CEqVar | Templated base generator for equidistant / variable axes as a tuple - 2D |
| CVar | Templated base generator for variable axis as a tuple - 1D |
| CVarEq | Templated base generator for a variable, equidistant axes tuple - 2D |
| CVarVar | Templated base generator for a two variable axes tuple - 2D |
| NHoughTransformUtils | |
| NPeakFinders | Example peak finders |
| CIslandsAroundMax | Peak finder inspired by ATLAS muon reconstruction |
| CMaximum | Data struct representing a local maximum |
| CIslandsAroundMaxConfig | Configuration for the IslandsAroundMax peak finder |
| CLayerGuidedCombinatoric | Peak finder inspired by ATLAS ITk event filter developments |
| CMaximum | Data class representing the found maxima |
| CLayerGuidedCombinatoricConfig | Configuration for the LayerGuidedCombinatoric peak finder |
| CSlidingWindowConfig | Peak finder using sliding window algorithm |
| CHoughAxisRanges | Struct to define the ranges of the hough histogram |
| CHoughCell | Data class for the information to store for each cell of the hough histogram |
| CHoughPlane | Representation of the hough plane - the histogram used for the hough transform with methods to fill and evaluate the histogram |
| CHoughPlaneConfig | Configuration - number of bins in each axis |
| NIndexGridNavigationJsonConverter | |
| COptions | Configure the conversion through that struct |
| NJsonSurfacesReader | |
| COptions | Options specification for surface reading The file should contain an array of json surfaces as produced by the SurfaceJsonConverter tools |
| NLogging | |
| CDefaultFilterPolicy | Default filter policy for debug messages |
| CDefaultPrintPolicy | Default print policy for debug messages |
| CLevelOutputDecorator | Decorate debug message with its debug level |
| CNamedOutputDecorator | Decorate debug message with a name |
| COutputDecorator | Base class for decorating the debug output |
| COutputFilterPolicy | Abstract base class for filtering debug output |
| COutputPrintPolicy | Abstract base class for printing debug output |
| CScopedFailureThreshold | Helper class that changes the failure threshold for the duration of its lifetime |
| CThreadOutputDecorator | Decorate debug message with a thread ID |
| CThresholdFailure | Custom exception class so threshold failures can be caught |
| CTimedOutputDecorator | Decorate debug message with a time stamp |
| NMaterialInteractionAssignment | Assignment of recorded material interactions to assignment candidates |
| COptions | Options for the material interaction matcher The options are used to specify the vetos for the assignment |
| CResult | The result struct of the assignment run |
| NMultiTrajectoryHelpers | |
| CTrajectoryState | Struct for brief trajectory summary info |
| NRanges | |
| Cto_adaptor | Adaptor for converting a range to a container |
| NStripSpacePointBuilder | |
| CClusterPairingOptions | Collection of cluster pairing options |
| CConstrainedOptions | Collection of constrained space point options |
| CConstrainedStripCache | Per-strip cache for the constrained space point formation |
| CCosmicOptions | Collection of cosmic space point options |
| CStripEnds | Strip cluster details |
| NTransform3JsonConverter | |
| COptions | The options for the transform converter |
| NTypes | |
| Capply | Apply a typelist to a type function |
| Capply< F, TypeList< Ts... > > | Apply a type function to types in a type list |
| Ccount | Count the number of times a type occurs in a type list |
| Ccount< T, TypeList< U, Us... > > | Count occurrences of a type in a type list |
| Ccount< T, TypeList<> > | Base case for empty type list count |
| CdoPushBack | Append a type |
| CdoPushBack< N, TypeList< Ts... > > | Append a type to the back of a type list |
| CdoPushFront | Prepend a type |
| CdoPushFront< N, TypeList< Ts... > > | Prepend a type to the front of a type list |
| Cfilter | Filter a list of types |
| Cfilter< Pred > | Base case for empty type list filter |
| Cfilter< Pred, T, Ts... > | Filter a type list using a predicate |
| CgetBack | Access the last type |
| CgetBack< TypeList< T, Ts... > > | Get the last type from a type list |
| CgetBack< TypeList<> > | Base case for empty type list |
| CgetFront | Access the first type |
| CgetFront< TypeList< T, Ts... > > | Get the first type from a type list |
| CgetSize | Number of types in the list |
| CgetSize< TypeList< Ts... > > | |
| Cmap | Apply a mapping function to a type list |
| Cmap< F, TypeList< Ts... > > | Map a type function over each type in a type list |
| CAccumulatedMaterialSlab | Accumulate material properties from multiple hits/track and multiple tracks |
| CAccumulatedSurfaceMaterial | This class is used by the BinnedSurfaceMaterialAccumulator in order to accumulate/collect material information during the mapping process |
| CAccumulatedVolumeMaterial | Accumulate and average volume-based material properties |
| CActorHasResultStruct | Helper struct exposing ActorHasResult as a boolean |
| CActorList | ActorList implementation to be used with the propagator |
| CActorResultTypeExtractor | Extract the result type of an actor |
| CAdaptiveGridDensityVertexFinder | Vertex finder that makes use of a track density grid |
| CConfig | The Config struct |
| CState | The State struct |
| CAdaptiveGridTrackDensity | Implements a 1D (no time seeding) / 2D (time seeding) grid that is filled with track densities |
| CConfig | The configuration struct |
| CAdaptiveMultiVertexFinder | Implements an iterative vertex finder |
| CConfig | Configuration struct |
| CState | State struct for fulfilling interface |
| CAdaptiveMultiVertexFitter | Implements an adaptive multi-vertex fitter as described in detail in Section 5.3.5 in: Ref |
| CCache | The fitter-private cache |
| CConfig | Configuration options for the adaptive multi-vertex fit |
| CState | The fitter state |
| CAdditionalSurface | A surface the navigator offers on top of the tracking geometry, whether the geometry holds it or not |
| CAmbiguityResolutionML | Generic implementation of the machine learning ambiguity resolution Contains method for data preparations |
| CConfig | Configuration for the ambiguity resolution algorithm |
| CAnnealingUtility | Implements a deterministic thermodynamic annealing scheme Ref |
| CConfig | The configuration struct |
| CState | The annealing state Resetting the state is done by just creating a new instance |
| CAnnulusBounds | Class that implements a (potentially asymmetric) bounds with difference between surface bound center and surface coordinate center |
| CAnyBase | Small opaque type-erased type with configurable small buffer optimization |
| CAnyBaseAll | Base class for all instances of AnyBase regarfless of SBO size |
| CAnyGridConstView | Type-safe view into a grid with const access |
| CAnyGridView | Type-safe view into a grid with mutable access |
| CAnySurfaceReached | Aborter that checks if the propagation has reached any surface |
| CAnyTrack | |
| CAnyTrackProxy | Type-erased track object This class provides a type-erased interface to track proxies without requiring heap allocation per instance |
| CAnyTrackStateProxy | Type-erased track state proxy for any trajectory backend |
| CAppendOnlyNavigationStream | Append-only helper to add candidates to a navigation stream |
| CApproachDescriptor | Virtual base class to decide and return which approaching surface to be taken, the surfaces are std::shared_ptr, as they can be the boundary surfaces of the representingVolume of the Layer |
| CAssertionFailureException | Exception type for assertion failures This class captures the information available to the throw_assert macro |
| CStreamFormatter | Class which allows to use the << operator to assemble a string |
| CAtlasStepper | AtlasStepper implementation for the |
| CConfig | Configuration for constructing an AtlasStepper |
| COptions | Stepper options extending plain stepper settings |
| CState | Nested State struct for the local caching |
| CAveragingScopedTimer | A timer class that measures and averages execution times of multiple samples |
| CSample | RAII wrapper class for measuring individual timing samples |
| CAxis | Calculate bin indices from a given binning structure |
| CAxis< AxisType::Equidistant, bdt > | Calculate bin indices for an equidistant binning |
| CAxis< AxisType::Variable, bdt > | Calculate bin indices for a variable binning |
| CAxisAlignedBoundingBox | Implementation of an Axis Aligned Bounding Box |
| CAxisBoundaryTypeTag | Tag helper type for Axis constructors with class template deduction |
| CAxisDirectionReferenceGenerator | A struct to access reference positions based on bin values |
| CAxisSpec | Variant-like spec of an axis that builds IAxis objects |
| CDeferredVariableParams | Parameters for a variable axis whose bin edges are relative and scaled onto the range supplied by the consumer |
| CEquidistantParams | Parameters for an equidistant axis |
| CVariableParams | Parameters for a variable axis with absolute bin edges |
| CAxisSpecOptions | Axis properties supplied by the consumer of an AxisSpec at build time |
| CBarrelEndcapAssembler | Fluent builder that assembles a combined barrel + endcap subdetector into a CylinderContainerBlueprintNode arranged along the Z axis |
| CBasePropagator | Common simplified base interface for propagators |
| CBetheHeitlerApprox | Interface for Bethe-Heitler Gaussian mixture approximations |
| CBetheHeitlerApproxSingleCmp | This class approximates the Bethe-Heitler with only one component |
| CBinnedArray | Pure virtual base class for Binned Array to avoid map searches |
| CBinnedArrayXD | Avoiding a map search, the templated BinnedArray class can help ordereing geometrical objects by providing a dedicated BinUtility |
| CBinnedGroup | |
| CBinnedGroupIterator | Iterator over a binned group grid neighborhood |
| CBinnedSurfaceMaterial | It extends the ISurfaceMaterial base class and is an array pf MaterialSlab |
| CBinnedSurfaceMaterialAccumulator | The binned surface material accumulator |
| CConfig | Nested config struct |
| CState | Nested state struct |
| CBinningData | This class holds all the data necessary for the bin calculation |
| CBinUtility | That translated global and local position into a bins of a BinnedArray, most performant is equidistant binning without a transform, however, optionally a transform can be provided, e.g |
| CBlueprint | This class is the top-level entry point to build a tracking geometry using the blueprint building mechanism |
| CConfig | Configuration for building a blueprint tracking geometry |
| CBlueprintBuilder | High-level builder that converts a backend detector element hierarchy into a blueprint node tree |
| CBlueprintNode | Base class for all nodes in the blueprint tree |
| CBlueprintOptions | Options controlling blueprint navigation policies |
| CBoundarySurfaceT | |
| CBoundaryTolerance | Variant-like type to capture different types of boundary tolerances |
| CAbsoluteEuclideanParams | Parameters for absolute Euclidean boundary tolerance |
| CChi2BoundParams | Parameters for chi2 boundary tolerance in bound coordinates |
| CChi2CartesianParams | Parameters for chi2 boundary tolerance in Cartesian coordinates |
| CInfiniteParams | |
| CNoneParams | |
| CBoundFactory | Factory helper class to construct volume or surface bounds where the constructed bounds are cached inside the factory and if the same bound parameters are requested at a later stage the factory automatically returns the cached bounds |
| CBoundParameterRecorder | Collector of the bound track parameters |
| CBoundTrackParameters | Track parameters bound to a reference surface for a single track |
| CBremCombinatorialKalmanFilterOptions | Options for the combinatorial Kalman filter with bremsstrahlung recovery |
| CBroadTripletSeedFilter | Triplet seed filter used in the triplet seeding algorithm |
| CCache | Cache for intermediate results to avoid reallocations |
| CConfig | Structure that holds configuration parameters for the seed filter algorithm |
| CState | State of the filter that is communicated between different stages |
| CButcherTableau | Coefficients of an explicit Runge-Kutta method |
| CCalibrationContext | This is the central definition of the Acts payload object regarding detector calibration |
| CCartesianSpacePointGrid | A cartesian space point grid used for seeding in a cartesian detector geometry |
| CConfig | Configuration parameters for the cartesian space point grid |
| CCenterReferenceGenerator | A struct to access the center position as a sole reference |
| CChargeHypothesis | Charge and momentum interpretation for arbitrarily charged particles |
| CCloneablePtr | A copyable smart pointer that uses a cloner function to copy the managed object |
| CColor | Struct describing a color |
| CCombinatorialKalmanFilter | Combinatorial Kalman filter to find tracks |
| CCombinatorialKalmanFilterExtensions | Extension struct which holds the delegates to customize the CKF behavior |
| CCombinatorialKalmanFilterOptions | Combined options for the combinatorial Kalman filter |
| CCombinatorialKalmanFilterResult | Result container for the combinatorial Kalman filter actor |
| CCompositePortalLink | Composite portal links can graft together other portal link instances, for example grids that could not be merged due to invalid binnings |
| CConeBounds | Bounds for a conical surface, the opening angle is stored in \( \tan(\alpha) \) and always positively defined |
| CConeLayer | Class to describe a conical detector layer for tracking, it inherits from both, Layer base class and ConeSurface class |
| CConeSurface | Class for a conical surface in the Tracking geometry |
| CConeVolumeBounds | Volume bound class for describing conical volumes either with cylindrical inlay or outer boundary, it also allows for a sectoral description |
| CConstantBField | The simplest magnetic field implementation is a constant field, which returns the same field values at every queried location |
| CCache | Cache object for constant magnetic field |
| CConstrainedStep | A constrained step class for the steppers |
| CConstRefHolder | Non-owning holder for referencing a backend with const access |
| CConstVectorMultiTrajectory | Const version of VectorMultiTrajectory |
| CConstVectorTrackContainer | Read-only vector-backed track container |
| CContainerBlueprintNode | A blueprint node that can contain multiple child volumes |
| CConvexPolygonBounds | This is the actual implementation of the bounds |
| CConvexPolygonBounds< PolygonDynamic > | This is the specialization handling a polygon with a dynamic number of points |
| CConvexPolygonBoundsBase | Base class for convex polygon bounds |
| CCuboidContainerBlueprintNode | Container blueprint node stacking cuboid volumes |
| CCuboidPortalShell | Base class for cuboid shaped portal shells, e.g |
| CCuboidStackPortalShell | This class describes a cuboid shell containing multiple volumes |
| CCuboidVolumeBounds | Bounds for a cubical Volume, the orientedSurfaces(...) method creates a vector of 6 surfaces: |
| CCuboidVolumeBuilder | This class builds a box detector with a configurable amount of surfaces in it |
| CConfig | This struct stores the configuration of the tracking geometry |
| CLayerConfig | This struct stores the data for the construction of a PlaneLayer |
| CSurfaceConfig | This struct stores the data for the construction of a single PlaneSurface |
| CVolumeConfig | This struct stores the data for the construction of a cuboid TrackingVolume with a given number of PlaneLayers |
| CCuboidVolumeStack | This class implements a x- |
| CCurvilinearSurface | Utility class for curvilinear surfaces |
| CCutoutCylinderVolumeBounds | Class which implements a cutout cylinder |
| CCylinderBounds | |
| CCylinderContainerBlueprintNode | Container blueprint node stacking cylindrical volumes |
| CCylinderLayer | Class to describe a cylindrical detector layer for tracking, it inherits from both, Layer base class and CylinderSurface class |
| CCylinderNavigationPolicy | Optimized navigation policy for cylindrical volumes that intelligently selects which portals to add as candidates based on geometric analysis |
| CCylinderPortalShell | Base class for cylinder shaped portal shells, e.g |
| CCylinderStackPortalShell | This class describes a cylinder shell containing multiple volumes |
| CCylinderSurface | Class for a CylinderSurface in the TrackingGeometry |
| CCylinderVolumeBounds | [0] and [1] at positive \( \phi \) |
| CCylinderVolumeBuilder | A volume builder to be used for building concentric cylinder volumes |
| CConfig | Nested configuration struct for this CylinderVolumeBuilder |
| CCylinderVolumeHelper | The concrete implementation for cylindrical TrackingVolume objects of the ITrackingVolumeCreator interface |
| CConfig | Nested configuration struct for this CylinderVolumeHelper |
| CCylinderVolumeStack | This class implements a z-aligned or r-aligned stack of cylinder volumes with synchronized bounds |
| CCylindricalSpacePointGrid | A cylindrical space point grid used for seeding in a cylindrical detector geometry |
| CConfig | Configuration parameters for the cylindrical space point grid |
| CDBScan | A general implementation of an N dimensional DBScan clustering algorithm |
| CDelegate | |
| CDelegate< R(Args...), H, O > | Delegate type that allows type erasure of a callable without allocation and with a single level of indirection |
| CDelegateFuncTag | Tag type to select a compile-time callable for Delegate |
| CDiamondBounds | |
| CDiamondPortalShell | Base class for diamond shaped portal shells, e.g single volumes with polygon shape or stacked (multiple) volumes (TODO) |
| CDiamondVolumeBounds | Bounds for a polygonal prism shaped Volume, the orientedSurface(...) method creates a vector of 8 surfaces: 2 Diamond Shape Surfaces (see |
| CDirectedProtoAxis | A Directed proto axis |
| CDirection | The direction is always with respect to a given momentum, surface normal or other general axes |
| CDirectNavigator | A fully guided navigator |
| CConfig | The nested configuration struct |
| COptions | The nested options struct |
| CState | Nested State struct |
| CDiscBounds | |
| CDiscLayer | Class to describe a disc-like detector layer for tracking, it inherits from both, Layer base class and DiscSurface class |
| CDiscSurface | Class for a disc surface (or a segment thereof) |
| CDiscTrapezoidBounds | Class to describe the bounds for a planar DiscSurface |
| CDistanceSorterT | This will check on absolute distance |
| CDoubletSeedFinder | Interface and a collection of standard implementations for a doublet seed finder |
| CConfig | Collection of configuration parameters for the doublet seed finder |
| CDerivedConfig | Derived configuration for the doublet seed finder using a magnetic field |
| CDoubletsForMiddleSp | Container for doublets found by the doublet seed finder |
| CIndexAndCotTheta | Pair of doublet index and cotTheta value |
| CProxy | Proxy accessor for a single doublet entry |
| CProxy2 | Same as Proxy but also contains cotTheta |
| CRange | Range view over doublets in the container |
| CSortStorage | Storage for sortByCotTheta, kept by the caller so that sorting does not allocate |
| CSubset | Subset view of doublets addressed by indices |
| CSubset2 | Subset view of doublets addressed by index and cotTheta pairs |
| CDummyVertexFitter | Dummy vertex fitter class, only to be used for ensuring interfaces where a vertex fitter type is required but no fitter is actually needed |
| CEigenStepper | Runge-Kutta-Nystroem stepper based on Eigen implementation for the following ODE: |
| CConfig | Configuration for the Eigen stepper |
| COptions | Stepper options including geometry and magnetic field contexts |
| CState | State for track parameter propagation |
| CEigenStepperDefaultExtension | Default evaluator of the k_i's and elements of the transport matrix D of the RKN4 stepping |
| CEigenStepperDenseExtension | Evaluator of the k_i's and elements of the transport matrix D of the RKN4 stepping |
| CElementFraction | Memory-efficient storage of the relative fraction of an element |
| CElementLayerAssembler | Fluent builder that assembles a flat collection of cylindrical or disc-like detector layers from layer-representative detector elements into a CylinderContainerBlueprintNode |
| CEllipseBounds | |
| CEndOfWorldReached | This is the condition that the end of world has been reached it then triggers an propagation abort |
| CEstimateTrackParamCovarianceConfig | Configuration for the estimation of the covariance matrix of the track parameters with estimateTrackParamCovariance |
| CEventDataView3D | Utilities to visualize event data in 3D |
| CExpSafeLimit | Specialization of the exponent limit to be used for safe exponential, depending on the floating point type |
| CExpSafeLimit< double > | Safe exponent limits for double precision |
| CExpSafeLimit< float > | Safe exponent limits for single precision |
| CExtendedSurface | A surface of the tracking geometry with the bounds check relaxed to the tolerance of the caller |
| CExtent | A class representing the geometric extent of an object in its possible dimensions, these can be all dimensions that are described as AxisDirections |
| CExtentEnvelope | This struct models a multi-dimensional enveloper along the axis directions |
| CArguments | Helper struct for designated initializer construction |
| CFiniteStateMachine | Implementation of a finite state machine engine |
| CTerminated | Contractual termination state |
| CFixedSubspaceHelper | Helper class for fixed subspace operations |
| CForcedSurfaceReached | Similar to SurfaceReached, but with an infinite overstep limit |
| CFreeTrackParameters | Track parameters not bound to a surface for a single track |
| CFrustum | Class representing a frustum shape |
| CFsmwMode1dFinder | Calculates the mode of a unidimenensional distribution using the Fraction of Sample Mode with Weights algorithm For reference, see: On a Fast, Robust Estimator of the Mode: Comparisons to Other Robust Estimators with Applications, David R |
| CFullBilloirVertexFitter | Vertex fitter class implementing the Billoir vertex fitter |
| CConfig | Configuration options for the Billoir vertex fitter |
| CGainMatrixSmoother | Kalman trajectory smoother based on gain matrix formalism |
| CGainMatrixUpdater | Kalman update step using the gain matrix formalism |
| CGaussianGridTrackDensity | Implements a 1-dim density grid to be filled with track Gaussian distributions |
| CConfig | The configuration struct |
| CGaussianSumFitter | Gaussian Sum Fitter implementation |
| CGaussianTrackDensity | Class to model tracks as 2D density functions based on their d0 and z0 perigee parameters (mean value) and covariance matrices (determining the width of the function) |
| CConfig | The Config struct |
| CState | The State struct |
| CTrackEntry | Struct to store information for a single track |
| CGenericApproachDescriptor | Class to decide and return which approaching surface to be taken, it's a generic descriptor for n surfaces |
| CGenericCuboidVolumeBounds | Volume bounds described by eight arbitrary cuboid vertices |
| CBoundValues | This struct helps to symmetrize with the the other volume bounds classes |
| CGenericRungeKuttaStepper | Reference stepper with a configurable Runge-Kutta tableau |
| CConfig | Configuration for the Runge-Kutta stepper |
| COptions | Runtime options for Runge-Kutta propagation |
| CState | State for track parameter propagation |
| CGeometryContext | This is the central definition of the Acts payload object regarding detector geometry status (e.g |
| CGeometryContextOstreamWrapper | Helper struct that stores an object and a context, and will print it to an outstream |
| CGeometryHierarchyMap | Store values mapped into the geometry hierarchy |
| CGeometryHierarchyMapJsonConverter | Convert a geometry hierarchy map to/from Json |
| CGeometryIdentifier | Identifier for geometry nodes within the geometry hierarchy |
| CGeometryIdentifierBlueprintNode | Blueprint node for configuring and applying geometry identifiers to volumes |
| CGeometryIdentifierHook | Base class for hooks that can be used to modify the Geometry Identifier during construction |
| CGeometryObject | Base class to provide GeometryIdentifier interface: |
| CGeometryObjectSorterT | Sorter functor for geometry objects by reference position |
| CGeometryView3D | Helper utilities for drawing geometry in 3D views |
| CGlueVolumesDescriptor | Descriptor class to hold GlueVolumes of a TrackingGeometry object |
| CGreedyAmbiguityResolution | Evicts tracks that seem to be duplicates or fakes |
| CConfig | Configuration parameters for greedy ambiguity resolution |
| CState | Mutable state used by the greedy ambiguity resolution |
| CGrid | Class for describing a regular multi-dimensional grid |
| CGridBinFinder | |
| CGridDensityVertexFinder | Vertex finder that makes use of a track density grid |
| CConfig | The Config struct |
| CState | The State struct |
| CGridGlobalIterator | Grid iterator using the global position |
| CGridLocalIterator | Grid iterator using the local position |
| CGridPortalLink | GridPortalLink implements a subdivided surface where the target volume depends on the position on the surface |
| CGridPortalLinkT | Concrete class deriving from GridPortalLink that boxes a concrete grid for lookup |
| CGridSurfaceMaterial | Concrete, non-template surface material backed by a 2D grid |
| CGloballyIndexed | Per-bin indices into a (possibly shared) globally owned material vector |
| CIndexed | Per-bin indices into a locally owned material vector |
| CGsfComponent | Encapsulates a component of a Gaussian mixture as used by the GSF [gsf component] |
| CGsfExtensions | The extensions needed for the GSF |
| CGsfOptions | Options for configuring the Gaussian-sum filter fit |
| CHelicalTrackLinearizer | Linearizes the track parameters at the PCA to a user-provided point (linPoint) |
| CConfig | Configuration struct |
| CHelixStepper | Stepper that moves the track along a helix in closed form |
| CConfig | Configuration for the helix stepper |
| COptions | Runtime options for helix propagation |
| CState | State for track parameter propagation |
| CHomogeneousSurfaceMaterial | It extends the ISurfaceMaterial virtual base class to describe a simple homogeneous material on a surface |
| CHomogeneousVolumeMaterial | It extends the IVolumeMaterial base class to describe a simple homogeneous material in a volume |
| CHoughVertexFinder | Implements the vertex finder based on the space points using Hough transform For more information, see arXiv:2410.14494 0 |
| CConfig | Configuration struct |
| CIAssignmentFinder | Interface for the material mapping that seeks the possible assignment candidates for the material interactiosn |
| CSurfaceAssignment | SurfaceAssignment is a surface, a position and a direction |
| CVolumeAssignment | VolumeAssignment is a volume and a entry and exit of the volume |
| CIAxis | Common base class for all Axis instances |
| CIConfinedTrackingVolumeBuilder | This is an interface class for constructing TrackingVolumes whose are confined in a mother-TrackingVolume |
| CIGrid | Base class for all grid types |
| CILayerArrayCreator | Interface class ILayerArrayCreators, it inherits from IAlgTool |
| CILayerBuilder | Interface class for ILayerBuilders in a typical | EC- | Central | EC+ | detector setup |
| CIMaterialDecorator | Virtual base class for decorators that allow to load material onto a TrackingGeometry |
| CImpactParametersAndSigma | Impact parameters and their uncertainties with optional timing |
| CImpactPointEstimator | Estimator for impact point calculations A description of the underlying mathematics can be found here: https://github.com/acts-project/acts/pull/2506 TODO: Upload reference at a better place |
| CConfig | Configuration settings for the impact point estimator |
| CState | State struct |
| CIMultiAxis | Common base class for all MultiAxis instances |
| Citerator | Random-access iterator over the contained axes |
| CIMultiAxisXD | Common base class for all multi-axes of a fixed, compile-time dimension |
| CINavigationPolicy | Base class for all navigation policies |
| CEmptyState | |
| CIndexGrid | This is an index grid based navigation state updator, it uses an extractor type and a filler type to handle the navigation state |
| CIndexGridFiller | A helper class that fills surfaces into predefined grids |
| CIndexGridNavigationConfig | Configuration for the index-grid based navigation policy |
| CIndexGridNavigationPolicy | A navigation policy that uses grid based navigation for indexed surfaces Navigate through a multilayer structure by creating an artificial path on the grid |
| CInfiniteBounds | Templated boundless extension to forward the interface Returns all inside checks to true and can templated for all bounds |
| CInputTrack | Type-erased wrapper around an input track pointer |
| CInteractionVolume | The Material interaction volume struct |
| CInteractionVolumeCollector | An Interaction volume collector with unique counting |
| Cthis_result | Simple result struct that holds the collected volumes |
| CInterpolatedBFieldMap | Interpolates magnetic field value from field values on a given grid |
| CCache | Cache for field cell to improve performance of field lookups |
| CConfig | Config structure for the interpolated B field map |
| CFieldCell | Struct representing smallest grid unit in magnetic field grid |
| CInterpolatedMagneticField | Base class for interpolated magnetic field providers |
| CInterpolatedMaterialMap | Interpolate material classification values from material values on a given grid |
| CCache | Temporary storage of a certain cell to improve material access |
| CIntersection | Intersection struct containing the position, path length and status of an intersection |
| CIntersectionMaterialAssigner | A purely intersection based material assigner on a trial and error basis |
| CConfig | Nested configuration struct |
| CIReferenceGenerator | An interface for reference point generators |
| CISensorDesign | Abstract base class for the physical design description of a detector element |
| CIsReadOnlyMultiTrajectory | |
| CIsReadOnlyMultiTrajectory< ActsPlugins::ConstPodioTrackStateContainer< holder_t > > | |
| CIsReadOnlyMultiTrajectory< ActsPlugins::MutablePodioTrackStateContainer< holder_t > > | |
| CIsReadOnlyMultiTrajectory< ConstVectorMultiTrajectory > | |
| CIsReadOnlyMultiTrajectory< VectorMultiTrajectory > | |
| CIsReadOnlyTrackContainer | |
| CIsReadOnlyTrackContainer< ActsPlugins::ConstPodioTrackContainer< holder_t > > | |
| CIsReadOnlyTrackContainer< ActsPlugins::MutablePodioTrackContainer< holder_t > > | |
| CIsReadOnlyTrackContainer< ConstVectorTrackContainer > | |
| CIsReadOnlyTrackContainer< VectorTrackContainer > | |
| CISurfaceMaterial | Base class of all surface-based material description |
| CISurfaceMaterialAccumulator | Interface for the material mapping, this is the accumulation step |
| CState | The state of the material accumulator, this is used to cache information across tracks/events |
| CTrackAccumulation | The accumulation input of a single track |
| CIterativeVertexFinder | Implements an iterative vertex finder |
| CConfig | Configuration struct |
| CState | State struct |
| CITrackingGeometryBuilder | Interface class for the TrackingGeometry building, this is used by the TrackingGeometrySvc to build the geometry |
| CITrackingGeometryJsonDecorator | Helper class to add extra information to surface or volume json objects |
| CITrackingGeometryVisitor | Base class for tracking geometry visitors |
| CITrackingVolumeArrayCreator | Interface class ITrackingVolumeArrayCreators It inherits from IAlgTool |
| CITrackingVolumeBuilder | Interface class ITrackingVolumeBuilders |
| CITrackingVolumeHelper | Interface class ITrackingVolumeHelper tools, it inherits from IAlgTool |
| CITripletSeedCuts | ITripletSeedCuts can be used to increase or decrease seed weights based on the space points used in a seed |
| CITripletSeedFilter | Interface for triplet seed filtering |
| CIVertexFinder | Common interface for both vertex finders and vertex seed finders |
| CIVisualization3D | Partially abstract base class which provides an interface to visualization helper classes |
| CIVolumeLookup | Immutable point-to-volume lookup policy owned by a TrackingVolume |
| CIVolumeMaterial | Material associated with a Volume (homogeneous, binned, interpolated) |
| CIVolumeMaterialJsonDecorator | Helper class to add extra information to surface or volume json objects |
| CJsonDetectorElement | A implementation of a detector element, that is constructed from a JSON description of a surface |
| CjsonKey | Store in a single place the different key used for the material mapping |
| CJsonKindDispatcher | JSON-specific dispatcher that routes decoder functions based on a string kind tag found in the encoded payload |
| CJsonMaterialDecorator | Material decorator from Json format |
| CKalmanFitter | Kalman fitter implementation |
| CKalmanFitterExtensions | Extension struct which holds delegates to customise the KF behavior |
| CKalmanFitterOptions | Combined options for the Kalman fitter |
| CKalmanFitterResult | Result payload returned by the Kalman fitter |
| CKDTree | A general k-d tree with fast range search |
| CKeyedSurfaceMaterial | A keyed assignment |
| CLayer | Base Class for a Detector Layer in the Tracking Geometry |
| CLayerArrayCreator | The LayerArrayCreator is a simple Tool that helps to construct LayerArrays from std::vector of Acts::CylinderLayer, Acts::DiscLayer, Acts::PlaneLayer |
| CConfig | This struct stores the configuration of the tracking geometry |
| CLayerBlueprintNode | The layer node is essentially an auto-sizing wrapper around a set of surfaces |
| CLayerCreator | The LayerCreator is able to build cylinder disc layers or plane layers from detector elements |
| CConfig | Configuration for the LayerCreator This is the nested configuration struct for the LayerCreator class |
| CLinearizedTrack | Class for linear expansion of track parameters in vicinity of vertex |
| CLinearVolumeLookup | Linearly scans children and recursively descends into the selected child |
| CConfig | Construction settings |
| CLineBounds | Bounds for a LineSurface |
| CLineSurface | Base class for a linear surfaces in the TrackingGeometry to describe dirft tube, straw like detectors or the Perigee It inherits from Surface |
| CLogger | Class for printing debug output |
| CMagneticFieldContext | Context object for lookup of magnetic field values |
| CMagneticFieldProvider | Base class for all magnetic field providers |
| CFieldAndGradient | Magnetic field and its spatial gradient at one position |
| CMaterial | Material description for interactions with matter |
| CMaterialComposition | Material composed from multiple elements with varying factions |
| CMaterialDesignatorBlueprintNode | This node type registers material proxies into its child volume during the blueprint construction |
| CMaterialInteraction | The Material interaction struct It records the surface and the passed material This is only necessary recorded when configured |
| CMaterialInteractor | Material interactor propagator action |
| CMaterialMapJsonConverter | Read the material from Json |
| CConfig | Configuration of the Converter |
| CMaterialMapLookup | Struct for mapping global 3D positions to material values |
| CMaterialCell | Struct representing smallest grid unit in material grid |
| CMaterialMapper | Class that implements the material mapping procedure |
| CConfig | Nested configuration struct |
| COptions | Nested options struct holds some options for the delegated calls |
| CState | Nested state struct |
| CMaterialSlab | Material description for an object with defined thickness |
| CMaterialSurfaceIdentifier | Selector for finding surface |
| CMaterialValidator | The material validator is a tool that allows to record the material seen by a ray through a set of material surfaces |
| CConfig | Nested configuration struct |
| CMbfSmoother | Kalman trajectory smoother based on the Modified Bryson–Frazier (mBF) smoother |
| CMeasurementSelector | Measurement selection struct selecting those measurements compatible with the given track parameter against provided criteria on one surface |
| CMeasurementSelectorCuts | Selection cuts for associating measurements with predicted track parameters on a surface |
| CMergedMaterialMarker | Sentinel surface material used by Portal::merge in its "keep going" mode |
| COrigin | Identity of an input whose material was discarded |
| CMiddleSpInfo | Derived quantities for the middle space point in a doublet |
| Cmissing_specialization | |
| CMultiAxis | Multi-dimensional binning defined by a product of one-dimensional axes |
| CMultiAxisSpec | Specification of a multi-dimensional binning that builds the axes of a grid |
| CMultiAxisSpecXD | Multi-dimensional binning spec of a compile-time dimension |
| CMultiComponentBoundTrackParameters | This class is only a light wrapper around a surface and a vector of parameters |
| CMultiIndex | A set of (hierarchical) indices bitpacked into a single value |
| CMultiIntersection | Container for up to two intersections in a given dimension |
| CMultiLayerNavigationPolicy | A navigation policy that uses grid based navigation for indexed surfaces Navigate through a multilayer structure by creating an artificial path on the grid |
| CConfig | Configuration for multilayer navigation behavior |
| CMultiNavigationPolicy | Combined navigation policy that calls all contained other navigation policies |
| CState | Marker state for MultiNavigationPolicy |
| CMultiRangeBField | Magnetic field provider modelling a magnetic field consisting of several (potentially overlapping) regions of constant values |
| CMultiStepperLoop | Stepper based on a single-component stepper, but can handle Multi-Component Tracks (e.g., for the GSF) |
| CConfig | Configuration for the multi-stepper loop |
| COptions | |
| CState | State container for multi-component stepping |
| CComponent | The struct that stores the individual components |
| CMultiStepperSurfaceReached | Aborter that stops when all components reach the target surface |
| CMultiTrajectory | Store a trajectory of track states with multiple components |
| CMultiWireVolumeBuilder | A class to build multiwire tracking volumes (e.g wire chambers) |
| CConfig | Configuration Struct |
| CMutableProtoLayer | A mutable proto layer that can be modified after construction |
| CNavigationArguments | Struct that serves as the argument to the navigation delegate |
| CNavigationLayer | Class to be used for gaps in Volumes as a navigational link |
| CNavigationOptions | The navigation options for the tracking geometry |
| CNavigationPolicyFactory | Base class for navigation policy factories |
| CNavigationPolicyState | Wrapper class for a navigation policy state stored in the state manager |
| CNavigationPolicyStateManager | Manager class for navigation policy states |
| CNavigationStream | The NavigationStream is a container for the navigation candidates that are currentlu processed in a given context |
| CQueryPoint | The query point for the navigation stream |
| CNavigationTarget | The navigation target |
| CNavigator | Steers the propagation through the geometry by providing the next surface to be targeted |
| CConfig | The navigator configuration |
| COptions | The navigator options |
| CState | Nested State struct |
| CAdditionalSurfaceState | An additional surface of the options with its bookkeeping |
| CResolvedExtendedSurface | An extended surface with its volume resolved |
| CNavigatorInitializeArguments | Per-run inputs to the navigator initialization |
| CNavigatorPlainOptions | Plain navigator options carrying geometry context and navigation settings |
| CNavigatorStatistics | A struct to hold statistics of the navigator |
| CNeighborHoodIndices | This object can be iterated to produce up to two sequences of integer indices, corresponding to the half-open integer ranges [begin1, end1[ and [begin2, end2[ |
| Citerator | Iterator over the neighborhood index sequence |
| CNoTargetAborter | Tag used in place of a target aborter type to build a propagator state for a propagation without a target surface |
| CNullBField | Null bfield which returns 0 always |
| CCache | Cache object for the null magnetic field provider |
| CNumericalTrackLinearizer | Linearizes the track parameters at the PCA to a user-provided point (linPoint) |
| CConfig | Configuration struct |
| CObjectSorterT | Sorter functor for geometry objects by axis direction |
| CObjVisualization3D | This helper produces output in the OBJ format |
| COrientedSurface | Helper bundle of a surface and its orientation |
| COuterStripSpacePointCalibrationDetails | Collection of outer strip space point details, used for the calibration |
| COuterStripSpacePointCalibrationDetailsDerived | Derived collection of outer strip space point details, used for the calibration |
| Coverloaded | Helper struct that can turn a set of lambdas into a single entity with overloaded call operator |
| COwningDelegate | |
| COwningDelegate< R(Args...), H > | Alias for an owning delegate |
| CPadBlueprintNode | Wraps a single child blueprint node and pads it into a larger volume whose dimensions are evaluated at construction time using the child's extent plus a configurable envelope |
| CParticleData | Lightweight particle properties description |
| CParticleHypothesis | Particle hypothesis used in reconstruction |
| CPassiveLayerBuilder | The PassiveLayerBuilder is able to build cylinder & disc layers with given dimensions and material |
| CConfig | Configuration struct for the passive layer builder This nested struct is used to configure the layer building |
| CPathLimitReached | This is the condition that the pathLimit has been reached |
| CPerigeeSurface | Class describing the Line to which the Perigee refers to |
| CPlanarBounds | Common base class for all bounds that are in a local x/y cartesian frame |
| CPlaneLayer | Class to describe a planar detector layer for tracking, it inherits from both, Layer base class and PlaneSurface class |
| CPlaneSurface | Class for a planaer in the TrackingGeometry |
| CPlyVisualization3D | Helper to write out PlyVisualization3D visualization format |
| CPointBounds | Bounds for a PointSurface |
| CPointSurface | Surface describing the point of closest approach (PCA) of a track to a single fixed 3D point (the surface center) |
| CPolyhedron | Struct which contains a cartesian approximation for any surface type |
| CPolyhedronReferenceGenerator | A struct to access generated vertices from surface polyhedrons These vertices are then used to find the bin boundary box for the indexed grid |
| CPolynomialBetheHeitlerApprox | This class approximates the Bethe-Heitler distribution as a gaussian mixture |
| CPolyData | Polynomial coefficient sets for a Gaussian mixture component |
| CRangeData | Single x/x0 range with its data and transformation flag |
| CPortal | A portal connects two or more neighboring volumes |
| CArguments | Helper struct for the arguments to the portal constructor below using designated initializers |
| CLink | Aggregate over a surface and a volume with optional semantics |
| CPortalDesignatorBlueprintNode | This node type assigns string tags to specific portal faces of its child volume during the blueprint construction |
| CPortalFusingException | Exception thrown when portals cannot be fused |
| CPortalLinkBase | PortalLinkBase is the abstract base class for all portal links |
| CPortalMergingException | Exception thrown when portals cannot be merged |
| CPortalShellBase | The portal shell of a volume is the set of portals that describes connections "outside" of the volume |
| CProjectedReferenceGenerator | A Projected reference generator which projects the polyhedron vertices onto a given reference surface |
| CPropagator | Propagator for particles (optionally in a magnetic field) |
| CPropagatorMaterialAssigner | A Propagator based material assigner that uses the navigation and transport of the propagator to assign the material to the surface or the volume |
| CPropagatorOptions | Options for propagate() call |
| CPropagatorPlainOptions | Holds the generic propagator options |
| CPropagatorResult | Simple class holding result of propagation call |
| CPropagatorState | Private Propagator state for navigation and debugging |
| CPropagatorStatistics | A struct to hold statistics of the propagator |
| CProtoAxis | This class is a pure run-time placeholder for the axis definition |
| CProtoLayer | Forward-declaration friendly class for backward compatibility This class does not allow modification of the underlying surfaces |
| CProtoLayerHelper | This class is designed to parse a vector of Surfaces and sort them into corresponding proto layers |
| CConfig | |
| CProtoSurfaceMaterialT | Proxy to SurfaceMaterial hand over BinUtility or other suitable binning description |
| CProtoVolumeMaterial | Proxy to VolumeMaterial hand over BinUtility |
| CProxyAccessorBase | Utility class that eases accessing dynamic columns in track and track state containers |
| CRadialBounds | Class to describe the bounds for a planar DiscSurface |
| CRangeXD | An orthogonal range in an arbitrary number of dimensions |
| CRay | Class which models a ray |
| CRecordedMaterial | Simple result struct to be returned It mainly acts as an internal state which is created for every propagation/extrapolation step |
| CRectangleBounds | |
| CRefHolder | Non-owning holder for referencing a backend |
| CRegularSurface | A physical surface which does not depend on the direction you look at it from |
| CRemovePointer | Introduce the Acts version of the pointer remove type trait because we want to fetch the underlying type for the pointer concept and std::library does not allow for an extension of the std::remove_pointer; |
| CRemovePointer< T > | This specialization allows std::remove_pointer to work with types satisfying Acts::SmartPointerConcept, similar to how it works with raw pointers |
| CResult | Class which encapsulates either a valid result, or an error |
| CResult< void, E > | Template specialization for the void case |
| CRzGridVolumeLookup | Built-in RZ grid spatial index |
| CConfig | Serializable construction parameters; assignments are rebuilt from volumes |
| CScopedTimer | A RAII timer class for measuring execution time of code blocks |
| CScoreBasedAmbiguityResolution | Generic implementation of the score based ambiguity resolution |
| CConfig | Configuration struct : contains the configuration for the ambiguity resolution |
| CDetectorConfig | Detector configuration struct : contains the configuration for each detector |
| COptionals | Optionals struct: contains the optional cuts, weights and score to be applied |
| CTrackFeatures | TrackFeatures struct : contains the features that are counted for each track |
| CSeedConfirmationRangeConfig | Contains parameters for quality seed confirmation |
| CSeedContainer | A container of seeds |
| CSeedDeduplicator | Flags seeds whose measurements one accepted track already holds |
| CConfig | Configuration of the duplicate threshold |
| CSeedProxy | A proxy class for accessing individual seeds |
| CSpacePointIterator | Iterator over space points referenced by the seed |
| CSpacePointRange | Range facade for the seed space points |
| CSensorLayer | Fluent builder that assembles a single cylindrical or disc-like detector layer directly from sensor elements, returning a LayerBlueprintNode (no container wrapper) |
| CSensorLayerAssembler | Fluent builder that assembles multiple cylindrical or disc-like detector layers directly from sensor elements into a CylinderContainerBlueprintNode |
| CShiftedCenterReferenceGenerator | A struct to access the shifted center of surface applying a shift on the corresponding coordinate |
| CSingleCuboidPortalShell | This class describes a cuboid shell containing a single volume |
| CSingleCylinderPortalShell | This class describes a cylinder shell containing a single volume |
| CSingleDiamondPortalShell | Implementation of a portal shell class for a single convex polygon volume |
| CSingleTrapezoidPortalShell | This class describes a trapezoid shell containing a single volume |
| CSolenoidBField | Analytical solenoid magnetic field implementation |
| CCache | Cache payload for magnetic field evaluation |
| CConfig | Config struct for the SolenoidBfield |
| CSourceLink | Type-erased source link wrapper |
| CSourceLinkAdapterIterator | Iterator adapter returning SourceLink wrappers |
| CSpacePointColumnProxy | Additional column of data that can be added to the space point container |
| CSubset | Subset view over selected column entries |
| CSpacePointContainer | A container for space points, which can hold additional columns of data and allows for efficient access to space points and their associated source links |
| CRange | Range facade over contiguous index spans |
| CSubset | Subset facade over arbitrary index sets |
| CSpacePointProxy | A proxy class for accessing individual space points |
| CStaticBlueprintNode | The static blueprint node wraps a single already-constructred TrackingVolume |
| CStepperPlainOptions | Common options shared by plain steppers |
| CDense | Options for dense material effects |
| CStepperStatistics | A struct to hold statistics of the stepper |
| CStraightLineStepper | Straight line stepper based on Surface intersection |
| CConfig | |
| COptions | Configuration options for straight line propagation |
| CState | State for track parameter propagation |
| CStrawSurface | Class for a StrawSurface in the TrackingGeometry to describe dirft tube and straw like detectors |
| CSupportsBoundParameters | |
| CSupportsBoundParameters< EigenStepper<> > | |
| CSupportsBoundParameters< GenericRungeKuttaStepper > | |
| CSupportsBoundParameters< HelixStepper > | |
| CSupportsBoundParameters< StraightLineStepper > | |
| CSupportsBoundParameters< SympyStepper > | |
| CSurface | Abstract Base Class for tracking surfaces |
| CSurfaceArray | Provides Surface binning in 2 dimensions |
| CNeighborWindow | Bounds on the neighbor window, in bins per grid axis |
| CSurfaceArrayCreator | It is designed create sub surface arrays to be ordered on Surfaces |
| CConfig | Configuration options for the surface array creator |
| CSurfaceArrayNavigationPolicy | A navigation policy that internally uses the Gen1 SurfaceArray class |
| CConfig | Config struct to configure the surface array navigation |
| CSurfaceBinningMatcher | Helper to compare surfaces for binning equivalence |
| CSurfaceBounds | Interface for surface bounds |
| CSurfaceCollector | A Surface Collector struct templated with a Selector type |
| Cthis_result | Simple result struct to be returned It has all the SurfaceHit objects that are collected (and thus have been selected) |
| CSurfaceHit | The information to be writtern out per hit surface |
| CSurfaceJsonConverter | Static class performing JSON conversion of the surfaces |
| CConfig | Configuration struct |
| COptions | Options for surface conversion |
| CSurfaceMaterialJsonConverter | Static class performing the JSON conversion of surface material |
| CConfig | Configuration struct |
| CSurfaceMergingException | Exception type failures to merge two surfaces |
| CSurfacePlacementBase | The SurfacePlacementBase is an API proxy to model the dynamic movement of the Acts::Surface representing e.g |
| CSurfaceReached | This is the condition that the Surface has been reached it then triggers a propagation abort |
| CSurfaceSelector | Simple struct to select surfaces |
| CSympyStepper | Stepper implementation using sympy-generated expressions |
| CConfig | Configuration for the sympy stepper |
| COptions | Runtime options for sympy propagation |
| CState | State for track parameter propagation |
| CTable | A utility class for creating formatted markdown tables with automatic column sizing and alignment |
| CColumn | Column definition used for layout and formatting |
| CToroidField | Toroid magnetic field implementation |
| CBarrelConfig | Configuration for barrel toroid coils |
| CCache | Cache for magnetic field provider |
| CConfig | Full configuration for the toroid field |
| CEctConfig | Configuration for end-cap toroid (ECT) coils |
| CLayoutConfig | Configuration for coil layout and discretization |
| CTrackAtVertex | Defines a track at vertex object |
| CTrackContainer | Track container interface class |
| CTrackDensityVertexFinder | Finds a vertex seed based on the maximum of a track density function |
| CConfig | The Config struct |
| CState | State struct for fulfilling interface |
| CTrackingGeometry | Owner of the constructed TrackingVolumes |
| CTrackingGeometryBuilder | The Acts::TrackingGeometry Builder for volumes that wrap around another |
| CConfig | Nested Configuration for the CylinderVolumeBuilder |
| CTrackingGeometryJsonConverter | Converter for tracking geometry JSON payloads |
| CConfig | Configuration for the tracking geometry JSON converter |
| CIdToPointerLikeLookup | Generic lookup from serialized ID to pointer-like object holder |
| COptions | JSON serialization options for tracking geometry conversion |
| CPointerToIdLookup | Generic lookup from object pointer identity to serialized object ID |
| CTrackingGeometryMaterial | Surface and volume material assignments |
| CTrackingGeometryMaterialJsonConverter | Versioned material-document conversion, independent of the legacy material converters |
| CConfig | Built-in or application-extended serialization registry |
| CDecodeContext | Per-document decoding state, also available to application decoders |
| CEncodeContext | Per-document encoding state, also available to application encoders |
| COptions | Output options. Version is a property of this codec, not an option |
| CTrackingGeometryMutableVisitor | Mutable visitor interface for modifying the tracking geometry hierarchy |
| CTrackingGeometryVisitor | Visitor interface for traversing the tracking geometry hierarchy |
| CTrackingVolume | Full Volume description used in Tracking, it inherits from Volume to get the geometrical structure |
| CTrackingVolumeArrayCreator | The TrackingVolumeArrayCreator is a simple Tool that helps to construct binned arrays of TrackingVolumes for both, confinement in another volume and navigation issues |
| CConfig | This struct stores the configuration of the tracking geometry |
| CTrackletJoiner | Join a second tracklet, filtered from a state of a smoothed first tracklet as prior, behind that shared state, and combine their smoothed estimates without a new propagation |
| CConfig | Configuration |
| CTrackParamsLookupAccumulator | Class to accumulate and average track lookup tables |
| CTrackProxy | Proxy class representing a single track |
| CTrackProxyCommon | Common CRTP implementation shared by the various track proxy front-ends |
| CTrackSelector | Class which performs filtering of tracks |
| CConfig | Configuration of a set of cuts for a single eta bin Default construction yields a set of cuts that accepts everything |
| CEtaBinnedConfig | Main config object for the track selector |
| CMeasurementCounter | Measurement counting rules for geometry-specific requirements |
| CTrackStateCreator | Create track states for selected measurements associated to a surface |
| CTrackStateProxy | Proxy object to access a single point on the trajectory |
| CTrackStateProxyCommon | Common CRTP implementation shared by track state proxy front-ends |
| CTrackStateTraits | Type aliases describing track state component mappings |
| CTrackStateType | TrackStateTypeBase captured by value |
| CTrackStateTypeBase | CRTP base class for TrackStateType and TrackStateTypeMap |
| CTrackStateTypeMap | TrackStateTypeBase mapped to external storage |
| CTrapezoidBounds | Bounds for a trapezoidal, planar Surface |
| CTrapezoidPortalShell | Base class for trapezoid shaped portal shells, e.g |
| CTrapezoidVolumeBounds | Bounds for a trapezoidal shaped Volume, the orientedSurface(...) method creates a vector of 6 surfaces: |
| CTripletSeeder | Full triplet seeder which depends on a doublet and triplet seed finder, and a triplet seed filter |
| CCache | Cache for storing intermediate results during triplet seeding to avoid reallocation |
| CTripletSeedFinder | Interface and a collection of standard implementations for a triplet seed finder |
| CConfig | Collection of configuration parameters for the triplet seed finder |
| CDerivedConfig | Derived configuration for the triplet seed finder using a magnetic field |
| CTripletTopCandidates | Container for triplet candidates found by the triplet seed finder |
| CProxy | Proxy providing access to a triplet candidate |
| CTrivialPortalLink | Trivial portal link links to a single target volume on every point on a surface |
| CTryAllNavigationPolicy | Policy which adds all candidates of the configured type to the stream |
| CConfig | Configuration for the try-all navigation policy |
| CTypeDispatcher | Template class for type-based function dispatch |
| CTypeDispatcher< base_t, return_t(args_t...)> | Type dispatcher specialization for function signature |
| CTypeList | Type list implementation |
| CTypeTag | |
| CValueHolder | Owning holder that stores a backend by value |
| CVariableSubspaceHelper | Helper class for variable subspace operations |
| CVectorMultiTrajectory | In-memory transient multi-trajectory implementation using std::vector as backend |
| CVectorTrackContainer | Track container backend using std::vector for storage |
| CVertex | Class for storing vertex objects |
| CVertexFitCandidate | Problem-level description of a single vertex candidate |
| CVertexFitProblem | A multi-vertex fit problem |
| CVertexInfo | Helper struct for storing vertex related information |
| CVertexingOptions | Vertex Finder Options |
| CViewConfig | Struct to concentrate all visualization configurations in order to harmonize visualization interfaces |
| CVisualizationBuffer | This helper produces output for Python visualization |
| CVoidNavigator | A navigator that does nothing |
| CConfig | Nested Config struct |
| COptions | Nested Options struct |
| CState | Nested State struct |
| CVolume | It inherits from GeometryObject for geometry identification |
| CVolumeBounds | Pure Absract Base Class for Volume bounds |
| CVolumeConfig | VolumeConfig struct to understand the layer config |
| CVolumeConstraintAborter | This is the condition that the end of world has been reached it then triggers a propagation abort |
| CVolumePlacementBase | Interface class to define the transform cache backend for alignable volumes |
| CVolumeStack | A stack of volumes |
| CResizeStrategies | Pair of resize strategies for volume stacking |
| CWrappingConfig | The WrappingSetup that is happening here |
| CZScanVertexFinder | Implements a vertex finder based on the mode of z0 values: |
| CConfig | Configuration struct |
| CState | State struct for fulfilling interface |
| NActsFatras | The ACTS Fatras fast simulation plugin |
| NCasts | |
| CAbsEta | Retrieve the direction absolute pseudo-rapidity |
| CAbsVz | Retrieve the longitudinal absolute distance of the position to the origin |
| CE | Retrieve the total energy |
| CEta | Retrieve the direction pseudo-rapidity |
| CP | Retrieve the absolute momentum |
| CPt | Retrieve the transverse momentum |
| CVrho | Retrieve the transverse absolute distance of the position to the origin |
| CVz | Retrieve the longitudinal distance of the position to the origin |
| CAbsPdgExcluder | Select all particles except for (anti-)particles of one specific type |
| CAbsPdgSelector | Select particles and antiparticles of one specific type |
| CBarcode | Particle identifier that encodes additional event information |
| CBetheBloch | Simulate energy loss using the Bethe-Bloch/Landau description |
| CBetheHeitler | Simulate electron energy loss using the Bethe-Heitler description |
| CBoundParametersSmearer | Uncorrelated smearing algorithm for fast digitisation of bound parameters |
| CChannel | A channel definition: Cell identification, readout word, links |
| CChannelizer | Class that ties the digitization modules together and produces the channels |
| CChargedSelector | Select all charged particles |
| CCluster | A (simulated) cluster with its constituents |
| CContinuousProcess | A continuous simulation process based on a physics model plus selectors |
| CEveryParticle | No-op particle selector that selects all particles |
| CEverySurface | Select every surface |
| CFailedParticle | A particle that failed to simulate |
| CFreeParametersSmearer | Uncorrelated smearing algorithm for fast digitisation of free parameters |
| CGenericScattering | Simulate (multiple) scattering using a configurable scattering model |
| CHit | A simulation hit on a surface |
| CInteractionList | Compile-time set of interaction processes for the simulation |
| CSelection | Point-like interaction selection |
| CLandauDistribution | Draw random numbers from a Landau distribution |
| Cparam_type | Parameter struct that contains all distribution parameters |
| CMax | Select all objects with an extracted value below the cut |
| CMin | Select all objects with an extracted value equal or larger than the cut |
| CMultiParticleSimulation | Multi-particle/event simulation |
| CNegativeSelector | Select negatively charged particles |
| CNeutralSelector | Select neutral particles |
| CNoDecay | Decay module that treats all particles as stable |
| CNoSurface | Do not select any surface, ever |
| CParticle | Particle identity information and kinematic state |
| CPdgExcluder | Select all particles except one specific type |
| CPdgSelector | Select particles of one specific type |
| CPhotonConversion | This class handles the photon conversion |
| CPointLikeProcess | A point like simulation process based on a physics model plus selectors |
| CPositiveSelector | Select positively charged particles |
| CRange | Select all objects with an extracted value within the range |
| CSegmentizer | The Segmentizer splits a surface segment, i.e |
| CChannelSegment | Nested struct for representing channel steps |
| CChannelStep | Nested struct for stepping from one channel to the next |
| CSingleParticleSimulation | Single particle simulation with fixed propagator, interactions, and decay |
| CSingleParticleSimulationResult | Single particle simulation result (and intermediate state) |
| CSurfaceDrift | The PlanarSurfaceDrift takes an intersection in the nominal surface and projects the ends into the readout surface, which can be at : -1, 0, 1 |
| CSurfaceMask | A brief struct that allows to apply a surface bound mask |
| NActsPlugins | The ACTS plugins namespace: All plugins go here |
| NDD4hep | |
| CDD4hepBackend | Backend adapter that maps a DD4hep detector hierarchy onto the ACTS experimental blueprint-builder interface |
| CConfig | Configuration of the DD4hep backend instance |
| CLayerSpec | Layer-specific configuration forwarded from the generic builder to the DD4hep backend |
| NDetrayConversionUtils | |
| CCache | Detray conversion cache object |
| NEDM4hepUtil | |
| CMeasurementData | Data extracted when reading a measurement from EDM4hep |
| CSimHitAssociation | Helper class for associating simulation hits between EDM4hep and internal indices |
| NGeant4PhysicalVolumeSelectors | |
| CAllSelector | Struct that selects all G4VPhysicalVolume objects |
| CNameSelector | Struct that selects G4VPhysicalVolume objects that match one of the provided names, exact or partially |
| CPositionSelector | Struct that selects G4VPhysicalVolume objects based on the allowed range of their position |
| NPodioUtil | |
| CConversionHelper | Helper interface for converting between ACTS and PODIO types |
| NSvg | |
| NGridConverter | |
| COptions | Nested Options struct |
| NIndexedSurfacesConverter | |
| COptions | Nested options struct |
| NLayerConverter | |
| COptions | A nested options class for the layer conversion |
| NSurfaceArrayConverter | Utilities to convert a surface array into proto objects for SVG output |
| COptions | Nested options struct |
| NSurfaceConverter | |
| COptions | Nested Options struct |
| NTrackingGeometryConverter | |
| COptions | Nested Options struct for the writing configuration |
| CState | State object to collect geometry-wise information |
| NTrackingGeometryProjections | |
| COptions | Options for tracking geometry projections |
| CStyle | Style struct |
| CAmbiguityTrackClassifier | Onnx model implementation for track scoring and selection |
| CBoostTrackBuilding | Track building implementation using Boost |
| CConfig | |
| CConstPodioTrackContainer | Read-only track container backend using podio for storage |
| CConstPodioTrackStateContainer | Read-only track state container backend using podio for storage |
| CCudaTrackBuilding | Track building implementation using CUDA |
| CConfig | Configuration for CUDA track building |
| CDD4hepDetectorElement | DetectorElement class implementation for DD4hep geometry |
| CDD4hepDetectorElementExtension | This extension holds an ACTS detector element belonging to a DD4hep detector element, and synchronizes ownership |
| CDD4hepDetectorSurfaceFactory | A factory to convert DD4hep DetectorElements into sensitive of passive surfaces which are filled into a Cache object, also the create DD4hepDetector elements are provided |
| CCache | Nested cache that records the conversion status |
| CConfig | Configuration struct |
| COptions | Nested options struct to steer the conversion |
| CDD4hepFieldAdapter | Adapter for DD4hep magnetic field to Acts magnetic field provider |
| CDD4hepLayerBuilder | Build layers of one cylinder-endcap setup from DD4hep input |
| CConfig | Nested configuration struct for steering of the layer builder |
| CDD4hepVolumeBuilder | Build confined TrackingVolumes of one cylinder setup from DD4hep input |
| CConfig | Nested configuration struct for steering of the volume builder |
| CDetrayGeometryConverter | Converter from an ACTS TrackingGeometry to a detray detector |
| CConfig | Configuration for the geometry converter |
| CDetrayGeometry | Combined result of a geometry conversion |
| CDetrayPayloadConverter | Converter for ACTS geometry to Detray payload format |
| CConfig | Configuration for the Detray payload converter |
| CPayloads | Container for all Detray payload outputs |
| CDetrayUnsupportedMaterialException | Exception thrown when encountering unsupported material types in Detray conversion |
| CDevice | A simple device description struct |
| CDWalkTrackBuilding | Track building stage using the D-WALK graph segmentation algorithm |
| CConfig | Configuration for D-WALK track building |
| CEdgeClassificationBase | Base class for edge classification stage in GNN pipeline |
| CEdgeLayerConnector | Track building stage based on the EdgeLayerConnector algorithm from the ModuleMapGraph library (CUDA based) |
| CConfig | Configuration for the EdgeLayerConnector |
| CExecutionContext | Capture the context of the execution |
| CFpeMonitor | Monitor for floating-point exceptions with stack trace capture |
| CBuffer | Buffer for storing stack traces |
| CResult | Result of FPE monitoring containing counts and stack traces |
| CFpeInfo | Information about a floating-point exception occurrence |
| CGeant4AlgebraConverter | Converter for Geant4 algebra objects (transforms, vectors, rotations) to ACTS |
| CGeant4DetectorElement | Detector element representative for Geant4 sensitive elements |
| CGeant4DetectorSurfaceFactory | A factory to convert Geant4 physical volumes into Geant4 detector elements |
| CCache | Nested cache that records the conversion status |
| CConfig | Nested configuration struct that holds global lifetime configuration |
| COptions | Nested option struct that allows per call changeable configuration |
| CGeant4MaterialConverter | Converter for Geant4 materials to ACTS material description |
| CGeant4MaterialStepConverter | Converts Geant4 steps into recorded material tracks |
| CConfig | Nested configuration struct |
| CGeant4PhysicalVolumeConverter | Converter for Geant4 physical volumes to ACTS surfaces |
| CGeant4ShapeConverter | Converter for Geant4 shapes to ACTS surface bounds |
| CGeant4VolumeConverter | Converter for Geant4 volumes to ACTS volume bounds |
| CGeoModelDetectorElement | Detector element representative for GeoModel based sensitive elements |
| CGeoModelDetectorElementITk | Specialization of the GeoModelDetectorElement for the ITk |
| CGeoModelDetectorObjectFactory | Factory class to convert GeoModel objects into Acts volumes and surfaces |
| CCache | Cache for storing created detector elements and factory objects |
| CConfig | Configuration for GeoModel detector object factory |
| CConvertedGeoVol | Tuple describing the shared ptr to a Volume which will be turned into a TrackingVolume, a Gen-2 volume and the pointer to the full physical volume |
| COptions | Options for the GeoModel detector object factory |
| CGeoModelTree | Holder struct to manage a GeoModel world |
| CVolumePublisher | Helper struct to manage the list of published full physical volumes |
| CGnnHook | Hook interface for GNN pipeline callbacks |
| CGnnPipeline | Graph Neural Network pipeline for track finding |
| CGnnTiming | Timing information for GNN pipeline execution |
| CGraphConstructionBase | Base class for graph construction algorithms |
| CGraphStoreHook | Hook for storing graph data during GNN pipeline execution |
| CIGeant4PhysicalVolumeSelector | Interface class for selectors from physical volumes |
| CIGeoShapeConverter | Interface for the conversion of GeoShapes to Acts surfaces |
| CITGeoDetectorElementSplitter | ITGeoElementSplitter |
| CITGeoIdentifierProvider | ITGeoIdentierProvider |
| CITkIdentifier | Identifier class for ITk detector elements |
| CMLTrackClassifier | Specialized class that labels tracks as good/duplicate/fake using a deep neural network |
| CModuleMapCuda | CUDA-based module map for graph construction |
| CConfig | Configuration for ModuleMapCuda |
| CMutablePodioTrackContainer | Mutable Podio-based track container implementation |
| CMutablePodioTrackStateContainer | Mutable Podio-based track state container implementation |
| CNoEdgesError | Error that is thrown if no edges are found |
| COnnxEdgeClassifier | ONNX-based edge classifier for GNN pipeline |
| CConfig | Configuration for OnnxEdgeClassifier |
| COnnxRuntimeBase | General class that sets up the ONNX runtime framework for loading an ML model and using it for inference |
| CPipelineTensors | Struct that ties together the tensors used in the GNN pipeline |
| CPodioTrackContainerBase | Base class for PODIO track containers |
| CPodioTrackStateContainerBase | Base class for PODIO track state containers |
| CRootHistogramFit | Fit a Gaussian to a histogram via ROOT's TH1::Fit |
| CConfig | Configuration for RootHistogramFit |
| CRootMaterialDecorator | Read the collection of SurfaceMaterial & VolumeMaterial |
| CConfig | Configuration of the Reader |
| CRootMaterialMapIo | Simple payload class that can be wrapped for reading and writing |
| CConfig | Configuration for the accessor Contains the tags used for writing and reading, tag names are configuration, as they are not very likely to change |
| CMaterialTreePayload | Payload structure for material tree data |
| COptions | Options for writing the material maps Folder names are optional as it allows to write more maps into one file, e.g |
| CRootMaterialTrackIo | Simple payload class that can be wrapped for reading and writing |
| CConfig | Configuration struct for material track I/O |
| CRootMeasurementIo | Helper class to manage the I/O of measurements to and from ROOT files |
| CConfig | Configuration struct for measurement I/O |
| CRootSpacePointIo | Root space point reading and writing utility |
| CSeedClassifier | Onnx model implementation for seed scoring and selection |
| CTensor | This is a very small, limited class that models a 2D tensor of arbitrary type |
| CTensorRTEdgeClassifier | Edge classifier using TensorRT inference |
| CConfig | Configuration struct for TensorRT edge classifier |
| CTGeoAxes | Type-safe representation of TGeo surface axes |
| CTGeoBlueprintBuilderBackend | Backend adapter for building ACTS blueprints from a TGeo geometry tree |
| CConfig | Runtime configuration for the TGeo blueprint backend |
| CElement | Lightweight backend element that points to a node context |
| CLayerSpec | Optional layer configuration used during layer assembly |
| CNodeContext | Context for one node in the TGeo hierarchy |
| CTGeoCylinderDiscSplitter | TGeoCylinderDiscSplitter |
| CConfig | Nested configuration struct |
| CTGeoDetectorElement | DetectorElement plugin for ROOT TGeo shapes |
| CTGeoLayerBuilder | This parses the gGeoManager and looks for a defined combination of volume with contained sensitive detector element |
| CConfig | Nested configuration struct for steering of the layer builder |
| CLayerConfig | Helper config structs for volume parsing |
| CTGeoMaterialConverter | Helper struct for converting TGeo materials to ACTS materials |
| COptions | Nested options struct to steer the conversion process |
| CTGeoParser | TGeoParser is a helper struct that walks recursively through a TGeometry and selects by string comparison the TGeoNodes that match the criteria |
| COptions | Nested configuration struct |
| CSelectedNode | Structure holding a selected TGeo node with its global transform |
| CState | Nested state struct |
| CTGeoPrimitivesHelper | Helper struct for creating ACTS primitives from TGeo geometry |
| CTGeoSurfaceConverter | Helper struct to convert TGeoShapes into Surface or Volume Bounds |
| CTorchEdgeClassifier | Edge classifier using PyTorch inference |
| CConfig | Configuration struct for Torch edge classifier |
| CTorchMetricLearning | Graph construction using PyTorch metric learning |
| CConfig | Configuration struct for Torch metric learning |
| CTrackBuildingBase | Base class for track building implementations |
| CTruthGraphMetricsHook | Hook for calculating metrics using truth graph information |
| Ndetray | Detray include(s) |
| Nactor | |
| Cempty_result | Dummy result type that signals that no result is present |
| Cmomentum_aborter | Aborter that checks whether the track fell below a minimum momentum |
| Cstate | Per-propagation minimum momentum thresholds |
| Cnoise_cfg | Configuration of noise estimation |
| Cparameter_setter | Set the free track parameters in the stepper state, in case observing actors (e.g |
| Cparameter_transporter | Transport the free track parameters at the destination surface and the covariance at the departure surface to bound track parameters at the destination surface (current sensitive/material surface) |
| Cget_bound_to_free_dpos_dangle_visitor | Visitor computing position derivatives with respect to direction angles |
| Cget_bound_to_free_dpos_dloc_visitor | Visitors to the surface local coordinate frameCompute position derivatives with respect to local coordinates |
| Cget_free_to_bound_dloc_dpos_visitor | Visitor computing local-coordinate derivatives with respect to position |
| Cselect_frame | Filter the masks of a detector according to the local frame type |
| Cparameter_transporter_result | Result of the param. transporter: bound track parameters at dest. sf |
| Cparameter_updater_state | State of the parameter updater |
| Cpathlimit_aborter | Aborter that checks whether the track has exceeded its pathlimit |
| Cstate | Pathlimit for a single propagation workflow |
| Cpointwise_material_interactor | Apply energy-loss and multiple-scattering effects at material surfaces |
| Ckernel | Material store visitor |
| Cstate | Per-surface material effects and their application settings |
| Crandom_scatterer | Actor that applies random energy loss and multiple scattering in material |
| Ckernel | Material store visitor |
| Cstate | Per-propagation state for random scattering and energy loss |
| Cresult | Result of the principal actor to be passed to the obsevers |
| Cstep_tracer | Collect information at every step |
| Cstate | Actor state that collects the data |
| Csurface_sequencer | Actor that records sensitive or material-bearing surfaces along a propagation |
| Cstate | Buffer and collection options maintained for one propagation |
| Ctarget_aborter | Aborter checks whether a specific surface was reached |
| Cstate | Keeps the index for the target surface |
| Nalgebra | |
| Narray | |
| Nstorage | |
| Cblock_getter | "Block getter", assuming a simple 2D array access |
| Celement_getter | "Element getter", assuming a simple 2D array access |
| Ndetail | |
| Cis_storage_vector | |
| Cis_storage_vector< algebra::storage::vector< N, scalar_t, array_t > > | |
| Neigen | |
| Nmath | |
| Ctransform3 | Transform wrapper class to ensure standard API within different plugins |
| Nstorage | |
| Cblock_getter | Functor used to extract a block from Eigen matrices |
| Celement_getter | Functor used to access elements of Eigen matrices |
| Nfastor | |
| Nmath | |
| Ctransform3 | Transform wrapper class to ensure standard API towards the Fastor library |
| Nstorage | |
| Cblock_getter | Functor used to extract a block from Fastor matrices |
| Celement_getter | Functor used to access elements of Fastor matrices |
| Ngeneric | |
| Nmath | |
| Ctransform3 | Transform wrapper class to ensure standard API within different plugins |
| Nmatrix | |
| Nadjoint | |
| Ccofactor | "Adjoint getter", assuming a N X N matrix |
| Cadjoint_getter_helper | Helper that computes the adjugate for a fixed matrix rank |
| Cadjoint_getter_helper< N > | Adjugate specialization for a one-element matrix |
| Ndecomposition | |
| Cpartial_pivot_lud | "Partial Pivot LU Decomposition", assuming a N X N matrix |
| Clud | Result of LU decomposition for a matrix of rank N |
| Ndeterminant | |
| Ccofactor | "Determinant getter", assuming a N X N matrix |
| Cdeterminant_getter_helper | Helper that evaluates the determinant for a fixed matrix rank |
| Cdeterminant_getter_helper< N > | Determinant specialization for a one-element matrix |
| Chard_coded | "Determinant getter", assuming a N X N matrix |
| Cpartial_pivot_lud | Compute a determinant from an LU decomposition with partial pivoting |
| Ninverse | |
| Ccofactor | "inverse getter", assuming a N X N matrix |
| Chard_coded | "inverse getter", assuming a N X N matrix |
| Cpartial_pivot_lud | Invert a square matrix using LU decomposition with partial pivoting |
| Cdeterminant_selector | Get the type of determinant algorithm according to matrix dimension |
| Cdeterminant_selector< 2, Args... > | Always use hard coded implementation for very small matrices |
| Cdeterminant_selector< 4, array::matrix_type< T, ROWS, COLS >, array::element_getter > | Choose the backend-specific determinant implementation for 4x4 matrices |
| Cdeterminant_selector< 4, vc_aos::matrix_type< T, ROWS, COLS >, vc_aos::element_getter > | Choose the backend-specific determinant implementation for 4x4 matrices |
| Cinversion_selector | Get the type of inversion algorithm according to matrix dimension |
| Cinversion_selector< 2, Args... > | Always use hard coded implementation for very small matrices |
| Cinversion_selector< 4, array::matrix_type< T, ROWS, COLS >, array::element_getter > | Choose the backend-specific inverse implementation for 4x4 matrices |
| Cinversion_selector< 4, vc_aos::matrix_type< T, ROWS, COLS >, vc_aos::element_getter > | Choose the backend-specific inverse implementation for 4x4 matrices |
| Nsmatrix | |
| Nmath | |
| Ctransform3 | Transform wrapper class to ensure standard API towards the ROOT::SMatrix lib |
| Nstorage | |
| Cblock_getter | Functor used to extract a block from SMatrix matrices |
| Celement_getter | Functor used to access elements of SMatrix matrices |
| Nstorage | |
| Cblock_getter | Functor used to access a submatrix of a matrix |
| Celement_getter | Functor used to access elements of a matrix |
| Cmatrix | Generic matrix type that can take vectors as columns |
| Cvector | Vector wrapper for AoS vs interleaved SoA data |
| Nvc_aos | |
| Nmath | |
| Ctransform3 | Transform wrapper class to ensure standard API within different plugins |
| Naxis | |
| Ndetail | |
| Cmulti_axis_assembler | Helper type to assemble a multi-axis from bounds and binnings |
| Cmulti_axis_assembler< is_owning, containers, local_frame, types::list< axis_bounds... >, types::list< binning_ts... > > | Specialized struct to extract axis bounds and binnings from a tuple |
| Cmulti_axis | An N-dimensional collection of single axes |
| Cmulti_bin | Multi-bin: contains bin indices from multiple axes |
| Cmulti_bin_range | Multi-bin-range: contains bin index ranges from multiple axes |
| Csingle_axis | A single axis |
| Nbins | |
| Cdynamic_array | Bin that views a collection of entries it does not own |
| Cdata | Metadata describing one bin's range in shared storage |
| Csingle | Bin with a single entry |
| Cstatic_array | Bin that holds a collection of entries |
| Ndetail | |
| Cadd_sf_material_map | A functor to add a material map to a surface |
| Cbit_encoder | Sets masked bits to a given value |
| Cdetector | The detector definition |
| Cextent2D | Helper type, used to define the r- or z-extent of detector volumes |
| Cfirst_idx | Extract the first value from an index pack |
| Cfirst_type | Extract the first type from a parameter pack |
| Cget_type_pos | Get the position of a type in a template parameter pack |
| Cget_value_type | Extract the value type of e.g |
| Cget_value_type< container_t > | Extract a container's value_type when it is not void |
| Cget_value_type< T * > | Extract the pointee type when the input is a raw pointer |
| Chas_reserve | Trait class to figure out if a given type has a reserve(...) function |
| Chas_type | Check if the tuple contains a type |
| Chas_type< T, detray::dtuple< T, Ts... > > | |
| Chas_type< T, detray::dtuple< U, Ts... > > | |
| Chas_type< T, detray::dtuple<> > | |
| Chelix | Describes a helical trajectory in a given B-field |
| Cis_permutation | Check for equality of tuple types modulo permutation |
| Cis_permutation< detray::dtuple< Args1... >, detray::dtuple< Args2... > > | Compare the two detray tuple type lists as unordered sets of types |
| Cis_permutation< detray::dtuple<>, detray::dtuple<> > | |
| Cmask_index_update | A functor to update the mask index in surface objects |
| Cmaterial_checker | A functor that checks the material parametrization for a surface/volume |
| Cquadratic_equation | |
| Cquadratic_equation< scalar_t > | Class to solve a quadratic equation of type a * x^2 + b * x + c = 0 |
| Crandom_numbers | Wrapper for CPU random number generatrion for the random_track_generator |
| Cray | Describes a straight-line trajectory |
| Csurface_checker | A functor that checks the surface descriptor and correct volume index in every acceleration data structure for a given volume |
| Ctuple_all | |
| Ctuple_all< trait, detray::dtuple< Args... > > | Apply trait to each element type of a detray tuple and combine with AND |
| Ctuple_any | Check trait on ever element of the tuple |
| Ctuple_any< trait, detray::dtuple< Args... > > | Apply trait to each element type of a detray tuple and combine with OR |
| Ctuple_cat_type | Concatenate tuple types |
| Ctuple_cat_type< detray::dtuple< Args... > > | Preserve a detray tuple type as the concatenation result |
| Ctuple_cat_type< detray::dtuple< Args1... >, detray::dtuple< Args2... >, tuple_ts... > | Concatenate two or more detray tuple type lists recursively |
| Ctuple_element | Tuple_element for std::tuple |
| Ctuple_element< N, detray::dtuple< value_types... > > | Select tuple element N from a detray tuple |
| Ctuple_size | Tuple_size for std::tuple |
| Ctuple_size<::detray::dtuple< value_types... > > | Report the number of elements in a detray tuple |
| Cunique_types | Remove duplicate types from tuple |
| Cunique_types< 0u, detray::dtuple< Arg1, Args... > > | Base case retaining the remaining unique element types |
| Cunique_types< I, detray::dtuple< Arg1, Args... > > | Remove duplicate entries from a detray tuple recursively |
| Cunique_types< I, detray::dtuple<> > | Base case for removing duplicates from an empty detray tuple |
| Cunwrap_refwrapper | Make_tuple for std::tuple users have to specify tuple_t for detail::make_tuple |
| Ngeometry | |
| Cidentifier | Unique identifier for geometry objects, based on the ACTS GeometryIdentifier |
| Csurface | Facade for a detray detector surface |
| Nintersection | |
| Cconfig | Intersector configuration |
| Nio | The following enums are global for all detectors |
| Ncsv | |
| Cbound_track_parameters | Type to read the data of bound track parameters |
| Cfree_track_parameters | Type to read the data of free track parameters |
| Cintersection2D | Type to read the data of a line-surface intersection |
| Caxis_payload | Axis definition and bin edges |
| Ccommon_header_payload | Payload for common information |
| Cdetector_grids_payload | A payload for the grid collections of a detector |
| Cdetector_homogeneous_material_payload | A payload for the homogeneous material description of a detector |
| Cdetector_payload | A payload for a detector geometry |
| Cdetector_reader_config | Config struct for detector reading |
| Cdetector_writer_config | Config struct for detector writing |
| Cfile_handle | Wrapper around a file stream |
| Cgeo_sub_header_payload | Geometry payloads |
| Cgeometry_reader | Tracking geometry reader backend |
| Cgeometry_writer | Tracking geometry writer backend |
| Cgrid_bin_payload | A payload for a single grid bin |
| Cgrid_payload | A payload for a grid definition |
| Cgrid_sub_header_payload | Payloads for a uniform grid |
| Cheader_payload | Payload for common and extra information |
| Chomogeneous_material_reader | Homogeneous material reader backend |
| Chomogeneous_material_sub_header_payload | Material payloads |
| Chomogeneous_material_writer | Homogeneous material writer backend |
| Cjson_converter | Class that adds converts io payloads to json and back |
| Cjson_converter< detector_t, backend_t > | Class that adds json functionality to backend reader types |
| Cmask_payload | A payload object for surface masks |
| Cmaterial_map_reader | Material map reader backend |
| Cmaterial_map_writer | Material maps writer backend |
| Cmaterial_param_payload | A payload object for a material parametrization |
| Cmaterial_volume_payload | A payload object for all of the [surface] material contained in a volume |
| Creader_interface | Abstract base class for detray detector component readers |
| Csingle_link_payload | A payload for a single object link (volume local) |
| Csurface_grid_reader | Surface grid reader backend |
| Csurface_grid_writer | Surface grid writer backend |
| Csurface_material_payload | A payload object for a material slab/rod |
| Csurface_payload | A payload for surfaces |
| Ctransform_payload | A payload for an affine transformation in homogeneous coordinates |
| Ctyped_link_payload | A payload for a typed object link (dtyped_index) |
| Cvolume_material_payload | A payload for the material of a volume |
| Cvolume_payload | A payload for volumes |
| Cwriter_interface | Abstract base class for detray detector component writers |
| Nmaterial_validator | |
| Cget_material_record | Functor to retrieve the material parameters for a given local position |
| Cmaterial_tracer | Actor that collects all material encountered by a track during navigation |
| Cstate | State used to collect material during propagation |
| Ctrack_material | Record the total material budget per track |
| Nnavigation | |
| Cbase_state | A navigation state object used to cache the information of the current navigation stream |
| Cconfig | Navigation configuration |
| Cobject_tracer | A navigation inspector that relays information about the encountered objects whenever the navigator reaches one or more status flags |
| Cprint_inspector | A navigation inspector that prints information about the current navigation state |
| Cvoid_generator | |
| Cvoid_inspector | A void inpector that does nothing |
| Cvoid_view | Empty view accepted by the no-op inspector |
| Nnavigation_validator | |
| Cempty_bfield | B-field placeholder for straight-line navigation |
| Cmin_dist_to_boundary | A functor to get the minimum distance to any surface boundary |
| Csurface_stats | Struct that keeps track of the number of encountered/skipped surfaces |
| Ctrack_statistics | Statistics on tracks with holes and extra surfaces |
| Npropagation | |
| Cconfig | Configuration of the propagation |
| Nranges | |
| Ndetail | |
| Ccartesian_product_iterator | Iterator implementation for the cartesian product view |
| Cjoin_iterator | Sequentially iterate through multiple ranges of the same type |
| Cstatic_join_iterator | Sequentially iterate through multiple ranges of the same type |
| Csubrange_view | Implements a subrange by providing start and end iterators on another range |
| Nviews | |
| Ccartesian_product | Interface type to construct a cartesian_product_view with CTAD |
| Cenumerate | Range adaptor that creates an enumerate view, optionally starting at a selected index |
| Ciota | Interface type to construct a iota_view with CTAD Range adaptor that constructs an iota view from a range, bounds, or start value |
| Cjoin | Interface type to construct a join_view with CTAD |
| Cpick | Range adaptor that selects indexed elements from an input range |
| Cpointer | Interface type to construct a pointer_view with CTAD |
| Csingle | Interface type to construct a single_view with CTAD |
| Cstatic_join | Interface type to construct a static_join_view with CTAD |
| Cbase_view | Definition of 'view' |
| Ccartesian_product_view | Range adaptor that generates a cartesian product from the given input ranges |
| Cdangling | Models a dangling iterator |
| Cempty_view | Implements an empty view of a given type |
| Cenumerate_view | Enumerates the elements of a range on the fly |
| Ciota_view | Range factory that produces a sequence of values |
| Cjoin_view | Range adaptor that joins different ranges of the same type (static) |
| Cpick_view | Range adaptor that indexes the elements of a range using another index range |
| Cpointer_view | Struct that implements a pointer based view on a single element |
| Csingle_view | Struct that implements a view on a single element |
| Cstatic_join_view | Range adaptor that joins different ranges of the same type (static) |
| Csubrange | Interface type to construct a subrange_view with CTAD |
| Cview_interface | Defines a detray 'view' |
| Nstepping | |
| Cconfig | Configuration flags and limits consumed by a stepper |
| Cprint_inspector | A stepper inspector that prints information about the current stepper state |
| Cvoid_inspector | A void inpector that does nothing |
| Nsvgtools | |
| Nconversion | |
| Ndetail | |
| Cbin_association_getter | A functor to access the bins and get the associated surface indices |
| Ctype_and_edge_getter | A functor to access the type and bin edges of a grid |
| Cmaterial_converter | A functor to fill the material proto grid with proto material slabs |
| Csurface_converter | A functor to set the proto surfaces type and bounds to be equivalent to the mask |
| Nmeta | |
| Nproto | |
| Ceta_lines | A proto eta line |
| Cinformation_section | A proto intersection record class as a simple translation layer from a intersection record description |
| Cintersection | A proto intersection class as a simple translation layer from an intersection description |
| Clandmark | A proto landmark class as a simple translation layer from a description of a point |
| Ctrajectory | A proto landmark class as a simple translation layer from a description of a point |
| Nstyling | |
| Ncolors | |
| Ctableau_colorblind10 | Tableau colorblind palette with grey, blue, and red tone sequences |
| Cdetector_style | Style applied to an actsvg proto detector |
| Ceta_lines_style | Style applied to proto eta lines |
| Cgrid_style | Style applied to an actsvg proto grid |
| Clandmark_style | Style applied to a proto landmark |
| Clink_style | Style applied to an actsvg proto portal link |
| Cportal_style | Style applied to an actsvg proto portal |
| Cstyle | Global styling options |
| Csurface_material_style | Style applied to an actsvg proto surface_material |
| Csurface_style | Style applied to an actsvg proto surface |
| Ctrajectory_style | Style applied to a proto trajectory |
| Cvolume_style | Style applied to an actsvg proto volume |
| Nutils | |
| Clink_end_getter | Functor to calculate a suitable end point for displaying the link arrow |
| Clink_start_getter | Functor to calculate a suitable starting point for displaying the link arrow |
| Cillustrator | SVG generator for a detector and related entities |
| Ntest | |
| Cconfiguration | Test configuration type |
| Cdetector_scan_config | Configuration for a detector scan test |
| Cmaterial_validation_config | Configuration for a detector scan test |
| Cnavigation_validation_config | Configuration for a detector scan test |
| Ntraits | |
| Cblock_getter | |
| Cblock_getter< Eigen::MatrixBase< derived_t > > | Block getter |
| Cdimensions | Matrix dimensions |
| Cdimensions< ::detray::detail::transport_jacobian_matrix_with_gradient< algebra_t > > | Matrix dimension traits for a transport Jacobian including gradients |
| Cdimensions< ::detray::detail::transport_jacobian_matrix_without_gradient< algebra_t > > | Matrix dimension traits for a transport Jacobian without gradients |
| Cdimensions< algebra::vc_aos::storage_type< T, N > > | Dimensions of Vc AoS storage, represented as one column of N rows |
| Cdimensions< algebra::vc_soa::storage_type< T, N > > | Dimensions of SoA storage, represented as one column of N rows |
| Cdimensions< Eigen::Block< Eigen::Matrix< T, ROWS, COLS, OPT, ROWS, COLS >, bROWS, bCOLS, false > > | Dimensions trait for a fixed-size Eigen matrix block |
| Cdimensions< Eigen::MatrixBase< derived_t > > | DimensionsDimensions trait for a fixed Eigen matrix expression |
| Cdimensions< M > | Specialization for scalar types |
| Cdimensions< Vc_1::Vector< T, Vc_1::simd_abi::fixed_size< N > > > | Dimensions of a fixed-size Vc vector, represented as one column |
| Celement_getter | Getter types |
| Celement_getter< Eigen::Block< Eigen::Matrix< T, ROWS, COLS, OPT, ROWS, COLS >, bROWS, bCOLS, false > > | Element accessor trait for an Eigen matrix block |
| Celement_getter< Eigen::MatrixBase< derived_t > > | Element getter |
| Cget_algebra | The algebra types |
| Cget_algebra< A > | Expose the types provided by a supported algebra |
| Cget_algebra< A< V >, W > | Switch the value type of an existing algebra definition |
| Cindex | Matrix traits |
| Cindex< ::detray::detail::transport_jacobian_matrix_with_gradient< algebra_t > > | Matrix index type for transport Jacobians that include gradients |
| Cindex< ::detray::detail::transport_jacobian_matrix_without_gradient< algebra_t > > | Matrix index type for transport Jacobians without gradients |
| Cindex< algebra::vc_aos::storage_type< T, N > > | Index type associated with a Vc AoS storage type |
| Cindex< Eigen::Block< Eigen::Matrix< T, ROWS, COLS, OPT, ROWS, COLS >, bROWS, bCOLS, false > > | Index trait specialization for a fixed Eigen matrix block |
| Cindex< Eigen::MatrixBase< derived_t > > | Index |
| Cindex< Vc_1::Vector< T, Vc_1::simd_abi::fixed_size< N > > > | Index trait for a fixed-size Vc vector |
| Cmatrix | |
| Cmatrix< Eigen::Block< Eigen::Matrix< T, ROWS, COLS, OPT, ROWS, COLS >, bROWS, bCOLS, false > > | Matrix trait for an Eigen block expression |
| Cmatrix< Eigen::MatrixBase< derived_t > > | MatrixMatrix trait for an Eigen matrix expression |
| Cscalar | Scalar type that is used with the matrix (can be multiple values in SoA) |
| Cscalar< algebra::storage::matrix< algebra::vc_soa::storage_type, Vc::Vector< T >, ROWS, COLS > > | Make sure the simd scalar type is recognized correctlyScalar trait for an SoA matrix whose entries are SIMD vectors |
| Cscalar< algebra::storage::vector< N, Vc::Vector< T >, algebra::vc_soa::storage_type > > | Scalar trait for an SoA vector whose entries are SIMD vectors |
| Cvalue | Value type that is used with the matrix (e.g |
| Cvalue< algebra::vc_aos::storage_type< T, N > > | Scalar type associated with a Vc AoS storage type |
| Cvalue< Eigen::Block< Eigen::Matrix< T, ROWS, COLS, OPT, ROWS, COLS >, bROWS, bCOLS, false > > | Value trait specialization for a fixed Eigen matrix block |
| Cvalue< Eigen::MatrixBase< derived_t > > | Value |
| Cvalue< T > | Map an arithmetic scalar type to itself as its value type |
| Cvalue< Vc::Vector< T > > | Get the single value type from the simd scalar typeValue trait that unwraps the element type from a Vc vector |
| Cvalue< Vc_1::Vector< T, Vc_1::simd_abi::fixed_size< N > > > | Value trait for a fixed-size Vc vector |
| Cvector | Vector type that is compatible with the matrix |
| Cvector< Eigen::MatrixBase< derived_t > > | VectorVector trait for an Eigen expression with a single compile-time column |
| Ntypes | |
| Ndetail | Traits for the type list |
| Cis_type_list | |
| Cis_type_list< types::list< Ts... > > | |
| Ccast_impl_id | Get the type corresponding to an ID |
| Ccast_impl_id< I, mapped_registry< R, S > > | Cast an in-range index to the identifier type of a mapped registry |
| Ccast_impl_id< I, registry< ID, Ts... > > | Cast an in-range index to the registry's identifier type |
| Ccast_impl_idx | |
| Ccast_impl_idx< I, mapped_registry< R, S > > | Translate an original index to its mapped-registry index |
| Ccast_impl_idx< I, registry< ID, Ts... > > | Cast an in-range index to the same index for an unfiltered registry |
| Ccontains_impl | Does the list contain a particular type? |
| Ccontains_impl< T, I, list< T, Ts... > > | Report the current position when the head type matches |
| Ccontains_impl< T, I, list<> > | Report an invalid position after reaching an empty list |
| Ccontains_impl< T, I, mapped_registry< R, S > > | Search a mapped registry and translate original positions to filtered positions where applicable |
| Ccontains_impl< T, I, registry< ID, Ts... > > | Specialization of the type list contains trait |
| Ccontains_impl< U, I, list< T, Ts... > > | Continue the lookup after the current head type did not match |
| Cdo_push_back | Append a type |
| Cdo_push_back< N, list< Ts... > > | Append N to the end of the supplied type list |
| Cdo_push_front | Prepend a type |
| Cdo_push_front< N, list< Ts... > > | Prepend N to the supplied type list |
| Cget_at | Access the N-th type |
| Cget_at< N, list< T, Ts... > > | Select the type at position N from a nonempty list |
| Cget_at< N, mapped_registry< R, S > > | Select a type by position from a mapped registry |
| Cget_at< N, registry< ID, Ts... > > | Specialization of the type list size trait |
| Cget_back | Access the last type |
| Cget_back< list< T, Ts... > > | Specialization returning the last type of a nonempty list |
| Cget_back< list<> > | Empty lists have no last type, represented here by void |
| Cget_front | Access the first type |
| Cget_front< list< T, Ts... > > | Specialization returning the head type of a nonempty list |
| Cget_id | Traits for the type registry |
| Cget_id< T, mapped_registry< R, S > > | Resolve a type to its identifier, accepting either original or filtered types for a mapped registry |
| Cget_id< T, registry< ID, Ts... > > | Resolve a registered type to its identifier in the original registry |
| Cget_size | Number of types in the list |
| Cget_size< list< Ts... > > | |
| Cget_size< mapped_registry< R, S > > | |
| Cget_size< registry< ID, Ts... > > | Specialization of the type list size traits |
| Cget_type | Get the type corresponding to an ID |
| Cget_type< I, mapped_registry< R, S > > | Resolve an original identifier value through a mapped registry |
| Cget_type< I, registry< ID, Ts... > > | Resolve an identifier value to its registered type |
| Clist | Type list implementation |
| Cmapped_registry | Select a number of types from another registry and map their IDs to a continuous range of new type indices |
| Cprint | Print a message when the type is not a type list |
| Cprint< list< Ts... > > | Print the types and delimiters of a type list |
| Cregistry | Match types with indices/identifiers and vice versa |
| Nutils | |
| Ndetail | |
| Caccelerator_printer | A functor that retrieves an acceleration struct and prints it |
| Cmaterial_printer | A functor that retrieves material and prints it |
| Cstring_view_concat2 | Convenience class to statically concatenate two string views |
| Cactor_chain | The interface to the actors and aborters in the propagation |
| Cactor_chain<> | Empty actor chain (placeholder) |
| Caggregate_inspector | An inspector that aggregates a number of different inspectors |
| Cair | Mixtures or Compounds |
| Caluminium | Predefined aluminium material with tabulated bulk properties |
| Calways_init | Struct that represents the most conservative navigation policy: always re- initialize the current volume |
| Cstate | Stateless policy state |
| Cannulus2D | Geometrical shape of a stereo annulus that is used for the ITk strip endcaps |
| Cantimuon | Positive muon hypothesis |
| Cargon_gas | Predefined argon gas material with tabulated bulk properties |
| Cargon_liquid | Predefined argon liquid material with tabulated bulk properties |
| Carray | Define the plugin types |
| Cattach | An attach populator that adds a new entry to a given bin |
| Caxis_aligned_bounding_volume | An axis aligned bounding box of a given |
| Caxis_rotation | Helper struct to rotate a vector around a given axis and angle counterclockwisely |
| Cbarrel_generator | Generates a number of surfaces in a barrel shape |
| Cbarrel_generator_config | Configuration for the barrel module generator |
| Cbase_actor | Base class actor implementation |
| Cis_comp_actor | Tag whether this is a composite type |
| Cstate | Defines the actors state. Hidden by actor implementations |
| Cbase_stepper | Base stepper implementation |
| Cstate | State struct holding the track |
| Cberyllium | Predefined beryllium material with tabulated bulk properties |
| Cberyllium_tml | Elements Declaration for ACTS Generic detector |
| Cbin_associator | Fill a grid surface finder by bin association |
| Cbound_parameters_vector | Six-component parameter vector expressed in a surface-bound coordinate frame |
| Cbound_track_parameters | Combine the bound track parameter vector with the covariance and associated surface |
| Cbrute_force_collection | A collection of brute force surface finders, callable by index |
| Cbrute_forcer | A nested surface finder that returns all surfaces in a range (brute force) |
| Cbrute_force_scan | Struct that holds functionality to shoot a parametrized particle trajectory through a detector |
| Ccaching_navigator | Navigation class which caches a 'road' through the detector |
| Cstate | Navigation state that contains a cache of candidates |
| Ccarbon_gas | Predefined carbon gas material with tabulated bulk properties |
| Ccartesian2D | Projection into a 2D cartesian coordinate frame |
| Ccartesian3D | Projection into a 3D cartesian coordinate frame |
| Ccesium_iodide | Predefined cesium iodide material with tabulated bulk properties |
| Ccesium_iodide_with_ded | Predefined cesium iodide material with density-effect data |
| Ccomplete | A complete populator that adds entries to a bin which contains an array of entries until it is completed - ignored afterwards |
| Ccomposite_actor | Composition of actors |
| Cis_comp_actor | Tag whether this is a composite type (hides the def in the actor) |
| Cconcentric_cylinder2D | Geometrical shape of a 2D concentric cylinder |
| Cconcentric_cylindrical2D | Projection into a 2D concentric cylindrical frame (No rotation in coordinate transformation) |
| Cconst_container_types | Bundle container type definitions |
| Cconstant | Physical and mathematical constants |
| Cconstrained_step | Struct that can be configured with a number of different step sizes by other actors and will then resolve the strictest one |
| Ccontainer_types | Bundle container type definitions |
| Ccopper | Predefined copper material with tabulated bulk properties |
| Ccopper_with_ded | Predefined copper material with density-effect data |
| Ccuboid3D | Geometrical shape of a full 3D cuboid |
| Ccuboid_intersector | Checks if a cuboid bonuding box is intersected by a ray |
| Ccuboid_portal_generator | Generates a portal box around a volume that already contains surfaces |
| Ccurvilinear_frame | Frame and Jacobian data associated with a free track's curvilinear frame |
| Ccylinder2D | Geometrical shape of a 2D cylinder |
| Ccylinder3D | Geometrical shape of a full 3D cylinder |
| Ccylinder_portal_config | Configuration for the cylinder portal generator |
| Ccylinder_portal_generator | Generates a portal box around a volume that already contains surfaces |
| Cboundaries | Save the boundaries of the cylinder after autofitting the portals |
| Ccylindrical2D | Projection into a 2D cylindrical coordinate frame |
| Ccylindrical3D | Projection into a 3D cylindrical coordinate frame |
| Cdefault_hash | Default hash function makes use of default node in the hash tree |
| Cdefault_metadata | Type and storage policy used to assemble a detector from geometry and material components |
| Cdetector_builder | Provides functionality to build a detray detector volume by volume |
| Cdetector_traits | |
| Cdetector_traits< detail::detector< metadata_t, container_t > > | Unified interface to detector types - from any detector type |
| Cdetector_traits< metadata_t > | Unified interface to detector types - from a metadata type |
| Cdirect_navigator | Navigator that visits an externally supplied sequence of surfaces in order |
| Cstate | Mutable state for traversing the external surface sequence |
| Ceigen | Define the plugin types |
| Celectron | Electron hypothesis |
| Cendcap_generator | Generates surfaces for an endcap layer consisting of two rings |
| Cendcap_generator_config | Configuration for the barrel module generator |
| Ceuler_rotation | Helper struct to perform an euler rotation for a given vector All rotation operations are counterclockwise |
| Cexternal_surface | Surface descriptor used for geometry supplied outside the detector store |
| Cfactory_decorator | Decorator for the surface factories |
| Cfastor | Define the plugin types |
| Cfill_by_bin | Fill a surface grid using a local bin index of the grid and a payload |
| Cbin_data | Single piece of data for a grid bin |
| Cfill_by_pos | Fill a surface grid using the surface translation |
| Cfree_parameters_vector | Six-component parameter vector expressed in global Cartesian coordinates |
| Cgold | Predefined gold material with tabulated bulk properties |
| Cgrid_builder | Build a grid of a certain shape |
| Cgrid_collection | A collection of grids that can be moved to device as part of the detector |
| Cgrid_collection< detray::grid_impl< axes_t, bin_t, serializer_t > > | Specialization for detray::grid |
| Cgrid_collection< spatial_grid_impl< grid_t > > | Accelerator collection specialization for detray::spatial_grid_impl |
| Cgrid_factory | Provides functionality to instantiate grids and grid collections |
| Cgrid_impl | An N-dimensional grid for object storage |
| Cguided_navigation | During guided navigation only the next surface should be re-evaluated |
| Cstate | Stateless policy state |
| Chash_tree | Builds a hash tree from the data of an input collection |
| Chashed_node | Default node in the hash tree |
| Chelium_gas | Predefined helium gas material with tabulated bulk properties |
| Chelix_intersector_impl | Intersection implementation for detector surfaces using a helix trajectory |
| Chelix_intersector_impl< cartesian2D< algebra_t >, algebra_t > | Intersection implementation for helical trajectories with planar surfaces |
| Chelix_intersector_impl< concentric_cylindrical2D< algebra_t >, algebra_t > | Helix intersector for a concentric cylindrical coordinate frame |
| Chelix_intersector_impl< cylindrical2D< algebra_t >, algebra_t > | Intersection implementation for cylinder surfaces using helical trajectories |
| Chelix_intersector_impl< line2D< algebra_t >, algebra_t > | Intersection implementation for helical trajectories with line surfaces |
| Chelix_intersector_impl< polar2D< algebra_t >, algebra_t > | |
| Chom_material_config | Configuration for the homogeneous material generator |
| Chomogeneous_material_builder | Build a volume containing surfaces with material |
| Chomogeneous_material_factory | Factory class for homogeneous material |
| Chomogeneous_material_generator | Surface factory decorator that adds homogeneous material to surfaces |
| Chomogeneous_volume_material_builder | Build a volume with homogeneous volume material |
| Chydrogen_gas | Predefined hydrogen gas material with tabulated bulk properties |
| Chydrogen_liquid | Predefined hydrogen liquid material with tabulated bulk properties |
| Cinteraction | Computes energy loss and multiple scattering in detector material |
| Cintersection2D | This class holds the intersection information |
| Cintersection_point | Result of intersector: Point of intersection on a surface |
| Cintersection_point< algebra_t, point_t, !intersection::contains_pos > | Result of intersector: Only contains the distance (production) |
| Cintersection_point< algebra_t, point_t, intersection::contains_pos > | Result of intersector: Distance and intersection point (debug) |
| Cintersection_point_err | Result of intersector: Distance, intersection point (2D or 3D, local/global) and error estimate on distance (for mask resolution) |
| Cintersection_record | Record of a surface intersection along a track |
| Cintersector | Intersection interface for detector surfaces |
| Cintersector_base | Base class for an intersector: Provides mask based call interfaces for convenience |
| Cinvalid | Invalid particle hypothesis (PDG number zero) |
| Ciron | Predefined iron material with tabulated bulk properties |
| Ciron_with_ded | Predefined iron material with density-effect data |
| Cis_ratio_one | Helper trait to check if the ratio is one |
| Cisobutane | Predefined isobutane material with tabulated bulk properties |
| Clandau_distribution | Landau distribution based on CERNLIB G110 Computer Physics Communications 31(1984) 97—111) |
| Cline | Geometrical shape of a line surface |
| Cline2D | Projection into a line coordinate frame |
| Cline_stepper | Straight line stepper implementation |
| Cstate | State carried by the straight-line stepper |
| Cmask | Mask a region on a surface and link it to a volume |
| Cmaterial | Material composition properties and density data used by interactions |
| Cmaterial_data | Bind components for material together |
| Cmaterial_map_builder | Build the material maps for a given volume |
| Cmaterial_map_config | Configuration for the material map generator |
| Cmap_config | How to configure the generation for a specific type of material map |
| Cmaterial_map_factory | Factory class for material maps |
| Cmaterial_map_generator | Surface factory decorator that adds material maps to surfaces |
| Cmaterial_record | Contains the material parameters and the pathlength |
| Cmaterial_rod | Rod structure to be mapped on the line mask |
| Cmaterial_slab | Slab structure to be mapped on the mask (plane, cylinder) |
| Cmixture | Compile-time material mixture type |
| Cmuon | Negative muon hypothesis |
| Cname_map | Map volume indices to volume names and vice versa |
| Cnavigator | The geometry navigation class |
| Cstate | Navigation state that contains a the current and the next candidates |
| Cnavigator_base | Navigation base class - interface towards the propagator |
| Cnitrogen_gas | Predefined nitrogen gas material with tabulated bulk properties |
| Codd_metadata | Detector-specific aliases and storage policy for odd geometry |
| Coxygen_gas | Predefined oxygen gas material with tabulated bulk properties |
| Coxygen_liquid | Predefined oxygen liquid material with tabulated bulk properties |
| Cpdg_particle | Particle hypothesis identified by PDG number, mass, and electric charge |
| Cperigee_extrapolator | Templated propagator class, using a stepper and a navigator object in succession |
| Cperigee_stopper | Actor that exits from a navigation stream, if it has reached the perigee |
| Cstate | Per-actor configuration for checking the perigee |
| Cphoton | Photon hypothesis |
| Cpion_minus | Negative pion hypothesis |
| Cpion_plus | Positive pion hypothesis |
| Cpion_zero | Neutral pion hypothesis |
| Cpolar2D | Projection into a polar coordinate frame |
| Cpositron | Positron hypothesis |
| Cpropagation_record | Data for a single step |
| Cpropagation_validation_config | Configure the Kalman Filter comparison test |
| Cpropagator | Templated propagator class, using a stepper and a navigator object in succession |
| Cstate_base | Propagation that state aggregates a stepping and a navigation state |
| Cpropane | Predefined propane material with tabulated bulk properties |
| Crandom_track_generator | Generates track states with random momentum directions |
| Crandom_track_generator_config | Configuration for the random track generator |
| Cratio_sum | Struct to sum over variadic std::ratio |
| Cratio_sum_helper | Helper struct to sum over variadic std::ratio |
| Cratio_sum_helper< R > | Base case for a one-element ratio sum |
| Cratio_sum_helper< ratio1, ratio2, ratios... > | Recursive case that adds two ratios before processing any remainder |
| Cray_intersector_impl | Intersection implementation for detector surfaces using a ray trajectory |
| Cray_intersector_impl< cartesian2D< algebra_t >, algebra_t, resolve_pos > | A functor to find intersections between straight line and planar surface |
| Cray_intersector_impl< concentric_cylindrical2D< algebra_t >, algebra_t, resolve_pos > | A functor to find intersections between a straight line and a cylindrical portal surface |
| Cray_intersector_impl< cylindrical2D< algebra_t >, algebra_t, resolve_pos > | A functor to find intersections between a ray and a 2D cylinder mask |
| Cray_intersector_impl< line2D< algebra_t >, algebra_t, resolve_pos > | A functor to find intersections between trajectory and line mask |
| Cray_intersector_impl< polar2D< algebra_t >, algebra_t, resolve_pos > | |
| Crectangle2D | Geometrical shape of a rectangle2D |
| Creplace | A replace populator that overrides whatever current content is in the bin with a new entry |
| Cring2D | Geometrical shape of a closed ring |
| Crk_stepper | Runge-Kutta-Nystrom 4th order stepper implementation |
| Cintermediate_state | Intermediate values evaluated at the RK integration stages |
| Cstate | Per-track integration state maintained by the stepper |
| Cscattering_helper | Generates a random direction after multiple scattering |
| Csilicon | Predefined silicon material with tabulated bulk properties |
| Csilicon_tml | Predefined silicon material using TrackML bulk properties |
| Csilicon_with_ded | Predefined silicon material with density-effect data |
| Csingle3D | Underlying geometry for a single parameter bound mask |
| Csmatrix | Define the plugin types |
| Cspatial_grid_impl | An N-dimensional spatial grid for geometry object searches |
| Cstep_record | Data for a single step |
| Cstepper_default_policy | Default navigation update policy for the steppers: If a constraint has been hit, lower the trustlevel to 'fair trust', otherwise stay in 'high trust' |
| Cstate | Tolerance for deciding whether a step reached a constraint |
| Cstepper_rk_policy | Specific navigation policy for the Runge-Kutta stepper: Use the relative amount of step size correction as a measure for the change in direction of the track state |
| Cstate | Relative correction thresholds used to choose navigation trust |
| Csurface_data | Bind transform and mask data together for surface building |
| Csurface_descriptor | Templated surface class for detector surfaces and portals |
| Csurface_factory | Generates a number of surfaces for a volume (can be portals, passives or sensitives) and fills them into the containers of a volume builder |
| Csurface_factory_interface | How to generate surfaces with their corresponding masks and transforms |
| Ctel_det_config | Configure the toy detector |
| Ctelescope_generator | Generates a number of surfaces along a given direction |
| Ctelescope_metadata | Defines a special telescope test detector type with only rectangle portals and one additional kind of contained module surfaces (mask_shape_t) |
| Ctoy_det_config | Configure the toy detector |
| Ctoy_metadata | Detector-specific aliases and storage policy for toy geometry |
| Ctracking_surface | Facade for a detray detector surface with extra tracking capabilities |
| Ctracking_volume | Facade for a detray detector volume |
| Ctrapezoid2D | Geometrical shape of a trapezoid2D |
| Ctungsten | Predefined tungsten material with tabulated bulk properties |
| Ctuple | Default tuple type |
| Ctuple< T, Ts... > | Recursive tuple node holding one value and the remaining tuple tail |
| Cunbounded | Wraps any shape, but does not enforce boundaries |
| Cunconstrained_step | Struct that represents unconstrained stepping |
| Cuniform_track_generator | Generates track states with momentum directions in a uniform angle space |
| Cuniform_track_generator_config | Configuration for the uniform track generator |
| Cunit | Unit conversion factors |
| Cunit_vectors | Build the curvilinear unit basis perpendicular to a three-dimensional direction |
| Cunmasked | Generic shape without boundaries |
| Cvacuum | Elements Declaration |
| Cvc_aos | Define the plugin types |
| Cvc_soa | Define the plugin types |
| Cvoid_actor | Placeholder struct for an action while walking through the graph |
| Cvoid_node_inspector | Placeholder struct for the implementation of an inspection function that will be executed, when a node is visited |
| Cvolume_builder | Provides basic functionality to build detector volumes |
| Cvolume_builder_interface | Interface for volume builders (and volume builder decorators) |
| Cvolume_builder_options | Options for the volume builder classes |
| Cvolume_decorator | Decorator for the volume builder |
| Cvolume_descriptor | The detray detector volume descriptor |
| Cvolume_graph | Uses the geometry implementations to walk through their graph-like structure breadth first |
| Cedge_generator | Builds graph edges from the detector mask collection on the fly |
| Cedge | An edge in the graph connects two nodes (volumes) |
| Cedges_builder | Nested functor that fills the edges from a mask container |
| Cnode_generator | Builds a graph node from the detector collections on the fly |
| Citerator | Iterator over the graph nodes |
| Cnode | A node in the graph has an index (volume index) and a collection of edges that belong to it (mask link of every surface in the volume) |
| Cnode_builder | A functor to retrieve the half-edges of a node |
| Cwire_chamber_config | Configuration for building a wire chamber detector |
| Cwire_chamber_metadata | Detector-specific aliases and storage policy for wire chamber geometry |
| Cwire_layer_generator | Generates a number of drift cells or straw tubes for a barrel layer |
| Cwire_layer_generator_config | Configuration for the wire layer generator |
1.15.0