Logo ROOT  
Reference Guide
 
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Loading...
Searching...
No Matches
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345678910]
 C__argb32__
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, N, M >Struct to do a Cholesky decomposition
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 0, M >Struct to do a Cholesky decomposition (specialized, N = 0)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 1, M >Struct to do a Cholesky decomposition (specialized, N = 1)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 2, M >Struct to do a Cholesky decomposition (specialized, N = 2)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 3, M >Struct to do a Cholesky decomposition (specialized, N = 3)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 4, M >Struct to do a Cholesky decomposition (specialized, N = 4)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 5, M >Struct to do a Cholesky decomposition (specialized, N = 5)
 CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 6, M >Struct to do a Cholesky decomposition (specialized, N = 6)
 CROOT::Math::CholeskyDecompHelpers::_decomposerGenDim< F, M >Struct to do a Cholesky decomposition (general dimensionality)
 C_EdgeTableEntry
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, N, M >Struct to obtain the inverse from a Cholesky decomposition
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 0, M >Struct to obtain the inverse from a Cholesky decomposition (N = 0)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 1, M >Struct to obtain the inverse from a Cholesky decomposition (N = 1)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 2, M >Struct to obtain the inverse from a Cholesky decomposition (N = 2)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 3, M >Struct to obtain the inverse from a Cholesky decomposition (N = 3)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 4, M >Struct to obtain the inverse from a Cholesky decomposition (N = 4)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 5, M >Struct to obtain the inverse from a Cholesky decomposition (N = 5)
 CROOT::Math::CholeskyDecompHelpers::_inverter< F, 6, M >Struct to obtain the inverse from a Cholesky decomposition (N = 6)
 CROOT::Math::CholeskyDecompHelpers::_inverterGenDim< F, M >Struct to obtain the inverse from a Cholesky decomposition (general dimensionality)
 C_PROCESS_MEMORY_COUNTERS
 C_root_std_complex< T >
 C_ScanLineList
 C_ScanLineListBlock
 CROOT::Math::CholeskyDecompHelpers::_solver< F, N, V >Struct to solve a linear system using its Cholesky decomposition
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 0, V >Struct to solve a linear system using its Cholesky decomposition (N=0)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 1, V >Struct to solve a linear system using its Cholesky decomposition (N=1)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 2, V >Struct to solve a linear system using its Cholesky decomposition (N=2)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 3, V >Struct to solve a linear system using its Cholesky decomposition (N=3)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 4, V >Struct to solve a linear system using its Cholesky decomposition (N=4)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 5, V >Struct to solve a linear system using its Cholesky decomposition (N=5)
 CROOT::Math::CholeskyDecompHelpers::_solver< F, 6, V >Struct to solve a linear system using its Cholesky decomposition (N=6)
 CROOT::Math::CholeskyDecompHelpers::_solverGenDim< F, V >Struct to solve a linear system using its Cholesky decomposition (generalised dimensionality)
 C_x3d_data_
 C_x3d_sizeof_
 CROOT::Minuit2::ABObj< mtype, M, T >
 CROOT::Minuit2::ABObj< sym, LASymMatrix, double >
 CROOT::Minuit2::ABObj< vec, LAVector, double >
 CROOT::Minuit2::ABProd< M1, M2 >
 CRooBatchCompute::AbsBuffer
 CRooBatchCompute::AbsBufferManager
 CROOT::Minuit2::ABSum< M1, M2 >
 CTMVA::AbsValue
 CROOT::option::Parser::Action
 CROOT::Math::AddOp< T >Addition Operation Class
 CROOT::Math::AddPolicy< T, D1, D2, R1, R2 >Matrix addition policy
 CROOT::Math::AddPolicy< T, D1, D2, MatRepSym< T, D1 >, MatRepSym< T, D1 > >
 CROOT::Detail::TCollectionProxyInfo::Address< T >
 CROOT::Detail::TCollectionProxyInfo::Address< const Bool_t & >
 CROOT::Detail::TCollectionProxyInfo::Address< T::const_reference >
 Cah
 CROOT::Minuit2::AlgebraicProdType< A, B >
 CROOT::Minuit2::AlgebraicProdType< gen, gen >
 CROOT::Minuit2::AlgebraicProdType< gen, sym >
 CROOT::Minuit2::AlgebraicProdType< gen, vec >
 CROOT::Minuit2::AlgebraicProdType< sym, gen >
 CROOT::Minuit2::AlgebraicProdType< sym, sym >
 CROOT::Minuit2::AlgebraicProdType< sym, vec >
 CROOT::Minuit2::AlgebraicProdType< T, T >
 CROOT::Minuit2::AlgebraicProdType< vec, gen >
 CROOT::Minuit2::AlgebraicProdType< vec, sym >
 CROOT::Minuit2::AlgebraicSumType< A, B >
 CROOT::Minuit2::AlgebraicSumType< gen, vec >
 CROOT::Minuit2::AlgebraicSumType< sym, vec >
 CROOT::Minuit2::AlgebraicSumType< T, T >
 CROOT::Minuit2::AlgebraicSumType< vec, gen >
 CROOT::Minuit2::AlgebraicSumType< vec, sym >
 CAlternateTupleIntDoubleAsc
 CAlternateTupleIntDoubleDes
 CRooAbsCachedPdf::AnaIntConfig
 CRooMultiVarGaussian::AnaIntData
 CRScanner::AnnotatedNamespaceDecl
 CROOT::TMetaUtils::AnnotatedRecordDecl
 CROOT::Fit::AreaComparer
 CROOT::option::ArgFunctions for checking the validity of option arguments
 CReadSpeed::Args
 Cstd::array< double, DIMENSIONS >
 CRooVectorDataStore::ArraysStruct::ArrayInfo< T >
 CRooVectorDataStore::ArraysStructOutput struct for the RooVectorDataStore::getArrays() helper function
 Carrow::ArrayVisitor
 CRooStats::HistFactory::AsimovTODO Here, we are missing some documentation
 CROOT::Math::Assign< T, D1, D2, A, R1, R2 >Structure to assign from an expression based to general matrix to general matrix
 CROOT::Math::Assign< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >Dummy Structure which flags an error to avoid assignment from expression based on a general matrix to a symmetric matrix
 CROOT::Math::Assign< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >Structure to assign from an expression based to symmetric matrix to symmetric matrix
 CROOT::Math::AssignItr< T, D1, D2, R >Structure for assignment to a general matrix from iterator
 CROOT::Math::AssignItr< T, D1, D2, MatRepSym< T, D1 > >Specialized structure for assignment to a symmetrix matrix from iterator
 CROOT::Math::AssignSymForce Expression evaluation from general to symmetric
 CTExMap::Assoc_t
 CTStreamerInfoActions::AssociativeLooper
 CROOT::Experimental::XRooFit::xRooFit::Asymptotics
 CXMLReader::Attributes
 CROOT::MacOSX::Util::AutoreleasePool
 CAutoRestorer
 CROOT::Math::AxisAngleAxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis
 CROOT::Experimental::Internal::AxisConfigToType< EKind >Converts a RAxisConfig of whatever kind to the corresponding RAxisBase-derived object
 CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kEquidistant >
 CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kGrow >
 CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kIrregular >
 CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kLabels >
 CB1
 CRooStats::HistFactory::RooBarlowBeestonLL::BarlowCache
 CBase_t
 CBaseClass
 CBaseCounterT
 CROOT::Math::BaseIntegratorOptionsBase class for Numerical integration options common in 1D and multi-dimension This is an internal class and is not supposed to be instantiated by the user
 CROOT::Math::KDTree< _DataPoint >::BaseNode
 CBaseSelectionRule
 CBasicGRULayerGeneric implementation
 CBasicLSTMLayerGeneric implementation
 CBasicRNNLayerGeneric implementation
 CBasisFunction< Func >
 CTTreePerfStats::BasketInfo
 CBatch
 CRooBatchCompute::Batch
 CTMVA::DNN::BatchEncapsulates one mini-batch
 CBatchesThese classes encapsulate the necessary data for the computations
 CRooBatchCompute::Batches
 Cbvh::v2::BBox< T, N >
 CTMVA::BDTEventWrapper
 CRooStats::BernsteinCorrectionBernsteinCorrection is a utility in RooStats to augment a nominal PDF with a polynomial correction term
 CBeta_interval_length
 CROOT::Minuit2::BFGSMinimizerType
 CROOT::Minuit2::VariableMetricMinimizer::BFGSType
 Cbvh::v2::BinnedSahBuilder< Node, BinCount >::Bin
 Cbvh::v2::MiniTreeBuilder< Node, MortonCode >::Bin
 CROOT::Math::BinaryOp< Operator, LHS, RHS, T >BinaryOperation class A class representing binary operators in the parse tree
 CROOT::Math::BinaryOpCopyL< Operator, LHS, RHS, T >Binary Operation class with value storage for the left argument
 CROOT::Math::BinaryOpCopyR< Operator, LHS, RHS, T >Binary Operation class with value storage for the right argument
 CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Op1 >
 CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Add >
 CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Div >
 CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Mul >
 CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Pow >
 CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Sub >
 CBinaryOpPolicy
 CTMVA::BinaryTreeBase class for BinarySearch and Decision Trees
 CROOT::R::TRDataFrame::Binding
 CROOT::R::TRInterface::Binding
 CTMVA::OptionMap::Binding
 CBinEdges
 CRooHelpers::BinnedLOutput
 CBinningRestorer
 CBinomialNeymanInterval< Sorter >Implement noncentral binomial confidence intervals using the Neyman construction
 CBinomialNeymanInterval< FeldmanCousinsSorter >
 CBinomialProbHelperHelper class impelementing the binomial probability and the likelihood ratio used for ordering the interval in the FeldmanCousins interval class
 CRooMultiVarGaussian::BitBlock
 CROOT::Math::GenVector_detail::BitReproducible
 CTStreamerInfoActions::BitsMarker
 CROOT::Experimental::RStyle::Block_t
 CTEveParamList::BoolConfig_t
 CBoolNameTable_t
 CROOT::Math::BoostLorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix
 CROOT::Math::BoostXClass representing a Lorentz Boost along the X axis, by beta
 CROOT::Math::BoostYClass representing a Lorentz Boost along the Y axis, by beta
 CROOT::Math::BoostZClass representing a Lorentz Boost along the Z axis, by beta
 CRgl::Pad::BoundingRect< ValueType >
 CROOT::Fit::Box
 CROOT::Fit::BoxContainer
 CRooNDKeysPdf::BoxInfo
 CRooBatchCompute::BracketAdapter< T >Little adapter that gives a bracket operator to types that don't have one
 CRooBatchCompute::BracketAdapterWithMask
 CRooStats::BranchStore
 CBRESINFO
 CTGeoBatemanSol::BtCoef_t
 CRooSimWSTool::BuildConfig
 CBuildNodeInfo
 Cbvh::v2::MiniTreeBuilder< Node, MortonCode >::BuildTask
 Cbvh::v2::Bvh< Node >
 Cbvh::v2::Bvh< bvh::v2::Node >
 CReadSpeed::ByteData
 CROOT::Detail::CallableTraitsImpl< T, HasCallOp >Extract types from the signature of a callable object. See CallableTraits
 CROOT::Detail::CallableTraitsImpl< R(*)(Args...), false >
 CROOT::Detail::CallableTraitsImpl< R(Args...), false >
 CROOT::Detail::CallableTraitsImpl< R(T::*)(Args...) const, false >
 CROOT::Detail::CallableTraitsImpl< R(T::*)(Args...), false >
 CROOT::Detail::CallableTraitsImpl< T, true >
 CCPyCppyy::CallContext
 CCPyCppyy::CallContextRAII< F >
 CTInterpreter::CallFuncIFacePtr_t
 CROOT::Internal::RDF::CallGuaranteedOrderStruct to wrap the call to a function with a guaranteed order of execution of its arguments
 Cbvh::v2::ReinsertionOptimizer< Node >::Candidate
 CCanvasPainterGeneratorCreates RCanvasPainter objects
 CROOT::Math::Cartesian2D< T >Class describing a 2D cartesian coordinate system (x, y coordinates)
 CROOT::Math::Cartesian3D< T >Class describing a 3D cartesian coordinate system (x, y, z coordinates)
 CROOT::Math::Cartesian3D< double >
 CROOT::Math::Cartesian3D< Scalar >
 CRooVectorDataStore::CatVector
 CTMVA::CCPrunerA helper class to prune a decision tree using the Cost Complexity method (see Classification and Regression Trees by Leo Breiman et al)
 CTMVA::CCTreeWrapper
 CTFITSHDU::Cell
 CTEveCaloLegoGL::Cell2D_t
 CCellData_tCell data inner structure
 CCellGeom_tCell geometry inner structure
 CROOT::Experimental::REveCaloData::CellGeom_t
 CTEveCaloData::CellGeom_tCell geometry inner structure
 CROOT::Experimental::REveCaloData::CellId_t
 CTEveCaloData::CellId_t
 CROOT::MacOSX::Util::CFScopeGuard< RefType >
 CROOT::MacOSX::Util::CFScopeGuard< CGContextRef >
 CROOT::MacOSX::Util::CFScopeGuard< CGImageRef >
 CROOT::MacOSX::Util::CFStrongReference< RefType >
 CROOT::Quartz::CGAAStateGuard
 Ccgi_environment
 CROOT::Quartz::CGStateGuard
 CChangeGuardRAII guard for locking Eve manager (ctor) and processing changes (dtor)
 CROOT::Experimental::REveManager::ChangeGuard
 CChangeOperModeRAIIStruct to temporarily change the operation mode of a RooAbsArg until it goes out of scope
 CRooStats::HistFactory::ChannelThis class encapsulates all information for the statistical interpretation of one experiment
 CCHAR64LONG16
 CTCling::CharPtrCmp_t
 CROOT::Math::ChebyshevApproxClass describing a Chebyshev series which can be used to approximate a function in a defined range [a,b] using Chebyshev polynomials
 CROOT::Math::ChebyshevPol
 CROOT::TestSupport::CheckDiagsRAIIInstall a ROOT diagnostic handler to analyse diagnostics
 CRooFit::Detail::JSONNode::child_iterator_t< Nd >
 CRooFit::Detail::JSONNode::children_view_t< Nd >
 CROOT::Math::CholeskyDecomp< F, N >Class to compute the Cholesky decomposition of a matrix
 CROOT::Math::CholeskyDecompGenDim< F >Class to compute the Cholesky decomposition of a matrix
 CROOT::Math::CholInverter< idim >
 CRcpp::class_
 CROOT::Browsable::RProvider::ClassArg
 CROOT::Meta::Selection::ClassAttributes< classAttributes >Used to specify attributes of classes in the "DictSelection" syntax
 CRooWorkspace::CodeRepo::ClassFiles
 CClassificationClass to perform two class classification
 CClassificationResultClass to save the results of the classifier
 CTMVA::ClassifierFactoryThis is the MVA factory
 CRooWorkspace::CodeRepo::ClassRelInfo
 Cclnt_HS_t
 CRooFit::TestStatistics::RooAbsL::ClonePdfDataConvenience wrapper class used to distinguish between pdf/data owning and non-owning constructors
 CROOT::Internal::TThreadedObjectUtils::Cloner< T, isCopyConstructible >Return a copy of the object or a "Clone" if the copy constructor is not implemented
 CROOT::Internal::TThreadedObjectUtils::Cloner< T, false >
 CROOT::MacOSX::Details::CocoaPrivate
 CRooFit::Experimental::CodegenContextA class to maintain the context for squashing of RooFit models into code
 CRooFit::Experimental::CodegenIntegralImplCaller< Arg_t >
 CTStreamerInfoActions::CollectionLooper< Looper >
 CTStreamerInfoActions::CollectionLooper< GenericLooper >
 CTStreamerInfoActions::CollectionLooper< ScalarLooper >
 CTStreamerInfoActions::CollectionLooper< VectorLooper >
 CTStreamerInfoActions::CollectionLooper< VectorPtrLooper >
 CCollectionManager
 CROOT::MacOSX::X11::ColorParser
 CColorStruct_t
 CTFITSHDU::Column
 CROOT::Internal::RDF::ColumnType< VaryExpressionRet_t, IsSingleColumn >
 CROOT::Internal::RDF::ColumnType< ROOT::RVec< ROOT::RVec< T > >, false >
 CROOT::Internal::RDF::ColumnType< ROOT::RVec< T >, true >
 CRooJSONFactoryWSTool::CombinedData
 CROOT::MacOSX::X11::Command
 CROOT::MacOSX::X11::CommandBuffer
 CROOT::Experimental::Internal::RPageSinkFile::CommitBatch
 CCompareAsc< T >
 CTKDTreeBinning::CompareAsc
 CcompareBAasc
 CcompareBAdesc
 CROOT::TMetaUtils::AnnotatedRecordDecl::CompareByName
 CCompareDataHistBins
 CCompareDesc< T >
 CTKDTreeBinning::CompareDesc
 CTTreeCloner::CompareEntry
 CROOT::Math::KDTree< _DataPoint >::ComparePoints
 CTTreeCloner::CompareSeek
 CCompareSparseHistBins
 CCompareVectorIndices
 CTMVA::Experimental::SOFIE::ComparisionTrait< T, Op1 >
 CTMVA::Experimental::SOFIE::ComparisionTrait< T, Eq >
 CTMVA::Experimental::SOFIE::ComparisionTrait< T, Greater >
 CTMVA::Experimental::SOFIE::ComparisionTrait< T, GreaterEq >
 CTMVA::Experimental::SOFIE::ComparisionTrait< T, Less >
 CTMVA::Experimental::SOFIE::ComparisionTrait< T, LessEq >
 CRooFit::Detail::CompileContext
 CROOT::Math::CompileTimeChecker< bool >
 CROOT::Math::CompileTimeChecker< false >
 CTMVA::Experimental::Internal::ComputeHelper< I, T, F >Compute helper
 Cstd::conditional_t
 Cbvh::v2::ReinsertionOptimizer< Node >::Config
 Cbvh::v2::TopDownSahBuilder< Node >::Config
 CRooBatchCompute::ConfigMinimal configuration struct to steer the evaluation of a single node with the RooBatchCompute library
 CRooFit::MultiProcess::ConfigConfiguration for MultiProcess infrastructure
 CRooLagrangianMorphFunc::Config
 CRooMinimizer::ConfigConfig argument to RooMinimizer constructor
 CTMVA::ConfigSingleton class for global configuration settings used by TMVA
 CRooStats::HistFactory::ConfigParserTODO Add documentation
 CRooAbsTestStatistic::Configuration
 CRooStats::HistFactory::HistoToWorkspaceFactoryFast::Configuration
 CROOT::Experimental::REveManager::Conn
 CROOT::Experimental::RAxisBase::const_iteratorRandom const_iterator through bins
 Cstd::vector< T >::const_iteratorSTL iterator class
 CROOT::Math::Constant< T >Constant expression class A class representing constant expressions (literals) in the parse tree
 CRooFit::TestStatistics::ConstantTermsOptimizerAnalyzes a function given a dataset/observables for constant terms and caches those in the dataset
 CContDistFree functions adapter needed by UNURAN for onedimensional continuous distributions
 CROOT::Minuit2::ContoursError
 CTMVA::ConvergenceTestCheck for convergence
 CTStreamerInfoActions::ConvertBasicType< From, To >
 CTStreamerInfoActions::GenericLooper::ConvertBasicType< From, To, Converter >
 CTStreamerInfoActions::VectorLooper::ConvertBasicType< From, To >
 CTStreamerInfoActions::VectorPtrLooper::ConvertBasicType< From, To >
 CTStreamerInfoActions::ConvertBasicType< BitsMarker, To >
 CTStreamerInfoActions::VectorLooper::ConvertBasicType< BitsMarker, To >
 CTStreamerInfoActions::VectorPtrLooper::ConvertBasicType< BitsMarker, To >
 CTStreamerInfoActions::GenericLooper::ConvertBasicType< BitsMarker, To, Generic >
 CTStreamerInfoActions::ConvertBasicType< NoFactorMarker< From >, To >
 CTStreamerInfoActions::VectorLooper::ConvertBasicType< NoFactorMarker< From >, To >
 CTStreamerInfoActions::VectorPtrLooper::ConvertBasicType< NoFactorMarker< From >, To >
 CTStreamerInfoActions::GenericLooper::ConvertBasicType< NoFactorMarker< From >, To, Converter >
 CTStreamerInfoActions::ConvertBasicType< WithFactorMarker< From >, To >
 CTStreamerInfoActions::VectorLooper::ConvertBasicType< WithFactorMarker< From >, To >
 CTStreamerInfoActions::VectorPtrLooper::ConvertBasicType< WithFactorMarker< From >, To >
 CTStreamerInfoActions::GenericLooper::ConvertBasicType< WithFactorMarker< From >, To, Converter >
 CTStreamerInfoActions::AssociativeLooper::ConvertCollectionBasicType< From, To >
 CTStreamerInfoActions::GenericLooper::ConvertCollectionBasicType< From, To >
 CTStreamerInfoActions::VectorLooper::ConvertCollectionBasicType< From, To >
 CTStreamerInfoActions::VectorLooper::ConvertCollectionBasicType< NoFactorMarker< From >, To >
 CCPyCppyy::Converter
 CTStreamerInfoActions::AssociativeLooper::ConvertRead< From, To >
 CTStreamerInfoActions::AssociativeLooper::ConvertRead< NoFactorMarker< From >, To >
 CTStreamerInfoActions::AssociativeLooper::ConvertRead< WithFactorMarker< From >, To >
 CROOT::Experimental::RPadLength::CoordSysBase< DERIVED >
 CROOT::Experimental::RPadLength::CoordSysBase< Normal >
 CROOT::Experimental::RPadLength::CoordSysBase< Pixel >
 CROOT::Experimental::RPadLength::CoordSysBase< User >
 Ccout_redirect
 CCPyCppyy::CPPDataMember
 CCPyCppyy::CPPExcInstance
 CCPyCppyy::CPPInstance
 CCPyCppyy::CPPOverload
 CCPyCppyy::CPPScope
 CCPPYY_G__p2p
 CCPPYY_G__value
 CCpuInfo_t
 CCPyCppyy_tagCDataObject
 CCPyCppyy_tagPyCArgObject
 CRooStats::HistFactory::Detail::CreateGammaConstraintsOutput
 CCreateMethodPluginsPlugins analysis
 CROOT::RWebDisplayHandle::Creator!< page content
 CROOT::Minuit2::MnCross::CrossFcnLimit
 CROOT::Minuit2::MnCross::CrossNewMin
 CROOT::Minuit2::MnCross::CrossParLimit
 CCrossValidation
 CTMVA::CrossValidationFoldResult
 CTMVA::CrossValidationResultClass to save the results of cross validation, the metric for the classification ins ROC and you can ROC curves ROC integrals, ROC average and ROC standard deviation
 CTMVA::DNN::CudaActivationDescriptor
 CTMVA::DNN::CudaConvolutionBwdDataAlgo
 CTMVA::DNN::CudaConvolutionBwdFilterAlgo
 CTMVA::DNN::CudaConvolutionDescriptor
 CTMVA::DNN::CudaConvolutionFwdAlgo
 CTMVA::DNN::CudaDataType
 CTMVA::DNN::CudaDropoutDescriptor
 CTMVA::DNN::CudaEmptyDescriptor
 CRooBatchCompute::CudaInterface::CudaEvent
 CTMVA::DNN::CudaFilterDescriptor
 CTMVA::DNN::CudaPoolingDescriptor
 CRooBatchCompute::CudaInterface::CudaStream
 CTMVA::Experimental::RSofieReader::CustomOperatorData
 CROOT::Math::KDTree< _DataPoint >::Cut
 CTMVA::CvSplitKFoldsExpr
 CROOT::Math::Cylindrical3D< T >Class describing a cylindrical coordinate system based on rho, z and phi
 CROOT::Math::CylindricalEta3D< T >Class describing a cylindrical coordinate system based on eta (pseudorapidity) instead of z
 Cd_iov_tIovec for memory buffer
 Cd_sg_list_tScatter/gather list for memory buffers
 Cdaos_cont_info_tContainer information
 Cdaos_eventEvent and event queue
 Cdaos_handle_tGeneric handle for various DAOS components like container, object, etc
 Cdaos_iod_t
 Cdaos_iom_t
 Cdaos_obj_id_t
 Cdaos_pool_info_tStorage pool
 Cdaos_prop_tDaos properties, for pool or container
 Cdaos_recx_t
 CReadSpeed::Data
 CRooStats::HistFactory::Data
 CROOT::Minuit2::FunctionGradient::Data
 CROOT::Minuit2::FunctionMinimum::Data
 CROOT::Minuit2::MinimumError::Data
 CROOT::Minuit2::MinimumParameters::Data
 CROOT::Minuit2::MinimumSeed::Data
 CROOT::Minuit2::MinimumState::Data
 CDataKeyTo use as a key type for RooFit data maps and containers
 CRooFit::Detail::DataKey
 CDataloader
 CROOT::Fit::DataOptionsDataOptions : simple structure holding the options on how the data are filled
 CROOT::Fit::DataRangeClass describing the range in the coordinates it supports multiple range in a coordinate
 CROOT::Math::GenVector_detail::BitReproducible::DB8
 CClingMemberIterInternal::DCIterIteration over collected DeclContexts
 Cde
 CDebuggingSamplerDebuggingSampler is a simple implementation of the DistributionCreator interface used for debugging
 CDebuggingTestStatDebuggingTestStat is a simple implementation of the DistributionCreator interface used for debugging
 Cbvh::v2::DefaultBuilder< Node >This builder is only a wrapper around all the other builders, which selects the best builder depending on the desired BVH quality and whether a multi-threaded build is desired
 CROOT::Math::DefaultCoordinateSystemTagDefaultCoordinateSystemTag Default tag for identifying any coordinate system
 CDefaultIcon_t
 Cllvm::orc::DefinitionGenerator
 CROOT::Math::Delaunay2DClass to generate a Delaunay triangulation of a 2D set of points
 CRScanner::DelayedAnnotatedRecordDeclInfo
 CTMVA::DeleteFunctor_t< T >
 CROOT::Math::DerivatorClass for computing numerical derivative of a function
 CROOT::Minuit2::DerivatorElement
 CDerivFunType
 CROOT::option::DescriptorDescribes an option, its help text (usage) and how it should be parsed
 CROOT::Internal::TThreadedObjectUtils::Detacher< T, ISHISTO >
 CROOT::Internal::TThreadedObjectUtils::Detacher< T, true >
 CRooStats::DetailedOutputAggregatorThis class is designed to aid in the construction of RooDataSets and RooArgSets, particularly those naturally arising in fitting operations
 CROOT::Math::Determinant< n, idim >Detrminant for a general squared matrix Function to compute the determinant from a square matrix ( det(A)) of dimension idim and order n
 CREveSelection::Deviator
 CROOT::Experimental::REveSelection::Deviator
 CdFieldStruct used by ShowGuidelines to store the distance Field between objects in the canvas
 CROOT::TestSupport::CheckDiagsRAII::Diag_t
 Cclang::DiagnosticConsumer
 CROOT::Experimental::REveDigitSet::DigitBase_t
 CTEveDigitSet::DigitBase_t
 CR6::Dim< T, kNDim >
 CR7::Dim< T, kNDim >
 CTMVA::Experimental::SOFIE::Dim
 CR6::Dim< T, 1 >
 CR7::Dim< T, 1 >
 CR6::Dim< T, 2 >
 CR7::Dim< T, 2 >
 CCPyCppyy::Dimensions
 Cdir_scan_data
 CROOT::Internal::TThreadedObjectUtils::DirCreator< T, ISHISTO >
 CROOT::Internal::TThreadedObjectUtils::DirCreator< T, true >
 CDisableCachingRAIIDisable all caches for sub-branches in an expression tree
 CDiscrDistFree functions adapter needed by UNURAN for one-dimensional discrete distribution
 CROOT::Experimental::RPalette::Discrete_tTag type used to signal that the palette's colors should not be interpolated
 CCPyCppyy::DispatchPtr
 CROOT::Math::DisplacementVector2D< CoordSystem, Tag >Class describing a generic displacement vector in 2 dimensions
 CROOT::Math::DisplacementVector3D< CoordSystem, Tag >Class describing a generic displacement vector in 3 dimensions
 CROOT::Math::DisplacementVector3D< Cartesian3D< double >, DefaultCoordinateSystemTag >
 CROOT::Math::DisplacementVector3D< Cartesian3D< Scalar > >
 CROOT::Internal::RDF::DisplayHelper< T >
 CROOT::Math::DistSamplerInterface class for generic sampling of a distribution, i.e
 CROOT::Math::DistSamplerOptionsDistSampler options class
 CROOT::Math::DivOp< T >Division (element-wise) Operation Class
 CRooFit::JSONIO::Detail::Domains
 CDoWork
 CTGLScene::DrawElement_t
 CRooPlot::DrawOpt
 CROOT::Internal::RootCling::DriverConfig
 CTMVA::DTNodeTrainingInfo
 CTMVA::DNN::DummyConvolutionBwdDataAlgo
 CTMVA::DNN::DummyConvolutionBwdFilterAlgo
 CTMVA::DNN::DummyConvolutionDescriptor
 CTMVA::DNN::DummyConvolutionFwdAlgo
 CTMVA::DNN::DummyCudaDataType
 CTMVA::DNN::DummyDataType
 CTMVA::DNN::DummyDescriptor
 CTMVA::DNN::DummyDropoutDescriptor
 CTMVA::DNN::DummyEmptyDescriptor
 CTMVA::DNN::DummyFilterDescriptor
 CTMVA::DNN::DummyPoolingDescriptor
 CTMVA::Experimental::SOFIE::DynamicTensorInfo
 CROOT::RCompressionSetting::EAlgorithm
 CROOT::RCompressionSetting::EDefaults
 CROOT::Experimental::REveGeoPolyShape::Edge_t
 CTEveGeoPolyShape::Edge_t
 CTEvePolygonSetProjectedGL::Edge_t
 CEdgeTable
 CR6::Dim< T, 1 >::EE
 CR6::Dim< T, 2 >::EE
 CR7::Dim< T, 1 >::EE
 CR7::Dim< T, 2 >::EE
 CEfficiencyPlotWrapperNote: This file assumes a certain structure on the input file
 CTBranchSTL::ElementBranchHelper_t
 CROOT::RCompressionSetting::ELevel
 CEmptyCall
 Cstd::enable_shared_from_this
 CRooMappedCategory::Entry
 CTTreeCache::MissCache::Entry
 CReadSpeed::EntryRange
 CENTupleColumnTypeThe available trivial, native content types of a column
 CROOT::Detail::TCollectionProxyInfo::EnvironBase
 Czmq::error_t
 CROOT::Math::gv_detail::ERROR_This_Rotation_Conversion_is_NOT_Supported
 CROOT::Math::EulerAnglesEulerAngles class describing rotation as three angles (Euler Angles)
 CRooFit::EvalContext
 CRooAbsReal::EvalError
 CRooAbsReal::EvalErrorContextContext to temporarily change the error logging mode as long as the context is alive
 CROOT::Fit::FitUtil::Evaluate< T >
 CRooFit::EvaluatorEvaluates a RooAbsReal object in other ways than recursive graph traversal
 CROOT::Math::EvaluatorOneDim< MultiFuncType >
 CROOT::Math::EvaluatorOneDim< const ROOT::Math::IParamMultiFunction & >
 CEvent
 CTMVA::kNN::Event
 CEvent_tEvent structure
 CTMVA::QuickMVAProbEstimator::EventInfo
 CTMVA::DataSetFactory::EventStats
 CROOT::MacOSX::X11::EventTranslator
 CUi::ExampleWidget
 Cstd::exceptionSTL class
 CCppyyLegacy::ExceptionContext_t
 CExceptionContext_t
 Cbvh::v2::Executor< Derived >Helper object that provides iteration and reduction over one-dimensional ranges
 CCPyCppyy::Executor
 CTMVA::ExecutorBase Executor class
 Cbvh::v2::Executor< ParallelExecutor >
 Cbvh::v2::Executor< SequentialExecutor >
 CRooExpensiveObjectCache::ExpensiveObject
 CRooFit::JSONIO::Exporter
 CRooFit::JSONIO::ExportKeys
 CROOT::Math::Expr< ExprType, T, D, D2, R1 >
 CTMVA::Experimental::SOFIE::ExtractDataFromTP< T >
 CTMVA::Experimental::SOFIE::ExtractDataFromTP< double >
 CTMVA::Experimental::SOFIE::ExtractDataFromTP< float >
 CTMVA::Experimental::SOFIE::ExtractDataFromTP< int32_t >
 CTMVA::Experimental::SOFIE::ExtractDataFromTP< int64_t >
 CRooWorkspace::CodeRepo::ExtraHeader
 Cextrapolation_table
 CROOT::Math::Fabs< T >Unary abs Operation Class
 CRooProdPdf::Factorized
 CFactory
 CROOT::Math::FactoryFactory class holding static functions to create the interfaces like ROOT::Math::Minimizer via the Plugin Manager
 CTMVA::DNN::TCpuBuffer< AFloat >::FakeIteratorBegin
 Cstd::false_type
 CROOT::Math::FastInverter< idim, n >Fast Matrix Inverter class Class to specialize calls to Dinv
 CROOT::Math::FastInverter< 3 >3x3 direct matrix inversion using Cramer Rule use only for FastInverter
 CROOT::Math::FastInverter< 4 >4x4 matrix inversion using Cramers rule
 CROOT::Math::FastInverter< 5 >5x5 Matrix inversion using Cramers rule
 CFeldmanCousinsSorter
 CROOT::Experimental::Internal::RDaosObject::FetchUpdateArgsContains required information for a single fetch/update operation
 CFileStat_t
 CRgl::Pad::FillAttribSet
 CROOT::TestSupport::FilterDiagsRAIIAllows a user function to catch and filter/analyse ROOT and cling diagnostics, e.g
 CFindFileData_tStruct used to pass information between OpenDirectory and GetDirEntry in a thread safe way (each thread creates a new instance of it)
 CROOT::Fit::FitConfigClass describing the configuration of the fit, options and parameter settings using the ROOT::Fit::ParameterSettings class
 CROOT::Fit::FitDataBase class for all the fit data types: Stores the coordinates and the DataOptions
 CROOT::Experimental::RFitPanel::FitRes
 CRooMinimizer::FitResult
 CROOT::Fit::FitResultClass containing the result of the fit and all the related information (fitted parameter values, error, covariance matrix and minimizer result information) Contains a pointer also to the fitted (model) function, modified with the fit parameter values
 CROOT::Fit::FitterFitter class, entry point for performing all type of fits
 CRooMinimizer::FitterInterface
 CFlagConvResult< T >
 CRooFit::Detail::FlatMap< Key_t, Val_t >
 CTEveParamList::FloatConfig_t
 CFMFunc
 CFontAttributes_t
 CROOT::MacOSX::Details::FontCache
 CROOT::MacOSX::Details::FontCache::FontList
 CFontMetrics_t
 CTGFontDialog::FontProp_t
 CFontStateMap_t
 CFoo
 CFoption_t
 CROOT::TestSupport::ForbidDiagnosticsError handler for gtests that generates failures for every received diagnostic > kInfo when this file is linked to
 CFormatPdfTree
 CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F, T >
 CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F *, T >
 CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F *const, T >
 CTFitEditor::FuncParamData_t
 Cfuncptr_and_voidptr_t
 CROOT::Minuit2::FunctionGradient
 CROOT::Minuit2::FunctionMinimumClass holding the full result of the minimization; both internal and external (MnUserParameterState) representation available for the parameters at the Minimum
 CTClassEdit::FunctionSplitInfoResult of splitting a function declaration into fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters)
 CRooRandomizeParamMCSModule::GausParam
 CRooRandomizeParamMCSModule::GausParamSet
 CGcCache_t
 CGCValues_tGraphics context structure
 CROOT::Minuit2::gen
 CRooMultiVarGaussian::GenData
 CROOT::Math::GeneralHessianCalc< T >
 CROOT::Math::GeneralHessianCalc< double >
 CROOT::Math::GeneralLinearFunctionDerivation< T >Auxiliar class to bypass the (provisional) lack of vectorization in TFormula::EvalPar
 CROOT::Math::GeneralLinearFunctionDerivation< double >
 CROOT::Experimental::Internal::RVirtualCanvasPainter::Generator
 CTStreamerInfoActions::GenericLooper::Generic< From, To >
 CROOT::Minuit2::GenericFunctionClass from which all the other classes, representing functions, inherit
 CGenericRooFIterInterface for RooFIter-compatible iterators
 CTMVA::GeneticAlgorithmBase definition for genetic algorithm
 CTMVA::GeneticGenesCut optimisation interface class for genetic algorithm
 CROOT::Math::GeneticMinimizerParameters
 CTMVA::GeneticPopulationPopulation definition for genetic algorithm
 CTMVA::GeneticRangeRange definition for genetic algorithm
 CRooAbsPdf::GenSpec
 CROOT::Internal::GetFunctorType< T >Internal class used by TF1 for obtaining the type from a functor out of the set of valid operator() signatures
 CROOT::Internal::GetFunctorType< T(F::*)(const T *, const double *) const >
 CROOT::Internal::GetFunctorType< T(F::*)(const T *, const double *)>
 CROOT::Internal::GetFunctorType< T(F::*)(T *, double *) const >
 CROOT::Internal::GetFunctorType< T(F::*)(T *, double *)>
 CTFormLeafInfo::GetValueHelper< T >
 CTLeaf::GetValueHelper< T >
 CTFormLeafInfo::GetValueHelper< Long64_t >
 CTLeaf::GetValueHelper< Long64_t >
 CTFormLeafInfo::GetValueHelper< LongDouble_t >
 CTLeaf::GetValueHelper< LongDouble_t >
 CTFormLeafInfo::GetValueHelper< ULong64_t >
 CTLeaf::GetValueHelper< ULong64_t >
 CGFunc
 CGifColorType
 CGInverseFunc
 CGInverseFuncNdim
 CRgl::Pad::GLLimits
 CROOT::Math::GlobalCoordinateSystemTagTag for identifying vectors based on a global coordinate system
 CRooAbsReal::GlobalSelectComponentRAII
 CTMVA::Experimental::SOFIE::GNN_Data
 CTMVA::Experimental::SOFIE::GNN_Init
 CROOT::Math::GoFTestGoFTest class implementing the 1 sample and 2 sample goodness of fit tests for uni-variate distributions and data
 CROOT::Minuit2::GradientCalculatorInterface class for gradient calculators
 CGraphCreatorHelperHelper class that provides the operation graph nodes
 CROOT::Internal::RDF::GraphDrawing::GraphCreatorHelper
 CTMVA::Experimental::SOFIE::GraphIndependent_Init
 CROOT::Internal::RDF::GraphDrawing::GraphNodeClass used to create the operation graph to be printed in the dot representation
 CRooMomentMorphFuncND::Grid2
 Cgroup
 CROOT::Experimental::RAxisConfig::Grow_tTag type signalling that an axis should be able to grow; used for calling the appropriate constructor
 Cbvh::v2::GrowingStack< T >Growing stack that can be used for BVH traversal
 CROOT::Math::GSL1DMinimizerWrapperWrapper class for gsl_min_fminimizer structure
 Cgsl_function_struct
 Cgsl_integration_workspace
 CROOT::Math::GSLChebSeriesWrapper class for C struct gsl_cheb_series
 CROOT::Math::GSLDerivatorClass for computing numerical derivative of a function based on the GSL numerical algorithm This class is implemented using the numerical derivatives algorithms provided by GSL (see GSL Online Manual )
 CROOT::Math::GSLErrorClass to change GSL Error handler to use ROOT one
 CROOT::Math::GSLFunctionAdapter< UserFunc >Class for adapting any C++ functor class to C function pointers used by GSL
 CROOT::Math::GSLFunctionDerivWrapperClass to wrap a gsl_function_fdf (with derivatives)
 CROOT::Math::GSLFunctionWrapperWrapper class to the gsl_function C structure
 CROOT::Math::GSLIntegrationWorkspace
 CROOT::Math::GSLInterpolatorInterpolation class based on GSL interpolation functions
 CROOT::Math::GSLMCIntegrationWorkspace
 CROOT::Math::GSLMonteFunctionAdapter< UserFunc >
 CROOT::Math::GSLMonteFunctionWrapperWrapper to a multi-dim function withtout derivatives for Monte Carlo multi-dimensional integration algorithm
 CROOT::Math::GSLMultiFitGSLMultiFit, internal class for implementing GSL non linear least square GSL fitting
 CROOT::Math::GSLMultiFitFunctionAdapter< FuncVector >Class for adapting a C++ functor class to C function pointers used by GSL MultiFit Algorithm The templated C++ function class must implement:
 CROOT::Math::GSLMultiFitFunctionWrapperWrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
 CROOT::Math::GSLMultiMinDerivFunctionWrapperWrapper for a multi-dimensional function with derivatives used in GSL multidim minimization algorithm
 CROOT::Math::GSLMultiMinFunctionAdapter< UserFunc >Class for adapting any multi-dimension C++ functor class to C function pointers used by GSL MultiMin algorithms
 CROOT::Math::GSLMultiMinFunctionWrapperWrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
 CROOT::Math::GSLMultiMinimizerGSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives
 CROOT::Math::GSLMultiRootBaseSolverGSLMultiRootBaseSolver, internal class for implementing GSL multi-root finders This is the base class for GSLMultiRootSolver (solver not using derivatives) and GSLMUltiRootDerivSolver (solver using derivatives)
 CROOT::Math::GSLMultiRootDerivFunctionWrapperWrapper to a multi-dim function with derivatives for multi roots algorithm
 CROOT::Math::GSLMultiRootFinderClass for Multidimensional root finding algorithms bassed on GSL
 CROOT::Math::GSLMultiRootFunctionAdapter< FuncVector >Class for adapting a C++ functor class to C function pointers used by GSL MultiRoot Algorithm The templated C++ function class must implement:
 CROOT::Math::GSLMultiRootFunctionWrapperWrapper to a multi-dim function without derivatives for multi roots algorithm
 CROOT::Math::GSLQRngWrapperGSLQRngWrapper class to wrap gsl_qrng structure
 CROOT::Math::GSLQuasiRandomEngineGSLQuasiRandomEngine Base class for all GSL quasi random engines, normally user instantiate the derived classes which creates internally the generator and uses the class ROOT::Math::QuasiRandom
 CROOT::Math::GSLRandomEngineGSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator
 CROOT::Math::GSLRngROOTWrapper< Engine >Class for wrapping ROOT Engines in gsl_rng types which can be used as extra GSL random number generators For this we need to implement functions which will be called by gsl_rng
 CROOT::Math::GSLRngWrapperGSLRngWrapper class to wrap gsl_rng structure
 CROOT::Math::GSLRootFdFSolverRoot-Finder with derivatives implementation class using GSL
 CROOT::Math::GSLRootFSolverRoot-Finder implementation class using GSL
 CROOT::Math::GSLSimAnFuncGSLSimAnFunc class description
 CROOT::Math::GSLSimAnnealingGSLSimAnnealing class for performing a simulated annealing search of a multidimensional function
 CROOT::Math::GSLSimAnParamsStructure holding the simulated annealing parameters
 CRooRandom::Guard
 CHAddArgs
 CROOT::TypeTraits::HasBeginAndEnd< T >
 CROOT::Experimental::Internal::RDaosContainer::ROidDkeyPair::Hash
 CRooFit::Detail::HashAssistedFindHelper for hash-map-assisted finding of elements by name
 CROOT::Internal::RConcurrentHashColl::HashValue
 CROOT::Internal::RDF::HasMakeNew< T >
 CTClingValue::HasTheSameSizeAsClingValue
 CTFITSHDU::HDURecord
 CRooFit::MultiProcess::HeatmapAnalyzerReads and processes logfiles produced by RooFit::MultiProcess::ProcessTimer
 CRooFit::MultiProcess::Detail::HeatmapAnalyzerJsonData
 CROOT::Experimental::REveTrackPropagator::Helix_t
 CTEveTrackPropagator::Helix_t
 CHelperOps
 CHEPEVT_DEFHEPEVT common block
 CRooHelpers::HijackMessageStreamHijacks all messages with given level and topic (and optionally object name) while alive
 CRooStats::HistFactory::HistFactoryNavigation
 CRooStats::HistFactory::HistogramUncertaintyBase////////////////////////////////////////////////////////////////////////////////////////////Base class to store the up and down variations for histogram uncertainties
 CRooStats::HistFactory::HistRefInternal class wrapping an histogram and managing its content
 CHoption_tHistograms' drawing options structure
 CHparam_tHistogram parameters structure
 CTMVA::HyperParameterOptimisationResult
 CRooStats::HypoTestCalculatorHypoTestCalculator is an interface class for a tools which produce RooStats HypoTestResults
 CHypoTestWrapper< HypoTestType >
 CROOT::Math::IBaseFunctionMultiDimTempl< T >Documentation for the abstract class IBaseFunctionMultiDim
 CROOT::Math::IBaseFunctionMultiDimTempl< double >
 CROOT::Math::IBaseFunctionOneDimInterface (abstract class) for generic functions objects of one-dimension Provides a method to evaluate the function given a value (simple double) by implementing operator() (const double )
 CROOT::Math::IBaseParamDocumentation for the abstract class IBaseParam
 CRooFactoryWSTool::IFace
 CTMVA::IFitterTargetInterface for a fitter 'target'
 Cbvh::v2::IgnoreArgsHelper callable object that just ignores its arguments and returns nothing
 CROOT::Math::IGradientMultiDimTempl< T >
 CR6::Dim< T, 1 >::II
 CR6::Dim< T, 2 >::II
 CR7::Dim< T, 1 >::II
 CR7::Dim< T, 2 >::II
 Cil_params
 CTMVA::IMethodInterface for all concrete MVA method implementations
 CROOT::Math::IMinimizer1DInterface class for numerical methods for one-dimensional minimization
 CParentFunctor::Impl
 CRooFit::Detail::JSONNode::child_iterator_t< Nd >::Impl
 CTJSONTree::Node::Impl
 CTRYMLTree::Impl
 CTRYMLTree::Node::Impl
 CRooFit::JSONIO::Importer
 CRooFit::JSONIO::ImportExpression
 CTMVA::Increment< T >
 Cbvh::v2::Index< Bits, PrimCountBits >Packed index data structure
 Cbvh::v2::Index< sizeof(T) *CHAR_BIT, 4 >
 CCPyCppyy::indexiterobject
 CIndexSortComparator
 CROOT::Detail::indices< Indices >
 CROOT::Math::rowOffsetsUtils::indices<... >
 CROOT::Detail::TStatusBitsChecker::Registry::Info
 CTFile::InfoListRetSimple struct of the return value of GetStreamerInfoListImpl
 CRooSimultaneous::InitializationOutputInternal struct used for initialization
 CTMVA::Experimental::SOFIE::InitializedTensor
 COuter::Inner
 Cbvh::v2::InputStreamStream of data that can be used to deserialize data structures
 CTMVA::Experimental::SOFIE::InputTensorInfo
 CTClass::InsertTClassInRegistryRAII
 CTEveParamList::IntConfig_t
 Cstd::integral_constant
 CROOT::Fit::FitUtil::IntegralEvaluator< ParamFunc >
 CROOT::Math::IntegratorMultiDimUser class for performing multidimensional integration
 CROOT::Math::IntegratorOneDimUser Class for performing numerical integration of a function in one dimension
 CROOT::Math::InterpolatorClass for performing function interpolation of points
 Ccling::InterpreterCallbacks
 CROOT::Internal::InterpreterMutexRegistrationRAII
 CTMVA::IntervalThe TMVA::Interval Class
 CRooStats::IntervalCalculatorIntervalCalculator is an interface class for a tools which produce RooStats ConfIntervals
 CTMVA::RuleFitAPI::IntParms
 CROOT::TreeUtils::InvalidTupleType< class >
 CROOT::TreeUtils::InvalidTupleType< TNtuple >
 CROOT::TreeUtils::InvalidTupleType< TNtupleD >
 CROOT::Math::Inverter< idim, n >Matrix Inverter class Class to specialize calls to Dinv
 CROOT::Math::Inverter< 0 >Inverter<0>
 CROOT::Math::Inverter< 1 >1x1 matrix inversion a111/a11
 CROOT::Math::Inverter< 2 >2x2 matrix inversion using Cramers rule
 CTMVA::Config::IONames
 CTTreeCache::IOPos
 CROOT::Math::IOptionsGeneric interface for defining configuration options of a numerical algorithm
 Cstd::ios_baseSTL class
 CIPFType
 CTMVA::IPruneToolIPruneTool - a helper interface class to prune a decision tree
 CTMVA::IPythonInteractiveThis class is needed by JsMVA, and it's a helper class for tracking errors during the training in Jupyter notebook
 CROOT::Math::IRootFinderMethodInterface for finding function roots of one-dimensional functions
 CROOT::Detail::is_array_class< Array >
 CROOT::Internal::RDF::IsDataContainer< T >Check for container traits
 CROOT::Internal::RDF::IsDataContainer< ROOT::VecOps::RVec< bool > >
 CROOT::option::PrintUsageImplementation::IStringWriter
 CROOT::Experimental::REveChunkManager::iterator
 CROOT::Math::KDTree< _DataPoint >::iterator
 CROOT::TSeq< T >::iterator
 CTEveChunkManager::iterator
 CTMVA::Experimental::RTensor< V, C >::Iterator
 CROOT::Experimental::TTreeReaderFast::Iterator_t
 CTTreeReader::Iterator_tIterate through the entries of a TTree
 CTTreeReaderArray< T >::Iterator_t< ReaderArrayType >Random access iterator to the elements of a TTreeReaderArray
 Cstd::iterator_traits
 CROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, large >Small helper to implement the function to create,access and destroy iterators
 CROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > >::Iterators
 CROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, true >
 CROOT::Detail::TCollectionProxyInfo::IteratorValue< Cont_t, value >Small helper to encapsulate whether to return the value pointed to by the iterator or its address
 CROOT::Detail::TCollectionProxyInfo::IteratorValue< Cont_t, value_ptr * >
 Ciu_params
 CRooFit::MultiProcess::JobInterface class for defining the actual work that must be done
 CRooFit::MultiProcess::JobManagerMain point of access for all MultiProcess infrastructure
 CRooFit::MultiProcess::JobTaskCombined job_object, state and task identifier type
 CRooFit::Detail::JSONNode
 CRooFit::Detail::JSONTree
 CJupyROOTExecutorHandler
 CROOT::Math::KahanSum< T, N >The Kahan summation is a compensated summation algorithm, which significantly reduces numerical errors when adding a sequence of finite-precision floating point numbers
 CROOT::Math::KahanSum< double >
 CTMVA::KDEKernelKDE Kernel for "smoothing" the PDFs
 CROOT::Math::KDTree< _DataPoint >
 CROOT::Meta::Selection::KeepFirstTemplateArguments< I >Used to specify the number of arguments to be kept
 CTKDE::KernelIntegrand
 CROOT::Experimental::Internal::ROnDiskPage::KeyOn-disk pages within a page source are identified by the column and page number
 CKeySymbolMap_t
 CkNNKNN::Event describes point in input variable vector-space, with additional functionality like distance between points
 CROOT::Minuit2::LASquareMatrix
 CROOT::Minuit2::LASymMatrixClass describing a symmetric matrix of size n
 CROOT::Minuit2::LAVector
 CTMVA::DNN::LayerLayer defines the layout of a layer
 CTMVA::DNN::LayerDataLayerData holds the data of one layer
 CLayoutChunk_t
 CTGFSComboBox::Lbc_t
 CTMVA::LDA
 CTLeaf::LeafCountValues
 CLikeFunction1
 CROOT::Fit::FitUtil::LikelihoodAux< T >
 CROOT::Fit::FitUtil::LikelihoodAux< double >
 CRooStats::LikelihoodFunction
 CRooFit::TestStatistics::LikelihoodGradientWrapperVirtual base class for implementation of likelihood gradient calculation strategies
 CRooFit::MultiProcess::Config::LikelihoodJob
 CRooFit::TestStatistics::LikelihoodWrapperVirtual base class for implementation of likelihood calculation strategies
 CTMath::Limits< T >
 CROOT::Experimental::REveStraightLineSet::Line_t
 CTEveStraightLineSet::Line_t
 CRgl::Pad::LineAttribSet
 CROOT::option::PrintUsageImplementation::LinePartIterator
 CROOT::option::PrintUsageImplementation::LineWrapper
 CLinkdefReader
 Cbvh::v2::MiniTreeBuilder< Node, MortonCode >::LocalBins
 CRooHelpers::LocalChangeMsgLevelSwitches the message service to a different level while the instance is alive
 CROOT::Math::LocalCoordinateSystemTagTag for identifying vectors based on a local coordinate system
 CROOT::Internal::UniqueLockRecurseCount::LocalCounts
 CTAtomicCount::LockGuard
 CROOT::Experimental::REveManager::Logger
 CTString::LongStr_t
 CRooFit::Experimental::CodegenContext::LoopScopeA class to manage loop scopes using the RAII technique
 CROOT::Math::LorentzRotationLorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix
 CROOT::Math::LorentzVector< CoordSystem >Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system for the spatial vector part
 CTMVA::LossFunction
 CTMVA::LossFunctionEventInfo
 CCPyCppyy::LowLevelView
 CLsTreeEntry_t
 CROOT::MacOSX::Details::MacOSXSystem
 CROOT::Detail::make_indices_impl< First, Step, N, class >
 CROOT::Math::rowOffsetsUtils::make_indices_impl< I, IndexTuple, N >
 CROOT::Math::rowOffsetsUtils::make_indices_impl< 0, indices<>, N >
 CROOT::Detail::make_indices_impl< First, 1,((Last - First)+(1 - 1))/1 >
 CROOT::Math::rowOffsetsUtils::make_indices_impl< I, indices< Indices... >, N >
 CROOT::Math::rowOffsetsUtils::make_indices_impl< N, indices< Indices... >, N >
 CROOT::Detail::make_indices_next< IndicesType, Next >
 CROOT::Detail::make_indices_next2< IndicesType, Next, Tail >
 CROOT::Detail::make_indices_next2< indices< Indices... >, Next, Tail >
 CROOT::Detail::make_indices_next2< ROOT::Detail::make_indices_impl< First, Step, N/2 >::type, First+N/2 *Step, First+(N - 1) *Step >
 CROOT::Detail::make_indices_next< indices< Indices... >, Next >
 CROOT::Detail::make_indices_next< ROOT::Detail::make_indices_impl< First, Step, N/2 >::type, First+N/2 *Step >
 CROOT::Math::detail::manipulator< char_t >
 Cstd::map< std::string, const void * >
 CROOT::Internal::TExecutor::MapRetType< F, CONTAINER >Helper class to get the correct return type from the Map function, necessary to infer the ResolveExecutorAndMap function type
 CROOT::Internal::TExecutor::MapRetType< F, unsigned >
 CROOT::Experimental::REveStraightLineSet::Marker_t
 CTEveStraightLineSet::Marker_t
 CMarkerDescription_t
 CRgl::Pad::MarkerPainter
 CROOT::RWebWindow::MasterConn
 Cmathtext::math_text_renderer_t
 CROOT::Math::MathMoreLib
 CROOT::Math::MatRepStd< T, D1, D2 >Expression wrapper class for Matrix objects
 CROOT::Math::MatRepStd< T, D1, D1 >
 CROOT::Math::MatRepSym< T, D >MatRepSym Matrix storage representation for a symmetric matrix of dimension NxN This class is a template on the contained type and on the symmetric matrix size, N
 CROOT::Minuit2::MatrixInverse< mtype, M, T >
 CROOT::Minuit2::MatrixInverse< vec, M, T >
 CROOT::Math::MatrixMulOp< MatrixA, MatrixB, T, D >Class for Matrix-Matrix multiplication
 Cmd5_state_s
 CTProof::MD5Mod_t
 CTMVA::DNN::MeanVariance
 CROOT::Meta::Selection::MemberAttributes< memberAttributes >Used to specify attributes of data members in the "DictSelection" syntax
 CROOT::Math::ParamMemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >::MemFuncEvaluator< PObj, F, T >
 CMemInfo_t
 CMemory_t
 CCPyCppyy::MemoryRegulator
 CRgl::Pad::MeshPatch_t
 CRooFit::MultiProcess::MessengerManages ZeroMQ sockets and wraps send and receive calls
 CROOT::Math::meta_col_dot< I >
 CROOT::Math::meta_col_dot< 0 >
 CROOT::Math::meta_dot< I >
 CROOT::Math::meta_dot< 0 >
 CROOT::Math::meta_mag< I >
 CROOT::Math::meta_mag< 0 >
 CROOT::Math::meta_matrix_dot< I >
 CROOT::Math::meta_matrix_dot< 0 >
 CROOT::Math::meta_row_dot< I >
 CROOT::Math::meta_row_dot< 0 >
 CTGenCollectionProxy::MethodSmall helper to execute (compiler) generated function for the access to STL or other containers
 CTGenCollectionProxy::Method0
 CTMVA::MethodCFMlpANN_UtilsImplementation of Clermond-Ferrand artificial neural network
 CCPyCppyy::CPPOverload::MethodInfo_t
 Cmg_callbacks
 Cmg_client_cert
 Cmg_client_options
 Cmg_connection
 Cmg_context
 Cmg_domain_context
 Cmg_error_data
 Cmg_file
 Cmg_file_access
 Cmg_file_stat
 Cmg_form_data_handler
 Cmg_handler_info
 Cmg_header
 Cmg_http_method_info
 Cmg_init_data
 Cmg_option
 Cmg_request_info
 Cmg_response_info
 Cmg_server_port
 Cmg_websocket_subprotocols
 Cmg_workerTLS
 CROOT::Math::MinimizerAbstract Minimizer class, defining the interface for the various minimizer (like Minuit2, Minuit, GSL, etc..) in ROOT
 CROOT::Math::MinimizerOptionsMinimizer options
 CROOT::Math::MinimizerVariableTransformationBase class for MinimizerVariable transformations defining the functions to deal with bounded parameters
 CROOT::Math::MinimTransformVariableMinimTransformVariable class Contains meta information of the variables such as bounds, fix flags and deals with transformation of the variable The class does not contain the values and the step size (error) of the variable This is an internal class used by the MinimTransformFunction class
 CROOT::Minuit2::MinimumBuilder
 CROOT::Minuit2::MinimumErrorMinimumError keeps the inv
 CROOT::Minuit2::MinimumErrorUpdator
 CROOT::Minuit2::MinimumParameters
 CROOT::Minuit2::MinimumSeed
 CROOT::Minuit2::MinimumSeedGeneratorBase class for seed generators (starting values); the seed generator prepares initial starting values from the input (MnUserParameterState) for the minimization;
 CROOT::Minuit2::MinimumStateMinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (usually in MinimumBuilder)
 Cbvh::v2::MiniTreeBuilder< Node, MortonCode >Multi-threaded top-down builder that partitions primitives using a grid
 CROOT::Math::MinOp< T >Subtraction Operation Class
 CROOT::Minuit2::MinosErrorClass holding the result of Minos (lower and upper values) for a specific parameter
 CROOT::Minuit2::MinuitParameterClass for the individual Minuit Parameter with Name and number; contains the input numbers for the minimization or the output result from minimization; possible interactions: Fix/release, set/remove limits, set Value/error;
 CROOT::Math::Minus< T >Unary Minus Operation Class
 CROOT::Math::MinusEquals< T, D1, D2, A, R1, R2 >Evaluate the expression performing a -= operation Need to check whether creating a temporary object with the expression result (like in op: A -= A * B )
 CROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >Specialization for symmetrix -= general : NOT Allowed operation
 CROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >Specialization for symmetric matrices
 CROOT::Experimental::REveManager::MIR
 CMIR_TL_Data_t
 CROOT::Math::MiserParametersStructure collecting parameters for MISER multidimensional integration
 CTTreeCache::MissCache
 CROOT::Math::MixMaxEngineImpl< N >
 CROOT::Math::MixMaxEngineImpl< ROOT_MM_N >
 CROOT::Minuit2::MnApplicationApplication interface class for minimizers (migrad, simplex, Minimize, Scan) User normally instantiates the derived class like ROOT::Minuit2::MnMigrad for using Migrad for minimization
 CROOT::Minuit2::MnContoursAPI class for Contours Error analysis (2-dim errors); minimization has to be done before and Minimum must be valid; possibility to ask only for the points or the points and associated Minos errors;
 CROOT::Minuit2::MnCovarianceSqueezeClass to reduce the covariance matrix when a parameter is fixed by removing the corresponding row and index
 CROOT::Minuit2::MnCross
 CROOT::Minuit2::MnEigenAPI class for calculating the eigenvalues of symmetric matrix
 CROOT::Minuit2::MnFcnWrapper class to FCNBase interface used internally by Minuit
 CROOT::Minuit2::MnFunctionCrossMnFunctionCross
 CROOT::Minuit2::MnGlobalCorrelationCoeffClass for global correlation coefficient
 CROOT::Minuit2::MnHesseAPI class for calculating the numerical covariance matrix (== 2x Inverse Hessian == 2x Inverse 2nd derivative); can be used by the user or Minuit itself
 CROOT::Minuit2::MnLineSearchImplements a 1-dimensional minimization along a given direction (i.e
 CROOT::Minuit2::MnMachinePrecisionSets the relative floating point (double) arithmetic precision
 CROOT::Minuit2::MnMinosAPI class for Minos Error analysis (asymmetric errors); minimization has to be done before and Minimum must be valid; possibility to ask only for one side of the Minos Error;
 CROOT::Minuit2::MnParabolaThis class defines a parabola of the form a*x*x + b*x + c
 CROOT::Minuit2::MnParabolaFactory
 CROOT::Minuit2::MnParabolaPointA point of a parabola
 CROOT::Minuit2::MnParameterScanScans the values of FCN as a function of one Parameter and retains the best function and Parameter values found
 CROOT::Minuit2::MnParStr
 CROOT::Minuit2::MnPlotMnPlot produces a text-screen graphical output of (x,y) points, e.g
 CROOT::Minuit2::MnPosDefForce the covariance matrix to be positive defined by adding extra terms in the diagonal
 CROOT::Minuit2::MnPrint
 CROOT::Minuit2::MnRefCountedPointer< T >
 CROOT::Minuit2::MnReferenceCounter
 CROOT::Minuit2::MnStrategyAPI class for defining four levels of strategies: low (0), medium (1), high (2), very high (>=3); acts on: Migrad (behavioural), Minos (lowers strategy by 1 for Minos-own minimization), Hesse (iterations), Numerical2PDerivative (iterations)
 CROOT::Minuit2::MnTiny
 CROOT::Minuit2::MnTraceObject
 CROOT::Minuit2::MnUserCovarianceClass containing the covariance matrix data represented as a vector of size n*(n+1)/2 Used to hide internal matrix representation to user
 CROOT::Minuit2::MnUserParametersAPI class for the user interaction with the parameters; serves as input to the minimizer as well as output from it; users can interact: Fix/release parameters, set values and errors, etc.; parameters can be accessed via their Parameter number (determined internally by Minuit and followed the order how the parameters are created) or via their user-specified Name (10 character string)
 CROOT::Minuit2::MnUserParameterStateClass which holds the external user and/or internal Minuit representation of the parameters and errors; transformation internal <-> external on demand;
 CROOT::Minuit2::MnUserTransformationClass dealing with the transformation between user specified parameters (external) and internal parameters used for minimization
 CROOT::Minuit2::MnVectorTransform
 CROOT::Minuit2::ModularFunctionMinimizerBase common class providing the API for all the minimizer Various Minimize methods are provided varying on the type of FCN function passesd and on the objects used for the parameters
 Csnt.Module
 Ctorch.nn.Module
 Cmodule_state
 Cclang::ModuleFileExtension
 Cclang::ModuleFileExtensionReader
 Cclang::ModuleFileExtensionWriter
 CTMVA::kNN::ModulekNN
 CTMVA::Monitoring
 CROOT::Minuit2::MPIProcess
 CROOT::Minuit2::MPITerminate
 CROOT::Math::MulOp< T >Multiplication (element-wise) Operation Class
 CMultiDistFree functions adapter needed by UNURAN for multidimensional cont distribution
 CROOT::Math::MultPolicy< T, R1, R2 >Matrix-matrix multiplication policy
 CTCling::MutexStateAndRecurseCount
 CTCling::MutexStateAndRecurseCountDelta
 CMWMHintsProperty_t
 CmyDetectorData
 CMyFunctor
 CMYSQL_BIND
 CMYSQL_STMT
 CNameCleanerForIOAn helper class to dismount the name and remount it changed whenever necessary
 CTGDMLWrite::NameLst
 CROOT::Experimental::RNTupleModel::NameWithDescription_tA wrapper over a field name and an optional description; used in AddField() and RUpdater::AddField()
 Cnan_value_t< Element >
 CTMVA::Experimental::SOFIE::NaryOperatorTraits< T, Op >
 CTMVA::Experimental::SOFIE::NaryOperatorTraits< float, EBasicNaryOperator::Mean >
 CTMVA::Experimental::SOFIE::NaryOperatorTraits< T, EBasicNaryOperator::Max >
 CTMVA::Experimental::SOFIE::NaryOperatorTraits< T, EBasicNaryOperator::Mean >
 CTMVA::Experimental::SOFIE::NaryOperatorTraits< T, EBasicNaryOperator::Min >
 CTMVA::Experimental::SOFIE::NaryOperatorTraits< T, EBasicNaryOperator::Sum >
 CROOT::Minuit2::NegativeG2LineSearchIn case that one of the components of the second derivative g2 calculated by the numerical Gradient calculator is negative, a 1dim line search in the direction of that component is done in order to find a better position where g2 is again positive
 CTMVA::DNN::NetNeural net
 CNewColorMapType
 CRooFit::TestStatistics::NLLFactory
 Cbvh::v2::Node< T, Dim, IndexBits, PrimCountBits >Binary BVH node, containing its bounds and an index into its children or the primitives it contains
 CTMVA::kNN::Node< T >This file contains binary tree and global function template that searches tree for k-nearest neigbors
 CTMVA::NodeNode for the BinarySearch or Decision Trees
 CTMVA::kNN::Node< TMVA::kNN::Event >
 CRooFit::NodeInfoA struct used by the Evaluator to store information on the RooAbsArgs in the computation graph
 CTStreamerInfoActions::NoFactorMarker< From >
 CROOT::Detail::RDF::ExtraArgsForDefine::None
 CTClassTable::NormalizeThenLock
 CRooStats::HistFactory::NormFactorConfiguration for an un- constrained overall systematic to scale sample normalisations
 C<NSApplicationDelegate>
 CNSEvent
 CNSObject
 CROOT::MacOSX::Util::NSScopeGuard< DerivedType >
 CROOT::MacOSX::Util::NSScopeGuard< ROOTApplicationDelegate >
 CROOT::MacOSX::Util::NSStrongReference< DerivedType >
 CROOT::MacOSX::Util::NSStrongReference< QuartzWindow >
 CNSView
 CNSWindow
 C<NSWindowDelegate>
 CRooStats::NuisanceParametersSamplerHelper class for ToyMCSampler
 CTMVA::null_t< F >
 CROOT::Math::NullTypeFunc1D
 CRooStats::NumberCountingPdfFactoryA factory for building PDFs and data for a number counting combination
 CParamHistFunc::NumBins
 CTStreamerInfoActions::GenericLooper::Numeric< From, To >
 CNumericalDerivatorOriginal version created on: Aug 14, 2013 Authors: L
 CROOT::Minuit2::NumericalDerivator
 CRooSimWSTool::ObjBuildConfig
 CROOT::Experimental::Internal::RDaosObject::ObjClassIdWrap around a daos_oclass_id_t
 Cobject
 CTClass::ObjectPtr
 CROOT::Fit::ObjFuncTrait< Func >
 CROOT::Fit::ObjFuncTrait< ROOT::Math::FitMethodFunction >
 CROOT::Fit::ObjFuncTrait< ROOT::Math::FitMethodGradFunction >
 CRooSimWSTool::ObjSplitRule
 CRooFit::Experimental::RooFuncWrapper::ObsInfo
 Cbvh::v2::Octant
 CTODBCStatement::ODBCBufferRec_t
 CRgl::Pad::OffScreenDevice
 CROOT::Minuit2::MnPrint::Oneline
 CTMVA::Experimental::SOFIE::RModelParser_ONNX::OperatorsMapImpl
 CROOT::option::OptionA parsed option from the command line together with its argument if it has one
 CTMVA::OptionMapClass to storage options for the differents methods
 CLinkdefReader::Options
 CROOT::Experimental::RFile::Options_tOptions for RFile construction
 CROOT::Math::IntegOptionsUtil::OptionTrait< OptionType >
 CROOT::Math::IntegOptionsUtil::OptionTrait< IntegratorMultiDimOptions >
 CROOT::Math::IntegOptionsUtil::OptionTrait< IntegratorOneDimOptions >
 CRooFit::MultiProcess::OrderedJobTask
 CROOT::Experimental::RPalette::OrdinalAndColorAn ordinal value and its associated color
 Cbvh::v2::OutputStreamStream of data that can be used to serialize data structures
 CRooStats::HistFactory::OverallSysConfiguration for a constrained overall systematic to scale sample normalisations
 COverloadedCall
 CROOT::Math::CholeskyDecompHelpers::PackedArrayAdapter< G >Adapter for packed arrays (to SMatrix indexing conventions)
 CPadRefresher
 CTWebCanvas::PadStatus
 Cstd::pair< double, double >
 CROOT::Detail::TCollectionProxyInfo::PairHolder< T, Q >
 CPaltFunction
 CROOT::Fit::FitUtil::ParamDerivFunc< GradFunc >
 CCPyCppyy::Parameter
 CROOT::Fit::ParameterSettingsClass, describing value, limits and step size of the parameters Provides functionality also to set/retrieve values, step sizes, limits and fix the parameters
 CROOT::Math::ParamFunctionBase< T >Class defining the signature for multi-dim parametric functions
 CROOT::Math::ParamFunctorTempl< T >Param Functor class for Multidimensional functions
 CROOT::option::ParserChecks argument vectors for validity and parses them into data structures that are easier to work with
 CROOT::Internal::ParsingStateRAIIRAII used to store Parser, Sema, Preprocessor state for recursive parsing
 CROOT::Internal::RDF::PassAsVecHelper< I, T, F >
 Cpasswd
 CPattern
 CPCREPriv_t
 CPgSQL_Stmt_t
 CPictureAttributes_t
 CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, R1, R2 >
 CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
 CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
 CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, R1, R2 >Structure to deal when a submatrix is placed in a matrix
 CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
 CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
 CROOT::Math::PlainParameters
 CROOT::Math::Impl::Plane3D< T >Class describing a geometrical plane in 3 dimensions
 CRooAbsData::PlotOpt
 CRooAbsReal::PlotOpt
 CTGLHistPainter::PlotOption_t
 CRgl::PlotTranslation
 CRooNumIntFactory::PluginInfo
 CROOT::Math::PlusEquals< T, D1, D2, A, R1, R2 >Evaluate the expression performing a += operation Need to check whether creating a temporary object with the expression result (like in op: A += A * B )
 CROOT::Math::PlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >Specialization for symmetrix += general : NOT Allowed operation
 CROOT::Math::PlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >Specialization for symmetric matrices Evaluate the expression performing a += operation for symmetric matrices Need to have a separate functions to avoid to modify two times the off-diagonal elements (i.e applying two times the expression) Need to check whether creating a temporary object with the expression result (like in op: A += A * B )
 CROOT::MacOSX::X11::Point
 CTColorGradient::Point
 CTProofDrawListOfGraphs::Point3D_t
 CTProofDrawListOfPolyMarkers3D::Point4D_t
 CPoint_tPoint structure (maps to the X11 XPoint structure)
 CROOT::Math::Polar2D< T >Class describing a polar 2D coordinate system based on r and phi Phi is restricted to be in the range [-PI,PI)
 CROOT::Math::Polar3D< T >Class describing a polar coordinate system based on r, theta and phi Phi is restricted to be in the range [-PI,PI)
 CROOT::Experimental::REvePolygonSetProjected::Polygon_t
 CTEvePolygonSetProjected::Polygon_t
 CRgl::Pad::PolygonStippleSet
 CROOT::Experimental::RFieldBase::RSchemaIteratorTemplate< IsConstT >::Position
 CROOT::Math::PositionVector2D< CoordSystem, Tag >Class describing a generic position vector (point) in 2 dimensions
 CROOT::Math::PositionVector3D< CoordSystem, Tag >Class describing a generic position vector (point) in 3 dimensions
 Cclang::PragmaHandler
 CROOT::Minuit2::PrefixStack< T >
 CRooStats::HistFactory::PreprocessFunction
 CROOT::Experimental::REveProjection::PreScaleEntry_t
 CTEveProjection::PreScaleEntry_t
 CROOT::option::PrintUsageImplementation
 CRooFit::Experimental::Prio< P >
 Cprocess_control_data
 CRooFit::MultiProcess::ProcessManagerFork processes for queue and workers
 CRooProdPdf::ProcessProductTermOutput
 CRooFit::MultiProcess::ProcessTimerCan be used to generate timings of multiple processes simultaneously and output logs
 CProcInfo_t
 CROOT::Experimental::REveDataProxyBuilderBase::Product
 CRooFit::JSONIO::Detail::Domains::ProductDomain
 CRooFit::JSONIO::Detail::Domains::ProductDomain::ProductDomainElement
 CRooStats::ProfileInspectorUtility class to plot conditional MLE of nuisance parameters vs
 CROOT::Browsable::RProvider::ProgressHandle
 CROOT::RDF::Experimental::ProgressHelperRDF progress helper
 CTGLSurfacePainter::Projection_t
 CROOT::Fit::ProxyListBox
 CRooAbsArg::ProxyListCache
 CCPyCppyy::proxyobject
 CTMVA::PruningInfo
 CROOT::Math::PtEtaPhiE4D< ScalarType >Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and E (or rho, phi, eta , T) The metric used is (-,-,-,+)
 CROOT::Math::PtEtaPhiM4D< ScalarType >Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used is (-,-,-,+)
 Cpthread_cond_t
 CROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > >::Iterators::PtrSize_t
 CROOT::Math::PxPyPzE4D< ScalarType >Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors stored as (Px, Py, Pz, E)
 CROOT::Math::PxPyPzM4D< ScalarType >Class describing a 4D coordinate system or momentum-energy vectors stored as (Px, Py, Pz, M)
 CCPyCppyy::PyCallable
 CCPyCppyy::PyCallArgs
 CCPyCppyy::Utility::PyError_t
 CTMVA::Internal::PyGILRAII
 CPyROOT::PyObjRefCounterA PyObject wrapper to track reference counting of external objects
 CCPyCppyy::Utility::PyOperators
 CCPyCppyy::PyResult
 CQuad
 CQuantizedColorType
 CROOT::Math::QuasiRandom< Engine >User class for MathMore random numbers template on the Engine type
 CROOT::Math::QuaternionRotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k)
 CRooFit::MultiProcess::Config::Queue
 CRooFit::MultiProcess::QueueKeeps a queue of tasks for workers and manages the queue process through its event loop
 CROOT::RWebWindow::QueueEntry
 CROOT::RWebWindow::QueueItem
 CTMVA::QuickMVAProbEstimator
 CQWidget
 CROOT::Internal::RDF::RActionBase
 CROOT::Detail::RDF::RActionImpl< Helper >Base class for action helpers, see RInterface::Book() for more information
 CROOT::Detail::RDF::RActionImpl< ProgressBarAction >
 CROOT::Detail::RDF::RActionImpl< RooAbsDataHelper< DataSet_t > >
 CROOT::Experimental::Internal::RPageSource::RActivePhysicalColumnsKeeps track of the requested physical column IDs and their in-memory target type via a column element identifier
 CROOT::Experimental::Internal::RDaosObject::RAkeyRequestContains an attribute key and the associated IOVs for a single scatter-gather I/O request
 CROOT::Math::Random< Engine >Documentation for the Random class
 CROOT::Math::RandomFunctions< Engine, EngineBaseType >
 CROOT::Math::RandomFunctions< EngineType, DefaultEngineType >
 CROOT::Math::RandomFunctionsImpl< EngineBaseType >Definition of the generic implementation class for the RandomFunctions
 CROOT::Math::RandomFunctionsImpl< DefaultEngineType >
 CROOT::Math::RandomFunctionsImpl< TRandomEngine >Implementation class for the RandomFunction for all the engined that derives from TRandomEngine class, which defines an interface which has TRandomEngine::Rndm() In this way we can have a common implementation for the RandomFunctions
 CTMVA::RandomGenerator< TRandomLike, UIntType, max_val >
 CTMVA::Rank
 CTMVA::RankingRanking for variables in method (implementation)
 CROOT::Math::RanluxppCompatEngineLuescherImpl< w, p >
 CROOT::Math::RanluxppEngineImpl< w, p, u >
 CROOT::Math::RanluxppEngineImpl< w, p >
 CROOT::Experimental::RAttrBaseBase class for all attributes, used with RDrawable
 CTMVA::Experimental::SOFIE::RAttributes_Pool
 CROOT::Experimental::RAttrMap
 CTString::RawStr_t
 CROOT::Experimental::RAxisBaseHistogram axis base class
 CROOT::Experimental::RAxisConfigObjects used to configure the different axis types
 Cbvh::v2::Ray< T, N >
 CROOT::Internal::RBaseType< T >
 CTMVA::Experimental::Internal::RBatchGenerator< Args >
 CTMVA::Experimental::Internal::RBatchLoader
 CRbcClassThis file contains the code for cuda computations using the RooBatchCompute library
 CTMVA::Experimental::RBDT
 CROOT::Experimental::RHistDataMomentUncert< DIMENSIONS, PRECISION >::RBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::RHistStatContent< DIMENSIONS, PRECISION >::RBinStatModifying view on a RHistStatContent for a given bin
 CROOT::Experimental::RHistStatRuntime< DIMENSIONS, PRECISION >::RBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::RHistStatTotalSumOfSquaredWeights< DIMENSIONS, PRECISION >::RBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::RHistStatTotalSumOfWeights< DIMENSIONS, PRECISION >::RBinStatNo-op; this class does not provide per-bin statistics
 CROOT::Experimental::RHistStatUncertainty< DIMENSIONS, PRECISION >::RBinStatModifying view on a RHistStatUncertainty for a given bin
 CROOT::Internal::RRawFile::RBlockBuffer
 CROOT::RTreeViewer::RBranchInfo
 CROOT::RBrowserWeb-based ROOT files and objects browser
 CROOT::RBrowserDataWay to browse (hopefully) everything in ROOT
 CROOT::RBrowserReplyReply on browser request
 CROOT::RBrowserRequestRequest send from client to get content of path element
 CROOT::RBrowserWidgetAbstract Web-based widget, which can be used in the RBrowser Used to embed canvas, geometry viewer and potentially any other widgets
 CROOT::RBrowserWidgetProvider
 CROOT::Experimental::RFieldBase::RBulkSimilar to RValue but manages an array of consecutive values
 CROOT::Experimental::RFieldBase::RBulkSpec
 CRByteSwap< N >Helper templated class for swapping bytes; specializations for N={2,4,8} are provided below
 CRByteSwap< 2 >
 CRByteSwap< 4 >
 CRByteSwap< 8 >
 CROOT::Internal::RDF::RCallback
 CROOT::Detail::RDF::RCallCleanUpTaskA RAII object that calls RLoopManager::CleanUpTask at destruction
 CROOT::Experimental::RFieldBase::RCheckResultUsed in the return value of the Check() method
 CTMVA::Experimental::Internal::RChunkLoader< Args >
 CTMVA::Experimental::Internal::RChunkLoaderFilters< Args >
 CTMVA::Experimental::Internal::RChunkLoaderFunctor< ColTypes >
 CTMVA::Experimental::Internal::RChunkLoaderFunctorFilters< ColTypes >
 CROOT::Experimental::Internal::RClusterAn in-memory subset of the packed and compressed pages of a cluster
 CROOT::Experimental::RClusterDescriptorMeta-data for a set of ntuple clusters
 CROOT::Experimental::Internal::RClusterDescriptorBuilderA helper class for piece-wise construction of an RClusterDescriptor
 CROOT::Experimental::RNTupleDescriptor::RClusterDescriptorIterableUsed to loop over all the clusters of an ntuple (in unspecified order)
 CROOT::Experimental::Internal::RNTupleSerializer::RClusterGroup
 CROOT::Experimental::RClusterGroupDescriptorClusters are bundled in cluster groups
 CROOT::Experimental::Internal::RClusterGroupDescriptorBuilderA helper class for piece-wise construction of an RClusterGroupDescriptor
 CROOT::Experimental::RNTupleDescriptor::RClusterGroupDescriptorIterableUsed to loop over all the cluster groups of an ntuple (in unspecified order)
 CROOT::Experimental::Internal::RPage::RClusterInfoStores information about the cluster in which this page resides
 CROOT::Experimental::Internal::RPageSource::RClusterInfoSummarizes cluster-level information that are necessary to load a certain page
 CROOT::Experimental::Internal::RClusterPoolManaged a set of clusters containing compressed and packed pages
 CROOT::Experimental::Internal::RNTupleSerializer::RClusterSummary
 CROOT::Experimental::RProxiedCollectionField::RCollectionIterableOnceAllows for iterating over the elements of a proxied collection
 CROOT::Experimental::RColorThe color class
 CROOT::Experimental::Internal::RColumnA column is a storage-backed array of a simple, fixed-size type, from which pages can be mapped into memory
 CROOT::Experimental::Internal::RPageSinkBuf::RColumnBufA buffered column
 CROOT::Experimental::RColumnDescriptorMeta-data stored for every column of an ntuple
 CROOT::Experimental::Internal::RColumnDescriptorBuilderA helper class for piece-wise construction of an RColumnDescriptor
 CROOT::Experimental::RNTupleDescriptor::RColumnDescriptorIterableUsed to loop over a field's associated columns
 CROOT::Experimental::Internal::RColumnElementBaseA column element encapsulates the translation between basic C++ types and their column representation
 CROOT::Experimental::Internal::RPageStorage::RColumnHandle
 CROOT::Experimental::Internal::RColumnIndexThe in-memory representation of a 32bit or 64bit on-disk index column
 CROOT::Experimental::Internal::RPageSink::RStagedCluster::RColumnInfo
 CROOT::Experimental::Internal::RPageSource::RActivePhysicalColumns::RColumnInfo
 CROOT::Experimental::Internal::RWritePageMemoryManager::RColumnInfo
 CROOT::Experimental::RNTupleInspector::RColumnInspectorProvides column-level storage information
 CROOT::Experimental::Internal::RColumnMergeInfo
 CROOT::Experimental::RClusterDescriptor::RColumnRangeThe window of element indexes of a particular column in a particular cluster
 CROOT::Experimental::RClusterDescriptor::RColumnRangeIterable
 CROOT::Detail::RDF::RColumnReaderBase
 CRColumnReaderBasePure virtual base class for all column reader types
 CROOT::Internal::RDF::RColumnReadersInfoThis type aggregates some of the arguments passed to GetColumnReaders
 CROOT::Internal::RDF::RColumnRegisterA binder for user-defined columns, variations and aliases
 CROOT::Experimental::RFieldBase::RColumnRepresentationsSome fields have multiple possible column representations, e.g
 CROOT::Experimental::Internal::RColumnSwitchHolds the index and the tag of a kSwitch column
 CROOT::Experimental::Internal::RNTupleJoinTable::RCombinedJoinFieldValueContainer for the hashes of the join fields
 CROOT::Experimental::Internal::RNTupleJoinTable::RCombinedJoinFieldValueHashHash combining the individual join field value hashes from RCombinedJoinFieldValue
 CROOT::Experimental::RFitPanelModel::RComboBoxItemGeneric item for ui5 ComboBox
 CROOT::RCompressionSettingThe global settings depend on a global variable named R__ZipMode which can be modified by a global function named R__SetZipMode
 CROOT::Experimental::Internal::RComputeGlobalBin< I, NDIMS, BINS, AXES >Recursively gets the total number of regular bins before the current dimension, when computing a global bin that is in under- or overflow in at least one dimension
 CROOT::Experimental::Internal::RComputeGlobalBin<-1, NDIMS, BINS, AXES >
 CROOT::Experimental::Internal::RComputeGlobalBinRaw< I, NDIMS, BINS, AXES, BINTYPE >Recursively computes a zero-based global bin index, given..
 CROOT::Experimental::Internal::RComputeGlobalBinRaw<-1, NDIMS, BINS, AXES, BINTYPE >
 CROOT::Experimental::Internal::RComputeLocalBins< I, NDIMS, AXES >Recursively computes the number of regular bins before the current dimension, as well as the number of under- and overflow bins left to account for, after the current dimension
 CROOT::Experimental::Internal::RComputeLocalBins< 0, NDIMS, AXES >
 CROOT::Experimental::Internal::RComputeLocalBinsInitialisation< I, NDIMS, AXES >Recursively compute some quantities needed for ComputeLocalBins, namely the total number of bins per hyperplane (overflow and regular) and the number of regular bins per hyperplane on the hyperplanes that have them
 CROOT::Experimental::Internal::RComputeLocalBinsInitialisation< 0, NDIMS, AXES >
 CROOT::Experimental::Internal::RComputeLocalBinsRaw< I, NDIMS, BINS, AXES, BINTYPE >Recursively computes zero-based local bin indices, given..
 CROOT::Experimental::Internal::RComputeLocalBinsRaw<-1, NDIMS, BINS, AXES, BINTYPE >
 CROOT::Internal::RConcurrentHashCollThis class is a thread-safe associative collection connecting a 256 bits digest/hash to a collection of uid (integer) This is used in the handling of the StreamerInfo record in TFile
 CROOT::RTreeViewer::RConfig
 CROOT::Experimental::RHistStatContent< DIMENSIONS, PRECISION >::RConstBinStatConst view on a RHistStatContent for a given bin
 CROOT::Experimental::RHistStatUncertainty< DIMENSIONS, PRECISION >::RConstBinStatConst view on a RHistStatUncertainty for a given bin
 CROOT::TMetaUtils::RConstructorType
 CROOT::Experimental::Internal::RNTupleSerializer::RContextThe serialization context is used for the piecewise serialization of a descriptor
 CROOT::Experimental::Internal::RPagePersistentSink::RCountersDefault I/O performance counters that get registered in fMetrics
 CROOT::Experimental::Internal::RPageSinkBuf::RCountersI/O performance counters that get registered in fMetrics
 CROOT::Experimental::Internal::RPageSource::RCountersDefault I/O performance counters that get registered in fMetrics
 CROOT::Experimental::RCreateFieldOptions
 CROOT::Experimental::RNTupleDescriptor::RCreateModelOptionsModifiers passed to CreateModel
 CROOT::Experimental::RFieldBase::RCreateObjectDeleter< T >
 CROOT::Experimental::RFieldBase::RCreateObjectDeleter< void >
 CROOT::RDF::RCutFlowReport
 CROOT::Experimental::Internal::RDaosContainerA RDaosContainer provides read/write access to objects in a given container
 CROOT::Experimental::Internal::RDaosEventQueue
 CROOT::Experimental::Internal::RDaosNTupleAnchorEntry point for an RNTuple in a DAOS container
 CROOT::Experimental::Internal::RDaosObjectProvides low-level access to DAOS objects in a container
 CROOT::Experimental::Internal::RDaosPoolA RDaosPool provides access to containers in a specific DAOS pool
 CROOT::RDF::Experimental::RDatasetSpecThe dataset specification for RDataFrame
 CROOT::RDF::RDataSourceRDataSource defines an API that RDataFrame can use to read arbitrary data formats
 CROOT::Internal::RDavixFileDes
 CROOT::Detail::RDF::RDefineBase
 CROOT::Internal::RDF::RDefinesWithReadersA helper type that keeps track of RDefine objects and their corresponding RDefineReaders
 CROOT::Experimental::RFieldBase::RDeleterA functor to release the memory acquired by CreateValue (memory and constructor)
 CROOT::RDF::RDFDescriptionA DFDescription contains useful information about a given RDataFrame computation graph
 CROOT::Experimental::RDirectoryKey/value store of objects
 CROOT::Experimental::Internal::RDirectoryEntry
 CROOT::RDF::RDisplayThis class is the textual representation of the content of a columnar dataset
 CROOT::Experimental::RDrawable::RDisplayContext
 CROOT::Internal::RDF::RDisplayElementHelper class to let Display print compact tabular representations of the events
 CROOT::Experimental::RDisplayItemBase class for painting data for JS
 CROOT::Experimental::RDrawableBase class for drawable entities: objects that can be painted on a RPad
 CROOT::Experimental::RDrawableReplyBase class for replies on RDrawableRequest
 CROOT::Experimental::RDrawableRequestBase class for requests which can be submitted from the clients
 Cread_auth_file_struct
 CReadSpeed::ReadSpeedRegex
 CTStreamerInfoActions::CollectionLooper< Looper >::ReadStreamerLoop< kIsTextT, Ts >
 CTFormLeafInfo::ReadValueHelper< T >
 CTFormLeafInfo::ReadValueHelper< Long64_t >
 CTFormLeafInfo::ReadValueHelper< LongDouble_t >
 CTFormLeafInfo::ReadValueHelper< ULong64_t >
 CRealInfo_t
 CTTreeFormula::RealInstanceCache
 CTMVA::RuleFitAPI::RealParms
 CRooVectorDataStore::RealVector
 CROOT::Experimental::REveCaloData::RebinData_t
 CTEveCaloData::RebinData_t
 CROOT::Experimental::RAttrBase::Rec_t
 CROOT::Experimental::REveSelection::Record
 CROOT::MacOSX::X11::Rectangle
 CRectangle_tRectangle structure (maps to the X11 XRectangle structure)
 CROOT::Internal::RecurseCounts
 Cclang::RecursiveASTVisitor
 CR6::Redirect< ndim, T >
 CR6::Redirect< 1, double >
 CR6::Redirect< 1, float >
 CR6::Redirect< 2, double >
 CR6::Redirect< 2, float >
 CRedirectHandle_t
 CRooBatchCompute::ReduceNLLOutput
 CROOT::ExecutorUtils::ReduceObjects< T >Merge collection of TObjects
 CRooAbsReal::RefA RooAbsReal::Ref can be constructed from a RooAbsReal& or a double that will be implicitly converted to a RooConstVar&
 CROOT::Detail::TStatusBitsChecker::Registry
 CTMVA::RegressionVarianceCalculate the "SeparationGain" for Regression analysis separation criteria used in various training algorithms
 Cbvh::v2::ReinsertionOptimizer< Node >::Reinsertion
 Cbvh::v2::ReinsertionOptimizer< Node >
 CROOT::Browsable::RElementBasic element of browsable hierarchy
 CROOT::TypeTraits::RemoveFirst< T, Rest >
 CROOT::TypeTraits::RemoveFirstParameter< typename >Remove first of possibly many template parameters
 CROOT::TypeTraits::RemoveFirstParameter< U< T, Rest... > >
 CROOT::Internal::RDF::RemoveFirstParameterIf< MustRemove, TypeList >type is TypeList if MustRemove is false, otherwise it is a TypeList with the first type removed
 CROOT::Internal::RDF::RemoveFirstParameterIf< true, TypeList >
 CROOT::Internal::RDF::RemoveFirstTwoParametersIf< MustRemove, TypeList >
 CROOT::Internal::RDF::RemoveFirstTwoParametersIf< true, TypeList >
 CROOT::Experimental::Internal::RPagePool::REntryEvery page in the page pool is annotated with a search key and a reference counter
 CROOT::Experimental::REntryThe REntry is a collection of values in an ntuple corresponding to a complete row in the data set
 CROOT::Experimental::Internal::RPageSource::REntryRangeUsed in SetEntryRange / GetEntryRange
 CROOT::RDF::Experimental::RDatasetSpec::REntryRange
 CROOT::Experimental::RNTupleDS::REntryRangeDSThe PrepareNextRanges() method populates the fNextRanges list with REntryRangeDS records
 CROOT::Experimental::Internal::RNTupleSerializer::REnvelopeLink
 CTString::Rep_t
 CROOT::RErrorCaptures diagnostics related to a ROOT runtime error
 CXrdCl::ResponseHandler
 CReadSpeed::Result
 CROOT::Internal::ExecutorUtils::ResultCaster< O, F >
 CROOT::Internal::ExecutorUtils::ResultCaster< TObject *, F >
 CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, R1, R2 >Structure for getting sub matrices We have different cases according to the matrix representations
 CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
 CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
 CREve3DProjection3D scaling projection
 CROOT::Experimental::REveAunt
 CREveBox3D box with arbitrary vertices (cuboid)
 CREveBoxProjectedProjection of REveBox
 CREveBoxSetCollection of 3D primitives (fixed-size boxes, boxes of different sizes, or arbitrary sexto-epipeds, cones)
 CREveCalo2DVisualization of a calorimeter event data in 2D
 CREveCalo3DVisualization of a calorimeter event data in 3D
 CREveCaloDataA central manager for calorimeter event data
 CREveCaloDataHistA central manager for calorimeter data of an event written in TH2F
 CROOT::Experimental::REveCaloDataSelector
 CROOT::Experimental::REveCaloDataSliceSelector
 CREveCaloDataVecCalo data for universal cell geometry
 CREveCaloLegoVisualization of calorimeter data as eta/phi histogram
 CREveCaloVizBase class for calorimeter data visualization
 CREveChunkManagerVector-like container with chunked memory allocation
 CROOT::Experimental::REveChunkManager
 CROOT::Experimental::REveClient
 CROOT::Experimental::REveClusterREveCluster Reconstructed cluster (also used in VSD)
 CREveCompoundDescription of REveCompound
 CREveCompoundProjectedDescription of REveCompoundProjected
 CROOT::Experimental::REveDataItem
 CROOT::Experimental::REveDataProxyBuilderBase
 CREveDigitSetBase-class for storage of digit collections; provides transformation matrix (REveTrans), signal to color mapping (REveRGBAPalette) and visual grouping (REveFrameBox)
 CREveElementBase class for REveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management
 CROOT::Experimental::REveElement
 CREveExceptionException class thrown by Eve classes and macros
 CREveFrameBoxDescription of a 2D or 3D frame that can be used to visually group a set of objects
 CREveGeoManagerHolderException safe wrapper for setting gGeoManager
 CROOT::Experimental::REveGeoManagerHolderREveGeoManagerHolder Exception-safe global variable holders
 CREveGeoPolyShapeDescription of REveGeoPolyShape
 CREveGeoShapeWrapper for TGeoShape with absolute positioning and color attributes allowing display of extracted TGeoShape's (without an active TGeoManager) and simplified geometries (needed for non-linear projections)
 CREveGeoShapeExtractGlobally positioned TGeoShape with rendering attributes and an optional list of daughter shape-extracts
 CREveGeoShapeProjectedA 3D projected REveGeoShape
 CROOT::Experimental::REveHitREveHit Monte Carlo hit (also used in VSD)
 CREveJetConeDraws a jet cone with leading particle is specified in (eta,phi) and cone radius is given
 CREveJetConeProjectedProjection of REveJetCone
 CREveLineAn arbitrary polyline with fixed line and marker attributes
 CREveLineProjectedProjected copy of a REveLine
 CREveMagFieldAbstract base-class for interfacing to magnetic field needed by the REveTrackPropagator
 CROOT::Experimental::REveMagFieldREveMagField Abstract interface to magnetic field
 CREveMagFieldConstImplements constant magnetic field, given by a vector fB
 CREveMagFieldDuoImplements constant magnetic filed that switches on given axial radius fR2 from vector fBIn to fBOut
 CREveManagerCentral application manager for web-based REve
 CROOT::Experimental::REveManager
 CROOT::Experimental::REveMCRecCrossRefREveMCRecCrossRef Cross-reference of sim/rec data per particle (also used in VSD)
 CROOT::Experimental::REvePathMarkT< TT >Special-point on track:
 CREvePointSelectorREvePointSelector is a sub-class of TSelectorDraw for direct extraction of point-like data from a Tree
 CREvePointSelectorConsumerREvePointSelectorConsumer is a virtual base for classes that can be filled from TTree data via the REvePointSelector class
 CROOT::Experimental::REvePointSelectorConsumer
 CREvePointSetREvePointSet is a render-element holding a collection of 3D points with optional per-point TRef and an arbitrary number of integer ids (to be used for signal, volume-id, track-id, etc)
 CREvePointSetArrayAn array of point-sets with each point-set playing a role of a bin in a histogram
 CREvePointSetProjectedProjected copy of a REvePointSet
 CREvePolygonSetProjectedA set of projected polygons
 CREveProjectableAbstract base-class for non-linear projectable objects
 CROOT::Experimental::REveProjectable
 CREveProjectedAbstract base class for classes that hold results of a non-linear projection transformation
 CROOT::Experimental::REveProjected
 CREveProjectionBase-class for non-linear projections
 CROOT::Experimental::REveProjectionREveProjection Base for specific classes that implement non-linear projections
 CREveProjectionManagerManager class for steering of projections and managing projected objects
 CROOT::Experimental::REveRecCascadeREveRecCascade
 CROOT::Experimental::REveRecKinkREveRecKink Reconstructed kink (also used in VSD)
 CROOT::Experimental::REveRecTrackT< TT >REveRecTrack Template for reconstructed track (also used in VSD)
 CROOT::Experimental::REveRecTrackT< Float_t >
 CROOT::Experimental::REveRecV0REveRecV0
 CREveRefBackPtrBase-class for reference-counted objects with reverse references to REveElement objects
 CREveRefCntBase-class for reference-counted objects
 CROOT::Experimental::REveRefCntREveRefCnt REveRefCnt base-class (interface)
 CROOT::Experimental::REveRenderData
 CREveRGBAPaletteA generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes
 CREveRhoZProjectionTransformation from 3D to 2D
 CREveRPhiProjectionXY projection with distortion around given center
 CREveScalableStraightLineSetStraight-line-set with extra scaling, useful for projectables that need to be scaled in accordance with an external object
 CREveSceneEve representation of TGLScene
 CREveSceneInfoRepresentation of a REveScene in a REveViewer
 CREveSceneListList of Scenes providing common operations on REveScene collections
 CREveSecondarySelectableSemi-abstract interface for classes supporting secondary-selection
 CROOT::Experimental::REveSecondarySelectable
 CREveSelectionMake sure there is a SINGLE running REveSelection for each selection type (select/highlight)
 CREveSelectorToEventListTSelector that stores entry numbers of matching TTree entries into an event-list
 CROOT::Experimental::REveServerStatus
 CREveShapeAbstract base-class for 2D/3D shapes
 CREveStraightLineSetProjectedProjected replica of a REveStraightLineSet
 CROOT::Experimental::REveTableEntryREveTableEntry
 CROOT::Experimental::REveTableHandleREveTableHandle
 CREveTrackVisual representation of a track
 CREveTrackListA list of tracks supporting change of common attributes and selection based on track parameters
 CREveTrackListProjectedSpecialization of REveTrackList for holding REveTrackProjected objects
 CREveTrackProjectedProjected copy of a REveTrack
 CREveTrackPropagatorHolding structure for a number of track rendering parameters
 CREveTransREveTrans is a 4x4 transformation matrix for homogeneous coordinates stored internally in a column-major order to allow direct usage by GL
 CREveUtilStandard utility functions for Eve
 CROOT::Experimental::REveUtilREveUtil Standard utility functions for Reve
 CROOT::Experimental::REveVector2T< TT >REveVector2T A two-vector template without TObject inheritance and virtual functions
 CROOT::Experimental::REveVectorT< TT >REveVectorT A three-vector template without TObject inheritance and virtual functions
 CROOT::Experimental::REveVectorT< Double_t >
 CROOT::Experimental::REveVectorT< Float_t >
 CROOT::Experimental::REveViewContext
 CREveViewerEve representation of a GL view
 CREveViewerListList of Viewers providing common operations on REveViewer collections
 CREveVSDVisualization Summary Data - a collection of trees holding standard event data in experiment independent format
 CREveXZProjectionXZ projection with distortion around given center
 CREveYZProjectionYZ projection with distortion around given center
 CREveZXProjectionZX projection with distortion around given center
 CREveZYProjectionZY projection with distortion around given center
 CRExceptionHandlerException handler for Eve exceptions
 CROOT::Experimental::Internal::RPageSource::RExclDescriptorGuardAn RAII wrapper used for the writable access to RPageSource::fDescriptor. See GetSharedDescriptorGuard()
 CROOT::Experimental::RExtraTypeInfoDescriptorField specific extra type information from the header / extenstion header
 CROOT::Experimental::Internal::RExtraTypeInfoDescriptorBuilderA helper class for piece-wise construction of an RExtraTypeInfoDescriptor
 CROOT::Experimental::RNTupleDescriptor::RExtraTypeInfoDescriptorIterableUsed to loop over all the extra type info record of an ntuple (in unspecified order)
 CROOT::Experimental::Internal::RPagePersistentSink::RFeaturesSet of optional features supported by the persistent sink
 CROOT::Experimental::RFieldBaseA field translates read and write calls from/to underlying columns to/from tree values
 CROOT::Experimental::RNTupleProcessor::RFieldContextManager for a field as part of the RNTupleProcessor
 CROOT::Experimental::RFieldDescriptorMeta-data stored for every field of an ntuple
 CROOT::Experimental::Internal::RFieldDescriptorBuilderA helper class for piece-wise construction of an RFieldDescriptor
 CROOT::Experimental::RNTupleDescriptor::RFieldDescriptorIterableUsed to loop over a field's child fields
 CROOT::Experimental::RNTupleDS::RFieldInfoHolds useful information about fields added to the RNTupleDS
 CROOT::Experimental::Internal::RFieldRepresentationModifier
 CROOT::Experimental::REntry::RFieldTokenThe field token identifies a (sub)field in this entry
 CROOT::Experimental::RNTupleInspector::RFieldTreeInspectorProvides field-level storage information
 CROOT::Experimental::Detail::RFieldVisitorAbstract base class for classes implementing the visitor design pattern
 CROOT::RFileDialogWeb-based FileDialog
 CROOT::Experimental::Internal::RNTupleFileWriter::RFileProper
 CROOT::Experimental::RFilePtrPoints to an object that stores or reads objects in ROOT's binary format
 CROOT::Experimental::Internal::RNTupleFileWriter::RFileSimple
 CROOT::Experimental::Internal::RFileStorageInterfaceBase class for RFile storage backends
 CROOT::Experimental::Internal::RFillIterRange< I, AXES >Recursively fills the ranges of all axes, excluding under- and overflow
 CROOT::Experimental::Internal::RFillIterRange<-1, AXES >
 CROOT::Experimental::Internal::RNTupleExporter::RFilter< T >
 CROOT::Experimental::Internal::RNTupleExporter::RFilter< ROOT::ENTupleColumnType >
 CROOT::Experimental::Internal::RFindLocalBins< I, NDIMS, BINS, COORD, AXES >Find the per-axis local bin indices associated with a certain set of coordinates
 CROOT::Experimental::Internal::RFindLocalBins<-1, NDIMS, BINS, COORD, AXES >
 CRFitPanelWeb-based FitPanel prototype
 CROOT::Experimental::RFitPanel
 CROOT::Experimental::RFitPanelModelData structure for the fit panel
 CROOT::Experimental::RFitResult
 CROOT::TreeUtils::RFriendInfoInformation about friend trees of a certain TTree or TChain object
 CROOT::Experimental::RFitPanelModel::RFuncParFunction parameter info, used in edit parameters dialog
 CROOT::Experimental::RFitPanelModel::RFuncParsListClass used to transfer functions parameters list from/to client
 CROOT::Experimental::RFunction< DIMENSION >
 CTMVA::Experimental::SOFIE::RFunction
 CROOT::MacOSX::X11::ColorParser::RGB_t
 CROOT::RGeomBrowserIterIterator of hierarchical geometry structures
 CROOT::RGeomConfigConfiguration parameters which can be configured on the client Send as is to-from client
 CROOT::RGeomDescription
 CROOT::RGeomDrawingObject with full description for drawing geometry It includes list of visible items and list of nodes required to build them
 CROOT::RGeomHierarchyWeb-based ROOT geometry hierarchy viewer
 CROOT::RGeomNodeBaseBase description of geometry node, required only to build hierarchy
 CROOT::RGeomNodeInfoNode information including rendering data
 CROOT::RGeomNodeVisibilityCustom settings for physical Node visibility
 CROOT::RGeomRenderInfoBase class for render info block
 CROOT::RGeomViewerWeb-based ROOT geometry viewer
 CROOT::RGeomVisibleRGeomVisible contains description of visible node It is path to the node plus reference to shape rendering data
 CROOT::Experimental::Internal::RGetNBinsCount< I, AXES >Recursively gets the total number of bins in whole hist, including under- and overflow
 CROOT::Experimental::Internal::RGetNBinsCount< 0, AXES >
 CROOT::Experimental::Internal::RGetNBinsNoOverCount< I, AXES >Recursively gets the total number of bins in whole hist, excluding under- and overflow
 CROOT::Experimental::Internal::RGetNBinsNoOverCount< 0, AXES >
 CROOT::Experimental::Internal::RGetNRegularBinsBefore< I, NDIMS, BINS, AXES >Recursively gets the number of regular bins just before the current dimension
 CROOT::Experimental::Internal::RGetNRegularBinsBefore<-1, NDIMS, BINS, AXES >
 CROOT::Internal::RHashMap
 CROOT::Experimental::RNTupleDescriptor::RHeaderExtensionSummarizes information about fields and the corresponding columns that were added after the header has been serialized
 CROOT::Experimental::RHist< DIMENSIONS, PRECISION, STAT >Histogram class for histograms with DIMENSIONS dimensions, where each bin count is stored by a value of type PRECISION
 CROOT::Experimental::RHist< DIMENSIONS, PRECISION, RHistStatContent >
 CROOT::Experimental::Detail::RHistBinPtr< HISTIMPL >Points to a histogram bin (or actually a RHistBinRef)
 CROOT::Experimental::Detail::RHistBinRef< HISTIMPL >Represents a bin reference
 CROOT::Experimental::Internal::RHistBufferedFillBase< DERIVED, HIST, SIZE >
 CROOT::Experimental::Internal::RHistBufferedFillBase< RHistBufferedFill< HIST, 1024 >, HIST, 1024 >
 CROOT::Experimental::Internal::RHistBufferedFillBase< RHistConcurrentFiller< HIST, SIZE >, HIST, SIZE >
 CROOT::Experimental::RHistConcurrentFillManager< HIST, SIZE >Manages the synchronization of calls to FillN()
 CROOT::Experimental::RHistConcurrentFillManager< HIST, SIZE >
 CROOT::Experimental::RHistDataMomentUncert< DIMENSIONS, PRECISION >For now do as RH1: calculate first (xw) and second (x^2w) moment
 CROOT::Experimental::Internal::RHistImplGen< NDIM, IDIM, DATA, PROCESSEDAXISCONFIG >Generate RHist::fImpl from RHist constructor arguments
 CROOT::Experimental::Internal::RHistImplGen< NDIM, NDIM, DATA, PROCESSEDAXISCONFIG... >Generate RHist::fImpl from constructor arguments; recursion end
 CROOT::Experimental::Detail::RHistImplPrecisionAgnosticBase< DIMENSIONS >Base class for RHistImplBase that abstracts out the histogram's PRECISION
 CROOT::Experimental::Detail::RHistImplPrecisionAgnosticBase< DATA::GetNDim()>
 CROOT::Experimental::RHistStatContent< DIMENSIONS, PRECISION >Basic histogram statistics, keeping track of the bin content and the total number of calls to Fill()
 CROOT::Experimental::RHistStatRuntime< DIMENSIONS, PRECISION >Interface implementing a pure virtual functions DoFill(), DoFillN()
 CROOT::Experimental::RHistStatTotalSumOfSquaredWeights< DIMENSIONS, PRECISION >Keeps track of the histogram's total sum of squared weights
 CROOT::Experimental::RHistStatTotalSumOfWeights< DIMENSIONS, PRECISION >Keeps track of the histogram's total sum of weights
 CROOT::Experimental::RHistStatUncertainty< DIMENSIONS, PRECISION >Histogram statistics to keep track of the Poisson uncertainty per bin
 CROOT::Experimental::RHistView< DIMENSIONS, PRECISION, STAT >A view on a histogram, selecting a range on a subset of dimensions
 CROOT::Experimental::RHistViewOutOfRange< HISTVIEW >
 CROOT::Browsable::RHolderBasic class for object holder of any kind
 CROOT::Math::RichardsonDerivatorUser class for calculating the derivatives of a function
 CROOT::Experimental::Internal::RColumnElementBase::RIdentifierEvery concrete RColumnElement type is identified by its on-disk type (column type) and the in-memory C++ type, given by a type index
 CROOT::Experimental::RNTupleImporter::RImportBranch
 CROOT::Experimental::RNTupleImporter::RImportField
 CROOT::Experimental::RNTupleImporter::RImportGuardWhen the schema is set up and the import started, it needs to be reset before the next Import() call can start
 CROOT::Experimental::RNTupleImporter::RImportLeafCountCollectionLeaf count arrays require special treatment
 CROOT::Experimental::RNTupleImporter::RImportTransformationBase class to perform data transformations from TTree branches to RNTuple fields if necessary
 CROOT::Experimental::Internal::RIndexIter< REFERENCE, POINTER >Iterates over an index; the REFERENCE is defined by the REFERENCE template parameter
 CROOT::Experimental::Internal::RIndexIter< RHistBinRef< HISTIMPL >, RHistBinPtr< HISTIMPL > >
 CROOT::Detail::RDF::RInferredType
 CROOT::Experimental::Internal::RClusterPool::RInFlightClusterClusters that are currently being processed by the pipeline
 CROOT::Experimental::RIntegralField< T >
 CROOT::Experimental::RIntegralField< Internal::RIntegralTypeMap< T >::type >
 CROOT::Experimental::Internal::RIntegralTypeMap< T >
 CROOT::Experimental::Internal::RIntegralTypeMap< int >
 CROOT::Experimental::Internal::RIntegralTypeMap< long >
 CROOT::Experimental::Internal::RIntegralTypeMap< long long >
 CROOT::Experimental::Internal::RIntegralTypeMap< short >
 CROOT::Experimental::Internal::RIntegralTypeMap< signed char >
 CROOT::Experimental::Internal::RIntegralTypeMap< unsigned char >
 CROOT::Experimental::Internal::RIntegralTypeMap< unsigned int >
 CROOT::Experimental::Internal::RIntegralTypeMap< unsigned long >
 CROOT::Experimental::Internal::RIntegralTypeMap< unsigned long long >
 CROOT::Experimental::Internal::RIntegralTypeMap< unsigned short >
 CRInterfaceBaseThe public interface to the RDataFrame federation of classes
 CROOT::RDF::RInterfaceBase
 CROOT::Experimental::Internal::RIOSharedBase
 CROOT::Internal::RIoUring
 CROOT::Internal::RRawFile::RIOVecUsed for vector reads from multiple offsets into multiple buffers
 CROOT::Internal::RRawFile::RIOVecLimitsImplementations may enforce limits on the use of vector reads
 CROOT::Browsable::RItemRepresentation of single item in the browser
 CROOT::Experimental::RFitPanelModel::RItemInfoBasic function info, used in combo boxes
 CROOT::Experimental::RClusterDescriptor::RColumnRangeIterable::RIterator
 CROOT::Experimental::RNTupleClusterRange::RIterator
 CROOT::Experimental::RNTupleDescriptor::RClusterDescriptorIterable::RIterator
 CROOT::Experimental::RNTupleDescriptor::RClusterGroupDescriptorIterable::RIterator
 CROOT::Experimental::RNTupleDescriptor::RColumnDescriptorIterable::RIterator
 CROOT::Experimental::RNTupleDescriptor::RExtraTypeInfoDescriptorIterable::RIterator
 CROOT::Experimental::RNTupleDescriptor::RFieldDescriptorIterable::RIterator
 CROOT::Experimental::RNTupleGlobalRange::RIterator
 CROOT::Experimental::RNTupleProcessor::RIteratorIterator over the entries of an RNTuple, or vertical concatenation thereof
 CROOT::Experimental::RNTupleReader::RIterator
 CROOT::Experimental::RProxiedCollectionField::RCollectionIterableOnce::RIterator
 CROOT::Experimental::RProxiedCollectionField::RCollectionIterableOnce::RIteratorFuncs
 CROOT::Experimental::Internal::RCluster::RKeyThe identifiers that specifies the content of a (partial) cluster
 CROOT::Experimental::Internal::RPagePool::RKey
 CROOT::Experimental::Internal::RPagePool::RKeyHasherHash function to be used in the unordered map fLookupByKey
 CROOT::Browsable::RLevelIterIterator over single level hierarchy like any array, keys list, ..
 CROOT::Experimental::Internal::RLocalBinsToCoords< I, NDIMS, BINS, COORD, AXES >Recursively converts local axis bins from the standard kUnderflowBin/kOverflowBin for under/overflow bin indexing convention, to the corresponding bin coordinates
 CROOT::Experimental::Internal::RLocalBinsToCoords<-1, NDIMS, BINS, COORD, AXES >
 CROOT::Experimental::Internal::RLocalBinsToVirtualBins< I, NDIMS, BINS, AXES >Recursively converts local axis bins from the standard kUnderflowBin/kOverflowBin for under/overflow bin indexing convention, to a "virtual bin" convention where the underflow bin has index 0 and the overflow bin has index N+1 where N is the axis' number of regular bins
 CROOT::Experimental::Internal::RLocalBinsToVirtualBins<-1, NDIMS, BINS, AXES >
 CROOT::RError::RLocation
 CROOT::RLogDiagCountKeep track of emitted errors and warnings
 CROOT::RLogEntryA diagnostic that can be emitted by the RLogManager
 CROOT::RLogHandlerAbstract RLogHandler base class
 CROOT::RLogLocationA diagnostic location, part of an RLogEntry
 CROOT::RLogScopedDiagCountObject to count the number of warnings and errors emitted by a section of code, after construction of this type
 CROOT::RLogScopedVerbosityChange the verbosity level (global or specific to the RLogChannel passed to the constructor) for the lifetime of this object
 CROOT::Experimental::Detail::RMenuArgumentArgument description for menu item which should invoke class method
 CROOT::Experimental::Detail::RMenuItemBase class for menu items, shown on JS side
 CROOT::Detail::RDF::RMergeableValueBaseBase class of RMergeableValue
 CROOT::RDF::Experimental::RMetaDataClass behaving as a heterogenuous dictionary to store the metadata of a dataset
 CROOT::Internal::RDF::RMetaDataJson
 CROOT::Experimental::RFitPanelModel::RMethodInfo
 CROOT::Experimental::Internal::RMiniFileReaderRead RNTuple data blocks from a TFile container, provided by a RRawFile
 CROOT::Experimental::RFitPanelModel::RMinimezerAlgorithmEntry in minimizer algorithm combo
 CTMVA::Experimental::SOFIE::RModel_Base
 CTMVA::Experimental::SOFIE::RModelParser_ONNX
 CROOT::Internal::RDF::RNewSampleFlag
 CROOT::Internal::RDF::RNewSampleNotifier
 Crng_state_st
 CROOT::Internal::TreeUtils::RNoCleanupNotifierHelper
 CROOT::Detail::RDF::RNodeBaseBase class for non-leaf nodes of the computational graph
 CROOT::RNTupleRepresentation of an RNTuple data set in a ROOT file
 CROOT::RNTupleCardinality< SizeT >Helper types to present an offset column as array of collection sizes
 CROOT::Experimental::RNTupleClusterRangeUsed to loop over entries of collections in a single cluster
 CROOT::Experimental::RNTupleCollectionViewA view for a collection, that can itself generate new ntuple views for its nested fields
 CROOT::Experimental::Internal::RNTupleCompressorHelper class to compress data blocks in the ROOT compression frame format
 CROOT::Experimental::Internal::RNTupleDecompressorHelper class to uncompress data blocks in the ROOT compression frame format
 CROOT::Experimental::RNTupleDescriptorThe on-storage meta-data of an ntuple
 CROOT::Experimental::Internal::RNTupleDescriptorBuilderA helper class for piece-wise construction of an RNTupleDescriptor
 CROOT::Experimental::RNTupleDirectAccessView< T >A view variant that provides direct access to the I/O buffers
 CROOT::Experimental::Internal::RNTupleExporter
 CROOT::Experimental::Internal::RNTupleFileWriterWrite RNTuple data blocks in a TFile or a bare file container
 CROOT::Experimental::RNTupleFillContextA context for filling entries (data) into clusters of an RNTuple
 CROOT::Experimental::RNTupleFillStatusA status object after filling an entry
 CROOT::Experimental::RNTupleFormatterContains helper functions for RNTupleReader::PrintInfo() and RPrintSchemaVisitor::VisitField()
 CROOT::Experimental::RNTupleGlobalRangeUsed to loop over indexes (entries or collections) between start and end
 CROOT::Experimental::RNTupleImporterConverts a TTree into an RNTuple
 CROOT::Experimental::RNTupleInspectorInspect on-disk and storage-related information of an RNTuple
 CROOT::Experimental::Internal::RNTupleJoinTableBuilds a join table on one or several fields of an RNTuple so it can be joined onto other RNTuples
 CROOT::RNTupleLocalIndexAddresses a column element or field item relative to a particular cluster, instead of a global NTupleSize_t index
 CROOT::RNTupleLocatorGeneric information about the physical location of data
 CROOT::RNTupleLocatorObject64RNTupleLocator payload that is common for object stores using 64bit location information
 CROOT::Experimental::Internal::RNTupleMergeData
 CROOT::Experimental::Internal::RNTupleMergeOptionsSet of merging options to pass to RNTupleMerger
 CROOT::Experimental::Internal::RNTupleMergerGiven a set of RPageSources merge them into an RPagePersistentSink, optionally changing their compression
 CROOT::Experimental::Detail::RNTupleMetricsA collection of Counter objects with a name, a unit, and a description
 CROOT::Experimental::RNTupleModelThe RNTupleModel encapulates the schema of an ntuple
 CROOT::Experimental::Internal::RNTupleModelChangesetThe incremental changes to a RNTupleModel
 CROOT::Experimental::RNTupleOpenSpecUsed to specify the underlying RNTuples in RNTupleProcessor
 CROOT::Experimental::RNTupleParallelWriterA writer to fill an RNTuple from multiple contexts
 CROOT::Experimental::Detail::RNTuplePerfCounterA performance counter with a name and a unit, which can be activated on demand
 CROOT::Experimental::RNTupleProcessorInterface for iterating over entries of RNTuples and vertically concatenated RNTuples (chains)
 CROOT::Experimental::RNTupleReaderAn RNTuple that is used to read data from storage
 CROOT::Experimental::RNTupleReadOptionsCommon user-tunable settings for reading ntuples
 CROOT::Experimental::Internal::RNTupleReadOptionsManip
 CROOT::Experimental::Internal::RNTupleSerializerA helper class for serializing and deserialization of the RNTuple binary format
 CROOT::Experimental::Detail::RNTupleTimer< WallTimeT, CpuTimeT >Record wall time and CPU time between construction and destruction
 CROOT::Experimental::RNTupleViewBase< T >An RNTupleView provides read-only access to a single field of the ntuple
 CROOT::Experimental::RNTupleViewBase< void >
 CROOT::Experimental::RNTupleWriteOptionsCommon user-tunable settings for storing ntuples
 CROOT::Experimental::Internal::RNTupleWriteOptionsManip
 CROOT::Experimental::RNTupleWriterAn RNTuple that gets filled with entries (data) and writes them to storage
 CTMVA::ROCCalc
 CTMVA::ROCCurve
 CROOT::Experimental::Internal::RDaosContainer::ROidDkeyPairA pair of <object ID, distribution key> that can be used to issue a fetch/update request for multiple attribute keys
 CROOT::Experimental::Internal::ROnDiskPageA page as being stored on disk, that is packed and compressed
 CROOT::Experimental::Internal::ROnDiskPageMapA memory region that contains packed and compressed pages
 CROOT::Internal::RDF::ROneTimeCallback
 CRooAbsCollection::RooAbsArgPtrOrDouble
 CRooAbsCacheAbstract base class for data members of RooAbsArgs that cache other (composite) RooAbsArg expressions
 CRooAbsCacheElementAbstract base class for objects to be stored in RooAbsCache cache manager objects
 CRooFit::Detail::RooAbsDataFiller
 CRooAbsFuncAbstract interface for evaluating a real-valued function of one real variable and performing numerical algorithms on it
 CRooAbsIntegratorAbstract interface for integrators of real-valued functions that implement the RooAbsFunc interface
 CRooFit::TestStatistics::RooAbsL
 CRooAbsLValueAbstract base class for objects that are lvalues, i.e
 CRooAbsMinimizerFcn
 CRooAbsNumGeneratorAbstract base class for MC event generator implementations like RooAcceptReject and RooFoam
 CRooAbsProxyAbstract interface for proxy classes
 CRooAddHelpers
 CRooAICRegistryUtility class for operator p.d.f classes that keeps track of analytical integration codes and associated normalization and integration sets
 CRooBatchCompute::RooBatchComputeInterfaceThe interface which should be implemented to provide optimised computation functions for implementations of RooAbsReal::doEval()
 CRooBinnedLImplements a -log(likelihood) calculation from a dataset (assumed to be binned) and a PDF
 CRooBlindTools
 CRooBrentRootFinderImplement the abstract 1-dimensional root finding interface using the Brent-Decker method
 CRooCFunction1Map< VO, VI >
 CRooCFunction2Map< VO, VI1, VI2 >
 CRooCFunction3Map< VO, VI1, VI2, VI3 >
 CRooCFunction4Map< VO, VI1, VI2, VI3, VI4 >
 CRooClassFactorySimilar to TTree::MakeClass(), generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names
 CRooCollection_t
 CRooCustomizerRooCustomizer is a factory class to produce clones of a prototype composite PDF object with the same structure but different leaf servers (parameters or dependents)
 CRooDirItemUtility base class for RooFit objects that are to be attached to ROOT directories
 CRooErrorHandler
 CRooFIterA one-time forward iterator working on RooLinkedList or RooAbsCollection
 CRooFitMoreLib
 CRooFunctorLightweight interface adaptor that exports a RooAbsPdf as a functor
 CRooGlobalFunc
 CRooHistErrorSingleton class used to calculate the error bars for each bin of a RooHist object
 CRooJSONFactoryWSToolWhen using RooFit, statistical models can be conveniently handled and stored as a RooWorkspace
 CRooLinkedListElemLink element for the RooLinkedList class
 CRooMath
 CRooMathCoreReg
 CRooMathMoreReg
 CRooMPSentinel
 CRooNaNPackerLittle struct that can pack a float into the unused bits of the mantissa of a NaN double
 CRooNormalizedPdfA RooNormalizedPdf wraps a pdf divided by its integral for a given normalization set into a new self-normalized pdf
 CRooNormSetCacheClass RooNormSet cache manage the bookkeeping of multiple instances of sets of integration and normalization observables that effectively have the same definition
 CRooNumberProvides numeric constants used in RooFit
 CRooPrintableA 'mix-in' base class that define the standard RooFit plotting and printing methods
 CRooPyBindA RooFit class for wrapping python functions
 CRooQuasiRandomGeneratorThis class generates the quasi-random (aka "low discrepancy") sequence for dimensions up to 12 using the Niederreiter base 2 algorithm described in Bratley, Fox, Niederreiter, ACM Trans
 CRooRandomThis class provides a static interface for generating random numbers
 CRooRealConstantProvides static functions to create and keep track of RooRealVar constants
 CRooSimWSToolThe RooSimWSTool is a tool operating on RooWorkspace objects that can clone PDFs into a series of variations that are joined together into a RooSimultaneous PDF
 CRooStats::RooStatsConfig
 CRooSTLRefCountList< T >
 CRooSTLRefCountList< RooAbsArg >
 CRooStreamParser
 CRooStringViewThe RooStringView is a wrapper around a C-style string that can also be constructed from a std::string or a TString
 CRooSubsidiaryLCalculates the sum of the -(log) likelihoods of a set of RooAbsPdf objects that represent subsidiary or constraint functions
 CROOT::Internal::RDF::RootConversionTraits< T >
 CROOT::Internal::RDF::RootConversionTraits< bool >
 CROOT::Internal::RDF::RootConversionTraits< double >
 CROOT::Internal::RDF::RootConversionTraits< float >
 CROOT::Internal::RDF::RootConversionTraits< int16_t >
 CROOT::Internal::RDF::RootConversionTraits< int32_t >
 CROOT::Internal::RDF::RootConversionTraits< int8_t >
 CROOT::Internal::RDF::RootConversionTraits< Long64_t >
 CROOT::Internal::RDF::RootConversionTraits< uint16_t >
 CROOT::Internal::RDF::RootConversionTraits< uint32_t >
 CROOT::Internal::RDF::RootConversionTraits< uint8_t >
 CROOT::Internal::RDF::RootConversionTraits< ULong64_t >
 CROOT::Math::RootFinderUser Class to find the Root of one dimensional functions
 CRooTMathReg
 CRooTraceControls the memory tracing hooks in all RooFit objects
 CRooUnbinnedLA -log(likelihood) calculation from a dataset (assumed to be unbinned) and a PDF
 CRooWorkspaceHandleAn interface to set and retrieve a workspace
 CTMVA::Experimental::SOFIE::ROperator
 CROOT::Internal::RRawFile::ROptionsOn construction, an ROptions parameter can customize the RRawFile behavior
 CROOT::RDF::RCsvDS::ROptionsOptions that control how the CSV file is parsed
 CRotatedTextItemTemplate_t
 CROOT::Math::Rotation3DRotation class with the (3D) rotation represented by a 3x3 orthogonal matrix
 CROOT::Math::RotationXRotation class representing a 3D rotation about the X axis by the angle of rotation
 CROOT::Math::RotationYRotation class representing a 3D rotation about the Y axis by the angle of rotation
 CROOT::Math::RotationZRotation class representing a 3D rotation about the Z axis by the angle of rotation
 CROOT::Math::RotationZYXRotation class with the (3D) rotation represented by angles describing first a rotation of an angle phi (yaw) about the Z axis, followed by a rotation of an angle theta (pitch) about the Y axis, followed by a third rotation of an angle psi (roll) about the X axis
 CROOT::Math::RowOffsets< D >Static structure to keep the conversion from (i,j) to offsets in the storage data for a symmetric matrix
 CROOT::Experimental::RPadExtentAn extent / size (horizontal and vertical) in a RPad
 CROOT::Experimental::RPadLengthA length in RPad
 CROOT::Experimental::RPadPosA position (horizontal and vertical) in a RPad
 CROOT::Experimental::Internal::RPageA page is a slice of a column that is mapped into memory
 CROOT::Experimental::Internal::RPageAllocatorAbstract interface to allocate and release pages
 CROOT::Experimental::RClusterDescriptor::RPageRange::RPageInfoWe do not need to store the element size / uncompressed page size because we know to which column the page belongs
 CROOT::Experimental::Internal::RPagePoolA thread-safe cache of pages loaded from the page source
 CROOT::Experimental::Internal::RPagePool::RPagePositionUsed in fLookupByKey to store both the absolute and the cluster-local page index of the referenced page
 CROOT::Experimental::RClusterDescriptor::RPageRangeRecords the partition of data into pages for a particular column in a particular cluster
 CROOT::Experimental::Internal::RPageRefReference to a page stored in the page pool
 CROOT::Experimental::Internal::RNTupleExporter::RPagesOptions
 CROOT::Experimental::Internal::RNTupleExporter::RPagesResult
 CROOT::Experimental::Internal::RPageStorageCommon functionality of an ntuple storage for both reading and writing
 CROOT::Experimental::Internal::RPageSinkBuf::RColumnBuf::RPageZipItem
 CROOT::Experimental::RPaletteA set of colors
 CROOT::Experimental::RPrintValueVisitor::RPrintOptions
 CROOT::RDF::RDisplay::RPrintOptions
 CROOT::Experimental::RNTupleImporter::RProgressCallbackUsed to report every ~100 MB (compressed), and at the end about the status of the import
 CROOT::Experimental::Internal::RProjectedFieldsThe projected fields of a RNTupleModel
 CROOT::Browsable::RProviderProvider of different browsing methods for supported classes
 CROOT::RRangeCast< T, isDynamic, Range_t >Wraps any collection that can be used in range-based loops and applies static_cast<T> or dynamic_cast<T> to each element
 CROOT::RRangeCast< T *, isDynamic, TCollection const & >
 CROOT::Internal::RRawFileThe RRawFile provides read-only access to local and remote files
 CROOT::Internal::RRawFileNetXNGImpl
 CTMVA::Experimental::RReaderA replacement for the TMVA::Reader legacy interface
 CROOT::Internal::RIoUring::RReadEventBasic read event composed of IO data and a target file descriptor
 CROOT::Experimental::Internal::RClusterPool::RReadItemRequest to load a subset of the columns of a particular cluster
 CROOT::RResultBaseCommon handling of the error case for RResult<T> (T != void) and RResult<void>
 CROOT::RDF::RResultHandleA type-erased version of RResultPtr and RResultMap
 CROOT::RDF::Experimental::RResultMap< T >
 CROOT::RDF::RResultPtr< T >Smart pointer for the return type of actions
 CROOT::RRulesList
 Crsa_KEY
 Crsa_KEY_export
 Crsa_NUMBER
 CROOT::RDF::Experimental::RSampleClass representing a sample which is a grouping of trees and their fileglobs, and, optionally, the sample's metadata information via the RMetaData object
 CROOT::RDF::RSampleInfoThis type represents a sample identifier, to be used in conjunction with RDataFrame features such as DefinePerSample() and per-sample callbacks
 CROOT::Experimental::RFieldBase::RSchemaIteratorTemplate< IsConstT >Iterates over the sub tree of fields in depth-first search order
 CROOT::Experimental::Internal::RPageStorage::RSealedPageA sealed page contains the bytes of a page as written to storage (packed & compressed)
 CROOT::Experimental::Internal::RPageStorage::RSealedPageGroupA range of sealed pages referring to the same column that can be used for vector commit
 CROOT::Experimental::Internal::RSealedPageMergeData
 CROOT::Experimental::Internal::RPageSink::RSealPageConfigParameters for the SealPage() method
 CRShared< T >Holder of with shared_ptr<T> instance
 CROOT::Experimental::Internal::RPageSource::RSharedDescriptorGuardAn RAII wrapper used for the read-only access to RPageSource::fDescriptor. See GetExclDescriptorGuard()`
 CROOT::Experimental::RFieldBase::RSharedPtrDeleter
 CROOT::Experimental::Internal::RPageSink::RSinkGuardAn RAII wrapper used to synchronize a page sink. See GetSinkGuard()
 CROOT::Internal::RSlotStackA thread-safe stack of N indexes (0 to size - 1)
 CROOT::Internal::RSlotStackRAIIA RAII object to pop and push slot numbers from a RSlotStack object
 CROOT::RDF::RSnapshotOptionsA collection of options to steer the creation of the dataset on file
 CTMVA::Experimental::RSofieReaderTMVA::RSofieReader class for reading external Machine Learning models in ONNX files, Keras .h5 files or PyTorch .pt files and performing the inference using SOFIE It is reccomended to use ONNX if possible since there is a larger support for model operators
 CROOT::RDF::Internal::RSqliteDSDataSetThe state of an open dataset in terms of the sqlite3 C library
 CROOT::Experimental::Internal::RPageSink::RStagedClusterCluster that was staged, but not yet logically appended to the RNTuple
 CROOT::Experimental::RClassField::RStagingItem
 CTMVA::Experimental::RStandardScaler< T >
 CROOT::Internal::RStl
 CROOT::Internal::RDF::RStringCacheA Thread-safe cache for strings
 CROOT::Experimental::Internal::RPageSourceFile::RStructureBufferHolds the uncompressed header and footer
 CROOT::Experimental::RStyleA set of defaults for graphics attributes, e.g
 CROOT::Experimental::RClassField::RSubFieldInfo
 CROOT::Internal::RTaskArenaWrapperWrapper for tbb::task_arena
 CROOT::Experimental::Internal::RPageStorage::RTaskSchedulerThe interface of a task scheduler to schedule page (de)compression tasks
 CTMVA::Experimental::RTensor< V, C >RTensor is a container with contiguous memory and shape information
 CTMVA::Experimental::RTensor< AFloat, TCpuBuffer< AFloat > >
 CTMVA::Experimental::RTensor< float >
 CTMVA::Experimental::RTensor< int >
 CTMVA::Experimental::RTensor< Value_t, Container_t >
 CROOT::Experimental::Internal::RTestFutureColumn
 CROOT::Experimental::Internal::RTFileControlBlockIf a TFile container is written by a C stream (simple file), on dataset commit, the file header and the TFile record need to be updated
 CROOT::RTreeViewerWeb-based ROOT TTree viewer
 CTMVA::RuleImplementation of a rule
 CTMVA::RuleCutA class describing a 'rule cut'
 CTMVA::RuleEnsemble
 CTMVA::RuleFitA class implementing various fits of rule ensembles
 CTMVA::RuleFitAPIJ Friedman's RuleFit method
 CTMVA::RuleFitParamsA class doing the actual fitting of a linear model using rules as base functions
 CRUnique< T >Holder of with unique_ptr<T> instance
 CROOT::Experimental::RNTupleModel::RUpdaterA model is usually immutable after passing it to an RNTupleWriter
 CROOT::Experimental::RFrame::RUserRanges
 CROOT::Experimental::RFieldBase::RValuePoints to an object with RNTuple I/O support and keeps a pointer to the corresponding field
 CROOT::Experimental::RColumnDescriptor::RValueRange
 CROOT::Internal::RDF::RVariationBaseThis type includes all parts of RVariation that do not depend on the callable signature
 CROOT::RDF::RVariationsDescriptionA descriptor for the systematic variations known to a given RDataFrame node
 CROOT::Internal::RDF::RVariationsWithReaders
 CROOT::Internal::VecOps::RVecInlineStorageSize< T >The size of the inline storage of an RVec
 CROOT::Experimental::Internal::RVirtualBinsToLocalBins< I, NDIMS, BINS, AXES >Recursively converts zero-based virtual bins where the underflow bin has index 0 and the overflow bin has index N+1 where N is the axis' number of regular bins, to the standard kUnderflowBin/kOverflowBin for under/overflow bin indexing convention
 CROOT::Experimental::Internal::RVirtualBinsToLocalBins<-1, NDIMS, BINS, AXES >
 CROOT::Experimental::Internal::RVirtualCanvasPainterAbstract interface for painting a canvas
 CROOT::RWebDisplayArgsHolds different arguments for starting browser with RWebDisplayHandle::Display() method
 CROOT::RWebDisplayHandleHandle of created web-based display Depending from type of web display, holds handle of started browser process or other display-specific information to correctly stop and cleanup display
 CROOT::RWebWindowRepresents web window, which can be shown in web browser or any other supported environment
 CROOT::Details::RWebWindowPlugin
 CROOT::RWebWindowsManagerCentral instance to create and show web-based windows like Canvas or FitPanel
 CROOT::Experimental::Internal::RDaosContainer::RWOperationDescribes a read/write operation on multiple attribute keys under the same object ID and distribution key, see the ReadV/WriteV functions
 CROOT::Experimental::Internal::RWritePageMemoryManagerHelper to maintain a memory budget for the write pages of a set of columns
 CTGeoParallelWorld::SafetyVoxelInfo
 CRooStats::HistFactory::Sample
 CROOT::Experimental::RPadExtent::ScaleFactorA scale factor (separate factors for horizontal and vertical) for scaling a RPadLength
 CROOT::Experimental::RPadPos::ScaleFactorA scale factor (separate factors for horizontal and vertical) for scaling a RPadLength
 CROOT::Experimental::REveScene::SceneCommand
 CROOT::MacOSX::Util::ScopedArray< T >
 CRooFit::Experimental::CodegenContext::ScopeRAII
 CROOT::Math::SDeterminant< n, idim >Dsfact
 CRooFit::TestStatistics::RooAbsL::SectionA part of some range delimited by two fractional points between 0 and 1 (inclusive)
 CSegment_tUsed for drawing line segments (maps to the X11 XSegments structure)
 CSelectionRulesThe class representing the collection of selection rules
 CROOT::Meta::Selection::SelectNoInstanceUsed to avoid to select all instances of a template
 CROOT::Internal::ParsingStateRAII::SemaExprCleanupsRAII
 CROOT::Internal::ParsingStateRAII::SemaParsingInitForAutoVarsRAII
 CTMVA::SeparationBaseAn interface to calculate the "SeparationGain" for different separation criteria used in various training algorithms
 CTStreamerInfoActions::TActionSequence::SequencePtr
 CROOT::Experimental::REveManager::ServerState
 CSetFreeIfTMapFile_tSet ROOT::Internal::gFreeIfTMapFile on library load
 CTMVA::DNN::SettingsSettings for the training of the neural net
 CSetWindowAttributes_tAttributes that can be used when creating or changing a window
 CROOT::Detail::TCollectionProxyInfo::SfinaeHelper
 CSgEsc_t
 CROOT::Internal::SHA256::sha256_t
 CSHA_CTX
 CROOT::RGeomDescription::ShapeDescr
 Cstd::shared_ptr< const RooFitResult >
 Cstd::shared_ptr< RooAbsReal >
 CSharedOffset
 CTString::ShortStr_t
 CSHtmlExtensions_t
 CSHtmlIndex_t
 CSHtmlMargin_t
 CSHtmlStyle_t
 CSHtmlStyleStack_t
 CSHtmlTokenMap_t
 CSignalmap_t
 CROOT::Fit::FitUtil::SimpleGradientCalculator
 CROOT::Minuit2::SimplexParametersClass describing the simplex set of points (f(x), x ) which evolve during the minimization iteration process
 CTMVA::SimulatedAnnealingBase implementation of simulated annealing fitting procedure
 CROOT::Minuit2::SinParameterTransformationClass for the transformation for double-limited parameter Using a sin function one goes from a double-limited parameter range to an unlimited one
 CROOT::Math::SInverter< T, n, idim >Dsinv
 CROOT::Math::SkipFunction< SkipNumber >
 CROOT::Math::SkipFunction< 0 >
 CROOT::Experimental::REveCaloData::SliceInfo_t
 CTEveCaloData::SliceInfo_t
 CROOT::Detail::RDF::ExtraArgsForDefine::Slot
 CROOT::Detail::RDF::ExtraArgsForDefine::SlotAndEntry
 Cbvh::v2::SmallStack< T, Capacity >Fixed-size stack that can be used for a BVH traversal
 CROOT::Internal::VecOps::SmallVectorAlignmentAndSize< T >Used to figure out the offset of the first element of an RVec
 CROOT::Internal::VecOps::SmallVectorBaseThis is all the stuff common to all SmallVectors
 CROOT::Internal::VecOps::SmallVectorStorage< T, N >Storage for the SmallVector elements
 CROOT::Internal::VecOps::SmallVectorStorage< bool, N >
 CROOT::Internal::VecOps::SmallVectorStorage< double, N >
 CROOT::Internal::VecOps::SmallVectorStorage< float, N >
 CROOT::Internal::VecOps::SmallVectorStorage< int, N >
 CROOT::Internal::VecOps::SmallVectorStorage< Long64_t, N >
 CROOT::Internal::VecOps::SmallVectorStorage< T, 0 >We need the storage to be properly aligned even for small-size of 0 so that the pointer math in SmallVectorTemplateCommon::getFirstEl() is well-defined
 CROOT::Internal::VecOps::SmallVectorStorage< ULong64_t, N >
 CROOT::Internal::VecOps::SmallVectorStorage< unsigned int, N >
 CROOT::Math::SMatrix< T, D1, D2, R >SMatrix: a generic fixed size D1 x D2 Matrix class
 CROOT::Math::SMatrix< T, D1, D2, R >
 CROOT::Math::SMatrixIdentity
 CROOT::Math::SMatrixNoInit
 CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow
 CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow_const
 Csocket
 CSOFIE_GNN
 CTMVA::Experimental::SofieFunctorHelper< I, F, T >Helper class used by SOFIEFunctor to wrap the infer signature interface to RDataFrame
 CTMVA_SOFIE_GNN.SofieGNN
 CROOT::Experimental::REveDataSimpleProxyBuilder::SPBProduct
 CTClingCXXRecMethIter::SpecFuncIter
 Cbvh::v2::BinnedSahBuilder< Node, BinCount >::Split
 Cbvh::v2::SweepSahBuilder< Node >::Split
 Cbvh::v2::SplitHeuristic< T >
 Cbvh::v2::SplitHeuristic< Scalar >
 CSQLite3_Stmt_t
 CROOT::Math::Sqr< T >Unary Square Operation Class
 CROOT::Math::Sqrt< T >Unary Square Root Operation Class
 CROOT::Minuit2::SqrtLowParameterTransformationTransformation from external to internal Parameter based on sqrt(1 + x**2)
 CROOT::Minuit2::SqrtUpParameterTransformationTransformation from external to internal Parameter based on sqrt(1 + x**2)
 Csrv_HS_t
 Cssl_func
 CROOT::Minuit2::StackAllocatorStackAllocator controls the memory allocation/deallocation of Minuit
 CROOT::Minuit2::StackAllocatorHolder
 CROOT::Minuit2::StackError
 CROOT::Minuit2::StackOverflowDefine stack allocator symbol
 CSTAT
 CTMVA::StatDialogBDT
 CTMVA::StatDialogBDTReg
 CTMVA::StatDialogMVAEffs
 CROOT::TVirtualRWMutex::StateEarlier lock state as returned by GetState() that can be passed to Restore()
 CROOT::TVirtualRWMutex::StateAndRecurseCount
 CROOT::TVirtualRWMutex::StateDeltaState as returned by GetStateDelta() that can be passed to Restore()
 CRooStats::HistFactory::StatErrorConfigConfiguration to automatically assign nuisance parameters for the statistical error of the Monte Carlo simulations
 CROOT::option::StatsDetermines the minimum lengths of the buffer and options arrays used for Parser
 CROOT::Math::StdEngine< Generator >Class to wrap engines from the C++ standard random library in the ROOT Random interface
 CROOT::Math::StdEngineType< Generator >
 CROOT::Math::StdRandomEngine
 CTMVA::DNN::SteepestSteepest Gradient Descent algorithm (SGD)
 CTJSONStackObj::StlRead
 Cstd::streambuf
 CRooMsgService::StreamConfig
 CTGenCollectionProxy::StreamHelperHelper class to facilitate I/O
 CROOT::Browsable::RProvider::StructBrowse
 CROOT::Browsable::RProvider::StructClass
 CROOT::Browsable::RProvider::StructDraw6
 CROOT::Browsable::RProvider::StructDraw7
 CROOT::Browsable::RProvider::StructFile
 CTGDMLWrite::StructLst
 CROOT::Browsable::RProvider::StructProgress
 CStyleTemplate_t
 CTGL5DPainter::Surf_t
 CTCling::SuspendAutoLoadingRAII
 CTInterpreter::SuspendAutoLoadingRAII
 CTInterpreter::SuspendAutoParsing
 CROOT::Math::SVector< T, D >SVector: a generic fixed size Vector class
 CTMVA::SVEventEvent class for Support Vector Machine
 CTMVA::SVKernelFunctionKernel for Support Vector Machine
 CTMVA::SVKernelMatrixKernel matrix for Support Vector Machine
 CTMVA::SVWorkingSetWorking class for Support Vector Machine
 CSXmlAttr_t
 CSXmlDoc_t
 CSXmlNode_t
 CROOT::Minuit2::sym
 CSysInfo_t
 CSYSTEM_BASIC_INFORMATION
 CSYSTEM_PERFORMANCE_INFORMATION
 CTA
 CTGTableLayout::TableData_t
 CTMVA::TActivationInterface for TNeuron activation function classes
 CTMVA::TActivationChooserClass for easily choosing activation functions
 CTakeAValue
 CROOT::TypeTraits::TakeFirstParameter< T >Return first of possibly many template parameters
 CROOT::TypeTraits::TakeFirstParameter< Template< T, Rest... > >
 CROOT::TypeTraits::TakeFirstType< T, Rest >
 CTApplicationImpABC describing GUI independent application implementation protocol
 CTArcBallImplements the arc-ball rotation manipulator
 CTArrayAbstract array base class
 CTArrayIndexProducerJSON array separators for multi-dimensional JSON arrays It fully reproduces array dimensions as in original ROOT classes Contrary to binary I/O, which always writes flat arrays
 CROOT::Internal::TArrayType< T, d >Helper template to be able to determine and use array dimensions
 CROOT::Internal::TArrayType< T, 0 >Helper class for proxy around multi dimension array
 Ctbb::task_arena
 CRooFit::TestStatistics::LikelihoodGradientJob::task_result_t
 CRooFit::TestStatistics::LikelihoodJob::task_result_t
 CTASLogHandlerGuard
 CTASPngWriterC++ wrapper over simple writer of PNG files for standard GL memory formats: LUMINANCE, LUMINANCE_ALPHA, RGB, and RGBA
 CTAtomicCount
 CROOT::Internal::TAtomicPointer< T >Helper class to manage atomic pointers
 CROOT::Internal::TAtomicPointer< TObjArray * >
 CTAtt3DUse this attribute class when an object should have 3D capabilities
 CTAttAxisManages histogram axis attributes
 CTAttBBoxHelper for management of bounding-box information
 CTAttBBox2DAbstract base class for elements drawn in the editor
 CTAttCanvasManages canvas attributes
 CTAttFillFill Area Attributes class
 CTAttImageTImage attributes
 CTAttLineLine Attributes class
 CTAttMarkerMarker Attributes class
 CTAttPadManages default Pad attributes
 CTAttTextText Attributes class
 CTBase64This code implements the Base64 encoding and decoding
 CTMVA::DNN::TBatch< AArchitecture >TBatch
 CTMVA::DNN::TBatchIterator< Data_t, AArchitecture >TBatchIterator
 CTBinIterator
 CROOT::Internal::TBranchCacheInfo
 CROOT::Internal::TBranchIMTHelperA helper class for managing IMT work during TTree:Fill operations
 CROOT::Detail::TBranchProxyBase class for all the proxy object
 CTBranchProxyClassDescriptorHold the processed information about a TClass used in a TBranch while TTreeProxyGenerator is parsing the TTree information
 CTBranchProxyDescriptor/Hold the processed information about a TBranch while /TTreeProxyGenerator is parsing the TTree information
 CROOT::Internal::TBranchProxyDirector
 CTBranchProxyDirectorThis class is used to 'drive' and hold a serie of TBranchProxy objects which represent and give access to the content of TTree object
 CROOT::Internal::TBranchProxyHelperString builder to be used in the constructors
 CTBrowserImpABC describing GUI independent browser implementation protocol
 CTBtItemItem stored in inner nodes of a TBtree
 CTBtNodeAbstract base class (ABC) of a TBtree node
 CTBuffer3DTypes
 CROOT::TBufferMergerTBufferMerger is a class to facilitate writing data in parallel from multiple threads, while writing to a single output file
 CROOT::Experimental::Internal::TBulkBranchReadHelper class for reading many branch entries at once to optimize throughput
 CTCanvasImpABC describing GUI independent main window (with menubar, scrollbars and a drawing area)
 CTCanvasInit
 CROOT::Internal::TCDGIILIBase
 CRgl::Mc::TCell< V >
 CTChainIndex::TChainIndexEntryHolds a description of indices of trees in the chain
 CROOT::Internal::TClaObjProxy< T >
 CTClass__GetCallingNewRAII
 CROOT::TClassAlt
 CROOT::Internal::TClassGetClassHelper< T >
 CROOT::TClassRec
 CTClassRefTClassRef is used to implement a permanent reference to a TClass object
 CTClassStreamer
 CTProofPlayer::TCleanup
 CTClingBaseClassInfoEmulation of the CINT BaseClassInfo class
 CTClingCallFuncEmulation of the CINT CallFunc class
 CTClingDeclInfo
 CTClingMemberIterIterate over all DeclT-s (or UsingShadowDecl-s pointing to DeclT-s) of a decl context, skipping those for which DerivedT::ShouldSkip(const Decl*) returns true when invoked with the Decl
 CROOT::Internal::TClonesArrayOwnershipRAII
 CTTree::TClusterIteratorHelper class to iterate over cluster of baskets
 CTCollectionProxyFactoryTCollectionProxyFactory Interface to collection proxy and streamer generator
 CROOT::Detail::TCollectionProxyInfo
 CTCollectionStreamerClass streamer object to implement TClassStreamer functionality for I/O emulation
 CTGLUtil::TColorLocker
 CTColorNumber
 CTStreamerInfo::TCompInfo
 CTComplex
 CTStreamerInfoActions::TConfigurationBase class of the Configurations
 CTDirectory::TContextTDirectory::TContext keeps track and restore the current directory
 CTVirtualPad::TContextSmall helper class to store/restore gPad context in TPad methods
 CTContextMenuImpThis class provides an interface to GUI independent context sensitive popup menus
 CTControlBarImpABC describing GUI independent control bar
 CTMVA::DNN::CNN::TConvParams
 CTMVA::DNN::TCpu< AReal >The TCpu architecture class
 CTMVA::DNN::TCpuBuffer< AFloat >TCpuBuffer
 CTMVA::DNN::TCpuMatrix< AFloat >The TCpuMatrix class
 CTCreatePrimitivesCreates new primitives
 CTMVA::DNN::TCuda< AReal >The TCuda architecture class
 CTMVA::DNN::TCudaDeviceBuffer< AFloat >TCudaDeviceBuffer
 CTMVA::DNN::TCudaDeviceReference< AFloat >TCudaDeviceReference
 CTMVA::DNN::TCudaHostBuffer< AFloat >TCudaHostBuffer
 CTMVA::DNN::TCudaMatrix< AFloat >TCudaMatrix Class
 CTMVA::DNN::TCudaTensor< AFloat >TCudaTensor Class
 CTCursorSwitcherHelper class used to change the cursor in a method and restore the original one when going out of the method scope
 CROOT::RDF::TCutInfo
 CTMVA::DNN::TDataLoader< Data_t, AArchitecture >TDataLoader
 CTMVA::DNN::TDataLoader< AData, TReference< AReal > >
 CROOT::Math::TDataPoint< K, _val_type >
 CROOT::Math::TDataPointN< _val_type >
 CTDatimeThis class stores the date and time with a precision of one second in an unsigned 32 bit word (950130 124559)
 CTDavixFileInternal
 CTClass::TDeclNameRegistry
 CTMVA::DNN::TDeepNet< Architecture_t, Layer_t >Generic Deep Neural Network class
 CTMVA::DNN::TDeepNet< Architecture_t, VGeneralLayer< Architecture_t > >
 CTMVA::DNN::TDescriptors
 CTMVA::DNN::TCpuBuffer< AFloat >::TDestructor
 CTMVA::DNN::TCudaDeviceBuffer< AFloat >::TDestructor
 CTMVA::DNN::TCudaHostBuffer< AFloat >::TDestructor
 CTMVA::DNN::TDeviceTDevice
 CROOT::Internal::TDirectoryAtomicAdapterInternal class used in the implementation of gDirectory The objects of type TDirectoryAtomicAdapter should only be used inside the thread that created them
 CTMVA::DNN::TDLGradientDescent< Architecture_t >
 CTDomParserDOM stands for the Document Object Model; this is an API for accessing XML or HTML structured documents
 CTGLUtil::TDrawQualityModifier
 CTGLUtil::TDrawQualityScaler
 CTElementActionT< Element >
 CTElementPosActionT< Element >
 CtempFileNamesCatalogLittle helper class to bookkeep the files names which we want to make temporary
 COuter::Template< T, U >
 COuter::Template< Inner, 1 >Simple specialisation
 COuter::Template< Template< Inner, 2 >, 1 >Complex specialisation
 CCPyCppyy::TemplateInfo
 CROOT::Internal::DictSelectionReader::TemplateInfo
 CCPyCppyy::TemplateProxy
 CCPyCppyy::CallContext::Temporary
 CTEngineHolder
 CTMVA::DNN::TCudaTensor< AFloat >::TensorDescriptor
 CTMVA::Experimental::SOFIE::TensorInfo
 CROOT::Math::TensorMulOp< Vector1, Vector2 >Class for Tensor Multiplication (outer product) of two vectors giving a matrix
 CTMVA::Experimental::SOFIE::TensorType< T >
 CTMVA::Experimental::SOFIE::TensorType< double >
 CTMVA::Experimental::SOFIE::TensorType< float >
 CTMVA::Experimental::SOFIE::TensorType< int32_t >
 CTMVA::Experimental::SOFIE::TensorType< int64_t >
 CTMVA::Experimental::SOFIE::TensorType< uint32_t >
 CTMVA::Experimental::SOFIE::TensorType< uint64_t >
 CTEnvParserTEnv Parser
 CRgl::Pad::Tesselator
 CRooStats::TestStatisticTestStatistic is an interface class to provide a facility for construction test statistics distributions to the NeymanConstruction class
 CROOT::Experimental::XRooFit::xRooFit::TestStatistic
 CRooStats::TestStatSamplerTestStatSampler is an interface class for a tools which produce RooStats SamplingDistributions
 CROOT::Experimental::EveGlu::TestTriangleHandlerTestTriangleHandler is just helper class to get access to protected members of TriangleCollector Hide static declarations, let use "native" GL types
 CTEveChunkManagerVector-like container with chunked memory allocation
 CTEveElementBase class for TEveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management
 CTEveFrameBoxGLA class encapsulating GL rendering of TEveFrameBox via a static member function
 CTEveGeoManagerHolderException safe wrapper for setting gGeoManager
 CTEveElement::TEveListTreeInfoStructure holding information about TGListTree and TGListTreeItem that represents given TEveElement
 CTEveMagFieldAbstract base-class for interfacing to magnetic field needed by the TEveTrackPropagator
 CTEveManagerCentral application manager for Eve
 CTEvePadHolderException safe wrapper for setting gPad
 CTEvePathMarkT< TT >Special-point on track:
 CTEvePointSelectorConsumerTEvePointSelectorConsumer is a virtual base for classes that can be filled from TTree data via the TEvePointSelector class
 CTEveProjectableAbstract base-class for non-linear projectable objects
 CTEveProjectedAbstract base class for classes that hold results of a non-linear projection transformation
 CTEveProjectionBase-class for non-linear projections
 CTEveRefCntBase-class for reference-counted objects
 CTEveSecondarySelectableSemi-abstract interface for classes supporting secondary-selection
 CTEveUtilStandard utility functions for Eve
 CTEveVector2T< TT >Minimal, templated two-vector
 CTEveVectorT< TT >Minimal, templated three-vector
 CTEveVectorT< Double_t >
 CTEveVectorT< Float_t >
 CTExceptionHandler
 CROOT::TExecutorCRTP< SubC >This class defines an interface to execute the same task multiple times, possibly in parallel and with different arguments every time
 CROOT::TExecutorCRTP< TExecutor >
 CROOT::TExecutorCRTP< TProcessExecutor >
 CROOT::TExecutorCRTP< TSequentialExecutor >
 CROOT::TExecutorCRTP< TThreadExecutor >
 CTExMapIter
 Cclang::TextDiagnosticPrinter
 CROOT::Quartz::TextLine
 CTLatex::TextSpec_tTLatex helper struct holding the attributes of a piece of text
 CROOT::Internal::TF1Builder< Func >Internal class used by TF1 for defining template specialization for different TF1 constructors
 CROOT::Internal::TF1Builder< const char * >TF1 building from a string used to build a TFormula based on a lambda function
 CROOT::Internal::TF1Builder< Func * >
 CTF1Convolution_EvalWrapper
 CTF1::TF1FunctorPointer
 CTF1ParametersTF1 Parameters class
 CTFdSet
 CTFileMergeInfo
 CTFitResultPtrProvides an indirection to the TFitResult class and with a semantics identical to a TFitResult pointer, i.e
 CTFormulaFunctionHelper class for TFormula
 CTFormulaParamOrderFunctor defining the parameter order
 CTFormulaVariableAnother helper class for TFormula
 CROOT::TForNamespace
 CTTree::TFriendLockHelper class to prevent infinite recursion in the usage of TTree Friends
 CROOT::Internal::TFriendProxy
 CTFriendProxyConcrete implementation of the proxy around a Friend Tree
 CTFriendProxyDescriptorHold the processed information about a Friend TTree while TTreeProxyGenerator is parsing the TTree information
 CTGClientInit
 CTGDimension
 CTGDMAssignmentHelper< T >
 CTGenCollectionProxy__SlowIterator
 CTGenericCollectionIterator
 CTGeoAttVisualization and tracking attributes for volumes and nodes
 CTGeoElemIterIterator for decay branches
 CTGeoFacet
 CTGeoIteratorA geometry iterator
 CTGeoRCPtr< T >A reference counting-managed pointer for classes derived from TGeoExtension which can be used as C pointer
 CTGeoStateInfoStatefull info for the current geometry level
 CTGeoVector3Simple 3-vector representation
 CTGeoVoxelGrid< T, S >A finite 3D grid structure, mapping/binning arbitrary 3D cartesian points onto discrete "voxels"
 CTGeoVoxelGrid< TGeoParallelWorld::SafetyVoxelInfo >
 CTGeoVoxelGridIndex
 CTGFileEntryUtility class used by the file selection dialog (TGFSDialog)
 CTGFileInfo
 CTGFSContainerUtility class used by the file selection dialog (TGFSDialog)
 CROOT::Internal::TGILRAIIClass to acquire and release the Python GIL where it applies, i.e
 CTGInsets
 CTGL5DDataSetEditor::TGL5DEditorPrivate
 CTGLAxisPainterUtility class to paint axis in GL
 CTGLBoundingBoxConcrete class describing an orientated (free) or axis aligned box of 8 vertices
 CTGLBoxCutUsed by plot-painters to determine the area of the plot that is cut away
 CTGLCapabilityEnabler
 CTGLCapabilitySwitch
 CTGLColorClass encapsulating color information in preferred GL format - an array of four unsigned bytes
 CTGLColorSetClass encapsulating a set of colors used throughout standard rendering
 CTGLContextThis class encapsulates window-system specific information about a GL-context and alows their proper management in ROOT
 CTGWin32GLManager::TGLContext
 CTX11GLManager::TGLContext_t
 CTGLContextIdentityIdentifier of a shared GL-context
 CTGLContextPrivate
 CTGLDisableGuard
 CTGLEnableGuard
 CTGLFaderHelper
 CTGLFBOFrame-buffer object
 CTGLFloatHolder
 CTGLFontA wrapper class for FTFont
 CTGLFontManagerA FreeType GL font manager
 CTGLFormatEncapsulation of format / contents of an OpenGL buffer
 CTGListTreeItem
 CTGLLevelPalette
 CTGLLine33D space, fixed length, line class, with direction / length 'vector', passing through point 'vertex'
 CTGLLockableSimple locking interface used by viewer and scene
 CTGLLogicalShapeAbstract logical shape - a GL 'drawable' - base for all shapes - faceset sphere etc
 CTGLMatrix16 component (4x4) transform matrix - column MAJOR as per GL
 CTGLMesh
 CTGLongPosition
 CTGLOutputWrapper class for GL capture & output routines
 CTGLOverlayElementAn overlay element
 CTGLOverlayListManage a collection of overlay elements
 CTGLPaintDevice
 CTGLPhysicalShapeConcrete physical shape - a GL drawable
 CTGLPlane3D plane class - of format Ax + By + Cz + D = 0
 CTGLPlotBoxImplementation of a box around a histogram/function for plot-painters
 CTGLPlotCameraCamera for TGLPlotPainter and sub-classes
 CTGLPlotCoordinatesHelper class for plot-painters holding information about axis ranges, numbers of bins and flags if certain axis is logarithmic
 CTGLPShapeRefBase class for references to TGLPysicalShape that need to be notified when the shape is destroyed
 CTGLQuadricWrapper class for GLU quadric shape drawing object
 CTGLRectViewport (pixel base) 2D rectangle class
 CTGLRnrCtxAggregates data for a given redering context as needed by various parts of the ROOT's OpenGL infrastructure
 CTGLSceneInfoBase class for extended scene context
 CTGLSdfFontMakerHelper class for generation of Signed Distance Field (SDF) fonts for REve
 CTGLSelectBufferEncapsulates OpenGL select buffer
 CTGLSelectionBuffer
 CTGLSelectRecordBaseBase class for select records
 CTGLStopwatchStopwatch object for timing GL work
 CTGLUtilWrapper class for various misc static functions - error checking, draw helpers etc
 CTGLVertex33 component (x/y/z) vertex class
 CTGMdiFrameList
 CTGMdiGeometry
 CTGMdiMenuThis file contains the TGMdiMenuBar class
 CTGNumberFormat
 CTGPasswdDialogGraphic dialog to enter passwords
 CTGPosition
 CTMVA::DNN::TGradientDescent< Architecture_t >
 CROOT::TF1Helper::TGradientParFunctionFunction class representing the derivative with respect a parameter of a given TF1
 CTGRectangle
 CTGRedirectOutputGuardThis class provides output redirection to a TGTextView in guaranteed exception safe way
 CRgl::Mc::TGridGeometry< V >
 CRgl::Mc::TGridGeometry< Double_t >
 CRgl::Mc::TGridGeometry< Float_t >
 CTGScrollBarElementsThe "head", "tail" and "slider"
 CTGSearchType
 CTGTextA TGText is a multi line text buffer
 CTGTextBufferA text buffer is used in several widgets, like TGTextEntry, TGFileDialog, etc
 CTGTextEditDialogsThis file defines several dialogs that are used by the TGTextEdit widget via its associated context popup menu
 CTGTextLine
 CTGTextViewStreamA TGTextViewStream is a text viewer widget
 CRgl::TGuardBase
 CTGuiBldDragManagerGrid
 CTGuiBldDragManagerPimpl
 CTGuiBuilder
 CTGuiNameFrame
 CTGWidgetThe widget base class
 CTGWin32GLThe TGWin32GL is win32gdk implementation of TVirtualGLImp class
 CTGWin32GLManager::TGWin32GLImpl
 CTGWin32ProxyBaseProxy classes provide thread-safe interface to global objects
 CTGWin32ProxyBasePrivate
 CROOT::RDF::TH1DModelA struct which stores the parameters of a TH1D
 CTH1Merger
 CROOT::RDF::TH2DModelA struct which stores the parameters of a TH2D
 CRgl::Mc::TH3Adapter< H, E >
 CROOT::RDF::TH3DModelA struct which stores the parameters of a TH3D
 CROOT::Internal::THashConsistencyHolder< T >
 CTHistRange
 CTHistRenderingRegion
 CROOT::Internal::THnBaseBinIterIterator over THnBase bins (internal implementation)
 CROOT::RDF::THnDModelA struct which stores the parameters of a THnD
 CTHnSparseCoordCompressionTHnSparseCoordCompression is a class used by THnSparse internally
 CTGeoBoolNode::ThreadData_t
 CTGeoPatternFinder::ThreadData_t
 CTGeoPgon::ThreadData_t
 CTGeoVolumeAssembly::ThreadData_t
 CTGeoXtru::ThreadData_t
 Cbvh::v2::ThreadPool
 CTHttpWSEngineInternal instance used to exchange WS functionality between THttpServer and THttpWSHandler
 CTIdleTOTimerGuard
 CTStreamerInfoActions::TIDNode
 CTimer
 CTIndArray
 CROOT::Internal::TInitBehavior
 CTInspectorImpABC describing GUI independent object inspector (abstraction mainly needed for Win32
 CTVirtualCollectionPtrIterators::TInternalIterator
 CTClassEdit::TInterpreterLookupHelper
 CTInterpreterValue
 CROOT::TIOFeaturesTIOFeatures provides the end-user with the ability to change the IO behavior of data written via a TTree
 CRgl::Mc::TIsoMesh< V >
 CRgl::Mc::TIsoMesh< double >
 CRgl::Mc::TIsoMesh< Float_t >
 CTIter
 CROOT::Detail::TKeyMapIterable::TIterator
 CTIteratorIterator abstract base class
 CTJoinHelper
 CTKDEFGT
 CTKDE::TKernel
 CROOT::Detail::TKeyMapIterable
 CROOT::Detail::TKeyMapNode
 CTLatex::TLatexFormSizeTLatex helper class used to compute the size of a portion of a formula
 CTMVA::DNN::TLayer< Architecture_t >Generic layer class
 CTLimit

Legacy Code

TLimit is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TLimit might still be a valid solution. Consider switching to RooStats.
Algorithm to compute 95% CL limits using the Likelihood ratio semi-bayesian method
 CTLockGuard
 CTLockPathGuard
 CTStreamerInfoActions::TLoopConfigurationBase class of the Configurations for the member wise looping routines
 CTLorentzRotation::TLorentzRotationRow
 CTMakeProject
 CROOT::TMapDeclIdToTClass
 CTMapRecKeep track of an object in the mapped file
 CROOT::TMapTypeToClassRec
 CROOT::TMapTypeToTClass
 CTMatrixDEigenTMatrixDEigen
 CTMatrixDSymEigenTMatrixDSymEigen
 CTMatrixTColumn_const< Element >
 CTMatrixTCramerInvTMatrixTCramerInv
 CTMatrixTDiag_const< Element >
 CTMatrixTFlat_const< Element >
 CTMatrixTRow_const< Element >
 CTMatrixTSparseDiag_const< Element >
 CTMatrixTSparseRow_const< Element >
 CTMatrixTSub_const< Element >
 CTMatrixTSymCramerInvTMatrixTSymCramerInv
 CTMatrixTUtilsMatrix utility classes
 CTMD5This code implements the MD5 message-digest algorithm
 CTMemberInspectorAbstract base class for accessing the data-members of a class
 CTMemberStreamer
 CTMemFile::TMemBlock
 CROOT::TModuleGenerator
 CTMPClientBase class for multiprocess applications' clients
 CTMPWorkerThis class works in conjuction with TMPClient, reacting to messages received from it as specified by the Notify and HandleInput methods
 CTMsgBoxA message dialog box
 CROOT::Internal::TMultiArrayType< T, d >Helper class for proxy around multi dimension array
 CTMVABase Class for all classes that need option parsing
 CTMVA::TMVAGaussPair
 CTMVA::TMVAGUI
 CROOT::Internal::TNamedBranchProxy
 CTNDArrayRef< T >Gives access to a sub-dimension, e.g
 CTStreamerInfoActions::TNestedIDs
 CTMVA::DNN::TNet< Architecture_t, Layer_t >Generic neural network class
 CTMVA::TNeuronInputInterface for TNeuron input calculation classes
 CTMVA::TNeuronInputChooserClass for easily choosing neuron input functions
 CTNewCanvasPainterReg
 CTNonCopyable
 CROOT::TMetaUtils::TNormalizedCtxt
 CROOT::TMetaUtils::TNormalizedCtxtImpl
 CROOT::TNumSlotsDefines the number of threads in some of ROOT's interfaces
 CTObjectMother of all ROOT objects
 CROOT::Internal::TObjProxy< T >
 CROOT::Experimental::RDirectory::ToContentType< T >
 CToolBarData_t
 CTMVA::ToolsGlobal auxiliary applications and data treatment routines
 Cbvh::v2::TopDownSahBuilder< Node >Base class for all SAH-based, top-down builders
 CROOT::Internal::TOperatorNewHelper
 CROOT::v5::TOperOffset
 CTPaletteEditorEdit the palette via a GUI
 CTMySQLStatement::TParamData
 CROOT::Internal::TParBranchProcessingRAII
 CTMemberInspector::TParentBuf
 CTPickerStackGuard
 CTPoint
 CTStreamerInfo::TPointerCollectionAdapter
 CROOT::Internal::TDS::TPointerHolderMother class of TTypedPointerHolder
 CTPoints2-D graphics point (world coordinates)
 CTPosixThreadCleanUp
 CTPRegexp
 CROOT::RDF::TProfile1DModelA struct which stores the parameters of a TProfile
 CROOT::RDF::TProfile2DModelA struct which stores the parameters of a TProfile2D
 CTProfileHelper
 CTProofDebug
 CTProofLockPathGuard
 CTProofMergePrg
 CTProofProgressDialogThis class provides a query progress bar
 CTProofServLogHandlerGuard
 CTProtoClass::TProtoRealData
 CTVirtualCollectionProxy::TPushPopRAII helper class that ensures that PushProxy() / PopProxy() are called when entering / leaving a C++ context
 CTPwdCtx
 CTPyArg
 CTPyReturn
 CTPythonAccessing the Python interpreter from C++
 CTQObjectThis is the ROOT implementation of the Qt object communication mechanism (see also http://www.troll.no/qt/metaobjects.html)
 CTQSlotPool
 CTMVA::TrainingHistoryTracking data from training
 CTrainNodeInfo
 CROOT::Math::TRandomEngine
 CTRandomEngine
 CROOT::Math::Impl::Transform3D< T >Basic 3D Transformation class describing a rotation and then a translation The internal data are a 3D rotation data (represented as a 3x3 matrix) and a 3D vector data
 CTMVA::TransformationHandlerClass that contains all the data information
 CROOT::Math::Impl::Translation3D< T >Class describing a 3 dimensional translation
 CROOT::Math::TransposeOp< Matrix, T, D1, D2 >Class for Transpose Operations
 CROOT::Math::TranspPolicy< T, D1, D2, R >Matrix transpose policy
 CROOT::Math::TranspPolicy< T, D1, D2, MatRepSym< T, D1 > >
 CROOT::TReadLockGuard
 CTRecorderStateAbstract class that defines interface for a state of recorder
 CTRedirectOutputGuard
 CTEveManager::TRedrawDisabler
 CROOT::TReentrantRWLock< MutexT, RecurseCountsT >
 CTReentrantRWLockAn implementation of a reentrant read-write lock with a configurable internal mutex/lock (default Spin Lock)
 CROOT::TReentrantRWLock< MutexT, ROOT::Internal::RecurseCounts >
 CTreeReadBuffer
 CTreeUtilsDifferent standalone functions to work with trees and tuples, not reqiuired to be a member of any class
 CTRefCntDefinitions for TRefCnt, base class for reference counted objects
 CTBits::TReference
 CTMVA::DNN::TReference< AReal >The reference architecture class
 CTRegexpRegular expression class
 CTRF1
 CROOT::Math::Delaunay2D::Triangle
 CROOT::Experimental::EveGlu::TriangleCollector
 CROOT::Internal::TROOTAllocator
 CTRootBrowserCursorSwitcher
 CTRootIOCtor
 CTRootSnifferScanRecStructure used to scan hierarchies of ROOT objects
 CROOT::Internal::RootCling::TROOTSYSSetter
 CTRotation::TRotationRow
 CTRSA_fun
 Cstd::true_type
 CROOT::TRWSpinLock
 CTRWSpinLockAn implementation of a read-write lock with an internal spin lock
 CROOT::TRWSpinLockReadGuard
 CROOT::TRWSpinLockWriteGuard
 CTSAXParserCallback
 CROOT::Internal::TSchemaHelper
 CROOT::Internal::TSchemaRuleProcessor
 CROOT::Internal::TSchemaType
 CROOT::TSeq< T >A pseudo container class which is a generator of indices
 CTSessionDialogsThis file defines several dialogs that are used by TSessionViewer
 CTMVA::DNN::TSharedLayer< Architecture_t >Layer class width shared weight and bias layers
 CTSimpleAnalysisA TSimpleAnalysis object creates histograms from a TChain
 CRgl::Mc::TSlice< V >
 CRgl::Mc::TSlice< ElementType_t >
 CRgl::Mc::TSourceAdapterSelector< class >
 CRgl::Mc::TSourceAdapterSelector< TF3 >
 CRgl::Mc::TSourceAdapterSelector< TH3C >
 CRgl::Mc::TSourceAdapterSelector< TH3D >
 CRgl::Mc::TSourceAdapterSelector< TH3F >
 CRgl::Mc::TSourceAdapterSelector< TH3I >
 CRgl::Mc::TSourceAdapterSelector< TH3S >
 CRgl::Mc::TSourceAdapterSelector< TKDEFGT >
 CROOT::Internal::TSpinLockGuardA spin mutex-as-code-guard class
 CROOT::TSpinMutexA spin mutex class which respects the STL interface for mutexes
 CRgl::Mc::TSplitterSelector< class, class >
 CRgl::Mc::TSplitterSelector< TF3, V >
 CRgl::Mc::TSplitterSelector< TH3C, V >
 CRgl::Mc::TSplitterSelector< TH3D, V >
 CRgl::Mc::TSplitterSelector< TH3F, V >
 CRgl::Mc::TSplitterSelector< TH3I, V >
 CRgl::Mc::TSplitterSelector< TH3S, V >
 CRgl::Mc::TSplitterSelector< TKDEFGT, V >
 CTClassEdit::TSplitType
 CTGenCollectionProxy::TStagingSmall helper to stage the content of an associative container when reading and before inserting it in the actual collection
 CROOT::Detail::TStatusBitsChecker
 CTStatusBitsCheckerTStatusBitsChecker::Check and TStatusBitsChecker::CheckAllClasses will determine if the set of "status bit" declared in the class and its base classes presents any overlap
 CROOT::Internal::TStdBitsetHelper< T >
 CROOT::Internal::TStlObjProxy< T >
 CTStorageStorage manager
 CTStringBasic string class
 CTSubStringA zero length substring is legal
 CTTabCom
 CTTableRange
 CROOT::Experimental::TTaskGroupA class to manage the asynchronous execution of work items
 CTMVA::DNN::TTensorBatch< Architecture_t >TTensorBatch
 CTMVA::DNN::TTensorBatchIterator< Data_t, Architecture_t >TTensorBatchIterator
 CTMVA::DNN::TTensorDataLoader< Data_t, Architecture_t >TTensorDataLoader
 CTMVA::DNN::TTensorDataLoader< AData, TReference< AReal > >
 CTTFInterface to the freetype 2 library
 CTTFX11InitSmall utility class that takes care of switching the current gVirtualX to the new TGX11TTF class as soon as the shared library containing this class is loaded
 CTTF::TTGlyphTTF helper class containing glyphs description
 CTThreadCleaner
 CROOT::TThreadedObject< T >A wrapper to make object instances thread private, lazily
 CROOT::TThreadedObject< ROOT::Internal::TTreeView >
 CTThreadPoolTask< aTask, aParam >
 CTThreadPoolTaskImp< aTask, aParam >
 CTThreadTearDownGuard
 CTTimeBasic time type with millisecond precision
 CTTimeStampThe TTimeStamp encapsulates seconds and ns since EPOCH
 CROOT::Experimental::REveDataItemList::TTip
 CTMVA::MethodDNN::TTrainingSettings
 CTMVA::TTrainingSettingsAll of the options that can be specified in the training string
 CTTreeClonerClass implementing or helping the various TTree cloning method
 CROOT::Internal::TTreeGeneratorBaseBase class for code generators like TTreeProxyGenerator and TTreeReaderGenerator
 CROOT::TTreeProcessorMTA class to process the entries of a TTree in parallel
 CROOT::Internal::TTreeReaderValueBaseBase class of TTreeReaderValue
 CTTreeReaderValueFastExtracts data from a TTree
 CROOT::Experimental::Internal::TTreeReaderValueFastBase
 CROOT::Internal::TTreeView
 CTTreeViewA helper class that encapsulates a file and a tree
 CTCling::TUniqueString
 CTGLLockable::TUnlocker
 CTUnuranTUnuran class
 CTUnuranBaseDistTUnuranBaseDist, base class for Unuran distribution classes such as TUnuranContDist (for one-dimension) or TUnuranMultiContDist (multi-dimension)
 CTUtmpContent
 CTUUIDThis class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDentifier)
 CROOT::Internal::RDF::TValueGetterHelper class which keeps track for each slot where to get the entry
 CTVersionCheckUsed to check if the shared library or plugin is compatible with the current version of ROOT
 CTVirtualArrayWrapper around an object and giving indirect access to its content even if the object is not of a class in the Cint/Reflex dictionary
 CTVirtualAuth
 CTVirtualCollectionIteratorsSmall helper class to generically acquire and release iterators
 CTVirtualCollectionProxyDefines a common interface to inspect/change the contents of an object that represents a collection
 CTVirtualCollectionPtrIterators
 CROOT::Internal::TVirtualCollectionReader
 CTVirtualDragManager
 CTVirtualGLAbstract base class defining the OpenGL interface protocol
 CTVirtualGLManip
 CTVirtualGLPainter
 CTVirtualIsAProxy
 CTVirtualMonitoringProvides the interface for externel Monitoring
 CTVirtualMutexThis class implements a mutex interface
 CTVirtualObjectWrapper around an object and giving indirect access to its content even if the object is not of a class in the Cint/Reflex dictionary
 CTVirtualPadEditorAbstract base class used by ROOT graphics editor
 CTVirtualPadPainterTo make it possible to use GL for 2D graphic in a TPad/TCanvas
 CTVirtualPaveStats
 CTVirtualRefProxy
 CTVirtualTableInterface
 CTVirtualVectorIterators
 CTWebMenuArgument
 CTWebMenuItemClass contains info for producing menu item on the JS side
 CTWebMenuItems
 CTWebObjectOptionsClass used to transport drawing options from the client
 CTWebPadClickClass used to transport pad click events
 CTWebPadOptionsClass used to transport ranges from JSROOT canvas
 CTWebSocket
 CTWin32SplashThread
 CTWin32ThreadCleanUp
 CTMVA::DNN::TWorkspace
 CROOT::TWriteLockGuard
 CTX11GLManager::TX11GLImpl
 CTXMLInputStream
 CTXMLOutputStream
 CTXMLSetup
 CTXMLStackObj
 Cstd::conditional::type
 CTSourceAdapterSelector::Type_t
 CTSourceAdapterSelector::Type_t
 CTSplitterSelector::Type_t
 CTSplitterSelector::Type_t
 CCPyCppyy::typedefpointertoclassobject
 CROOT::Internal::TypedIter< T, WrappedIterator_t, isDynamic >
 CROOT::TypeTraits::TypeList< Types >Lightweight storage for a collection of types
 CTMVA::TypesSingleton class for Global types used by TMVA
 CTypeTraits
 Carrow::TypeVisitor
 CROOT::Math::UnaryOp< Operator, RHS, T >UnaryOperation class A class representing unary operators in the parse tree
 CTMVA::Experimental::SOFIE::UnaryOpTraits< T, Op >
 CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kCos >
 CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kExp >
 CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kLog >
 CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kNeg >
 CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kReciprocal >
 CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kSin >
 CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kSqrt >
 CRooRandomizeParamMCSModule::UniParam
 CRooRandomizeParamMCSModule::UniParamSet
 CRooFit::UniqueId< Class >A UniqueId can be added as a class member to enhance any class with a unique identifier for each instantiated object
 CRooFit::UniqueId< RooAbsCollection >
 CRooFit::UniqueId< RooAbsData >
 CRooFit::UniqueId< RooArgSet >
 CROOT::Internal::UniqueLockRecurseCount
 Cbvh::v2::UnsignedInt< Bits >Helper type that gives an unsigned integer type with the given number of bits
 Cbvh::v2::UnsignedInt< 16 >
 Cbvh::v2::UnsignedInt< 32 >
 Cbvh::v2::UnsignedInt< 64 >
 Cbvh::v2::UnsignedInt< 8 >
 CUnuranRng< Random >UnuranRng class for interface ROOT random generators to Unuran
 CTTreeCacheUnzip::UnzipState
 CROOT::Internal::Update
 CRooFit::TestStatistics::LikelihoodJob::update_state_t
 Cusa
 CUserGroup_t
 CClingMemberIterInternal::UsingDeclIter::UsingDeclFrame
 CClingMemberIterInternal::UsingDeclIter
 CTString::UStr_t
 CRooSharedProperties::UUID
 CTUUID::uuid_time_t
 CROOT::Experimental::RAttrBase::Val_t
 CCPyCppyy::Parameter::Value
 CROOT::Internal::TCheckHashRecursiveRemoveConsistency::Value
 CTGenCollectionProxy::ValueSmall helper to describe the Value_type or the key_type of an STL container
 CValue
 CROOT::Experimental::RAttrMap::Value_t
 CROOT::RDF::RSqliteDS::Value_tUsed to hold a single "cell" of the SELECT query's result table. Can be changed to std::variant once available
 CROOT::Experimental::RAttrValue< T >::ValueExtractor< Q, bool >
 CROOT::Experimental::RAttrValue< T >::ValueExtractor< Q, false >
 CROOT::Internal::RDF::ValueType< T, IsDataContainer >
 CROOT::Internal::RDF::ValueType< ROOT::VecOps::RVec< T >, false >
 CROOT::Internal::RDF::ValueType< T, false >
 CRooCmdConfig::Var< T >
 CTMVA::VariableImportanceResult
 CROOT::Minuit2::VariableMetricEDMEstimator
 CTMVA::Config::VariablePlotting
 CTMVA::TransformationHandler::VariableStat
 CRooDataHist::VarInfoStructure to cache information on the histogram variable that is frequently used for histogram weights retrieval
 CTMVA::MethodCFMlpANN_Utils::VARn2
 CTMVA::VarTransformHandler
 CROOT::Math::VavilovBase class describing a Vavilov distribution
 Cbvh::v2::Vec< T, N >
 CROOT::Minuit2::vec
 Cvec
 CROOT::Math::VecExpr< ExprType, T, D >Expression wrapper class for Vector objects
 Cstd::vector< T >STL class
 Cstd::vector< const TSchemaRule * >
 Cstd::vector< std::pair< RooArgSet *, RooArgList * > >
 Cstd::vector< std::shared_ptr< xRooNode > >
 Cstd::vector< std::vector< double > >
 Cstd::vector< TVectorD >
 Cstd::vector< xRooHypoPoint >
 CROOT::Math::VectorMatrixColOp< Vector, Matrix, D1 >Class for Vector-Matrix multiplication
 CROOT::Math::VectorMatrixRowOp< Matrix, Vector, D2 >
 CROOT::Minuit2::VectorOuterProduct< M, T >
 CROOT::Math::VegasParametersStructures collecting parameters for VEGAS multidimensional integration For implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h
 CROOT::Geom::Vertex_t
 CTGLParametricPlot::Vertex_t
 CTMVA::DNN::VGeneralLayer< Architecture_t >Generic General Layer class
 CROOT::Math::VirtualIntegratorAbstract class for all numerical integration methods (1D and multi-dim) Interface defining the common methods for the numerical integrator classes of one and multi dimensions The derived class VirtualIntegratorOneDim defines the methods for one-dimensional integration
 CVisual
 CTMVA::VolumeVolume for BinarySearchTree
 CTMVA::DNN::VOptimizer< Architecture_t, Layer_t, DeepNet_t >Generic Optimizer class
 CTMVA::DNN::VOptimizer< Architecture_t, VGeneralLayer< Architecture_t >, TDeepNet< Architecture_t, VGeneralLayer< Architecture_t > > >
 CROOT::Experimental::RCanvasPainter::WebCommand
 CROOT::Experimental::RCanvasPainter::WebConn
 CROOT::RWebWindow::WebConn
 CTWebCanvas::WebConn
 CWebFont_t
 Cwebsocket_client_thread_data
 CROOT::Experimental::RCanvasPainter::WebUpdate
 CROOT::MacOSX::X11::CommandBuffer::WidgetRect
 CWindowAttributes_tWindow attributes that can be inquired
 CTStreamerInfoActions::WithFactorMarker< From >
 Cbvh::v2::TopDownSahBuilder< Node >::WorkItem
 CRooFit::TestStatistics::WrapperCalculationCleanFlagsFor communication with wrappers, an instance of this struct must be shared between them and MinuitFcnGrad
 CTStreamerInfoActions::GenericLooper::Write_WithoutFastArray_ConvertBasicType< To, From >
 CTStreamerInfoActions::GenericLooper::WriteConvertBasicType< Onfile, Memory, Converter >
 CTStreamerInfoActions::VectorLooper::WriteConvertBasicType< Onfile, Memory >
 CTStreamerInfoActions::VectorPtrLooper::WriteConvertBasicType< To, From >
 CTStreamerInfoActions::WriteConvertBasicType< Onfile, Memory >
 CTStreamerInfoActions::VectorLooper::WriteConvertBasicType< NoFactorMarker< Onfile >, Memory >
 CTStreamerInfoActions::GenericLooper::WriteConvertBasicType< NoFactorMarker< Onfile >, Memory, Converter >
 CTStreamerInfoActions::VectorPtrLooper::WriteConvertBasicType< NoFactorMarker< To >, From >
 CTStreamerInfoActions::VectorLooper::WriteConvertBasicType< WithFactorMarker< Onfile >, Memory >
 CTStreamerInfoActions::GenericLooper::WriteConvertBasicType< WithFactorMarker< Onfile >, Memory, Converter >
 CTStreamerInfoActions::VectorPtrLooper::WriteConvertBasicType< WithFactorMarker< To >, From >
 CTStreamerInfoActions::AssociativeLooper::WriteConvertCollectionBasicType< Memory, Onfile >
 CTStreamerInfoActions::GenericLooper::WriteConvertCollectionBasicType< Memory, Onfile >
 CTStreamerInfoActions::VectorLooper::WriteConvertCollectionBasicType< Memory, Onfile >
 CTStreamerInfoActions::AssociativeLooper::WriteConvertCollectionBasicType< Memory, NoFactorMarker< Onfile > >
 CTStreamerInfoActions::AssociativeLooper::WriteConvertCollectionBasicType< Memory, WithFactorMarker< Onfile > >
 CTStreamerInfoActions::CollectionLooper< Looper >::WriteStreamerLoop< kIsTextT, Ts >
 C<X11Drawable>
 CXColor
 CXColor_tDescription of a X11 color
 CXGCValues
 CXImage
 CXLFDAttributes_t
 CROOT::MacOSX::X11::XLFDName
 CTMVA::Experimental::Internal::XMLConfigContainer for information extracted from TMVA XML config
 CXMLReader
 CXpmAttributes
 CROOT::Experimental::XRooFit::xRooFit
 CXSetWindowAttributes
 CXShapeEvent
 CXVisualInfo
 CXWindow_tDescription of a X11 window
 CTGDMLWrite::Xyz
 CTMemFile::ZeroCopyView_tA read-only memory range which we do not control
 CZeroMQPollerWrapper class for polling ZeroMQ sockets
 CZeroMQSvcWrapper class for basic ZeroMQ context and socket management
 CZmqLingeringSocketPtrDeleter< PERIOD >
 CAReal
 CROOT::Experimental::Detail::BASES
 Cbool
 CCGContextRef
 CCGImageRef
 Cdouble
 CEAlign
 CECorner
 CEngineType *
 CEStyle
 CFloat_t
 CFunctionType
 Cint
 CLong64_t
 CMutexT
 CR
 CULong64_t
 Cunsigned int
 CXPoint