 |
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 |
| CGbtsEdge | Edge between two GBTS nodes with fit parameters |
| CGbtsEdgeState | Per-edge tracking state used by the GBTS filter |
| CGbtsEtaBin | Eta-bin container for GBTS nodes and edge data |
| CGbtsGeometry | Geometry helper built from layers and connectors |
| CGbtsLayer | Layer helper with eta-bin access for GBTS seeding |
| CGbtsLayerConnection | Connection between two GBTS layers with binning information |
| CGbtsLayerConnectionMap | Loader and container for GBTS layer connection data |
| CLayerGroup | Group of connections targeting a destination layer |
| CGbtsLayerConnectionTool | Layer connection training tool for creating layer map for GBTS |
| CConfig | Configuration for the layer connection tool |
| CHitCoordinates | Container for track layer hit information |
| 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 |
| CGbtsNode | GBTS graph node storing space point properties |
| CGbtsNodeStorage | Storage container for GBTS nodes |
| CGbtsRoiDescriptor | GBTS region-of-interest descriptor with eta/phi/zed bounds |
| CGbtsTrackingFilter | Tracking filter operating on the GBTS edge graph |
| CConfig | Configuration for the tracking filter |
| CState | State for the tracking filter, containing edge states and a global counter |
| 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 |
| COutputSeedProperties | Output seed metadata |
| CSeedCandidateProperties | Candidate seed metadata produced by the GBTS algorithm |
| CSlidingWindow | Sliding window in phi used to define range used for edge creation |
| 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 |
| NGridAccess | |
| CAffine3Transformed | Adapter that applies an affine transform before grid-local conversion |
| CBoundCylinderToZPhi | Convert bound cylinder local coordinates to Z-Phi grid coordinates |
| CGlobalSubspace | A global (potentially casted) sub space of a global position |
| CIBoundToGridLocal | Interface class for owning delegate |
| CIGlobalToGridLocal | Interface class for owning delegate |
| CLocalSubspace | Access a local coordinate subspace for bound parameter grids |
| 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 | |
| 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 |
| 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 SurfaceMaterialMapper 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 |
| CConfig | Configuration options for the adaptive multi-vertex fit |
| CState | The fitter state |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| CGloballyIndexedMaterialAccessor | This is an accessor for cases where the material is filled in a global material vector that is accessed from the different material grids |
| 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 |
| CGridMaterialAccessor | This is an accessor for cases where the material is directly stored in the grid, it simply forwards the grid entry in const and non-const way |
| 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 |
| CGridSurfaceMaterialT | GridSurfaceMaterialT |
| CGsfComponent | Encapsulates a component of a Gaussian mixture as used by the GSF |
| 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 |
| 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 |
| CIGridMaterialAccessor | Base class for material accessors, this is needed for the I/O of the different grid material types, in the actual implementation the material accessor is a template parameter |
| CIGridSurfaceMaterial | Intermediate interface to the grid surface material given access to the grid and the material accessor |
| CIGridSurfaceMaterialBase | Base class for the concrete templated grid surface material 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 | |
| CIndexedMaterialAccessor | This is an accessor for cases where the material is filled in a vector and then indexed by the grid |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| CMaterialSurface | Selector for finding surface |
| 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 |
| CMaterialVolume | Selector for finding volume |
| 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 |
| 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 |
| 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 |
| CNavigatorPlainOptions | Plain navigator options carrying geometry context and surfaces |
| 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 |
| 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 |
| 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 |
| 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 |
| 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< StraightLineStepper > | |
| CSupportsBoundParameters< SympyStepper > | |
| CSurface | Abstract Base Class for tracking surfaces |
| CSurfaceArray | Provides Surface binning in 2 dimensions |
| 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 |
| CSurfaceMaterialMapper | SurfaceMaterialMapper |
| CConfig | Nested Configuration struct for the material mapper |
| CState | Nested State struct which is used for the mapping prococess |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| CVolumeCollector | A Volume Collector struct templated with a Selector type |
| Cthis_result | Simple result struct to be returned It has all the VolumeHit objects that are collected (and thus have been selected) |
| 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 |
| CVolumeHit | The information to be writtern out per hit volume |
| CVolumeMaterialMapper | VolumeMaterialMapper |
| CConfig | Nested Configuration struct for the material mapper |
| CState | Nested State struct which is used for the mapping prococess |
| CVolumePlacementBase | Interface class to define the transform cache backend for alignable volumes |
| CVolumeSelector | Simple struct to select 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 |
| 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 |
| 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 |
| 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 and associated clusters 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 |
1.15.0