  acts | |
  _adapter | |
 examples | |
 dd4hep | |
| detector | |
 CylindricalDetectorVolume | |
 CylindricalDetectorContainer | |
| edm4hep | |
| geant4 | |
| dd4hep | |
| hepmc3 | |
| hepmc3 | |
| itk | |
| InputSpacePointsType | |
| mockupbuilder | |
| odd | |
| odd_light | |
| onnx | |
| mlpack | |
| reconstruction | |
| VertexFinder | |
| simulation | |
| CustomLogLevel | |
| Sequencer | |
| FpeMask | |
| Acts | Acts includes to create all necessary definitions |
| AxisJsonConverter | |
| Ccl | |
| internal | |
| cellTypeHasRequiredFunctions | |
| cellTypeHasRequiredFunctions< T, 2, std::void_t< decltype(getCellRow(std::declval< T >())), decltype(getCellColumn(std::declval< T >())), decltype(getCellLabel(std::declval< T & >()))> > | |
| cellTypeHasRequiredFunctions< T, 1, std::void_t< decltype(getCellColumn(std::declval< T >())), decltype(getCellLabel(std::declval< T & >()))> > | |
| clusterTypeHasRequiredFunctions | |
| clusterTypeHasRequiredFunctions< T, U, std::void_t< decltype(clusterAddCell(std::declval< T >(), std::declval< U >()))> > | |
| Compare | |
| Compare< Cell, 2 > | |
| Compare< Cell, 1 > | |
| DisjointSets | |
| ConnectionsBase | |
| Connections | |
| Connections< 1 > | |
| Connections< 2 > | |
| Connect2D | |
| Connect1D | |
| DefaultConnect | |
| DefaultConnect< Cell, 2 > | |
| DefaultConnect< Cell, 1 > | |
| Concepts | |
| Linearizer | |
| LinearizerConcept | |
| SourceLinkAccessor | |
| SourceLinkAccessorConcept | |
| Stepper | |
| CommonStepperConcept | |
| SingleStepperConcept | |
| MultiStepperConcept | |
| VertexFinder | |
| VertexFinderConcept | |
| VertexFitter | |
| VertexFitterConcept | |
| BoundTrackParametersConceptImpl | |
| FreeTrackParametersConceptImpl | |
| Cuda | |
| Details | |
| SpacePoint | Helper struct describing a spacepoint on the device |
| DubletCounts | Helper struct summarising the results of the dublet search |
| LinCircle | Helper struct holding the linearly transformed coordinates of spacepoints |
| Triplet | Structure used in the CUDA-based triplet finding |
| DeviceArrayDeleter | Class performing the deletion of a CUDA device memory array |
| HostArrayDeleter | Class performing the deletion of pinned host memory |
| SeedFinder | |
| TripletFilterConfig | Structure holding pointers to the user defined filter functions |
| Info | |
| Device | Helper struct describing one available CUDA device |
| MemoryManager | |
| DeviceMemory | |
| StreamWrapper | |
| detail | These functions perform the transport of a covariance matrix using given Jacobians. The required data is provided by the stepper object with some additional data. Since this is a purely algebraic problem the calculations are identical for StraightLineStepper and EigenStepper. As a consequence the methods can be located in a separate file |
| Test | |
| VerticesHelper | Helper methods for polyhedron vertices drawing and inside/outside checks |
| CorrectedFreeToBoundTransformer | Corrected free to bound transform class based on covariance matrix sqrt root in UKF: https://doi.org/10.1117/12.280797 |
| covariance_helper | Check and correct covariance matrix |
| DynamicColumnBase | |
| DynamicColumn | |
| DynamicColumn< bool > | |
| Wrapper | |
| UnrestrictedParameterTraits | Traits class for an unrestricted parameter |
| RestrictedParameterTraits | |
| CyclicParameterTraits | |
| PhiBoundParameterLimits | |
| ThetaBoundParameterLimits | |
| ParameterTraitsImpl< BoundIndices, BoundIndices::eBoundPhi > | |
| ParameterTraitsImpl< BoundIndices, BoundIndices::eBoundTheta > | |
| ParameterTraitsImpl< BoundIndices, kIndex > | |
| ParameterTraitsImpl< FreeIndices, kIndex > | |
| ParametersTraitsImpl< BoundIndices > | |
| ParametersTraitsImpl< FreeIndices > | |
| visit_measurement_callable | |
| is_same_template | |
| is_same_template< T, T > | |
| SmallObjectCache | Small opaque cache type which uses small buffer optimization |
| Handler | |
| HandlerBase | |
| abort_list_impl< first, others...> | |
| abort_list_impl< last > | This is the check call on the a last of all conditions |
| abort_list_impl<> | This is the empty call list - never abort |
| action_list_impl< first, others...> | |
| action_list_impl< last > | |
| action_list_impl<> | The empty action list call implementation |
| VoidAuctioneer | Auctioneer that takes all extensions as valid that make a valid bid |
| FirstValidAuctioneer | Auctioneer that states only the first one that makes a valid bid |
| HighestValidAuctioneer | Auctioneer that makes only the highest bidding extension valid. If multiple elements have the same int, the first one with this value is picked |
| GenericDefaultExtension | Default evaluater of the k_i's and elements of the transport matrix D of the RKN4 stepping. This is a pure implementation by textbook |
| GenericDenseEnvironmentExtension | Evaluater of the k_i's and elements of the transport matrix D of the RKN4 stepping. This implementation involves energy loss due to ioninisation, bremsstrahlung, pair production and photonuclear interaction in the propagation and the jacobian. These effects will only occur if the propagation is in a TrackingVolume with attached material |
| stepper_bound_parameters | |
| stepper_curvilinear_parameters | |
| PointwiseMaterialInteraction | Struct to handle pointwise material interaction |
| Step | The step information for recording |
| SteppingLogger | Step length logger for debugging the stepping |
| this_result | Simple result struct to be returned |
| VoidNavigator | The void navigator struct as a default navigator |
| State | Nested State struct, minimal requirement |
| VolumeMaterialInteraction | Struct to handle volume material interaction |
| FacesHelper | Helper for writing out faces for polyhedron representation |
| IntersectionHelper2D | |
| GaussianComponent | |
| GsfResult | |
| GsfActor | The actor carrying out the GSF algorithm |
| Config | |
| TemporaryStates | |
| ScopedGsfInfoPrinterAndChecker | |
| MultiTrajectoryProjector | Projector type which maps a MultiTrajectory-Index to a tuple of [weight, parameters, covariance]. Therefore, it contains a MultiTrajectory and for now a std::map for the weights |
| SymmetricKLDistanceMatrix | Class representing a symmetric distance matrix |
| IsMultiComponentBoundParameters | |
| IsMultiComponentBoundParameters< MultiComponentBoundTrackParameters > | |
| NeighborHoodIndices | |
| iterator | |
| Axis< AxisType::Equidistant, bdt > | Calculate bin indices for an equidistant binning |
| Axis< AxisType::Variable, bdt > | Calculate bin indices for a variable binning |
| Extendable | |
| Grid | Class for describing a regular multi-dimensional grid |
| GlobalNeighborHoodIndices | |
| iterator | |
| grid_helper_impl | |
| grid_helper_impl< 0u > | |
| grid_helper | Helper functions for grid-related operations |
| can_interpolate | Check types for requirements needed by interpolation |
| get_dimension | Determine number of dimension from power of 2 |
| result_type_extractor | |
| action_type_extractor | |
| RealQuadraticEquation | |
| FixedSizeSubspace | |
| CyclicAngle | Angle descriptions for the combineBoundGaussianMixture function |
| CyclicRadiusAngle | |
| AngleDescription | A compile time map to provide angle descriptions for different surfaces |
| AngleDescription< Surface::Disc > | |
| AngleDescription< Surface::Cylinder > | |
| RefHolder | Internal holder type for referencing a backend without ownership |
| ConstRefHolder | |
| ValueHolder | Internal holder type holding a backend container by value |
| nonesuch | Helper struct which cannot be constructed (or destroyed) at all |
| detector | |
| detector< Default, std::void_t< Op< Args...> >, Op, Args...> | |
| CantorEdge | |
| TorchTypeMap | So far this is only needed for integers |
| TorchTypeMap< int64_t > | |
| TorchTypeMap< int32_t > | |
| TorchTypeMap< int16_t > | |
| TorchTypeMap< int8_t > | |
| TorchTypeMap< float > | |
| TorchTypeMap< double > | |
| detail_lt | |
| TransitiveConstPointer | Helper type to make a member pointers constness transitive |
| Types | Type construction helper for coefficients and associated covariances |
| TrackStateProxy | |
| TrackStateRange | Helper type that wraps two iterators |
| Iterator | |
| detail_tc | |
| TrackProxyIterator | Helper iterator to allow iteration over tracks via track proxies |
| detail_vmt | |
| VectorMultiTrajectoryBase | |
| IndexData | |
| Statistics | |
| detail_vtc | |
| VectorTrackContainerBase | |
| DetectorJsonConverter | |
| Options | |
| DetectorVolumeJsonConverter | |
| Options | |
| DetrayJsonHelper | |
| EDM4hepUtil | |
| detail | |
| Parameters | |
| EventDataView3DTest | |
| Experimental | |
| Blueprint | |
| Node | |
| detail | |
| BlueprintHelper | |
| CylindricalDetectorHelper | |
| GridAxisGenerators | |
| Eq | Templated base generator for equidistant axis as a tuple - 1D |
| Var | Templated base generator for variable axis as a tuple - 1D |
| EqEq | Templated base generator for two equidistant axes as a tuple - 2D |
| EqVar | Templated base generator for equidistant / variable axes as a tuple - 2D |
| VarEq | Templated base generator for a variable, equidistant axes tuple - 2D |
| VarVar | Templated base generator for a two variable axes tuple - 2D |
| PortalHelper | |
| SupportHelper | This file contains helper methods to build common support structures such as support cylinders or discs |
| IndexedGridFiller | A helper class that fills surfaces into predefined grids |
| IndexedSurfacesGenerator | A templated indexed grid generator |
| CenterReferenceGenerator | |
| BinningValueReferenceGenerator | |
| PolyhedronReferenceGenerator | |
| CylindricalContainerBuilder | A dedicated container builder for cylindrical detector containers |
| Config | Nested configuration object |
| Detector | A detector |
| DetectorBuilder | Standard generic Detector builder that calls the top level component builder and transfers the result into a detector object |
| Config | Nested configuration object |
| RootDetectorVolumes | Container to collect root volumes for the construction of a Detector |
| DetectorComponent | The currently built detector components including the constructed volumes and the current shell/coating, i.e. portals ordered in a map |
| ExternalStructure | Holder struct for the external structure components required to construct a detectorVolume |
| InternalStructure | Holder struct for the internal structure components of a DetectorVolume |
| DetectorVolume | Define a dummy detector volume |
| ObjectStore | |
| DetectorVolumeFactory | A detector volume factory which first constructs the detector volume and then constructs the portals. This ensures that the std::shared_ptr holding the detector volume is not weak when assigning to the portals |
| AllPortalsExtractor | Helper extractors: all portals |
| AllSurfacesExtractor | Helper extractors: all surfaces |
| IndexedSurfacesExtractor | Helper extractors: indexed surfaces |
| AllSubVolumesExtractor | Helper extractors: all sub volumes of a volume |
| IndexedSubVolumesExtractor | Helper extractors: indexed sub volume of a volume |
| DetectorVolumeBuilder | A generic detector volume builder that uses an external builder for shape and portals and an internal structure builder for volume internals |
| Config | Nested configuration object |
| GeometryIdGenerator | This is the default implementation of the geometry id generator |
| Cache | Nested cache struct |
| Config | Nested config struct |
| IndexedRootVolumeFinderBuilder | This is the interface for builders that create root volume finder delegates |
| IDetectorBuilder | This is the interface for building a Detector object |
| IDetectorComponentBuilder | This is the interface for detector component builders; such a builder could be a simple detector volume builder, with or without internal structure, or more complicated objects |
| IExternalStructureBuilder | This is the interface definition of external structure builders for DetectorVolume construction |
| IGeometryIdGenerator | This is the interface for generating geometry ids and assign them to detector volumes, portals and surfaces |
| IInternalStructureBuilder | This is the interface definition of internal structure builders for DetectorVolume construction |
| IRootVolumeFinderBuilder | This is the interface for builders that create root volume finder delegates |
| ISurfacesProvider | This is the interface for providing surfaces to the detector building process. These surfaces manly describe the sensitive detector surfaces, but also passive (i.e. material carrying) surfaces are considered |
| KdtSurfaces | A wrapper class around a KDTree of surfaces |
| KdtSurfacesProvider | Callable struct wrapper around the KDT surface structure |
| LayerStructureBuilder | This is a builder of layer structures to be contained within a DetectorVolume, it extends the IInternalStructureBuilder interface and provides the internal structure components of DetectorVolume objects to be constructed |
| Config | Configuration struct for the LayerStructureBuilder |
| SurfacesHolder | A holder struct for surfaces |
| MultiWireStructureBuilder | |
| Config | Configuration struct for the MultiWireStructure Builder |
| Portal | |
| ProtoBinning | Simple helper class to define a binning structure |
| ProtoSupport | Support parameter definitions |
| VolumeStructureBuilder | |
| Config | Nexted configuration struct |
| DetectorNavigator | |
| Config | |
| State | |
| NoopFinder | |
| RootVolumeFinder | |
| TrialAndErrorVolumeFinder | |
| IndexedDetectorVolumeExtractor | A helper struct that allows to extrace a volume from the detector by its index |
| EndOfWorldImpl | The end of world sets the volume pointer of the navigation state to nullptr, usually indicates the end of the known world, hence the name |
| SingleDetectorVolumeImpl | Single volume updator, it sets the current navigation volume to the volume in question |
| DetectorVolumesCollection | This holds and extracts a collection of detector volumes. Alternatively an extractor could also use the detector and its associated detector volume container for volume extraction |
| BoundVolumesGrid1Impl | This is used for volumes that are indexed in a bound 1-dimensional grid, e.g. a z-spaced array, or an r-spaced array of volumes |
| MultiLayerSurfacesUpdatorImpl | |
| PathGridSurfacesGenerator | |
| INavigationDelegate | |
| NavigationState | A navigation state struct that is holding the current navigation information |
| SurfaceCandidate | A surface candidate and its intersection |
| DetectorVolumeFiller | Filler of the current volume |
| SurfacesFiller | Fillers and attachers for surfaces to act on the navigation state |
| PortalsFiller | Fillers and attachers for portals to act on the navigation state |
| SingleObjectImpl | This sets a single object, e.g. single surface or single volume |
| StaticUpdatorImpl | This uses state less extractor and fillers to manipulate the navigation state |
| IndexedUpdatorImpl | This is an index grid based navigation state updator, it uses an extractor type and a filler type to handle the navigation state |
| ChainedUpdatorImpl | |
| AllPortalsImpl | |
| AllPortalsAndSurfacesImpl | |
| AdditionalSurfacesImpl | This holds and extracts a collection of surfaces without much checking, this could be e.g. support surfaces for layer structures, e.g |
| Gx2FitterExtensions | Extension struct which holds delegates to customize the KF behavior |
| Gx2FitterOptions | |
| Gx2FitterResult | |
| Gx2Fitter | |
| Aborter | Aborter can stay like this probably |
| Actor | Propagator Actor plugin for the GX2F |
| DD4hepLayerStructure | This class allows to generate layer structure builders for dd4hep sub detectors It performs an intermediate step by taking dd4hep::DetElemnent objects that describe a detector structure and prepares the translation of the detector element and eventual passive surfaces |
| Options | Nested options struct |
| DD4hepVolumeStructure | This class allows to generate volumes structure builders for dd4hep sub detectors, together with an internal structure builder, this is sufficient to build the new DetectorVolume objects |
| Options | Nested options struct |
| LinkToVolumeImpl | Simple link to volume struct |
| Geant4PhysicalVolumeSelectors | |
| AllSelector | Struct that selects all G4VPhysicalVolume objects |
| NameSelector | Struct that selects G4VPhysicalVolume objects that match one of the provided names, exact or partially |
| GridJsonConverter | |
| GsfConstants | |
| HashedStringLiteral | |
| IndexedSurfacesJsonConverter | |
| IntegrationTest | |
| StreamWrapper | |
| KalmanVertexTrackUpdater | |
| detail | |
| KalmanVertexUpdater | |
| detail | |
| MatrixCache | Adds or removes track from or updates current vertex Based on R. Frühwirth et al. Vertex reconstruction and track bundling at the lep collider using robust Algorithms Computer Physics Comm.: 96 (1996) 189, chapter 2.1 |
| Legacy | |
| AtlasSeedFinder | |
| Config | |
| comCurvature | |
| InternalSeed | |
| Seed | |
| SPForSeed | |
| Logging | Debug output related helper classes and functions |
| ThresholdFailure | Custom exception class so threshold failures can be caught |
| OutputPrintPolicy | Abstract base class for printing debug output |
| OutputFilterPolicy | Abstract base class for filtering debug output |
| DefaultFilterPolicy | Default filter policy for debug messages |
| OutputDecorator | Base class for decorating the debug output |
| NamedOutputDecorator | Decorate debug message with a name |
| TimedOutputDecorator | Decorate debug message with a time stamp |
| ThreadOutputDecorator | Decorate debug message with a thread ID |
| LevelOutputDecorator | Decorate debug message with its debug level |
| DefaultPrintPolicy | Default print policy for debug messages |
| MultiTrajectoryHelpers | |
| TrajectoryState | Struct for brief trajectory summary info |
| MultiTrajectoryTraits | |
| PhysicalConstants | |
| PlanarHelper | Helpers for planar surfaces that share the same maths |
| podio_detail | |
| ConstDynamicColumnBase | |
| DynamicColumnBase | |
| DynamicColumn | |
| ConstDynamicColumn | |
| PodioUtil | |
| ConversionHelper | |
| PortalJsonConverter | |
| Options | |
| PrimitivesView3DTest | |
| Python | |
| Context | |
| PythonLogger | |
| SurfaceBoundsJsonConverter | |
| SurfaceJsonConverter | |
| Options | |
| SurfaceView3DTest | |
| Svg | |
| DetectorConverter | |
| Options | A nested options class for the layer conversion |
| DetectorVolumeConverter | |
| Options | A nested options class for the layer conversion |
| EventDataConverter | |
| GridConverter | |
| Options | Nested Options struct |
| IndexedSurfacesConverter | |
| Options | Nested options struct |
| LayerConverter | |
| Options | A nested options class for the layer conversion |
| PortalConverter | |
| Options | Nested Options struct for conversion options |
| Sheet | |
| SurfaceArrayConverter | |
| Options | Nested options struct |
| SurfaceConverter | |
| Options | Nested Options struct |
| TrackingGeometryConverter | |
| Options | Nested Options struct for the writing configuration |
| State | State object to collect geometry-wise information |
| TrackingGeometryProjections | |
| Options | |
| View | |
| Style | |
| Sycl | |
| detail | |
| DeviceSpacePoint | |
| DeviceLinEqCircle | |
| DeviceSeedFinderConfig | |
| DeviceTriplet | |
| SeedData | |
| DupletSearch | Functor taking care of finding viable spacepoint duplets |
| LinearTransform | Functor performing a linear coordinate transformation on spacepoint pairs |
| TripletFilter | Functor performing Triplet Filter |
| TripletSearch | Functor performing Triplet Search |
| DeviceArrayDeleter | Deleter functor for the smart pointer type(s) |
| DeviceExperimentCuts | |
| SeedFinder | |
| DeviceSelector | Custom device selector that refuses to select NVIDIA OpenCL backends |
| QueueWrapper | |
| Test | |
| benchmark_tools_internal | |
| MicroBenchmarkIterImpl | |
| MicroBenchmarkIterImpl< Callable, Input, void > | |
| MicroBenchmarkIterImpl< Callable, void, Result > | |
| MicroBenchmarkIterImpl< Callable, void, void > | |
| MicroBenchmarkIter | |
| MicroBenchmarkIter< Callable, void > | |
| events | |
| Connect | |
| Established | |
| Timeout | |
| Ping | |
| Pong | |
| Disconnect | |
| float_compare_internal | |
| Layers | |
| states | |
| Disconnected | |
| Connecting | |
| Pinging | |
| Connected | |
| MicroBenchmarkResult | |
| CubicBVHTrackingGeometry | |
| CubicTrackingGeometry | |
| CylindricalTrackingGeometry | |
| DetectorElementStub | |
| LineSurfaceStub | |
| MeasurementResolution | Measurement resolution configuration for a single detector type |
| Measurements | Result struct for generated measurements and outliers |
| MeasurementsCreator | Propagator action to create smeared measurements |
| MultiTrajectoryTestsCommon | |
| TestSourceLink | |
| SurfaceAccessor | |
| TestSpacePoint | Space point representation of a measurement suitable for track seeding |
| TestTrackState | |
| DummySequenceElement | |
| GenericReadWriteTool | |
| Cell1D | |
| Cluster1D | |
| Cell2D | |
| Cluster2D | |
| AlignmentContext | |
| AlignableDetectorElement | |
| StepVolumeCollector | |
| this_result | Data container for result analysis |
| LayerCreatorFixture | |
| SurfaceArrayCreatorFixture | |
| CallableHook | |
| SurfaceMaterialStub | |
| MockPropagatorState | Simplified propagator state |
| MockNavigator | |
| PropState | Simplified propagator state |
| EndOfWorld | Aborter for the case that a particle leaves the detector or reaches a custom made threshold |
| StepCollector | Data collector while propagation |
| this_result | Data container for result analysis |
| PlaneSelector | |
| StepWiseActor | Bound state propagation |
| this_result | The result is the piece-wise jacobian |
| SteppingState | Mockup of stepping state |
| Stepper | Mockup of stepping state |
| NavigationState | Mockup of navigation state |
| Options | Mockup of the Propagator Options |
| PropagatorState | Mockup of propagtor state |
| Options | Emulate the options template |
| Stepper | This is a simple cache struct to mimic a Stepper |
| State | |
| PerpendicularMeasure | An observer that measures the perpendicular distance |
| this_result | Simple result struct to be returned |
| SurfaceObserver | An observer that measures the perpendicular distance |
| this_result | Simple result struct to be returned |
| StepperState | Simplified stepper state |
| NaivgatorState | Simplified navigator |
| State | Simplified propagator state |
| Navigator | Simplified navigator |
| SurfaceArrayFixture | |
| Detector | |
| Object | |
| fsm | |
| fsm2 | |
| S1 | |
| S2 | |
| S3 | |
| E1 | |
| E2 | |
| E3 | |
| fsm3 | |
| MyStruct | |
| functor | |
| TreeFixture1DDoubleInt1 | |
| TreeFixture1DDoubleInt2 | |
| TreeFixture2DDoubleInt1 | |
| TreeFixture3DDoubleInt1 | |
| TreeFixture3DDoubleInt2 | |
| TreeFixture3DDoubleInt3 | |
| TreeFixture10DDoubleInt1 | |
| TreeFixture3DDoubleString1 | |
| TreeFixture1DIntInt1 | |
| TreeFixture2DIntInt1 | |
| variadic_struct | |
| tuple_helper | |
| NoCopy | |
| E | |
| M | |
| M2 | |
| M3 | |
| M4 | |
| M5 | |
| N | |
| N2 | |
| N3 | |
| A | |
| meta | |
| Nested | |
| A2 | |
| meta | |
| Nested | |
| B | |
| C | |
| D | |
| InputTrack | |
| VertexInfo | Helper struct to store reference vertex related information |
| PlyElement | Ply element struct |
| RootGeometry | Struct to load the global geometry |
| TrackingGeometryView3DTest | |
| Transform3JsonConverter | |
| Options | The options for the transform converter |
| UnitConstants | |
| UnitLiterals | |
| VectorHelpers | |
| detail | |
| VolumeBoundsJsonConverter | |
| VolumeView3DTest | |
| GreedyAmbiguityResolution | |
| Config | |
| State | |
| Direction | |
| ParticleData | |
| ProtoVolume | |
| ContainerStructure | |
| InternalStructure | |
| ProtoDetector | |
| CartesianSegmentation | Segmentation Base class |
| DigitizationCell | Pair of ints for definition of a cell |
| DigitizationStep | DigitizationStep for further handling |
| DigitizationModule | |
| DigitizationSourceLink | Source link to connect digitization clusters back to truth information |
| PlanarModuleCluster | |
| PlanarModuleStepper | |
| Segmentation | Segmentation Base class |
| Neutral | Charge and momentum interpretation for neutral particles |
| SinglyCharged | Charge and momentum interpretation for particles with +-e charge |
| NonNeutralCharge | |
| AnyCharge | |
| FreeToBoundCorrection | Free to bound transformation Correction configuration class |
| GenericBoundTrackParameters | |
| GenericCurvilinearTrackParameters | |
| GenericFreeTrackParameters | |
| GenericParticleHypothesis | Particle hypothesis used in reconstruction |
| Measurement | |
| MultiComponentBoundTrackParameters | |
| MultiComponentCurvilinearTrackParameters | |
| TrackStateTraits | |
| MultiTrajectory | |
| SinglyChargedParticleHypothesis | |
| NeutralParticleHypothesis | |
| NonNeutralChargedParticleHypothesis | |
| ParticleHypothesis | |
| SourceLink | |
| SourceLinkAdapterIterator | |
| SpacePointData | |
| TrackContainer | |
| TrackAccessorBase | |
| TrackProxy | |
| TrackStateType | |
| ConstTrackStateType | |
| IsReadOnlyMultiTrajectory< VectorMultiTrajectory > | |
| VectorMultiTrajectory | |
| IsReadOnlyMultiTrajectory< ConstVectorMultiTrajectory > | |
| ConstVectorMultiTrajectory | |
| IsReadOnlyTrackContainer< VectorTrackContainer > | |
| VectorTrackContainer | |
| IsReadOnlyTrackContainer< ConstVectorTrackContainer > | |
| ConstVectorTrackContainer | |
| AbstractVolume | |
| ApproachDescriptor | |
| BoundarySurfaceT | |
| ConeLayer | |
| ConeVolumeBounds | |
| CuboidVolumeBounds | |
| CuboidVolumeBuilder | This class builds a box detector with a configurable amount of surfaces in it. The idea is to allow a quick configuration of a detector for mostly unit test applications. Therefore this class does not demand to be a universal construction factory but a raw first draft of the idea of factory that may be extended in the future |
| Config | This struct stores the configuration of the tracking geometry |
| LayerConfig | This struct stores the data for the construction of a PlaneLayer |
| SurfaceConfig | This struct stores the data for the construction of a single PlaneSurface |
| VolumeConfig | This struct stores the data for the construction of a cuboid TrackingVolume with a given number of PlaneLayers |
| CutoutCylinderVolumeBounds | |
| CylinderLayer | |
| CylinderVolumeBounds | |
| VolumeConfig | VolumeConfig struct to understand the layer config |
| WrappingConfig | The WrappingSetup that is happening here |
| CylinderVolumeBuilder | |
| Config | |
| CylinderVolumeHelper | |
| Config | |
| DetectorElementBase | |
| DiscLayer | |
| Extent | |
| GenericApproachDescriptor | |
| GenericCuboidVolumeBounds | |
| BoundValues | This struct helps to symmetrize with the the other volume bounds classes |
| GeometryHierarchyMap | |
| GeometryIdentifier | |
| GeometryIdentifierHook | |
| GeometryObject | |
| ObjectSorterT | |
| DistanceSorterT | This will check on absolute distance |
| GeometryObjectSorterT | |
| GlueVolumesDescriptor | |
| IConfinedTrackingVolumeBuilder | This is an interface class for constructing TrackingVolumes whose are confined in a mother-TrackingVolume |
| ILayerArrayCreator | |
| ILayerBuilder | |
| ITrackingGeometryBuilder | |
| ITrackingVolumeArrayCreator | |
| ITrackingVolumeBuilder | |
| ITrackingVolumeHelper | |
| KDTreeTrackingGeometryBuilder | |
| Cache | Private construction cache |
| Config | Nested Configuration for this TrackingGeometryBuilder |
| Layer | |
| LayerArrayCreator | |
| Config | This struct stores the configuration of the tracking geometry |
| LayerCreator | |
| Config | |
| NavigationLayer | |
| PassiveLayerBuilder | |
| Config | |
| PlaneLayer | |
| Polyhedron | |
| ProtoLayer | |
| ProtoLayerHelper | |
| Config | |
| SurfaceArrayCreator | |
| Config | |
| ProtoAxis | |
| SurfaceBinningMatcher | |
| TrackingGeometry | |
| TrackingGeometryBuilder | |
| Config | |
| TrackingVolume | |
| TrackingVolumeArrayCreator | |
| Config | This struct stores the configuration of the tracking geometry |
| TrapezoidVolumeBounds | |
| Volume | |
| VolumeBounds | |
| ConstantBField | |
| Cache | |
| InterpolatedMagneticField | |
| InterpolatedBFieldMap | Interpolate magnetic field value from field values on a given grid |
| Cache | |
| Config | Config structure for the interpolated B field map |
| FieldCell | Struct representing smallest grid unit in magnetic field grid |
| MagneticFieldProvider | Base class for all magnetic field providers |
| NullBField | Null bfield which returns 0 always |
| Cache | |
| SolenoidBField | |
| Cache | |
| Config | Config struct for the SolenoidBfield |
| AccumulatedMaterialSlab | |
| AccumulatedSurfaceMaterial | |
| AccumulatedVolumeMaterial | |
| BinnedSurfaceMaterial | |
| HomogeneousSurfaceMaterial | |
| HomogeneousVolumeMaterial | |
| IMaterialDecorator | |
| MaterialMapper | Struct for mapping global 3D positions to material values |
| MaterialCell | Struct representing smallest grid unit in material grid |
| InterpolatedMaterialMap | Interpolate material classification values from material values on a given grid |
| Cache | Temporary storage of a certain cell to improve material access |
| ISurfaceMaterial | |
| IVolumeMaterial | Material associated with a Volume (homogeneous, binned, interpolated) |
| Material | |
| MaterialHit | The information to be writtern out per hit surface |
| MaterialCollector | A Material Collector struct |
| this_result | |
| ElementFraction | |
| MaterialComposition | |
| InteractionVolume | The Material interaction volume struct It acts as a switch between detctor and tracking volume as long as those co-exist alongside |
| MaterialInteraction | The Material interaction struct It records the surface and the passed material This is only necessary recorded when configured |
| RecordedMaterial | |
| MaterialSlab | |
| ProtoSurfaceMaterial | Proxy to SurfaceMaterial hand over BinUtility |
| ProtoVolumeMaterial | Proxy to VolumeMaterial hand over BinUtility |
| MaterialSurface | Selector for finding surface |
| MaterialVolume | Selector for finding volume |
| SurfaceMaterialMapper | SurfaceMaterialMapper |
| Config | |
| State | |
| VolumeMaterialMapper | VolumeMaterialMapper |
| BoundSurfaceSelector | Selector for finding surface |
| Config | |
| MaterialVolumeSelector | Selector for finding |
| State | |
| AtlasStepper | AtlasStepper implementation for the |
| State | Nested State struct for the local caching |
| ConstrainedStep | |
| CovarianceCache | |
| DenseStepperPropagatorOptions | |
| DirectNavigator | |
| State | |
| EigenStepper | Runge-Kutta-Nystroem stepper based on Eigen implementation for the following ODE: |
| State | State for track parameter propagation |
| MaterialInteractor | |
| WeightedComponentReducerLoop | Reducer struct for the Loop MultiEigenStepper which reduces the multicomponent state to simply by summing the weighted values |
| MaxMomentumReducerLoop | |
| MultiEigenStepperLoop | Stepper based on the EigenStepper, but handles Multi-Component Tracks (e.g., for the GSF). Internally, this only manages a vector of EigenStepper::States. This simplifies implementation, but has several drawbacks: |
| ComponentProxy | |
| ComponentProxyBase | |
| SinglePropState | |
| State | |
| Component | The struct that stores the individual components |
| MultiStepperSurfaceReached | This |
| NavigationOptions | Struct for the Navigation options that are forwarded to the geometry |
| Navigator | |
| Config | |
| State | |
| PropagatorResult | Simple class holding result of propagation call |
| PropagatorPlainOptions | Class holding the trivial options in propagator options |
| PropagatorOptions | Options for propagate() call |
| Propagator | Propagator for particles (optionally in a magnetic field) |
| result_type_helper | Helper struct determining the result's type |
| RiddersPropagator | This class performs the Ridders algorithm to estimate the propagation of the covariance to a certain point in space |
| Config | |
| result_type_helper | Helper struct determining the result's type |
| TargetOptions | TargetOptions struct for geometry interface |
| PathLimitReached | This is the condition that the pathLimit has been reached |
| SurfaceReached | |
| EndOfWorldReached | |
| StepperExtensionList | Container of extensions used in the stepper of the propagation. This struct allows a broadcast of function calls for each element in the list. The broadcasts occur for a certain function at each step in a specific order. The first function is an evaluater if an extension is or how many extensions are applicable for an upcoming step. The next functions called are the evaluations of the k_1 - k_4 or the RKN4 integration. The last function call in a step is the finalize() method. This method is an overloaded function (optionally propagates the covariance). Each method has the possibility to break the evaluation of a given step if an extension reports that something went wrong (e.g. a particle lost too much momentum during the step) |
| StraightLineStepper | Straight line stepper based on Surface intersection |
| State | |
| SurfaceSelector | Simple struct to select surfaces |
| SurfaceHit | The information to be writtern out per hit surface |
| SurfaceCollector | |
| this_result | |
| VolumeSelector | Simple struct to select volumes |
| VolumeHit | The information to be writtern out per hit volume |
| VolumeCollector | |
| this_result | |
| BinFinder | |
| BinnedSPGroupIterator | |
| BinnedSPGroup | |
| TripletCandidate | A description of a triplet candidate |
| CandidatesForMiddleSp | |
| FTF_SP | |
| TrigFTF_GNN_Node | |
| CompareByPhi | |
| TrigFTF_GNN_EtaBin | |
| TrigFTF_GNN_DataStorage | |
| TrigFTF_GNN_Edge | |
| CompareLevel | |
| TrigInDetSiLayer | |
| TrigFTF_GNN_Layer | |
| TrigFTF_GNN_Geometry | |
| IExperimentCuts | |
| InternalSeed | |
| InternalSpacePoint | |
| Neighbour | A class that helps in processing the neighbours, given a collection of middle space points The idea here is that in the seeding we look for compatible b-m and m-t doublets. One of the requirements is that the bottom/top space point is at a suitable distance (in radius) w.r.t. the middle space point. We know however that the space points in each bin are sorted in radius. That means we can use this sorting in order to reduce the number of space point to consider when looking for compatible doublets. The idea is to keep track of first space point that is in the allowed bin, by storing its position using an iterator itr This helps us since the lower possible buondary is given by the first middle space point (its radius minus the mad deltaR defined by the user). The subsequent middle space point will have a higher radius. That means that there is no point in looking at neighbour space point before itr, since we know they will be out of range |
| Seed | |
| SeedConfirmationRangeConfig | Parameters for seed confirmation |
| SeedFilterState | |
| SeedFilter | |
| SeedFilterConfig | |
| SeedFinder | |
| SeedingState | |
| SeedFinderConfig | |
| SeedFinderOptions | |
| GNN_TrigTracklet | |
| SeedFinderFTF | |
| SeedFinderFTFConfig | |
| SeedFinderOrthogonal | |
| SeedFinderOrthogonalConfig | |
| LinCircle | A partial description of a circle in u-v space |
| SpacePointGridConfig | |
| SpacePointGridOptions | |
| SpacePointGridCreator | |
| SpacePointBuilder | |
| SpacePointBuilderConfig | |
| SpacePointBuilderOptions | |
| StripPairOptions | |
| AnnulusBounds | Class that implements a (potentially asymmetric) bounds with difference between surface bound center and surface coordinate center |
| BoundaryCheck | |
| ConeBounds | |
| ConeSurface | |
| ConvexPolygonBoundsBase | Base class for convex polygon bounds |
| ConvexPolygonBounds | |
| ConvexPolygonBounds< PolygonDynamic > | |
| CylinderBounds | |
| CylinderSurface | |
| DiamondBounds | |
| DiscBounds | |
| DiscTrapezoidBounds | |
| EllipseBounds | |
| InfiniteBounds | |
| LineBounds | |
| LineSurface | |
| PerigeeSurface | |
| PlanarBounds | |
| PlaneSurface | |
| RadialBounds | |
| RectangleBounds | |
| StrawSurface | |
| Surface | Abstract Base Class for tracking surfaces |
| SurfaceArray | Provides Surface binning in N dimensions |
| ISurfaceGridLookup | Base interface for all surface lookups |
| SingleElementLookup | Lookup implementation which wraps one element and always returns this element when lookup is called |
| SurfaceGridLookup | Lookup helper which encapsulates a Grid |
| SurfaceBounds | |
| TrapezoidBounds | |
| CombinatorialKalmanFilterTipState | |
| CombinatorialKalmanFilterExtensions | Extension struct which holds the delegates to customize the CKF behavior |
| CombinatorialKalmanFilterOptions | |
| CombinatorialKalmanFilterResult | |
| CombinatorialKalmanFilter | |
| Aborter | |
| Actor | Propagator Actor plugin for the CombinatorialKalmanFilter |
| FasTrackConnection | |
| FasTrackConnector | |
| LayerGroup | |
| MeasurementSelectorCuts | |
| MeasurementSelector | Measurement selection struct selecting those measurements compatible with the given track parameter against provided criteria on one surface |
| RoiDescriptor | |
| TrackSelector | |
| Config | |
| EtaBinnedConfig | |
| BetheHeitlerApproxSingleCmp | |
| AtlasBetheHeitlerApprox | |
| PolyData | |
| GainMatrixSmoother | |
| GainMatrixUpdater | Kalman update step using the gain matrix formalism |
| InternalTrackState | |
| GaussianSumFitter | |
| GsfComponent | |
| GsfExtensions | The extensions needed for the GSF |
| GsfOptions | |
| KalmanFitterExtensions | Extension struct which holds delegates to customise the KF behavior |
| KalmanFitterOptions | |
| KalmanFitterResult | |
| KalmanFitter | |
| Aborter | |
| Actor | Propagator Actor plugin for the KalmanFilter |
| ExpSafeLimit | |
| ExpSafeLimit< double > | |
| ExpSafeLimit< float > | |
| AnnealingUtility | Implements a deterministic thermodynamic annealing scheme Ref. (1): CERN-THESIS-2010-027 |
| Config | The configuration struct |
| State | The annealing state Resetting the state is done by just creating a new instance |
| AnyBaseAll | |
| AnyBase | Small opaque cache type which uses small buffer optimization |
| BinnedArray | |
| BinnedArrayXD | |
| BinningData | |
| BinUtility | |
| AxisAlignedBoundingBox | |
| NamedType | |
| SizeParameter | |
| Delegate< R(Args...), H, O > | |
| OwningDelegate< R(Args...), H > | Alias for an owning delegate |
| ContextType | |
| FiniteStateMachine | |
| Terminated | |
| Frustum | |
| IAxis | |
| Identity | Function object which maps a value to itself by perfect forwarding This is a backport of C++20's std::identity |
| Intersection | |
| ObjectIntersection | Class extensions to return also the object and a representation |
| ObjectMultiIntersection | Class extensions to return also the object and a representation |
| KDTree | A general k-d tree with fast range search |
| KDTreeNode | An abstract class containing common features of k-d tree node types |
| Logger | Class for printing debug output |
| MultiIndex | |
| Range1D | A one-dimensional range between two points |
| RangeXD | An orthogonal range in an arbitrary number of dimensions |
| Ray | |
| Result | |
| Result< void, E > | |
| SpacePointParameters | Storage container for variables related to the calculation of space points |
| SpacePointUtility | |
| AssertionFailureException | Exception type for assertion failures This class captures the information available to the throw_assert macro |
| StreamFormatter | Class which allows to use the << operator to assemble a string |
| AdaptiveGridDensityVertexFinder | Vertex finder that makes use of a track density grid. Each single track is modelled as a 2-dim Gaussian distribution grid in the d0-z0 plane, but only the overlap with the z-axis (i.e. a 1-dim density vector) needs to be calculated. All track contributions along the beam axis (main density vector) are superimposed and the z-value of the bin with the highest track density is returned as a vertex candidate. Unlike the GridDensityVertexFinder, this seeder implements an adaptive version where the density grid grows bigger with added tracks |
| Config | The Config struct |
| State | The State struct |
| AdaptiveGridTrackDensity | Implements a 1D (no time seeding) / 2D (time seeding) grid that is filled with track densities. Each track is modelled by a 2D / 3D Gaussian distribution in the d0-z0 / d0-z0-t0 plane, which is evaluated at d0=0. Therefore, each track effectively lives in 1D / 2D. The position of the highest track density (of either a single bin or the sum of a certain region) can be determined. Single tracks can be cached and removed from the overall density. Unlike in the GaussianGridTrackDensity, the overall density map grows adaptively when tracks densities are added to the grid |
| Config | The configuration struct |
| AdaptiveMultiVertexFinder | Implements an iterative vertex finder |
| Config | Configuration struct |
| NeedsRemovedTracks | |
| NeedsRemovedTracks< T, decltype((void) T::tracksToRemove, 0)> | |
| State | State struct for fulfilling interface |
| AdaptiveMultiVertexFitter | Implements an adaptive multi-vertex fitter as described in detail in Section 5.3.5 in: Ref. (1): CERN-THESIS-2010-027, Author: Piacquadio, Giacinto: Identification of b-jets and investigation of the discovery potential of a Higgs boson in the WH−−>lvbb¯ channel with the ATLAS experiment |
| Config | |
| State | The fitter state |
| VertexInfo | Helper struct for storing vertex related information |
| DummyVertexFitter | Dummy vertex fitter class, only to be used for ensuring interfaces where a vertex fitter type is required but no fitter is actually needed |
| FsmwMode1dFinder | |
| FullBilloirVertexFitter | Vertex fitter class implementing the Billoir vertex fitter |
| Config | |
| State | |
| GaussianGridTrackDensity | Implements a 1-dim density grid to be filled with track Gaussian distributions. Each single track is modelled as a 2(!)-dim Gaussian distribution grid in the d0-z0 plane, but only the overlap with the z-axis (i.e. a 1-dim density vector) needs to be calculated. The position of the highest track density (of either a single bin or the sum of a certain region) can be determined. Single tracks can be cached and removed from the overall density |
| Config | The configuration struct |
| GaussianTrackDensity | 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) |
| Config | The Config struct |
| GaussianTrackDensityStore | |
| State | The State struct |
| TrackEntry | Struct to store information for a single track |
| GridDensityVertexFinder | Vertex finder that makes use of a track density grid. Each single track is modelled as a 2(!)-dim Gaussian distribution grid in the d0-z0 plane, but only the overlap with the z-axis (i.e. a 1-dim density vector) needs to be calculated. All track contributions along the beam axis (main density grid) a superimposed and the z-value of the bin with the highest track density is returned as a vertex candidate |
| Config | The Config struct |
| State | The State struct |
| HelicalTrackLinearizer | |
| Config | Configuration struct |
| State | State struct |
| ImpactParametersAndSigma | |
| ImpactPointEstimator | 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 |
| Config | |
| State | State struct |
| IterativeVertexFinder | Implements an iterative vertex finder |
| Config | Configuration struct |
| State | State struct |
| LinearizedTrack | |
| NumericalTrackLinearizer | |
| Config | Configuration struct |
| State | State struct |
| SingleSeedVertexFinder | Implements the vertex finder based on the track seeds 0. Assumes there is only 1 vertex and that it has a high multiplicity |
| Config | Configuration struct |
| SortedSpacepoints | Struct to store sorted spacepoints for each layer (near, middle, and far), for each slice of phi, and for each slice of z |
| Triplet | Struct to store spacepoint combinations from near, middle, and far parts of the detector. Also stores straight line fit through the spacepoints in case minimalizeWRT=="rays", so it's not fitted twice |
| TrackAtVertex | Defines a track at vertex object |
| TrackDensityVertexFinder | Finds a vertex seed based on the maximum of a track density function. Each track is modelled as a 2d density function around its d0/z0 perigee parameter values. The z seed position is then found as the position of the maximum of all summed track density functions |
| Config | The Config struct |
| State | State struct for fulfilling interface |
| Vertex | Class for storing vertex objects |
| VertexingOptions | Vertex Finder Options |
| ZScanVertexFinder | Implements a vertex finder based on the mode of z0 values: |
| Config | Configuration struct |
| State | State struct for fulfilling interface |
| EventDataView3D | |
| GeometryView3D | |
| IVisualization3D | |
| ObjVisualization3D | |
| PlyVisualization3D | Helper to write out PlyVisualization3D visualization format |
| ViewConfig | Struct to concentrate all visualization configurations in order to harmonize visualization interfaces |
| MappingMaterialDecorator | Material decorator using a map as input |
| MaterialWiper | |
| AutodiffExtensionWrapper | Default RKN4 evaluator for autodiff |
| FakePropState | |
| FakeStepper | |
| FakeStepperState | |
| SeedFinder< external_spacepoint_t, Acts::Cuda > | |
| CpuMatrix | |
| CpuScalar | |
| CpuVector | |
| DD4hepDetectorElement | DetectorElement class implementation for DD4hep geometry |
| DD4hepDetectorSurfaceFactory | |
| Cache | Nested cache that records the conversion status |
| Options | Nested options struct to steer the conversion |
| DD4hepLayerBuilder | Build layers of one cylinder-endcap setup from DD4hep input |
| Config | |
| DD4hepVolumeBuilder | Build confined TrackingVolumes of one cylinder setup from DD4hep input |
| Config | |
| BoostTrackBuilding | |
| CugraphTrackBuilding | |
| ExaTrkXTiming | |
| ExaTrkXHook | |
| ExaTrkXPipeline | |
| ExaTrkXTime | Collection of timing information of the Exa.TrkX algorithm |
| ExaTrkXTimer | |
| OnnxEdgeClassifier | |
| Config | |
| OnnxMetricLearning | |
| Config | |
| GraphConstructionBase | |
| EdgeClassificationBase | |
| TrackBuildingBase | |
| TorchEdgeClassifier | |
| Config | |
| TorchMetricLearning | |
| Config | |
| TorchTruthGraphMetricsHook | |
| FpeMonitor | |
| Buffer | |
| GlobalState | |
| Result | |
| FpeInfo | |
| Geant4AlgebraConverter | |
| Geant4ShapeConverter | |
| Geant4PhysicalVolumeConverter | |
| Geant4MaterialConverter | |
| Geant4VolumeConverter | |
| Geant4DetectorElement | |
| Geant4DetectorSurfaceFactory | |
| Cache | Nested cache that records the conversion status |
| Config | |
| Options | Nested option struct that allows per call changeable configuration |
| IGeant4PhysicalVolumeSelector | Interface class for selectors from physical volumes |
| IdentifiedDetectorElement | The identified detector element |
| GeometryHierarchyMapJsonConverter | |
| missing_specialization | |
| jsonKey | Store in a single place the different key used for the material mapping |
| ITrackingGeometryJsonDecorator | Helper class to add extra information to surface or volume json objects |
| IVolumeMaterialJsonDecorator | Helper class to add extra information to surface or volume json objects |
| JsonMaterialDecorator | Material decorator from Json format |
| MaterialMapJsonConverter | Read the material from Json |
| Config | |
| AmbiguityTrackClassifier | Onnx model implementation for track scoring and selection |
| MLTrackClassifier | |
| OnnxRuntimeBase | |
| IsReadOnlyTrackContainer< MutablePodioTrackContainer > | |
| IsReadOnlyTrackContainer< ConstPodioTrackContainer > | |
| PodioTrackContainerBase | |
| MutablePodioTrackContainer | |
| ConstPodioTrackContainer | |
| PodioTrackStateContainerBase | |
| IsReadOnlyMultiTrajectory< ConstPodioTrackStateContainer > | |
| ConstPodioTrackStateContainer | |
| IsReadOnlyMultiTrajectory< MutablePodioTrackStateContainer > | |
| MutablePodioTrackStateContainer | |
| ITGeoDetectorElementSplitter | ITGeoElementSplitter |
| ITGeoIdentifierProvider | ITGeoIdentierProvider |
| TGeoCylinderDiscSplitter | TGeoCylinderDiscSplitter |
| Config | Nested configuration struct |
| TGeoDetectorElement | |
| TGeoLayerBuilder | |
| Config | Nested configuration struct for steering of the layer builder |
| LayerConfig | Helper config structs for volume parsing |
| TGeoMaterialConverter | |
| Options | Nested options struct to steer the conversion process |
| TGeoParser | TGeoParser is a helper struct that walks recursively through a TGeometry and selects by string comparison the TGeoNodes that match the criteria |
| Options | Nested configuration struct |
| SelectedNode | |
| State | Nested state struct |
| TGeoPrimitivesHelper | |
| TGeoSurfaceConverter | Helper struct to convert TGeoShapes into Surface or Volume Bounds |
| LayerStub | |
| TestAxis | |
| MultiGrid1D | |
| MultiGrid2D | |
| ATLASBottomBinFinder | |
| ATLASCuts | |
| ATLASTopBinFinder | |
| CovarianceTool | |
| SurfaceBoundsStub | Class to implement pure virtual method of SurfaceBounds for testing only |
| SurfaceStub | Surface derived class stub |
| MockTrack | Mock track object with minimal methods implemented for compilation |
| ActsAlignment | |
| detail | |
| AlignmentErrorCategory | |
| TrackAlignmentState | Struct to store info needed for track-based alignment |
| AlignmentOptions | Options for align() call |
| AlignmentResult | Alignment result struct |
| Alignment | KalmanFitter-based alignment implementation |
| ActsExamples | |
| Contextual | |
| AlignedDetector | |
| Config | |
| AlignmentDecorator | A mockup service that rotates the modules in a simple tracking geometry |
| Config | Nested configuration struct |
| ExternalAlignmentDecorator | A mockup service that rotates the modules in a simple tracking geometry |
| Config | Nested configuration struct |
| ExternallyAlignedDetectorElement | |
| AlignmentStore | |
| ContextType | |
| InternalAlignmentDecorator | A mockup service that rotates the modules in a simple tracking geometry |
| Config | Nested configuration struct |
| IovStatus | |
| InternallyAlignedDetectorElement | |
| ContextType | |
| DD4hep | |
| DD4hepDetector | |
| DD4hepDetectorHelper | |
| DD4hepGeometryService | Service creating geometries from dd4hep input |
| Config | |
| DefaultHoughFunctions | |
| detail | |
| NuclearInteractionParametrisation | |
| EventFraction | |
| FatrasSimulation | |
| GeometryIdGetter | |
| CompareGeometryId | |
| CompareParticleId | |
| PrimaryVertexIdGetter | |
| SecondaryVertexIdGetter | |
| Digitization | |
| Exact | |
| Gauss | |
| GaussTrunc | |
| GaussClipped | |
| Uniform | |
| Digital | |
| EDM4hepUtil | |
| Geant4 | |
| HepMC3 | |
| EventAction | |
| PrimaryGeneratorAction | |
| RunAction | |
| SteppingAction | Collects the particles history |
| Geant4Detector | |
| Config | Nested configuration struct |
| Generic | |
| GenericDetectorElement | |
| LayerBuilderT | |
| Config | |
| ProtoLayerSurfaces | |
| ProtoLayerCreatorT | |
| Config | |
| Geometry | |
| HepMC3Event | |
| HepMC3Particle | |
| HepMC3Vertex | |
| JsonSurfacesReader | |
| Options | Options specification for surface reading |
| Options | |
| detail | |
| Interval | |
| Reals | |
| VariableReals | |
| Integers | |
| VariableIntegers | |
| PlotHelpers | |
| Binning | Nested binning struct for booking plots |
| Simulation | |
| tbbWrap | |
| task_arena | |
| parallel_for | Small wrapper for tbb::parallel_for |
| queuing_mutex | Small wrapper for tbb::queuing_mutex and tbb::queuing_mutex::scoped_lock |
| scoped_lock | |
| Telescope | |
| TelescopeG4DetectorConstruction | |
| TelescopeG4DetectorConstructionFactory | |
| TelescopeDetector | |
| Config | |
| TelescopeDetectorElement | |
| ContextType | |
| AlignmentAlgorithm | |
| AlignmentFunction | |
| Config | |
| GreedyAmbiguityResolutionAlgorithm | |
| Config | |
| DigitizationAlgorithm | Algorithm that turns simulated hits into measurements by truth smearing |
| CombinedDigitizer | |
| GeometricConfig | |
| DigiComponentsConfig | |
| DigitizationConfig | |
| DigitizationConfigurator | |
| DigitizedParameters | |
| ModuleValue | |
| ModuleClusters | |
| PlanarSteppingAlgorithm | Create planar clusters from simulation hits |
| Config | |
| Digitizable | |
| ParameterSmearingConfig | |
| FatrasSimulation | Fast track simulation using the Acts propagation and navigation |
| Config | |
| DDG4DetectorConstruction | Construct the Geant4 detector from a DD4hep description |
| DDG4DetectorConstructionFactory | |
| DetectorConstructionFactory | |
| EventStore | Common event store for all Geant4 related sub algorithms |
| GdmlDetectorConstruction | Construct the Geant4 detector from a Gdml file |
| GdmlDetectorConstructionFactory | |
| Geant4Handle | |
| Geant4Manager | Allows easy instantiation of a Geant4Handle object |
| Geant4SimulationBase | Abstracts common Geant4 Acts algorithm behaviour |
| Config | Nested configuration struct for the Geant4 simulation |
| Geant4Simulation | Algorithm to run Geant4 simulation in the ActsExamples framework |
| Config | |
| Geant4MaterialRecording | |
| Config | |
| MagneticFieldWrapper | |
| Config | Configuration of the Magnetic Field Action |
| MaterialPhysicsList | Stripped down physics list to Geantinos and only Transport This speeds up the initialization of the MaterialRecording job |
| MaterialSteppingAction | Collects the RecordedMaterialSlab entities |
| Config | Nested configuration struct |
| ParticleKillAction | |
| Config | Configuration of the Stepping action |
| ParticleTrackingAction | |
| Config | |
| PhysicsListFactory | A factory around G4VUserPhysicsList which allows on demand instantiation |
| PhysicsListFactoryFunction | Convenience implementation of PhysicsListFactory from std::function |
| SensitiveSteppingAction | |
| Config | Configuration of the Stepping action |
| SensitiveSurfaceMapper | |
| Config | Configuration struct for the surface mapper |
| SimParticleTranslation | |
| Config | |
| SteppingActionList | |
| Config | |
| EventRecording | |
| Config | |
| EventGenerator | |
| Config | |
| Generator | Combined struct which contains all generator components |
| MultiplicityGenerator | Generator interface for event multiplicity of vertices |
| ParticlesGenerator | Generator interface particles for a vertex |
| VertexGenerator | Generator interface for a vertex position |
| FixedMultiplicityGenerator | |
| PoissonMultiplicityGenerator | |
| ParametricParticleGenerator | |
| Config | |
| FixedVertexGenerator | |
| GaussianVertexGenerator | |
| Pythia8Generator | |
| Config | |
| VolumeAssociationTest | |
| Config | Nested Configuration struct |
| HepMCProcessExtractor | This class extracts a certain process from a HepMC event record |
| Config | |
| IMaterialWriter | |
| MaterialMapping | Initiates and executes material mapping |
| Config | |
| HitsPrinter | Print hits within some geometric region-of-interest |
| Config | |
| ParticlesPrinter | Print all particles |
| Config | |
| TrackParametersPrinter | Print track parameters |
| Config | |
| PropagationAlgorithm | This test algorithm performs test propagation within the Acts::Propagator |
| Config | |
| PropagatorInterface | Propagator wrapper |
| ConcretePropagator | Concrete instance of a propagator |
| HoughMeasurementStruct | |
| HoughTransformSeeder | Construct track seeds from space points |
| Config | |
| SeedingAlgorithm | Construct track seeds from space points |
| Config | |
| SeedingFTFAlgorithm | |
| Config | |
| SeedingOrthogonalAlgorithm | Construct track seeds from space points |
| Config | |
| SpacePointMaker | |
| Config | |
| TrackFindingAlgorithm | |
| Config | |
| TrackFinderFunction | |
| TrackParamsEstimationAlgorithm | |
| Config | |
| PrototracksToParameters | |
| Config | |
| TrackFindingAlgorithmExaTrkX | |
| Config | |
| TrackFindingFromPrototrackAlgorithm | |
| Config | |
| AmbiguityResolutionML | |
| AmbiguityResolutionMLAlgorithm | |
| Config | |
| AmbiguityResolutionMLDBScanAlgorithm | |
| Config | |
| RefittingAlgorithm | |
| Config | |
| RefittingCalibrator | |
| RefittingSourceLink | |
| SurfaceSortingAlgorithm | |
| Config | |
| TrackFitterFunction | |
| GeneralFitterOptions | |
| TrackFittingAlgorithm | |
| Config | |
| ParticleSelector | Select particles by applying some selection cuts |
| Config | |
| ParticleSmearing | |
| Config | |
| TrackModifier | Select tracks by applying some selection cuts |
| Config | |
| TrackParameterSelector | Select tracks by applying some selection cuts |
| Config | |
| TruthSeedingAlgorithm | Construct track seeds from particles |
| Config | |
| TruthSeedSelector | |
| Config | |
| TruthTrackFinder | |
| Config | |
| TruthVertexFinder | Group particles into proto vertices using truth information |
| Config | |
| MeasurementMapSelector | |
| Config | |
| PrototracksToSeeds | |
| Config | |
| SeedsToPrototracks | |
| Config | |
| TrackSelectorAlgorithm | Select tracks by applying some selection cuts |
| Config | |
| TracksToTrajectories | |
| Config | |
| TrajectoriesToPrototracks | |
| Config | |
| AdaptiveMultiVertexFinderAlgorithm | |
| Config | |
| IterativeVertexFinderAlgorithm | |
| Config | |
| SingleSeedVertexFinderAlgorithm | |
| Config | |
| TutorialVertexFinderAlgorithm | |
| Config | |
| VertexFitterAlgorithm | |
| Config | |
| ScalableBFieldContext | The ScalableBField-specific magnetic field context |
| ScalableBField | A constant magnetic field that is scaled depending on the event context |
| Cache | |
| ScalableBFieldService | |
| Config | |
| MockupSectorBuilder | |
| ChamberConfig | Nested configuration struct for chamber |
| Config | Nested configuration struct |
| TGeoDetector | |
| Config | |
| LayerTriplet | |
| Volume | |
| TGeoITkModuleSplitter | TGeoITkModuleSplitter |
| Config | Nested configuration struct |
| Cluster | Simple struct holding cluster information |
| ExtractedSimulationProcess | |
| GeometryIdMultisetAccessor | |
| IndexSourceLink | |
| SurfaceAccessor | |
| IndexSourceLinkAccessor | |
| MeasurementCalibrator | Abstract base class for measurement-based calibration |
| PassThroughCalibrator | |
| MeasurementCalibratorAdapter | |
| ScalingCalibrator | |
| ConstantTuple | |
| MapTuple | |
| SimSpacePoint | Space point representation of a measurement suitable for track seeding |
| SimVertex | A simultated vertex e.g. from a physics process |
| Trajectories | |
| AlgorithmContext | Aggregated information to run one algorithm over one event |
| DataHandleBase | |
| WriteDataHandle | |
| ReadDataHandle | |
| IAlgorithm | |
| IContextDecorator | Decorator for the AlgorithmContext with additional event specific information |
| IReader | |
| IWriter | |
| RandomNumbers | < Mersenne Twister |
| Config | |
| SequenceElement | |
| FpeFailure | Custom exception class so FPE failures can be caught |
| SequenceConfigurationException | |
| Sequencer | |
| Config | |
| FpeMask | |
| SequenceElementWithFpeResult | |
| WhiteBoard | |
| HolderT | |
| IHolder | |
| WriterT | |
| GroupBy | |
| GroupIterator | Iterator type representing a group of elements |
| Range | |
| DuplicationPlotTool | |
| Config | The nested configuration struct |
| DuplicationPlotCache | Nested Cache struct |
| EffPlotTool | |
| Config | The nested configuration struct |
| EffPlotCache | Nested Cache struct |
| FakeRatePlotTool | |
| Config | The nested configuration struct |
| FakeRatePlotCache | Nested Cache struct |
| ResPlotTool | |
| Config | Nested configuration struct |
| ResPlotCache | Nested Cache struct |
| ParticleHitCount | Associate a particle to its hit count within a proto track |
| TrackSummaryPlotTool | |
| Config | The nested configuration struct |
| TrackSummaryPlotCache | Nested Cache struct |
| NeuralCalibrator | |
| CsvBFieldWriter | Writer for B-fields that outputs field data in CSV format |
| Config | Configuration type for the magnetic field writer |
| CsvMeasurementReader | |
| Config | |
| CsvMeasurementWriter | |
| Config | |
| CsvMultiTrajectoryWriter | |
| Config | |
| trackInfo | Struct for brief trajectory summary info |
| CsvParticleReader | |
| Config | |
| CsvParticleWriter | |
| Config | |
| CsvPlanarClusterReader | |
| Config | |
| CsvPlanarClusterWriter | |
| Config | |
| CsvProtoTrackWriter | |
| Config | |
| CsvSimHitReader | |
| Config | |
| CsvSimHitWriter | |
| Config | |
| CsvSpacePointReader | |
| Config | |
| CsvSpacepointWriter | |
| Config | |
| CsvTrackingGeometryWriter | |
| Config | |
| CsvTrackParameterReader | |
| Config | |
| CsvTrackParameterWriter | |
| Config | |
| ParticleData | |
| SimHitData | |
| TruthHitData | |
| HitData | |
| MeasurementSimHitLink | |
| MeasurementData | |
| CellData | |
| CellDataLegacy | |
| SurfaceData | |
| LayerVolumeData | |
| SpacePointData | |
| SurfaceGridData | |
| SpacepointData | |
| TrackParameterData | |
| ProtoTrackData | |
| EDM4hepMeasurementReader | |
| Config | |
| EDM4hepMeasurementWriter | |
| Config | |
| EDM4hepMultiTrajectoryWriter | |
| Config | |
| EDM4hepParticleReader | |
| Config | |
| EDM4hepParticleWriter | |
| Config | |
| EDM4hepSimHitReader | |
| Config | |
| EDM4hepSimHitWriter | |
| Config | |
| EDM4hepTrackReader | |
| Config | |
| EDM4hepTrackWriter | |
| Config | |
| HepMC3AsciiReader | HepMC3 event reader |
| Config | |
| HepMC3AsciiWriter | HepMC3 event writer |
| Config | |
| JsonMaterialWriter | |
| Config | |
| JsonSpacePointWriter | |
| Config | |
| JsonSurfacesWriter | |
| Config | |
| RootNuclearInteractionParametersWriter | |
| Config | |
| ObjPropagationStepsWriter | |
| Config | |
| ObjSpacePointWriter | |
| Config | |
| ObjTrackingGeometryWriter | |
| Config | |
| CKFPerformanceWriter | |
| Config | |
| SeedingPerformanceWriter | |
| Config | |
| TrackFinderPerformanceWriter | |
| Config | |
| Impl | |
| TrackFitterPerformanceWriter | |
| Config | |
| VertexPerformanceWriter | |
| Config | |
| RootAthenaNTupleReader | |
| BranchPointerWrapper | |
| Config | The nested configuration struct |
| RootBFieldWriter | |
| Config | |
| RootMaterialDecorator | Read the collection of SurfaceMaterial & VolumeMaterial |
| Config | |
| RootMaterialTrackReader | Reads in MaterialTrack information from a root file and fills it into a format to be understood by the MaterialMapping algorithm |
| Config | The nested configuration struct |
| RootMaterialTrackWriter | Writes out MaterialTrack collections from a root file |
| Config | |
| RootMaterialWriter | Material decorator from Root format |
| Config | |
| RootMeasurementWriter | |
| Config | |
| DigitizationTree | |
| RootParticleReader | Reads in Particles information from a root file |
| Config | The nested configuration struct |
| RootParticleWriter | |
| Config | |
| RootPlanarClusterWriter | |
| Config | |
| RootPropagationStepsWriter | |
| Config | |
| RootSimHitReader | |
| Config | The nested configuration struct |
| RootSimHitWriter | |
| Config | |
| RootSpacepointWriter | |
| Config | |
| RootTrackParameterWriter | |
| Config | |
| RootTrajectoryStatesWriter | |
| Config | |
| RootTrajectorySummaryReader | Reads in TrackParameter information from a root file and fills it into a Acts::BoundTrackParameter format |
| Config | The nested configuration struct |
| RootTrajectorySummaryWriter | |
| Config | |
| AccessorXYZ | |
| AccessorPositionXYZ | |
| SvgPointWriter | |
| Config | |
| SvgTrackingGeometryWriter | |
| Config | |
| AlignedDetectorWithOptions | |
| GenericDetectorWithOptions | |
| IBaseDetector | |
| TelescopeDetectorWithOptions | |
| TGeoDetectorWithOptions | |
| DD4hepDetectorWithOptions | |
| HelloData | An example data object to be shared via the event store |
| HelloLoggerAlgorithm | A simple algorithm that just prints hello world |
| HelloRandomAlgorithm | An example algorithm that uses the random number generator to generate data |
| Config | |
| HelloWhiteBoardAlgorithm | Example algorithm that reads/writes data from/to the event store |
| Config | |
| ActsFatras | |
| Casts | |
| Vrho | Retrieve the transverse absolute distance of the position to the origin |
| Vz | Retrieve the longitudinal distance of the position to the origin |
| AbsVz | Retrieve the longitudinal absolute distance of the position to the origin |
| Eta | Retrieve the direction pseudo-rapidity |
| AbsEta | Retrieve the direction absolute pseudo-rapidity |
| Pt | Retrieve the transverse momentum |
| P | Retrieve the absolute momentum |
| E | Retrieve the total energy |
| detail | |
| SimulationActor | |
| ParticleNotAlive | Abort if the particle was killed during a previous interaction |
| TupleIndexOf< T, std::tuple< T, Types...> > | |
| TupleIndexOf< T, std::tuple< U, Types...> > | |
| TupleFilterImpl | |
| TupleFilterImpl< predicate_t, tuple_t, 0u, kIndices...> | |
| IsPointLikeProcess | |
| MockUniformRandomBitGenerator | |
| IsContinuousProcess | |
| GaussianMixture | Generate scattering angles using a Gaussian mixture model |
| GeneralMixture | |
| Highland | |
| ScatteringImpl | |
| NuclearInteractionParameters | Data storage of the parametrized nuclear interaction |
| ParametersWithFixedMultiplicity | Nested struct for the storage of the kinematic parametrisations for a given final state multiplicity |
| CombineSelectors | Combine multiple selectors with a configurable combine function |
| DummyDetectorConstruction | Construct a dummy Geant4 detector |
| Geant4Decay | Handle particle decays using the Geant4 decay models |
| PDGtoG4Converter | This class converts a PDG ID into a corresponding Geant4 particle |
| Channelizer | |
| ChannelSegment | Nested struct for representing channel steps |
| ChannelStep | Nested struct for stepping from one channel to the next |
| Channel | |
| Cluster | |
| PlanarSurfaceDrift | |
| PlanarSurfaceMask | A brief struct that allows to apply a surface bound mask |
| BoundParametersSmearer | |
| FreeParametersSmearer | |
| Barcode | |
| Hit | |
| Particle | |
| ContinuousProcess | |
| InteractionList | |
| Selection | Point-like interaction selection |
| SingleParticleSimulation | |
| FailedParticle | A particle that failed to simulate |
| Simulation | |
| SimulationResult | |
| NoDecay | Decay module that treats all particles as stable |
| BetheBloch | |
| BetheHeitler | |
| PhotonConversion | |
| NuclearInteraction | |
| EveryParticle | No-op particle selector that selects all particles |
| NeutralSelector | Select neutral particles |
| ChargedSelector | Select all charged particles |
| PositiveSelector | Select positively charged particles |
| NegativeSelector | Select negatively charged particles |
| PdgSelector | |
| AbsPdgSelector | Select particles and antiparticles of one specific type |
| PdgExcluder | |
| AbsPdgExcluder | Select all particles except for (anti-)particles of one specific type |
| Min | Select all objects with an extracted value equal or larger than the cut |
| Max | Select all objects with an extracted value below the cut |
| Range | |
| NoSurface | Do not select any surface, ever |
| EverySurface | Select every surface |
| LandauDistribution | |
| param_type | Parameter struct that contains all distribution parameters |
| RectangleRandom | Generate ranom numbers within the regular, centric Rectangle |
| TrapezoidRandom | Create Random variables inside a regular Trapezoid |
| DiscRandom | Generate ranom numbers within disc ring |
| AnnulusRandom | Generate random numbers within an Annulus object |
| DigitizationCsvOutput | Helper to write out Digitization tesbed into csv files |
| PlanarSurfaceTestBeds | Helper struct to create a testbed for Digitization steps |
| ACTSGEOM | |
| ActsPodioEdm | |
| ActsTests | |
| PropagationDatasets | |
| add_histos | |
| add_histos_bX | |
| adl_test | |
| AjParameters | |
| AlignmentDefs | |
| ambiguity_solver_full_chain | |
| ambiguity_solver_network | |
| DuplicateClassifier | |
| Normalise | |
| ambiguity_solver_perf | |
| at | |
| autodiff | |
| detail | |
| bar | |
| MixedUpTestCaseTest | |
| MixedUpTestCaseWithSameTestNameTest | |
| bbc_onlmon | |
| BbcDefs | |
| BbcReturnCodes | |
| bfield_writing | |
| BJetDCA | |
| BlackHoleGeometry | |
| boost | |
| detail | |
| static_cast_tag | |
| const_cast_tag | |
| dynamic_cast_tag | |
| polymorphic_cast_tag | |
| shared_ptr_traits | |
| shared_ptr_traits< void > | |
| shared_ptr_traits< void const > | |
| shared_ptr_traits< void volatile > | |
| shared_ptr_traits< void const volatile > | |
| sp_enable_if_auto_ptr | |
| sp_enable_if_auto_ptr< std::auto_ptr< T >, R > | |
| filesystem | |
| math | |
| program_options | |
| array | |
| array< T, 0 > | |
| shared_ptr | |
| c10 | |
| CaloTowerDefs | |
| CDB | |
| centProxy | |
| check_clang_tidy | |
| check_end_of_file | |
| check_fpe_masks | |
| check_include_guards | |
| check_license | |
| bcolors | |
| CommitInfo | |
| check_smearing_config | |
| ckf | |
| CKF_timing_vs_mu | |
| ckf_tracks | |
| cl | Forward declaration of incomplete type cl::sycl::queue |
| detail | |
| GetInfoHelper | |
| GetInfoHelper< Func, VECTOR_CLASS< T > > | |
| GetInfoHelper< Func, VECTOR_CLASS< char * > > | |
| GetInfoHelper< Func, STRING_CLASS > | |
| param_traits | |
| GetInfoFunctor0 | |
| GetInfoFunctor1 | |
| ReferenceHandler | |
| ReferenceHandler< cl_device_id > | |
| ReferenceHandler< cl_platform_id > | |
| ReferenceHandler< cl_context > | |
| ReferenceHandler< cl_command_queue > | |
| ReferenceHandler< cl_mem > | |
| ReferenceHandler< cl_sampler > | |
| ReferenceHandler< cl_program > | |
| ReferenceHandler< cl_kernel > | |
| ReferenceHandler< cl_event > | |
| Wrapper | |
| KernelArgumentHandler | |
| KernelArgumentHandler< LocalSpaceArg > | |
| sycl | |
| string | Simple string class, that provides a limited subset of std::string functionality but avoids many of the issues that come with that class |
| vector | Fixed sized vector implementation that mirroring std::vector functionality |
| iterator | Iterator class for vectors |
| size_t | Size_t class used to interface between C++ and OpenCL C calls that require arrays of size_t values, who's size is known statically |
| ImageFormat | ImageFormat interface fro cl_image_format |
| Device | Device interface for cl_device_id |
| Platform | Platform interface |
| Context | |
| Event | Event interface for cl_event |
| Memory | Memory interface for cl_mem |
| Buffer | Memory buffer interface |
| BufferGL | Memory buffer interface for GL interop |
| BufferRenderGL | Memory buffer interface for GL interop with renderbuffer |
| Image | Base class interface for all images |
| Image2D | Image interface for 2D images |
| Image2DGL | 2D image interface for GL interop |
| Image3D | Image interface for 3D images |
| Image3DGL | |
| Sampler | Sampler interface for cl_sampler |
| NDRange | NDRange interface |
| LocalSpaceArg | Local address raper for use with Kernel::setArg |
| Kernel | Kernel interface that implements cl_kernel |
| Program | Program interface that implements cl_program |
| CommandQueue | CommandQueue interface for cl_command_queue |
| KernelFunctor | Kernel functor interface |
| CLHEP | |
| clvisc | |
| BulkInfo | |
| Config | |
| CLIdeal | |
| CLVisc | |
| CompileOption | |
| OpenclBackend | |
| common | |
| conf | |
| configureMap | |
| conftest | |
| RootHashAssertionError | |
| cpp | |
| ast | |
| _NullDict | |
| Node | |
| Define | |
| Include | |
| Goto | |
| Expr | |
| Return | |
| Delete | |
| Friend | |
| Using | |
| Parameter | |
| _GenericDeclaration | |
| VariableDeclaration | |
| Typedef | |
| _NestedType | |
| Union | |
| Enum | |
| Class | |
| Struct | |
| Function | |
| Method | |
| Type | |
| TypeConverter | |
| AstBuilder | |
| gmock_class | |
| gmock_class_test | |
| TestCase | |
| GenerateMethodsTest | |
| GenerateMocksTest | |
| keywords | |
| tokenize | |
| Token | |
| utils | |
| Dataset | |
| dd4hep | |
| DD4hepTestsHelper | |
| det | |
| utils | |
| detail | |
| digitization | |
| digitization_config | |
| DstOut | |
| emid_commons | |
| Enable | |
| EPDDefs | |
| erhic | |
| event_recording | |
| EVTGENDECAYER | |
| exatrkx | |
| fastjet | |
| contrib | |
| Fatras | |
| casts | |
| eta | The Eta cast operator |
| absEta | The Eta cast operator |
| pT | The Pt cast operator |
| p | The P cast operator |
| E | The E cast operator |
| vR | The E cast operator |
| vZ | The E cast operator |
| AbsVz | The E cast operator |
| detail | |
| Test | |
| Particle | Particle for testing acts-fatras core functionality |
| Generator | Needed are : generator, detector, particle |
| Detector | The detector |
| SterileProcess | Physics process that does not trigger a break |
| FatalProcess | Physics process that DOES trigger a break |
| Selector | The selector |
| EnergyDecreaser | The scattering formula |
| Object | Needed are : object, environment |
| Environment | |
| FeatureSelector | |
| NameSelector | |
| EnvironmentSelector | |
| LandauDist | |
| param_type | A RandomNumberDistribution should provide a parameters struct |
| VoidSelector | |
| Interactor | |
| this_result | |
| PhysicsList | |
| Process | Process class that turns a parameterized or tabularized fast simulation module into a process that can be plugged into the PhysicsList |
| SelectorListAXOR | This is the SelectorList struct that is used for fast simulation |
| VoidDetector | |
| Simulator | Fatras simulator |
| BetheBloch | The struct for the EnergyLoss physics list |
| BetheHeitler | |
| ParametricNuclearInt | |
| GaussianMixture | The struct to be provided to the Scatterer action This is the gaussian mixture |
| GeneralMixture | |
| Highland | |
| Scattering | |
| ChargedSelector | |
| NeutralSelector | |
| PositiveSelector | |
| NegativeSelector | |
| X0Limit | |
| L0Limit | |
| AbsPdgSelector | |
| PdgSelector | |
| AbsPdgExcluder | |
| PdgExcluder | |
| Min | |
| Max | |
| Range | |
| fatras | |
| fetchrun | |
| filter | |
| State | |
| findNode | |
| fix_pragma | |
| fixGDML | |
| foo | |
| UnprintableInFoo | |
| PrintableViaPrintTo | |
| PointerPrintable | |
| PrintableViaPrintToTemplate | |
| StreamableTemplateInFoo | |
| MixedUpTestCaseTest | |
| MixedUpTestCaseWithSameTestNameTest | |
| full_chain_itk | |
| full_chain_itk_FTF | |
| full_chain_odd | |
| Fun4AllReturnCodes | |
| Fun4AllUtils | |
| fuse_gmock_files | |
| fuse_gtest_files | |
| G4BEAMLINE | |
| G4CEMC | |
| G4CEMCALBEDO | |
| G4DSTREADER | |
| G4EPD | |
| G4Eval | |
| TrkrClusterComparer | |
| ClusKeyIter | |
| ClusCntr | |
| g4evalfn | |
| G4GLOBAL | |
| G4HCALIN | |
| G4HCALOUT | |
| G4HIJETS | |
| G4INTT | |
| G4MAGNET | |
| G4MBD | |
| G4MICROMEGAS | |
| G4MVTX | |
| G4MVTXAlignment | |
| G4P6DECAYER | |
| G4PIPE | |
| G4PLUGDOOR | |
| G4TPC | |
| G4TRACKING | |
| G4USER | |
| G4WORLD | |
| G4ZDC | |
| gbl | Namespace for the general broken lines package |
| BorderedBandMatrix | (Symmetric) Bordered Band Matrix |
| GblData | Data (block) for independent scalar measurement |
| GblPoint | Point on trajectory |
| GblTrajectory | GBL trajectory |
| MilleBinary | Millepede-II (binary) record |
| VVector | Simple Vector based on std::vector<double> |
| VMatrix | Simple Matrix based on std::vector<double> |
| VSymMatrix | Simple symmetric Matrix based on std::vector<double> |
| geant4 | |
| geant4_parallel | |
| gen_gtest_pred_impl | |
| generate_files_AA | |
| generate_files_AA_dag | |
| generate_particle_data_table | |
| generate_run_files_300evts_AA_MDC2 | |
| generic_plotter | |
| Model | |
| Config | |
| HistConfig | |
| Extra | |
| Config | |
| Mode | |
| genfit | Defines for I/O streams used for error and debug printing |
| RKTools | Array matrix multiplications used in RKTrackRep |
| tools | |
| Field | Field Wrapper |
| AbsBField | Abstract Interface to magnetic fields in GENFIT |
| AbsFinitePlane | Abstract base class for finite detector planes |
| AbsFitter | Abstract base class for fitters |
| AbsFitterInfo | This class collects all information needed and produced by a specific AbsFitter and is specific to one AbsTrackRep of the Track |
| AbsHMatrix | HMatrix for projecting from AbsTrackRep parameters to measured parameters in a DetPlane |
| AbsMeasurement | Contains the measurement and covariance in raw detector coordinates |
| MatStep | Simple struct containing MaterialProperties and stepsize in the material |
| AbsTrackRep | Abstract base class for a track representation |
| DetPlane | Detector plane |
| Exception | Exception class for error handling in GENFIT (provides storage for diagnostic information) |
| fieldCache | Cache B field at a position. Used by FieldManager |
| FieldManager | Singleton which provides access to magnetic field maps |
| PruneFlags | Info which information has been pruned from the Track |
| FitStatus | Class where important numbers and properties of a fit can be stored |
| Material | |
| MeasuredStateOnPlane | StateOnPlane with additional covariance matrix |
| MeasurementFactory | Factory object to create AbsMeasurement objects from digitized and clustered data |
| MeasurementOnPlane | Measured coordinates on a plane |
| AbsMeasurementProducer | Abstract interface class for MeasurementProducer |
| MeasurementProducer | Template class for a measurement producer module |
| SharedPlanePtrCreator | |
| StateOnPlane | A state with arbitrary dimension defined in a DetPlane |
| ThinScatterer | Thin or thick scatterer |
| TrackPointComparator | Helper class for TrackPoint sorting, used in Track::sort() |
| Track | Collection of TrackPoint objects, AbsTrackRep objects and FitStatus objects |
| TrackCand | Track candidate – seed values and indices |
| TrackCandHit | Hit object for use in TrackCand. Provides IDs and sorting parameters |
| TrackPoint | Object containing AbsMeasurement and AbsFitterInfo objects |
| EventDisplay | Event display designed to run with Genfit |
| ConstField | Constant Magnetic field |
| RectangularFinitePlane | Rectangular finite plane |
| AbsKalmanFitter | Abstract base class for Kalman fitter and derived fitting algorithms |
| DAF | Determinstic Annealing Filter (DAF) implementation |
| KalmanFitStatus | FitStatus for use with AbsKalmanFitter implementations |
| KalmanFittedStateOnPlane | MeasuredStateOnPlane with additional info produced by a Kalman filter or DAF |
| KalmanFitter | Simple Kalman filter implementation |
| KalmanFitterInfo | Collects information needed and produced by a AbsKalmanFitter implementations and is specific to one AbsTrackRep of the Track |
| KalmanFitterRefTrack | Kalman filter implementation with linearization around a reference track |
| ReferenceStateOnPlane | StateOnPlane with linearized transport to that ReferenceStateOnPlane from previous and next ReferenceStateOnPlane |
| GblFitStatus | FitStatus for use with GblFitter |
| GblFitter | Generic GBL implementation |
| GblFitterInfo | Collects information needed and produced by a GblFitter/GBL and is specific to one AbsTrackRep of the Track |
| GblTrackSegmentController | TrackSegmentController for use with GblFitter |
| GFGbl | Generic GBL implementation |
| ICalibrationParametersDerivatives | Abstract base class to establish an interface between physical representation of the detector for alignment/calibration and (fitted) state on genfit::Track |
| GFRaveMagneticField | GFRaveMagneticField class Uses the FieldManager to provide a magnetic field to rave |
| GFRavePropagator | GFRavePropagator class |
| GFRaveTrackParameters | GFRaveTrackParameters class Contains a pointer to the original genfit::Track, the weight of the track in the vertex, and smoothed (with the vertex information) state and covariance of the track |
| GFRaveVertex | GFRaveVertex class |
| trackAndState | Simple struct containing a Track pointer and a MeasuredStateOnPlane. Used in GFRave |
| GFRaveVertexFactory | Vertex factory for producing GFRaveVertex objects from Track objects |
| ConstFieldUninitializedTests | |
| ConstFieldInitializedTests | |
| MaterialTests | |
| MaterialEffectsTests | |
| RKTrackRepTests | |
| FullMeasurement | Measurement class implementing a measurement of all track parameters |
| HMatrixPhi | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| HMatrixU | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| HMatrixUnit | AbsHMatrix implementation for 5-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| HMatrixUV | AbsHMatrix implementation for two-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| HMatrixV | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| PlanarMeasurement | Measurement class implementing a planar hit geometry (1 or 2D) |
| ProlateSpacepointMeasurement | Class for measurements implementing a space point hit geometry with a very prolate form of the covariance matrix |
| SpacepointMeasurement | Class for measurements implementing a space point hit geometry |
| WireMeasurement | Class for measurements in wire detectors (Straw tubes and drift chambers) which do not measure the coordinate along the wire |
| WireMeasurementNew | Class for measurements in wire detectors (Straw tubes and drift chambers) which do not measure the coordinate along the wire |
| WirePointMeasurement | Class for measurements in wire detectors (Straw tubes and drift chambers) which can measure the coordinate along the wire |
| WireTrackCandHit | Hit object for use in TrackCand. Provides additional left/right parameter |
| AbsMaterialInterface | Abstract base class for geometry interfacing |
| MaterialEffects | Stepper and energy loss/noise matrix calculation |
| MplTrackRep | |
| RKMatrix | |
| RKStep | Helper for RKTrackRep |
| ExtrapStep | Helper for RKTrackRep |
| RKTrackRep | AbsTrackRep with 5D track parameterization in plane coordinates: (q/p, u', v', u, v) |
| StepLimits | Helper to store different limits on the stepsize for the RKTRackRep |
| TGeoMaterialInterface | AbsMaterialInterface implementation for use with ROOT's TGeoManager |
| HelixTrackModel | Helix track model for testing purposes |
| MeasurementCreator | Create different measurement types along a HelixTrackModel for testing purposes |
| mySpacepointDetectorHit | Example class for a spacepoint detector hit |
| mySpacepointMeasurement | Example class for a spacepoint measurement which can be created from mySpacepointDetectorHit via the MeasurementFactory |
| geometry | |
| GeometryVisualisationAndMaterialHandling | |
| index_info | |
| global-time-converter | |
| gmock_doctor | |
| gmock_gen | |
| gmock_leak_test | |
| GMockLeakTest | |
| gmock_output_test | |
| GMockOutputTest | |
| gmock_test_utils | |
| graph_fancy | |
| gtest_break_on_failure_unittest | |
| GTestBreakOnFailureUnitTest | |
| gtest_catch_exceptions_test | |
| CatchSehExceptionsTest | |
| CatchCxxExceptionsTest | |
| gtest_color_test | |
| GTestColorTest | |
| gtest_env_var_test | |
| GTestEnvVarTest | |
| gtest_filter_unittest | |
| GTestFilterUnitTest | |
| gtest_help_test | |
| GTestHelpTest | |
| gtest_list_tests_unittest | |
| GTestListTestsUnitTest | |
| gtest_output_test | |
| GTestOutputTest | |
| gtest_shuffle_test | |
| GTestShuffleUnitTest | |
| gtest_test_utils | |
| Subprocess | |
| gtest_throw_on_failure_test | |
| ThrowOnFailureTest | |
| gtest_uninitialized_test | |
| GTestUninitializedTest | |
| gtest_xml_outfiles_test | |
| GTestXMLOutFilesTest | |
| gtest_xml_output_unittest | |
| GTestXMLOutputUnitTest | |
| gtest_xml_test_utils | |
| GTestXMLTestCase | |
| GTL | |
| H5 | |
| HeavyFlavorReco | |
| helpers | |
| hash_root | |
| AssertCollectionExistsAlg | |
| HepMC | |
| HFjets | |
| Enable | |
| KFPARTICLE | |
| KFParticleBaseCut | |
| HFTriggerRequirement | |
| HIJETS | |
| Input | |
| INPUTEMBED | |
| INPUTGENERATOR | |
| INPUTHEPMC | |
| INPUTMANAGER | |
| INPUTREADEIC | |
| INPUTREADHITS | |
| INTT | |
| Indexes_s | |
| INTT_Felix | |
| Ladder_s | |
| InttDefs | Utility functions for INTT |
| InttFelix | |
| InttNameSpace | |
| RawData_s | |
| Online_s | |
| Offline_s | |
| RawDataComparator | |
| OnlineComparator | |
| OfflineComparator | |
| INTTVtxZ | |
| item | |
| Item | |
| ItemCollection | |
| itk | |
| itk_seeding | |
| Jetscape | |
| JetScapeWriterAsciiGZ | |
| Afterburner | Interface to hadronic afterburner |
| FluidCellInfo | |
| Parameter | |
| FluidDynamics | |
| InvalidSpaceTimeRange | |
| EvolutionHistory | |
| FourVector | |
| Hadronization | |
| HadronizationManager | |
| HadronizationModule | |
| HardProcess | |
| InitialState | |
| Jet | |
| Vertex | |
| JetEnergyLoss | |
| JetEnergyLossManager | |
| JetEnergyLossModule | |
| JetScape | |
| JetScapeEvent | |
| JetScapeEventHeader | |
| SafeOstream | |
| GuardedImpl | |
| impl | |
| LogStreamer | |
| LogStreamerThread | |
| JetScapeLogger | |
| JetScapeModuleBase | |
| JetScapeModuleFactory | |
| RegisterJetScapeModule | Registers Jetscape modules in the factory map |
| JetScapeModuleMutex | |
| JetScapeParticleBase | |
| Parton | |
| Hadron | |
| Photon | |
| JetScapeSignalManager | |
| JetScapeTask | |
| JetScapeTaskSupport | |
| JetScapeWriter | |
| JetScapeWriterFinalStateStream | |
| JetScapeWriterFinalStatePartonsStream | |
| JetScapeWriterFinalStateHadronsStream | |
| JetScapeWriterHepMC | |
| JetScapeWriterStream | |
| JetScapeWriterStreamFilter | |
| JetScapeXML | |
| Droplet | |
| LiquefierBase | |
| _Unique_if | |
| _Unique_if< T[]> | |
| _Unique_if< T[N]> | |
| PartonShower | |
| PartonShowerGenerator | |
| PreEquilibriumParameterFile | |
| PreequilibriumDynamics | |
| SoftParticlization | |
| StringTokenizer | |
| SurfaceCellInfo | |
| SurfaceFinder | |
| EventInfo | |
| TrentoInitial | |
| RangeFailure | |
| HadronPrinter | |
| PartonPrinter | |
| CausalLiquefier | |
| JetScapeReader | |
| JetScapeWriterRootHepMC | |
| KF_timing | |
| KFPARTICLE | |
| KFParticleBaseCut | |
| KFPMath | |
| LambdaJetHunterOptions | |
| make_inp_lists | |
| makeCondorJobs | |
| matcher_test | |
| MatcherComparatorOptions | |
| material_mapping | |
| material_mapping_itk | |
| material_mapping_optimisation | |
| material_recording | |
| material_validation | |
| material_validation_itk | |
| MATSCAN | |
| MbdDefs | |
| MbdReturnCodes | |
| merge_hashes | |
| MicromegasDefs | |
| mvtx | |
| lhcConstants | |
| ChipStat | |
| ChipError | |
| GBTLinkDecodingStat | Statistics for per-link decoding |
| TRGData | |
| mvtx_hit | |
| GBTLink | Support for the GBT single link data |
| GBTWord | |
| GBTCalibDataWord | |
| InteractionRecord | < TODO: Add RHIC constants |
| PayLoadCont | |
| PayLoadSG | |
| SGPiece | |
| PixelData | < single pixel datum |
| ChipPixelData | |
| mvtx_utils | |
| RdhExt_t | |
| MvtxDefs | Utility functions for MVTX |
| mvtxGeomDef | |
| my_namespace | |
| testing | |
| Test | |
| Message | |
| AssertionResult | |
| myAnalysis | |
| namespace1 | |
| MyTypeInNameSpace1 | |
| namespace2 | |
| MyTypeInNameSpace2 | |
| nanoflann | |
| KNNResultSet | |
| RadiusResultSet | |
| IndexDist_Sorter | |
| L1_Adaptor | |
| L2_Adaptor | |
| L2_Simple_Adaptor | |
| metric_L1 | |
| traits | |
| metric_L2 | |
| traits | |
| metric_L2_Simple | |
| traits | |
| KDTreeSingleIndexAdaptorParams | |
| SearchParams | |
| PooledAllocator | |
| CArray | |
| array_or_vector_selector | |
| array_or_vector_selector<-1, T > | |
| KDTreeSingleIndexAdaptor | |
| Interval | |
| Node | |
| KDTreeEigenMatrixAdaptor | |
| odbc | |
| CallableStatement | |
| Connection | |
| DatabaseMetaData | |
| Driver | |
| DataSource | |
| DriverManager | |
| ErrorHandler | |
| PreparedStatement | |
| ResultSet | |
| ResultSetMetaData | |
| Statement | |
| Types | |
| Bytes | |
| Rep | |
| Date | |
| Time | |
| Timestamp | |
| CleanVector | |
| DriverMessage | |
| SQLException | |
| SQLWarning | |
| Deleter | |
| OnCalDBCodes | |
| OnCalHistoBinDefs | |
| OnlMonDefs | |
| OnlMonStatus | |
| Optuna_tuning | |
| Objective | |
| Orion_tuning | |
| Objective | |
| Ort | |
| parse_clang_tidy | |
| parse_cmake_options | |
| particle_gun | |
| perf_headwind | |
| PHG4CellDefs | |
| EtaPhiBinning | |
| EtaXsizeBinning | |
| MVTXBinning | |
| ScintillatorSlatBinning | |
| SizeBinning | |
| SpacalBinning | |
| TPCBinning | |
| PHG4CylinderCellDefs | |
| PHG4HcalDefs | |
| PHG4HitDefs | |
| PHG4InttDefs | |
| PHG4MvtxDefs | |
| PHG4PrototypeHcalDefs | |
| PHG4ScintillatorSlatDefs | |
| PHG4Sector | |
| Layer | |
| Sector_Geometry | |
| PHG4SectorConstructor | Generalized detector which use sectors of flat panels to cover full azimuthal acceptance |
| PHG4StepStatusDecode | |
| PHG4TpcColorDefs | |
| PHG4TpcDefs | |
| PHG4TrackStatusDecode | |
| PHG4TrackUserInfo | |
| PHG4ZDCDefs | |
| PHGenFit | Simple class to hold conversion information This could be optimized by initializing the object with the necessary node pointers |
| Fitter | |
| Measurement | |
| PlanarMeasurement | |
| SpacepointMeasurement | |
| Track | |
| phooldefs | |
| physmon_ckf_tracking | |
| physmon_common | |
| physmon_simulation | |
| physmon_track_finding_ttbar | |
| physmon_truth_tracking_gsf | |
| physmon_truth_tracking_kalman | |
| physmon_vertexing | |
| PILEUP | |
| PktSizeCommon | |
| plot-woods-saxon | |
| plot_DataSimComp | |
| plotTracklet | |
| plotUtil | |
| pr_commands | |
| CommandError | |
| Context | |
| print_units_physical_constants | |
| Private | |
| MirrorInfo | |
| PRODUCTION | |
| propagation | |
| propagation_timing | |
| proto2 | |
| PROTOTYPE2_FEM | |
| PROTOTYPE3_FEM | |
| PROTOTYPE4_FEM | |
| pump | |
| Cursor | |
| Token | |
| CodeNode | |
| VarNode | |
| RangeNode | |
| ForNode | |
| ElseNode | |
| IfNode | |
| RawCodeNode | |
| LiteralDollarNode | |
| ExpNode | |
| Env | |
| Output | |
| PYTHIA6 | |
| PYTHIA8 | |
| pythia8 | |
| Pythia8 | |
| python_algorithm | |
| PyAlg | |
| PyAlg1 | |
| QA | |
| QAG4Util | |
| QAHistManagerDef | |
| quick_view | |
| rave | |
| RawClusterDefs | |
| RawTowerDefs | |
| RecoPV_optimization | |
| release | |
| Commit | |
| release_docs | |
| WikiBrancher | |
| ROOT | |
| Shadow | |
| root_event_diff_np | |
| ROOTDict | |
| ROOTShadow | |
| Shadow | |
| runCondor | |
| runCondor_beamspot | |
| runCondor_plotTracklet | |
| runCondor_recotracklet | |
| runCondor_recovtxz | |
| s95p | |
| SColdQcdCorrelatorAnalysis | |
| SCorrelatorUtilities | |
| ClustInfo | |
| CstInfo | |
| RecoInfo | |
| GenInfo | |
| FlowInfo | |
| ParInfo | |
| JetInfo | |
| TrkInfo | |
| SCorrelatorJetTree | |
| SBaseQAPlugin | |
| SCheckTrackPairsConfig | |
| SCheckTrackPairs | |
| SCorrelatorQAMaker | |
| SEnergyCorrelator | |
| SLambdaJetHunter | |
| SLambdaJetHunterConfig | |
| seeding | |
| EnumAction | |
| ServiceProperties | |
| sigmaEff | |
| sigslot | |
| single_threaded | |
| lock_block | |
| _connection_base0 | |
| _connection_base1 | |
| _connection_base2 | |
| _connection_base3 | |
| _connection_base4 | |
| _connection_base5 | |
| _connection_base6 | |
| _connection_base7 | |
| _connection_base8 | |
| _signal_base | |
| has_slots | |
| _signal_base0 | |
| _signal_base1 | |
| _signal_base2 | |
| _signal_base3 | |
| _signal_base4 | |
| _signal_base5 | |
| _signal_base6 | |
| _signal_base7 | |
| _signal_base8 | |
| _connection0 | |
| _connection1 | |
| _connection2 | |
| _connection3 | |
| _connection4 | |
| _connection5 | |
| _connection6 | |
| _connection7 | |
| _connection8 | |
| signal0 | |
| signal1 | |
| signal2 | |
| signal3 | |
| signal4 | |
| signal5 | |
| signal6 | |
| signal7 | |
| signal8 | |
| smearing-config | |
| std | STL namespace |
| tr1 | |
| gtest_internal | |
| ByRef | |
| ByRef< T & > | |
| AddRef | |
| AddRef< T & > | |
| TupleElement< true, 0, GTEST_10_TUPLE_(T) > | |
| TupleElement< true, 1, GTEST_10_TUPLE_(T) > | |
| TupleElement< true, 2, GTEST_10_TUPLE_(T) > | |
| TupleElement< true, 3, GTEST_10_TUPLE_(T) > | |
| TupleElement< true, 4, GTEST_10_TUPLE_(T) > | |
| TupleElement< true, 5, GTEST_10_TUPLE_(T) > | |
| TupleElement< true, 6, GTEST_10_TUPLE_(T) > | |
| TupleElement< true, 7, GTEST_10_TUPLE_(T) > | |
| TupleElement< true, 8, GTEST_10_TUPLE_(T) > | |
| TupleElement< true, 9, GTEST_10_TUPLE_(T) > | |
| Get< 0 > | |
| Get< 1 > | |
| Get< 2 > | |
| Get< 3 > | |
| Get< 4 > | |
| Get< 5 > | |
| Get< 6 > | |
| Get< 7 > | |
| Get< 8 > | |
| Get< 9 > | |
| SameSizeTuplePrefixComparator< 0, 0 > | |
| SameSizeTuplePrefixComparator< k, k > | |
| tuple<> | |
| tuple | |
| tuple_size< GTEST_0_TUPLE_(T) > | |
| tuple_size< GTEST_1_TUPLE_(T) > | |
| tuple_size< GTEST_2_TUPLE_(T) > | |
| tuple_size< GTEST_3_TUPLE_(T) > | |
| tuple_size< GTEST_4_TUPLE_(T) > | |
| tuple_size< GTEST_5_TUPLE_(T) > | |
| tuple_size< GTEST_6_TUPLE_(T) > | |
| tuple_size< GTEST_7_TUPLE_(T) > | |
| tuple_size< GTEST_8_TUPLE_(T) > | |
| tuple_size< GTEST_9_TUPLE_(T) > | |
| tuple_size< GTEST_10_TUPLE_(T) > | |
| tuple_element | |
| is_error_code_enum< ActsAlignment::AlignmentError > | |
| hash< Acts::GeometryIdentifier > | |
| is_error_code_enum< Acts::MagneticFieldError > | |
| is_error_code_enum< Acts::EigenStepperError > | |
| is_error_code_enum< Acts::MultiStepperError > | |
| is_error_code_enum< Acts::PropagatorError > | |
| is_error_code_enum< Acts::SurfaceError > | |
| is_error_code_enum< Acts::CombinatorialKalmanFilterError > | |
| is_error_code_enum< Acts::Experimental::GlobalChiSquareFitterError > | |
| is_error_code_enum< Acts::GsfError > | |
| is_error_code_enum< Acts::KalmanFitterError > | |
| hash< Acts::MultiIndex< Storage, BitsPerLevel...> > | |
| is_error_code_enum< Acts::VertexingError > | |
| is_error_code_enum< HoughError > | |
| is_error_code_enum< ActsFatras::DigitizationError > | |
| hash< ActsFatras::Barcode > | |
| is_error_code_enum< ActsFatras::detail::SimulationError > | |
| is_error_code_enum< MyError > | |
| numeric_limits< half > | |
| hash< std::array< T, N > > | |
| hash< pair< A, B > > | |
| _Unique_if | |
| _Unique_if< T[]> | |
| _Unique_if< T[N]> | |
| summary | |
| SVM_v1 | |
| syncdefs | |
| tau_commons | |
| TauVsDIS_MachineLearning_Differentiation | |
| telescope_simulation | |
| test_algorithms | |
| test_base | |
| test_detectors | |
| test_examples | |
| test_fpe | |
| FpeMaker | |
| FuncAlg | |
| test_magnetic_field | |
| test_material | |
| test_propagation | |
| AssertCollectionExistsAlg | |
| test_reader | |
| test_writer | |
| testing | |
| gmock_generated_actions_test | |
| action_test | |
| NullaryFunctor | |
| UnaryFunctor | |
| SumOf5Functor | |
| SumOf6Functor | |
| SubstractAction | |
| NullaryConstructorClass | |
| UnaryConstructorClass | |
| TenArgConstructorClass | |
| BoolResetter | |
| GiantTemplate | |
| gmock_generated_function_mockers_test | |
| FooInterface | |
| MockFoo | |
| FunctionMockerTest | |
| MockB | |
| StackInterface | |
| MockStack | |
| MockOverloadedOnArgNumber | |
| MockOverloadedOnConstness | |
| gmock_matchers_test | |
| GreaterThanMatcher | |
| EvenMatcherImpl | |
| NewEvenMatcherImpl | |
| ReferencesBarOrIsZeroImpl | |
| PolymorphicIsEvenImpl | |
| IntValue | |
| ConvertibleFromAny | |
| IntReferenceWrapper | |
| Base | |
| Derived | |
| OtherDerived | |
| Unprintable | |
| Type | |
| IsGreaterThan | |
| ConvertibleToBool | |
| AllArgsHelper | |
| FloatingPointTest | |
| FloatingPointNearTest | |
| ConstPropagatingPtr | |
| Uncopyable | |
| AStruct | |
| DerivedStruct | |
| AClass | |
| DerivedClass | |
| Functor | |
| PolymorphicFunctor | |
| ReferencingFunctor | |
| DivisibleByImpl | |
| NotCopyable | |
| Streamlike | |
| ConstIter | |
| PostIncrProxy | |
| UnorderedElementsAreTest | |
| BacktrackingBPMTest | |
| BipartiteTest | |
| BipartiteNonSquareTest | |
| BipartiteRandomTest | |
| IsHalfOfMatcher | |
| gmock_more_actions_test | |
| NullaryFunctor | |
| VoidNullaryFunctor | |
| UnaryFunctor | |
| SumOf5Functor | |
| SumOf6Functor | |
| Foo | |
| DeletionTester | |
| gmock_nice_strict_test | |
| Foo | |
| MockFoo | |
| MockBar | |
| gtest_printers_test | |
| Foo | |
| AllowsGenericStreaming | |
| AllowsGenericStreamingTemplate | |
| AllowsGenericStreamingAndImplicitConversionTemplate | |
| iterator | |
| const_iterator | |
| Big | |
| internal | |
| edit_distance | |
| invoke_argument | |
| AdlTag | |
| posix | |
| BuiltInDefaultValueGetter | |
| BuiltInDefaultValueGetter< T, false > | |
| BuiltInDefaultValue | |
| BuiltInDefaultValue< const T > | |
| BuiltInDefaultValue< T * > | |
| ActionAdaptor | |
| ByMoveWrapper | |
| ReturnAction | |
| Impl | |
| Impl< ByMoveWrapper< R_ >, F > | |
| ReturnNullAction | |
| ReturnVoidAction | |
| ReturnRefAction | |
| Impl | |
| ReturnRefOfCopyAction | |
| Impl | |
| DoDefaultAction | |
| AssignAction | |
| SetErrnoAndReturnAction | |
| SetArgumentPointeeAction | |
| SetArgumentPointeeAction< N, Proto, true > | |
| InvokeWithoutArgsAction | |
| InvokeMethodWithoutArgsAction | |
| IgnoreResultAction | |
| Impl | |
| ReferenceWrapper | |
| DoBothAction | |
| Impl | |
| InvokeHelper< R,::testing::tuple<> > | |
| InvokeHelper< R,::testing::tuple< A1 > > | |
| InvokeHelper< R,::testing::tuple< A1, A2 > > | |
| InvokeHelper< R,::testing::tuple< A1, A2, A3 > > | |
| InvokeHelper< R,::testing::tuple< A1, A2, A3, A4 > > | |
| InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5 > > | |
| InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5, A6 > > | |
| InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5, A6, A7 > > | |
| InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8 > > | |
| InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9 > > | |
| InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > > | |
| SelectArgs | |
| SelectArgs< Result, ArgumentTuple,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| SelectArgs< Result, ArgumentTuple, k1,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| SelectArgs< Result, ArgumentTuple, k1, k2,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| SelectArgs< Result, ArgumentTuple, k1, k2, k3,-1,-1,-1,-1,-1,-1,-1 > | |
| SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4,-1,-1,-1,-1,-1,-1 > | |
| SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5,-1,-1,-1,-1,-1 > | |
| SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6,-1,-1,-1,-1 > | |
| SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7,-1,-1,-1 > | |
| SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8,-1,-1 > | |
| SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, k9,-1 > | |
| WithArgsAction | |
| Impl | |
| ExcessiveArg | |
| ActionHelper | |
| FunctionMocker< R()> | |
| FunctionMocker< R(A1)> | |
| FunctionMocker< R(A1, A2)> | |
| FunctionMocker< R(A1, A2, A3)> | |
| FunctionMocker< R(A1, A2, A3, A4)> | |
| FunctionMocker< R(A1, A2, A3, A4, A5)> | |
| FunctionMocker< R(A1, A2, A3, A4, A5, A6)> | |
| FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7)> | |
| FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8)> | |
| FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> | |
| FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> | |
| TupleFields | |
| TupleFields< Tuple,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| TupleFields< Tuple, k0,-1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| TupleFields< Tuple, k0, k1,-1,-1,-1,-1,-1,-1,-1,-1 > | |
| TupleFields< Tuple, k0, k1, k2,-1,-1,-1,-1,-1,-1,-1 > | |
| TupleFields< Tuple, k0, k1, k2, k3,-1,-1,-1,-1,-1,-1 > | |
| TupleFields< Tuple, k0, k1, k2, k3, k4,-1,-1,-1,-1,-1 > | |
| TupleFields< Tuple, k0, k1, k2, k3, k4, k5,-1,-1,-1,-1 > | |
| TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6,-1,-1,-1 > | |
| TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7,-1,-1 > | |
| TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,-1 > | |
| ArgsMatcherImpl | |
| ArgsMatcher | |
| AllOfResult1 | |
| AllOfResult2 | |
| AllOfResult3 | |
| AllOfResult4 | |
| AllOfResult5 | |
| AllOfResult6 | |
| AllOfResult7 | |
| AllOfResult8 | |
| AllOfResult9 | |
| AllOfResult10 | |
| AnyOfResult1 | |
| AnyOfResult2 | |
| AnyOfResult3 | |
| AnyOfResult4 | |
| AnyOfResult5 | |
| AnyOfResult6 | |
| AnyOfResult7 | |
| AnyOfResult8 | |
| AnyOfResult9 | |
| AnyOfResult10 | |
| AnyEq | |
| AnyNe | |
| AnyLt | |
| AnyGt | |
| AnyLe | |
| AnyGe | |
| DummyMatchResultListener | |
| StreamMatchResultListener | |
| MatcherBase | |
| MatcherCastImpl | |
| MatcherCastImpl< T, Matcher< U > > | |
| Impl | |
| MatcherCastImpl< T, Matcher< T > > | |
| TuplePrefix | |
| TuplePrefix< 0 > | |
| TransformTupleValuesHelper | |
| IterateOverTuple | |
| IterateOverTuple< Tup, 0 > | |
| AnyMatcherImpl | |
| AnythingMatcher | |
| ComparisonBase | |
| Impl | |
| EqMatcher | |
| NeMatcher | |
| LtMatcher | |
| GtMatcher | |
| LeMatcher | |
| GeMatcher | |
| IsNullMatcher | |
| NotNullMatcher | |
| RefMatcher< T & > | |
| Impl | |
| StrEqualityMatcher | |
| HasSubstrMatcher | |
| StartsWithMatcher | |
| EndsWithMatcher | |
| MatchesRegexMatcher | |
| PairMatchBase | |
| Impl | |
| Eq2Matcher | |
| Ne2Matcher | |
| Lt2Matcher | |
| Gt2Matcher | |
| Le2Matcher | |
| Ge2Matcher | |
| NotMatcherImpl | |
| NotMatcher | |
| BothOfMatcherImpl | |
| BothOfMatcher | |
| EitherOfMatcherImpl | |
| EitherOfMatcher | |
| TrulyMatcher | |
| MatcherAsPredicate | |
| PredicateFormatterFromMatcher | |
| FloatingEqMatcher | |
| Impl | |
| PointeeMatcher | |
| Impl | |
| WhenDynamicCastToMatcherBase | |
| WhenDynamicCastToMatcher | |
| WhenDynamicCastToMatcher< To & > | |
| FieldMatcher | |
| PropertyMatcher | |
| CallableTraits | |
| CallableTraits< ResType(*)(ArgType)> | |
| ResultOfMatcher | |
| Impl | |
| SizeIsMatcher | |
| Impl | |
| BeginEndDistanceIsMatcher | |
| Impl | |
| ContainerEqMatcher | |
| LessComparator | |
| WhenSortedByMatcher | |
| Impl | |
| PointwiseMatcher | |
| Impl | |
| QuantifierMatcherImpl | |
| ContainsMatcherImpl | |
| EachMatcherImpl | |
| ContainsMatcher | |
| EachMatcher | |
| KeyMatcherImpl | |
| KeyMatcher | |
| PairMatcherImpl | |
| PairMatcher | |
| ElementsAreMatcherImpl | |
| MatchMatrix | |
| UnorderedElementsAreMatcherImplBase | |
| UnorderedElementsAreMatcherImpl | |
| CastAndAppendTransform | |
| UnorderedElementsAreMatcher | |
| ElementsAreMatcher | |
| UnorderedElementsAreArrayMatcher | |
| ElementsAreArrayMatcher | |
| BoundSecondMatcher | |
| Impl | |
| InvokeAction | |
| InvokeMethodAction | |
| UntypedFunctionMockerBase | |
| UntypedOnCallSpecBase | |
| OnCallSpec | |
| ExpectationBase | |
| TypedExpectation | |
| MockSpec | |
| ReferenceOrValueWrapper | |
| ReferenceOrValueWrapper< T & > | |
| UntypedActionResultHolderBase | |
| ActionResultHolder | |
| ActionResultHolder< void > | |
| FunctionMockerBase | |
| IgnoredValue | |
| MatcherTuple< ::testing::tuple<> > | |
| MatcherTuple< ::testing::tuple< A1 > > | |
| MatcherTuple< ::testing::tuple< A1, A2 > > | |
| MatcherTuple< ::testing::tuple< A1, A2, A3 > > | |
| MatcherTuple< ::testing::tuple< A1, A2, A3, A4 > > | |
| MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5 > > | |
| MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5, A6 > > | |
| MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5, A6, A7 > > | |
| MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8 > > | |
| MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9 > > | |
| MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > > | |
| Function< R()> | |
| Function< R(A1)> | |
| Function< R(A1, A2)> | |
| Function< R(A1, A2, A3)> | |
| Function< R(A1, A2, A3, A4)> | |
| Function< R(A1, A2, A3, A4, A5)> | |
| Function< R(A1, A2, A3, A4, A5, A6)> | |
| Function< R(A1, A2, A3, A4, A5, A6, A7)> | |
| Function< R(A1, A2, A3, A4, A5, A6, A7, A8)> | |
| Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> | |
| Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> | |
| PointeeOf | |
| PointeeOf< T * > | |
| LinkedPtrLessThan | |
| KindOf | |
| LosslessArithmeticConvertibleImpl | |
| LosslessArithmeticConvertibleImpl< kBool, bool, kBool, bool > | |
| LosslessArithmeticConvertibleImpl< kBool, bool, kInteger, To > | |
| LosslessArithmeticConvertibleImpl< kBool, bool, kFloatingPoint, To > | |
| LosslessArithmeticConvertibleImpl< kInteger, From, kBool, bool > | |
| LosslessArithmeticConvertibleImpl< kInteger, From, kInteger, To > | |
| LosslessArithmeticConvertibleImpl< kInteger, From, kFloatingPoint, To > | |
| LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kBool, bool > | |
| LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kInteger, To > | |
| is_reference | |
| is_reference< T & > | |
| type_equals | |
| type_equals< T, T > | |
| remove_reference | |
| remove_reference< T & > | |
| DecayArray | |
| DecayArray< T[N]> | |
| DecayArray< T[]> | |
| StlContainerView | |
| StlContainerView< Element[N]> | |
| StlContainerView< ::testing::tuple< ElementPointer, Size > > | |
| RemoveConstFromKey | |
| RemoveConstFromKey< std::pair< const K, V > > | |
| BooleanConstant | |
| GoogleTestFailureReporter | |
| MaxBipartiteMatchState | |
| ExpectationTester | |
| FormatForComparison | |
| FormatForComparison< ToPrint[N], OtherOperand > | |
| UniversalPrinter | |
| UniversalPrinter< T[N]> | |
| UniversalPrinter< T & > | |
| UniversalTersePrinter | |
| UniversalTersePrinter< T & > | |
| UniversalTersePrinter< T[N]> | |
| UniversalTersePrinter< const char * > | |
| UniversalTersePrinter< char * > | |
| UniversalTersePrinter< wchar_t * > | |
| SingleFailureChecker | |
| HasNewFatalFailureHelper | |
| EqHelper | |
| EqHelper< true > | |
| AssertHelper | |
| AssertHelperData | |
| FilePath | |
| ScopedTrace | |
| FloatingPoint | |
| FloatingPointUnion | |
| TypeIdHelper | |
| TestFactoryBase | |
| TestFactoryImpl | |
| CodeLocation | |
| ConstCharPtr | |
| Random | |
| CompileAssertTypesEqual< T, T > | |
| RemoveReference | |
| RemoveReference< T & > | |
| RemoveConst | |
| RemoveConst< const T > | |
| RemoveConst< const T[N]> | |
| AddReference | |
| AddReference< T & > | |
| ImplicitlyConvertible | |
| IsAProtocolMessage | |
| EnableIf< true > | |
| RelationToSourceReference | |
| RelationToSourceCopy | |
| NativeArray | |
| linked_ptr_internal | |
| linked_ptr | |
| CompileAssert | |
| StaticAssertTypeEqHelper< T, T > | |
| scoped_ptr | |
| RE | |
| GTestLog | |
| Mutex | |
| GTestMutexLock | |
| ThreadLocal | |
| bool_constant | |
| is_pointer | |
| is_pointer< T * > | |
| IteratorTraits | |
| IteratorTraits< T * > | |
| IteratorTraits< const T * > | |
| TypeWithSize | |
| TypeWithSize< 4 > | |
| TypeWithSize< 8 > | |
| String | |
| GTestFlagSaver | |
| TestPropertyKeyIs | |
| UnitTestOptions | |
| OsStackTraceGetterInterface | |
| OsStackTraceGetter | |
| TraceInfo | |
| DefaultGlobalTestPartResultReporter | |
| DefaultPerThreadTestPartResultReporter | |
| UnitTestImpl | |
| TestResultAccessor | |
| PrettyUnitTestResultPrinter | |
| TestEventRepeater | |
| XmlUnitTestResultPrinter | |
| ScopedPrematureExitFile | |
| TestCaseNameIs | |
| EventRecordingListener | |
| EnvironmentInvocationCatcher | |
| ListenerTest | |
| Base | |
| Derived | |
| Castable | |
| ConstCastable | |
| ConstAndNonConstCastable | |
| To | |
| NoDefaultContructor | |
| LessByName | |
| UnitTestHelper | |
| FinalSuccessChecker | |
| TestEventListenersAccessor | |
| UnitTestRecordPropertyTestHelper | |
| internal2 | |
| TypeWithoutFormatter | |
| TypeWithoutFormatter< T, kProtobuf > | |
| TypeWithoutFormatter< T, kConvertibleToInteger > | |
| DefaultValue | |
| FactoryValueProducer | |
| FixedValueProducer | |
| ValueProducer | |
| DefaultValue< T & > | |
| DefaultValue< void > | |
| ActionInterface | |
| Action | |
| PolymorphicAction | |
| MonomorphicImpl | |
| CardinalityInterface | |
| Cardinality | |
| MockFunction< R()> | |
| MockFunction< R(A0)> | |
| MockFunction< R(A0, A1)> | |
| MockFunction< R(A0, A1, A2)> | |
| MockFunction< R(A0, A1, A2, A3)> | |
| MockFunction< R(A0, A1, A2, A3, A4)> | |
| MockFunction< R(A0, A1, A2, A3, A4, A5)> | |
| MockFunction< R(A0, A1, A2, A3, A4, A5, A6)> | |
| MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7)> | |
| MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> | |
| MockFunction< R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> | |
| NiceMock | |
| NaggyMock | |
| StrictMock | |
| MatchResultListener | |
| MatcherDescriberInterface | |
| MatcherInterface | |
| StringMatchResultListener | |
| Matcher | |
| Matcher< const internal::string & > | |
| Matcher< internal::string > | |
| PolymorphicMatcher | |
| MonomorphicImpl | |
| SafeMatcherCastImpl | |
| Mock | |
| Expectation | |
| Less | |
| ExpectationSet | |
| Sequence | |
| InSequence | |
| Message | |
| ScopedFakeTestPartResultReporter | |
| TestPartResult | |
| TestPartResultArray | |
| TestPartResultReporterInterface | |
| AssertionResult | |
| Test | |
| Setup_should_be_spelled_SetUp | |
| TestProperty | |
| TestResult | |
| TestInfo | |
| TestCase | |
| Environment | |
| Setup_should_be_spelled_SetUp | |
| TestEventListener | |
| EmptyTestEventListener | |
| TestEventListeners | |
| UnitTest | |
| TestInfoTest | |
| CodeLocationForTESTF | |
| CodeLocationForTESTP | |
| CodeLocationForTYPEDTEST | |
| CodeLocationForTYPEDTESTP | |
| SetUpTestCaseTest | |
| Flags | |
| InitGoogleTestTest | |
| CurrentTestInfoTest | |
| testing_internal | |
| testSigmaEff | |
| tgeo-response2json | |
| tinyxml2 | |
| Entity | |
| LongFitsIntoSizeTMinusOne | |
| LongFitsIntoSizeTMinusOne< false > | |
| StrPair | |
| DynArray | |
| MemPool | |
| MemPoolT | |
| Block | |
| Item | |
| XMLVisitor | |
| XMLUtil | |
| XMLNode | |
| XMLText | |
| XMLComment | |
| XMLDeclaration | |
| XMLUnknown | |
| XMLAttribute | |
| XMLElement | |
| XMLDocument | |
| XMLHandle | |
| XMLConstHandle | |
| XMLPrinter | |
| TMVA | |
| torch | |
| jit | |
| TowerInfoDefs | |
| TPC_Cluster_Drift_Animator | |
| TPC_Cluster_Drift_Animator_beam | |
| TPCDaqDefs | |
| FEEv1 | TPC v1 FEE test stand decoder |
| SampleFit_PowerLawDoubleExp_PDFMaker | |
| TpcDefs | Utility functions for TPC |
| TpcPrototypeDefs | |
| FEEv2 | TPC v1 FEE test stand decoder |
| SampleFit_PowerLawDoubleExp_PDFMaker | |
| TpotMonDefs | |
| TrackAnalysisUtils | |
| TRACKING | |
| train_ambiguity_solver | |
| trento | |
| hdf5 | |
| random | |
| records | |
| Collider | |
| Event | |
| FastExp | |
| NucleonProfile | |
| Nucleon | |
| Nucleus | |
| Proton | Trivial nucleus with a single nucleon |
| Deuteron | |
| MinDistNucleus | |
| WoodsSaxonNucleus | |
| DeformedWoodsSaxonNucleus | |
| Output | |
| TrkrDefs | Define a namespace for Trkr typedefs |
| truth_tracking_gsf | |
| truth_tracking_gsf_refitting | |
| truth_tracking_gx2f | |
| truth_tracking_kalman | |
| truth_tracking_telescope | |
| upload | |
| ClientLoginError | |
| AbstractRpcServer | |
| HttpRpcServer | elif e.code >= 500 and e.code < 600:
Server Error - try again.
|
| VersionControlSystem | |
| SubversionVCS | |
| GitVCS | |
| MercurialVCS | |
| upload_gmock | |
| upload_gtest | |
| util | |
| utils | |
| varids | |
| versiongenerate | |
| vertex_fitting | |
| vertex_mu_scan | |
| volume_association_test | |
| warnings_filter | |
| WarningsFilter | |
| writeMapConfig | |
| __inheritance_helper | |
| _NoInfo | |
| A_Event | |
| ABlob | |
| abort_list_impl | |
| AcceptAll | This Struct is to accept all values - a placeholder |
| AcceptCombination | |
| AcceptRange | |
| action_list_impl | The dummy list call implementation |
| ActionAdaptor | |
| ActsAborter | |
| ActsAlignmentStates | |
| ActsEvaluator | |
| ActsGeometry | |
| ActsGsfTrackFittingAlgorithm | |
| ActsPropagator | |
| ActsSourceLink | |
| SurfaceAccessor | |
| ActsSurfaceMaps | |
| ActsTrackFittingAlgorithm | |
| Config | |
| DirectedTrackFitterFunction | |
| GeneralFitterOptions | |
| TrackFitterFunction | |
| ActsTrackingGeometry | |
| ActsTransformations | |
| AdSCFT | |
| AdSCFTMutex | |
| AdSCFTUserInfo | |
| AfterburnerModus | |
| algo_info | |
| algorithm | Abstract baseclass for all algoritm-classes |
| ALICEKF | |
| alignBlkV1 | |
| AlignmentTransformation | |
| alignmentTransformationContainer | Container class for Alignment transformations |
| analysis | |
| AnalyticFieldModel | |
| AnalyzeSimpleTree | |
| AnaMvtxPrototype1 | |
| AnaMvtxTelescopeHits | |
| AnaMvtxTestBeam2019 | |
| AnaSvtxTracksForGenFit | |
| AnaTutorial | Definition of this analysis module class |
| AnnularFieldSim | |
| AntiTrigger | |
| AnyVector | |
| are_sorted | |
| are_within | |
| AssocInfoContainer | |
| AssocInfoContainerv1 | |
| at_index | |
| ATLASBinFinder | |
| ATLASBinFinder | |
| atpAlignBlk | |
| ATrace | |
| ATrack | |
| Axis | Calculate bin indices from a given binning structure |
| AZigzag | |
| BarEnvironment | |
| Base | |
| BaseTruthEval | |
| BbcCheck | |
| BbcGeom | |
| BbcGeomV1 | |
| BbcMon | |
| BbcMonDraw | |
| BbcOut | |
| BbcOutV1 | |
| BbcOutV2 | |
| BbcPmtContainer | |
| BbcPmtContainerV1 | |
| BbcPmtHit | |
| BbcPmtHitV1 | |
| BbcPmtInfoContainerV1 | |
| BbcPmtInfoV1 | |
| BBCStudy | |
| BbcVertex | |
| BbcVertexMap | |
| BbcVertexMapv1 | |
| BbcVertexv1 | |
| BbcVertexv2 | |
| BDiJetModule | |
| BDTGNode | |
| BDTNode | |
| BeamLineMagnetDetector | |
| BeamLineMagnetDisplayAction | |
| BeamLineMagnetSteppingAction | |
| BeamLineMagnetSubsystem | |
| Beamspot | |
| bellman_ford | Bellman Ford algorithm |
| BEmcProfile | |
| BEmcRec | |
| BEmcRecCEMC | |
| bfs | Breadth-First-Search (BFS) algorithm |
| Bias | |
| biconnectivity | Biconnectivity-test and low-numbers |
| bid_dijkstra | Dijkstra's Algorithm for computing a shortest path from a single source to a single target |
| BiggestIntConvertible | |
| bin_heap | Binary heap |
| BinnedSPGroup | |
| BJetModule | |
| Bool | |
| BoundarySurfaceT | |
| BranchComparisonHarness | |
| EventLoaderT | |
| IEventLoader | |
| TreeMetadata | |
| UnsupportedBranchType | |
| Brick | |
| buffer | |
| bufferstructure | |
| BuildEdgesKDTree | |
| BuildResonanceJetTaggingTree | Definition of this analysis module class |
| caen_correction | |
| Calib | |
| Calibrator | |
| CalibratorAdapter | |
| CaloAna | |
| CaloCalibEmc_Pi0 | |
| CaloCalibration | |
| CaloEvalStack | |
| CaloEvaluator | Compares reconstructed showers to truth particles |
| CaloGeomMapping | |
| CaloRawClusterEval | |
| CaloRawTowerEval | |
| CaloRecoUtility | CaloRecoUtility |
| CaloTemplateFit | |
| CaloTowerBuilder | |
| CaloTowerCalib | |
| caloTowerEmbed | |
| CaloTowerStatus | |
| caloTreeGen | |
| CaloTriggerInfo | |
| CaloTriggerInfov1 | |
| CaloTriggerSim | Simple trigger emulation |
| CaloTruthEval | |
| CaloUnpackPRDF | |
| CaloValid | |
| CaloWaveformFitting | |
| CaloWaveformProcessing | |
| CaloWaveformSim | |
| CaloWaveFormSim | |
| capture_stdout | |
| CDBHistos | |
| CDBInterface | |
| CDBTTree | |
| CdbUrlSave | |
| CdbUrlSavev1 | |
| CDBUtils | |
| cdevBPMData | |
| cdevBucketsData | |
| cdevDvmData | |
| cdevIrData | |
| cdevMadchData | |
| cdevPolarimeterData | |
| cdevPolarimeterZData | |
| cdevPolTargetData | |
| cdevRingData | |
| cdevRingNoPolData | |
| cdevRingPolData | |
| cdevSISData | |
| cdevWCMData | |
| cdevWCMHistory | |
| Cell | |
| CemcMon | |
| CemcMonDraw | |
| cemcReco | |
| CentralityInfo | |
| CentralityInfov1 | |
| CentralityInfov2 | |
| CentralityReco | |
| CentralityValid | |
| char64long16 | |
| ChargeMapReader | |
| CheckDestructor | |
| CheveronPad_t | |
| ClientHistoList | |
| ClientThread | |
| ClosestPair2D | |
| Point | |
| Shuffle | |
| triplet | |
| ClosestPair2DBase | |
| ClusHitsVerbose | |
| ClusHitsVerbosev1 | Cluster container object |
| ClusKeyIter | |
| ClusterErrorPara | |
| ClusterIso | |
| ClusterJetInput | |
| ClusterSequence | |
| _Line | |
| _Parabola | |
| BriefJet | |
| EEBriefJet | |
| Extras | |
| history_element | |
| Tile | |
| TiledJet | |
| ClusterSequenceStructure | |
| CLVisc | |
| CMFlashCluster | Base class for Central Membrane flassh combined cluster object |
| CMFlashClusterContainer | Cluster container object |
| CMFlashClusterContainerv1 | CM flash cluster container object |
| CMFlashClusterv1 | Version 1 of CMFlashCluster |
| CMFlashClusterv2 | Version 2 of CMFlashCluster |
| CMFlashClusterv3 | Version 3 of CMFlashCluster |
| CMFlashDifference | Base class for Central Membrane flassh combined difference object |
| CMFlashDifferenceContainer | CM cluster difference due to distortions container object |
| CMFlashDifferenceContainerv1 | CM flash difference container object |
| CMFlashDifferencev1 | Version 1 of CMFlashDifference |
| Co | |
| ColoredHadronization | |
| ColorlessHadronization | |
| ColorShutterItem | |
| CommandLineArguments | |
| CommonTest | |
| CompBuilder | |
| CompileAssertTypesEqual | |
| components | Connected components algorithm |
| CompositeJetStructure | |
| ConcreteDelegate | |
| ConnectStringParser | |
| Conversion | |
| ConversionHelperBase | |
| ConversionHelperDerived | |
| ConvertibleToAssertionResult | |
| Coord2D | |
| CopyAndSubtractJets | Creates subtractd copy of a jet collection |
| Cornelius | |
| CosmicSpray | |
| Counter | |
| cs_base64_ctx | |
| cs_sha1_ctx | |
| CsvSpacePointWriter | |
| ctl_msg | |
| Cube | |
| CudaMatrix | |
| CudaScalar | |
| CudaVector | |
| cumulant_generating | |
| CylinderGeom_Mvtx | |
| CylinderGeomIntt | |
| CylinderGeomMicromegas | |
| CylindricalVolumeBuilder | A mockup volume builder, it generates volumes with a single surface filled in in order to use the CylindricalContainerBuilder infrastructure |
| D | |
| D2 | |
| D3 | |
| daq_device | |
| daq_device_command | |
| daq_device_deadtime | |
| daq_device_file | |
| daq_device_filenumbers | |
| daq_device_gauss | |
| daq_device_pluginexample | |
| daq_device_random | |
| daq_device_rtclock | |
| daqBuffer | |
| buffer_ptr | |
| daqEvent | |
| DaqMon | |
| DaqMonDraw | |
| daqONCSEvent | |
| daqPRDFEvent | |
| data32 | |
| dataBlockHdr | |
| DataStr | |
| date_filter_msg_buffer | |
| DbForm | |
| DbFormEntry | |
| dcbAlignBlk | |
| dcmAlignBlk | |
| DeadHotMapLoader | DeadHotMapLoader loads dead map at inti run |
| DecayFinder | |
| DecayFinderContainer_v1 | |
| DecayFinderContainerBase | DecayFinder container object |
| DefaultFactoryError | |
| Delegate | |
| DelegateInterface | |
| DetectorVolumeFactory | |
| DetectorVolumeFactory | |
| DetermineTowerBackground | UE background calculator |
| dfs | Depth-First-Search (DFS) algorithm |
| dijkstra | Dijkstra's Algorithm for computing single source shortest path |
| DirectAccessor | |
| direction_indicator | |
| DirectPhotonPythia | |
| DisabledTest | |
| DiscSurfaceBuilder | Construct a disc at track position with plane normal along track tangent |
| DISKinematicsReco | |
| DivisionAccessor | |
| dNdEtaINTT | |
| DnnError | |
| DpipeFilter | |
| DSTCompressor | |
| DSTEmulator | |
| DSTTrackInfoReader | |
| DSTTrackInfoWriter | |
| DummyComponent | |
| DummyDecorator | |
| DummyPropState | |
| DumpBbcPmtInfoContainer | |
| DumpBbcVertexMap | |
| DumpCaloTriggerInfo | |
| DumpCdbUrlSave | |
| DumpCentralityInfo | |
| DumpEpdGeom | |
| Dumper | |
| DumpEventHeader | |
| DumpFlagSave | |
| DumpGl1RawHit | |
| DumpGlobalVertexMap | |
| DumpInttDeadMap | |
| DumpInttRawHitContainer | |
| DumpJetContainer | |
| DumpJetMap | |
| DumpMbdGeom | |
| DumpMbdOut | |
| DumpMbdPmtContainer | |
| DumpMbdVertexMap | |
| DumpMicromegasRawHitContainer | |
| DumpMvtxRawEvtHeader | |
| DumpMvtxRawHitContainer | |
| DumpObject | |
| DumpParticleFlowElementContainer | |
| DumpPdbParameterMap | |
| DumpPdbParameterMapContainer | |
| DumpPHFieldConfig | |
| DumpPHG4BlockCellGeomContainer | |
| DumpPHG4BlockGeomContainer | |
| DumpPHG4CellContainer | |
| DumpPHG4CylinderCellContainer | |
| DumpPHG4CylinderCellGeomContainer | |
| DumpPHG4CylinderGeomContainer | |
| DumpPHG4HitContainer | |
| DumpPHG4InEvent | |
| DumpPHG4ParticleSvtxMap | |
| DumpPHG4ScintillatorSlatContainer | |
| DumpPHG4TpcCylinderGeomContainer | |
| DumpPHG4TruthInfoContainer | |
| DumpPHGenIntegral | |
| DumpPHHepMCGenEventMap | |
| DumpRawClusterContainer | |
| DumpRawTowerContainer | |
| DumpRawTowerGeomContainer | |
| DumpRunHeader | |
| DumpSvtxPHG4ParticleMap | |
| DumpSvtxTrackMap | |
| DumpSvtxVertexMap | |
| DumpSyncObject | |
| DumpTowerBackground | |
| DumpTowerInfoContainer | |
| DumpTpcRawHitContainer | |
| DumpTpcSeedTrackMap | |
| DumpTrackSeedContainer | |
| DumpTrkrClusterContainer | |
| DumpTrkrClusterCrossingAssoc | |
| DumpTrkrClusterHitAssoc | |
| DumpTrkrHitSetContainer | |
| DumpTrkrHitTruthAssoc | |
| DumpVariableArray | |
| DVMPHelper | |
| particle_reco | |
| particle_truth | |
| DynamicNearestNeighbours | |
| EcoMug | Class for the generation of cosmic muons |
| EdepNtuple | |
| edge | An edge in a graph |
| edge_data | |
| edge_map | A specialized map with edges as keys |
| eic_bnl_rich | |
| eic_dual_rich | |
| EicEventHeader | |
| EicEventHeaderv1 | |
| u_property | Convert between 32bit inputs and storage type prop_storage_t |
| ElectronID | |
| ElogHandler | |
| ElossValidate | |
| EmbRecoMatch | |
| Comp | |
| EmbRecoMatchContainer | |
| EmbRecoMatchContainerv1 | |
| CompShortToPair | |
| EmbRecoMatchv1 | |
| Emcal_Tower_Masking | |
| EMCalAna | |
| EMCalCalib | |
| EMCalCalib_TestBeam | |
| EMCalLikelihood | EMCalLikelihood |
| EMCalTrk | EMCalTrk |
| emcChannelLongList | |
| emcChannelShortList | |
| EmcCluster | |
| EmcModule | |
| EMJetVal | |
| EMMaximization | |
| EmptyDetector | |
| EMRandom | |
| enable_shared_from_this | |
| enable_shared_from_this2 | |
| EnableIf | |
| EoS | |
| EoSs | |
| EpdGeom | |
| EpdGeomV1 | |
| epemGun | |
| EpFinder | |
| EpFinderEval | |
| EpHit | |
| EpInfo | |
| Error | |
| errorEntryV1 | |
| EtaPhi | |
| Event | |
| event_kinematics_cut | |
| EventCombiner | |
| EventEvaluator | Compares reconstructed showers to truth particles |
| EventHeader | Base class for EventHeaders |
| EventHeaderv1 | Simple event header with ID and time |
| EventHeaderv2 | Simple event header with ID and time |
| EventInfoSummary | |
| channel_info | |
| Eventiterator | |
| EventNumberCheck | |
| Eventplaneinfo | |
| EventplaneinfoMap | |
| EventplaneinfoMapv1 | |
| Eventplaneinfov1 | |
| EventPlaneReco | |
| eventReceiverClient | |
| evt_data | |
| EvtGenExtDecayerPhysics | |
| example_plugin | |
| ExampleAnalysisModule | You get started |
| Eval_Cluster | |
| Eval_Run | |
| ExclusiveReco | |
| ExpectFailureTest | |
| ExternalsBuilder | Mockup external structure builder |
| Factory | |
| FailedTest | |
| FailingParamTest | |
| fast_eta2y | |
| FastJetAlgo | |
| FastJetAlgoSub | |
| FastJetOptions | |
| FastJetOptItem | |
| FastPid_RICH | |
| FastTrackingEval | |
| FatalFailureInFixtureConstructorTest | |
| FatalFailureInSetUpTest | |
| Fe55 | |
| FermimotionAfterburner | |
| FFT | |
| FieldHelper | |
| FieldMapReadBack | |
| FieldMaps | |
| FieldMapsLaplace | |
| fileEventiterator | |
| FileF | |
| FileList | |
| FillClusMatchTree | |
| fillSpaceChargeMaps | |
| FillTruthRecoMatchMap | |
| FillTruthRecoMatchTree | |
| filter_msg_buffer | |
| FilterEvents | |
| FilterEventsUpsilon | |
| FitterTester | |
| FlagHandler | |
| FlagSave | |
| FlagSavev1 | |
| Fluid | |
| fluidCell_2D | |
| fluidCell_3D | |
| fluidCell_3D_ideal | |
| fluidCell_3D_new | |
| FluidcellStatistic | |
| fm_partition | Heuristic graph bi-partitioning algorithm (Fiduccia-Mattheyses) |
| FooEnvironment | |
| FooTest | |
| formatError | |
| Forward_pi0s | |
| FreestreamMilneWrapper | |
| FROG | |
| frozen | |
| FullJetFinder | |
| chConstituent | |
| Container | |
| CutSelection | |
| neConstituent | |
| PrimaryVertex | |
| RecoJets | Reconstructed jets |
| TruthJets | Truth jets |
| fullRunningMean | |
| Fun4AllBase | |
| Fun4AllDstInputManager | |
| Fun4AllDstOutputManager | |
| Fun4AllDstPileupInputManager | |
| Deleter | Random generator |
| Fun4AllDstPileupMerger | |
| Fun4AllDummyInputManager | |
| Fun4AllEventOutputManager | |
| Fun4AllEventOutStream | |
| Fun4AllFileOutStream | |
| Fun4AllHepMCInputManager | |
| Fun4AllHepMCOutputManager | |
| Fun4AllHepMCPileupInputManager | |
| Fun4AllHistoManager | |
| Fun4AllInputManager | |
| Fun4AllMemoryTracker | |
| Fun4AllMessenger | |
| Fun4AllMonitoring | |
| Fun4AllNoSyncDstInputManager | |
| Fun4AllOscarInputManager | |
| Fun4AllOutputManager | |
| Fun4AllPrdfInputManager | |
| Fun4AllPrdfInputPoolManager | |
| PacketInfo | |
| SinglePrdfInputInfo | |
| Fun4AllPrdfOutputManager | |
| Fun4AllRolloverFileOutStream | |
| Fun4AllRunNodeInputManager | |
| Fun4AllServer | |
| Fun4AllSingleDstPileupInputManager | |
| Deleter | Random generator |
| Fun4AllStreamingInputManager | |
| Gl1RawHitInfo | |
| InttRawHitInfo | |
| MicromegasRawHitInfo | |
| MvtxRawHitInfo | |
| TpcRawHitInfo | |
| Fun4AllSyncManager | |
| Function | |
| FunctionMocker | |
| FunctionMocker | |
| FunctionMockerBase | |
| FunctionMockerBase | |
| FunctionOfPseudoJet | |
| G4CellNtuple | |
| G4EdepNtuple | |
| G4EvtGenDecayer | |
| G4EvtTree | |
| G4Example01Detector | |
| G4Example01SteppingAction | |
| G4Example01Subsystem | Example Fun4All module |
| G4Example02Detector | |
| G4Example02SteppingAction | |
| G4Example02Subsystem | Example Fun4All module |
| G4Example03Detector | |
| G4Example03DisplayAction | |
| G4Example03SteppingAction | |
| G4Example03Subsystem | Example Fun4All module |
| G4HitNtuple | |
| g4hitshift | |
| g4hitshifthcal | |
| G4HitTTree | |
| G4Pythia6Decayer | |
| G4Pythia6DecayerMessenger | |
| G4RawTowerTTree | |
| G4RootHitContainer | |
| G4RootRawTower | |
| G4RootRawTowerContainer | |
| G4RootScintillatorSlat | |
| G4RootScintillatorSlatContainer | |
| G4RootScintillatorTower | |
| G4RootScintillatorTowerContainer | |
| G4ScintillatorSlatTTree | |
| G4ScintillatorTowerTTree | |
| G4SnglNtuple | |
| G4SnglTree | |
| G4TBFieldMessenger | |
| G4TBMagneticFieldSetup | |
| G4TowerNtuple | |
| G4VPhysicalVolume | Mockup class |
| G4VtxNtuple | |
| G__cpp_setup_initDirectPhotonPythia_Dict | |
| G__cpp_setup_initExampleAnalysisModule_Dict | |
| G__cpp_setup_inithcalUtilDict | |
| G__cpp_setup_initRecoInfoExport_Dict | |
| G__cpp_setup_initSimpleTrackingAnalysis_Dict | |
| G__cpp_setup_initSTACalorimeterCharacterization_Dict | |
| G__Sizep2memfuncDirectPhotonPythia_Dict | |
| G__Sizep2memfuncExampleAnalysisModule_Dict | |
| G__Sizep2memfunchcalUtilDict | |
| G__Sizep2memfuncRecoInfoExport_Dict | |
| G__Sizep2memfuncSimpleTrackingAnalysis_Dict | |
| G__Sizep2memfuncSTACalorimeterCharacterization_Dict | |
| gamma_cut | |
| gauss_plugin | |
| GeneralElement | |
| GenericDetector | |
| Config | |
| GenericUnpackPRDF | |
| GenFitTrackProp | |
| GenHadron | |
| Get | |
| GL1_1_DATA | |
| GL1_2_DATA | |
| GL1_3_DATA | |
| GL1_EVENT_DATA | |
| GL1_TIME_STAMP | |
| GL1P_DATA | |
| Gl1RawHit | |
| Gl1RawHitv1 | |
| Glasma | |
| GlobalVertex | |
| GlobalVertexFastSimReco | Simple truth vertex smearing algorithm |
| GlobalVertexMap | |
| GlobalVertexMapv1 | |
| GlobalVertexReco | Simple truth vertex smearing algorithm |
| GlobalVertexv1 | |
| GlobalVertexv2 | |
| GML_error | Reason and position of an error in a GML file |
| GML_list_elem | |
| GML_pair | |
| GML_pair_val | |
| GML_stat | |
| GML_tok_val | |
| GML_token | |
| GMockOutputTest | |
| GPUTPCBaseTrackParam | |
| GPUTPCTrackLinearisation | |
| GPUTPCTrackParam | |
| GPUTPCTrackFitParam | |
| graph | A directed or undirected graph |
| grid_helper_impl | Helper struct to calculate number of bins inside a grid |
| groot | |
| GTL_debug | |
| GubserHydro | |
| gzbuffer | |
| gzstreambase | |
| gzstreambuf | |
| hadron_cut | |
| half | |
| uif | |
| halfFunction | |
| has_duplicates | |
| has_slots | |
| hash | |
| hcal | |
| hcal_towerid | |
| HCALAnalysis | |
| HCalCalibTree | |
| hcalHelper | |
| HCalib | |
| HCalJetPhiShift | |
| hcalLabTree | |
| HcalMon | |
| HcalMonDraw | |
| HcalRawTowerBuilder | |
| hcalTree | |
| hcalUtil | |
| HeadReco | |
| heap_node | |
| HelicalFitter | |
| helixResiduals | |
| HepMCCompress | |
| HepMCFlowAfterBurner | |
| HepMCNodeReader | |
| HFFastSim | |
| D02PiK | |
| Lc2pPiK | |
| HFJetTruthTrigger | |
| HFMLTriggerHepMCTrigger | |
| HFMLTriggerInterface | |
| HFMLTriggerOccupancy | |
| HFTrackEfficiency | |
| HFTrigger | |
| HFTriggerMVA | |
| hijbkg_upc | |
| HijCrdn | Class definition for HijCrdn, which is used to modify the Hijing HIJCRDN common |
| HIJCRDN | |
| HijingCountNtuple | |
| HIJINGFlipAfterburner | |
| HijingShowerSize | |
| HijJet1 | Class definition for HijJet1, which is used to modify the Hijing HIJJET1 common |
| HIJJET1 | |
| HijJet2 | Class definition for HijJet2, which is used to modify the Hijing HIJJET2 common |
| HIJJET2 | |
| HijJet4 | Class definition for HijJet4, which is used to modify the Hijing HIJJET4 common |
| HIJJET4 | |
| HiMain1 | Class definition for HiMain1, which is used to modify the Hijing HIMAIN1 common |
| HIMAIN1 | |
| HiMain2 | Class definition for HiMain2, which is used to modify the Hijing HIMAIN2 common |
| HIMAIN2 | |
| HiParnt | Class definition for HiParnt, which is used to modify the Hijing HIPARNT common |
| HIPARNT | |
| HiStrng | Class definition for HiStrng, which is used to modify the Hijing HISTRNG common |
| HISTRNG | |
| Hit | |
| HitCountEval | |
| HitCountNtuple | |
| Hits | |
| hLabHelper | |
| http_message | |
| HybridHadronization | |
| hadron_collection | |
| HHhadron | |
| HHparton | |
| parton_collection | |
| Hydro | |
| hydrofluidCell | |
| HydroFromFile | |
| Hydroinfo_MUSIC | |
| HydroinfoH5 | |
| HydroSourceJETSCAPE | |
| Hypercube | |
| IC | |
| ICGlauber | |
| ICGubser | |
| IClassifierReader | |
| igzstream | |
| IndexedSortHelper | |
| InitialFromFile | |
| InputFileHandler | |
| InsertCalib | |
| IntegerFunctionTest | |
| integral_type | |
| Interface | |
| InternalError | |
| InternalSurfaceBuilder | Mockup internal surface builder |
| InternalVolumeBuilder | Mockup internal surface builder |
| interpolate_impl | Helper struct for performing multi-dimensional linear interpolation |
| intt_pool | |
| intt_hit | |
| InttCheck | |
| InttClusterizer | |
| InttCombinedRawDataConverter | |
| InttCombinedRawDataDecoder | |
| InttDeadMap | |
| InttDeadMapv1 | |
| InttEventInfo | |
| InttEventInfov1 | |
| InttMap | |
| Offline_s | |
| OfflineComparator | |
| OfflineWildcardComparator | |
| Online_s | |
| OnlineComparator | |
| OnlineWildcardComparator | |
| RawData_s | |
| RawDataComparator | |
| RawDataWildcardComparator | |
| InttMaskedChannelSet | |
| InttMaskedChannelSetv1 | |
| InttMon | |
| InttMonDraw | |
| Option_s | |
| InttRawDataConverter | |
| InttRawDataDecoder | |
| InttRawHit | |
| InttRawHitContainer | |
| InttRawHitContainerv1 | |
| InttRawHitv1 | |
| InttSurveyMap | |
| InttSurveyMapv1 | |
| InttVertex | |
| InttVertexFinder | |
| InttVertexMap | |
| InttVertexMapv1 | |
| InttVertexv1 | |
| InvokeHelper | |
| IPGlasmaWrapper | |
| IsBaseAndDerived | |
| Host | |
| isoCluster | |
| IsolatedTrackAnalysis | |
| iSpectraSamplerWrapper | |
| IsReadOnlyMultiTrajectory | |
| IsReadOnlyMultiTrajectory | |
| IsReadOnlyTrackContainer | |
| IsReadOnlyTrackContainer | |
| IsStateFinal | This predicate returns true if the input has no decay vertex |
| IterJetv2TCA | |
| Jet | |
| IterJetTCA | |
| JetAlgo | |
| JetAnalysisUserInfo | |
| JetAnalyzer | |
| JetBkgdSub | |
| JetContainer | |
| JetContainerv1 | |
| JetDefinition | |
| DefaultRecombiner | |
| Plugin | |
| Recombiner | |
| JetEnergies | Compares reconstructed jets to truth jets |
| JetEvalStack | |
| JetEvaluator | Compares reconstructed jets to truth jets |
| JetHepMCLoader | JetHepMCLoader loads special jet objects encoded in HepMC records to DST Jet nodes. Example use are loading sHijing HIJFRG jets |
| hepmc_jet_src | |
| jetHistogrammer | |
| JetIndicesMatcher | |
| JetInput | |
| JetKinematicCheck | |
| JetMap | |
| JetMapv1 | |
| JetMultSub | Subtracts reco jets using multiplicity method |
| JetNconstituents | |
| JetProbeInput | |
| JetProbeMaker | |
| Deleter | |
| JetReco | Jet reco with user def inputs and algos |
| JetRecoEval | |
| JetRhoMedian | |
| jetrtrack | |
| JetScapeModuleComponentFactory | Factory for modules in the Jetscape framework |
| JetScapeXML | JetScape XML init reader class (meant as singleton) |
| JetSeedCount | |
| JetTruthEval | |
| JetUnderlyingEvent | |
| Jetv1 | Jetv1 |
| Jetv2 | Jetv2 |
| CompareSRC | |
| JetV2SortingCriteria | |
| JetValidation | |
| Json | Writes out Detector material maps using the Json Geometry converter |
| json_token | |
| KFEfficiencyParticleInfo | A helper class to define parameters of the decay list in KFPartEfficiencies |
| KFMCCounter | A helper structure to store information on the number of reconstructed and Monte Carlo particles for efficiency calculation |
| KFMCParticle | A class to store relations between mother and daughter Monte Carlo simulated particles |
| KFMCTrack | A class for storage of the Monte Carlo simulated track in the cartesian parametrisation |
| KFMCVertex | A class to store information about simulated Monte Carlo primary vertices |
| KFPartEfficiencies | Class to calculate efficiency of KF Particle Finder |
| KFParticle | The main scalar class of KF Particle package, describes particle objects |
| KFParticle_Container | KFParticle container object |
| KFParticle_DST | |
| KFParticle_eventReconstruction | |
| KFParticle_MVA | |
| KFParticle_nTuple | |
| KFParticle_sPHENIX | |
| KFParticle_Tools | |
| KFParticle_truthAndDetTools | |
| KFParticleBase | The base of KFParticle class, describes particle objects |
| KFParticleBaseSIMD | The base of KFParticleSIMD class |
| KFParticleDatabase | The class stores information about particle masses and expected width of the peacks |
| KFParticleFieldRegion | A class to store an approximation of the magnetic field along the particle trajectory. Is used for nonhomogeneous field |
| KFParticleFieldValue | A class to store a vector with the magnetic field values {Bx, By, Bz} at the certain point |
| KFParticleFinder | Class for reconstruction short-lived particles |
| KFParticlePVReconstructor | Class for reconstruction of primary vertices |
| KFParticleCluster | A helper structure for reconstruction of a primary vertex |
| KFParticleSIMD | The main vectorised class of KF Particle pacakge, describes particle objects |
| KFParticleTest | |
| KFParticleTopoReconstructor | Class for reconstruction of the full event topology including primary vertices and short-lived particles |
| KFPartMatch | A structure to store matching information between simulated Monte Carlo and reconstructed particles |
| KFPEmcCluster | A class to store vectors of input cluster from the electro-magnetic calorimeter |
| KFPHistogram | A common object containing histograms for all particle species |
| KFPHistogram1D | One-dimensional histogram |
| KFPHistogramSet | A set of histograms collected at the external devise |
| KFPInputData | Class with the input data for KF Particle Finder: tracks, primary vertex and magnetic field |
| KFPInputDataArray | Structure with the set of the input data for KF Particle Finder |
| KFPLinkedList | Structure to creat a linked list of the input data |
| KFPSimdAllocator | Allocator which is needed to allocate memory in std::vector aligned by the size of SIMD vectors |
| rebind | Rebind allocator to type U of the SIMD allocator |
| KFPTrack | A scalar class for storage of the track in the cartesian parametrisation |
| KFPTrackIndex | Helper structure to sort tracks in the KFPTrackVector object |
| KFPTrackVector | A class to store vectors of input tracks in the cartesian parametrisation |
| KFPVEfficiencies | Class to calculate efficiency of KF Particle Finder |
| KFPVertex | A scalar class for storage of the vertex in the cartesian parametrisation |
| KFVertex | Mathematics for reconstruction of primary vertices based on KFParticle |
| KshortReconstruction | |
| Langevin | |
| LaplaceSolution | |
| LazyTiling25 | |
| LazyTiling9 | |
| LazyTiling9Alt | |
| LBT | |
| LBTMutex | |
| LBTUserInfo | |
| LEDTowerBuilder | |
| lepton_cut | |
| Leptoquarks | |
| LeptoquarksReco | |
| less_dist | |
| Lifecycle | |
| Lifecycle< 0 > | |
| LifecycleCounters | |
| LifecycleHandle | |
| LightCollectionModel | |
| LimitedWarning | |
| lin_res | |
| Line | |
| linkId | |
| listEventiterator | |
| LiteCaloEval | |
| LL1HEADER | |
| LL1Mon | |
| LL1MonDraw | |
| loaderObj | |
| lzobuffer | |
| MakeActsGeometry | |
| MakeMilleFiles | |
| MakeSimpleTree | |
| MakeSourceLinks | |
| MapHelper | |
| Martini | |
| dGammas | |
| Gamma_info | |
| MartiniMutex | |
| MARTINIUserInfo | |
| MatcherTuple | |
| MaterialHistograms | |
| MatrixCache | |
| Matter | |
| maxflow_ff | Maximum flow algorithm (Edmonds-Karp) |
| maxflow_pp | Maximum flow algorithm (Malhotra, Kumar, Maheshwari) |
| maxflow_sap | Maximum flow algorithm with shortest augmenting paths |
| mbdAnalysis | |
| MbdCalib | |
| MbdDigitization | |
| MbdEvent | |
| MbdGeom | |
| MbdGeomV1 | |
| MbdOut | |
| MbdOutV1 | |
| MbdOutV2 | |
| MbdPmtContainer | |
| MbdPmtContainerV1 | |
| MbdPmtHit | |
| MbdPmtHitV1 | |
| MbdReco | |
| MbdSig | |
| MBDStudy | |
| MbdVertex | |
| MbdVertexFastSimReco | Simple truth vertex smearing algorithm |
| MbdVertexMap | |
| MbdVertexMapv1 | |
| MbdVertexv1 | |
| MbdVertexv2 | |
| mbuf | |
| MCPhoton | MCPhoton |
| md5_state_s | |
| MD5Context | |
| MessageSystem | |
| mg_add_sock_opts | |
| mg_bind_opts | |
| mg_cgi_env_block | |
| mg_connect_opts | |
| mg_connection | |
| mg_dns_header | |
| mg_dns_message | |
| mg_dns_resource_record | |
| mg_http_endpoint | |
| mg_http_multipart_part | |
| mg_http_multipart_stream | |
| mg_http_proto_data | |
| mg_http_proto_data_cgi | |
| mg_http_proto_data_chuncked | |
| mg_http_proto_data_file | |
| mg_mgr | |
| mg_mqtt_message | |
| mg_mqtt_topic_expression | |
| mg_resolve_async_opts | |
| mg_resolve_async_request | |
| mg_rpc_error | |
| mg_rpc_reply | |
| mg_rpc_request | |
| mg_send_mqtt_handshake_opts | |
| mg_serve_http_opts | |
| mg_str | |
| MicromegasCalibrationData | Micromegas calibration data |
| calibration_data_t | Simple structure to store calibration data |
| MicromegasClusterizer | Micromegas clusterizer |
| MicromegasCombinedDataDecoder | Micromegas raw data decoder |
| MicromegasCombinedDataEvaluation | Micromegas raw data decoder |
| Container | |
| Sample | |
| Waveform | |
| MicromegasGeometry | Handle simplified TPOT 2D geometry, for histogram representation |
| MicromegasHotChannelMapData | Micromegas calibration data |
| channel_id_t | Channel id |
| MicromegasMapping | Micromegas mapping |
| DetectorId | All relevant detector information |
| MicromegasRawDataCalibration | Micromegas raw data decoder |
| MicromegasRawDataDecoder | Micromegas raw data decoder |
| MicromegasRawDataEvaluation | Micromegas raw data decoder |
| Container | |
| Sample | |
| Waveform | |
| MicromegasRawHit | |
| MicromegasRawHitContainer | |
| MicromegasRawHitContainerv1 | |
| MicromegasRawHitv1 | |
| MicromegasTile | Header only class that contains information about a given Tile location inside CylinderGeom |
| Mille | Class to write C binary file |
| min_tree | Kruskal's algorithm for finding minimal spanning tree of a graph |
| input_comp | |
| MinHeap | |
| ValueLoc | |
| MinimumBiasClassifier | |
| MinimumBiasInfo | |
| MinimumBiasInfov1 | |
| mis | |
| miz_indgdef | |
| miz_irdgdef | |
| miz_subdef | |
| Mock | |
| MockFoo | |
| MockFunction | |
| MockNavigator | |
| MockTrack | |
| MockupsectorBuilder | |
| MomentumEvaluator | |
| MpiMusic | |
| MQTTConnection | |
| msg_buffer | |
| msg_control | |
| msgProfile | |
| multi_threaded_local | |
| MultiArray | |
| MultiDetectorMultiplicity | Definition of this analysis module class |
| MultiTrajectory | |
| MultivariateNormalDistribution | |
| MultiWireInternalStructureBuilder | |
| Config | |
| MvtxAlign | |
| AlignmentPar | |
| MvtxApplyHotDead | |
| MvtxClusterizer | Clusterizer for the MVTX |
| MvtxCombinedRawDataDecoder | Mvtx raw data decoder |
| MvtxEventInfo | |
| MvtxEventInfov1 | |
| MvtxEventInfov2 | |
| MvtxHitPruner | Clusterizer for the MVTX |
| MvtxMon | |
| linkId | |
| MvtxMonDraw | |
| MvtxPrototype2Align | |
| AlignmentPar | |
| MvtxPrototype2Clusterizer | Clusterizer for the MVTX |
| MvtxPrototype2Geom | |
| MvtxPrototype2UnpackPRDF | |
| MvtxQAHisto | |
| MvtxRawEvtHeader | |
| MvtxRawEvtHeaderv1 | |
| MvtxRawHit | |
| MvtxRawHitContainer | |
| MvtxRawHitContainerv1 | |
| MvtxRawHitv1 | |
| MvtxRunInfoUnpackPRDF | |
| MvtxStandaloneTracking | |
| MvtxTrack | |
| MvtxUnpackPRDF | |
| my_graph | |
| MyArray | |
| MyJetAnalysis | |
| MyMon | |
| MyMonDraw | |
| MySimpleTree | |
| MySourceLink | |
| MySQLConnectionPrivate | |
| MySQLParser | |
| MySQLPreparedStatementPrivate | |
| MySQLResultSetPrivate | |
| MyString | |
| MyTClonesArray | |
| MyType | |
| Navigation | |
| NavigationOptions | |
| NavigationOptions | |
| NcollListFromFile | |
| ne_map | Baseclass for node_map and edge_map |
| nested | |
| NNBase | |
| NNH | |
| NNBJ | |
| NNInfo | |
| NNInfo< _NoInfo > | |
| node | A node in a graph |
| node_data | |
| node_map | A specialized map with nodes as keys |
| noiDict | |
| noiGetter | |
| noiMsgTree | |
| noiPadDim | |
| noiPadDimSet | |
| noiPads | |
| noiPtrDbl | |
| noiWordIn | |
| noiWordOut | |
| NonContainer | |
| NonFatalFailureInFixtureConstructorTest | |
| NonFatalFailureInSetUpTest | |
| NullHelper | |
| NullPreDynamics | |
| O | |
| oamlBuffer | |
| oBuffer | |
| buffer_ptr | |
| ODBCCallableStatement | |
| ODBCConnection | |
| ODBCDatabaseMetaData | |
| ODBCPreparedStatement | |
| ODBCResultSet | |
| ODBCResultSetMetaData | |
| ODBCStatement | |
| odd_filter | |
| oEvent | |
| ogzBuffer | |
| ogzstream | |
| Ohit | |
| olzoBuffer | |
| OnCal | |
| OnCalDBodbc | |
| OnCalServer | |
| oncsBuffer | |
| buffer_ptr | |
| oncsEvent | |
| oncsEventiterator | |
| oncsevt_data | |
| oncsSub_id2evt | |
| oncsSub_id4evt | |
| oncsSub_idbspetdata | |
| oncsSub_idcaenv1742 | |
| oncsSub_idcaenv792 | |
| oncsSub_idcstr | |
| oncsSub_iddigitizerv1 | |
| oncsSub_iddreamv0 | |
| FEU_decoded_data | |
| oncsSub_iddrs4v1 | |
| oncsSub_idfnalmwpc | |
| SpillInfo | |
| TDC_hit | |
| TDCData | |
| TDCEvent | |
| TDCspillheader | |
| oncsSub_idfnalmwpcv2 | |
| SpillInfo | |
| TDC_hit | |
| TDCData | |
| TDCEvent | |
| TDCspillheader | |
| oncsSub_idgl1v0 | |
| oncsSub_idinttv0 | |
| intt_hit | |
| oncsSub_idmvtxv0 | |
| oncsSub_idmvtxv1 | |
| oncsSub_idmvtxv2 | |
| oncsSub_idmvtxv3 | |
| dumpEntry | |
| oncsSub_idrcpetdata | |
| oncsSub_idsis3300 | |
| oncsSub_idsis3300r | |
| oncsSub_idsrs_v01 | |
| hybriddata | |
| report | |
| oncsSub_idtpcfeev1 | |
| oncsSub_idtpcfeev2 | |
| tpc_sample | |
| oncsSub_idtpcfeev3 | |
| bco_compare | |
| gtm_payload | |
| sampa_waveform | |
| oncsSub_iduppetdata | |
| oncsSub_iduppetdata_v104 | |
| oncsSub_iduppetparams | |
| oncsSubevent | |
| oncsSubevent_w1 | |
| oncsSubevent_w2 | |
| oncsSubevent_w4 | |
| OneHit | |
| OnlBbcEvent | |
| OnlBbcSig | |
| OnlMon | |
| OnlMonBase | |
| OnlMonClient | |
| OnlMonDB | |
| OnlMonDBodbc | |
| OnlMonDBVar | |
| OnlMonDraw | |
| OnlMonHtml | |
| OnlMonServer | |
| OnlMonStatusDB | |
| OnTheFlyPrimeTable | |
| ophBuffer | |
| Options | |
| OracleParser | |
| ospBuffer | |
| ospEvent | |
| Output | |
| OwningDelegate | |
| P6DExtDecayerPhysics | |
| p_node | |
| Packet | |
| Packet_A | |
| Packet_cdevbpm | |
| Packet_cdevbuckets | |
| Packet_cdevdvm | |
| Packet_cdevir | |
| Packet_cdevmadch | |
| Packet_cdevpolarimeter | |
| Packet_cdevpoltarget | |
| Packet_cdevring | |
| Packet_cdevringnopol | |
| Packet_cdevwcm | |
| packet_data | |
| Packet_fvtx_dcm0 | |
| Packet_gl1 | |
| Packet_gl1_evclocks | |
| Packet_gl1p | |
| Packet_gl1psum | |
| Packet_hbd_fpga | |
| Packet_hbd_fpgashort | |
| Packet_id2evt | |
| Packet_id4evt | |
| Packet_id4scaler | |
| Packet_idcstr | |
| Packet_iddigitizerv2 | |
| Packet_iddigitizerv3 | |
| Packet_idll1v1 | |
| Packet_starscaler | |
| Packet_w1 | |
| Packet_w2 | |
| Packet_w4 | |
| PairMaker | |
| ParameterReader | |
| ParametersTraitsImpl | |
| ParameterTraitsImpl | |
| ParticleFlowElement | |
| ParticleFlowElementContainer | |
| ParticleFlowElementv1 | |
| ParticleFlowJetInput | |
| ParticleFlowReco | |
| ParticleInfo | Helper structure to clean particle spectra by competition of PDG hypothesis |
| ParticleReader | |
| parton | |
| PasswordDialog | |
| pathfinder | |
| const_iterator | |
| PdbApplication | |
| PdbBankID | |
| PdbBankList | |
| PdbBankListIterator | |
| PdbBankManager | |
| PdbCalBank | |
| PdbCalBankIterator | |
| PdbCalChan | |
| PdbClassMap | |
| PdbParameter | |
| PdbParameterError | |
| PdbParameterMap | |
| PdbParameterMapContainer | |
| PgPostApplication | |
| PgPostBankBackupLog | PgPostBankBackupLog |
| PgPostBankBackupManager | PgPostBankBackupManager |
| PgPostBankBackupStorage | PgPostBankBackupStorage |
| BankHeader | |
| PgPostBankManager | |
| PgPostBankWrapper | |
| PgPostBankWrapperManager | |
| PgPostCalBank | |
| PgPostCalBankIterator | |
| ValPeriod | |
| PGun | |
| PH3DVertexing | Base class for track seeding |
| PHActsGSF | |
| PHActsInitialVertexFinder | |
| PHActsKDTreeSeeding | |
| PHActsSiliconSeeding | |
| PHActsToSvtxTracks | |
| PHActsTrackProjection | |
| PHActsTrackPropagator | |
| PHActsTrkFitter | |
| PHActsVertexFinder | |
| PHActsVertexFitter | |
| PHActsVertexPropagator | |
| PHAJMaker | |
| PHAna | |
| PHBBox | |
| PHCASeeding | |
| PHCompositeNode | |
| PHCosmicSeedCombiner | |
| PHCosmicSeeder | |
| seed | |
| PHCosmicSiliconPropagator | |
| PHCosmicsTrkFitter | |
| PHCosmicTrackMerger | |
| PHDataNode | |
| tobjcast | |
| PHDataNodeIterator | |
| PhDi | |
| PHEvtGenRandomEngine | |
| PHField | Transient object for field storage and access |
| PHField2D | |
| PHField3DCartesian | |
| PHField3DCylindrical | |
| PHFieldConfig | PHFieldConfig store field configuration information |
| PHFieldConfigv1 | PHFieldConfigv1 implements field configuration information for input a field map file |
| PHFieldConfigv2 | PHFieldConfigv2 implements field configuration information for uniform field model |
| PHFieldUniform | |
| PHFieldUtility | Toolsets to do geometry operations |
| PHFlag | |
| PHFlowJetMaker | |
| PHG4BbcDetector | |
| PHG4BbcDisplayAction | |
| PHG4BbcSteppingAction | |
| PHG4BbcSubsystem | Fun4All module to simulate the BBC detector, aka MBD |
| PHG4BeamlineMagnetDetector | |
| PHG4BeamlineMagnetSubsystem | |
| PHG4BlockCellGeom | |
| PHG4BlockCellGeomContainer | |
| PHG4BlockCellReco | |
| PHG4BlockDetector | |
| PHG4BlockDisplayAction | |
| PHG4BlockGeom | |
| PHG4BlockGeomContainer | |
| PHG4BlockGeomv1 | |
| PHG4BlockSteppingAction | |
| PHG4BlockSubsystem | |
| PHG4Cell | |
| PHG4CellContainer | |
| PHG4Cellv1 | |
| u_property | Convert between 32bit inputs and storage type prop_storage_t |
| PHG4CEmcTestBeamDetector | |
| PHG4CEmcTestBeamSteppingAction | |
| PHG4CEmcTestBeamSubsystem | |
| PHG4CentralityReco | |
| PHG4ConeDetector | |
| PHG4ConeDisplayAction | |
| PHG4ConeSteppingAction | |
| PHG4ConeSubsystem | |
| PHG4ConsistencyCheck | |
| PHG4CylinderCell | |
| PHG4CylinderCellContainer | |
| PHG4CylinderCellGeom | |
| PHG4CylinderCellGeom_Spacalv1 | PHG4CylinderCellGeom_Spacalv1 |
| PHG4CylinderCellGeomContainer | |
| PHG4CylinderCellReco | |
| PHG4CylinderCellv1 | |
| PHG4CylinderCellv2 | |
| PHG4CylinderCellv3 | |
| PHG4CylinderDetector | |
| PHG4CylinderDisplayAction | |
| PHG4CylinderGeom | |
| PHG4CylinderGeom_Spacalv1 | |
| PHG4CylinderGeom_Spacalv2 | |
| PHG4CylinderGeom_Spacalv3 | |
| geom_tower | |
| scint_id_coder | Compact ID of each fiber in 32bit PHG4Hit::set_scint_id(). Buffer the result for repeated use |
| PHG4CylinderGeomContainer | |
| PHG4CylinderGeomv1 | |
| PHG4CylinderGeomv2 | |
| PHG4CylinderGeomv3 | |
| PHG4CylinderGeomv4 | |
| PHG4CylinderSteppingAction | |
| PHG4CylinderSubsystem | |
| PHG4Detector | Base class for phenix detector creation |
| PHG4DetectorGroupSubsystem | |
| PHG4DetectorSubsystem | |
| PHG4DisplayAction | |
| PHG4DstCompressReco | |
| PHG4DSTReader | PHG4DSTReader save information from DST to an evaluator, which could include hit. particle, vertex, towers and jet (to be activated) |
| record | |
| PHG4EICMvtxDetector | |
| PHG4EICMvtxSteppingAction | |
| PHG4EICMvtxSubsystem | |
| PHG4EnvelopeDetector | |
| PHG4EnvelopeSteppingAction | |
| PHG4EnvelopeSubsystem | |
| PHG4EPDDetector | |
| PHG4EPDDisplayAction | |
| PHG4EPDModuleReco | |
| PHG4EPDSteppingAction | |
| PHG4EPDSubsystem | |
| PHG4EtaParameterization | |
| PHG4EtaPhiParameterization | |
| PHG4EventAction | |
| PHG4EventActionClearZeroEdep | |
| PHG4EventHeader | |
| PHG4EventHeaderv1 | |
| PHG4FullProjSpacalCellReco | |
| PHG4FullProjSpacalDetector | |
| PHG4FullProjTiltedSpacalDetector | Fully projective SPACAL built from 2D tapered modules and allow azimuthal tilts |
| PHG4GDMLAuxStructType | |
| PHG4GDMLConfig | PHG4GDMLConfig |
| PHG4GDMLDetector | PHG4GDMLDetector is a generic detector built from a GDML import |
| PHG4GDMLSubsystem | PHG4GDMLSubsystem is a generic detector built from a GDML import |
| PHG4GDMLUtility | PHG4GDMLUtility is utility class that drive the PHG4GDMLWriteStructure |
| PHG4GDMLWrite | |
| PHG4GDMLWriteDefine | |
| PHG4GDMLWriteMaterials | |
| PHG4GDMLWriteParamvol | |
| PHG4GDMLWriteSetup | |
| PHG4GDMLWriteSolids | |
| G4ThreeVectorCompare | |
| PHG4GDMLWriteStructure | |
| PHG4GenHit | |
| PHG4HcalCellReco | |
| PHG4HcalDetector | |
| PHG4HcalPrototypeDetector | |
| PHG4HcalPrototypeDetectorMessenger | |
| PHG4HcalPrototypeSteppingAction | |
| PHG4HcalPrototypeSubsystem | |
| PHG4HcalSteppingAction | |
| PHG4HcalSubsystem | |
| PHG4HeadReco | |
| PHG4Hit | |
| PHG4HitContainer | |
| PHG4HitEval | PHG4HitEval for evaluating PHG4Hitv1 in CINT readable evaluation trees |
| PHG4HitReadBack | |
| PHG4Hitv1 | |
| u_property | Convert between 32bit inputs and storage type prop_storage_t |
| PHG4IHCalDetector | |
| PHG4IHCalDisplayAction | |
| PHG4IHCalSteppingAction | |
| PHG4IHCalSubsystem | |
| PHG4InEvent | |
| PHG4InEventCompress | |
| PHG4InEventReadBack | |
| PHG4InnerHcalDetector | |
| PHG4InnerHcalDisplayAction | |
| PHG4InnerHcalSteppingAction | |
| PHG4InnerHcalSubsystem | |
| PHG4InputFilter | |
| PHG4InttDeadMapLoader | PHG4InttDeadMapLoader loads dead map at inti run |
| PHG4InttDetector | |
| PHG4InttDigitizer | |
| PHG4InttDisplayAction | |
| PHG4InttFPHXParameterisation | |
| PHG4InttHitReco | |
| PHG4InttSteppingAction | |
| PHG4InttSubsystem | |
| PHG4IonGun | |
| PHG4MagneticField | PHG4MagneticField interfaces with Geant4 |
| PHG4MicromegasDetector | |
| PHG4MicromegasDigitizer | |
| Deleter | Rng de-allocator |
| PHG4MicromegasDisplayAction | |
| PHG4MicromegasHitReco | |
| Deleter | Rng de-allocator |
| PHG4MicromegasSteppingAction | |
| PHG4MicromegasSubsystem | Detector Subsystem module The detector is constructed and registered via PHG4MicromegasDetector |
| PHG4MicromegasSurvey | |
| tile_id_hash_t | |
| tile_id_t | Internal detector definition (tile number, detector) |
| transformation_t | |
| PHG4MvtxCable | |
| PHG4MvtxDetector | |
| PHG4MvtxDigitizer | |
| PHG4MvtxDisplayAction | |
| PHG4MvtxHitReco | |
| Deleter | |
| PHG4MvtxSteppingAction | |
| PHG4MvtxSubsystem | |
| PHG4MvtxSupport | |
| PHG4OHCalDetector | |
| PHG4OHCalDisplayAction | |
| PHG4OHCalFieldSetup | PHG4OHCalFieldSetup following Geant4 example F03FieldSetup |
| PHG4OHCalSteppingAction | |
| PHG4OHCalSubsystem | |
| PHG4OuterHcalDetector | |
| PHG4OuterHcalDisplayAction | |
| PHG4OuterHcalField | PHG4OuterHcalField |
| PHG4OuterHcalFieldSetup | PHG4OuterHcalFieldSetup following Geant4 example F03FieldSetup |
| PHG4OuterHcalSteppingAction | |
| PHG4OuterHcalSubsystem | |
| PHG4Particle | |
| PHG4ParticleGenerator | |
| PHG4ParticleGeneratorBase | |
| PHG4ParticleGeneratorD0 | |
| PHG4ParticleGeneratorVectorMeson | |
| PHG4ParticleGun | |
| PHG4ParticleSvtxMap | |
| PHG4ParticleSvtxMap_v1 | |
| PHG4Particlev1 | |
| PHG4Particlev2 | |
| PHG4Particlev3 | |
| PHG4PhenixDetector | This is the main detector construction class, passed to geant to construct the entire phenix detector |
| PHG4PhenixDisplayAction | |
| PHG4PhenixEventAction | |
| PHG4PhenixStackingAction | |
| PHG4PhenixSteppingAction | |
| PHG4PhenixTrackingAction | |
| PHG4PileupGenerator | |
| PHG4PrimaryGeneratorAction | |
| PHG4Prototype2HcalCellReco | |
| PHG4Prototype2InnerHcalDetector | |
| PHG4Prototype2InnerHcalSteppingAction | |
| PHG4Prototype2InnerHcalSubsystem | |
| PHG4Prototype2OuterHcalDetector | |
| PHG4Prototype2OuterHcalSteppingAction | |
| PHG4Prototype2OuterHcalSubsystem | |
| PHG4Prototype3InnerHcalDetector | |
| PHG4Prototype3InnerHcalSteppingAction | |
| PHG4Prototype3InnerHcalSubsystem | |
| PHG4PSTOFDetector | |
| PHG4PSTOFSteppingAction | |
| PHG4PSTOFSubsystem | Fun4All module to simulate the Barrel PSTOF detector |
| PHG4Reco | Runs G4 as a subsystem |
| PHG4RegionInformation | |
| PHG4ScintillatorSlat | |
| PHG4ScintillatorSlatContainer | |
| PHG4ScintillatorSlatv1 | |
| PHG4ScoringManager | PHG4ScoringManager is the connection between Fun4All to G4ScoringManager Track primitive score like flux or energy deposition integrated over events and save to histograms More on G4ScoringManager see Manual http://geant4-userdoc.web.cern.ch/geant4-userdoc/UsersGuides/ForApplicationDeveloper/BackupVersions/V9.6/html/ch04s08.html And talk http://geant4.slac.stanford.edu/JLAB2012/Scoring1.pdf |
| PHG4SectorDetector | |
| PHG4SectorDisplayAction | |
| PHG4SectorSteppingAction | |
| PHG4SectorSubsystem | |
| PHG4Shower | |
| PHG4Showerv1 | |
| PHG4SimpleEventGenerator | |
| PHG4SpacalDetector | |
| PHG4SpacalDisplayAction | |
| PHG4SpacalPrototype4Detector | |
| PHG4SpacalPrototype4SteppingAction | |
| PHG4SpacalPrototype4Subsystem | |
| PHG4SpacalPrototypeDetector | |
| PHG4SpacalPrototypeSteppingAction | |
| PHG4SpacalPrototypeSubsystem | |
| PHG4SpacalSteppingAction | |
| PHG4SpacalSubsystem | |
| PHG4StackingAction | |
| PHG4SteppingAction | |
| PHG4Subsystem | |
| PHG4TpcCentralMembrane | |
| PHG4TpcCylinderGeom | |
| PHG4TpcCylinderGeomContainer | |
| PHG4TpcDetector | |
| PHG4TpcDigitizer | |
| PHG4TpcDirectLaser | |
| Laser | Stores laser position and direction along z |
| PHG4TpcDisplayAction | |
| PHG4TpcDistortion | Handle distortions (static and time-ordered) |
| PHG4TpcElectronDrift | |
| Deleter | Rng de-allocator |
| PHG4TpcEndCapDetector | |
| PHG4TpcEndCapDisplayAction | |
| PHG4TpcEndCapSteppingAction | |
| PHG4TpcEndCapSubsystem | Detector Subsystem module |
| PHG4TpcPadBaselineShift | |
| PHG4TpcPadPlane | |
| PHG4TpcPadPlaneReadout | |
| PHG4TpcSteppingAction | |
| PHG4TpcSubsystem | |
| PHG4TrackFastSim | |
| PHG4TrackFastSimEval | |
| PHG4TrackingAction | |
| PHG4TrackUserInfoV1 | |
| PHG4TruthEventAction | |
| PHG4TruthInfoContainer | |
| PHG4TruthSubsystem | |
| PHG4TruthTrackingAction | |
| G4ParticleInfo | |
| PHG4UIsession | |
| PHG4UserPrimaryParticleInformation | |
| PHG4Utils | |
| PHG4VertexSelection | |
| PHG4VtxPoint | |
| PHG4VtxPointv1 | |
| PHG4ZDCDetector | |
| PHG4ZDCDisplayAction | |
| PHG4ZDCSteppingAction | |
| PHG4ZDCSubsystem | |
| PHGenericFactoryT | |
| ProductCreatorPair | |
| PHGenFitTrackProjection | Projects into calorimeters and fills track cal fields |
| PHGenFitTrkFitter | Refit SvtxTracks with PHGenFit |
| PHGenIntegral | PHGenIntegral |
| PHGenIntegralv1 | PHGenIntegralv1 |
| PHGeomFileImport | Fun4All module to import TGeo ROOT Geometry at run time |
| PHGeomIOTGeo | PHGeomIOTGeo store geometry information to DST files in the format of binary streamed TGeoVolume. It completely owns the geometry object For run-time use of TGeoManager, please use PHGeomTGeo For operation of this class with DST node, please use PHGeomUtility |
| PHGeomTGeo | PHGeomTGeo provide run-time access to TGeoManger. It is transient object and it shall NOT be saved to DST. For DST storage, please use PHGeomIOTGeo For operation of this class with DST node, please use PHGeomUtility |
| PHGeomUtility | Toolsets to do geometry operations |
| PHGhostRejection | |
| PHHepMCGenEvent | |
| PHHepMCGenEventMap | PHHepMCGenEventMap is collection of HEPMC events input into this simulation map of embedding ID -> PHHepMCGenEvent positive ID is the embedded event of interest, e.g. jetty event from pythia negative IDs are backgrounds, .e.g out of time pile up collisions Usually, ID = 0 means the primary Au+Au collision background |
| PHHepMCGenEventv1 | |
| PHHepMCGenHelper | PHHepMCGenHelper provides service of DST upload of HepMC subevent, vertex assignment and random generator |
| PHHepMCParticleSelectorDecayProductChain | |
| PHHybridSeeding | |
| PHInitVertexing | Base class for inital vertexing |
| PHIODataNode | |
| PHIOManager | |
| PHLog | |
| PHmd5Value | |
| PHMicromegasTpcTrackMatching | |
| PHNode | |
| PHNodeDump | |
| PHNodeIntegrate | |
| PHNodeIOManager | |
| PHNodeIterator | |
| PHNodeOperation | |
| PHNodeReset | |
| PHObject | |
| PhotonJet | |
| PhotonPair | PhotonPair |
| Photons | |
| PHParameterContainerInterface | |
| PHParameterInterface | |
| PHParameters | |
| PHParametersContainer | |
| PHPointerList | |
| PHPointerListIterator | |
| PHPy6ForwardElectronTrig | |
| PHPy6GenTrigger | |
| PHPy6JetTrigger | |
| PHPy6ParticleTrigger | |
| PHPy8GenTrigger | |
| PHPy8JetTrigger | |
| PHPy8ParticleTrigger | |
| PHPythia6 | |
| PHPythia8 | |
| PHRandomSeed | |
| PHRaveVertexFactory | |
| PHRaveVertexing | Refit SvtxTracks with PHGenFit |
| PHRawDataNode | |
| PHRawOManager | |
| PHSartre | |
| PHSartreGenTrigger | |
| PHSartreParticleTrigger | |
| PHSiliconHelicalPropagator | |
| PHSiliconSeedMerger | |
| PHSiliconTpcTrackMatching | |
| PHSiliconTruthTrackSeeding | Vertexing using truth info |
| PHSimpleKFProp | |
| KDPointCloud | |
| PHSimpleVertexFinder | |
| PHTFileServer | TFile clean handling. It allow independant classes to access the same TFile and write ntuple to it. TFiles get written only when as many write request are achieved as open request. It get closed when the server is deleted |
| SafeTFile | Local class to store TFile and counter |
| PHTimer | |
| Frequency | Internal frequency read from cpu information file |
| time_struct | Used to store high precision time using two integers |
| PHTimeServer | PHTimer server for accessing external information |
| iterator | Light iterator over PHTimer map |
| timer | Wrapper around PHTimer, for storage in a map |
| PHTimeStamp | |
| PHTpcCentralMembraneClusterizer | |
| PHTpcCentralMembraneMatcher | |
| PHTpcClusterMover | |
| PHTpcDeltaZCorrection | |
| PHTpcResiduals | |
| PHTpcTrackSeedCircleFit | |
| PHTrackCleaner | |
| PHTrackClusterAssociator | |
| PHTrackFitting | Base class for track seeding |
| PHTrackPropagating | Base class for track seeding |
| PHTrackSeeding | Base class for track seeding |
| PHTrackSelector | |
| PHTrackSetCopyMerging | |
| PHTrackSetMerging | Base class for track seeding |
| PHTruthClustering | |
| PHTruthSiliconAssociation | |
| Deleter | Rng de-allocator |
| PHTruthTrackSeeding | Vertexing using truth info |
| Deleter | Rng de-allocator |
| PHTruthVertexing | Vertexing using truth info |
| PHTypedNodeIterator | |
| physics_list_impl | |
| pi0ClusterAna | |
| pi0Efficiency | |
| pi0EtaByEta | |
| Pi0MassAnalysis | |
| PidCandidate | |
| PidCandidatev1 | |
| u_property | Convert between 32bit inputs and storage type prop_storage_t |
| PidInfo | |
| PidInfo_RICH_v1 | |
| PidInfoContainer | |
| PIDplots | |
| PIDProbabilities | |
| PJContainer | |
| PJTranslator | |
| PktSizeDBodbc | |
| PktSizeMon | |
| PktSizeMonDraw | |
| planar_embedding | Ordered adjacency lists as a result of planarity testing |
| planarity | Tests if a graph can be drawn on a plane without any edge crossings |
| PlaneSurfaceBuilder | Construct a plane at track position with plane normal along track tangent |
| pmonstate | |
| pMutex | |
| Poisson | |
| Polygon | |
| Polyhedron | |
| PomsMainFrame | |
| PostgreSQLParser | |
| pq_leaf | |
| pq_node | |
| pq_tree | PQ-Trees |
| prdfBuffer | |
| buffer_ptr | |
| prdffile | |
| prdfoStream | |
| buffer_ptr | |
| PreCalculatedPrimeTable | |
| PredFormatFunctor1 | |
| PredFormatFunctor2 | |
| PredFormatFunctor3 | |
| PredFormatFunctor4 | |
| PredFormatFunctor5 | |
| PredFunctor1 | |
| PredFunctor2 | |
| PredFunctor3 | |
| PredFunctor4 | |
| PredFunctor5 | |
| Predicate1Test | |
| Predicate2Test | |
| Predicate3Test | |
| Predicate4Test | |
| Predicate5Test | |
| PrimeTable | |
| PrimeTableTest | |
| PrintTowers | |
| PrivateCode | |
| PropertyOne | |
| PropertyRecordingTest | |
| PropertyTwo | |
| ProtectedFixtureMethodsTest | |
| Proto2ShowerCalib | |
| Eval_Cluster | |
| Eval_Run | |
| HCAL_shower | |
| Time_Samples | |
| Proto3ShowerCalib | |
| Eval_Cluster | |
| Eval_Run | |
| HCAL_shower | |
| Scientillators | |
| Time_Samples | |
| Proto4SampleFrac | You get started |
| Proto4ShowerCalib | You get started |
| Eval_Cluster | |
| Eval_Run | |
| HCAL_Tower | |
| Proto4TowerCalib | You get started |
| HCAL_Tower | |
| Prototype2_DSTReader | |
| Prototype2DSTReader | Prototype2DSTReader save information from DST to an evaluator, which could include hit. particle, vertex, towers and jet (to be activated) |
| record | |
| Prototype2RawTowerBuilder | |
| Prototype3DSTReader | Prototype3DSTReader save information from DST to an evaluator, which could include hit. particle, vertex, towers and jet (to be activated) |
| record | |
| Prototype4DSTReader | Prototype4DSTReader save information from DST to an evaluator, which could include hit. particle, vertex, towers and jet (to be activated) |
| record | |
| PseudoJet | |
| InexistentUserInfo | |
| UserInfoBase | |
| PseudoJetPlus | |
| PseudoJetPlusUserInfoBase | |
| PseudoJetPlusUserInfoTrack | |
| PseudoJetStructureBase | |
| pseudoRunningMean | |
| psTOFTimezeroEval | Compares reconstructed tracks to truth particles |
| PtErrorAccessor | |
| PtResidualAccessor | This the dedicted pT residual accessor |
| pulserTriggerHandler | |
| Pydat1_t | PYDAT1 common-block |
| Pydat3_t | PYDAT3 common-block |
| Pyjets_t | PYJETS common-block |
| Pythia6 | |
| Pythia6Particle | Structure for Pythia6 particle properties |
| pythiaEMCalAna | |
| PythiaGun | |
| q_node | |
| QAG4Decayer | |
| QAG4SimulationCalorimeter | |
| QAG4SimulationCalorimeterSum | |
| QAG4SimulationDistortions | |
| QAG4SimulationIntt | |
| QAG4SimulationJet | |
| QAG4SimulationKFParticle | |
| QAG4SimulationMicromegas | |
| QAG4SimulationMvtx | |
| QAG4SimulationTpc | |
| QAG4SimulationTracking | |
| QAG4SimulationTruthDecay | |
| QAG4SimulationUpsilon | |
| QAG4SimulationVertex | |
| Qhit | |
| QopResidualAccessor | |
| QPileUp | |
| QPileUpToy | |
| QuantityAbsEta | |
| QuantityAbsRap | |
| QuantityBase | |
| QuantityE | |
| QuantityEt2 | |
| QuantityEta | |
| QuantityM2 | |
| QuantityPt2 | |
| QuantityRap | |
| QuantitySquareBase | |
| Quarkonia2LeptonsMC | |
| Queue | |
| QueueNode | |
| QueueTest | |
| quickHIJING | |
| QuickTest | |
| Quiver | |
| RandomConeAna | |
| RanSeed | Class definition for RanSeed, which is used to modify the Hijing RANSEED common |
| RANSEED | |
| RateConversion | |
| RateElastic | |
| RateRadiative | |
| ratio_cut_partition | Heuristic graph bi-partitioning algorithm (Wei-Cheng) |
| RawCluster | |
| RawClusterBuilderGraph | |
| RawClusterBuilderTemplate | |
| RawClusterBuilderTopo | |
| RawClusterContainer | |
| RawClusterDeadHotMask | |
| RawClusterPositionCorrection | |
| RawClusterUtility | RawClusterUtility |
| RawClusterv1 | |
| u_property | Convert between 32bit inputs and storage type prop_storage_t |
| RawClusterZVertexRecorrect | |
| RawHit | Base class for hit object |
| RawHitSet | Container for storing RawHit's |
| RawHitSetContainer | |
| RawHitSetContainerv1 | |
| RawHitSetv1 | |
| RawHitTpc | Base class for hit object |
| RawHitv1 | Base class for hit object |
| RawTower | |
| RawTower_Prototype2 | |
| RawTower_Prototype3 | |
| RawTower_Prototype4 | |
| RawTower_Temperature | |
| RawTowerBuilder | |
| RawTowerBuilderByHitIndex | SubsysReco module creating calorimeter tower objects (RawTowerv1) from hits (PHG4Hit) using j,k indeces of these hits |
| RawTowerCalibration | |
| RawTowerCombiner | RawTowerCombiner module that joints multiple RawTower together to form a single readout in a separate node Use this class to simulate ganged readout or trigger channels that combined multiple towers Should be called after RawTowerBuilder but before RawTowerDigitizer |
| RawTowerContainer | |
| RawTowerDeadMap | |
| RawTowerDeadMapv1 | |
| RawTowerDeadTowerInterp | RawTowerDeadTowerInterp recovers the energy in the known dead towers with interpolation between alive towers near-by |
| RawTowerDigitizer | |
| RawTowerGeom | |
| RawTowerGeomContainer | Base class to describe calorimeter geometries |
| RawTowerGeomContainer_Cylinderv1 | With additional description to conveniently use in central calorimeter with eta-phi bins |
| RawTowerGeomContainerv1 | Generic tower geometry class, store each tower's geometry individually |
| RawTowerGeomv1 | |
| RawTowerGeomv2 | |
| RawTowerGeomv3 | |
| RawTowerGeomv4 | |
| RawTowerv1 | |
| RawTowerv2 | RawTowerv1 but allow flexible tags |
| rcdaqEventiterator | |
| RCDAQPlugin | |
| RDBCBench | |
| ReactionPlaneAfterburner | |
| ReadBDT | |
| ReadBDTG | |
| ReadCalib | |
| ReadCuts | |
| ReadDataHandle | |
| readDigitalCurrents | |
| ReadEICFiles | |
| ReadFisher | |
| ReadLD | |
| ReadLikelihoodD | |
| ReadMLPnew | |
| ReadSynRadFiles | |
| RealQuadradicEquation | |
| recoConsts | |
| RecoConversionEval | |
| RecoInfoExport | |
| RecoTrackInfo | |
| RecursiveMomentumContainer | |
| RecursiveMomentumContainerEnd | |
| RefMatcher | |
| Region | |
| remote_msg_buffer | |
| ResidualAccessor | |
| ResidualOutlierFinder | |
| ResidualPullHandle | |
| ResonanceJetTagging | Definition of this analysis module class |
| RetowerCEMC | Creates 0.1x0.1-towerized CEMC container |
| RhoFluct | |
| richChannelList | |
| RICHEvaluator | |
| RICHParticleID | |
| rootfile | |
| Rossegger | |
| rPad | |
| RunDBodbc | |
| RunHeader | |
| RunHeaderv1 | |
| RunInfoUnpackPRDF | |
| channel_info | |
| runningMean | |
| RunToTime | |
| RunToTimePg | |
| RunTowerInfo | Definition of this analysis module class |
| SameSizeTuplePrefixComparator | |
| SaveTowerInfo | Definition of this analysis module class |
| Scatterering | |
| sChargeMap | |
| SDeltaPtCutStudy | |
| sdm | |
| sdm_c_blockdef | |
| SearchTree | |
| circulator | |
| const_circulator | |
| Node | |
| sebAlignBlk | |
| SecondaryVertexFinder | |
| seedComparator | |
| SegmentationAlpide | |
| Selector | |
| InvalidArea | |
| InvalidWorker | |
| selector_list_impl | |
| SelectorChargeWorker | |
| SelectorDijetWorker | |
| SelectorWorker | |
| SeparateDelegate | |
| SepdMon | |
| SepdMonDraw | |
| SequenceTestingListener | |
| SetupDualRICHAnalyzer | |
| shared_ptr | |
| SharedPtr | |
| __SharedCountingPtr | |
| sHelix | |
| sHEPGen | |
| Shifter | |
| shower | |
| shower2 | |
| ShowerSize | |
| SigmaTimingNtuple | |
| SignatureTest | |
| SIGSLOT_DEFAULT_MT_POLICY | |
| SIGTERMhandler | |
| simpleRandom | |
| SimpleTrackingAnalysis | |
| SimX | |
| sinfo | Information on a given surface |
| SingleGl1PoolInput | |
| SingleHandle | This is a s |
| SingleInttPoolInput | |
| SingleMicromegasPoolInput | |
| bco_alignment_t | Keep track of matching between fee and gtm_bco |
| SingleMvtxPoolInput | |
| singlePhotonClusterAna | |
| SinglePrdfInput | |
| PacketInfo | |
| SingleStreamingInput | |
| SingleTpcPoolInput | |
| SingleZdcInput | |
| PacketInfo | |
| SmashWrapper | |
| socket_address | |
| SoftLeptonTaggingTruth | |
| sort_IntDoubleByDouble | |
| SpacePoint | |
| SpacePoint4SSVFT | SpacePoint definition to be used for the unit tests. Implements all the relevant methods |
| Span | |
| SpectrRatio | |
| SpectrResp | |
| sPHAnalysis | |
| sPHAnalysis_calo | |
| sPHElectron | |
| sPHElectronPair | |
| sPHElectronPairContainer | |
| sPHElectronPairContainerv1 | |
| sPHElectronPairv1 | |
| sPHElectronv1 | |
| sPHENIXActsDetectorElement | |
| SphenixClient | |
| sPHENIXTrackFitterFunctionImpl | |
| Square | |
| st_number | ST-number algorithm |
| STACalorimeterCharacterization | |
| stack | |
| StaticAssertTypeEqHelper | |
| StaticAssertTypeEqTestHelper | |
| Stopwatch | |
| STrackCutStudy | |
| STrackMatcherComparator | |
| Consts | |
| STrackMatcherComparatorConfig | |
| STrackMatcherComparatorHistContent | |
| STrackMatcherComparatorHistDef | |
| StrawSelector | |
| StreamableInGlobal | |
| StreamingCheck | |
| strless | |
| Sub1rhoA | |
| subevt_data | |
| SubjetIndices | |
| SubjetIndicesv1 | |
| SubsysReco | |
| SubSystem | |
| SubSystemAction | |
| SubSystemActionDraw | |
| SubSystemActionDrawHtml | |
| SubSystemActionDrawPS | |
| SubSystemActionSavePlot | |
| SubSystemActionShowCanvases | |
| SubSystemActionTileCanvases | |
| Subtractor | |
| SubtractTowers | Creates new UE-subtracted towers |
| SubtractTowersCS | Creates new UE-subtracted towers |
| SuccessfulTest | |
| SurfaceBuilder | |
| SurfaceFinder | |
| SurfaceGeoIdGenerator | |
| SVReco | Find secondary vertex from track pairs and refit SvtxTracks with PHGenFit |
| SvtxAlignmentState | |
| SvtxAlignmentState_v1 | |
| SvtxAlignmentStateMap | |
| SvtxAlignmentStateMap_v1 | |
| SvtxClusterEval | |
| SvtxEvalStack | |
| SvtxEvaluator | Compares reconstructed tracks to truth particles |
| SvtxEvaluatorHaiwang | Compares reconstructed tracks to truth particles |
| SvtxHitEval | |
| SvtxPHG4ParticleMap | |
| SvtxPHG4ParticleMap_v1 | |
| SvtxSimPerformanceCheckReco | |
| SvtxTrack | |
| SvtxTrack_FastSim | |
| SvtxTrack_FastSim_v1 | |
| SvtxTrack_FastSim_v2 | |
| SvtxTrack_FastSim_v3 | |
| SvtxTrack_v1 | |
| SvtxTrack_v2 | |
| SvtxTrack_v3 | |
| SvtxTrack_v4 | |
| SvtxTrackCaloClusterMap | |
| SvtxTrackCaloClusterMap_v1 | |
| SvtxTrackEval | |
| SvtxTrackInfo | |
| SvtxTrackInfo_v1 | |
| SvtxTrackMap | |
| SvtxTrackMap_v1 | |
| SvtxTrackMap_v2 | |
| SvtxTrackSeed_v1 | |
| SvtxTrackSeed_v2 | |
| SvtxTrackState | |
| SvtxTrackState_v1 | |
| SvtxTrackState_v2 | |
| SvtxTrackStateRemoval | |
| SvtxTruthEval | |
| SvtxTruthRecoTableEval | |
| SvtxVertex | |
| SvtxVertex_v1 | |
| SvtxVertex_v2 | |
| SvtxVertexEval | |
| SvtxVertexMap | |
| SvtxVertexMap_v1 | |
| SW_AbsRapMax | |
| SW_AbsRapRange | |
| SW_And | |
| SW_BinaryOperator | |
| SW_Circle | |
| SW_Doughnut | |
| SW_Identity | |
| SW_IsZero | |
| SW_Mult | |
| SW_NHardest | |
| SW_Not | |
| SW_Or | |
| SW_PhiRange | |
| SW_PtFractionMin | |
| SW_QuantityMax | |
| SW_QuantityMin | |
| SW_QuantityRange | |
| SW_RapMax | |
| SW_RapMin | |
| SW_RapPhiRange | |
| SW_RapRange | |
| SW_Rectangle | |
| SW_Strip | |
| SW_WithReference | |
| symlist | List which can be reversed in  |
| symlist_iterator | |
| symnode | |
| SyncObject | |
| SyncObjectv1 | |
| SyncReco | |
| SynRadAna | |
| TDirectoryHelper | |
| tecChannelList | |
| TemperatureCorrection | |
| TempInfoUnpackPRDF | |
| TemplateCreation | |
| temporary_path | |
| TEST_before_TEST_F_in_same_test_case | |
| TEST_F_before_TEST_in_same_test_case | |
| TestCase | |
| testEventiterator | |
| TestHostCuts | Custom selection cuts for the test, used on the host |
| TestingVector | |
| TestListener | |
| TestOutlierFinder | |
| TestReverseFilteringLogic | |
| TestSpacePoint | Simple spacepoint implementation for the test |
| ThermalPartonSampler | |
| threadargument | |
| Tile | |
| Tile2Base | |
| TiledJet | |
| tileHelper | |
| eventtilesummary | |
| runtilesummary | |
| tileLightYield | |
| tileTree | |
| TilingExtent | |
| TimerStats | |
| TimingNtuple | |
| Tokenizer | |
| topsort | Topological sorting |
| tower | |
| TowerBackground | |
| TowerBackgroundv1 | |
| TowerGeom | |
| towerid | |
| TowerInfo | |
| TowerInfoContainer | |
| TowerInfoContainerv1 | |
| TowerInfoContainerv2 | |
| TowerInfoContainerv3 | |
| TowerInfoDeadHotMask | |
| TowerInfov1 | |
| TowerInfov2 | |
| TowerInfov3 | |
| TowerJetInput | |
| TowerTiming | |
| tpc_hits | |
| tpc_pool | |
| bco_compare | |
| gtm_payload | |
| sampa_waveform | |
| TPC_RawHit | TPC raw hit class |
| TpcCheck | |
| TpcClusterBuilder | |
| TpcClusterCleaner | |
| TpcClusterizer | |
| TpcClusterMover | |
| TpcClusterQA | |
| TpcClusterZCrossingCorrection | |
| TpcCombinedRawDataUnpacker | |
| TPCDataStreamEmulator | TPCDataStreamEmulator |
| TpcDirectLaserReconstruction | |
| TpcDistortionCorrection | |
| TpcDistortionCorrectionContainer | |
| TPCFEETestRecov1 | |
| ChannelHeader | Simple channel header class for ROOT file IO |
| ClusterData | Buffer for a cluster's data |
| EventHeader | Simple event header class for ROOT file IO |
| PadPlaneData | Buffer for full event data |
| SampleID | |
| TPCGemGainCalb | |
| TPCHitTrackDisplay | |
| TPCIntegratedCharge | |
| TpcLoadDistortionCorrection | |
| TPCMap | |
| tpc_map | |
| TpcMap | |
| tpc_map | |
| TPCMLDataInterface | TPCMLDataInterface |
| TpcMon | |
| TpcMonDraw | |
| TPCPedestalCalibration | |
| TpcPrototypeCluster | Version 1 of TrkrCluster |
| TpcPrototypeClusterizer | |
| TpcPrototypeGenFitTrkFinder | Find tracks |
| TpcPrototypeGenFitTrkFitter | Refit SvtxTracks with PHGenFit |
| TpcPrototypeTrack | TpcPrototypeTrack |
| TpcPrototypeUnpacker | |
| ChannelHeader | Simple channel header class for ROOT file IO |
| ClusterData | Buffer for a cluster's data |
| EventHeader | Simple event header class for ROOT file IO |
| PadPlaneData | Buffer for full event data |
| SampleID | |
| TPCR2Map | |
| TpcRawDataDecoder | |
| ped_tpc_map | |
| TpcRawDataTree | Dump TPC raw data in PRDF format to a TTree for online debugging and seeding formal Fun4All reco/calib modules |
| TPCRawDataTree | |
| TpcRawHit | |
| TpcRawHitContainer | |
| TpcRawHitContainerv1 | |
| TpcRawHitv1 | |
| TpcRawWriter | |
| TpcSeedTrackMap | |
| TpcSeedTrackMapv1 | |
| TpcSimpleClusterizer | |
| TpcSpaceChargeMatrixContainer | Cluster container object |
| TpcSpaceChargeMatrixContainerv1 | Cluster container object |
| TpcSpaceChargeMatrixInversion | Performs space charge distortion reconstruction using tracks |
| TpcSpaceChargeReconstruction | Performs space charge distortion reconstruction using tracks To reconstruct the distortions dr0, drphi0 and dz0 in a given volume element, the following chisquare is minimized chisquare = sum_cluster (drphi - (drphi0 + dr0 tan alpha))**2/error**2 + sum_cluster ( dz - (dz0 + dr0 tan beta))**2/error**2 with |
| TpcSpaceChargeReconstructionHelper | |
| TpcTpotEventInfo | Base class for TPC and TPOT event level information |
| TpcTpotEventInfov1 | Version 1 of TpcTpotEventInfo |
| TpotMon | |
| detector_histograms_t | |
| TpotMonDraw | |
| TrackClusEvaluator | |
| TrackClusterEvaluator | |
| TrackContainerCombiner | |
| TrackerEventDisplay | |
| TrackEvaluation | |
| TrackEvaluationContainer | Track evaluation container base class |
| TrackEvaluationContainerv1 | Track evaluation container |
| ClusterStruct | Cluster information |
| EventStruct | Event information |
| TrackStruct | Track information |
| TrackFitUtils | |
| TrackInfoContainer | |
| TrackInfoContainer_v1 | |
| TrackingIterationCounter | |
| TrackingPerformanceCheck | |
| TrackJetInput | |
| Tracklet | |
| TrackletData | |
| TrackPidAssoc | Class for associating particle ID categories to tracks |
| TrackProjectionTools | |
| TrackProjectorPid | |
| TrackProjectorPlaneECAL | |
| TrackResiduals | |
| TrackSeed | |
| TrackSeed_FastSim_v1 | |
| TrackSeed_v1 | |
| TrackSeedContainer | |
| TrackSeedContainer_v1 | |
| TrackSeedTrackMapConverter | |
| TracksInJets | |
| TrackStateInfo | |
| TrackStateInfo_v1 | |
| TrackStatesReader | |
| TrackSummaryReader | |
| TrainingHits | |
| TrainingHitsContainer | |
| traits2 | |
| TransportCoeff | |
| TRDBCServer | |
| TreeMaker | |
| TreeReader | |
| TrigFTF_GNN_EdgeState | |
| Compare | |
| TrigFTF_GNN_TrackingFilter | |
| TriggerHandler | |
| TrigInDetTriplet | |
| TrivialTrack | |
| TrkrClusLoc | |
| TrkrCluster | Base class for cluster object |
| TrkrClusterContainer | Cluster container object |
| TrkrClusterContainerv1 | Cluster container object |
| TrkrClusterContainerv2 | Cluster container object |
| TrkrClusterContainerv3 | Cluster container object |
| TrkrClusterContainerv4 | Cluster container object |
| TrkrClusterCrossingAssoc | Base class for associating clusters to the hits that went into them |
| TrkrClusterCrossingAssocv1 | Class for associating clusters to the bunch crossing that created them |
| TrkrClusterHitAssoc | Base class for associating clusters to the hits that went into them |
| TrkrClusterHitAssocv1 | Class for associating clusters to the hits that went into them |
| TrkrClusterHitAssocv2 | Class for associating clusters to the hits that went into them |
| TrkrClusterHitAssocv3 | Class for associating clusters to the hits that went into them |
| TrkrClusterIsMatcher | |
| TrkrClusterIterationMap | Base class for associating clusters to iterations they were used in |
| TrkrClusterIterationMapv1 | Class for associating clusters to the hits that went into them |
| TrkrClusterv1 | Version 1 of TrkrCluster |
| TrkrClusterv2 | Version 2 of TrkrCluster |
| TrkrClusterv3 | Version 3 of TrkrCluster |
| TrkrClusterv4 | Version 4 of TrkrCluster |
| TrkrClusterv5 | Version 5 of TrkrCluster |
| TrkrHit | Base class for hit object |
| TrkrHitSet | Container for storing TrkrHit's |
| TrkrHitSetContainer | |
| TrkrHitSetContainerv1 | |
| TrkrHitSetv1 | |
| TrkrHitTruthAssoc | Association object for PHG4Cells contributiong to TrkrHits |
| TrkrHitTruthAssocv1 | Association object for PHG4Cells contributiong to TrkrHits |
| TrkrHitv1 | Inherited class v1 for hit object |
| TrkrHitv2 | Base class for hit object |
| TrkrNtuplizer | |
| TrkrTruthTrack | |
| Comp | |
| TrkrTruthTrackContainer | |
| TrkrTruthTrackContainerv1 | Cluster container object |
| TrkrTruthTrackv1 | |
| CompHitSetKey | |
| TruthCaloTree | |
| TruthClusterizerBase | |
| TruthConversionEval | |
| truthDecayTester | |
| TruthJetInput | |
| TruthJetTagging | |
| TruthPhotonJet | |
| TruthRecoTrackMatching | |
| CompRECOtoEta | |
| CompRECOtoPhi | |
| CompRECOtoPt | |
| SortPossibleMatch | |
| TruthTrackerHepMC | |
| TSQL | |
| TSQLCallableStatement | |
| TSQLConnection | |
| TSQLDatabaseMetaData | |
| TSQLDate | |
| TSQLDriverInfo | |
| TSQLDriverManager | |
| TSQLException | |
| TSQLImportClient | |
| TSQLImporter | |
| TSQLini | |
| TSQLPreparedStatement | |
| TSQLResultSet | |
| TSQLResultSetMetaData | |
| TSQLStatement | |
| TSQLTime | |
| TSQLTimestamp | |
| TSQLUrl | |
| tuBinVec | |
| tuple | |
| tuple_size | |
| TupleElement | |
| TupleFields | |
| TupleIndexOf | |
| TupleIndexOf | |
| TuplePolicy | |
| twrs | |
| TypedExpectation | |
| TypedTest | |
| TypeParamTest | |
| UEvsEtaCentrality | |
| UniversalPrinter | |
| UnprintableTemplateInGlobal | |
| UpsilonPair | UpsilonPair |
| ValueGen1 | |
| ValueGen2 | |
| ValueParamTest | |
| VariableArray | |
| VariableArrayContainer | |
| VariableArrayUtils | |
| vector2D | |
| vector3D | |
| Vertex | |
| vertex | |
| VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName | |
| VolumeGeoIdGenerator | |
| Cache | |
| VtxData | |
| VtxRegressor | |
| VtxTest | |
| weak_ptr | |
| websocket_message | |
| Widget | |
| ws_mask_ctx | |
| X_Event | |
| xMD5Context | |
| ZCylinderSurfaceBuilder | Construct a z-cylinder centered at zero with the track on its surface |
| ZdcMon | |
| ZdcMonDraw | |
| ZStrawSurfaceBuilder | Construct a z-straw at the track position |
1.8.2
with sPHENIX GitHub integration
