  inputParser::_parameter< T > | |
| inputParser::_parameter< bool > | |
| inputParser::_parameter< double > | |
| inputParser::_parameter< float > | |
| inputParser::_parameter< int > | |
| inputParser::_parameter< std::string > | |
| inputParser::_parameter< unsigned int > | |
| Acts::Test::A | |
| Acts::Test::A2 | |
| abort_list_impl< conditions > | |
| Acts::detail::abort_list_impl< first, others...> | |
| Acts::detail::abort_list_impl< last > | This is the check call on the a last of all conditions |
| Acts::detail::abort_list_impl<> | This is the empty call list - never abort |
| Acts::CombinatorialKalmanFilter< propagator_t, updater_t, smoother_t, source_link_selector_t, branch_stopper_t, calibrator_t >::Aborter< source_link_t, parameters_t > | |
| Acts::KalmanFitter< propagator_t, updater_t, smoother_t, outlier_finder_t, calibrator_t >::Aborter< source_link_t, parameters_t > | |
| Acts::Test::AborterWithoutResult | |
| Acts::Test::AborterWithoutResultInvalid | |
| Acts::Test::AborterWithResultA | |
| Acts::Test::AborterWithResultB | |
| Acts::Test::AborterWithResultInvalid | |
 genfit::AbsBField | Abstract Interface to magnetic fields in GENFIT |
 genfit::ConstField | Constant Magnetic field |
 genfit::Field | Field Wrapper |
| ActsFatras::Casts::AbsEta | Retrieve the direction absolute pseudo-rapidity |
| genfit::AbsFinitePlane | Abstract base class for finite detector planes |
| genfit::RectangularFinitePlane | Rectangular finite plane |
| genfit::AbsFitter | Abstract base class for fitters |
| genfit::AbsKalmanFitter | Abstract base class for Kalman fitter and derived fitting algorithms |
| genfit::DAF | Determinstic Annealing Filter (DAF) implementation |
| genfit::KalmanFitter | Simple Kalman filter implementation |
| genfit::KalmanFitterRefTrack | Kalman filter implementation with linearization around a reference track |
| genfit::GblFitter | Generic GBL implementation |
| genfit::GFGbl | Generic GBL implementation |
| genfit::AbsMeasurementProducer< measurement_T > | Abstract interface class for MeasurementProducer |
| genfit::AbsMeasurementProducer< genfit::AbsMeasurement > | |
| genfit::MeasurementProducer< hit_T, measurement_T > | Template class for a measurement producer module |
| AbsNystromEQM | |
| LSLEQM | |
| ActsFatras::AbsPdgExcluder< Pdg > | Select all particles except for (anti-)particles of one specific type |
| ActsFatras::AbsPdgSelector< Pdg > | Select particles and antiparticles of one specific type |
| ActsFatras::Casts::AbsVz | Retrieve the longitudinal absolute distance of the position to the origin |
| Smear::Acceptance | |
| Acts::AccumulatedMaterialSlab | |
| Acts::AccumulatedSurfaceMaterial | |
| Acts::AccumulatedVolumeMaterial | |
| action_list_impl< actors > | The dummy list call implementation |
| Acts::detail::action_list_impl< first, others...> | |
| Acts::detail::action_list_impl< last > | |
| Acts::detail::action_list_impl<> | The empty action list call implementation |
| Acts::detail::action_type_extractor | |
| Acts::CombinatorialKalmanFilter< propagator_t, updater_t, smoother_t, source_link_selector_t, branch_stopper_t, calibrator_t >::Actor< source_link_t, parameters_t > | Propagator Actor plugin for the CombinatorialKalmanFilter |
| Acts::KalmanFitter< propagator_t, updater_t, smoother_t, outlier_finder_t, calibrator_t >::Actor< source_link_t, parameters_t > | Propagator Actor plugin for the KalmanFilter |
| Acts::Test::ActorA | |
| Acts::Test::ActorB | |
| Acts::ActsExtension | Extension of the DD4hep DetElement needed for translation into the Acts tracking geometry |
| ActsSurfaceMaps | |
| ActsTrackingGeometry | |
| ActsTransformations | |
| Acts::AdaptiveMultiVertexFinder< vfitter_t, sfinder_t > | Implements an iterative vertex finder |
| Acts::AdaptiveMultiVertexFitter< input_track_t, linearizer_t > | 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 |
| add_to_value_container< v, C > | |
| Acts::detail::full_parset< parameter_indices_t >::add_to_value_container< v, std::integer_sequence< parameter_indices_t, others...> > | |
| adl_serializer< T, SFINAE > | Default JSONSerializer template argument |
| nlohmann::adl_serializer< typename, typename > | |
| algo_info | |
| ActsExamples::AlgorithmContext | Aggregated information to run one algorithm over one event |
| ALICEKF | |
| alignBlkV1 | |
| Acts::Test::AlignmentContext | |
| dfe::SmallVector< T, N, Allocator >::AllocatedStorage | |
| AnalyticFieldModel | |
| AnalyzeTree | |
| AngleIndexList | |
| AngleIndexPair | |
| Acts::AnnealingUtility | Implements a deterministic thermodynamic annealing scheme Ref. (1): CERN-THESIS-2010-027 |
| AnnularFieldSim | |
| Acts::AnyCharge | |
| AnyVector | |
| Acts::ApproachDescriptor | |
| Acts::GenericApproachDescriptor | |
| ArgParser | |
| boost::array< T, N > | |
| boost::array< T, 0 > | |
| nanoflann::array_or_vector_selector< DIM, T > | |
| nanoflann::array_or_vector_selector< DIM, Interval > | |
| nanoflann::array_or_vector_selector<-1, T > | |
| tetgenmesh::arraypool | |
| ATLASBinFinder | |
| ATLASBinFinder | |
| Acts::Legacy::AtlasSeedfinder< SpacePoint > | |
| Acts::AtlasStepper< bfield_t > | AtlasStepper implementation for the |
| atpAlignBlk | |
| Axis< type, bdt > | Calculate bin indices from a given binning structure |
| Acts::AxisAlignedBoundingBox< entity_t, value_t, DIM > | |
| Acts::AxisAlignedBoundingBox< Volume, double, 3 > | |
| Acts::Test::B | |
| B1 | |
| nlohmann::detail::conjunction< B1 > | |
| tetgenmesh::badface | |
| BaseTruthEval | |
| basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > | |
| nlohmann::basic_json | Class to store JSON values |
| check_license.bcolors | |
| beamBeamSystem | |
| twoPhotonLuminosity | |
| BeamLine | |
| BeamParticles | |
| BeastMagneticField | |
| BeastMagneticFieldCell | |
| BEmcProfile | |
| BEmcRec | |
| BEmcRecCEMC | |
| BEmcRecEEMC | |
| BEmcRecFEMC | |
| ActsFatras::BetheBloch | |
| ActsFatras::BetheHeitler | |
| binary_function | |
| Acts::DistanceSorterT< T > | This will check on absolute distance |
| Acts::GeometryObjectSorterT< T > | |
| Acts::ObjectSorterT< T > | |
| BinaryFunctor | Base class for all functors which are used in the FairTSBufferFunctional |
| StopTime | |
| TimeGap | |
| CbmRichHoughHitCmpUp | CbmRichHoughHit comparator for hits sorting by X coordinate |
| CbmRichHoughHitCmpUp | CbmRichHoughHit comparator for hits sorting by X coordinate |
| CbmRichRingComparatorMore | CbmRichRingLight comparator based on the selection ANN criterion |
| CbmRichRingComparatorMore | CbmRichRingLight comparator based on the selection ANN criterion |
| Acts::ObjectSorterT< Vector3D > | |
| Packet_idcdevdescr::valuesetPtrLess | |
| strless< T > | |
| nlohmann::detail::binary_reader< BasicJsonType, SAX > | Deserialization of CBOR, MessagePack, and UBJSON values |
| nlohmann::detail::binary_writer< BasicJsonType, CharType > | Serialization to CBOR and MessagePack values |
| BinEntryPair5D | |
| Acts::BinFinder< external_spacepoint_t > | |
| Acts::BinnedArray< T > | |
| Acts::BinnedArrayXD< T > | |
| Acts::BinnedSPGroup< external_spacepoint_t > | |
| Acts::BinnedSPGroupIterator< external_spacepoint_t > | |
| ActsExamples::PlotHelpers::Binning | Nested binning struct for booking plots |
| Acts::BinningData | |
| Acts::BinUtility | |
| FairDbMultConnector::BLock | |
| gbl::BorderedBandMatrix | (Symmetric) Bordered Band Matrix |
| Bore | |
| nlohmann::detail::dtoa_impl::boundaries | |
| Acts::BoundaryCheck | |
| Acts::BoundarySurfaceT< volume_t > | |
| BoundaryType | |
| ActsFatras::BoundParametersSmearer< kParameters > | |
| Acts::VolumeMaterialMapper::BoundSurfaceSelector | Selector for finding surface |
| Acts::Concepts::BoundTrackParametersConceptImpl< T > | |
| PHG4mRICHDetector::BoxPar | |
| BranchBuffer | |
| BranchComparisonHarness | |
| buffer | |
| oncsBuffer | |
 prdfBuffer | |
 gzbuffer | |
| lzobuffer | |
| oBuffer::buffer_ptr | |
| oncsBuffer::buffer_ptr | |
| prdfBuffer::buffer_ptr | |
| Acts::Test::C | |
| Acts::ConstantBField::Cache | |
| Acts::InterpolatedBFieldMap< Mapper_t >::Cache | |
| Acts::NullBField::Cache | |
| Acts::SolenoidBField::Cache | |
| Acts::InterpolatedMaterialMap< Mapper_t >::Cache | Temporary storage of a certain cell to improve material access |
| ActsExamples::BField::ScalableBField::Cache | |
| nlohmann::detail::dtoa_impl::cached_power | |
| caen_correction | |
| Acts::Test::CallCounter | A call counter struct as an actor |
| CaloEvalStack | |
| CaloRawClusterEval | |
| CaloRawTowerEval | |
| CaloTruthEval | |
| Acts::detail::can_interpolate< Point1, Point2, Point3, Value > | Check types for requirements needed by interpolation |
| nanoflann::CArray< T, N > | |
| CbmAddress | Base class for interfaces to the unique address |
| CbmDrawingOptions | Default options for drawing |
| CbmModuleList | Manages module Ids and names |
| CbmRichConverter | Convert internal data classes to cbmroot common data classes |
| CbmRichElectronIdAnn | Implementation of the electron identification algorithm in the RICH detector using Artificial Neural Network(ANN) |
| CbmRichHitLight | |
| CbmRichHoughHit | Implementation of RICH hit for ring finder algorithm |
| CbmRichHoughHitVec | |
| CbmRichProjectionProducerBase | Base class for STS track projections onto the photodetector plane |
| CbmRichProjectionProducer | Project track by straight line from imaginary plane to the mirror and reflect it to the photodetector plane |
| CbmRichProtProjectionProducer | |
| CbmRichRadiusCorrection | |
| CbmRichRingFinderHoughImpl | Ring finder implementation based on Hough Transform method |
| CbmRichRingFinderHoughSimd | SIMDized ring finder based on Hough Transform method |
| CbmRichRingFitterBase | Abstract base class for concrete Rich Ring fitting algorithms. Each derived class must implement the method DoFit |
| CbmRichRingFitterCircle | Implementation of a ring fitting algorithm with equation of a circle. Algorithm from F77 subroutine of S.Sadovsky |
| CbmRichRingFitterCOP | Here the ring is fitted with the COP algorithm from A. Ayriyan/G. Ososkov |
| CbmRichRingFitterEllipseBase | Base class for concrete ellipse fitting algorithms. Each derived class must implement the method DoFit |
| CbmRichRingFitterEllipseMinuit | This is the implementation of ellipse fitting using MINUIT |
| CbmRichRingFitterEllipseTau | Here the ring is fitted with Taubin algorithm from A. Ayriyan, G. Ososkov, N. Chernov |
| CbmRichRingFitterRobustCOP | Here the ring is fitted with the RobustCOP algorithm from A. Ayriyan/G. Ososkov |
| CbmRichRingFitterTAU | Here the ring is fitted with the TAU algorithm from A. Ayriyan/ G. Ososkov |
| CbmRichRingFitterCOPLight | |
| CbmRichRingLight | |
| CbmRichRingSelectAnn | Implementation for concrete RICH ring selection algorithm: reject rings using a trained neural net (input file with weights needed!) store resulting value (0-1) in "SelectionNN": 0 = good rings 1 = rings to be rejected –> choose a value in between depending on required purity/ efficiency |
| CbmRichRingSelectImpl | |
| CbmRichRingSelectImplLight | |
| CbmRichRingSelectNeuralNet | |
| CbmRichRingTrackAssignBase | Base class for RICH rings - STS tracks matching algorithms |
| CbmRichRingTrackAssignClosestD | Ring-Track Assignment according to the closest distance criterion |
| CbmRichRingTrackAssignIdeal | Ideal Ring-Track Assignment. CbmRichRingMatch must be run prior to this procedure |
| CbmRichTrackExtrapolationBase | |
| CbmRichTrackExtrapolationIdeal | "TrackExtrapolation" from MC points. It reads the PointArray with ImPlanePoints from MC and selects those to be projected to the Rich Photodetector |
| CbmRichTrackExtrapolationKF | "TrackExtrapolation" from STS tracks (Kalman Fitter) It reads the track array form STS and extrapolates those to be projected to the Rich Photodetector to some z-Plane in RICH |
| CbmRichTrackExtrapolationMirrorIdeal | This is the implementation of the TrackExtrapolation from MC points - operating on points in the RICH mirror! It reads the STS track array, gets the corresponding MC MirrorPoint and selects those to be projected to the Rich Photodetector points will be stored on mirror surface again. WARNING!!!: ProjectionProducer needs to be run with zflag==2!!! |
| cdevBPMData | |
| cdevBucketsData | |
| cdevDvmData | |
| cdevIrData | |
| cdevMadchData | |
| cdevPolarimeterData | |
| cdevPolarimeterZData | |
| cdevPolTargetData | |
| cdevRingData | |
| cdevRingNoPolData | |
| cdevRingPolData | |
| cdevSISData | |
| cdevWCMData | |
| cdevWCMHistory | |
| Cell | |
| ActsExamples::CellData | |
| CellType | |
| CellularAutomaton | |
| CellularAutomaton_v1 | |
| ActsFatras::ChargedSelector | Select all charged particles |
| kdfinder::Circle< T > | |
| kdfinder::CircleFit< T > | |
| CircleHough | |
| CylindricalHough | |
| Acts::CKFSourceLinkSelector | Source link selection struct selecting those source links compatible with the given track parameter against provided criteria on one surface |
| FairDbTableProxyRegistry::Cleaner | |
| TrackEvaluationContainerv1::ClusterStruct | Cluster information |
| Collimator | |
| FairDbTableMetaData::ColumnAttributes | Column attributes |
| ColumnOrBranchDescriptor | |
| Acts::CombinatorialKalmanFilter< propagator_t, updater_t, smoother_t, source_link_selector_t, branch_stopper_t, calibrator_t > | CombinatorialKalmanFilter implementation of Acts as a plugin |
| Acts::CombinatorialKalmanFilterOptions< source_link_selector_t > | Options struct how the CombinatorialKalmanFilter (CKF) is called |
| Acts::CombinatorialKalmanFilterResult< source_link_t > | |
| Acts::CombinatorialKalmanFilterTipState | Struct to keep record of the track quality |
| ActsFatras::detail::CombineSelectors< Initial, Combine, Selectors > | Combine multiple selectors with a configurable combine function |
| Acts::Legacy::comCurvature | |
| dfe::Dispatcher::Command | |
| CommandLineArguments | |
| check_license.CommitInfo | |
| ActsExamples::detail::CompareGeometryId | |
| ActsExamples::detail::CompareParticleId | |
| CompCal | |
| Acts::Concepts::detail_aborter::Concept< T, propagator_state_t, stepper_t > | |
| Acts::Concepts::detail_aborter::ConceptConditional< T, propagator_state_t, stepper_t, has_result > | |
| Acts::Concepts::detail_aborter::ConceptConditional< T, propagator_state_t, stepper_t, true > | |
| Acts::TrackingVolumeArrayCreator::Config | This struct stores the configuration of the tracking geometry |
| Acts::AdaptiveMultiVertexFinder< vfitter_t, sfinder_t >::Config | |
| Acts::InterpolatedBFieldMap< Mapper_t >::Config | Configuration object for magnetic field interpolation |
| Acts::AdaptiveMultiVertexFitter< input_track_t, linearizer_t >::Config | |
| Acts::FullBilloirVertexFitter< input_track_t, linearizer_t >::Config | |
| Acts::GaussianGridTrackDensity< mainGridSize, trkGridSize >::Config | Struct |
| Acts::SolenoidBField::Config | Config struct for the SolenoidBfield |
| Acts::GaussianTrackDensity< input_track_t >::Config | The Config struct |
| Acts::GridDensityVertexFinder< mainGridSize, trkGridSize, vfitter_t >::Config | The Config struct |
| Acts::HelicalTrackLinearizer< propagator_t, propagator_options_t >::Config | Configuration struct |
| Acts::ImpactPointEstimator< input_track_t, propagator_t, propagator_options_t >::Config | |
| Acts::IterativeVertexFinder< vfitter_t, sfinder_t >::Config | |
| Acts::TrackDensityVertexFinder< vfitter_t, track_density_t >::Config | The Config struct |
| Acts::ZScanVertexFinder< vfitter_t >::Config | |
| ActsExamples::DigitizationAlgorithm::Config | |
| ActsExamples::HitSmearing::Config | |
| Acts::SurfaceMaterialMapper::Config | |
| ActsExamples::FatrasAlgorithm< simulator_t >::Config | |
| ActsExamples::FittingAlgorithm::Config | |
| ActsExamples::TrkrClusterFittingAlgorithm::Config | |
| ActsExamples::TrkrClusterOutlierFittingAlgorithm::Config | |
| Acts::VolumeMaterialMapper::Config | |
| ActsExamples::GeantinoRecording::Config | |
| ActsExamples::PrimaryGeneratorAction::Config | |
| ActsExamples::EventGenerator::Config | |
| ActsExamples::ParametricParticleGenerator::Config | |
| ActsExamples::Pythia8Generator::Config | |
| ActsExamples::MaterialMapping::Config | |
| ActsExamples::PrintHits::Config | |
| ActsExamples::PrintParticles::Config | |
| ActsExamples::PropagationAlgorithm< propagator_t >::Config | |
| ActsExamples::TrackFindingAlgorithm::Config | |
| ActsExamples::TrkrClusterFindingAlgorithm::Config | |
| ActsExamples::ParticleSelector::Config | |
| ActsExamples::ParticleSmearing::Config | |
| ActsExamples::TrackSelector::Config | |
| ActsExamples::TruthSeedSelector::Config | |
| ActsExamples::TruthTrackFinder::Config | |
| ActsExamples::TruthVertexFinder::Config | |
| ActsExamples::AdaptiveMultiVertexFinderAlgorithm::Config | |
| ActsExamples::IterativeVertexFinderAlgorithm::Config | |
| ActsExamples::TutorialVertexFinderAlgorithm::Config | |
| ActsExamples::VertexFitterAlgorithm::Config | |
| ActsExamples::Contextual::AlignmentDecorator::Config | Nested configuration struct |
| ActsExamples::Contextual::PayloadDecorator::Config | Nested configuration struct |
| ActsExamples::DD4hep::DD4hepGeometryService::Config | |
| ActsExamples::Generic::LayerBuilderT< detector_element_t >::Config | |
| ActsExamples::Generic::ProtoLayerCreatorT< detector_element_t >::Config | |
| ActsExamples::BField::BFieldScalor::Config | Nested configuration struct |
| ActsExamples::RandomNumbers::Config | |
| ActsExamples::Sequencer::Config | |
| ActsExamples::DuplicationPlotTool::Config | The nested configuration struct |
| ActsExamples::EffPlotTool::Config | The nested configuration struct |
| ActsExamples::ResPlotTool::Config | Nested configuration struct |
| ActsExamples::TrackSummaryPlotTool::Config | The nested configuration struct |
| ActsExamples::CsvParticleReader::Config | |
| ActsExamples::CsvParticleWriter::Config | |
| ActsExamples::FakeRatePlotTool::Config | The nested configuration struct |
| ActsExamples::CsvPlanarClusterReader::Config | |
| ActsExamples::CsvPlanarClusterWriter::Config | |
| ActsExamples::CsvTrackingGeometryWriter::Config | |
| ActsExamples::ObjPropagationStepsWriter< step_t >::Config | |
| ActsExamples::JsonSpacePointWriter< T >::Config | |
| ActsExamples::ObjSpacePointWriter< T >::Config | |
| ActsExamples::ObjTrackingGeometryWriter::Config | |
| ActsExamples::CKFPerformanceWriter::Config | |
| ActsExamples::TrackFinderPerformanceWriter::Config | |
| ActsExamples::TrackFitterPerformanceWriter::Config | |
| ActsExamples::RootBFieldWriter< bfield_t >::Config | |
| ActsExamples::RootMaterialDecorator::Config | |
| ActsExamples::RootMaterialTrackReader::Config | The nested configuration struct |
| ActsExamples::RootMaterialTrackWriter::Config | |
| ActsExamples::RootMaterialWriter::Config | |
| ActsExamples::RootParticleWriter::Config | |
| ActsExamples::RootPlanarClusterWriter::Config | |
| ActsExamples::RootSimHitWriter::Config | |
| ActsExamples::RootPropagationStepsWriter::Config | |
| ActsExamples::RootTrajectoryWriter::Config | The nested configuration struct |
| ActsExamples::RootTrackParameterWriter::Config | |
| ActsExamples::HelloRandomAlgorithm::Config | |
| ActsExamples::HelloService::Config | |
| Acts::CuboidVolumeBuilder::Config | This struct stores the configuration of the tracking geometry |
| ActsExamples::HelloWhiteBoardAlgorithm::Config | |
| Acts::CylinderVolumeHelper::Config | |
| Acts::CylinderVolumeBuilder::Config | |
| Acts::DD4hepLayerBuilder::Config | |
| Acts::DD4hepVolumeBuilder::Config | |
| Acts::JsonGeometryConverter::Config | |
| Acts::Legacy::AtlasSeedfinder< SpacePoint >::Config | |
| Acts::LayerArrayCreator::Config | This struct stores the configuration of the tracking geometry |
| Acts::AnnealingUtility::Config | The configuration struct |
| Acts::TGeoLayerBuilder::Config | Nested configuration struct for steering of the layer builder |
| Acts::PassiveLayerBuilder::Config | |
| Acts::LayerCreator::Config | |
| Acts::ProtoLayerHelper::Config | |
| Acts::SurfaceArrayCreator::Config | |
| Acts::TrackingGeometryBuilder::Config | |
| Acts::Test::events::Connect | |
| Acts::Test::states::Connected | |
| Acts::Test::states::Connecting | |
| boost::detail::const_cast_tag | |
| Acts::ConstantBField | |
| Acts::ConstrainedStep | A constrained step class for the steppers |
| ActsExamples::Contextual::AlignedDetectorElement::ContextType | |
| ActsExamples::Contextual::PayloadDetectorElement::ContextType | |
| Converter< T > | |
| converter< T > | |
| dfe::Variable::Converter< bool > | |
| dfe::Variable::Converter< double > | |
| dfe::Variable::Converter< float > | |
| Acts::detail::full_parset< parameter_indices_t >::converter< std::integer_sequence< parameter_indices_t, values...> > | |
| dfe::Variable::Converter< std::string > | |
| CoordinateDescriptor | |
| CoordSystem | |
| Acts::detail::covariance_helper< CovMatrix_t, NumIter > | Check and correct covariance matrix |
| Acts::CovarianceTool | |
| Acts::CpuMatrix< var_t > | |
| Acts::CpuScalar< var_t > | |
| Acts::CpuVector< var_t > | |
| Acts::Test::CubicTrackingGeometry | |
| CudaMatrix< var_t > | |
| CudaScalar< var_t > | |
| CudaVector< var_t > | |
| Smear::Acceptance::CustomCut | |
| Smear::Acceptance::CustomCutFunction | |
| Acts::detail::CyclicParameterTraits< limits_t > | |
| Acts::Test::CylindricalTrackingGeometry | |
| Acts::Test::D | |
| kdfinder::Data< T > | |
| data32 | |
| dataBlockHdr | |
| dcbAlignBlk | |
| dcmAlignBlk | |
| ActsExamples::DD4hep::DD4hepDetectorHelper | |
| Acts::DefaultExtension | 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 |
| DefaultFactoryError< AbstractProduct > | |
| DeleteObject | |
| Fun4AllDstPileupInputManager::Deleter | Random generator |
| Fun4AllSingleDstPileupInputManager::Deleter | Random generator |
| PHG4MicromegasDigitizer::Deleter | Rng de-allocator |
| PHG4MicromegasHitReco::Deleter | Rng de-allocator |
| PHG4TpcElectronDrift::Deleter | Rng de-allocator |
| Acts::DenseEnvironmentExtension | 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 |
| Acts::detail::detector< Default, AlwaysVoid, Op, Args > | |
| nlohmann::detail::detector< Default, AlwaysVoid, Op, Args > | |
| Acts::detail::detector< Default, std::void_t< Op< Args...> >, Op, Args...> | |
| nlohmann::detail::detector< Default, void_t< Op< Args...> >, Op, Args...> | |
| Acts::DetectorElementBase | |
| Acts::IdentifiedDetectorElement | The identified detector element |
| Acts::TGeoDetectorElement | |
| Acts::DD4hepDetectorElement | DetectorElement class implementation for DD4hep geometry |
| ActsExamples::Generic::GenericDetectorElement | |
| ActsExamples::Contextual::AlignedDetectorElement | |
| ActsExamples::Contextual::PayloadDetectorElement | |
| Acts::Test::AlignableDetectorElement | |
| Acts::Test::DetectorElementStub | |
| Acts::JsonGeometryConverter::DetectorRep | Detector representation for Json writing |
| DetUtils | |
| device_selector | |
| Acts::Sycl::DeviceSelector | Custom device selector that refuses to select NVIDIA OpenCL backends |
| Acts::Cuda::Details::DeviceArrayDeleter | Class performing the deletion of a CUDA device memory array |
| Acts::Sycl::DeviceExperimentCuts | |
| Acts::Sycl::detail::DeviceLinEqCircle | |
| Acts::Sycl::detail::DeviceSeedfinderConfig | |
| Acts::Sycl::detail::DeviceSpacePoint | |
| Acts::Sycl::detail::DeviceTriplet | |
| Acts::detail::DifferenceCalculator< indices_t, kParameters > | |
| twoPhotonLuminosity::difflumiargs | |
| ActsExamples::DigitizationAlgorithm::Digitizable | |
| Acts::DigitizationCell | Pair of ints for definition of a cell |
| Acts::DigitizationModule | |
| Acts::DigitizationStep | DigitizationStep for further handling |
| Acts::DirectNavigator | |
| Acts::Test::events::Disconnect | |
| Acts::Test::states::Disconnected | |
| DiscSurface | |
| Acts::DiscLayer | |
| DiscSurfaceBuilder | Construct a disc at track position with plane normal along track tangent |
| dfe::Dispatcher | |
| Acts::Test::DistanceObserver | A distance observer struct as an actor |
| Smear::Distributor | |
| nlohmann::detail::dtoa_impl::diyfp | |
| Acts::DoubleHitSpacePointConfig | Configuration of the class to steer its behaviour |
| DpipeFilter | |
| odd_filter | |
| DSTCompressor | |
| dfe::io_dsv_impl::DsvReader< Delimiter > | Read arbitrary data as delimiter-separated values from a text file |
| dfe::io_dsv_impl::DsvWriter< Delimiter > | Write arbitrary data as delimiter-separated values into a text file |
| Acts::Cuda::Details::DubletCounts | Helper struct summarising the results of the dublet search |
| Acts::DummyVertexFitter< input_track_t, linearizer_t > | Dummy vertex fitter class, only to be used for ensuring interfaces where a vertex fitter type is required but no fitter is actually needed |
| DumpObject | |
| DumpAssocInfoContainer | |
| DumpBbcVertexMap | |
| DumpCaloTriggerInfo | |
| DumpEventHeader | |
| DumpGlobalVertexMap | |
| DumpJetMap | |
| DumpParticleFlowElementContainer | |
| DumpPdbParameterMap | |
| DumpPdbParameterMapContainer | |
| DumpPHG4BlockCellGeomContainer | |
| DumpPHG4BlockGeomContainer | |
| DumpPHG4CellContainer | |
| DumpPHG4CylinderCellContainer | |
| DumpPHG4CylinderCellGeomContainer | |
| DumpPHG4CylinderGeomContainer | |
| DumpPHG4HitContainer | |
| DumpPHG4InEvent | |
| DumpPHG4ScintillatorSlatContainer | |
| DumpPHG4TruthInfoContainer | |
| DumpPHHepMCGenEventMap | |
| DumpRawClusterContainer | |
| DumpRawTowerContainer | |
| DumpRawTowerGeom | |
| DumpRawTowerGeomContainer | |
| DumpRunHeader | |
| DumpSvtxTrackMap | |
| DumpSvtxVertexMap | |
| DumpSyncObject | |
| DumpTowerBackground | |
| DumpTrkrClusterContainer | |
| DumpTrkrClusterHitAssoc | |
| DumpTrkrHitSetContainer | |
| DumpTrkrHitTruthAssoc | |
| DumpVariableArray | |
| ActsExamples::DuplicationPlotTool::DuplicationPlotCache | Nested Cache struct |
| ActsExamples::DuplicationPlotTool | |
| boost::detail::dynamic_cast_tag | |
| Acts::Test::E | |
| ActsFatras::Casts::E | Retrieve the total energy |
| Acts::Test::E1 | |
| Acts::Test::E2 | |
| Acts::Test::E3 | |
| e_starlight | |
| e_starlightStandalone | |
| eASTHistoType | |
| eASTInitialization | |
| eASTMagneticFieldMap | |
| eASTUserActionDispatcher | |
| eASTVDetectorComponent | |
| eASTBeamPipe | |
| eASTDetectorComponentGDML | |
| eASTSupportStructure | |
| ActsExamples::EffPlotTool::EffPlotCache | Nested Cache struct |
| ActsExamples::EffPlotTool | |
| EicBlackHole | |
| EicCadWizardCut | |
| EicCadWizardCone | |
| EicCadWizardCylinder | |
| EicCadWizardPlane | |
| EicCadWizardSphere | |
| EicCadWizardTorus | |
| EicFileNameExpansion | |
| EICG4dRICHConfig | |
| EICG4ZDCStructure | |
| EicSmearStatistics | |
| EicSmearStep | |
| EicStlAssembly | A collection of facets which compose a distinct solid object in the input STL file |
| EicStlFacet | Three 3D vertices defining one of the facets in STL input file |
| EicStlFacetEdge | A pair of 3D vertices defining one of the three facet edges in STL input file |
| EicStlKey | Naive multi-float-value key used for ordering objects in CAD-related classes; |
| EicStlMediaGroup | |
| EicStlVertex | 3D vertex defined in STL input file |
| EicTrackingRecoHit | |
| EicPlanarRecoHit | |
| EicSpaceRecoHit | |
| Acts::EigenStepper< bfield_t, extensionlist_t, auctioneer_t > | Runge-Kutta-Nystroem stepper based on Eigen implementation for the following ODE: |
| element_t | |
| edge_t | |
| point_t | |
| surface_t | |
| Acts::ElementFraction | |
| ElmergridType | |
| emcChannelLongList | |
| emcChannelShortList | |
| EmcModule | |
| enable_shared_from_this | |
| Acts::Surface | Abstract Base Class for tracking surfaces |
| Acts::ConeSurface | |
| Acts::ConeLayer | |
| Acts::CylinderSurface | |
| Acts::CylinderLayer | |
| Acts::LineSurface | |
| Acts::PerigeeSurface | |
| Acts::StrawSurface | |
| Acts::Test::LineSurfaceStub | |
| Acts::PlaneSurface | |
| Acts::PlaneLayer | |
| Acts::SurfaceStub | Surface derived class stub |
| Acts::LayerStub | |
| enable_shared_from_this< T > | |
| enable_shared_from_this2< T > | |
| Acts::Test::EndOfWorld | Aborter for the case that a particle leaves the detector or reaches a custom made threshold |
| Acts::EndOfWorldReached | |
| ePHENIXRICH::ePHENIXRICHConstruction | This class creates the ePHENIX RICH volumes for Geant4 based on the geometry information in ePHENIXRICH::RICH_Geometry |
| PHG4RICHDetector | This class creates the ePHENIX RICH volumes for Geant4 within Fun4All via ePHENIXRICH::ePHENIXRICHConstruction based on the geometry information in ePHENIXRICH::RICH_Geometry |
| std::error_category | STL class |
| Acts::detail::CombinatorialKalmanFilterErrorCategory | |
| Acts::detail::EigenStepperErrorCategory | |
| Acts::detail::KalmanFitterErrorCategory | |
| Acts::detail::PropagatorErrorCategory | |
| Acts::detail::SurfaceErrorCategory | |
| Acts::detail::VertexingErrorCategory | |
| ActsFatras::detail::DigitizationErrorCategory | |
| errorEntryV1 | |
| Acts::Test::events::Established | |
| ActsFatras::Casts::Eta | Retrieve the direction pseudo-rapidity |
| starlightConstants::event | |
| Event | |
| A_Event | |
| X_Event | |
| X_Event | |
| oncsEvent | |
| Acts::EventDataView3D | |
| Eventiterator | |
| fileEventiterator | |
| listEventiterator | |
| oncsEventiterator | |
| rcdaqEventiterator | |
| testEventiterator | |
| erhic::EventMCFilterABC | |
| eventqacollection | |
| TrackEvaluationContainerv1::EventStruct | Event information |
| EventToDot | |
| ActsFatras::EveryInput | |
| ActsFatras::EveryParticle | No-op particle selector that selects all particles |
| ActsFatras::EverySurface | Select every surface |
| evt_data | |
| std::exception | STL class |
| Acts::AssertionFailureException | Exception type for assertion failures This class captures the information available to the throw_assert macro |
| BranchComparisonHarness::UnsupportedBranchType | |
| genfit::Exception | Exception class for error handling in GENFIT (provides storage for diagnostic information) |
| GFException | Exception class for error handling in GENFIT (provides storage for diagnostic information) |
| nlohmann::detail::exception | General exception of the basic_json class |
| nlohmann::detail::invalid_iterator | Exception indicating errors with iterators |
| nlohmann::detail::other_error | Exception indicating other library errors |
| nlohmann::detail::out_of_range | Exception indicating access out of the defined range |
| nlohmann::detail::parse_error | Exception indicating a parse error |
| nlohmann::detail::type_error | Exception indicating executing a member function with a wrong type |
| eXEvent | |
| ExitWindowV2 | |
| Acts::detail::Extendable< extensions_t > | |
| Acts::detail::Extendable< aborters_t...> | |
| Acts::AbortList< PathLimitReached > | |
| Acts::AbortList< aborters_t > | AbortList object to be used in the propagation |
| Acts::detail::Extendable< actors_t...> | |
| Acts::ActionList< actors_t > | ActionList implementation to be used with the propagator |
| Acts::detail::Extendable< extensions...> | |
| Acts::StepperExtensionList< extensions > | 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) |
| Acts::detail::Extendable< result_list...> | |
| Acts::PropagatorResult< parameters_t, result_list > | Simple class holding result of propagation call |
| Acts::Test::ExtendedMinimalSourceLink | |
| Acts::Extent | |
| external_constructor< value_t > | |
| nlohmann::detail::external_constructor< value_t::array > | |
| nlohmann::detail::external_constructor< value_t::boolean > | |
| nlohmann::detail::external_constructor< value_t::number_float > | |
| nlohmann::detail::external_constructor< value_t::number_integer > | |
| nlohmann::detail::external_constructor< value_t::number_unsigned > | |
| nlohmann::detail::external_constructor< value_t::object > | |
| nlohmann::detail::external_constructor< value_t::string > | |
| genfit::ExtrapStep | Helper for RKTrackRep |
| tetgenmesh::face | |
| Acts::detail::FacesHelper | Helper for writing out faces for polyhedron representation |
| tetgenio::facet | |
| FactoryErrorPolicy | |
| PHGenericFactoryT< AbstractProduct, FactoryErrorPolicy > | |
| ActsFatras::Simulator< charged_selector_t, charged_simulator_t, neutral_selector_t, neutral_simulator_t >::FailedParticle | A particle that failed to simulate |
| FairDbBinaryFile | |
| FairDbCache | |
| FairDbConf | |
| FairDbConfDialog | |
| FairDbConfigStream | |
| FairDbConfigurable | |
| FairDbTableProxyRegistry | |
| FairDbConnection | |
| FairDbConnectionMaintainer | |
| FairDbException | |
| FairDbExceptionLog | |
| FairDbFieldType | |
| FairDbMultConnector | |
| FairDBObjectMemberValue | |
| FairDBObjectMemberValues | |
| FairDbProxy | |
| FairDbResult | |
| FairDbResultAgg | |
| FairDbResultNonAgg | |
| FairDbResultPtr< T > | |
| FairDbResultPtr< FairDbConfigSet > | |
| FairDbRollbackDates | |
| FairDbRowStream | |
| FairDbOutRowStream | |
| FairDbResultSet | |
| FairDbServices | |
| FairDbSimFlagAssociation | |
| FairDbSqlValPacket | |
| FairDbStatement | |
| FairDbString | |
| FairDbSqlContext | |
| FairDbTableMetaData | |
| FairDbTableProxy | |
| FairDbTimer | |
| FairDbTimerManager | |
| FairDbValidityRecBuilder | |
| FairDbValRecSet | |
| FairDbWriter< T > | |
| FairField | |
| EicMagneticField | |
| EicMagneticFieldFromGradients | |
| PndConstField | |
| PndFieldMap | |
| PndDipoleMap | |
| PndSolenoidMap | |
| PndTransMap | |
| PndMultiField | |
| FairFieldFactory | |
| PndFieldCreator | |
| FairRadGridManager | |
| FairRadLenManager | |
| FairRadMapManager | |
| FairRegistry::FairRegistryKey | |
| FairRunIdGenerator | |
| FairTrajFilter | |
| ActsExamples::FakeRatePlotTool::FakeRatePlotCache | Nested Cache struct |
| ActsExamples::FakeRatePlotTool | |
| false_type | |
| Acts::AdaptiveMultiVertexFinder< vfitter_t, sfinder_t >::NeedsRemovedTracks< T, typename > | |
| always_false< T > | |
| nlohmann::detail::is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType > | |
| nlohmann::detail::is_compatible_array_type< BasicJsonType, CompatibleArrayType > | |
| nlohmann::detail::is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType > | |
| nlohmann::detail::is_compatible_integer_type< RealIntegerType, CompatibleNumberIntegerType > | |
| nlohmann::detail::is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType > | |
| nlohmann::detail::is_compatible_object_type< BasicJsonType, CompatibleObjectType > | |
| nlohmann::detail::is_compatible_string_type_impl< BasicJsonType, ConstructibleStringType > | |
| nlohmann::detail::is_compatible_string_type< BasicJsonType, ConstructibleStringType > | |
| nlohmann::detail::is_compatible_type_impl< BasicJsonType, CompatibleType > | |
| nlohmann::detail::is_compatible_type< BasicJsonType, CompatibleType > | |
| nlohmann::detail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType > | |
| nlohmann::detail::is_constructible_array_type< BasicJsonType, ConstructibleArrayType > | |
| nlohmann::detail::is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType > | |
| nlohmann::detail::is_constructible_object_type< BasicJsonType, ConstructibleObjectType > | |
| nlohmann::detail::is_constructible_string_type_impl< BasicJsonType, ConstructibleStringType > | |
| nlohmann::detail::is_constructible_string_type< BasicJsonType, ConstructibleStringType > | |
| nlohmann::detail::has_from_json< BasicJsonType, T, typename > | |
| nlohmann::detail::has_non_default_from_json< BasicJsonType, T, typename > | |
| nlohmann::detail::has_to_json< BasicJsonType, T, typename > | |
| nlohmann::detail::is_basic_json< typename > | |
| nlohmann::detail::is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType, typename > | |
| nlohmann::detail::is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, typename > | |
| nlohmann::detail::is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, typename > | |
| nlohmann::detail::is_compatible_string_type_impl< BasicJsonType, CompatibleStringType, typename > | |
| nlohmann::detail::is_compatible_type_impl< BasicJsonType, CompatibleType, typename > | |
| nlohmann::detail::is_complete_type< T, typename > | |
| nlohmann::detail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, typename > | |
| nlohmann::detail::is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType, typename > | |
| nlohmann::detail::is_constructible_string_type_impl< BasicJsonType, ConstructibleStringType, typename > | |
| nlohmann::detail::is_constructible_tuple< T1, T2 > | |
| nlohmann::detail::is_iterator_traits< T, typename > | |
| nlohmann::detail::is_json_ref< typename > | |
| fastvec | |
| fastvec2d | |
| FCNBase | |
| FCNEllipse | FCN for Minuit |
| FemType | |
| oncsSub_iddreamv0::FEU_decoded_data | |
| genfit::fieldCache | Cache B field at a position. Used by FieldManager |
| Acts::InterpolatedBFieldMapper< G >::FieldCell | Struct representing smallest grid unit in magnetic field grid |
| genfit::FieldManager | Singleton which provides access to magnetic field maps |
| eicpy.build.File | |
| erhic::FileFactory | |
| fileWriter | |
| eventFileWriter | |
| FinderTask | |
| Acts::FiniteStateMachine< Derived, States > | |
| Acts::FiniteStateMachine< fsm, states::Disconnected, states::Connecting, states::Pinging, states::Connected > | |
| Acts::Test::fsm | |
| Acts::FiniteStateMachine< fsm2, states::Disconnected, states::Connected > | |
| Acts::Test::fsm2 | |
| Acts::FiniteStateMachine< fsm3, S1, S2, S3 > | |
| Acts::Test::fsm3 | |
| Acts::detail::FirstValidAuctioneer | Auctioneer that states only the first one that makes a valid bid |
| genfit::FitStatus | Class where important numbers and properties of a fit can be stored |
| genfit::GblFitStatus | FitStatus for use with GblFitter |
| genfit::KalmanFitStatus | FitStatus for use with AbsKalmanFitter implementations |
| Acts::fittable_measurement_helper< source_link_t > | |
| Acts::fittable_volume_measurement_helper< source_link_t > | |
| PHGenFit::Fitter | |
| PHGenFit2::Fitter | |
| ActsExamples::FixedMultiplicityGenerator | |
| ActsExamples::FixedVertexGenerator | |
| dfe::FlatMap< Key, T, Compare > | |
| dfe::FlatSet< T, Compare, Container > | |
| dfe::FlatSet< KeyIndex, KeyCompare > | |
| tetgenmesh::flipconstraints | |
| floatBin | |
| formatError | |
| frec | |
| ActsFatras::FreeParametersSmearer< kParameters > | |
| Acts::Concepts::FreeTrackParametersConceptImpl< T > | |
| PHTimer::Frequency | Internal frequency read from cpu information file |
| FROG | |
| nlohmann::detail::from_json_fn | |
| Acts::Frustum< value_t, DIM, SIDES > | |
| Acts::FsmwMode1dFinder | |
| Acts::detail::full_parset< parameter_indices_t > | Generate ParameterSet type containing all defined parameters |
| Acts::detail::full_parset< BoundIndices > | |
| Acts::detail::full_parset< FreeIndices > | |
| Acts::FullBilloirVertexFitter< input_track_t, linearizer_t > | Vertex fitter class implementing the Billoir vertex fitter |
| Fun4AllBase | |
| Fun4AllEventOutStream | |
| Fun4AllFileOutStream | |
| Fun4AllRolloverFileOutStream | |
| Fun4AllHistoManager | |
| Fun4AllInputManager | |
| Fun4AllDstInputManager | |
| Fun4AllNoSyncDstInputManager | |
| Fun4AllDstPileupInputManager | |
| Fun4AllDummyInputManager | |
| Fun4AllHepMCInputManager | |
| Fun4AllHepMCPileupInputManager | |
| Fun4AllOscarInputManager | |
| Fun4AllPrdfInputManager | |
| Fun4AllSingleDstPileupInputManager | |
| Fun4AllMemoryTracker | |
| Fun4AllOutputManager | |
| Fun4AllDstOutputManager | |
| Fun4AllEventOutputManager | |
| Fun4AllHepMCOutputManager | |
| Fun4AllPrdfOutputManager | |
| Fun4AllServer | |
| Fun4AllSyncManager | |
| SubsysReco | |
| ActsEvaluator | |
| AnalyzeSimpleTree | |
| AnaTutorial | Definition of this analysis module class |
| B0RawTowerBuilderByHitIndex | SubsysReco module creating calorimeter tower objects (RawTowerv1) from hits (PHG4Hit) using j,k indeces of these hits |
| B0TrackFastSim | |
| B0TrackFastSimEval | |
| BbcVertexFastSimReco | Simple truth vertex smearing algorithm |
| BwdRawTowerBuilderByHitIndex | SubsysReco module creating calorimeter tower objects (RawTowerv1) from hits (PHG4Hit) using j,k indeces of these hits |
| CaloAna | |
| CaloCalibEmc_Pi0 | |
| CaloEvaluator | Compares reconstructed showers to truth particles |
| CaloTriggerSim | Simple trigger emulation |
| ClusterIso | |
| CopyAndSubtractJets | Creates subtractd copy of a jet collection |
| CreateCZHitContainer | |
| DecayFinder | |
| DetermineTowerBackground | UE background calculator |
| DSTEmulator | |
| Dumper | |
| EICG4dRICHOptics | |
| EICG4dRICHAerogel | |
| EICG4dRICHFilter | |
| EICG4dRICHGas | |
| EICG4dRICHMirror | |
| EICG4dRICHPhotosensor | |
| EICG4dRICHTree | |
| EICG4RPHitTree | |
| EICG4ZDCHitTree | |
| EICG4ZDCNtuple | |
| EICG4ZDCRawTowerBuilderByHitIndex | SubsysReco module creating calorimeter tower objects (RawTowerZDCv1) from hits (PHG4Hit) using j,k,l indeces of these hits |
| EvalRootTTreeReco | |
| EventEvaluator | Compares reconstructed showers to truth particles |
| EventEvaluatorEIC | Compares reconstructed showers to truth particles |
| FarForwardEvaluator | Compares reconstructed showers to truth particles |
| FermimotionAfterburner | |
| FieldMapReadBack | |
| G4CellNtuple | |
| G4DIRCTree | |
| G4EdepNtuple | |
| G4HitNtuple | |
| G4HitTTree | |
| G4RawTowerTTree | |
| G4ScintillatorSlatTTree | |
| G4ScintillatorTowerTTree | |
| G4SnglNtuple | |
| G4SnglTree | |
| G4TowerNtuple | |
| G4VtxNtuple | |
| GlobalVertexFastSimReco | Simple truth vertex smearing algorithm |
| GlobalVertexReco | Simple truth vertex smearing algorithm |
| HcalRawTowerBuilder | |
| HeadReco | |
| HepMCCompress | |
| HepMCFlowAfterBurner | |
| HepMCNodeReader | |
| InttClusterizer | |
| 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 |
| JetReco | Jet reco with user def inputs and algos |
| KFParticle_sPHENIX | |
| LiteCaloEval | |
| MakeActsGeometry | |
| MakeSimpleTree | |
| MicromegasClusterizer | Micromegas clusterizer |
| MomentumEvaluator | |
| MvtxClusterizer | Clusterizer for the MVTX |
| MyJetAnalysis | |
| ParticleFlowReco | |
| PH3DVertexing | Base class for track seeding |
| PHActsSiliconSeeding | |
| PHActsToSvtxTracks | |
| PHActsTrackProjection | |
| PHActsTrkFitter | |
| PHActsVertexFitter | |
| PHActsVertexPropagator | |
| PHG4BlockCellReco | |
| PHG4CentralityReco | |
| PHG4ConsistencyCheck | |
| PHG4CylinderCellReco | |
| PHG4DstCompressReco | |
| PHG4DSTReader | PHG4DSTReader save information from DST to an evaluator, which could include hit. particle, vertex, towers and jet (to be activated) |
| PHG4ForwardCalCellReco | |
| PHG4FullProjSpacalCellReco | |
| PHG4GenHit | |
| PHG4HcalCellReco | |
| PHG4HeadReco | |
| PHG4HitReadBack | |
| PHG4InEventCompress | |
| PHG4InEventReadBack | |
| PHG4InputFilter | |
| PHG4InttDeadMapLoader | PHG4InttDeadMapLoader loads dead map at inti run |
| PHG4InttDigitizer | |
| PHG4InttHitReco | |
| PHG4MicromegasDigitizer | |
| PHG4MicromegasHitReco | |
| PHG4MvtxDigitizer | |
| PHG4MvtxHitReco | |
| PHG4ParticleGeneratorBase | |
| PHG4IonGun | |
| PHG4ParticleGenerator | |
| PHG4ParticleGenerator_flat_pT | |
| PHG4ParticleGenerator_flat_pT | |
| PHG4ParticleGeneratorD0 | |
| PHG4ParticleGeneratorVectorMeson | |
| PHG4ParticleGun | |
| PHG4PileupGenerator | |
| PHG4SimpleEventGenerator | |
| PHG4Reco | Runs G4 as a subsystem |
| 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 |
| PHG4Subsystem | |
| G4Example01Subsystem | Example Fun4All module |
| G4LmonSubsystem | Example Fun4All module |
| PHG4CEmcTestBeamSubsystem | |
| PHG4DetectorGroupSubsystem | |
| G4JLeicVTXSubsystem | Fun4All module to simulate the Barrel PSTOF detector |
| G4JLeicVTXSubsystem | Fun4All module to simulate the Barrel PSTOF detector |
| PHG4EICMvtxSubsystem | |
| PHG4InttSubsystem | |
| PHG4MvtxSubsystem | |
| PHG4PSTOFSubsystem | Fun4All module to simulate the Barrel PSTOF detector |
| PHG4DetectorSubsystem | |
| AllSi_Al_support_Subsystem | Detector Subsystem module |
| AllSi_Al_support_Subsystem | Detector Subsystem module |
| AllSiliconTrackerSubsystem | Detector Subsystem module |
| AllSiliconTrackerSubsystem | Detector Subsystem module |
| BeamLineMagnetSubsystem | |
| BeastMagnetSubsystem | Detector Subsystem module |
| EicFRichSubsystem | Detector Subsystem module |
| EicFRichSubsystem | Detector Subsystem module |
| EICG4B0ECALSubsystem | Detector Subsystem module |
| EICG4B0Subsystem | Detector Subsystem module |
| EICG4BwdSubsystem | Detector Subsystem module |
| EICG4dRICHSubsystem | Detector Subsystem module |
| EICG4LumiSubsystem | Detector Subsystem module |
| EICG4RPSubsystem | Detector Subsystem module |
| EICG4ZDCSubsystem | Detector Subsystem module |
| EicRootSubsystem | |
| EicRootGemSubsystem | |
| EicRootMuMegasSubsystem | |
| EicRootVstSubsystem | |
| EicToyModelSubsystem | Detector Subsystem module |
| G4EicDircSubsystem | Example Fun4All module |
| G4Example02Subsystem | Example Fun4All module |
| G4Example03Subsystem | Example Fun4All module |
| G4JLeicBeamLineMagnetSubsystem | |
| G4JLeicBeamLineMagnetSubsystem | |
| G4JLeicDIRCSubsystem | Fun4All module to simulate the Barrel PSTOF detector |
| G4JLeicDIRCSubsystem | Fun4All module to simulate the Barrel PSTOF detector |
| G4LBLVtxSubsystem | G4LBLVtxSubsystem is a generic detector built from a GDML import |
| G4LBLVtxSubsystem | G4LBLVtxSubsystem is a generic detector built from a GDML import |
| PHG4BackwardHcalSubsystem | |
| PHG4BarrelEcalSubsystem | |
| PHG4BbcSubsystem | Fun4All module to simulate the BBC detector, aka MBD |
| PHG4BeamlineMagnetSubsystem | |
| PHG4BlockSubsystem | |
| PHG4ConeSubsystem | |
| PHG4CrystalCalorimeterSubsystem | |
| PHG4CylinderStripSubsystem | |
| PHG4CylinderSubsystem | |
| PHG4ECAPToFSubsystem | |
| PHG4EPDSubsystem | |
| PHG4ForwardDualReadoutSubsystem | |
| PHG4ForwardEcalSubsystem | |
| PHG4ForwardHcalSubsystem | |
| PHG4GDMLSubsystem | PHG4GDMLSubsystem is a generic detector built from a GDML import |
| PHG4HybridHomogeneousCalorimeterSubsystem | |
| PHG4InnerHcalSubsystem | |
| PHG4LFHcalSubsystem | |
| PHG4MicromegasSubsystem | Detector Subsystem module The detector is constructed and registered via PHG4MicromegasDetector |
| PHG4mRICHSubsystem | |
| PHG4OuterHcalSubsystem | |
| PHG4SpacalSubsystem | |
| PHG4TpcEndCapSubsystem | Detector Subsystem module |
| PHG4TpcSubsystem | |
| PHG4TRDSubsystem | |
| PHG4TTLSubsystem | |
| PHG4ZDCSubsystem | |
| PHG4EnvelopeSubsystem | |
| PHG4FCalSubsystem | |
| PHG4FPbScSubsystem | |
| PHG4HcalSubsystem | |
| PHG4RICHSubsystem | Fun4All module to simulate the RICH detector |
| PHG4SectorSubsystem | |
| PHG4TruthSubsystem | |
| PHG4TpcCentralMembrane | |
| PHG4TpcDigitizer | |
| PHG4TpcDirectLaser | |
| PHG4TpcElectronDrift | |
| PHG4TpcPadBaselineShift | |
| PHG4TpcPadPlane | |
| PHG4TpcPadPlaneReadout | |
| PHG4TrackFastSim | |
| PHG4TrackFastSimEval | |
| PHG4VertexSelection | |
| PHGenFitTrackProjection | Projects into calorimeters and fills track cal fields |
| PHGenFitTrkFitter | Refit SvtxTracks with PHGenFit |
| PHGeomFileImport | Fun4All module to import TGeo ROOT Geometry at run time |
| PHGhostRejection | |
| PHHepMCParticleSelectorDecayProductChain | |
| PHInitVertexing | Base class for inital vertexing |
| PHActsInitialVertexFinder | |
| PHActsVertexFinder | |
| PHInitZVertexing | |
| PHTruthVertexing | Vertexing using truth info |
| PHMicromegasTpcTrackMatching | |
| PHPatternReco | |
| PHPythia6 | |
| PHPythia8 | |
| PHRaveVertexing | Refit SvtxTracks with PHGenFit |
| PHSartre | |
| PHSiliconTpcTrackMatching | |
| PHSimpleKFProp | |
| PHSimpleVertexFinder | |
| PHTpcCentralMembraneClusterizer | |
| PHTpcClusterMover | |
| PHTpcDeltaZCorrection | |
| PHTpcResiduals | |
| PHTpcTrackSeedCircleFit | |
| PHTrackCleaner | |
| PHTrackFitting | Base class for track seeding |
| PHTrackPropagating | Base class for track seeding |
| PHGenFitTrkProp | Propagate tracklet to full track using GenFit |
| PHTrackSeeding | Base class for track seeding |
| PHCASeeding | |
| PHHoughSeeding | A fun4all implementation of Alan's Hough Transform |
| PHHybridSeeding | |
| PHRTreeSeeding | |
| PHSiliconTruthTrackSeeding | Vertexing using truth info |
| PHTpcTracker | |
| PHTruthTrackSeeding | Vertexing using truth info |
| PHTrackSelector | |
| PHTrackSetMerging | Base class for track seeding |
| PHTrackSetCopyMerging | |
| PHTruthClustering | |
| PHTruthSiliconAssociation | |
| QAExample | |
| QAG4SimulationCalorimeter | |
| QAG4SimulationCalorimeterSum | |
| QAG4SimulationEicCalorimeter | |
| QAG4SimulationEicCalorimeterSum | |
| QAG4SimulationIntt | |
| QAG4SimulationJet | |
| QAG4SimulationKFParticle | |
| QAG4SimulationMicromegas | |
| QAG4SimulationMvtx | |
| QAG4SimulationTpc | |
| QAG4SimulationTracking | |
| QAG4SimulationUpsilon | |
| QAG4SimulationVertex | |
| RawClusterBuilderFwd | |
| RawClusterBuilderGraph | |
| RawClusterBuilderHelper | |
| RawClusterBuilderkMA | |
| RawClusterBuilderkV3 | |
| RawClusterBuilderTemplate | |
| RawClusterBuilderTopo | |
| RawClusterDeadAreaMask | |
| RawClusterPositionCorrection | |
| RawDigitBuilderTTL | SubsysReco module creating calorimeter tower objects (RawTowerv1) from hits (PHG4Hit) using j,k indeces of these hits |
| RawTowerBuilder | |
| RawTowerBuilderByHitIndex | SubsysReco module creating calorimeter tower objects (RawTowerv1) from hits (PHG4Hit) using j,k indeces of these hits |
| RawTowerBuilderByHitIndexBECAL | SubsysReco module creating calorimeter tower objects (RawTowerv1) from hits (PHG4Hit) using j,k indeces of these hits |
| RawTowerBuilderByHitIndexLHCal | SubsysReco module creating calorimeter tower objects (RawTowerv1) from hits (PHG4Hit) using j,k,l indeces of these hits |
| RawTowerBuilderDRCALO | 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 |
| RawTowerDeadMapLoader | RawTowerDeadMapLoader loads dead map at inti run |
| RawTowerDeadTowerInterp | RawTowerDeadTowerInterp recovers the energy in the known dead towers with interpolation between alive towers near-by |
| RawTowerDigitizer | |
| RawTowerZDCCalibration | |
| RawTowerZDCDigitizer | |
| ReadEICFiles | |
| RetowerCEMC | Creates 0.1x0.1-towerized CEMC container |
| SamplingFractionReco | |
| sHEPGen | |
| SimpleNtuple | |
| SimpleNtuple | |
| SubtractTowers | Creates new UE-subtracted towers |
| SubtractTowersCS | Creates new UE-subtracted towers |
| SvtxEvaluator | Compares reconstructed tracks to truth particles |
| SyncReco | |
| TpcClusterCleaner | |
| TpcClusterizer | |
| TPCDataStreamEmulator | TPCDataStreamEmulator |
| TpcDirectLaserReconstruction | |
| TPCFEETestRecov1 | |
| TPCIntegratedCharge | |
| TpcLoadDistortionCorrection | |
| TpcRS | |
| 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 |
| TrackEvaluation | |
| TrackFastSimEval | |
| TrackFastSimEval | |
| TrackFastSimEval | |
| TpcSpaceChargeMatrixInversion | Performs space charge distortion reconstruction using tracks |
| Fun4AllDstPileupMerger | |
| FitNewton::FunctionGradHessian | |
| FitNewton::ChiSquareGradHessian | |
| FitNewton::GaussianGradHessian | |
| FitNewton::GaussianIntegralGradHessian | |
| FitNewton::GaussianRegGradHessian | |
| FitNewton::SquareGradient | |
| HelixDCAFunc | |
| VertexFitFunc | |
| Acts::Test::functor< I > | |
| G4EventTree | |
| G4EvtTree | |
| G4GDMLMatrix | |
| G4GDMLParser | |
| G4GDMLRead | |
| G4GDMLReadDefine | |
| G4GDMLReadParamvol | |
| G4GDMLReadStructure | |
| G4MagneticField | |
| eASTMagneticField | |
| PHG4MagneticField | PHG4MagneticField interfaces with Geant4 |
| PHG4OuterHcalField | PHG4OuterHcalField |
| G4OpBoundaryProcess | |
| G4EicDircOpBoundaryProcess | |
| PrtOpBoundaryProcess | |
| PHG4TruthTrackingAction::G4ParticleInfo | |
| G4Run | |
| eASTRun | |
| G4TBMagneticFieldSetup | |
| PHG4GDMLWriteSolids::G4ThreeVectorCompare | |
| G4UImessenger | |
| eASTDetectorComponentMessenger | |
| eASTDetectorConstructionMessenger | |
| eASTPhysicsListMessenger | |
| eASTPrimGenActionMessenger | |
| eASTRunActionMessenger | |
| Fun4AllMessenger | |
| G4Pythia6DecayerMessenger | |
| G4TBFieldMessenger | |
| G4UIsession | |
| PHG4UIsession | |
| G4UserEventAction | |
| ActsExamples::EventAction | Writes out material track records |
| eASTEventAction | |
| PHG4PhenixEventAction | |
| G4UserRunAction | |
| ActsExamples::RunAction | The material mapping run action |
| eASTRunAction | |
| G4UserStackingAction | |
| eASTStackingAction | |
| PHG4PhenixStackingAction | |
| G4UserSteppingAction | |
| ActsExamples::SteppingAction | Collects the RecordedMaterialSlab entities |
| PHG4FCalSteppingAction | |
| PHG4FPbScRegionSteppingAction | |
| PHG4PhenixSteppingAction | |
| PHG4RICHSteppingAction | This class defines the user stepping action for the ePHENIX RICH volumes within Fun4All |
| G4UserTrackingAction | |
| eASTTrackingAction | |
| PHG4PhenixTrackingAction | |
| PHG4TrackingAction | |
| PHG4TruthTrackingAction | |
| G4VExtDecayer | |
| G4Pythia6Decayer | |
| G4VModularPhysicsList | |
| BasicPhysicsList | |
| BasicPhysicsList | |
| eASTPhysicsList | |
| EICPhysicsList | |
| G4VPhysicsConstructor | |
| AntiBaryonPhysics | |
| eASTAntiBaryonPhysics | |
| eASTGammaLeptoNuclearPhysics | |
| eASTHyperonPhysics | |
| eASTIonPhysics | |
| eASTKaonPhysics | |
| eASTNeutronPhysics | |
| eASTPionPhysics | |
| eASTProtonPhysics | |
| GammaLeptoNuclearPhysics | |
| HyperonPhysics | |
| IonPhysics | |
| KaonPhysics | |
| NeutronPhysics | |
| P6DExtDecayerPhysics | |
| PionPhysics | |
| ProtonPhysics | |
| G4VPrimaryGenerator | |
| eASTHepMC3Interface | |
| G4VPVParameterisation | |
| PHG4EtaParameterization | |
| PHG4EtaPhiParameterization | |
| PHG4InttFPHXParameterisation | |
| G4VUserActionInitialization | |
| eASTActionInitialization | |
| G4VUserDetectorConstruction | |
| ActsExamples::DD4hepDetectorConstruction | Construct the Geant4 detector from a DD4hep description |
| ActsExamples::GdmlDetectorConstruction | Construct the Geant4 detector from a Gdml file |
| BasicDetectorConstruction | |
| BasicDetectorConstruction | |
| eASTDetectorConstruction | |
| PHG4PhenixDetector | This is the main detector construction class, passed to geant to construct the entire phenix detector |
| G4VUserPrimaryGeneratorAction | |
| ActsExamples::PrimaryGeneratorAction | Configures the run |
| eASTPrimaryGeneratorAction | |
| PHG4PrimaryGeneratorAction | |
| G4VUserPrimaryParticleInformation | |
| PHG4UserPrimaryParticleInformation | |
| G4VUserRegionInformation | |
| eASTRegionInformation | |
| PHG4RegionInformation | |
| G4VUserTrackInformation | |
| PHG4TrackUserInfoV1 | |
| Acts::GainMatrixSmoother | Kalman smoother implementation based on Gain matrix formalism |
| Acts::GainMatrixUpdater | Update step of Kalman Filter using gain matrix formalism |
| Acts::GaussianGridTrackDensity< mainGridSize, trkGridSize > | 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 |
| ActsFatras::detail::GaussianMixture | Generate scattering angles using a Gaussian mixture model |
| Acts::GaussianTrackDensity< input_track_t > | 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) |
| Acts::GaussianTrackDensity< input_track_t >::GaussianTrackDensityStore | |
| ActsExamples::GaussianVertexGenerator | |
| gbl::GblData | Data (block) for independent scalar measurement |
| gbl::GblPoint | Point on trajectory |
| genfit::GblTrackSegmentController | TrackSegmentController for use with GblFitter |
| gbl::GblTrajectory | GBL trajectory |
| GCBANK_DEF | |
| ActsFatras::detail::GeneralMixture | |
| ActsExamples::EventGenerator::Generator | |
| PHG4CylinderGeom_Spacalv3::geom_tower | |
| Acts::GeometryHierarchyMap< value_t > | |
| Acts::GeometryHierarchyMap< SourceLinkSelectorCuts > | |
| Acts::GeometryHierarchyMapJsonConverter< value_t > | |
| Acts::GeometryIdentifier | |
| ActsExamples::detail::GeometryIdGetter | |
| Acts::GeometryObject | |
| Acts::Layer | |
| Acts::ConeLayer | |
| Acts::CylinderLayer | |
| Acts::DiscLayer | |
| Acts::LayerStub | |
| Acts::NavigationLayer | |
| Acts::PlaneLayer | |
| Acts::Surface | Abstract Base Class for tracking surfaces |
| Acts::Volume | |
| Acts::AbstractVolume | |
| Acts::TrackingVolume | |
| Acts::GeometryView3D | |
| Acts::detail::get_dimension< N > | Determine number of dimension from power of 2 |
| GFAbsBField | Generic Interface to magnetic fields in GENFIT |
| GFConstField | Constant Magnetic field |
| PndGenfitField | Magnetic field |
| GFAbsRecoHitComparator | |
| GFAbsRecoHitProducer | Abstract interface class for GFRecoHitProducer |
| GFRecoHitProducer< hit_T, recoHit_T > | Template class for a hit producer module |
| GFFieldManager | Singleton which provides access to magnetic field for track representations |
| GFKalman | Generic Kalman Filter implementation |
| GFDaf | Determinstic Annealing Filter (DAF) implementation |
| GFPointPath | |
| genfit::GFRaveVertexFactory | Vertex factory for producing GFRaveVertex objects from Track objects |
| GFRecoHitFactory | Factory object to create RecoHits from digitized and clustered data |
| GL1_1_DATA | |
| GL1_2_DATA | |
| GL1_3_DATA | |
| GL1_EVENT_DATA | |
| GL1_TIME_STAMP | |
| GL1P_DATA | |
| Acts::detail::GlobalNeighborHoodIndices< DIM > | |
| Acts::GlueVolumesDescriptor | |
| GPUTPCBaseTrackParam | |
| GPUTPCTrackParam::GPUTPCTrackFitParam | |
| GPUTPCTrackLinearisation | |
| GPUTPCTrackParam | |
| Acts::detail::Grid< T, Axes > | Class for describing a regular multi-dimensional grid |
| Acts::detail::Grid< external_spacepoint_t > | |
| Acts::detail::Grid< SurfaceVector, Axes...> | |
| Acts::detail::grid_helper | Helper functions for grid-related operations |
| grid_helper_impl< N > | Helper struct to calculate number of bins inside a grid |
| Acts::detail::grid_helper_impl< N > | |
| Acts::detail::grid_helper_impl< 0u > | |
| Acts::GridDensityVertexFinder< mainGridSize, trkGridSize, vfitter_t > | 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 |
| GridType | |
| ActsExamples::GroupBy< Iterator, KeyGetter > | |
| ActsExamples::GroupBy< Iterator, KeyGetter >::GroupIterator | Iterator type representing a group of elements |
| GroupMember | |
| Acts::detail_lt::GrowableColumns< Storage, kSizeIncrement > | |
| half | |
| halfFunction< T > | |
| has_duplicates< Args > | |
| nlohmann::detail::has_from_json< BasicJsonType, T, enable_if_t< not is_basic_json< T >::value > > | |
| nlohmann::detail::has_non_default_from_json< BasicJsonType, T, enable_if_t< not is_basic_json< T >::value > > | |
| nlohmann::detail::has_to_json< BasicJsonType, T, enable_if_t< not is_basic_json< T >::value > > | |
| hash< T > | |
| std::hash< Acts::GeometryIdentifier > | |
| std::hash< Acts::MultiIndex< Storage, BitsPerLevel...> > | |
| std::hash< ActsFatras::Barcode > | |
| std::hash< nlohmann::json > | Hash value for JSON objects |
| std::hash< pair< A, B > > | |
| std::hash< std::array< T, N > > | |
| Acts::HelicalTrackLinearizer< propagator_t, propagator_options_t > | |
| kdfinder::Helix< T > | |
| HelixHough | |
| FourHitSeedFinder | |
| NHitSeedFinder | |
| sPHENIXSeedFinder | |
| sPHENIXTracker | |
| sPHENIXTrackerTpc | |
| ThreeHitSeedGrower | |
| VtxTrackFinder | |
| HelixKalman | |
| CylinderKalman | |
| HelixKalmanFilter | |
| HelixKalmanState | |
| HelixRange | |
| HelixResolution | |
| ActsExamples::HelloData | An example data object to be shared via the event store |
| ActsExamples::HepMC3Event | Helper struct to convert HepMC3 event to the internal format |
| ActsExamples::HepMC3Particle | Helper struct to convert HepMC3 particles to internal format |
| ActsExamples::HepMC3ReaderAscii | HepMC3 event reader |
| ActsExamples::HepMC3Vertex | Helper struct to convert HepMC3 vertex into the internal format |
| hepMC3Writer | |
| ActsExamples::HepMC3WriterAscii | HepMC3 event writer |
| JetHepMCLoader::hepmc_jet_src | |
| Acts::detail::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 |
| ActsFatras::detail::Highland | |
| HijCrdn | Class definition for HijCrdn, which is used to modify the Hijing HIJCRDN common |
| HijCrdn::HIJCRDN | |
| HijJet1 | Class definition for HijJet1, which is used to modify the Hijing HIJJET1 common |
| HijJet1::HIJJET1 | |
| HijJet2 | Class definition for HijJet2, which is used to modify the Hijing HIJJET2 common |
| HijJet2::HIJJET2 | |
| HijJet4 | Class definition for HijJet4, which is used to modify the Hijing HIJJET4 common |
| HijJet4::HIJJET4 | |
| HiMain1 | Class definition for HiMain1, which is used to modify the Hijing HIMAIN1 common |
| HiMain1::HIMAIN1 | |
| HiMain2 | Class definition for HiMain2, which is used to modify the Hijing HIMAIN2 common |
| HiMain2::HIMAIN2 | |
| HiParnt | Class definition for HiParnt, which is used to modify the Hijing HIPARNT common |
| HiParnt::HIPARNT | |
| dfe::Histogram< T, Axes > | |
| HiStrng | Class definition for HiStrng, which is used to modify the Hijing HISTRNG common |
| HiStrng::HISTRNG | |
| ActsFatras::Hit | |
| hit_triplet | |
| ActsExamples::HitData | |
| hitTriplet | |
| Acts::Cuda::Details::HostArrayDeleter | Class performing the deletion of pinned host memory |
| HoughCell | |
| HoughDimension | |
| HoughNodeGroup | |
| FwdHoughNodeGroup | |
| HoughTree | |
| FwdHoughTree | |
| oncsSub_idsrs_v01::hybriddata | |
| ActsExamples::IAlgorithm | |
| ActsExamples::BareAlgorithm | |
| ActsExamples::AdaptiveMultiVertexFinderAlgorithm | |
| ActsExamples::DigitizationAlgorithm | Create planar clusters from simulation hits |
| ActsExamples::FatrasAlgorithm< simulator_t > | |
| ActsExamples::FittingAlgorithm | |
| ActsExamples::GeantinoRecording | |
| ActsExamples::HelloLoggerAlgorithm | A simple algorithm that just prints hello world |
| ActsExamples::HelloRandomAlgorithm | An example algorithm that uses the random number generator to generate data |
| ActsExamples::HelloWhiteBoardAlgorithm | Example algorithm that reads/writes data from/to the event store |
| ActsExamples::HitSmearing | |
| ActsExamples::IterativeVertexFinderAlgorithm | |
| ActsExamples::MaterialMapping | Initiates and executes material mapping |
| ActsExamples::ParticleSelector | Select particles by applying some selection cuts |
| ActsExamples::ParticleSmearing | |
| ActsExamples::PrintHits | Print hits within some geometric region-of-interest |
| ActsExamples::PrintParticles | Print all particles |
| ActsExamples::PropagationAlgorithm< propagator_t > | This test algorithm performs test propagation within the Acts::Propagator |
| ActsExamples::TrackFindingAlgorithm | |
| ActsExamples::TrackSelector | Select tracks by applying some selection cuts |
| ActsExamples::TrkrClusterFindingAlgorithm | |
| ActsExamples::TrkrClusterFittingAlgorithm | |
| ActsExamples::TrkrClusterOutlierFittingAlgorithm | |
| ActsExamples::TruthSeedSelector | |
| ActsExamples::TruthTrackFinder | |
| ActsExamples::TruthVertexFinder | Group particles into proto vertices using truth information |
| ActsExamples::TutorialVertexFinderAlgorithm | |
| ActsExamples::VertexFitterAlgorithm | |
| Acts::IAxis | |
| Acts::detail::Axis< AxisType::Equidistant, bdt > | Calculate bin indices for an equidistant binning |
| Acts::detail::Axis< AxisType::Variable, bdt > | Calculate bin indices for a variable binning |
| ActsExamples::IBaseDetector | |
| AlignedDetector | |
| DD4hepDetector | |
| EmptyDetector | |
| GenericDetector | |
| PayloadDetector | |
| TGeoDetector | |
| IBinFinder | |
| Acts::ATLASBottomBinFinder< SpacePoint > | |
| Acts::ATLASTopBinFinder< SpacePoint > | |
| genfit::ICalibrationParametersDerivatives | Abstract base class to establish an interface between physical representation of the detector for alignment/calibration and (fitted) state on genfit::Track |
| Acts::IConfinedTrackingVolumeBuilder | This is an interface class for constructing TrackingVolumes whose are confined in a mother-TrackingVolume |
| Acts::DD4hepVolumeBuilder | Build confined TrackingVolumes of one cylinder setup from DD4hep input |
| ActsExamples::IContextDecorator | Decorator for the AlgorithmContext with additional event specific information |
| ActsExamples::BField::BFieldScalor | |
| ActsExamples::Contextual::AlignmentDecorator | A mockup service that rotates the modules in a simple tracking geometry |
| ActsExamples::Contextual::PayloadDecorator | A mockup service that rotates the modules in a simple tracking geometry |
| BranchComparisonHarness::IEventLoader | |
| BranchComparisonHarness::EventLoaderT< T > | |
| Acts::IExperimentCuts< SpacePoint > | |
| Acts::ATLASCuts< SpacePoint > | |
| Acts::ATLASCuts< SpacePoint > | |
| Acts::ATLASCuts< SpacePoint > | |
| Acts::IExperimentCuts< external_spacepoint_t > | |
| Acts::IExperimentCuts< TestSpacePoint > | |
| TestHostCuts | Custom selection cuts for the test, used on the host |
| ActsExamples::WhiteBoard::IHolder | |
| ActsExamples::WhiteBoard::HolderT< T, typename > | |
| Acts::ILayerArrayCreator | |
| Acts::LayerArrayCreator | |
| Acts::ILayerBuilder | |
| Acts::DD4hepLayerBuilder | Build layers of one cylinder-endcap setup from DD4hep input |
| Acts::PassiveLayerBuilder | |
| Acts::TGeoLayerBuilder | |
| ActsExamples::Generic::LayerBuilderT< detector_element_t > | |
| Acts::IMaterialDecorator | |
| Acts::JsonMaterialDecorator | Material decorator from Json format |
| Acts::MaterialWiper | |
| ActsExamples::RootMaterialDecorator | Read the collection of SurfaceMaterial & VolumeMaterial |
| ActsExamples::IMaterialWriter | |
| ActsExamples::MaterialWriterT< writer_t > | |
| Acts::ImpactParametersAndSigma | |
| Acts::ImpactPointEstimator< input_track_t, propagator_t, propagator_options_t > | Estimator for impact point calculations |
| Acts::ImpactPointEstimator< InputTrack_t, Propagator_t > | |
| ActsExamples::TrackFinderPerformanceWriter::Impl | |
| Index< T, Tuple > | |
| ActsFatras::PhysicsList< processes_t >::Index< T, std::tuple< T, Types...> > | |
| ActsFatras::PhysicsList< processes_t >::Index< T, std::tuple< U, Types...> > | |
| nlohmann::detail::index_sequence< Ints > | |
| nlohmann::detail::index_sequence< 0 > | |
| nlohmann::detail::make_index_sequence< 1 > | |
| nlohmann::detail::index_sequence< I1...,(sizeof...(I1)+I2)... > | |
| nlohmann::detail::merge_and_renumber< index_sequence< I1...>, index_sequence< I2...> > | |
| nlohmann::detail::index_sequence<> | |
| nlohmann::detail::make_index_sequence< 0 > | |
| Acts::detail_lt::IndexData | |
| nanoflann::IndexDist_Sorter | |
| initialize_parset< T, params > | Initialize parameter set with given parameter values |
| Acts::detail::initialize_parset< T, first, others...> | |
| Acts::detail::initialize_parset< T, last > | |
| Acts::DirectNavigator::Initializer | |
| nlohmann::detail::input_adapter | |
| nlohmann::detail::input_adapter_protocol | Abstract input adapter interface |
| nlohmann::detail::file_input_adapter | |
| nlohmann::detail::input_buffer_adapter | Input adapter for buffer input |
| nlohmann::detail::input_stream_adapter | |
| nlohmann::detail::wide_string_input_adapter< WideStringType > | |
| inputParameters | |
| inputParser | |
| Acts::Test::InputTrack | |
| tetgenmesh::insertvertexflags | |
| IntegerConverter< I > | |
| dfe::Variable::IntegerConverter< I > | |
| dfe::Variable::IntegerConverter< int16_t > | |
| dfe::Variable::Converter< int16_t > | |
| dfe::Variable::IntegerConverter< int32_t > | |
| dfe::Variable::Converter< int32_t > | |
| dfe::Variable::IntegerConverter< int64_t > | |
| dfe::Variable::Converter< int64_t > | |
| dfe::Variable::IntegerConverter< int8_t > | |
| dfe::Variable::Converter< int8_t > | |
| dfe::Variable::IntegerConverter< uint16_t > | |
| dfe::Variable::Converter< uint16_t > | |
| dfe::Variable::IntegerConverter< uint32_t > | |
| dfe::Variable::Converter< uint32_t > | |
| dfe::Variable::IntegerConverter< uint64_t > | |
| dfe::Variable::Converter< uint64_t > | |
| dfe::Variable::IntegerConverter< uint8_t > | |
| dfe::Variable::Converter< uint8_t > | |
| integral_constant | |
| std::tuple_size<::nlohmann::detail::iteration_proxy_value< IteratorType > > | |
| ActsFatras::detail::Interactor< generator_t, physics_list_t, hit_surface_selector_t > | |
| nlohmann::detail::internal_iterator< BasicJsonType > | Iterator value |
| nlohmann::detail::internal_iterator< typename std::remove_const< BasicJsonType >::type > | |
| Acts::InternalSeed< SpacePoint > | |
| Acts::Legacy::InternalSeed< SpacePoint > | |
| Acts::InternalSpacePoint< SpacePoint > | |
| interpolate_impl< T, Point1, Point2, Point3, D, N > | Helper struct for performing multi-dimensional linear interpolation |
| Acts::InterpolatedBFieldMap< Mapper_t > | Interpolate magnetic field value from field values on a given grid |
| Acts::InterpolatedBFieldMapper< G > | Struct for mapping global 3D positions to field values |
| Acts::Intersection< DIM > | |
| Acts::Intersection< 3 > | |
| Acts::detail::IntersectionHelper2D | |
| nanoflann::KDTreeSingleIndexAdaptor< Distance, DatasetAdaptor, DIM, IndexType >::Interval | |
| ActsExamples::Options::Interval | |
| std::ios_base | STL class |
| std::basic_ios< Char > | STL class |
| std::basic_istream< Char > | STL class |
| std::istream | STL class |
| igzstream | |
| std::basic_ostream< Char > | STL class |
| std::ostream | STL class |
| FairLogger | |
| ogzstream | |
| std::ios | STL class |
| gzstreambase | |
| igzstream | |
| ogzstream | |
| ActsExamples::IReader | |
| ActsExamples::CsvParticleReader | |
| ActsExamples::CsvPlanarClusterReader | |
| ActsExamples::EventGenerator | |
| ActsExamples::RootMaterialTrackReader | Reads in MaterialTrack information from a root file and fills it into a format to be understood by the MaterialMapping algorithm |
| nlohmann::detail::is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType, enable_if_t< is_detected< value_type_t, CompatibleArrayType >::value andis_detected< iterator_t, CompatibleArrayType >::value andnot is_iterator_traits< iterator_traits< CompatibleArrayType > >::value > > | |
| nlohmann::detail::is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, enable_if_t< std::is_integral< RealIntegerType >::value andstd::is_integral< CompatibleNumberIntegerType >::value andnot std::is_same< bool, CompatibleNumberIntegerType >::value > > | |
| nlohmann::detail::is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, enable_if_t< is_detected< mapped_type_t, CompatibleObjectType >::value andis_detected< key_type_t, CompatibleObjectType >::value > > | |
| nlohmann::detail::is_compatible_string_type_impl< BasicJsonType, CompatibleStringType, enable_if_t< is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, CompatibleStringType >::value > > | |
| nlohmann::detail::is_compatible_type_impl< BasicJsonType, CompatibleType, enable_if_t< is_complete_type< CompatibleType >::value > > | |
| nlohmann::detail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< not std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value andstd::is_default_constructible< ConstructibleArrayType >::value and(std::is_move_assignable< ConstructibleArrayType >::value or std::is_copy_assignable< ConstructibleArrayType >::value) andis_detected< value_type_t, ConstructibleArrayType >::value andis_detected< iterator_t, ConstructibleArrayType >::value andis_complete_type< detected_t< value_type_t, ConstructibleArrayType > >::value > > | |
| nlohmann::detail::is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType, enable_if_t< is_detected< mapped_type_t, ConstructibleObjectType >::value andis_detected< key_type_t, ConstructibleObjectType >::value > > | |
| nlohmann::detail::is_constructible_string_type_impl< BasicJsonType, ConstructibleStringType, enable_if_t< is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, ConstructibleStringType >::value > > | |
| nlohmann::detail::is_iterator_traits< iterator_traits< T > > | |
| nlohmann::detail::is_sax< SAX, BasicJsonType > | |
| nlohmann::detail::is_sax_static_asserts< SAX, BasicJsonType > | |
| ActsExamples::IService | |
| ActsExamples::BareService | |
| ActsExamples::DD4hep::DD4hepGeometryService | Service creating geometries from dd4hep input |
| ActsExamples::HelloService | A simple service that adds an event block index |
| IsStateFinal | This predicate returns true if the input has no decay vertex |
| Acts::SurfaceArray::ISurfaceGridLookup | Base interface for all surface lookups |
| Acts::SurfaceArray::SingleElementLookup | Lookup implementation which wraps one element and always returns this element when lookup is called |
| Acts::SurfaceArray::SurfaceGridLookup< Axes > | Lookup helper which encapsulates a Grid |
| Acts::ISurfaceMaterial | |
| Acts::BinnedSurfaceMaterial | |
| Acts::HomogeneousSurfaceMaterial | |
| Acts::ProtoSurfaceMaterial | Proxy to SurfaceMaterial hand over BinUtility |
| nlohmann::detail::iter_impl< BasicJsonType > | Template for a bidirectional iterator for the basic_json class This class implements a both iterators (iterator and const_iterator) for the basic_json class |
| nlohmann::detail::iteration_proxy< IteratorType > | Proxy class for the items() function |
| nlohmann::detail::iteration_proxy_value< IteratorType > | |
| Acts::IterativeVertexFinder< vfitter_t, sfinder_t > | Implements an iterative vertex finder |
| PHTimeServer::iterator | Light iterator over PHTimer map |
| Acts::detail::NeighborHoodIndices::iterator | |
| Acts::detail::GlobalNeighborHoodIndices< DIM >::iterator | |
| nlohmann::detail::iterator_traits< T, typename > | |
| nlohmann::detail::iterator_traits< T *, enable_if_t< std::is_object< T >::value > > | |
| nlohmann::detail::iterator_types< It, typename > | |
| nlohmann::detail::iterator_types< It, void_t< typename It::difference_type, typename It::value_type, typename It::pointer, typename It::reference, typename It::iterator_category > > | |
| nlohmann::detail::iterator_types< T > | |
| nlohmann::detail::iterator_traits< T, enable_if_t< !std::is_pointer< T >::value > > | |
| Acts::ITGeoIdentifierProvider | ITGeoIdentierProvider |
| Acts::ITrackingGeometryBuilder | |
| Acts::TrackingGeometryBuilder | |
| Acts::ITrackingVolumeArrayCreator | |
| Acts::TrackingVolumeArrayCreator | |
| Acts::ITrackingVolumeBuilder | |
| Acts::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 |
| Acts::CylinderVolumeBuilder | |
| Acts::ITrackingVolumeHelper | |
| Acts::CylinderVolumeHelper | |
| Acts::IVisualization3D | |
| Acts::ObjVisualization3D< T > | |
| Acts::PlyVisualization3D< T > | Helper to write out PlyVisualization3D visualization format |
| Acts::IVolumeMaterial | Material associated with a Volume (homogenous, binned, interpolated) |
| Acts::HomogeneousVolumeMaterial | |
| Acts::InterpolatedMaterialMap< Mapper_t > | Interpolate material classification values from material values on a given grid |
| Acts::ProtoVolumeMaterial | Proxy to VolumeMaterial hand over BinUtility |
| ActsExamples::IWriter | |
| ActsExamples::CsvTrackingGeometryWriter | |
| ActsExamples::WriterT< write_data_t > | |
| ActsExamples::RootTrackParameterWriter | Writes out SingleBoundTrackParamters into a TTree |
| ActsExamples::WriterT< GeometryIdMultimap< Acts::PlanarModuleCluster > > | |
| ActsExamples::CsvPlanarClusterWriter | |
| ActsExamples::RootPlanarClusterWriter | |
| ActsExamples::WriterT< GeometryIdMultimap< T > > | |
| ActsExamples::JsonSpacePointWriter< T > | |
| ActsExamples::ObjSpacePointWriter< T > | |
| ActsExamples::WriterT< ProtoTrackContainer > | |
| ActsExamples::TrackFinderPerformanceWriter | |
| ActsExamples::WriterT< SimHitContainer > | |
| ActsExamples::RootSimHitWriter | |
| ActsExamples::WriterT< SimParticleContainer > | |
| ActsExamples::CsvParticleWriter | |
| ActsExamples::RootParticleWriter | |
| ActsExamples::WriterT< std::vector< Acts::RecordedMaterialTrack > > | |
| ActsExamples::RootMaterialTrackWriter | Writes out MaterialTrack collections from a root file |
| ActsExamples::WriterT< std::vector< PropagationSteps > > | |
| ActsExamples::RootPropagationStepsWriter | |
| ActsExamples::WriterT< std::vector< std::vector< step_t > > > | |
| ActsExamples::ObjPropagationStepsWriter< step_t > | |
| ActsExamples::WriterT< TrajectoryContainer > | |
| ActsExamples::CKFPerformanceWriter | |
| ActsExamples::RootTrajectoryWriter | |
| ActsExamples::TrackFitterPerformanceWriter | |
| JetAlgo | |
| FastJetAlgo | |
| FastJetAlgoSub | |
| JetEvalStack | |
| JetInput | |
| ClusterJetInput | |
| ParticleFlowJetInput | |
| TowerJetInput | |
| TrackJetInput | |
| TruthJetInput | |
| JetRecoEval | |
| JetTruthEval | |
| JEventProcessor | |
| EicJEventProcessor | |
| JEventSource | |
| EicJEventSource | |
| Json | Writes out Detector material maps using the Json Geometry converter |
| json_pointer< BasicJsonType > | JSON Pointer |
| nlohmann::json_pointer< BasicJsonType > | |
| json_ref< typename > | |
| nlohmann::detail::json_ref< BasicJsonType > | |
| nlohmann::json_sax< BasicJsonType > | SAX interface |
| nlohmann::detail::json_sax_acceptor< BasicJsonType > | |
| nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType > | |
| nlohmann::detail::json_sax_dom_parser< BasicJsonType > | SAX implementation to create a JSON value from SAX events |
| nlohmann::basic_json::json_value | JSON value |
| Acts::JsonGeometryConverter | Read the material from Json |
| ActsExamples::JsonMaterialWriter | |
| KalmanFilter | |
| TrKalmanFilter | |
| HtcKalmanFilter | |
| Acts::KalmanFitter< propagator_t, updater_t, smoother_t, outlier_finder_t, calibrator_t > | Kalman fitter implementation of Acts as a plugin |
| Acts::KalmanFitterOptions< outlier_finder_t > | Options struct how the Fitter is called |
| Acts::KalmanFitterResult< source_link_t > | |
| KalmanNode | |
| TrKalmanNode | |
| KalmanNodeWrapper | |
| kdfinder::KDPointCloud< T > | |
| PHSimpleKFProp::KDPointCloud< T > | |
| kdfinder::KDPointCloud< double > | |
| nanoflann::KDTreeEigenMatrixAdaptor< MatrixType, DIM, Distance > | |
| nanoflann::KDTreeSingleIndexAdaptor< Distance, DatasetAdaptor, DIM, IndexType > | |
| nanoflann::KDTreeSingleIndexAdaptor< nanoflann::L2_Simple_Adaptor< double, kdfinder::KDPointCloud< double > >, kdfinder::KDPointCloud< double >, 3 > | |
| nanoflann::KDTreeSingleIndexAdaptorParams | |
| kdfinder::KDTriplet< T > | |
| dfe::FlatMap< Key, T, Compare >::KeyCompare | |
| dfe::FlatMap< Key, T, Compare >::KeyIndex | |
| Keyword | |
| KfMatrix | |
| KFParticle_DST | |
| KFParticle_sPHENIX | |
| KFParticle_MVA | |
| KFParticle_Tools | |
| KFParticle_eventReconstruction | |
| KFParticle_sPHENIX | |
| KFParticle_particleList | |
| KFParticle_Tools | |
| KFParticle_truthAndDetTools | |
| KFParticle_nTuple | |
| KFParticle_sPHENIX | |
| erhic::KinematicsComputer | |
| erhic::DoubleAngleComputer | |
| erhic::JacquetBlondelComputer | |
| erhic::LeptonKinematicsComputer | |
| nanoflann::KNNResultSet< DistanceType, IndexType, CountType > | |
| nanoflann::L1_Adaptor< T, DataSource, _DistanceType > | |
| nanoflann::L2_Adaptor< T, DataSource, _DistanceType > | |
| nanoflann::L2_Simple_Adaptor< T, DataSource, _DistanceType > | |
| nanoflann::L2_Simple_Adaptor< double, kdfinder::KDPointCloud< double > > | |
| ActsFatras::LandauDistribution | |
| PHG4TpcDirectLaser::Laser | Stores laser position and direction along z |
| PHG4Sector::Layer | |
| Acts::CuboidVolumeBuilder::LayerConfig | This struct stores the data for the construction of a PlaneLayer that has a single PlaneSurface encapsulated |
| Acts::TGeoLayerBuilder::LayerConfig | Helper config structs for volume parsin |
| Acts::LayerCreator | |
| Acts::Test::LayerCreatorFixture | |
| Acts::JsonGeometryConverter::LayerRep | Layer representation for Json writing |
| PHG4mRICHDetector::LensPar | |
| std::less<::nlohmann::detail::value_t > | |
| nlohmann::detail::lexer< BasicJsonType > | Lexical analysis |
| PHG4FullProjSpacalCellReco::LightCollectionModel | |
| Acts::LinCircle | |
| Acts::Cuda::Details::LinCircle | Helper struct holding the linearly transformed coordinates of spacepoints |
| kdfinder::Line< T > | |
| kdfinder::LinearFit< T > | |
| Acts::LinearizedTrack | |
| Acts::Concepts::Linearizer::LinearizerConcept< S > | |
| loaderObj | |
| Acts::Logger | Class for printing debug output |
| Acts::LoggerWrapper | Class that contains (but doesn't own) a logger instance. Is callable so can be used with the logging macros |
| erhic::LogReaderFactory | |
| Acts::detail::LoopProtection< path_arborter_t > | |
| lorentzVector | |
| starlightParticle | |
| Acts::Test::M | |
| Acts::Test::M2 | |
| Acts::Test::M3 | |
| Acts::Test::M4 | |
| Acts::Test::M5 | |
| MagElement | |
| Dipole | |
| Quadrupole | |
| Magnet | |
| MagneticField | |
| genfit::GFRaveMagneticField | GFRaveMagneticField class Uses the FieldManager to provide a magnetic field to rave |
| make_projection_matrix< columns, rows > | Initialize projection matrices |
| Acts::detail::make_projection_matrix< columns, i > | |
| Acts::detail::make_projection_matrix< columns, i, N...> | |
| nlohmann::detail::make_void< Ts > | |
| MatchCandidateGroup | |
| Acts::Material | |
| genfit::Material | |
| Acts::MaterialMapper< G >::MaterialCell | Struct representing smallest grid unit in material grid |
| Acts::MaterialCollector | A Material Collector struct |
| Acts::MaterialComposition | |
| genfit::MaterialEffects | Stepper and energy loss/noise matrix calculation |
| Acts::MaterialHit | The information to be writtern out per hit surface |
| Acts::MaterialInteraction | The Material interaction struct It records the surface and the passed material This is only nessecary recorded when configured |
| Acts::MaterialInteractor | |
| Acts::MaterialMapper< G > | Struct for mapping global 3D positions to material values |
| Acts::Test::MaterialScattering | Simplified material interaction effect by pure gaussian deflection |
| Acts::MaterialSlab | |
| Acts::MaterialSurface | Selector for finding surface |
| Acts::MaterialVolume | Selector for finding volume |
| Acts::VolumeMaterialMapper::MaterialVolumeSelector | Selector for finding |
| Acts::KalmanVertexUpdater::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 |
| genfit::MatStep | Simple struct containing MaterialProperties and stepsize in the material |
| ActsFatras::Max< cast_t > | Select all objects with an extracted value below the cut |
| md5_state_s | |
| Acts::fittable_measurement_helper< source_link_t >::meas_factory< pars > | |
| Acts::fittable_volume_measurement_helper< source_link_t >::meas_factory< pars > | |
| Acts::Test::meas_factory< pars > | |
| Acts::Test::meas_factory2< pars > | |
| PHGenFit::Measurement | |
| PHGenFit::PlanarMeasurement | |
| PHGenFit::SpacepointMeasurement | |
| PHGenFit::SpacepointMeasurement2 | |
| Acts::Measurement< source_link_t, parameter_indices_t, params > | Base class for Measurements |
| Acts::PlanarModuleCluster | |
| Acts::Test::MeasurementCreator | This struct creates FittableMeasurements on the detector surfaces, according to the given smearing xxparameters |
| genfit::MeasurementFactory< measurement_T > | Factory object to create AbsMeasurement objects from digitized and clustered data |
| MediaBank | |
| MediaLayer | |
| MediaSlice | |
| MediaSliceArray | |
| tetgenmesh::memorypool | |
| merge_and_renumber< Sequence1, Sequence2 > | |
| merge_and_renumber< make_index_sequence< N/2 >::type, make_index_sequence< N-N/2 >::type > | |
| nlohmann::detail::make_index_sequence< N > | |
| mesh_t | |
| Acts::Test::A::meta< U, V > | |
| Acts::Test::A2::meta< U > | |
| nanoflann::metric_L1 | |
| nanoflann::metric_L2 | |
| nanoflann::metric_L2_Simple | |
| MgridCell | |
| MgridCombiCell | |
| MgridDirection | |
| MgridHeader | |
| Mgrid | |
| MgridInterpolation | |
| MgridPosition | |
| MgridSlice | |
| Acts::Test::benchmark_tools_internal::MicroBenchmarkIter< Callable, Input > | |
| Acts::Test::benchmark_tools_internal::MicroBenchmarkIter< Callable, void > | |
| Acts::Test::benchmark_tools_internal::MicroBenchmarkIterImpl< Callable, Input, Result > | |
| Acts::Test::benchmark_tools_internal::MicroBenchmarkIterImpl< Callable, Input, void > | |
| Acts::Test::benchmark_tools_internal::MicroBenchmarkIterImpl< Callable, void, Result > | |
| Acts::Test::benchmark_tools_internal::MicroBenchmarkIterImpl< Callable, void, void > | |
| Acts::Test::MicroBenchmarkResult | |
| gbl::MilleBinary | Millepede-II (binary) record |
| ActsFatras::Min< cast_t > | Select all objects with an extracted value equal or larger than the cut |
| Acts::Test::MinimalOutlierFinder | |
| Acts::MinimalSourceLink | |
| ActsExamples::SimIdentifier | |
| miz_indgdef | |
| miz_irdgdef | |
| miz_subdef | |
| Acts::Test::MockPropagatorState | Simplified propagator state |
| Acts::MockTrack | Mock track object with minimal methods implemented for compilation |
| Module | |
| CharmJetModule | |
| ElectronPIDModule | |
| EventSelectionModule | |
| KaonPIDModule | |
| MuonPIDModule | |
| TaggingModule | |
| TaggingStudyModule | |
| ModuleHandler | |
| PHG4mRICHDetector::mRichParameter | |
| msg_control | |
| msgProfile | |
| Acts::MultiIndex< T, BitsPerLevel > | |
| Acts::MultiIndex< uint64_t, 12, 12, 16, 8, 16 > | |
| ActsFatras::Barcode | |
| MultiTrajectory< source_link_t > | |
| Acts::MultiTrajectory< source_link_t > | |
| Acts::MultiTrajectory< SimSourceLink > | |
| Acts::MultiTrajectory< SourceLink > | |
| Acts::Test::MyStruct | |
| Acts::Test::N | |
| Acts::Test::N2 | |
| Acts::Test::N3 | |
| dfe::io_dsv_impl::NamedTupleDsvReader< Delimiter, NamedTuple > | |
| dfe::io_dsv_impl::NamedTupleDsvWriter< Delimiter, NamedTuple > | Write records as delimiter-separated values into a text file |
| dfe::NamedTupleNumpyWriter< NamedTuple > | |
| dfe::NamedTupleRootReader< NamedTuple > | Read records from a ROOT TTree |
| dfe::NamedTupleRootWriter< NamedTuple > | Write records into a ROOT TTree |
| Acts::AxisAlignedBoundingBox< entity_t, value_t, DIM >::NamedType< T, P > | |
| Packet_idcdevdescr::namedVector | |
| NavigationOptions< object_t > | |
| Acts::NavigationOptions< object_t > | Struct for the Navigation options that are forwarded to the geometry |
| Acts::Test::NavigationState | Mockup of navigation state |
| Acts::Navigator | |
| Acts::Test::NavigatorState | |
| nBodyPhaseSpaceGen | |
| SeamStress::Needle | |
| SeamStress::Pincushion< ChiSquareGradHessian > | |
| SeamStress::Pincushion< GaussianRegGradHessian > | |
| SeamStress::Pincushion< sPHENIXSeedFinder > | |
| SeamStress::Pincushion< sPHENIXTracker > | |
| SeamStress::Pincushion< sPHENIXTrackerTpc > | |
| SeamStress::Pincushion< TClass > | |
| ActsFatras::NegativeSelector | Select negatively charged particles |
| Acts::Neighborhood< external_spacepoint_t > | |
| Acts::detail::NeighborHoodIndices | |
| Acts::NeighborhoodIterator< external_spacepoint_t > | |
| Acts::Test::A::Nested | |
| Acts::Test::A2::Nested | |
| nested | |
| Acts::Neutral | Charge and momentum interpretation for neutral particles |
| ActsFatras::NeutralSelector | Select neutral particles |
| FitNewton::NewtonMinimizerGradHessian | |
| NNfunction | |
| Acts::Test::NoCopy | |
| nanoflann::KDTreeSingleIndexAdaptor< Distance, DatasetAdaptor, DIM, IndexType >::Node | |
| node_t | |
| NodeGroup | |
| NodeList | |
| nlohmann::detail::nonesuch | |
| Acts::detail::nonesuch | |
| ActsFatras::NoSurface | Do not select any surface, ever |
| nucleus | |
| beam | |
| Acts::NullBField | Null bfield which returns 0 always |
| std::numeric_limits< half > | |
| Nystrom | |
| O | |
| object | |
| eicpy.binning.Bins | |
| eicpy.binning.BinsLog10 | |
| eicpy.cpplint.CleansedLines | |
| eicpy.qaplots.EventHists | |
| eicpy.qaplots.THWrapper | |
| eicpy.qaplots.TrackHists | |
| eicpy.verify.Histograms | |
| eicpy.verify.DjangohHistograms | |
| eicpy.verify.PythiaHistograms | |
| Acts::Test::Object | |
| ObjectFace | |
| Acts::ObjectIntersection< object_t, representation_t > | Class extensions to return also the object and a representation |
| ActsExamples::ObjTrackingGeometryWriter | |
| oBuffer | |
| ophBuffer | |
| ogzBuffer | |
| olzoBuffer | |
| oamlBuffer | |
| ospBuffer | |
| ODDModuleHelper | |
| oEvent | |
| oncsevt_data | |
| OneHitSpacePointBuilder | |
| OpDet | |
| OpTable | |
| Acts::Test::Options | Mockup of the Propagator Options |
| Acts::TGeoParser::Options | Nested configuration struct |
| Acts::Test::PropagatorState::Options | Emulate the options template |
| tetgenmesh::optparameters | |
| ospEvent | |
| nlohmann::detail::output_adapter< CharType, StringType > | |
| nlohmann::detail::output_adapter_protocol< CharType > | Abstract output adapter interface |
| nlohmann::detail::output_stream_adapter< CharType > | Output adapter for output streams |
| nlohmann::detail::output_string_adapter< CharType, StringType > | Output adapter for basic_string |
| nlohmann::detail::output_vector_adapter< CharType > | Output adapter for byte vectors |
| Acts::Logging::OutputFilterPolicy | Abstract base class for filtering debug output |
| Acts::Logging::DefaultFilterPolicy | Default filter policy for debug messages |
| Acts::Logging::OutputPrintPolicy | Abstract base class for printing debug output |
| Acts::Logging::DefaultPrintPolicy | Default print policy for debug messages |
| Acts::Logging::OutputDecorator | Base class for decorating the debug output |
| Acts::Logging::LevelOutputDecorator | Decorate debug message with its debug level |
| Acts::Logging::MirrorOutputDecorator | Mirror debug message |
| Acts::Logging::NamedOutputDecorator | Decorate debug message with a name |
| Acts::Logging::ThreadOutputDecorator | Decorate debug message with a thread ID |
| Acts::Logging::TimedOutputDecorator | Decorate debug message with a time stamp |
| Acts::Logging::OutStream | Thread-safe output stream |
| dfe::OverflowAxis< T > | |
| ActsFatras::Casts::P | Retrieve the absolute momentum |
| Packet | |
| oncsSubevent | |
| oncsSubevent_w1 | |
| oncsSub_idcstr | |
| oncsSubevent_w2 | |
| oncsSub_id2evt | |
| oncsSub_idtpcfeev2 | |
| oncsSubevent_w4 | |
| oncsSub_id4evt | |
| oncsSub_idbspetdata | |
| oncsSub_idcaenv1742 | |
| oncsSub_idcaenv792 | |
| oncsSub_iddigitizerv1 | |
| oncsSub_iddreamv0 | |
| oncsSub_iddrs4v1 | |
| oncsSub_idfnalmwpc | |
| oncsSub_idfnalmwpcv2 | |
| oncsSub_idmvtxv0 | |
| oncsSub_idmvtxv1 | |
| oncsSub_idmvtxv2 | |
| oncsSub_idrcpetdata | |
| oncsSub_idsis3300 | |
| oncsSub_idsis3300r | |
| oncsSub_idsrs_v01 | |
| oncsSub_idtpcfeev1 | |
| oncsSub_iduppetdata | |
| oncsSub_iduppetdata_v104 | |
| oncsSub_iduppetparams | |
| Packet_A | |
| Packet_w1 | |
| Packet_idcdevdescr | |
| Packet_idcstr | |
| Packet_w2 | |
| Packet_id2evt | |
| Packet_w4 | |
| Packet_cdevbpm | |
| Packet_cdevbuckets | |
| Packet_cdevdvm | |
| Packet_cdevir | |
| Packet_cdevmadch | |
| Packet_cdevpolarimeter | |
| Packet_cdevpoltarget | |
| Packet_cdevring | |
| Packet_cdevringnopol | |
| Packet_cdevwcm | |
| Packet_fvtx_dcm0 | |
| Packet_gl1 | |
| Packet_gl1_evclocks | |
| Packet_gl1p | |
| Packet_gl1psum | |
| Packet_hbd_fpga | |
| Packet_hbd_fpgashort | |
| Packet_id4evt | |
| Packet_id4scaler | |
| Packet_iddigitizerv2 | |
| Packet_starscaler | |
| TPCFEETestRecov1::PadPlaneData | Buffer for full event data |
| Pair | |
| FairDbConfigSet::Param | |
| ActsFatras::LandauDistribution::param_type | Parameter struct that contains all distribution parameters |
| parameterbase | |
| parameter< T, validate > | |
| parameter< bool, NO_VALIDITY_CHECK > | |
| parameter< bool, VALIDITY_CHECK > | |
| parameter< double, VALIDITY_CHECK > | |
| parameter< int, NO_VALIDITY_CHECK > | |
| parameter< int, VALIDITY_CHECK > | |
| parameter< std::string, NO_VALIDITY_CHECK > | |
| parameter< unsigned int, VALIDITY_CHECK > | |
| ParameterCluster | |
| parameterlist | |
| ParameterSet< parameter_indices_t, params > | |
| Acts::ParameterSet< parameter_indices_t, params > | Description of a set of (local) parameters |
| Acts::ParameterSet< parameter_indices_t, params...> | |
| ActsFatras::detail::ParametersSmearer< indices_t, kParameters > | |
| ParametersTraitsImpl< indices_t > | |
| Acts::detail::ParametersTraitsImpl< BoundIndices > | |
| Acts::detail::ParametersTraitsImpl< FreeIndices > | |
| ParameterTraitsImpl< index_t, kIndex > | |
| Acts::detail::ParameterTraitsImpl< BoundIndices, BoundIndices::eBoundPhi > | |
| Acts::detail::ParameterTraitsImpl< BoundIndices, BoundIndices::eBoundTheta > | |
| Acts::detail::ParameterTraitsImpl< BoundIndices, kIndex > | |
| Acts::detail::ParameterTraitsImpl< FreeIndices, kIndex > | |
| ActsExamples::ParametricParticleGenerator | |
| ParRange | |
| nlohmann::detail::parser< BasicJsonType > | Syntax analysis |
| ActsFatras::Particle | Simulation particle information and kinematic state |
| ActsExamples::ParticleData | |
| ActsExamples::ParticleHitCount | Associate a particle to its hit count within a proto track |
| ParticleIdentifier | |
| ActsFatras::detail::Interactor< generator_t, physics_list_t, hit_surface_selector_t >::ParticleNotAlive | Abort if the particle was killed during a previous interaction |
| ParticleSelector | |
| ActsFatras::AsInputSelector< ParticleSelector > | Enable usage of a particle selector as an input selector |
| ActsFatras::ParticleSimulator< propagator_t, physics_list_t, hit_surface_selector_t > | |
| ActsFatras::PathLimitL0 | Select particles whose L0 limit would be reached after material passage |
| Acts::PathLimitReached | This is the condition that the pathLimit has been reached |
| ActsFatras::PathLimitX0 | Select particles whose X0 limit would be reached after material passage |
| PdbApplication | |
| PgPostApplication | |
| PdbBankManager | |
| PgPostBankManager | |
| PdbCalBankIterator | |
| PgPostCalBankIterator | |
| PdbClassMap< T > | |
| ActsFatras::PdgExcluder< Pdg > | |
| ActsFatras::PdgSelector< Pdg > | |
| Acts::Test::PerpendicularMeasure | An observer that measures the perpendicular distance |
| PgPostBankBackupLog | PgPostBankBackupLog |
| PgPostBankBackupManager | PgPostBankBackupManager |
| PgPostBankWrapperManager | |
| PHBBox | |
| PHField | Transient object for field storage and access |
| PHField2D | |
| PHField3DCartesian | |
| PHField3DCylindrical | |
| PHFieldBeast | |
| PHFieldCleo | |
| PHFieldUniform | |
| PHFieldUtility | Toolsets to do geometry operations |
| PHFlag | |
| recoConsts | |
| PHG4Detector | Base class for phenix detector creation |
| AllSi_Al_support_Detector | |
| AllSi_Al_support_Detector | |
| AllSiliconTrackerDetector | |
| AllSiliconTrackerDetector | |
| BeamLineMagnetDetector | |
| BeastMagnetDetector | |
| EicFRichDetector | |
| EicFRichDetector | |
| EICG4B0Detector | |
| EICG4B0ECALDetector | |
| EICG4BwdDetector | |
| EICG4dRICHDetector | |
| EICG4LumiDetector | |
| EICG4RPDetector | |
| EICG4ZDCDetector | |
| EicRootDetector | |
| EicToyModelDetector | |
| G4EicDircDetector | |
| G4Example01Detector | |
| G4Example02Detector | |
| G4Example03Detector | |
| G4JLeicBeamLineMagnetDetector | |
| G4JLeicBeamLineMagnetDetector | |
| G4JLeicDIRCDetector | |
| G4JLeicDIRCDetector | |
| G4JLeicVTXDetector | |
| G4JLeicVTXDetector | |
| G4LBLVtxDetector | G4LBLVtxDetector is a generic detector built from a GDML import |
| G4LBLVtxDetector | G4LBLVtxDetector is a generic detector built from a GDML import |
| G4LmonDetector | |
| PHG4BackwardHcalDetector | |
| PHG4BarrelEcalDetector | |
| PHG4BbcDetector | |
| PHG4BeamlineMagnetDetector | |
| PHG4BlockDetector | |
| PHG4CEmcTestBeamDetector | |
| PHG4ConeDetector | |
| PHG4CrystalCalorimeterDetector | |
| PHG4ProjCrystalCalorimeterDetector | |
| PHG4CylinderDetector | |
| PHG4CylinderStripDetector | |
| PHG4ECAPToFDetector | |
| PHG4EICMvtxDetector | |
| PHG4EnvelopeDetector | |
| PHG4EPDDetector | |
| PHG4FCalDetector | |
| PHG4ForwardDualReadoutDetector | |
| PHG4ForwardEcalDetector | |
| PHG4EICForwardEcalDetector | |
| PHG4ForwardHcalDetector | |
| PHG4FPbScDetector | |
| PHG4GDMLDetector | PHG4GDMLDetector is a generic detector built from a GDML import |
| PHG4HcalDetector | |
| PHG4HybridHomogeneousCalorimeterDetector | |
| PHG4InnerHcalDetector | |
| PHG4InttDetector | |
| PHG4LFHcalDetector | |
| PHG4MicromegasDetector | |
| PHG4mRICHDetector | |
| PHG4MvtxDetector | |
| PHG4OuterHcalDetector | |
| PHG4PSTOFDetector | |
| PHG4RICHDetector | This class creates the ePHENIX RICH volumes for Geant4 within Fun4All via ePHENIXRICH::ePHENIXRICHConstruction based on the geometry information in ePHENIXRICH::RICH_Geometry |
| PHG4SectorDetector | |
| PHG4SpacalDetector | |
| PHG4FullProjSpacalDetector | |
| PHG4FullProjTiltedSpacalDetector | Fully projective SPACAL built from 2D tapered modules and allow azimuthal tilts |
| PHG4TpcDetector | |
| PHG4TpcEndCapDetector | |
| PHG4TRDDetector | |
| PHG4TTLDetector | |
| PHG4ZDCDetector | |
| PHG4DisplayAction | |
| AllSi_Al_support_DisplayAction | |
| AllSi_Al_support_DisplayAction | |
| AllSiliconTrackerDisplayAction | |
| AllSiliconTrackerDisplayAction | |
| BeamLineMagnetDisplayAction | |
| BeastMagnetDisplayAction | |
| G4EicDircDisplayAction | |
| G4Example03DisplayAction | |
| G4JLeicBeamLineMagnetDisplayAction | |
| G4JLeicBeamLineMagnetDisplayAction | |
| G4JLeicDIRCDisplayAction | |
| G4JLeicDIRCDisplayAction | |
| G4JLeicVTXDisplayAction | |
| G4JLeicVTXDisplayAction | |
| G4LBLVtxDisplayAction | |
| G4LBLVtxDisplayAction | |
| PHG4BackwardHcalDisplayAction | |
| PHG4BarrelEcalDisplayAction | |
| PHG4BbcDisplayAction | |
| PHG4BlockDisplayAction | |
| PHG4ConeDisplayAction | |
| PHG4CrystalCalorimeterDisplayAction | |
| PHG4CylinderDisplayAction | |
| PHG4EPDDisplayAction | |
| PHG4ForwardDualReadoutDisplayAction | |
| PHG4ForwardEcalDisplayAction | |
| PHG4ForwardHcalDisplayAction | |
| PHG4HybridHomogeneousCalorimeterDisplayAction | |
| PHG4InnerHcalDisplayAction | |
| PHG4InttDisplayAction | |
| PHG4LFHcalDisplayAction | |
| PHG4MvtxDisplayAction | |
| PHG4OuterHcalDisplayAction | |
| PHG4PhenixDisplayAction | |
| PHG4RICHDisplayAction | |
| PHG4SectorDisplayAction | |
| PHG4SpacalDisplayAction | |
| PHG4TpcDisplayAction | |
| PHG4TpcEndCapDisplayAction | |
| PHG4TTLDisplayAction | |
| PHG4ZDCDisplayAction | |
| PHG4EventAction | |
| G4LmonEventAction | |
| PHG4EventActionClearZeroEdep | |
| PHG4TruthEventAction | |
| PHG4GDMLAuxStructType | |
| PHG4GDMLUtility | PHG4GDMLUtility is utility class that drive the PHG4GDMLWriteStructure |
| PHG4GDMLWrite | |
| PHG4GDMLWriteDefine | |
| PHG4GDMLWriteMaterials | |
| PHG4GDMLWriteSolids | |
| PHG4GDMLWriteSetup | |
| PHG4GDMLWriteParamvol | |
| PHG4GDMLWriteStructure | |
| PHG4OuterHcalFieldSetup | PHG4OuterHcalFieldSetup following Geant4 example F03FieldSetup |
| PHG4Sector::PHG4SectorConstructor | Generalized detector which use sectors of flat panels to cover full azimuthal acceptance |
| PHG4SectorDetector | |
| PHG4StackingAction | |
| G4EicDircStackingAction | |
| PHG4SteppingAction | |
| AllSi_Al_support_SteppingAction | |
| AllSi_Al_support_SteppingAction | |
| AllSiliconTrackerSteppingAction | |
| AllSiliconTrackerSteppingAction | |
| BeamLineMagnetSteppingAction | |
| BeastMagnetSteppingAction | |
| EicFRichSteppingAction | |
| EicFRichSteppingAction | |
| EICG4B0ECALSteppingAction | |
| EICG4B0SteppingAction | |
| EICG4BwdSteppingAction | |
| EICG4dRICHSteppingAction | |
| EICG4LumiSteppingAction | |
| EICG4RPSteppingAction | |
| EICG4ZDCSteppingAction | |
| G4EicDircSteppingAction | |
| G4Example01SteppingAction | |
| G4Example02SteppingAction | |
| G4Example03SteppingAction | |
| G4JLeicBeamLineMagnetSteppingAction | |
| G4JLeicBeamLineMagnetSteppingAction | |
| G4JLeicDIRCSteppingAction | |
| G4JLeicDIRCSteppingAction | |
| G4JLeicVTXSteppingAction | |
| G4JLeicVTXSteppingAction | |
| G4LBLVtxSteppingAction | |
| G4LBLVtxSteppingAction | |
| G4LmonSteppingAction | |
| GdmlImportDetectorSteppingAction | |
| PHG4BackwardHcalSteppingAction | |
| PHG4BarrelEcalSteppingAction | |
| PHG4BbcSteppingAction | |
| PHG4BlockSteppingAction | |
| PHG4CEmcTestBeamSteppingAction | |
| PHG4ConeSteppingAction | |
| PHG4CrystalCalorimeterSteppingAction | |
| PHG4CylinderSteppingAction | |
| PHG4CylinderStripSteppingAction | |
| PHG4ECAPToFSteppingAction | |
| PHG4EICMvtxSteppingAction | |
| PHG4EnvelopeSteppingAction | |
| PHG4EPDSteppingAction | |
| PHG4ForwardDualReadoutSteppingAction | |
| PHG4ForwardEcalSteppingAction | |
| PHG4ForwardHcalSteppingAction | |
| PHG4FPbScSteppingAction | |
| PHG4HcalSteppingAction | |
| PHG4HybridHomogeneousCalorimeterSteppingAction | |
| PHG4InnerHcalSteppingAction | |
| PHG4InttSteppingAction | |
| PHG4LFHcalSteppingAction | |
| PHG4MicromegasSteppingAction | |
| PHG4mRICHSteppingAction | |
| PHG4MvtxSteppingAction | |
| PHG4OuterHcalSteppingAction | |
| PHG4PSTOFSteppingAction | |
| PHG4SectorSteppingAction | |
| PHG4SpacalSteppingAction | |
| PHG4TpcEndCapSteppingAction | |
| PHG4TpcSteppingAction | |
| PHG4TRDSteppingAction | |
| PHG4TTLSteppingAction | |
| PHG4ZDCSteppingAction | |
| PHG4TpcDistortion | Handle distortions (static and time-ordered) |
| PHG4Utils | |
| PHGeomUtility | Toolsets to do geometry operations |
| PHHepMCGenHelper | PHHepMCGenHelper provides service of DST upload of HepMC subevent, vertex assignment and random generator |
| Fun4AllHepMCInputManager | |
| Fun4AllOscarInputManager | |
| PHPythia6 | |
| PHPythia8 | |
| PHSartre | |
| ReadEICFiles | |
| sHEPGen | |
| Acts::detail::PhiBoundParameterLimits | |
| PHIOManager | |
| PHNodeIOManager | |
| PHRawOManager | |
| PHLog | |
| PHmd5Value | |
| PHNode | |
| PHCompositeNode | |
| PHDataNode< T > | |
| PHIODataNode< T > | |
| PHDataNode< PHDWORD > | |
| PHRawDataNode | |
| PHNodeIterator | |
| PHDataNodeIterator | |
| PHTypedNodeIterator< T > | |
| PHNodeOperation | |
| PHNodeDump | |
| PHNodeIntegrate | |
| PHNodeReset | |
| PHOperation< T > | |
| photonNucleusCrossSection | |
| e_narrowResonanceCrossSection | |
| e_wideResonanceCrossSection | |
| incoherentPhotonNucleusLuminosity | |
| incoherentVMCrossSection | |
| narrowResonanceCrossSection | |
| photonElectronLuminosity | |
| photonNucleusLuminosity | |
| wideResonanceCrossSection | |
| PHParameterContainerInterface | |
| PHG4BlockCellReco | |
| PHG4CylinderCellReco | |
| PHG4MvtxHitReco | |
| PHParameterInterface | |
| HcalRawTowerBuilder | |
| PHG4FullProjSpacalCellReco | |
| PHG4HcalCellReco | |
| PHG4InttDigitizer | |
| PHG4InttHitReco | |
| PHG4MicromegasDigitizer | |
| PHG4MicromegasHitReco | |
| PHG4TpcCentralMembrane | |
| PHG4TpcDirectLaser | |
| PHG4TpcElectronDrift | |
| PHG4TpcPadPlane | |
| PHG4VertexSelection | |
| PHTpcDeltaZCorrection | |
| TpcDirectLaserReconstruction | |
| 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 |
| PHPointerList< T > | |
| PHPointerList< PdbCalBank > | |
| PdbBankList | |
| PHPointerList< PHNode > | |
| PHPointerListIterator< T > | |
| PHPointerListIterator< PdbCalBank > | |
| PdbBankListIterator | |
| PHPy6GenTrigger | |
| PHPy6ForwardElectronTrig | |
| PHPy6JetTrigger | |
| PHPy6ParticleTrigger | |
| PHPy8GenTrigger | |
| PHPy8JetTrigger | |
| PHPy8ParticleTrigger | |
| PHRandomSeed | |
| PHSartreGenTrigger | |
| PHSartreParticleTrigger | |
| 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 |
| PHTimer | |
| PHTimeServer | PHTimer server for accessing external information |
| PHTpcEventExporter | |
| PHTpcLookup | |
| PHTpcSeedFinder | |
| PHTpcTrackFollower | |
| PHTpcVertexFinder | |
| ActsFatras::PhysicsList< processes_t > | |
| erhic::Pid | |
| PID | |
| tofBarrel | |
| pidqacollection | |
| Pincushion< TClass > | |
| Pincushion< TClass > | |
| Pincushion< TClass > | |
| Pincushion< TClass > | |
| Pincushion< TClass > | |
| Acts::Test::events::Ping | |
| Acts::Test::states::Pinging | |
| Acts::PlanarModuleStepper | |
| Acts::Test::PlaneSelector | |
| PlaneSurfaceBuilder | Construct a plane at track position with plane normal along track tangent |
| plot_config | |
| Acts::Test::PlyElement | Ply element struct |
| pmonstate | |
| pMutex | |
| PndStringSeparator | |
| tetgenio::pointparam | |
| Acts::detail::PointwiseMaterialInteraction | Struct to handle pointwise material interaction |
| ActsExamples::PoissonMultiplicityGenerator | |
| tetgenio::polygon | |
| Acts::Polyhedron | |
| boost::detail::polymorphic_cast_tag | |
| PHG4mRICHDetector::PolyPar | |
| Acts::Test::events::Pong | |
| nanoflann::PooledAllocator | |
| nlohmann::detail::position_t | Struct to capture the start position of the current token |
| ActsFatras::PositiveSelector | Select positively charged particles |
| ActsExamples::detail::PrimaryVertexIdGetter | |
| nlohmann::detail::primitive_iterator_t | |
| nlohmann::detail::priority_tag< N > | |
| nlohmann::detail::priority_tag< 0 > | |
| ActsFatras::Process< physics_t, input_selector_t, output_particle_selector_t, child_particle_selector_t > | |
| ProcessNoise | |
| PHGenericFactoryT< AbstractProduct, FactoryErrorPolicy >::ProductCreatorPair | |
| Acts::Propagator< stepper_t, navigator_t > | Propagator for particles (optionally in a magnetic field) |
| Propagator | |
| genfit::GFRavePropagator | GFRavePropagator class |
| Acts::Propagator< StraightLineStepper, Navigator > | |
| Acts::PropagatorPlainOptions | Class holding the trivial options in propagator options |
| Acts::PropagatorOptions< action_list_t, aborter_list_t > | Options for propagate() call |
| Acts::DenseStepperPropagatorOptions< action_list_t, aborter_list_t > | |
| Acts::Test::PropagatorState | Mockup of propagtor state |
| Acts::Test::PropState< stepper_state_t > | Simplified propagator state |
| Acts::SurfaceArrayCreator::ProtoAxis | |
| Acts::ProtoLayer | |
| ActsExamples::Generic::ProtoLayerCreatorT< detector_element_t > | |
| Acts::ProtoLayerHelper | |
| ActsExamples::Generic::ProtoLayerSurfaces | |
| genfit::PruneFlags | Info which information has been pruned from the Track |
| ActsFatras::Casts::Pt | Retrieve the transverse momentum |
| Pydat1_t | PYDAT1 common-block |
| Pydat3_t | PYDAT3 common-block |
| Pyjets_t | PYJETS common-block |
| erhic::Pythia6 | |
| Pythia6 | |
| Pythia6Particle | Structure for Pythia6 particle properties |
| erhic::Pythia6ParticleBuilder | Factory class for Monte Carlo particles |
| ActsExamples::Pythia8Generator | |
| pythiaDecayer | |
| pythiaInterface | |
| pythiaStarlight | |
| qaparameters | |
| Acts::Sycl::QueueWrapper | |
| nanoflann::RadiusResultSet< DistanceType, IndexType > | |
| randomGenerator | |
| ActsExamples::RandomNumbers | < Mersenne Twister |
| ActsFatras::Range< cast_t > | |
| ActsExamples::Range< Iterator > | |
| RanSeed::RANSEED | |
| RanSeed | Class definition for RanSeed, which is used to modify the Hijing RANSEED common |
| RawClusterUtility | RawClusterUtility |
| Acts::Ray< value_t, DIM > | |
| erhic::Reader | |
| readLuminosity | |
| eventChannel | |
| Gammaavectormeson | |
| e_Gammaanarrowvm | |
| e_Gammaawidevm | |
| Gammaaincoherentvm | |
| Gammaanarrowvm | |
| Gammaawidevm | |
| Gammagammasingle | |
| starlightPythia | |
| RealQuadradicEquation | |
| Acts::detail::RealQuadraticEquation | |
| PHG4DSTReader::record | |
| RecursiveMomentumContainer | |
| RecursiveMomentumContainerEnd | |
| Acts::detail::ReferenceObject< T > | Deduction of the measuring geometry object based on the used indices |
| Acts::detail::ReferenceObject< BoundIndices > | |
| Acts::detail::ReferenceObject< FreeIndices > | |
| oncsSub_idsrs_v01::report | |
| ResidualOutlierFinder | |
| ResolutionLevel | |
| ActsExamples::ResPlotTool::ResPlotCache | Nested Cache struct |
| ActsExamples::ResPlotTool | |
| Acts::detail::RestrictedParameterTraits< limits_t > | |
| Acts::Result< T, E > | |
| Acts::MaterialInteractor::Result | |
| Acts::Test::Result | |
| Acts::Result< void > | |
| Acts::Result< void, E > | |
| Acts::Test::ActorA::result_type | |
| Acts::Test::ActorB::result_type | |
| Acts::detail::result_type_extractor | |
| Acts::Propagator< stepper_t, navigator_t >::result_type_helper< parameters_t, action_list_t > | Helper struct determining the result's type |
| Acts::RiddersPropagator< propagator_t >::result_type_helper< parameters_t, action_list_t > | Helper struct determining the result's type. |
| reverse_iterator | |
| nlohmann::detail::json_reverse_iterator< Base > | Template for a reverse iterator class |
| ePHENIXRICH::RICH_Geometry | This class provides geometry and material parameters to construct the ePHENIX RICH detector in ePHENIXRICHConstruction |
| richChannelList | |
| Acts::RiddersPropagator< propagator_t > | This class performs the Ridders algorithm to estimate the propagation of the covariance to a certain point in space |
| RingElectronParam | Input Parameters for ANN for electron identification in RICH |
| RingSelectParam | Input Parameters for ANN |
| genfit::RKMatrix< nRows, nCols > | |
| genfit::RKMatrix< 1, 7 > | |
| genfit::RKMatrix< 7, 7 > | |
| genfit::RKStep | Helper for RKTrackRep |
| ActsExamples::RootBFieldWriter< bfield_t > | |
| Acts::Test::RootGeometry | Struct to load the global geometry |
| ActsExamples::RootMaterialWriter | Material decorator from Root format |
| RootOut | |
| Rossegger | |
| RungeKutta | |
| RungeKuttaRequest | |
| RunToTime | |
| RunToTimePg | |
| Acts::Test::S1 | |
| Acts::Test::S2 | |
| Acts::Test::S3 | |
| Acts::SameSurfaceIntersection | |
| TPCDaqDefs::FEEv1::SampleFit_PowerLawDoubleExp_PDFMaker | |
| TPCFEETestRecov1::PadPlaneData::SampleID | |
| ActsExamples::BField::ScalableBField | Returns a given constant field value at every point |
| ActsExamples::BField::ScalableBFieldContext | The Context to be handed around |
| ActsFatras::detail::Scattering< scattering_model_t > | |
| PHG4CylinderGeom_Spacalv3::scint_id_coder | Compact ID of each fiber in 32bit PHG4Hit::set_scint_id(). Buffer the result for repeated use |
| sdm | |
| sdm_c_blockdef | |
| SeamStress::Seamstress | |
| nanoflann::SearchParams | |
| sebAlignBlk | |
| ActsExamples::detail::SecondaryVertexIdGetter | |
| PHG4Sector::Sector_Geometry | |
| Acts::Seed< SpacePoint > | |
| Acts::Legacy::Seed< SpacePoint > | |
| seedComparator | |
| Acts::Sycl::detail::SeedData | |
| Acts::SeedFilter< external_spacepoint_t > | |
| Acts::SeedFilterConfig | |
| Acts::Seedfinder< external_spacepoint_t, platform_t > | |
| Acts::Sycl::Seedfinder< external_spacepoint_t > | |
| Acts::Cuda::SeedFinder< external_spacepoint_t > | |
| Acts::Seedfinder< external_spacepoint_t, Acts::Cuda > | |
| Acts::SeedfinderConfig< SpacePoint > | |
| Acts::SeedfinderConfig< external_spacepoint_t > | |
| Acts::Segmentation | Segmentation Base class |
| Acts::CartesianSegmentation | Segmentation Base class |
| SegmentationAlpide | |
| Acts::TGeoParser::SelectedNode | |
| SensitiveVolume | |
| ActsExamples::Sequencer | |
| nlohmann::detail::serializer< BasicJsonType > | |
| ServiceStructure | |
| shared_ptr< T > | |
| boost::shared_ptr< T > | |
| boost::shared_ptr< TClonesArray > | |
| boost::detail::shared_ptr_traits< T > | |
| boost::detail::shared_ptr_traits< void > | |
| boost::detail::shared_ptr_traits< void const > | |
| boost::detail::shared_ptr_traits< void const volatile > | |
| boost::detail::shared_ptr_traits< void volatile > | |
| Acts::SharedBField< BField > | Allows to use a shared magnetic field in several places and with multiple steppers mainly targeted to save memory |
| genfit::SharedPlanePtrCreator | |
| Shifter | |
| ActsExamples::SimMultiTrajectory | Struct for truth track fitting/finding result with Acts::KalmanFitter/Acts::CombinatorialKalmanFilter |
| SimpleHit3D | |
| simpleRandom | |
| SimpleTrack3D | |
| ActsExamples::SimSourceLink | |
| ActsFatras::SimulationResult | |
| ActsFatras::Simulator< charged_selector_t, charged_simulator_t, neutral_selector_t, neutral_simulator_t > | |
| ActsExamples::SimVertex | A simultated vertex e.g. from a physics process |
| sinfo | Information on a given surface |
| Acts::SingleBoundTrackParameters< charge_t > | |
| Acts::SingleCurvilinearTrackParameters< charge_t > | |
| Acts::SingleBoundTrackParameters< SinglyCharged > | |
| ActsFatras::detail::SingleComponentSmearer< values_t, covariance_t > | |
| Acts::SingleFreeTrackParameters< charge_t > | |
| Acts::SinglyCharged | Charge and momentum interpretation for particles with +-e charge |
| Acts::AxisAlignedBoundingBox< entity_t, value_t, DIM >::SizeParameter | |
| dfe::SmallVector< T, N, Allocator > | |
| ActsFatras::SmearInput | |
| Acts::SolenoidBField | |
| source_electron | |
| Acts::Concepts::detail_slc::SourceLinkConcept< T > | |
| Acts::SourceLinkSelectorCuts | |
| boost::detail::sp_enable_if_auto_ptr< T, R > | |
| boost::detail::sp_enable_if_auto_ptr< std::auto_ptr< T >, R > | |
| Acts::Cuda::Details::SpacePoint | Helper struct describing a spacepoint on the device |
| Acts::SpacePoint< Cluster > | Structure for easier bookkeeping of space points |
| SpacePoint | |
| Acts::SpacePointBuilder< S > | |
| Acts::SpacePointBuilder< SpacePoint< Cluster > > | |
| Acts::SpacePointGridConfig | |
| Acts::SpacePointGridCreator | |
| Acts::detail::SpacePointParameters | Storage container for variables related to the calculation of space points |
| spectrum | |
| spectrumProtonNucleus | |
| Acts::Legacy::SPForSeed< SpacePoint > | |
| oncsSub_idfnalmwpc::SpillInfo | |
| oncsSub_idfnalmwpcv2::SpillInfo | |
| Splitter | |
| starlightParticleCodes | |
| Acts::HelicalTrackLinearizer< propagator_t, propagator_options_t >::State | |
| Acts::AdaptiveMultiVertexFinder< vfitter_t, sfinder_t >::State | For fulfilling interface |
| Acts::AdaptiveMultiVertexFitter< input_track_t, linearizer_t >::State | The fitter state |
| Acts::GaussianTrackDensity< input_track_t >::State | The State struct |
| Acts::ImpactPointEstimator< input_track_t, propagator_t, propagator_options_t >::State | |
| Acts::StraightLineStepper::State | |
| Acts::IterativeVertexFinder< vfitter_t, sfinder_t >::State | |
| Acts::TrackDensityVertexFinder< vfitter_t, track_density_t >::State | For fulfilling interface |
| Acts::Navigator::State | |
| Acts::EigenStepper< bfield_t, extensionlist_t, auctioneer_t >::State | State for track parameter propagation |
| Acts::AtlasStepper< bfield_t >::State | Nested State struct for the local caching |
| Acts::Test::State | Simplified propgator state |
| Acts::ZScanVertexFinder< vfitter_t >::State | For fulfilling interface |
| Acts::DirectNavigator::State | |
| Acts::Propagator< stepper_t, navigator_t >::State< propagator_options_t > | Private Propagator state for navigation and debugging |
| Acts::AnnealingUtility::State | The annealing state Resetting the state is done by just creating a new instance |
| Acts::GridDensityVertexFinder< mainGridSize, trkGridSize, vfitter_t >::State | The State struct |
| Acts::detail::VoidNavigator::State | Nested State struct, minimal requirement |
| Acts::SurfaceMaterialMapper::State | |
| Acts::TGeoParser::State | Nested state struct |
| Acts::FullBilloirVertexFitter< input_track_t, linearizer_t >::State | |
| Acts::VolumeMaterialMapper::State | |
| Acts::Test::PropagatorState::Stepper::State | |
| genfit::StateOnPlane | A state with arbitrary dimension defined in a DetPlane |
| genfit::MeasuredStateOnPlane | StateOnPlane with additional covariance matrix |
| genfit::KalmanFittedStateOnPlane | MeasuredStateOnPlane with additional info produced by a Kalman filter or DAF |
| genfit::MeasurementOnPlane | Measured coordinates on a plane |
| genfit::ReferenceStateOnPlane | StateOnPlane with linearized transport to that ReferenceStateOnPlane from previous and next ReferenceStateOnPlane |
| boost::detail::static_cast_tag | |
| nlohmann::detail::static_const< T > | |
| erhic::Forester::Status | |
| Acts::detail::Step | Step information for |
| Acts::Test::StepCollector | Data collector while propagation |
| genfit::StepLimits | Helper to store different limits on the stepsize for the RKTRackRep |
| Acts::Test::PropagatorState::Stepper | This is a simple cache struct to mimic a Stepper |
| Acts::Test::Stepper | This is a struct to mimic the stepper |
| stepper_extension_list_impl< N > | The dummy list call implementation |
| Acts::detail::stepper_extension_list_impl< N > | |
| Acts::detail::stepper_extension_list_impl< 0u > | Template specialized list call implementation |
| Acts::Concepts::Stepper::StepperConcept< S, state > | |
| Acts::Test::PropagatorState::StepperState | |
| Acts::Test::StepperState | Simplified stepper state |
| Acts::detail::SteppingLogger | Step length logger for debugging the stepping |
| Acts::Test::SteppingState | Mockup of stepping state |
| Acts::Test::StepVolumeCollector | |
| Acts::Test::StepWiseActor | Bound state propagation |
| Stopwatch | |
| Acts::StraightLineStepper | Straight line stepper based on Surface intersection |
| streambuf | |
| gzstreambuf | |
| STREAMBUF | |
| msg_buffer | |
| filter_msg_buffer | |
| date_filter_msg_buffer | |
| remote_msg_buffer | |
| Acts::AssertionFailureException::StreamFormatter | Class which allows to use the << operator to assemble a string |
| Acts::IntegrationTest::StreamWrapper | |
| StringList | |
| subevt_data | |
| Acts::SurfaceArray | Provides Surface binning in N dimensions |
| Acts::SurfaceArrayCreator | |
| Acts::Test::SurfaceArrayCreatorFixture | |
| Acts::Test::SurfaceArrayFixture | |
| Acts::SurfaceBinningMatcher | |
| Acts::SurfaceBounds | |
| Acts::ConeBounds | |
| Acts::CylinderBounds | |
| Acts::DiscBounds | |
| Acts::AnnulusBounds | Class that implements a (potentially asymmetric) bounds with difference between surface bound center and surface coordinate center |
| Acts::DiscTrapezoidBounds | |
| Acts::RadialBounds | |
| Acts::InfiniteBounds | |
| Acts::LineBounds | |
| Acts::PlanarBounds | |
| Acts::ConvexPolygonBoundsBase | Base class for convex polygon bounds |
| Acts::ConvexPolygonBounds< N > | |
| Acts::ConvexPolygonBounds< PolygonDynamic > | |
| Acts::DiamondBounds | |
| Acts::EllipseBounds | |
| Acts::RectangleBounds | |
| Acts::TrapezoidBounds | |
| Acts::SurfaceBoundsStub | Class to implement pure virtual method of SurfaceBounds for testing only |
| Acts::SurfaceCollector< Selector > | |
| Acts::CuboidVolumeBuilder::SurfaceConfig | This struct stores the data for the construction of a single PlaneSurface |
| ActsExamples::SurfaceData | |
| Acts::SurfaceHit | The information to be writtern out per hit surface |
| Acts::SurfaceMaterialMapper | SurfaceMaterialMapper |
| Acts::Test::SurfaceObserver< Surface > | An observer that measures the perpendicular distance |
| Acts::SurfaceReached | |
| Acts::SurfaceSelector | Simple struct to select surfaces |
| SvtxClusterEval | |
| SvtxEvalStack | |
| SvtxHitEval | |
| SvtxTrackEval | |
| SvtxTruthEval | |
| SvtxVertexEval | |
| t_3d_cs_vector | |
| t_3d_line | |
| t_3d_plane | |
| t_ascii_coord | |
| t_cmd_line_key | |
| t_cmd_line_variable | |
| t_cmd_line_variable_array | |
| t_coord_name | |
| t_htc_interpolation | |
| t_kf_matrix_chain | |
| t_particle | |
| t_particle_group | |
| Acts::TargetOptions | TargetOptions struct for geometry interface |
| oncsSub_idfnalmwpcv2::TDC_hit | |
| oncsSub_idfnalmwpc::TDC_hit | |
| oncsSub_idfnalmwpc::TDCData | |
| oncsSub_idfnalmwpcv2::TDCData | |
| oncsSub_idfnalmwpcv2::TDCEvent | |
| oncsSub_idfnalmwpc::TDCEvent | |
| oncsSub_idfnalmwpcv2::TDCspillheader | |
| oncsSub_idfnalmwpc::TDCspillheader | |
| TDirectoryHelper | |
| tecChannelList | |
| TempComb | |
| Acts::FiniteStateMachine< Derived, States >::Terminated | |
| Test | |
| genfit::RKMatrixEigenTransformations | |
| Test | |
| genfit::ConstFieldInitializedTests | |
| genfit::ConstFieldUninitializedTests | |
| genfit::MaterialEffectsTests | |
| genfit::MaterialTests | |
| genfit::RKTrackRepTests | |
| genfit::RootEigenTransformations | |
| genfit::UnitTests | |
| TestCase | |
| TestSpacePoint | Simple spacepoint implementation for the test |
| Acts::Test::TestTrackState | |
| tetgenbehavior | |
| tetgenio | |
| tetgenmesh | |
| TEveBoxSet | |
| FairBoxSet | |
| TEveEventManager | |
| FairEventManager | |
| EicEventManager | |
| TFile | |
| FairParamList::FairParamTFile | |
| PHTFileServer::SafeTFile | Local class to store TFile and counter |
| TGDMLParse | |
| EicGDMLParse | |
| TGedFrame | |
| FairBoxSetEditor | |
| FairEventManagerEditor | |
| FairMCTracksEditor | |
| TGeoCompositeShape | |
| EicCompositeShape | |
| Acts::TGeoParser | TGeoParser is a helper struct that walks recursively through a TGeometry and selects by string comparison the TGeoNodes that match the criteria |
| Acts::TGeoPrimitivesHelper | |
| Acts::TGeoSurfaceConverter | Helper struct to convert TGeoShapes into Surface or Volume Bounds |
| Acts::detail::ThetaBoundParameterLimits | |
| Acts::Test::StepCollector::this_result | Data container for result analysis |
| Acts::Test::StepVolumeCollector::this_result | Data container for result analysis |
| Acts::Test::StepWiseActor::this_result | The result is the piece-wise jacobian |
| Acts::Test::CallCounter::this_result | |
| Acts::DirectNavigator::Initializer::this_result | Actor result / state |
| Acts::VolumeCollector< Selector >::this_result | |
| Acts::Test::SurfaceObserver< Surface >::this_result | Simple result struct to be returned |
| Acts::SurfaceCollector< Selector >::this_result | |
| Acts::Test::DistanceObserver::this_result | |
| Acts::Test::MeasurementCreator::this_result | |
| Acts::Test::PerpendicularMeasure::this_result | Simple result struct to be returned |
| Acts::detail::SteppingLogger::this_result | Simple result struct to be returned |
| Acts::MaterialCollector::this_result | |
| threadargument | |
| ThreeDeePolynomial | |
| ThreeDeePolyPoint | |
| ThreeDeePolySpace | |
| PHTimer::time_struct | Used to store high precision time using two integers |
| Acts::Test::events::Timeout | |
| PHTimeServer::timer | Wrapper around PHTimer, for storage in a map |
| TNamed | |
| CbmMCEpoch | |
| CbmMCEvent | |
| CbmMCMatch | |
| CbmVertex | |
| EicGeoMedia | |
| EicGeoMedium | |
| FairContainer | |
| FairContFact | |
| CbmRichContFact | |
| EicContFact | FairRoot-style EIC container factory, whatever it is good for |
| FairBaseContFact | |
| PndFieldContFact | |
| PndPassiveContFact | |
| PndSensorNameContFact | |
| FairDetParIo | |
| FairDetParAsciiFileIo | |
| FairGenericParAsciiFileIo | |
| FairDetParRootFileIo | |
| FairGenericParRootFileIo | |
| FairDetParTSQLIo | |
| FairGenericParTSQLIo | |
| FairEventHeader | |
| FairFileHeader | |
| FairFileInfo | |
| FairGeanePro | |
| FairGenerator | |
| EicProtoGenerator | |
| EicBoxGenerator | |
| EicAsciiBoxGenerator | |
| EicEventGenerator | |
| FairGeoBasicShape | |
| FairGeoAssembly | |
| FairGeoBrik | |
| FairGeoCone | |
| FairGeoCons | |
| FairGeoEltu | |
| FairGeoPcon | |
| FairGeoPgon | |
| FairGeoSphe | |
| FairGeoTorus | |
| FairGeoTrap | |
| FairGeoTrd1 | |
| FairGeoTube | |
| FairGeoTubs | |
| FairGeoBuilder | |
| FairGeoRootBuilder | |
| FairGeoLoader | |
| FairGeoMedia | |
| FairGeoMedium | |
| FairGeoSet | |
| CbmGeoRich | |
| EicGeo | |
| PndGeoCave | |
| PndGeoMagnet | |
| PndGeoPipe | |
| PndGeoTarget | |
| FairGeoSet::FairGeoCopyNode | |
| FairGeoVolume | |
| FairGeoCompositeVolume | |
| FairGeoNode | |
| FairIon | |
| FairMCEventHeader | |
| CbmMCEventHeader | |
| FairModule | |
| CbmModule | |
| FairDetector | |
| CbmRich | Defines the active detector RICH. Constructs the geometry and creates MCPoints |
| EicDetector | EIC detector |
| EicCalorimeter | |
| EicDummyDetector | Convenient default inactive detector of qDUMMY type |
| EicCadFile | |
| EicFieldGradDetector | |
| EicFieldMapDetector | |
| EicGem | |
| EicLowQ2Tagger | Low Q^2 tagging detector wrapper class |
| EicMaps | |
| EicMuMegas | |
| EicTpc | |
| PndCave | |
| PndMagnet | |
| PndPipe | |
| PndTarget | |
| FairParamObj | |
| FairParRootFile | |
| FairParSet | |
| FairParGenericSet | |
| CbmGeoRichPar | |
| EicGeoPar | |
| FairBaseParSet | |
| PndFieldPar | |
| PndGeoPassivePar | |
| PndMapPar | |
| PndConstPar | |
| PndDipole1Par | |
| PndDipole2Par | |
| PndDipole3Par | |
| PndDipolePar | |
| PndMultiFieldPar | |
| PndSolenoid1Par | |
| PndSolenoid2Par | |
| PndSolenoid3Par | |
| PndSolenoid4Par | |
| PndSolenoidPar | |
| PndTransPar | |
| PndSensorNamePar | Unique match between SensorID and path in TGeoManager |
| FairParVersion | |
| FairPrimaryGenerator | |
| FairRegistry | |
| FairRtdbRun | |
| FairRun | |
| FairRunAna | |
| EicRunAna | |
| EicRunDigi | |
| FairRunSim | |
| EicRunSim | |
| FairVolume | |
| genfit::EventDisplay | Event display designed to run with Genfit |
| LqstCell | |
| MapsStave | |
| MapsStave | |
| PgPostBankBackupStorage | PgPostBankBackupStorage |
| PndFieldMapData | |
| PndRecoDafFit | |
| PndRecoKalmanFit | |
| TVirtualMagField | |
| nlohmann::detail::to_json_fn | |
| PHDataNode< T >::tobjcast | |
| TObject | |
| BeamPipeElement | |
| BeamPipeSection | |
| CalorimeterCell | |
| CalorimeterCellGroup | |
| CalorimeterCellParent | |
| CalorimeterCellZCoordBin | |
| CalorimeterDigiParData | |
| CalorimeterRecoParData | |
| CalorimeterSensorGroup | |
| CbmBaseHit | |
| CbmPixelHit | |
| CbmRichHit | |
| CbmStripHit | |
| CbmCluster | Base class for cluster objects |
| CbmDetectorList | Provides some utility functions for DetectorId |
| CbmDigi | Base class for persistent representation of digital information |
| CbmGlobalTrack | |
| CbmGlobalTrackFitter | |
| CbmHistManager | Histogram manager |
| CbmMCList | |
| CbmMCObject | |
| CbmMCResult | |
| CbmMCStage | |
| CbmMCTrack | |
| CbmPrimaryVertexFinder | |
| CbmPropagator | |
| CbmReport | Base class for reports |
| CbmStudyReport | Base class for study reports |
| CbmRichGeoTestStudyReport | Creates study report for RICH geometry testing |
| CbmReportElement | Abstract class for basic report elements (headers, tables, images etc.) |
| CbmHtmlReportElement | Implementation of CbmReportElement for text output |
| CbmLatexReportElement | Implementation of CbmLitReportElement for Latex output |
| CbmTextReportElement | Implementation of CbmLitReportElement for text output |
| CbmRichMerger | |
| CbmRichRing | |
| CbmRichRingFinder | |
| CbmRichProtRingFinderHough | Main class for ring finder based on Hough Transform implementation |
| CbmRichRingFinderHough | Main class for ring finder based on Hough Transform implementation |
| CbmRichRingFinderIdeal | |
| CbmRichRingFitter | |
| CbmRichRingFitterQa | Test ellipse and circle fitting on toy model |
| CbmRichRingSelect | |
| CbmRichRingTrackAssign | |
| CbmRichTrackExtrapolation | |
| CbmTrack | |
| CbmTrackMatch | |
| CbmTrackMerger | |
| EicBitMask< T > | |
| EicBitMask< T > | |
| EicBitMask< UGeantIndex_t > | |
| EicBitMask< UGeantIndex_t > | |
| EicBitMask< ULogicalIndex_t > | |
| EicBitMask< ULogicalIndex_t > | |
| EicBuffer3D | |
| EicCadFileConfig | |
| EicCadWizard | |
| EicCadWizardFile | |
| EicCadWizardFileConfig | |
| EicCalorimeterDigiHit | |
| EicCalorimeterHub | |
| EicDetectorGroup | |
| EicDetName | Detector name in all flavors like TPC, Tpc, tpc |
| EicDetName | Detector name in all flavors like TPC, Tpc, tpc |
| EicDigiParData | Bare base class with minumum set of methods shared between various detector digi data blocks |
| TpcDigiParData | |
| EicEnergyMonitor | |
| EicGeoMap | |
| EicGeoMap | |
| EicGeoParData | |
| BeamPipeGeoParData | |
| CalorimeterGeoParData | |
| BarrelGeoParData | |
| CemcGeoParData | |
| EndcapGeoParData | |
| BemcGeoParData | |
| FemcGeoParData | |
| HcalGeoParData | |
| GemGeoParData | |
| EicRootGemSubsystem | |
| GemGeoParData | |
| LqstGeoParData | |
| MapsGeoParData | |
| FstGeoParData | |
| FstGeoParData | |
| VstGeoParData | |
| EicRootVstSubsystem | |
| VstGeoParData | |
| MapsGeoParData | |
| MuMegasGeoParData | |
| EicRootMuMegasSubsystem | |
| MuMegasGeoParData | |
| TpcGeoParData | |
| EicGeoParData | |
| EicHtcHit | |
| EicHtcHitComponent | |
| EicHtcTrack | |
| EicKfNodeTemplate | |
| EicKfNodeTemplate1D | |
| EicKfNodeTemplateAsimuthal1D | |
| EicKfNodeTemplateLinear1D | |
| EicKfNodeTemplateRadial1D | |
| EicKfNodeTemplateOrth2D | |
| EicKfNodeTemplateCartesian2D | |
| EicKfNodeTemplateCylindrical2D | |
| EicKfNodeTemplateOrth3D | |
| EicMagneticFieldGrad | |
| EicMagneticFieldMap | |
| EicBeamLineElementGrad | |
| EicBeamLineElementMap | |
| EicConstantField | |
| EicConstantBoxField | |
| EicConstantTubeField | |
| EicPndFieldMap | |
| EicMediaHub | |
| EicNamePatternHub< T > | |
| EicNamePatternHub< T > | |
| EicNamePatternHub< Char_t > | |
| EicNamePatternHub< Char_t > | |
| EicNamePatternHub< Color_t > | |
| EicNamePatternHub< Color_t > | |
| EicNamePatternHub< double > | |
| EicNamePatternHub< double > | |
| EicNamePatternHub< SteppingType > | |
| EicNamePatternHub< SteppingType > | |
| EicNamePatternHub< unsigned > | |
| EicNamePatternHub< unsigned > | |
| EicPOD | |
| GemModule | |
| MapsMimosaAssembly | |
| MuMegasLayer | |
| EicRcCalorimeterHit | |
| EicRcVertex | |
| EicRootInputFile | |
| EicRootManager | |
| EicStlFactory | |
| EicToyModel | |
| EmcCluster | |
| EnergyDeposit | |
| erhic::DisKinematics | |
| erhic::FileType | |
| erhic::File< T > | |
| erhic::File< erhic::EventHepMC > | |
| erhic::Forester | |
| Poacher | |
| erhic::LogReader | |
| erhic::LogReaderDjangoh | |
| erhic::LogReaderGmcTrans | |
| erhic::LogReaderMilou | |
| erhic::LogReaderPepsi | |
| erhic::LogReaderPythia | |
| erhic::ParticleMCeA | |
| erhic::VirtualEvent | Abstract base class for a physics event |
| erhic::EventDis | |
| EicRcEvent | |
| erhic::EventMC | |
| erhic::EventDEMP | |
| erhic::EventDjangoh | |
| erhic::EventDpmjet | |
| erhic::EventGmcTrans | |
| erhic::EventHepMC | |
| erhic::EventMilou | |
| erhic::EventPepsi | |
| erhic::EventPythia | Pythia 6 DIS event |
| erhic::EventBeagle | |
| erhic::EventRapgap | |
| erhic::EventSartre | |
| erhic::EventSimple | |
| EventEicMC | |
| EventProMC | |
| Smear::Event | |
| erhic::hadronic::EventMC | |
| erhic::hadronic::EventPythiaPP | |
| erhic::hadronic::EventSmear | |
| erhic::VirtualEventFactory | |
| erhic::EventFromAsciiFactory< T > | |
| erhic::hadronic::Pythia6EventFactory | |
| erhic::Pythia6EventBuilder | |
| Smear::EventFactory< erhic::hadronic::EventSmear > | |
| Smear::HadronicEventBuilder | |
| Smear::EventFactory< Smear::Event > | |
| Smear::EventDisFactory | |
| Smear::EventFactory< T > | |
| erhic::VirtualParticle | Abstract base class for a general particle |
| EicRcParticle | |
| erhic::hadronic::ParticleMC | |
| erhic::ParticleMCbase | |
| erhic::ParticleMC | |
| Smear::ParticleMCS | |
| EtmAzimuthalScan | |
| EtmBoundaryModificationRequest | |
| EtmDetectorStack | |
| EtmEtaBoundary | |
| EtmLine2D | |
| EtmPalette | |
| EtmPaletteEntry | |
| EtmPolygonGroup | |
| EtmDetector | |
| EtmVacuumChamber | |
| vc2020_03_20 | |
| FairDbResultKey | |
| FairDbTableRow | |
| FairDbConfigSet | |
| FairDbLogEntry | |
| FairDbValidityRec | |
| FairGeaneUtil | |
| FairGeoInterface | |
| FairGeoIo | |
| FairGeoAsciiIo | |
| FairGeoOldAsciiIo | |
| FairGeoMatrix | |
| FairGeoRotation | |
| FairGeoShapes | |
| FairGeoTransform | |
| FairGeoVector | |
| FairLink | |
| PndTrackCandHit | |
| FairMesh | |
| FairMultiLinkedData | |
| CbmMCEntry | |
| FairDoubleHit | |
| FairMCPoint | |
| CbmRichPoint | |
| EicMoCaPoint | |
| FairRadLenPoint | |
| FairRadMapPoint | |
| FairRecoCandidate | |
| PndPidCandidate | |
| FairTimeStamp | |
| FairHit | |
| CbmHit | |
| EicTrackingDigiHit | |
| EicTrackingDigiHit1D | |
| EicTrackingDigiHit3D | |
| EicTrackingDigiHitOrth2D | |
| PndVertex | |
| PndTrack | |
| PndTrackCand | |
| FairParamList | |
| FairParIo | |
| FairParAsciiFileIo | |
| FairParRootFileIo | |
| FairParTSQLIo | |
| FairParticle | |
| FairRegistryItem | |
| FairRegistryItemXxx< T > | |
| FairRingSorter | |
| FairRKPropagator | |
| FairRootManager | |
| FairRunInfo | |
| FairRuntimeDb | List of container factories |
| FairTrackPar | |
| FairTrackParH | |
| FairTrackParP | |
| FairTrackParam | |
| FairTSBufferFunctional | A class to access time ordered data in a root branch |
| FairTSQLObject | ==================================== |
| FairVolumeList | |
| FairWriteoutBuffer | A container class to store digi data during events |
| FairWriteoutBufferAbsBasis | |
| FiberParData | |
| FiberTowerLayer | |
| FluxMonitorGrid | |
| FluxMonitorParticleType | |
| FstDisc | |
| FstDisc | |
| FwdMcTrackMapper | |
| GeantVolumeLevel | |
| GeantVolumeLevel | |
| GemModule | |
| GemWheel | |
| GemWheel | |
| genfit::AbsFitterInfo | This class collects all information needed and produced by a specific AbsFitter and is specific to one AbsTrackRep of the Track |
| genfit::GblFitterInfo | Collects information needed and produced by a GblFitter/GBL and is specific to one AbsTrackRep of the Track |
| genfit::KalmanFitterInfo | Collects information needed and produced by a AbsKalmanFitter implementations and is specific to one AbsTrackRep of the Track |
| genfit::AbsHMatrix | HMatrix for projecting from AbsTrackRep parameters to measured parameters in a DetPlane |
| genfit::HMatrixPhi | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| genfit::HMatrixU | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| genfit::HMatrixUnit | AbsHMatrix implementation for 5-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| genfit::HMatrixUV | AbsHMatrix implementation for two-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| genfit::HMatrixV | AbsHMatrix implementation for one-dimensional MeasurementOnPlane and RKTrackRep parameterization |
| genfit::AbsMaterialInterface | Abstract base class for geometry interfacing |
| genfit::TGeoMaterialInterface | AbsMaterialInterface implementation for use with ROOT's TGeoManager |
| genfit::AbsMeasurement | Contains the measurement and covariance in raw detector coordinates |
| genfit::FullMeasurement | Measurement class implementing a measurement of all track parameters |
| genfit::PlanarMeasurement | Measurement class implementing a planar hit geometry (1 or 2D) |
| genfit::SpacepointMeasurement | Class for measurements implementing a space point hit geometry |
| genfit::mySpacepointMeasurement | Example class for a spacepoint measurement which can be created from mySpacepointDetectorHit via the MeasurementFactory |
| genfit::ProlateSpacepointMeasurement | Class for measurements implementing a space point hit geometry with a very prolate form of the covariance matrix |
| genfit::WireMeasurement | Class for measurements in wire detectors (Straw tubes and drift chambers) which do not measure the coordinate along the wire |
| genfit::WirePointMeasurement | Class for measurements in wire detectors (Straw tubes and drift chambers) which can measure the coordinate along the wire |
| genfit::WireMeasurementNew | Class for measurements in wire detectors (Straw tubes and drift chambers) which do not measure the coordinate along the wire |
| genfit::AbsTrackRep | Abstract base class for a track representation |
| genfit::RKTrackRep | AbsTrackRep with 5D track parameterization in plane coordinates: (q/p, u', v', u, v) |
| genfit::DetPlane | Detector plane |
| genfit::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 |
| genfit::GFRaveVertex | GFRaveVertex class |
| genfit::HelixTrackModel | Helix track model for testing purposes |
| genfit::MeasurementCreator | Create different measurement types along a HelixTrackModel for testing purposes |
| genfit::mySpacepointDetectorHit | Example class for a spacepoint detector hit |
| genfit::ThinScatterer | Thin or thick scatterer |
| genfit::Track | Collection of TrackPoint objects, AbsTrackRep objects and FitStatus objects |
| genfit::TrackCand | Track candidate – seed values and indices |
| genfit::TrackCandHit | Hit object for use in TrackCand. Provides IDs and sorting parameters |
| genfit::WireTrackCandHit | Hit object for use in TrackCand. Provides additional left/right parameter |
| genfit::TrackPoint | Object containing AbsMeasurement and AbsFitterInfo objects |
| GFAbsFinitePlane | Abstract base class for implementing arbitrarily shaped finite detector planes |
| GFRectFinitePlane | Concrete implementation of finitie detector plane for rectangles |
| GFAbsRecoHit | Base Class for representing a Hit in GENFIT |
| GFDafHit | Wrapper class for use with GFDaf |
| GFRecoHitIfc< HitPolicy > | RecoHit interface template class. Provides comfortable interface to create RecoHits |
| GFRecoHitIfc< GFPlanarHitPolicy > | |
| EicPlanarRecoHit | |
| GFRecoHitIfc< GFSpacepointHitPolicy > | |
| EicSpaceRecoHit | |
| PndHitRecoHit | A planar (x,y) reco hit & its sensor plane |
| VirtSpacePointRecoHit | A basic space point reco hit. Uses a TVector3 for initialization |
| GFAbsTrackRep | Base Class for genfit track representations. Defines interface for track parameterizations |
| GeaneTrackRep | |
| LSLTrackRep | Local straight line track representation |
| RKTrackRep | Track Representation module based on a Runge-Kutta algorithm including a full material model |
| GFBookkeeping | |
| GFDetPlane | Detector plane genfit geometry class |
| GFMaterialEffects | Contains stepper and energy loss/noise matrix calculation |
| GFPlanarHitPolicy | Policy class implementing a planar hit geometry |
| GFPseudoSpacepointWireHitPolicy | Policy class implementing a poseudo space point hit geometry |
| GFSpacepointHitPolicy | Policy class implementing a space point hit geometry |
| GFTrack | Track object for genfit. genfit algorithms work on these objects |
| GFTrackCand | Track candidate – a list of cluster indices |
| GFWireHitPolicy | Policy class for hits in wire detectors (STT and DCH) which do not measure the coordinate along the wire |
| GFWirepointHitPolicy | Policy class for hits in wire detectors (STT and DCH) which can measure the coordinate along the wire |
| LogicalVolumeGroup | |
| LogicalVolumeGroup | |
| LogicalVolumeGroupProjection | |
| LogicalVolumeGroupProjection | |
| LogicalVolumeLookupTableEntry | |
| LogicalVolumeLookupTableEntry | |
| MapsMimosaAssembly | |
| MatchCandidate | |
| FwdMatchCandidate | |
| MultiArray< T > | |
| MultiArray< double > | |
| MultiArray< TVector3 > | |
| MuMegasBarrel | |
| MuMegasBarrel | |
| MuMegasLayer | |
| NaiveTrackParameterization | |
| ParticleMappingTable | |
| PgPostBankBackupStorage::BankHeader | |
| PhaseSpaceVariable | |
| PHObject | |
| AssocInfoContainer | |
| AssocInfoContainerv1 | |
| BbcVertex | |
| BbcVertexv1 | |
| BbcVertexMap | |
| BbcVertexMapv1 | |
| CaloTriggerInfo | |
| CaloTriggerInfov1 | |
| CentralityInfo | |
| CentralityInfov1 | |
| CMFlashCluster | Base class for Central Membrane flassh combined cluster object |
| CMFlashClusterv1 | Version 1 of CMFlashCluster |
| CMFlashClusterContainer | Cluster container object |
| CMFlashClusterContainerv1 | CM flash cluster container object |
| DecayFinderContainerBase | DecayFinder container object |
| DecayFinderContainer_v1 | |
| EicEventHeader | |
| EicEventHeaderv1 | |
| EICPIDParticle | |
| EICPIDParticlev1 | |
| EICPIDParticleContainer | |
| EvalCluster | |
| EvalHit | |
| EvalRootTTree | |
| EvalTower | |
| EventHeader | Base class for EventHeaders |
| EventHeaderv1 | Simple event header with ID and time |
| EventHeaderv2 | Simple event header with ID and time |
| FlagSave | |
| FlagSavev1 | |
| G4RootHitContainer | |
| G4RootRawTower | |
| G4RootRawTowerContainer | |
| G4RootScintillatorSlat | |
| G4RootScintillatorSlatContainer | |
| G4RootScintillatorTower | |
| G4RootScintillatorTowerContainer | |
| GlobalVertex | |
| GlobalVertexv1 | |
| GlobalVertexMap | |
| GlobalVertexMapv1 | |
| HelixHoughBin | |
| HelixHoughBin_v1 | |
| HelixHoughFuncs | |
| HelixHoughFuncs_v1 | |
| HelixHoughSpace | |
| HelixHoughSpace_v1 | |
| InttDeadMap | |
| InttDeadMapv1 | |
| Jet | |
| Jetv1 | Jetv1 |
| JetMap | |
| JetMapv1 | |
| KFParticle_Container | KFParticle container object |
| MicromegasTile | Header only class that contains information about a given Tile location inside CylinderGeom |
| MySimpleTree | |
| MyTClonesArray | |
| ParticleFlowElement | |
| ParticleFlowElementv1 | |
| ParticleFlowElementContainer | |
| PdbBankID | |
| PdbCalBank | |
| PgPostCalBank | |
| PgPostBankWrapper | |
| PdbCalChan | |
| PdbParameter | |
| PdbParameterError | |
| PdbParameterMap | |
| PdbParameterMapContainer | |
| 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 |
| PHG4BlockCellGeom | |
| PHG4BlockCellGeomContainer | |
| PHG4BlockGeom | |
| PHG4BlockGeomv1 | |
| PHG4BlockGeomContainer | |
| PHG4Cell | |
| PHG4Cellv1 | |
| PHG4CylinderCell | |
| PHG4CylinderCellv1 | |
| PHG4CylinderCellv2 | |
| PHG4CylinderCellv3 | |
| PHG4CellContainer | |
| PHG4CylinderCellContainer | |
| PHG4CylinderCellGeom | |
| PHG4CylinderCellGeom_Spacalv1 | PHG4CylinderCellGeom_Spacalv1 |
| PHG4CylinderCellGeomContainer | |
| PHG4CylinderGeom | |
| CylinderGeom_Mvtx | |
| CylinderGeomIntt | |
| CylinderGeomMicromegas | |
| PHG4CylinderGeomv1 | |
| PHG4CylinderGeomv2 | |
| PHG4CylinderGeom_Spacalv1 | |
| PHG4CylinderGeom_Spacalv2 | |
| PHG4CylinderGeom_Spacalv3 | |
| PHG4CylinderGeomv3 | |
| PHG4CylinderGeomv4 | |
| PHG4CylinderGeomContainer | |
| PHG4EventHeader | |
| PHG4EventHeaderv1 | |
| PHG4GDMLConfig | PHG4GDMLConfig |
| PHG4Hit | |
| EICG4dRICHHit | |
| PHG4Hitv1 | |
| PHG4HitEval | PHG4HitEval for evaluating PHG4Hitv1 in CINT readable evaluation trees |
| PrtHit | |
| PHG4HitContainer | |
| PHG4InEvent | |
| PHG4Particle | |
| PHG4Particlev1 | |
| PHG4Particlev2 | |
| PHG4Particlev3 | |
| PHG4ScintillatorSlat | |
| PHG4ScintillatorSlatv1 | |
| PHG4ScintillatorSlatContainer | |
| PHG4Shower | |
| PHG4Showerv1 | |
| PHG4TruthInfoContainer | |
| PHG4VtxPoint | |
| PHG4VtxPointv1 | |
| PHGenIntegral | PHGenIntegral |
| PHGenIntegralv1 | PHGenIntegralv1 |
| 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 |
| PHHepMCGenEvent | |
| PHHepMCGenEventv1 | |
| 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 |
| PHParameters | |
| PHParametersContainer | |
| PHTimeStamp | |
| RawCluster | |
| RawClusterv1 | |
| RawClusterContainer | |
| RawTower | |
| RawTowerv1 | |
| RawTowerv2 | RawTowerv1 but allow flexible tags |
| RawTowerContainer | |
| RawTowerDeadMap | |
| RawTowerDeadMapv1 | |
| RawTowerGeom | |
| RawTowerGeomv1 | |
| RawTowerGeomv2 | |
| RawTowerGeomv3 | |
| RawTowerGeomv4 | |
| RawTowerGeomContainer | Base class to describe calorimeter geometries |
| RawTowerGeomContainerv1 | Generic tower geometry class, store each tower's geometry individually |
| RawTowerGeomContainer_Cylinderv1 | With additional description to conveniently use in central calorimeter with eta-phi bins |
| RawTowerZDC | |
| RawTowerZDCv1 | |
| RawTowerZDCContainer | |
| RawTowerZDCDeadMap | |
| RawTowerZDCGeom | |
| RawTowerZDCGeomv1 | |
| RawTowerZDCGeomContainer | Generic tower geometry class, store each tower's geometry individually |
| RunHeader | |
| RunHeaderv1 | |
| SvtxTrack | |
| SvtxTrack_v1 | |
| SvtxTrack_FastSim | |
| SvtxTrack_FastSim_v1 | |
| SvtxTrack_v2 | |
| SvtxTrack_FastSim_v2 | |
| SvtxTrackMap | |
| SvtxTrackMap_v1 | |
| SvtxTrackState | |
| SvtxTrackState_v1 | |
| SvtxVertex | |
| SvtxVertex_v1 | |
| SvtxVertexMap | |
| SvtxVertexMap_v1 | |
| SyncObject | |
| SyncObjectv1 | |
| TowerBackground | |
| TowerBackgroundv1 | |
| TpcSeedTrackMap | |
| TpcSeedTrackMapv1 | |
| TpcSpaceChargeMatrixContainer | Cluster container object |
| TpcSpaceChargeMatrixContainerv1 | Cluster container object |
| TrackEvaluationContainer | Track evaluation container base class |
| TrackEvaluationContainerv1 | Track evaluation container |
| TrkrCluster | Base class for cluster object |
| TrkrClusterv1 | Version 1 of TrkrCluster |
| TrkrClusterv2 | Version 2 of TrkrCluster |
| TrkrClusterv3 | Version 3 of TrkrCluster |
| TrkrClusterContainer | Cluster container object |
| TrkrClusterContainerv1 | Cluster container object |
| TrkrClusterContainerv2 | Cluster container object |
| TrkrClusterContainerv3 | Cluster container object |
| 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 |
| TrkrClusterIterationMap | Base class for associating clusters to iterations they were used in |
| TrkrClusterIterationMapv1 | Class for associating clusters to the hits that went into them |
| TrkrHit | Base class for hit object |
| TrkrHitv1 | Inherited class v1 for hit object |
| TrkrHitv2 | Base class for hit object |
| TrkrHitSet | Container for storing TrkrHit's |
| TrkrHitSetv1 | |
| TrkrHitSetContainer | |
| TrkrHitSetContainerv1 | |
| TrkrHitTruthAssoc | Association object for PHG4Cells contributiong to TrkrHits |
| TrkrHitTruthAssocv1 | Association object for PHG4Cells contributiong to TrkrHits |
| VariableArray | |
| VariableArrayContainer | |
| PndFileNameCreator | A simple class which adds the corresponding file extensions to a given base class |
| PndMCTrack | |
| PndPidProbability | |
| PndRegion | |
| PndTrackID | |
| ResolutionLevelPattern | |
| Smear::Detector | |
| Smear::FormulaString | |
| Smear::Smearer | |
| EPhenixMomentum | |
| Smear::Device | |
| Smear::Bremsstrahlung | A specialized Device class for modelling radiative losses |
| Smear::NumSigmaPid | |
| Smear::TofBarrelSmearer | |
| Smear::ParticleID | |
| Smear::PerfectID | |
| Smear::Tracker | |
| Smear::PlanarTracker | |
| Smear::RadialTracker | |
| SourceFile | |
| TowerParData | |
| TPCFEETestRecov1::ChannelHeader | Simple channel header class for ROOT file IO |
| TPCFEETestRecov1::ClusterData | Buffer for a cluster's data |
| TPCFEETestRecov1::EventHeader | Simple event header class for ROOT file IO |
| ValContext | |
| ValRange | |
| ValValidate | |
| VstBarrelLayer | |
| VstBarrelLayer | |
| TowerGeom | |
| PHG4ForwardEcalDetector::towerposition | |
| PHG4EICForwardEcalDetector::towerposition | |
| PHG4CrystalCalorimeterDetector::towerposition | |
| EICG4BwdDetector::towerposition | |
| EICG4B0ECALDetector::towerposition | |
| PHG4BarrelEcalDetector::towerposition | |
| PHG4ForwardHcalDetector::towerposition | |
| PHG4ForwardDualReadoutDetector::towerposition | |
| PHG4HybridHomogeneousCalorimeterDetector::towerposition | |
| PHG4LFHcalDetector::towerposition | |
| PHG4BackwardHcalDetector::towerposition | |
| RawClusterBuilderHelper::towersStrct | |
| Acts::detail::full_parset< parameter_indices_t >::tparam_generator< T, N > | |
| Acts::detail::full_parset< parameter_indices_t >::tparam_generator< T, 0 > | |
| oncsSub_idtpcfeev2::tpc_sample | |
| TpcDistortionCorrection | |
| TpcDistortionCorrectionContainer | |
| TpcSpaceChargeReconstructionHelper | |
| TPolyLine3D | |
| FairVTrack | |
| erhic::TProcessIdObjectCount | |
| PHGenFit2::Track | |
| PHGenFit::Track | |
| genfit::trackAndState | Simple struct containing a Track pointer and a MeasuredStateOnPlane. Used in GFRave |
| Acts::TrackAtVertex< input_track_t > | Defines a track at vertex object |
| Acts::TrackAtVertex< InputTrack_t > | |
| kdfinder::TrackCandidate< T > | |
| Acts::TrackDensityVertexFinder< vfitter_t, track_density_t > | 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 |
| Acts::GaussianTrackDensity< input_track_t >::TrackEntry | Struct to store information for a single track |
| Acts::TrackingGeometry | |
| genfit::TrackPointComparator | Helper class for TrackPoint sorting, used in Track::sort() |
| PHGenFitTrkProp::TrackQuality | |
| TrackSegment | |
| Acts::detail_lt::TrackStateProxy< source_link_t, M, ReadOnly > | |
| TrackEvaluationContainerv1::TrackStruct | Track information |
| ActsExamples::TrackSummaryPlotTool::TrackSummaryPlotCache | Nested Cache struct |
| ActsExamples::TrackSummaryPlotTool | |
| nanoflann::metric_L2_Simple::traits< T, DataSource > | |
| nanoflann::metric_L2::traits< T, DataSource > | |
| nanoflann::metric_L1::traits< T, DataSource > | |
| traits2< bool > | |
| Acts::MultiTrajectoryHelpers::TrajectoryState | Struct for brief trajectory summary info : add nSharedHits |
| TreeHandler | |
| BranchComparisonHarness::TreeMetadata | |
| tetgenmesh::triface | |
| TRint | |
| SmearRint | |
| Acts::Cuda::Details::Triplet | Structure used in the CUDA-based triplet finding |
| Acts::Cuda::TripletFilterConfig | Structure holding pointers to the user defined filter functions |
| TrivialTrack | |
| TrKalmanNodeLocation | |
| ActsExamples::TrkrClusterMultiTrajectory | Struct for truth track fitting/finding result with Acts::KalmanFitter/Acts::CombinatorialKalmanFilter |
| ActsExamples::TrkrClusterSourceLink | |
| true_type | |
| Acts::AdaptiveMultiVertexFinder< vfitter_t, sfinder_t >::NeedsRemovedTracks< T, decltype((void) T::tracksToRemove, 0)> | |
| nlohmann::detail::conjunction< std::is_constructible< T1, Args >...> | |
| nlohmann::detail::is_constructible_tuple< T1, std::tuple< Args...> > | |
| nlohmann::detail::conjunction<> | |
| nlohmann::detail::is_basic_json< NLOHMANN_BASIC_JSON_TPL > | |
| nlohmann::detail::is_complete_type< T, decltype(void(sizeof(T)))> | |
| nlohmann::detail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value > > | |
| nlohmann::detail::is_json_ref< json_ref< T > > | |
| std::is_error_code_enum< Acts::CombinatorialKalmanFilterError > | |
| std::is_error_code_enum< Acts::EigenStepperError > | |
| std::is_error_code_enum< Acts::KalmanFitterError > | |
| std::is_error_code_enum< Acts::PropagatorError > | |
| std::is_error_code_enum< Acts::SurfaceError > | |
| std::is_error_code_enum< Acts::VertexingError > | |
| std::is_error_code_enum< ActsFatras::detail::SimulatorError > | |
| std::is_error_code_enum< ActsFatras::DigitizationError > | Register with STL |
| std::is_error_code_enum< MyError > | |
| ActsExamples::TruthHitData | |
| TSelector | |
| FairAnaSelector | |
| TTask | |
| FairTask | |
| CbmDigiManager | |
| CbmMCMatchCreatorTask | |
| CbmMCMatchLoaderTask | |
| CbmMCMatchSelectorTask | |
| CbmRichEventDisplay | Event display for the RICH detector |
| CbmRichGeoTest | RICH geometry checking and testing |
| CbmRichHitProducer | Class for producing RICH hits directly from MCPoints |
| CbmRichMatchRings | Task class for matching a reconstructed CbmRichRings with a simulated CbmMCTrack. The matching criterion is a maximal number of common hits/points. The task fills the data class CbmRichRingMatch for each CbmRichRing |
| CbmRichReconstruction | Main class for running event reconstruction in the RICH detector |
| CbmRichTestHits | This class fills some histograms for a fast check of simulated data |
| CbmRichTestSim | This class fills some histograms for a fast check of simulated data |
| CbmRichTrainAnnElectrons | Train ANN for electron identification in RICH |
| CbmRichTrainAnnSelect | Train ANN for fake rejection |
| CbmRichUrqmdTest | RICH geometry testing in Urqmd collisions |
| EicCalorimeterReconstruction | |
| EicDigiHitProducer | Base digitization class |
| EicCalorimeterDigiHitProducer | |
| EicTrackingDigiHitProducer | |
| EicTpcDigiHitProducer | |
| EicEventAssembler | |
| EicEventGeneratorTask | |
| EicFluxMonitorTask | |
| EicHtcTask | |
| FwdTrackFinder | |
| EicIdealTrackingCode | |
| FwdIdealTrackingCode | |
| EicSmearTask | |
| FairBoxSetDraw | |
| FairHitDraw | |
| FairTimeStampPointDraw | |
| FairGeane | |
| FairMCStack | |
| FairMCTracks | |
| FairPointSetDraw | |
| FairHitPointSetDraw | |
| FairMCPointDraw | |
| FairRingSorterTask | |
| PndBlackBoxTask | |
| PndEventCounterTask | |
| PndGeoHandling | Class to access the naming information of the MVD |
| PndGFTrackToPndTrackConvertorTask | |
| PndMcCloner | |
| PndPidCorrelator | |
| PndRecoKalmanTask | |
| EicRecoKalmanTask | |
| PndRecoMultiKalmanTask | |
| PndTrackArrayMerger | |
| PrimSelector | |
| std::tuple_element< N,::nlohmann::detail::iteration_proxy_value< IteratorType > > | |
| Acts::Test::tuple_helper< Args > | |
| kdfinder::TVector< T > | |
| TVirtualMCApplication | |
| FairGeaneApplication | |
| FairMCApplication | |
| EicMCApplication | |
| TVirtualMCStack | |
| FairGenericStack | |
| CbmStack | |
| PndStack | |
| TwoHitsSpacePointBuilder | |
| twrs | |
| twrs_fwd | |
| type | |
| nlohmann::detail::conjunction< B1, Bn...> | |
| TypeCode< T, Enable > | |
| dfe::namedtuple_root_impl::TypeCodeIntImpl< T, Unsigned, Signed > | |
| dfe::namedtuple_root_impl::TypeCodeIntImpl< T, 'b', 'B'> | |
| dfe::namedtuple_root_impl::TypeCode< T, typename std::enable_if_t< is_integer_with_size_v< T, 1 > > > | |
| dfe::namedtuple_root_impl::TypeCodeIntImpl< T, 'i', 'I'> | |
| dfe::namedtuple_root_impl::TypeCode< T, typename std::enable_if_t< is_integer_with_size_v< T, 4 > > > | |
| dfe::namedtuple_root_impl::TypeCodeIntImpl< T, 'l', 'L'> | |
| dfe::namedtuple_root_impl::TypeCode< T, typename std::enable_if_t< is_integer_with_size_v< T, 8 > > > | |
| dfe::namedtuple_root_impl::TypeCodeIntImpl< T, 's', 'S'> | |
| dfe::namedtuple_root_impl::TypeCode< T, typename std::enable_if_t< is_integer_with_size_v< T, 2 > > > | |
| dfe::namedtuple_root_impl::TypeCodePlainImpl< Code > | |
| dfe::namedtuple_root_impl::TypeCodePlainImpl<'D'> | |
| dfe::namedtuple_root_impl::TypeCode< double > | |
| dfe::namedtuple_root_impl::TypeCodePlainImpl<'F'> | |
| dfe::namedtuple_root_impl::TypeCode< float > | |
| dfe::namedtuple_root_impl::TypeCodePlainImpl<'O'> | |
| dfe::namedtuple_root_impl::TypeCode< bool > | |
| Acts::detail_lt::Types< Size, ReadOnlyMaps > | Type construction helper for coefficients and associated covariances |
| Acts::detail_lt::Types< eBoundSize > | |
| Acts::detail_lt::Types< MeasurementSizeMax > | |
| RawClusterv1::u_property | Convert between 32bit inputs and storage type prop_storage_t |
| EICPIDParticlev1::u_property | Convert between 32bit inputs and storage type prop_storage_t |
| PHG4Cellv1::u_property | Convert between 32bit inputs and storage type prop_storage_t |
| EicEventHeaderv1::u_property | Convert between 32bit inputs and storage type prop_storage_t |
| PHG4Hitv1::u_property | Convert between 32bit inputs and storage type prop_storage_t |
| half::uif | |
| dfe::UniformAxis< T > | Uniform binning without under/overflow bins |
| Acts::detail::UnrestrictedParameterTraits | Traits class for an unrestricted parameter |
| FairRunIdGenerator::uuid | |
| PgPostCalBankIterator::ValPeriod | |
| ValTimeStamp | |
| Acts::detail::ValueCorrector< indices_t, kParameters > | |
| dfe::Variable | Variable-type value object a.k.a. a poor mans std::variant |
| VariableArrayUtils | |
| dfe::VariableAxis< T > | Variable binninng defined by arbitrary bin edges |
| Acts::Test::variadic_struct< args > | |
| std::vector< T > | STL class |
| G4LogicalVolumeStore | |
| G4PhysicalVolumeStore | |
| G4SolidStore | |
| vector3 | |
| Acts::Vertex< input_track_t > | Class for storing vertex objects |
| Acts::Vertex< InputTrack_t > | |
| VertexFinder | A class to determine the vertex |
| Acts::Concepts::VertexFinder::VertexFinderConcept< S > | |
| VertexFitter | A class to determine the vertex |
| Acts::Concepts::VertexFitter::VertexFitterConcept< S > | |
| Acts::Test::VertexInfo | Helper struct to store reference vertex related information |
| Acts::VertexInfo< input_track_t > | Helper struct for storing vertex related information |
| Acts::VertexInfo< InputTrack_t > | |
| Acts::VertexingOptions< input_track_t > | Vertex Finder Options |
| Acts::ViewConfig | Struct to concentrate all visulation configuration in order to harmonize visualization interfaces |
| Acts::detail::visit_measurement_callable< I > | |
| gbl::VMatrix | Simple Matrix based on std::vector<double> |
| Acts::detail::VoidAuctioneer | Auctioneer that takes all extensions as valid that make a valid bid |
| Acts::VoidBranchStopper | Void branch stopper |
| Acts::VoidKalmanComponents | Void Measurement calibrator and converter |
| Acts::VoidKalmanSmoother | Void Kalman smoother |
| Acts::VoidKalmanUpdater | Void Kalman updater |
| Acts::VoidMeasurementCalibrator | Void measurement calibrator for filtering |
| Acts::detail::VoidNavigator | The void navigator struct as a default navigator |
| Acts::VoidOutlierFinder | Void outlier finder |
| Acts::VolumeBounds | |
| Acts::ConeVolumeBounds | |
| Acts::CuboidVolumeBounds | |
| Acts::CutoutCylinderVolumeBounds | |
| Acts::CylinderVolumeBounds | |
| Acts::GenericCuboidVolumeBounds | |
| Acts::TrapezoidVolumeBounds | |
| Acts::VolumeCollector< Selector > | |
| Acts::VolumeConfig | VolumeConfig struct to understand the layer config |
| Acts::CuboidVolumeBuilder::VolumeConfig | This struct stores the data for the construction of a cuboid TrackingVolume with a given number of PlaneLayers |
| Acts::VolumeHit | The information to be writtern out per hit volume |
| Acts::detail::VolumeMaterialInteraction | Struct to handle volume material interaction |
| Acts::VolumeMaterialMapper | VolumeMaterialMapper |
| Acts::JsonGeometryConverter::VolumeRep | Volume representation for Json writing |
| Acts::VolumeSelector | Simple struct to select volumes |
| tetgenio::voroedge | |
| tetgenio::vorofacet | |
| FairDbResultKey::VRecKey | |
| ActsFatras::Casts::Vrho | Retrieve the transverse absolute distance of the position to the origin |
| gbl::VSymMatrix | Simple symmetric Matrix based on std::vector<double> |
| gbl::VVector | Simple Vector based on std::vector<double> |
| ActsFatras::Casts::Vz | Retrieve the longitudinal distance of the position to the origin |
| weak_ptr< T > | |
| ActsExamples::WhiteBoard | |
| nlohmann::detail::wide_string_input_helper< WideStringType, T > | |
| nlohmann::detail::wide_string_input_helper< WideStringType, 2 > | |
| Acts::WrappingConfig | The WrappingSetup that is happening here |
| x | |
| eicpy.qaplots.LogAxis | |
| xMD5Context | |
| y | |
| eicpy.qaplots.LogAxis | |
| z | |
| eicpy.qaplots.LogAxis | |
| ZCylinderSurfaceBuilder | Construct a z-cylinder centered at zero with the track on its surface |
| ZHough | |
| ZHough_Cylindrical | |
| Smear::Acceptance::Zone | |
| Acts::ZScanVertexFinder< vfitter_t > | Implements a vertex finder based on the mode of z0 values: |
| ZStrawSurfaceBuilder | Construct a z-straw at the track position |
| namedtuple | |
| eicpy.qaplots.LogAxis | |
1.8.2
with EIC GitHub integration
